CLI: add "db push" command

Author: ymc9

packages/cli/src/actions/common.ts

@@ -0,0 +1,11 @@
+export function handleSubProcessError(err: unknown) {
+    if (
+        err instanceof Error &&
+        'status' in err &&
+        typeof err.status === 'number'
+    ) {
+        process.exit(err.status);
+    } else {
+        process.exit(1);
+    }
+}

packages/cli/src/actions/db.ts

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { execPackage } from '../utils/exec-utils';
+import { getSchemaFile } from './action-utils';
+import { run as runGenerate } from './generate';
+import { handleSubProcessError } from './common';
+
+type CommonOptions = {
+    schema?: string;
+    name?: string;
+};
+
+/**
+ * CLI action for db related commands
+ */
+export async function run(command: string, options: CommonOptions) {
+    const schemaFile = getSchemaFile(options.schema);
+
+    // run generate first
+    await runGenerate({
+        schema: schemaFile,
+        silent: true,
+    });
+
+    const prismaSchemaFile = path.join(
+        path.dirname(schemaFile),
+        'schema.prisma'
+    );
+
+    switch (command) {
+        case 'push':
+            await runPush(prismaSchemaFile, options);
+            break;
+    }
+}
+
+async function runPush(prismaSchemaFile: string, options: any) {
+    const cmd = `prisma db push --schema "${prismaSchemaFile}"${
+        options.acceptDataLoss ? ' --accept-data-loss' : ''
+    }${options.forceReset ? ' --force-reset' : ''} --skip-generate`;
+    try {
+        await execPackage(cmd, {
+            stdio: 'inherit',
+        });
+    } catch (err) {
+        handleSubProcessError(err);
+    }
+}

packages/cli/src/actions/index.ts

@@ -1,5 +1,6 @@
+import { run as db } from './db';
 import { run as generate } from './generate';
 import { run as info } from './info';
 import { run as migrate } from './migrate';
 
-export { generate, info, migrate };
+export { db, generate, info, migrate };

packages/cli/src/actions/migrate.ts

@@ -9,7 +9,7 @@ type CommonOptions = {
 };
 
 /**
- * CLI action for generating code from schema
+ * CLI action for migration-related commands
  */
 export async function run(command: string, options: CommonOptions) {
     const schemaFile = getSchemaFile(options.schema);
@@ -27,28 +27,24 @@ export async function run(command: string, options: CommonOptions) {
 
     switch (command) {
         case 'dev':
-            await runDev(schemaFile, prismaSchemaFile, options);
+            await runDev(prismaSchemaFile, options);
             break;
 
         case 'reset':
-            await runReset(schemaFile, prismaSchemaFile, options as any);
+            await runReset(prismaSchemaFile, options as any);
             break;
 
         case 'deploy':
-            await runDeploy(schemaFile, prismaSchemaFile, options);
+            await runDeploy(prismaSchemaFile, options);
             break;
 
         case 'status':
-            await runStatus(schemaFile, prismaSchemaFile, options);
+            await runStatus(prismaSchemaFile, options);
             break;
     }
 }
 
-async function runDev(
-    _schemaFile: string,
-    prismaSchemaFile: string,
-    _options: unknown
-) {
+async function runDev(prismaSchemaFile: string, _options: unknown) {
     try {
         await execPackage(
             `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate`,
@@ -61,11 +57,7 @@ async function runDev(
     }
 }
 
-async function runReset(
-    _schemaFile: string,
-    prismaSchemaFile: string,
-    options: { force: boolean }
-) {
+async function runReset(prismaSchemaFile: string, options: { force: boolean }) {
     try {
         await execPackage(
             `prisma migrate reset --schema "${prismaSchemaFile}"${
@@ -80,11 +72,7 @@ async function runReset(
     }
 }
 
-async function runDeploy(
-    _schemaFile: string,
-    prismaSchemaFile: string,
-    _options: unknown
-) {
+async function runDeploy(prismaSchemaFile: string, _options: unknown) {
     try {
         await execPackage(
             `prisma migrate deploy --schema "${prismaSchemaFile}"`,
@@ -97,11 +85,7 @@ async function runDeploy(
     }
 }
 
-async function runStatus(
-    _schemaFile: string,
-    prismaSchemaFile: string,
-    _options: unknown
-) {
+async function runStatus(prismaSchemaFile: string, _options: unknown) {
     try {
         await execPackage(
             `prisma migrate status --schema "${prismaSchemaFile}"`,

packages/cli/src/index.ts

@@ -4,23 +4,24 @@ import { Command, Option } from 'commander';
 import * as actions from './actions';
 import { getVersion } from './utils/version-utils';
 
-export const infoAction = async (projectPath: string): Promise<void> => {
+const infoAction = async (projectPath: string): Promise<void> => {
     await actions.info(projectPath);
 };
 
-export const generateAction = async (
+const generateAction = async (
     options: Parameters<typeof actions.generate>[0]
 ): Promise<void> => {
     await actions.generate(options);
 };
 
-export const migrateAction = async (
-    command: string,
-    options: any
-): Promise<void> => {
+const migrateAction = async (command: string, options: any): Promise<void> => {
     await actions.migrate(command, options);
 };
 
+const dbAction = async (command: string, options: any): Promise<void> => {
+    await actions.db(command, options);
+};
+
 export function createProgram() {
     const program = new Command('zenstack');
 
@@ -64,7 +65,7 @@ export function createProgram() {
 
     const migrateCommand = program
         .command('migrate')
-        .description('Run migration.');
+        .description('Update the database schema with migrations.');
 
     migrateCommand
         .command('dev')
@@ -91,7 +92,7 @@ export function createProgram() {
         .command('deploy')
         .addOption(schemaOption)
         .description(
-            'deploy your pending migrations to your production/staging database.'
+            'Deploy your pending migrations to your production/staging database.'
         )
         .action((options) => migrateAction('deploy', options));
 
@@ -101,6 +102,25 @@ export function createProgram() {
         .description('check the status of your database migrations.')
         .action((options) => migrateAction('status', options));
 
+    const dbCommand = program
+        .command('db')
+        .description('Manage your database schema during development.');
+
+    dbCommand
+        .command('push')
+        .description('Push the state from your schema to your database')
+        .addOption(schemaOption)
+        .addOption(
+            new Option('--accept-data-loss', 'ignore data loss warnings')
+        )
+        .addOption(
+            new Option(
+                '--force-reset',
+                'force a reset of the database before push'
+            )
+        )
+        .action((options) => dbAction('push', options));
+
     return program;
 }