@zenstackhq/cli 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/actions/migrate.ts

@@ -1,57 +1,70 @@
-import path from 'node:path';
+import fs from 'node:fs';
 import { execPackage } from '../utils/exec-utils';
-import { getSchemaFile } from './action-utils';
-import { run as runGenerate } from './generate';
+import { generateTempPrismaSchema, getSchemaFile } from './action-utils';
 
 type CommonOptions = {
     schema?: string;
+};
+
+type DevOptions = CommonOptions & {
     name?: string;
+    createOnly?: boolean;
+};
+
+type ResetOptions = CommonOptions & {
+    force?: boolean;
 };
 
+type DeployOptions = CommonOptions;
+
+type StatusOptions = CommonOptions;
+
 /**
  * CLI action for migration-related commands
  */
 export async function run(command: string, options: CommonOptions) {
     const schemaFile = getSchemaFile(options.schema);
+    const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
 
-    // run generate first
-    await runGenerate({
-        schema: schemaFile,
-        silent: true,
-    });
-
-    const prismaSchemaFile = path.join(path.dirname(schemaFile), 'schema.prisma');
-
-    switch (command) {
-        case 'dev':
-            await runDev(prismaSchemaFile, options);
-            break;
+    try {
+        switch (command) {
+            case 'dev':
+                await runDev(prismaSchemaFile, options as DevOptions);
+                break;
 
-        case 'reset':
-            await runReset(prismaSchemaFile, options as any);
-            break;
+            case 'reset':
+                await runReset(prismaSchemaFile, options as ResetOptions);
+                break;
 
-        case 'deploy':
-            await runDeploy(prismaSchemaFile, options);
-            break;
+            case 'deploy':
+                await runDeploy(prismaSchemaFile, options as DeployOptions);
+                break;
 
-        case 'status':
-            await runStatus(prismaSchemaFile, options);
-            break;
+            case 'status':
+                await runStatus(prismaSchemaFile, options as StatusOptions);
+                break;
+        }
+    } finally {
+        if (fs.existsSync(prismaSchemaFile)) {
+            fs.unlinkSync(prismaSchemaFile);
+        }
     }
 }
 
-async function runDev(prismaSchemaFile: string, _options: unknown) {
+async function runDev(prismaSchemaFile: string, options: DevOptions) {
     try {
-        await execPackage(`prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate`, {
-            stdio: 'inherit',
-        });
+        await execPackage(
+            `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate${options.name ? ` --name ${options.name}` : ''}${options.createOnly ? ' --create-only' : ''}`,
+            {
+                stdio: 'inherit',
+            },
+        );
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runReset(prismaSchemaFile: string, options: { force: boolean }) {
+async function runReset(prismaSchemaFile: string, options: ResetOptions) {
     try {
         await execPackage(`prisma migrate reset --schema "${prismaSchemaFile}"${options.force ? ' --force' : ''}`, {
             stdio: 'inherit',
@@ -61,7 +74,7 @@ async function runReset(prismaSchemaFile: string, options: { force: boolean }) {
     }
 }
 
-async function runDeploy(prismaSchemaFile: string, _options: unknown) {
+async function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
     try {
         await execPackage(`prisma migrate deploy --schema "${prismaSchemaFile}"`, {
             stdio: 'inherit',
@@ -71,7 +84,7 @@ async function runDeploy(prismaSchemaFile: string, _options: unknown) {
     }
 }
 
-async function runStatus(prismaSchemaFile: string, _options: unknown) {
+async function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
     try {
         await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`, {
             stdio: 'inherit',

package/src/index.ts

@@ -49,6 +49,13 @@ export function createProgram() {
         .command('generate')
         .description('Run code generation.')
         .addOption(schemaOption)
+        .addOption(new Option('--silent', 'do not print any output'))
+        .addOption(
+            new Option(
+                '--save-prisma-schema [path]',
+                'save a Prisma schema file, by default into the output directory',
+            ),
+        )
         .addOption(new Option('-o, --output <path>', 'default output directory for core plugins'))
         .action(generateAction);
 

package/test/db.test.ts

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createProject, runCli } from './utils';
+
+const model = `
+model User {
+    id String @id @default(cuid())
+}
+`;
+
+describe('CLI db commands test', () => {
+    it('should generate a database with db push', () => {
+        const workDir = createProject(model);
+        runCli('db push', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+    });
+});

package/test/generate.test.ts

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createProject, runCli } from './utils';
+
+const model = `
+model User {
+    id String @id @default(cuid())
+}
+`;
+
+describe('CLI generate command test', () => {
+    it('should generate a TypeScript schema', () => {
+        const workDir = createProject(model);
+        runCli('generate', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.prisma'))).toBe(false);
+    });
+
+    it('should respect custom output directory', () => {
+        const workDir = createProject(model);
+        runCli('generate --output ./zen', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zen/schema.ts'))).toBe(true);
+    });
+
+    it('should respect custom schema location', () => {
+        const workDir = createProject(model);
+        fs.renameSync(path.join(workDir, 'zenstack/schema.zmodel'), path.join(workDir, 'zenstack/foo.zmodel'));
+        runCli('generate --schema ./zenstack/foo.zmodel', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.ts'))).toBe(true);
+    });
+
+    it('should respect save prisma schema option', () => {
+        const workDir = createProject(model);
+        runCli('generate --save-prisma-schema', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.prisma'))).toBe(true);
+    });
+
+    it('should respect save prisma schema custom path option', () => {
+        const workDir = createProject(model);
+        runCli('generate --save-prisma-schema "../prisma/schema.prisma"', workDir);
+        expect(fs.existsSync(path.join(workDir, 'prisma/schema.prisma'))).toBe(true);
+    });
+});

package/test/init.test.ts

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import tmp from 'tmp';
+import { describe, expect, it } from 'vitest';
+import { runCli } from './utils';
+
+describe('Cli init command tests', () => {
+    it('should create a new project', () => {
+        const { name: workDir } = tmp.dirSync({ unsafeCleanup: true });
+        runCli('init', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.zmodel'))).toBe(true);
+    });
+});

package/test/migrate.test.ts

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createProject, runCli } from './utils';
+
+const model = `
+model User {
+    id String @id @default(cuid())
+}
+`;
+
+describe('CLI migrate commands test', () => {
+    it('should generate a database with migrate dev', () => {
+        const workDir = createProject(model);
+        runCli('migrate dev --name init', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/migrations'))).toBe(true);
+    });
+
+    it('should reset the database with migrate reset', () => {
+        const workDir = createProject(model);
+        runCli('db push', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+        runCli('migrate reset --force', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+    });
+
+    it('should reset the database with migrate deploy', () => {
+        const workDir = createProject(model);
+        runCli('migrate dev --name init', workDir);
+        fs.rmSync(path.join(workDir, 'zenstack/dev.db'));
+        runCli('migrate deploy', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+    });
+
+    it('supports migrate status', () => {
+        const workDir = createProject(model);
+        runCli('migrate dev --name init', workDir);
+        runCli('migrate status', workDir);
+    });
+});

package/test/utils.ts

@@ -0,0 +1,23 @@
+import { createTestProject } from '@zenstackhq/testtools';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ZMODEL_PRELUDE = `datasource db {
+    provider = "sqlite"
+    url = "file:./dev.db"
+}
+`;
+
+export function createProject(zmodel: string, addPrelude = true) {
+    const workDir = createTestProject();
+    fs.mkdirSync(path.join(workDir, 'zenstack'), { recursive: true });
+    const schemaPath = path.join(workDir, 'zenstack/schema.zmodel');
+    fs.writeFileSync(schemaPath, addPrelude ? `${ZMODEL_PRELUDE}\n\n${zmodel}` : zmodel);
+    return workDir;
+}
+
+export function runCli(command: string, cwd: string) {
+    const cli = path.join(__dirname, '../dist/index.js');
+    execSync(`node ${cli} ${command}`, { cwd });
+}