Merge pull request #87 from zenstackhq/dev

merge dev to main

Author: ymc9

.prettierignore

@@ -0,0 +1,2 @@
+packages/language/src/generated/**
+**/schema.ts

package.json

@@ -1,6 +1,6 @@
 {
     "name": "zenstack-v3",
-    "version": "3.0.0-alpha.9",
+    "version": "3.0.0-alpha.10",
     "description": "ZenStack",
     "packageManager": "[email protected]",
     "scripts": {

packages/cli/package.json

@@ -3,7 +3,7 @@
     "publisher": "zenstack",
     "displayName": "ZenStack CLI",
     "description": "FullStack database toolkit with built-in access control and automatic API generation.",
-    "version": "3.0.0-alpha.9",
+    "version": "3.0.0-alpha.10",
     "type": "module",
     "author": {
         "name": "ZenStack Team"

packages/cli/src/actions/action-utils.ts

@@ -1,3 +1,4 @@
+import { findUp } from '@zenstackhq/common-helpers';
 import { loadDocument } from '@zenstackhq/language';
 import { PrismaSchemaGenerator } from '@zenstackhq/sdk';
 import colors from 'colors';
@@ -13,6 +14,14 @@ export function getSchemaFile(file?: string) {
         return file;
     }
 
+    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+    if (pkgJsonConfig.schema) {
+        if (!fs.existsSync(pkgJsonConfig.schema)) {
+            throw new CliError(`Schema file not found: ${pkgJsonConfig.schema}`);
+        }
+        return pkgJsonConfig.schema;
+    }
+
     if (fs.existsSync('./zenstack/schema.zmodel')) {
         return './zenstack/schema.zmodel';
     } else if (fs.existsSync('./schema.zmodel')) {
@@ -51,3 +60,26 @@ export async function generateTempPrismaSchema(zmodelPath: string) {
     fs.writeFileSync(prismaSchemaFile, prismaSchema);
     return prismaSchemaFile;
 }
+
+export function getPkgJsonConfig(startPath: string) {
+    const result: { schema: string | undefined; output: string | undefined } = { schema: undefined, output: undefined };
+    const pkgJsonFile = findUp(['package.json'], startPath, false);
+
+    if (!pkgJsonFile) {
+        return result;
+    }
+
+    let pkgJson: any = undefined;
+    try {
+        pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf8'));
+    } catch {
+        return result;
+    }
+
+    if (pkgJson.zenstack && typeof pkgJson.zenstack === 'object') {
+        result.schema = pkgJson.zenstack.schema && path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.schema);
+        result.output = pkgJson.zenstack.output && path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.output);
+    }
+
+    return result;
+}

packages/cli/src/actions/db.ts

@@ -26,13 +26,16 @@ async function runPush(options: Options) {
 
     try {
         // run prisma db push
-        const cmd = `prisma db push --schema "${prismaSchemaFile}"${
-            options.acceptDataLoss ? ' --accept-data-loss' : ''
-        }${options.forceReset ? ' --force-reset' : ''} --skip-generate`;
+        const cmd = [
+            'prisma db push',
+            ` --schema "${prismaSchemaFile}"`,
+            options.acceptDataLoss ? ' --accept-data-loss' : '',
+            options.forceReset ? ' --force-reset' : '',
+            ' --skip-generate',
+        ].join('');
+
         try {
-            await execPackage(cmd, {
-                stdio: 'inherit',
-            });
+            await execPackage(cmd);
         } catch (err) {
             handleSubProcessError(err);
         }

packages/cli/src/actions/generate.ts

@@ -4,7 +4,7 @@ import { PrismaSchemaGenerator, TsSchemaGenerator, type CliGenerator } from '@ze
 import colors from 'colors';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getSchemaFile, loadSchemaDocument } from './action-utils';
+import { getPkgJsonConfig, getSchemaFile, loadSchemaDocument } from './action-utils';
 
 type Options = {
     schema?: string;
@@ -20,7 +20,7 @@ export async function run(options: Options) {
     const schemaFile = getSchemaFile(options.schema);
 
     const model = await loadSchemaDocument(schemaFile);
-    const outputPath = options.output ?? path.dirname(schemaFile);
+    const outputPath = getOutputPath(options, schemaFile);
 
     // generate TS schema
     const tsSchemaFile = path.join(outputPath, 'schema.ts');
@@ -55,6 +55,18 @@ const client = new ZenStackClient(schema, {
     }
 }
 
+function getOutputPath(options: Options, schemaFile: string) {
+    if (options.output) {
+        return options.output;
+    }
+    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+    if (pkgJsonConfig.output) {
+        return pkgJsonConfig.output;
+    } else {
+        return path.dirname(schemaFile);
+    }
+}
+
 async function runPlugins(model: Model, outputPath: string, tsSchemaFile: string) {
     const plugins = model.declarations.filter(isPlugin);
     for (const plugin of plugins) {

packages/cli/src/actions/migrate.ts

@@ -53,42 +53,45 @@ export async function run(command: string, options: CommonOptions) {
 
 async function runDev(prismaSchemaFile: string, options: DevOptions) {
     try {
-        await execPackage(
-            `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate${options.name ? ` --name ${options.name}` : ''}${options.createOnly ? ' --create-only' : ''}`,
-            {
-                stdio: 'inherit',
-            },
-        );
+        const cmd = [
+            'prisma migrate dev',
+            ` --schema "${prismaSchemaFile}"`,
+            ' --skip-generate',
+            options.name ? ` --name ${options.name}` : '',
+            options.createOnly ? ' --create-only' : '',
+        ].join('');
+
+        await execPackage(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
 async function runReset(prismaSchemaFile: string, options: ResetOptions) {
     try {
-        await execPackage(`prisma migrate reset --schema "${prismaSchemaFile}"${options.force ? ' --force' : ''}`, {
-            stdio: 'inherit',
-        });
+        const cmd = ['prisma migrate reset', ` --schema "${prismaSchemaFile}"`, options.force ? ' --force' : ''].join(
+            '',
+        );
+
+        await execPackage(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
 async function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
     try {
-        await execPackage(`prisma migrate deploy --schema "${prismaSchemaFile}"`, {
-            stdio: 'inherit',
-        });
+        const cmd = ['prisma migrate deploy', ` --schema "${prismaSchemaFile}"`].join('');
+
+        await execPackage(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
 async function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
     try {
-        await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`, {
-            stdio: 'inherit',
-        });
+        await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`);
     } catch (err) {
         handleSubProcessError(err);
     }

packages/cli/test/generate.test.ts

@@ -41,4 +41,19 @@ describe('CLI generate command test', () => {
         runCli('generate --save-prisma-schema "../prisma/schema.prisma"', workDir);
         expect(fs.existsSync(path.join(workDir, 'prisma/schema.prisma'))).toBe(true);
     });
+
+    it('should respect package.json config', () => {
+        const workDir = createProject(model);
+        fs.mkdirSync(path.join(workDir, 'foo'));
+        fs.renameSync(path.join(workDir, 'zenstack/schema.zmodel'), path.join(workDir, 'foo/schema.zmodel'));
+        fs.rmdirSync(path.join(workDir, 'zenstack'));
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(workDir, 'package.json'), 'utf8'));
+        pkgJson.zenstack = {
+            schema: './foo/schema.zmodel',
+            output: './bar',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+        runCli('generate', workDir);
+        expect(fs.existsSync(path.join(workDir, 'bar/schema.ts'))).toBe(true);
+    });
 });

packages/common-helpers/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenstackhq/common-helpers",
-    "version": "3.0.0-alpha.9",
+    "version": "3.0.0-alpha.10",
     "description": "ZenStack Common Helpers",
     "type": "module",
     "scripts": {

packages/common-helpers/src/find-up.ts

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * A type named FindUp that takes a type parameter e which extends boolean.
+ */
+export type FindUpResult<Multiple extends boolean> = Multiple extends true ? string[] | undefined : string | undefined;
+
+/**
+ * Find and return file paths by searching parent directories based on the given names list and current working directory (cwd) path.
+ * Optionally return a single path or multiple paths.
+ * If multiple allowed, return all paths found.
+ * If no paths are found, return undefined.
+ *
+ * @param names An array of strings representing names to search for within the directory
+ * @param cwd A string representing the current working directory
+ * @param multiple A boolean flag indicating whether to search for multiple levels. Useful for finding node_modules directories...
+ * @param An array of strings representing the accumulated results used in multiple results
+ * @returns Path(s) to a specific file or folder within the directory or parent directories
+ */
+export function findUp<Multiple extends boolean = false>(
+    names: string[],
+    cwd: string = process.cwd(),
+    multiple: Multiple = false as Multiple,
+    result: string[] = [],
+): FindUpResult<Multiple> {
+    if (!names.some((name) => !!name)) return undefined;
+    const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
+    if (multiple === false && target) return path.join(cwd, target) as FindUpResult<Multiple>;
+    if (target) result.push(path.join(cwd, target));
+    const up = path.resolve(cwd, '..');
+    if (up === cwd) return (multiple && result.length > 0 ? result : undefined) as FindUpResult<Multiple>; // it'll fail anyway
+    return findUp(names, up, multiple, result);
+}