Simplified migration commands

src/commands/apply.ts

@@ -0,0 +1,111 @@
+import ora from 'ora';
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { initializeDatabase } from '@/src/utils/database';
+import type { MigrationFlags } from '@/src/utils/migration';
+import { MODELS_IN_CODE_DIR } from '@/src/utils/misc';
+import { getModels } from '@/src/utils/model';
+import { Protocol } from '@/src/utils/protocol';
+import { getOrSelectSpaceId } from '@/src/utils/space';
+import { spinner } from '@/src/utils/spinner';
+import { RoninError } from '@ronin/compiler';
+import type { Database } from '@ronin/engine';
+
+/**
+ * Applies a migration file to the database.
+ */
+export default async (
+  appToken: string | undefined,
+  sessionToken: string | undefined,
+  flags: MigrationFlags,
+  positionals: Array<string>,
+): Promise<void> => {
+  const spinner = ora('Applying migration').start();
+  const migrationFilePath = positionals[positionals.indexOf('apply') + 1];
+
+  const db = await initializeDatabase();
+
+  try {
+    const { slug } = await getOrSelectSpaceId(sessionToken, spinner);
+    const existingModels = await getModels(
+      db,
+      appToken ?? sessionToken,
+      slug,
+      flags.local,
+    );
+    const protocol = await new Protocol().load(migrationFilePath);
+    const statements = protocol.getSQLStatements(existingModels);
+
+    const files = fs.readdirSync(
+      path.join(process.cwd(), MODELS_IN_CODE_DIR, '.protocols'),
+    );
+    const latestProtocolFile = files.sort().pop() || 'migration';
+
+    const migrationsPath = path.join(process.cwd(), MODELS_IN_CODE_DIR, 'migrations');
+
+    if (!fs.existsSync(migrationsPath)) {
+      fs.mkdirSync(migrationsPath, { recursive: true });
+    }
+
+    fs.copyFileSync(
+      migrationFilePath ||
+        path.join(
+          process.cwd(),
+          MODELS_IN_CODE_DIR,
+          '.protocols',
+          path.basename(latestProtocolFile),
+        ),
+      path.join(migrationsPath, path.basename(latestProtocolFile)),
+    );
+
+    await applyMigrationStatements(appToken ?? sessionToken, flags, db, statements, slug);
+
+    spinner.succeed('Successfully applied migration');
+    process.exit(0);
+  } catch (err) {
+    const message =
+      err instanceof RoninError
+        ? err.message
+        : `Failed to apply migration: ${err instanceof Error ? err.message : err}`;
+    spinner.fail(message);
+
+    process.exit(1);
+  }
+};
+
+/**
+ * Applies migration statements to the database.
+ */
+const applyMigrationStatements = async (
+  appTokenOrSessionToken: string | undefined,
+  flags: MigrationFlags,
+  db: Database,
+  statements: Array<{ statement: string }>,
+  slug: string,
+): Promise<void> => {
+  if (flags.local) {
+    spinner.info('Applying migration to local database');
+
+    await db.query(statements.map(({ statement }) => statement));
+    fs.writeFileSync('.ronin/db.sqlite', await db.getContents());
+
+    return;
+  }
+
+  spinner.info('Applying migration to production database');
+
+  await fetch(`https://data.ronin.co/?data-selector=${slug}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${appTokenOrSessionToken}`,
+    },
+    body: JSON.stringify({
+      nativeQueries: statements.map((query) => ({
+        query: query.statement,
+        mode: 'write',
+      })),
+    }),
+  });
+};

src/commands/diff.ts

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import apply from '@/src/commands/apply';
+import { initializeDatabase } from '@/src/utils/database';
+import { type MigrationFlags, diffModels } from '@/src/utils/migration';
+import { MODELS_IN_CODE_DIR, getModelDefinitions, logTableDiff } from '@/src/utils/misc';
+import { getModels } from '@/src/utils/model';
+import { Protocol } from '@/src/utils/protocol';
+import { getOrSelectSpaceId } from '@/src/utils/space';
+import { type Status, spinner } from '@/src/utils/spinner';
+import { type Model, RoninError } from '@ronin/compiler';
+
+/**
+ * Creates a new migration based on model differences.
+ */
+export default async (
+  appToken: string | undefined,
+  sessionToken: string | undefined,
+  flags: MigrationFlags,
+): Promise<void> => {
+  let status: Status = 'readingConfig';
+  spinner.text = 'Reading configuration';
+
+  const db = await initializeDatabase();
+
+  try {
+    const { slug } = await getOrSelectSpaceId(sessionToken, spinner);
+    status = 'comparing';
+    spinner.text = 'Comparing models';
+
+    const [existingModels, definedModels] = await Promise.all([
+      getModels(db, appToken ?? sessionToken, slug, flags.local),
+      getModelDefinitions(),
+    ]);
+
+    if (flags.debug) {
+      logModelDiffs(definedModels, existingModels);
+    }
+
+    const modelDiff = await diffModels(definedModels, existingModels);
+
+    if (modelDiff.length === 0) {
+      spinner.succeed('No changes detected');
+      return process.exit(0);
+    }
+
+    status = 'syncing';
+    spinner.text = 'Writing migration protocol file';
+
+    const migrationsDir = path.join(process.cwd(), MODELS_IN_CODE_DIR, '.protocols');
+    const nextNum = (() => {
+      if (!fs.existsSync(migrationsDir)) return 1;
+      const files = fs.readdirSync(migrationsDir);
+      const migrationFiles = files.filter((f) => f.startsWith('migration-'));
+      if (migrationFiles.length === 0) return 1;
+      const numbers = migrationFiles.map((f) => Number.parseInt(f.split('-')[1]));
+      return Math.max(...numbers) + 1;
+    })();
+
+    const paddedNum = String(nextNum).padStart(4, '0');
+    const protocol = new Protocol(modelDiff);
+    await protocol.convertToQueryObjects();
+    await protocol.save(`migration-${paddedNum}`);
+
+    if (flags.sql) {
+      const allModels = [...existingModels, ...definedModels];
+      await protocol.saveSQL(`migration-${paddedNum}`, allModels);
+    }
+
+    spinner.succeed('Successfully generated migration protocol file');
+
+    // If desired, immediately apply the migration
+    if (flags.apply) {
+      await apply(appToken, sessionToken, flags, ['apply']);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    const message =
+      err instanceof RoninError
+        ? err.message
+        : `Failed during ${status}: ${err instanceof Error ? err.message : err}`;
+    spinner.fail(message);
+
+    process.exit(1);
+  }
+};
+
+/**
+ * Helper to log model differences in debug mode.
+ */
+const logModelDiffs = (
+  definedModels: Array<Model>,
+  existingModels: Array<Model>,
+): void => {
+  for (const existingModel of existingModels) {
+    const definedModel = definedModels.find((local) => local.slug === existingModel.slug);
+    if (definedModel && definedModel !== existingModel) {
+      logTableDiff(definedModel, existingModel, definedModel.slug);
+    }
+  }
+};