merge dev to main (v3.0.0-beta.23)

package.json

@@ -1,6 +1,6 @@
 {
     "name": "zenstack-v3",
-    "version": "3.0.0-beta.22",
+    "version": "3.0.0-beta.23",
     "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-beta.22",
+    "version": "3.0.0-beta.23",
     "type": "module",
     "author": {
         "name": "ZenStack Team"

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

@@ -19,7 +19,15 @@ export function getSchemaFile(file?: string) {
         if (!fs.existsSync(pkgJsonConfig.schema)) {
             throw new CliError(`Schema file not found: ${pkgJsonConfig.schema}`);
         }
-        return pkgJsonConfig.schema;
+        if (fs.statSync(pkgJsonConfig.schema).isDirectory()) {
+            const schemaPath = path.join(pkgJsonConfig.schema, 'schema.zmodel');
+            if (!fs.existsSync(schemaPath)) {
+                throw new CliError(`Schema file not found: ${schemaPath}`);
+            }
+            return schemaPath;
+        } else {
+            return pkgJsonConfig.schema;
+        }
     }
 
     if (fs.existsSync('./zenstack/schema.zmodel')) {

packages/cli/src/actions/db.ts

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { execPackage } from '../utils/exec-utils';
+import { execPrisma } from '../utils/exec-utils';
 import { generateTempPrismaSchema, getSchemaFile, handleSubProcessError } from './action-utils';
 
 type Options = {
@@ -27,15 +27,15 @@ async function runPush(options: Options) {
     try {
         // run prisma db push
         const cmd = [
-            'prisma db push',
+            'db push',
             ` --schema "${prismaSchemaFile}"`,
             options.acceptDataLoss ? ' --accept-data-loss' : '',
             options.forceReset ? ' --force-reset' : '',
             ' --skip-generate',
         ].join('');
 
         try {
-            await execPackage(cmd);
+            execPrisma(cmd);
         } catch (err) {
             handleSubProcessError(err);
         }

packages/cli/src/actions/migrate.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { CliError } from '../cli-error';
-import { execPackage } from '../utils/exec-utils';
+import { execPrisma } from '../utils/exec-utils';
 import { generateTempPrismaSchema, getSchemaFile } from './action-utils';
 
 type CommonOptions = {
@@ -64,69 +64,65 @@ export async function run(command: string, options: CommonOptions) {
     }
 }
 
-async function runDev(prismaSchemaFile: string, options: DevOptions) {
+function runDev(prismaSchemaFile: string, options: DevOptions) {
     try {
         const cmd = [
-            'prisma migrate dev',
+            'migrate dev',
             ` --schema "${prismaSchemaFile}"`,
             ' --skip-generate',
-            options.name ? ` --name ${options.name}` : '',
+            options.name ? ` --name "${options.name}"` : '',
             options.createOnly ? ' --create-only' : '',
         ].join('');
-
-        await execPackage(cmd);
+        execPrisma(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runReset(prismaSchemaFile: string, options: ResetOptions) {
+function runReset(prismaSchemaFile: string, options: ResetOptions) {
     try {
         const cmd = [
-            'prisma migrate reset',
+            'migrate reset',
             ` --schema "${prismaSchemaFile}"`,
             ' --skip-generate',
             options.force ? ' --force' : '',
         ].join('');
-
-        await execPackage(cmd);
+        execPrisma(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
+function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
     try {
-        const cmd = ['prisma migrate deploy', ` --schema "${prismaSchemaFile}"`].join('');
-
-        await execPackage(cmd);
+        const cmd = ['migrate deploy', ` --schema "${prismaSchemaFile}"`].join('');
+        execPrisma(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
+function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
     try {
-        await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`);
+        execPrisma(`migrate status --schema "${prismaSchemaFile}"`);
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runResolve(prismaSchemaFile: string, options: ResolveOptions) {
+function runResolve(prismaSchemaFile: string, options: ResolveOptions) {
     if (!options.applied && !options.rolledBack) {
         throw new CliError('Either --applied or --rolled-back option must be provided');
     }
 
     try {
         const cmd = [
-            'prisma migrate resolve',
+            'migrate resolve',
             ` --schema "${prismaSchemaFile}"`,
-            options.applied ? ` --applied ${options.applied}` : '',
-            options.rolledBack ? ` --rolled-back ${options.rolledBack}` : '',
+            options.applied ? ` --applied "${options.applied}"` : '',
+            options.rolledBack ? ` --rolled-back "${options.rolledBack}"` : '',
         ].join('');
-
-        await execPackage(cmd);
+        execPrisma(cmd);
     } catch (err) {
         handleSubProcessError(err);
     }

packages/cli/src/utils/exec-utils.ts

@@ -1,4 +1,5 @@
 import { execSync as _exec, type ExecSyncOptions } from 'child_process';
+import { fileURLToPath } from 'url';
 
 /**
  * Utility for executing command synchronously and prints outputs on current console
@@ -24,3 +25,18 @@ export function execPackage(
     const packageManager = process?.versions?.['bun'] ? 'bunx' : 'npx';
     execSync(`${packageManager} ${cmd}`, options);
 }
+
+/**
+ * Utility for running prisma commands
+ */
+export function execPrisma(args: string, options?: Omit<ExecSyncOptions, 'env'> & { env?: Record<string, string> }) {
+    let prismaPath: string;
+    if (typeof import.meta.resolve === 'function') {
+        // esm
+        prismaPath = fileURLToPath(import.meta.resolve('prisma/build/index.js'));
+    } else {
+        // cjs
+        prismaPath = require.resolve('prisma/build/index.js');
+    }
+    execSync(`node ${prismaPath} ${args}`, options);
+}

packages/cli/test/generate.test.ts

@@ -45,6 +45,21 @@ describe('CLI generate command test', () => {
         expect(fs.existsSync(path.join(workDir, 'bar/schema.ts'))).toBe(true);
     });
 
+    it('should respect package.json schema dir 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',
+            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);
+    });
+
     it('should respect lite option', () => {
         const workDir = createProject(model);
         runCli('generate --lite', workDir);

packages/cli/test/migrate.test.ts

@@ -9,8 +9,7 @@ model User {
 }
 `;
 
-// skip due to timeout in CI
-describe.skip('CLI migrate commands test', () => {
+describe('CLI migrate commands test', () => {
     it('should generate a database with migrate dev', () => {
         const workDir = createProject(model);
         runCli('migrate dev --name init', workDir);

packages/clients/tanstack-query/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenstackhq/tanstack-query",
-    "version": "3.0.0-beta.22",
+    "version": "3.0.0-beta.23",
     "description": "TanStack Query Client for consuming ZenStack v3's CRUD service",
     "main": "index.js",
     "type": "module",

packages/clients/tanstack-query/src/react.ts

@@ -145,108 +145,108 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        useFindFirst<T extends FindFirstArgs<Schema, Model>>(
             args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model>>(
             args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
 
-        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelSuspenseInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, true>>(
+        useCreate<T extends CreateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+        useDelete<T extends DeleteArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model, true>>(
+        useCount<T extends CountArgs<Schema, Model>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelQueryResult<CountResult<Schema, Model, T>>;
 
-        useSuspenseCount<T extends CountArgs<Schema, Model, true>>(
+        useSuspenseCount<T extends CountArgs<Schema, Model>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
 
-        useAggregate<T extends AggregateArgs<Schema, Model, true>>(
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useSuspenseAggregate<T extends AggregateArgs<Schema, Model, true>>(
+        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useGroupBy<T extends GroupByArgs<Schema, Model, true>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
 
-        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model, true>>(
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;