@ductape/cli 0.2.0 → 0.2.2

package/.env.ductape.example

@@ -0,0 +1,5 @@
+# Ductape — credentials from Workbench → SDK Access
+DUCTAPE_ACCESS_KEY=
+# Passed to new Ductape({ accessKey, product, env }) — constructor is the only place for product/env defaults
+DUCTAPE_PRODUCT=
+DUCTAPE_ENV=dev

package/DB_MIGRATE_PLAN.md

@@ -0,0 +1,223 @@
+# `ductape db migrate` — Research & Implementation Plan
+
+## What already exists
+
+### 1. `ductape init` creates `.ductape/`
+[`src/commands/init.ts`](src/commands/init.ts) calls `writeInitArtifacts()` and `saveProjectConfig()`.
+[`src/lib/config.ts`](src/lib/config.ts) line 13 defines:
+```ts
+export const PROJECT_CONFIG_DIR = '.ductape';
+export const PROJECT_CONFIG_PATH = path.join(PROJECT_CONFIG_DIR, 'config.json');
+```
+This is the only change needed in `config.ts` to rename to `ductape/`.
+
+### 2. `ductape db <verb>` — proxy passthrough
+[`src/commands/db.ts`](src/commands/db.ts) is a generic proxy that already understands `migration.list` and `migration.run` as method strings (defined in [`src/lib/db-methods.ts`](src/lib/db-methods.ts)). These work today but require a JSON body file (`-f`) and are not user-friendly for the workflow we're building.
+
+### 3. SDK `MigrationEngine` — fully built
+[`sdk/ts/src/database/migrations/migration-engine.ts`](../sdk/ts/src/database/migrations/migration-engine.ts):
+- Tracks applied migrations in a `_ductape_migrations` table/collection created automatically on first run.
+- `migrate(migrations[])` — runs all pending (not yet in `_ductape_migrations`) in dependency order.
+- `rollback(count)` / `rollbackAll()` / `reset()`.
+- `getPendingMigrations(migrations[])` — diffs supplied list against `_ductape_migrations`.
+- `getAppliedMigrations()` — returns history with tag, name, checksum, appliedAt.
+- `getStatus(migrations[])` — returns `{ total, completed, pending, pendingMigrations[], appliedMigrations[] }`.
+- Works across PostgreSQL, MySQL, MariaDB, MongoDB, DynamoDB, Cassandra.
+
+### 4. SDK `SchemaManager` + `MigrationBuilder`
+[`sdk/ts/src/database/schema/schema-manager.ts`](../sdk/ts/src/database/schema/schema-manager.ts):
+- `createCollection(name, fields[], options?)` — generates an `IMigration` (up: createCollection, down: dropCollection).
+- `addField()`, `dropField()`, `renameField()`, `modifyField()` — each generates a reversible `IMigration`.
+- `createIndex()`, `dropIndex()`, `addConstraint()`, `dropConstraint()`.
+- `MigrationBuilder` — fluent API for batching multiple operations into one migration object.
+- All operations produce `IMigration` objects with `up[]` and `down[]` — the same shape the engine consumes.
+
+### 5. `IFieldDefinition` type system
+Supported field types: `string`, `text`, `integer`, `bigint`, `smallint`, `decimal`, `float`, `double`, `uuid`, `boolean`, `date`, `time`, `datetime`, `timestamp`, `binary`, `blob`, `json`, `object`, `array`, `enum`.
+
+Field options: `nullable`, `unique`, `primaryKey`, `autoGenerate` (auto-increment/SERIAL), `defaultValue`, `maxLength`, `precision`, `scale`, `enumValues`, `arrayElementType`.
+
+---
+
+## What does not exist yet
+
+### Gap 1 — `ductape/` folder structure (not `.ductape/`)
+Currently `PROJECT_CONFIG_DIR = '.ductape'`. Needs to become `'ductape'`.
+
+`ductape init` should also scaffold:
+```
+ductape/
+  config.json          ← existing (project linking)
+  database/
+    schema.json        ← NEW: declarative schema definition
+    migrations/        ← NEW: generated migration files (one JSON per migration)
+```
+
+### Gap 2 — `ductape/database/schema.json` format
+No parser, type-mapper, or loader exists. This needs to be written.
+
+User-specified format:
+```json
+[
+  {
+    "db": "dbTag",
+    "tables": {
+      "users": {
+        "name":  { "type": "String", "required": true },
+        "email": { "type": "String", "unique": true },
+        "age":   { "type": "Number" }
+      },
+      "orders": {
+        "userId":    { "type": "String", "required": true },
+        "total":     { "type": "Number" },
+        "createdAt": { "type": "Date", "default": "now" }
+      }
+    }
+  }
+]
+```
+
+The CLI must translate this mongoose-style syntax to `IFieldDefinition[]` before it can call `SchemaManager` or `MigrationEngine`. Mapping table needed (see below).
+
+### Gap 3 — `ductape db migrate` command
+No high-level migrate command exists. The existing `ductape db migration.run` requires a structured JSON body and is a raw proxy call, not schema-aware.
+
+### Gap 4 — Schema diff logic
+The CLI needs to determine which tables and fields in `schema.json` are new (not yet migrated). Two available signals:
+- `migration.list` via proxy — returns `_ductape_migrations` history (knows what ran).
+- `schema.describe` / `schema.list` via proxy — introspects current DB structure directly.
+
+The safer approach is to use the migration history (what the CLI itself applied) as the source of truth, and use `schema.describe` only as a secondary check. This keeps the system append-only and prevents false positives from manual DB changes.
+
+### Gap 5 — Generated migration files
+When the CLI generates a migration from a schema diff, it should write a timestamped JSON file to `ductape/database/migrations/`:
+```
+ductape/database/migrations/
+  20250703_120000_create_users.json
+  20250703_120001_create_orders.json
+```
+These files are the local record of what was generated and are committed to version control. On `ductape db migrate`, the CLI reads all files from this folder, diffs against applied migrations, and runs the pending ones.
+
+### Gap 6 — Remote schema sync (deferred — see below)
+No mechanism exists to push/pull `schema.json` to/from a remote location. This is the biggest open architectural question.
+
+---
+
+## Mongoose-to-Ductape type mapping
+
+| Mongoose style | `FieldType` |
+|---|---|
+| `String` | `string` |
+| `Number` | `integer` (default) or `decimal` if `float: true` |
+| `Boolean` | `boolean` |
+| `Date` | `datetime` |
+| `Buffer` | `binary` |
+| `Mixed` / `Object` | `object` |
+| `Array` | `array` |
+| `ObjectId` / `UUID` | `uuid` |
+| `Map` | `object` |
+| `Decimal128` | `decimal` |
+
+Mongoose field options → `IFieldDefinition`:
+| Mongoose | `IFieldDefinition` |
+|---|---|
+| `required: true` | `nullable: false` |
+| `unique: true` | `unique: true` |
+| `default: value` | `defaultValue: value` |
+| `default: 'now'` | `defaultValue: 'CURRENT_TIMESTAMP'` |
+| `maxlength: N` | `maxLength: N` |
+| `enum: [...]` | `type: 'enum', enumValues: [...]` |
+| `index: true` | generates a separate `createIndex` operation |
+| `primaryKey: true` | `primaryKey: true` |
+| `autoGenerate: true` | `autoGenerate: true` |
+
+---
+
+## Proposed command surface
+
+```
+ductape db migrate              Run all pending migrations for all dbs in schema.json
+ductape db migrate --env <tag>  Run against a specific environment
+ductape db migrate --dry-run    Print what would run without applying
+ductape db migrate --db <tag>   Limit to one db entry from schema.json
+
+ductape db migrate status       Show applied vs pending migrations
+ductape db migrate rollback     Roll back the last migration
+ductape db migrate rollback -n 3  Roll back the last 3
+
+ductape db schema generate      Diff schema.json vs applied migrations and write new migration files to migrations/ WITHOUT running them
+ductape db schema push          Push local schema.json to remote (Ductape platform storage) — deferred
+ductape db schema pull          Fetch remote schema.json to local — deferred
+```
+
+The core flow for `ductape db migrate`:
+1. Load `ductape/database/schema.json`.
+2. For each `{ db, tables }` entry:
+   a. Resolve the db tag to a database_context via `db connect`.
+   b. Load all migration files from `ductape/database/migrations/` that match this db.
+   c. Call `migration.list` via proxy to get already-applied migration tags.
+   d. Filter to pending migrations (files whose tag is not in applied list).
+   e. Call `migration.run` via proxy for each pending migration in order.
+3. Report results.
+
+The `ductape db schema generate` flow:
+1. Load `schema.json`.
+2. Load existing migration files from `migrations/`.
+3. Reconstruct the "current intended schema" from applied migrations (replay up-ops in memory).
+4. Diff declared schema (from `schema.json`) vs current intended schema.
+5. For new tables → generate `createCollection` migration.
+6. For new fields on existing tables → generate `addField` migration.
+7. For removed fields/tables → refuse by default; require `--destructive` flag.
+8. Write each generated migration as a JSON file in `migrations/`.
+
+---
+
+## Things to watch out for
+
+### Non-destructive by default
+`ductape db schema generate` must never emit `dropCollection` or `dropField` operations unless `--destructive` is explicitly passed. Removing a field from `schema.json` silently generating a drop migration could wipe production data.
+
+### Schema.json vs migration files as source of truth
+`schema.json` expresses intent. Migration files express history. The CLI generates migration files from `schema.json` changes. Once a migration file exists, it is the immutable record — `schema.json` can diverge (e.g., someone deletes a table definition) but the migration file should not be regenerated or deleted automatically.
+
+### db tag resolution
+Each `{ db: 'dbTag' }` in schema.json needs to be connected before migrations can run. The existing `ductape db connect` / `database_context` mechanism handles this. The `migrate` command should do a `connect` call per db entry before running its migrations.
+
+### Migration ordering across tables
+When generating migrations for multiple new tables in one run, ordering matters if tables have foreign keys. The user can declare `dependencies` on a migration to enforce order. For the initial scaffold, generate one migration file per table in the order they appear in `schema.json`. A future improvement could auto-detect FK dependencies.
+
+### Idempotency
+`migration.run` via the engine already checks `_ductape_migrations` before applying. Re-running `ductape db migrate` is safe — it skips already-applied migrations.
+
+### Checksum integrity
+The `MigrationEngine` records a SHA-256 checksum of the migration content at apply time. If a migration file is edited after being applied, the engine will detect a mismatch. The CLI should warn about this rather than silently failing.
+
+---
+
+## The multi-codebase schema sync problem
+
+This is the hardest part of the system and is explicitly deferred.
+
+**The problem:** Team member A adds `products` table to `schema.json` and runs `ductape db schema generate`, producing `20250703_create_products.json`. Team member B pulls code and gets the migration file. But if B's `schema.json` is out of date, running `ductape db schema generate` again might produce a duplicate or conflicting migration.
+
+**Proposed approach (to validate before implementing):**
+- Migration files (`ductape/database/migrations/*.json`) are committed to version control. This is the primary sync mechanism — same as Prisma, Flyway, Liquibase.
+- `schema.json` is the declarative desired state. It should also be committed, but is the secondary source. Migration files take precedence.
+- `ductape db schema push` uploads `schema.json` to a `_ductape_schema` collection (or Ductape platform storage) so other machines can fetch it.
+- `ductape db schema pull` fetches the remote schema.json and merges it — or simply overwrites the local one (simpler, with a warning).
+- The authoritative migration history is always `_ductape_migrations` in the actual database. The CLI's job is just to generate and apply files; the DB is always the final word on what ran.
+
+**Key constraint to solve before implementing sync:** If two developers generate migrations from different `schema.json` states at the same time (e.g., both add different tables locally), their migration files will have different tags and could conflict when both are applied to the same DB. This is the same problem Git branch migrations have in Prisma. The recommended solution is to treat migration file generation as a gated step that only runs on `main` / via CI, not locally in parallel. This is a workflow decision that should be locked in before the sync commands are built.
+
+---
+
+## Implementation order
+
+1. Rename `PROJECT_CONFIG_DIR` from `.ductape` to `ductape` in `config.ts`.
+2. Update `writeInitArtifacts()` in `templates.ts` to scaffold `database/schema.json` and `database/migrations/`.
+3. Write `src/lib/schema-loader.ts` — loads and validates `schema.json`, maps mongoose types to `IFieldDefinition`.
+4. Write `src/lib/migration-files.ts` — reads/writes migration JSON files from `ductape/database/migrations/`.
+5. Add `ductape db schema generate` subcommand.
+6. Add `ductape db migrate` subcommand (run pending migration files via proxy).
+7. Add `ductape db migrate status` and `ductape db migrate rollback`.
+8. Deferred: `ductape db schema push` / `ductape db schema pull`.

package/dist/commands/apply.d.ts

@@ -0,0 +1,6 @@
+export type ApplyType = 'sessions' | 'notifications' | 'events';
+interface ApplyOpts {
+    dryRun?: boolean;
+}
+export declare function runApply(type: ApplyType | undefined, opts: ApplyOpts): Promise<void>;
+export {};

package/dist/commands/apply.js

@@ -0,0 +1,71 @@
+import { findProjectConfig } from '../lib/config.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { fail } from '../lib/output.js';
+import { buildCrudParams } from '../lib/resources.js';
+import { loadSessions, loadNotifications, loadEvents, } from '../lib/apply-loaders.js';
+const MODULE_FOR = {
+    sessions: 'sessions',
+    notifications: 'notifications',
+    events: 'messageBrokers',
+};
+async function syncItems(type, items, productTag, proxy, dryRun) {
+    const module = MODULE_FOR[type];
+    const listResult = await proxy.execute(module, 'list', buildCrudParams(module, 'list', productTag, {}));
+    const existingList = Array.isArray(listResult) ? listResult : [];
+    const existingTags = new Set(existingList.map((r) => r.tag ?? '').filter(Boolean));
+    for (const item of items) {
+        if (!item.tag) {
+            console.warn(`  [${type}] skipped — missing "tag" field`);
+            continue;
+        }
+        const verb = existingTags.has(item.tag) ? 'update' : 'create';
+        if (dryRun) {
+            console.log(`  [${type}] would ${verb}: ${item.tag}`);
+            continue;
+        }
+        try {
+            const params = buildCrudParams(module, verb, productTag, { tag: item.tag, body: item });
+            await proxy.execute(module, verb, params);
+            console.log(`  [${type}] ${verb}d: ${item.tag}`);
+        }
+        catch (err) {
+            console.error(`  [${type}] ${verb} failed for "${item.tag}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+export async function runApply(type, opts) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory.');
+    const { dir } = found;
+    const session = requireSession();
+    const proxy = getSdkProxy(session);
+    const productTag = session.project.product_tag;
+    const dryRun = Boolean(opts.dryRun);
+    const targets = type ? [type] : ['sessions', 'notifications', 'events'];
+    const loaders = {
+        sessions: () => loadSessions(dir),
+        notifications: () => loadNotifications(dir),
+        events: () => loadEvents(dir),
+    };
+    for (const t of targets) {
+        let items;
+        try {
+            items = loaders[t]();
+        }
+        catch (err) {
+            console.error(`[${t}] parse error: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        if (items === null) {
+            console.log(`[${t}] no ductape/${t}.json found — skipping`);
+            continue;
+        }
+        if (items.length === 0) {
+            console.log(`[${t}] empty — nothing to apply`);
+            continue;
+        }
+        console.log(`[${t}] applying ${items.length} item(s)${dryRun ? ' (dry run)' : ''}...`);
+        await syncItems(t, items, productTag, proxy, dryRun);
+    }
+}

package/dist/commands/db-migrate.d.ts

@@ -0,0 +1,19 @@
+interface MigrateOpts {
+    env?: string;
+    db?: string;
+    dryRun?: boolean;
+}
+interface MigrateStatusOpts {
+    env?: string;
+    db?: string;
+    json?: boolean;
+}
+interface MigrateRollbackOpts {
+    env?: string;
+    db?: string;
+    n?: number;
+}
+export declare function runDbMigrate(opts: MigrateOpts): Promise<void>;
+export declare function runDbMigrateStatus(opts: MigrateStatusOpts): Promise<void>;
+export declare function runDbMigrateRollback(opts: MigrateRollbackOpts): Promise<void>;
+export {};

package/dist/commands/db-migrate.js

@@ -0,0 +1,154 @@
+import { findProjectConfig } from '../lib/config.js';
+import { loadSchemaFile } from '../lib/schema-loader.js';
+import { loadMigrationFiles } from '../lib/migration-files.js';
+import { getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { fail, printJson } from '../lib/output.js';
+function buildDbContext(dbTag, envSlug, productTag) {
+    return { database: dbTag, env: envSlug, product: productTag };
+}
+async function getAppliedTags(proxy, dbContext, productTag, envSlug) {
+    try {
+        const result = await proxy.execute('migration.list', [{ product: productTag, env: envSlug, database: dbContext.database }], dbContext);
+        const list = Array.isArray(result)
+            ? result
+            : Array.isArray(result.data)
+                ? result.data
+                : [];
+        return list.map((r) => r.tag ?? '').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+export async function runDbMigrate(opts) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory.');
+    const { dir } = found;
+    const session = requireSession();
+    const proxy = getDbProxy(session);
+    const envSlug = opts.env ?? session.project.env_slug;
+    const productTag = session.project.product_tag;
+    const schemaEntries = loadSchemaFile(dir);
+    const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+    if (targets.length === 0) {
+        fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
+    }
+    let totalApplied = 0;
+    let totalDry = 0;
+    for (const entry of targets) {
+        const { db } = entry;
+        const dbContext = buildDbContext(db, envSlug, productTag);
+        const migrations = loadMigrationFiles(dir, db);
+        if (migrations.length === 0) {
+            console.log(`[${db}] No migration files found. Run \`ductape db schema generate\` first.`);
+            continue;
+        }
+        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const pending = migrations.filter((m) => !appliedTags.includes(m.tag));
+        if (pending.length === 0) {
+            console.log(`[${db}] Already up to date.`);
+            continue;
+        }
+        console.log(`[${db}] ${pending.length} pending migration(s).`);
+        for (const migration of pending) {
+            if (opts.dryRun) {
+                console.log(`  [dry-run] Would apply: ${migration.tag}`);
+                totalDry++;
+                continue;
+            }
+            process.stdout.write(`  Applying ${migration.tag}... `);
+            try {
+                await proxy.execute('migration.run', [{ product: productTag, env: envSlug, database: db, migrations: [migration] }], dbContext);
+                console.log('done');
+                totalApplied++;
+            }
+            catch (err) {
+                console.log('failed');
+                fail(`Migration "${migration.tag}" failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    if (opts.dryRun) {
+        console.log(`\nDry run: ${totalDry} migration(s) would be applied.`);
+    }
+    else {
+        console.log(`\nApplied ${totalApplied} migration(s).`);
+    }
+}
+export async function runDbMigrateStatus(opts) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory.');
+    const { dir } = found;
+    const session = requireSession();
+    const proxy = getDbProxy(session);
+    const envSlug = opts.env ?? session.project.env_slug;
+    const productTag = session.project.product_tag;
+    const schemaEntries = loadSchemaFile(dir);
+    const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+    const statusReport = {};
+    for (const entry of targets) {
+        const { db } = entry;
+        const dbContext = buildDbContext(db, envSlug, productTag);
+        const migrations = loadMigrationFiles(dir, db);
+        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const applied = migrations.filter((m) => appliedTags.includes(m.tag)).map((m) => m.tag);
+        const pending = migrations.filter((m) => !appliedTags.includes(m.tag)).map((m) => m.tag);
+        statusReport[db] = { applied, pending };
+        if (!opts.json) {
+            console.log(`\n[${db}]`);
+            if (applied.length > 0) {
+                console.log(`  Applied (${applied.length}):`);
+                for (const t of applied)
+                    console.log(`    + ${t}`);
+            }
+            if (pending.length > 0) {
+                console.log(`  Pending (${pending.length}):`);
+                for (const t of pending)
+                    console.log(`    - ${t}`);
+            }
+            if (applied.length === 0 && pending.length === 0) {
+                console.log('  No migration files found.');
+            }
+        }
+    }
+    if (opts.json)
+        printJson(statusReport, true);
+}
+export async function runDbMigrateRollback(opts) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory.');
+    const { dir } = found;
+    const session = requireSession();
+    const proxy = getDbProxy(session);
+    const envSlug = opts.env ?? session.project.env_slug;
+    const productTag = session.project.product_tag;
+    const rollbackCount = opts.n ?? 1;
+    const schemaEntries = loadSchemaFile(dir);
+    const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+    for (const entry of targets) {
+        const { db } = entry;
+        const dbContext = buildDbContext(db, envSlug, productTag);
+        const migrations = loadMigrationFiles(dir, db);
+        const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+        const applied = migrations.filter((m) => appliedTags.includes(m.tag));
+        const toRollback = applied.slice(-rollbackCount).reverse();
+        if (toRollback.length === 0) {
+            console.log(`[${db}] Nothing to roll back.`);
+            continue;
+        }
+        for (const migration of toRollback) {
+            process.stdout.write(`  Rolling back ${migration.tag}... `);
+            try {
+                await proxy.execute('migration.rollback', [{ product: productTag, env: envSlug, database: db, migrations: [migration] }], dbContext);
+                console.log('done');
+            }
+            catch (err) {
+                console.log('failed');
+                fail(`Rollback of "${migration.tag}" failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}

package/dist/commands/db-schema.d.ts

@@ -0,0 +1,6 @@
+interface SchemaGenerateOpts {
+    db?: string;
+    destructive?: boolean;
+}
+export declare function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<void>;
+export {};

package/dist/commands/db-schema.js

@@ -0,0 +1,135 @@
+import path from 'node:path';
+import { findProjectConfig } from '../lib/config.js';
+import { loadSchemaFile, parseTableDef } from '../lib/schema-loader.js';
+import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
+import { fail } from '../lib/output.js';
+function replayMigrations(migrations) {
+    const schema = new Map();
+    for (const migration of migrations) {
+        for (const op of migration.up) {
+            if (op.type === 'createCollection') {
+                if (!schema.has(op.name)) {
+                    schema.set(op.name, { fields: new Set(op.fields.map((f) => f.name)) });
+                }
+            }
+            else if (op.type === 'dropCollection') {
+                schema.delete(op.name);
+            }
+            else if (op.type === 'addField') {
+                const t = schema.get(op.collection);
+                if (t)
+                    t.fields.add(op.field.name);
+            }
+            else if (op.type === 'dropField') {
+                const t = schema.get(op.collection);
+                if (t)
+                    t.fields.delete(op.fieldName);
+            }
+        }
+    }
+    return schema;
+}
+export async function runDbSchemaGenerate(opts) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory.');
+    const { dir } = found;
+    const schemaEntries = loadSchemaFile(dir);
+    const targets = opts.db
+        ? schemaEntries.filter((e) => e.db === opts.db)
+        : schemaEntries;
+    if (targets.length === 0) {
+        fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
+    }
+    let totalGenerated = 0;
+    for (const entry of targets) {
+        const { db, tables } = entry;
+        const existing = loadMigrationFiles(dir, db);
+        const current = replayMigrations(existing);
+        const newMigrations = [];
+        let counter = existing.length + 1;
+        for (const [tableName, fieldDefs] of Object.entries(tables)) {
+            const parsed = parseTableDef(tableName, fieldDefs);
+            const currentTable = current.get(tableName);
+            if (!currentTable) {
+                const up = [
+                    {
+                        type: 'createCollection',
+                        name: tableName,
+                        fields: parsed.fields,
+                        ifNotExists: true,
+                    },
+                ];
+                for (const { fieldName, unique } of parsed.indexFields) {
+                    up.push({
+                        type: 'createIndex',
+                        collection: tableName,
+                        name: `${tableName}_${fieldName}_idx`,
+                        fields: [{ name: fieldName }],
+                        unique,
+                        ifNotExists: true,
+                    });
+                }
+                const down = [
+                    { type: 'dropCollection', name: tableName, ifExists: true },
+                ];
+                newMigrations.push({
+                    tag: `create_${tableName}`,
+                    name: `Create collection ${tableName}`,
+                    up,
+                    down,
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            else {
+                const addOps = [];
+                const dropOps = [];
+                for (const field of parsed.fields) {
+                    if (!currentTable.fields.has(field.name)) {
+                        addOps.push({ type: 'addField', collection: tableName, field });
+                    }
+                }
+                const desiredFields = new Set(parsed.fields.map((f) => f.name));
+                const removedFields = [];
+                for (const existingField of currentTable.fields) {
+                    if (!desiredFields.has(existingField)) {
+                        removedFields.push(existingField);
+                        if (opts.destructive) {
+                            dropOps.push({ type: 'dropField', collection: tableName, fieldName: existingField });
+                        }
+                    }
+                }
+                if (!opts.destructive && removedFields.length > 0) {
+                    console.warn(`  [${db}] Warning: field(s) removed from schema.json for "${tableName}": ${removedFields.join(', ')}. Pass --destructive to generate drop migrations.`);
+                }
+                const allOps = [...addOps, ...dropOps];
+                if (allOps.length > 0) {
+                    const down = addOps.map((op) => ({
+                        type: 'dropField',
+                        collection: tableName,
+                        fieldName: op.field.name,
+                    }));
+                    newMigrations.push({
+                        tag: `alter_${tableName}_${Date.now()}`,
+                        name: `Alter collection ${tableName}`,
+                        up: allOps,
+                        down,
+                        createdAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        if (newMigrations.length === 0) {
+            console.log(`[${db}] Schema is up to date. No migrations generated.`);
+            continue;
+        }
+        for (const migration of newMigrations) {
+            const filePath = writeMigrationFile(dir, db, migration, counter++);
+            console.log(`[${db}] Generated ${path.basename(filePath)}`);
+            totalGenerated++;
+        }
+    }
+    if (totalGenerated > 0) {
+        console.log(`\nGenerated ${totalGenerated} migration file(s). Run \`ductape db migrate\` to apply them.`);
+    }
+}

package/dist/commands/install.d.ts

@@ -1 +1 @@
-export declare function runInstall(): void;
+export declare function runInstall(): Promise<void>;