@cleverbrush/orm-cli 0.0.0-beta-20260424142030

package/README.md

@@ -0,0 +1,166 @@
+# `@cleverbrush/orm-cli`
+
+A standalone CLI for managing PostgreSQL schema migrations for projects built
+with [`@cleverbrush/orm`](https://github.com/cleverbrush/framework).
+
+```
+cb-orm migrate generate [name]   # diff DB → schema, emit TS migration file (name defaults to "migration")
+cb-orm migrate run               # apply pending migrations
+cb-orm migrate rollback          # roll back last batch
+cb-orm migrate status            # list applied/pending migrations
+cb-orm db push                   # sync schema in-place (dev only)
+```
+
+---
+
+## Installation
+
+```sh
+npm install --save-dev @cleverbrush/orm-cli
+```
+
+`knex` is a peer dependency and must be installed in your project. `tsx` is a regular dependency and is installed automatically.
+
+---
+
+## Quick start
+
+### 1. Create `db.config.ts` in your project root
+
+```ts
+// db.config.ts
+import knex from 'knex';
+import { defineConfig } from '@cleverbrush/orm-cli';
+import { UserEntity, TodoEntity } from './src/db/schemas.js';
+
+const db = knex({
+    client: 'pg',
+    connection: process.env.DATABASE_URL
+});
+
+export default defineConfig({
+    knex: db,
+    entities: { users: UserEntity, todos: TodoEntity },
+    migrations: {
+        directory: './migrations',  // where .ts migration files are written
+        tableName: 'knex_migrations' // default; override if needed
+    }
+});
+```
+
+### 2. Add convenience scripts to `package.json`
+
+```json
+{
+  "scripts": {
+    "db:generate": "cb-orm migrate generate",
+    "db:run":      "cb-orm migrate run",
+    "db:rollback": "cb-orm migrate rollback",
+    "db:status":   "cb-orm migrate status",
+    "db:push":     "cb-orm db push"
+  }
+}
+```
+
+---
+
+## Commands
+
+### `migrate generate <name>`
+
+Compares every entity in `config.entities` against the live database and emits
+a single timestamped TypeScript migration file when differences are found.
+
+- New tables → `CREATE TABLE`.
+- Existing tables with column/index/FK changes → `ALTER TABLE`.
+- Multiple tables are FK-dependency-ordered (parents created first, dropped last).
+- Polymorphic (CTI) entities include one entry per variant table.
+- File written as `<dir>/YYYYMMDDHHmmss_<name>.ts`.
+
+```sh
+npx cb-orm migrate generate add_role_column
+# → migrations/20260423120000_add_role_column.ts
+```
+
+### `migrate run`
+
+Applies all pending migrations via `knex.migrate.latest`.
+
+```sh
+npx cb-orm migrate run
+# Batch 1. Applied 2 migration(s):
+#   ✓ 20260423000001_init.ts
+#   ✓ 20260423120000_add_role_column.ts
+```
+
+Use `--to <filename>` to migrate up to a specific file:
+
+```sh
+npx cb-orm migrate run --to 20260423000001_init.ts
+```
+
+### `migrate rollback`
+
+Rolls back the most recently applied batch.
+
+```sh
+npx cb-orm migrate rollback
+# Roll back all batches:
+npx cb-orm migrate rollback --all
+```
+
+### `migrate status`
+
+Lists applied and pending migrations.
+
+```sh
+npx cb-orm migrate status
+
+# Applied migrations:
+#   ✓ 20260423000001_init.ts
+# Pending migrations:
+#   ○ 20260423120000_add_role_column.ts
+```
+
+### `db push`
+
+Applies all schema changes directly to the database **without** writing a
+migration file.  Runs inside a single transaction.
+
+> **Warning — dev only.**  Requires `--yes` when `NODE_ENV=production`.
+
+```sh
+npx cb-orm db push          # asks for confirmation
+npx cb-orm db push --yes    # skip confirmation
+```
+
+---
+
+## Options
+
+| Flag | Commands | Description |
+|------|----------|-------------|
+| `--config <path>` | all | Path to config file (default: `db.config.ts` in cwd) |
+| `--dir <path>` | all | Migrations directory (overrides `config.migrations.directory`) |
+| `--to <name>` | `migrate run` | Apply up to a specific migration filename |
+| `--all` | `migrate rollback` | Roll back all batches |
+| `--yes` | `db push` | Skip the interactive confirmation prompt |
+
+---
+
+## How it works
+
+The CLI delegates all schema intelligence to `@cleverbrush/knex-schema`:
+
+| Step | Function |
+|------|---------|
+| Detect new tables | `tableExistsInDb(knex, tableName)` |
+| Generate CREATE TABLE source | `generateCreateTableSource(schema)` |
+| Introspect live table | `introspectDatabase(knex, tableName)` |
+| Diff schema vs DB | `diffSchema(schema, dbState)` |
+| Generate ALTER TABLE source | `generateMigration(diff, tableName)` |
+| Apply diff without file | `applyDiff(knex, diff, tableName)` |
+| Polymorphic variant tables | `getPolymorphicVariantSchemas(schema)` |
+
+`tsx` is used to load `db.config.ts` at runtime by registering the
+`tsx/esm/api` hook before any dynamic `import()` of the config file.

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { register } from "tsx/esm/api";
+register();
+var { run } = await import("./cli-XMDVRIZG.js");
+await run(process.argv.slice(2));

package/dist/chunk-E43XQHR3.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+// src/commands/run.ts
+async function run(config, flags) {
+  const migrationConfig = buildMigrationConfig(config, flags);
+  const toMigration = flags["--to"];
+  if (toMigration) {
+    const [batchNo, applied] = await config.knex.migrate.up({
+      ...migrationConfig,
+      name: toMigration
+    });
+    if (applied.length === 0) {
+      console.log(`${toMigration} \u2014 already applied.`);
+    } else {
+      console.log(
+        `Batch ${batchNo}. Applied: ${applied.join(", ")}`
+      );
+    }
+  } else {
+    const [batchNo, applied] = await config.knex.migrate.latest(migrationConfig);
+    if (applied.length === 0) {
+      console.log("Already up to date.");
+    } else {
+      console.log(
+        `Batch ${batchNo}. Applied ${applied.length} migration(s):`
+      );
+      for (const m of applied) console.log(`  \u2713 ${m}`);
+    }
+  }
+}
+function buildMigrationConfig(config, flags) {
+  return {
+    directory: flags["--dir"] ?? config.migrations.directory,
+    tableName: config.migrations.tableName ?? "knex_migrations",
+    loadExtensions: [".ts", ".js"]
+  };
+}
+
+export {
+  run,
+  buildMigrationConfig
+};

package/dist/cli-XMDVRIZG.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+
+// src/config.ts
+import { existsSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var CANDIDATE_NAMES = [
+  "db.config.ts",
+  "db.config.js",
+  "db.config.mjs"
+];
+async function loadConfig(configPath) {
+  const resolved = configPath ? path.resolve(process.cwd(), configPath) : findConfigFile();
+  if (!existsSync(resolved)) {
+    throw new Error(`Config file not found: ${resolved}`);
+  }
+  const mod = await import(pathToFileURL(resolved).href);
+  const config = mod.default ?? mod;
+  assertConfig(config);
+  return config;
+}
+function findConfigFile() {
+  for (const name of CANDIDATE_NAMES) {
+    const candidate = path.resolve(process.cwd(), name);
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `No config file found. Create db.config.ts in your project root, or pass --config <path>.`
+  );
+}
+function assertConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error(
+      "Config must be an object (default export of db.config.ts)."
+    );
+  }
+  const c = config;
+  if (!c.knex || typeof c.knex.schema !== "object") {
+    throw new Error("config.knex must be a Knex instance.");
+  }
+  if (!c.entities || typeof c.entities !== "object") {
+    throw new Error(
+      "config.entities must be an object mapping names to Entity instances."
+    );
+  }
+  if (!c.migrations || typeof c.migrations.directory !== "string") {
+    throw new Error(
+      "config.migrations.directory must be a non-empty string path."
+    );
+  }
+}
+
+// src/cli.ts
+var _require = createRequire(import.meta.url);
+var _pkg = _require("../package.json");
+async function run(argv) {
+  const [cmd, sub, ...rest] = argv;
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    printHelp();
+    return;
+  }
+  if (cmd === "--version" || cmd === "-v") {
+    console.log(_pkg.version ?? "unknown");
+    return;
+  }
+  const flags = parseFlags(rest);
+  const configPath = flags["--config"];
+  try {
+    if (cmd === "migrate") {
+      switch (sub) {
+        case "generate": {
+          let name = "migration";
+          for (let i = 0; i < rest.length; i++) {
+            if (rest[i].startsWith("-")) {
+              const next = rest[i + 1];
+              if (next !== void 0 && !next.startsWith("-"))
+                i++;
+            } else {
+              name = rest[i];
+              break;
+            }
+          }
+          const config = await loadConfig(configPath);
+          const { generate } = await import("./generate-CMLVA6DT.js");
+          await generate(name, config, flags);
+          break;
+        }
+        case "run": {
+          const config = await loadConfig(configPath);
+          const { run: runMigrations } = await import("./run-PSIPMF6V.js");
+          await runMigrations(config, flags);
+          break;
+        }
+        case "rollback": {
+          const config = await loadConfig(configPath);
+          const { rollback } = await import("./rollback-AVV6DTXF.js");
+          await rollback(config, flags);
+          break;
+        }
+        case "status": {
+          const config = await loadConfig(configPath);
+          const { status } = await import("./status-W3A6JWR3.js");
+          await status(config, flags);
+          break;
+        }
+        default:
+          fatal(
+            `Unknown migrate command: ${sub ?? "(none)"}. Run \`cb-orm --help\` for usage.`
+          );
+      }
+    } else if (cmd === "db") {
+      switch (sub) {
+        case "push": {
+          const config = await loadConfig(configPath);
+          const { push } = await import("./push-SNCDOATW.js");
+          await push(config, flags);
+          break;
+        }
+        default:
+          fatal(
+            `Unknown db command: ${sub ?? "(none)"}. Run \`cb-orm --help\` for usage.`
+          );
+      }
+    } else {
+      fatal(`Unknown command: ${cmd}. Run \`cb-orm --help\` for usage.`);
+    }
+  } catch (err) {
+    console.error(
+      `
+Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[arg] = next;
+        i++;
+      } else {
+        flags[arg] = true;
+      }
+    }
+  }
+  return flags;
+}
+function fatal(msg) {
+  console.error(`
+Error: ${msg}
+`);
+  process.exit(1);
+}
+function printHelp() {
+  console.log(`
+cb-orm \u2014 Schema migration CLI for @cleverbrush/orm
+
+USAGE
+  cb-orm <command> [options]
+
+COMMANDS
+  migrate generate [name]   Diff DB vs schema, emit a timestamped TS migration file (default name: "migration")
+  migrate run               Apply pending migrations  (knex.migrate.latest)
+  migrate rollback          Roll back last batch      (knex.migrate.rollback)
+  migrate status            List applied and pending migrations
+  db push                   Sync schema to DB in-place (dev only \u2014 no migration file)
+
+OPTIONS
+  --config <path>   Path to db.config.ts  (default: db.config.ts in cwd)
+  --dir    <path>   Migrations directory  (overrides config.migrations.directory)
+  --to     <name>   (migrate run)      Apply up to a specific migration by filename
+  --all             (migrate rollback) Roll back all applied migrations
+  --yes             (db push)          Skip the confirmation prompt
+  --help,    -h     Show this help
+  --version, -v     Show version
+`);
+}
+export {
+  parseFlags,
+  run
+};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+export declare function run(argv: string[]): Promise<void>;
+/** Parse `--flag` / `--flag value` pairs from an argv tail. */
+export declare function parseFlags(args: string[]): Record<string, string | true>;

package/dist/commands/generate.d.ts

@@ -0,0 +1,11 @@
+import type { OrmCliConfig } from '../types.js';
+/**
+ * Diff the current entity schemas against the committed snapshot and write a
+ * single timestamped TypeScript migration file when changes are detected.
+ * Also updates the snapshot file so the next run starts from the new baseline.
+ *
+ * No live database connection is needed — the snapshot is the source of truth.
+ *
+ * File name pattern: `YYYYMMDDHHmmss_<name>.ts`  (matches Knex defaults).
+ */
+export declare function generate(name: string, config: OrmCliConfig, flags: Record<string, string | true>): Promise<void>;

package/dist/commands/push.d.ts

@@ -0,0 +1,11 @@
+import type { OrmCliConfig } from '../types.js';
+/**
+ * Sync every registered entity's schema to the live database without
+ * generating a migration file.
+ *
+ * - New tables are created via {@link generateCreateTable}.
+ * - Existing tables are altered via {@link applyDiff}.
+ * - All changes run inside a single transaction.
+ * - Aborted (no `--yes`) when `NODE_ENV=production`.
+ */
+export declare function push(config: OrmCliConfig, flags: Record<string, string | true>): Promise<void>;

package/dist/commands/rollback.d.ts

@@ -0,0 +1,5 @@
+import type { OrmCliConfig } from '../types.js';
+/**
+ * Roll back the last migration batch (or all batches with `--all`).
+ */
+export declare function rollback(config: OrmCliConfig, flags: Record<string, string | true>): Promise<void>;

package/dist/commands/run.d.ts

@@ -0,0 +1,11 @@
+import type { OrmCliConfig } from '../types.js';
+/**
+ * Apply pending migrations via `knex.migrate.latest`.
+ * Pass `--to <migrationName>` to migrate up to a specific file.
+ */
+export declare function run(config: OrmCliConfig, flags: Record<string, string | true>): Promise<void>;
+export declare function buildMigrationConfig(config: OrmCliConfig, flags: Record<string, string | true>): {
+    directory: string;
+    tableName: string;
+    loadExtensions: string[];
+};

package/dist/commands/status.d.ts

@@ -0,0 +1,5 @@
+import type { OrmCliConfig } from '../types.js';
+/**
+ * List applied and pending migrations in a two-column display.
+ */
+export declare function status(config: OrmCliConfig, flags: Record<string, string | true>): Promise<void>;

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import type { OrmCliConfig } from './types.js';
+/**
+ * Load and validate a CLI config file.
+ *
+ * Resolution order:
+ * 1. Explicit `configPath` argument (relative to `process.cwd()`).
+ * 2. `db.config.ts`, `db.config.js`, `db.config.mjs` in `process.cwd()`.
+ *
+ * The file must export a default {@link OrmCliConfig} object (or use the
+ * {@link defineConfig} helper).  TypeScript files work because the tsx ESM
+ * hook was registered in `bin.ts` before this module is imported.
+ */
+export declare function loadConfig(configPath?: string): Promise<OrmCliConfig>;

package/dist/generate-CMLVA6DT.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+// src/commands/generate.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+import {
+  generateMigrationsForContext,
+  loadSnapshot,
+  writeSnapshot
+} from "@cleverbrush/knex-schema";
+async function generate(name, config, flags) {
+  const dir = flags["--dir"] ?? config.migrations.directory;
+  const absDir = path.resolve(process.cwd(), dir);
+  const snapshotPath = config.migrations.snapshot ?? path.join(absDir, "snapshot.json");
+  const absSnapshotPath = path.resolve(process.cwd(), snapshotPath);
+  const entities = Object.values(config.entities);
+  const prevSnapshot = loadSnapshot(absSnapshotPath);
+  const result = generateMigrationsForContext(entities, prevSnapshot);
+  if (result.isEmpty) {
+    console.log("No schema changes detected.");
+    return;
+  }
+  mkdirSync(absDir, { recursive: true });
+  const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
+  const safeName = name.replace(/[^a-z0-9_]/gi, "_");
+  const filename = `${timestamp}_${safeName}.ts`;
+  const filepath = path.join(absDir, filename);
+  writeFileSync(filepath, result.full, "utf-8");
+  console.log(`Created migration: ${filepath}`);
+  writeSnapshot(absSnapshotPath, result.nextSnapshot);
+  console.log(`Updated snapshot: ${absSnapshotPath}`);
+}
+function formatTimestamp(d) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+export {
+  generate
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { MigrationsConfig, OrmCliConfig } from './types.js';
+export { defineConfig } from './types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+// src/types.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig
+};

package/dist/push-SNCDOATW.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+// src/commands/push.ts
+import path from "path";
+import readline from "readline";
+import {
+  applyDiff,
+  diffSchema,
+  entitiesToSnapshot,
+  generateCreateTable,
+  getPolymorphicVariantSchemas,
+  getTableName,
+  introspectDatabase,
+  isDiffEmpty,
+  tableExistsInDb,
+  writeSnapshot
+} from "@cleverbrush/knex-schema";
+async function push(config, flags) {
+  const isProduction = process.env.NODE_ENV === "production";
+  const confirmed = flags["--yes"] === true;
+  if (isProduction && !confirmed) {
+    console.error(
+      "\nError: `db push` is not allowed in NODE_ENV=production without the --yes flag.\n"
+    );
+    process.exit(1);
+  }
+  if (!confirmed) {
+    const answer = await prompt(
+      "\nThis will apply schema changes directly to the database (no migration file will be created).\nContinue? [y/N] "
+    );
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const tableEntries = [];
+  for (const entity of Object.values(config.entities)) {
+    const schema = entity.schema;
+    const tableName = getTableName(schema);
+    tableEntries.push({ schema, tableName });
+    for (const vs of getPolymorphicVariantSchemas(schema)) {
+      const vt = vs.getExtension("tableName");
+      if (vt) tableEntries.push({ schema: vs, tableName: vt });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = tableEntries.filter((e) => {
+    if (seen.has(e.tableName)) return false;
+    seen.add(e.tableName);
+    return true;
+  });
+  await config.knex.transaction(async (trx) => {
+    let changed = 0;
+    for (const { schema, tableName } of unique) {
+      const exists = await tableExistsInDb(trx, tableName);
+      if (!exists) {
+        await generateCreateTable(schema)(trx);
+        console.log(`  + Created table: ${tableName}`);
+        changed++;
+      } else {
+        const dbState = await introspectDatabase(trx, tableName);
+        const diff = diffSchema(schema, dbState);
+        if (!isDiffEmpty(diff)) {
+          await applyDiff(trx, diff, tableName);
+          console.log(`  ~ Altered table: ${tableName}`);
+          changed++;
+        }
+      }
+    }
+    if (changed === 0) {
+      console.log("No schema changes detected.");
+    } else {
+      console.log(`
+Applied ${changed} table change(s).`);
+    }
+  });
+  const dir = config.migrations.directory;
+  const absDir = path.resolve(process.cwd(), dir);
+  const snapshotPath = config.migrations.snapshot ?? path.join(absDir, "snapshot.json");
+  const absSnapshotPath = path.resolve(process.cwd(), snapshotPath);
+  writeSnapshot(
+    absSnapshotPath,
+    entitiesToSnapshot(Object.values(config.entities))
+  );
+  console.log(`Updated snapshot: ${absSnapshotPath}`);
+}
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+export {
+  push
+};

package/dist/rollback-AVV6DTXF.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import {
+  buildMigrationConfig
+} from "./chunk-E43XQHR3.js";
+
+// src/commands/rollback.ts
+async function rollback(config, flags) {
+  const migrationConfig = buildMigrationConfig(config, flags);
+  const all = flags["--all"] === true;
+  const [batchNo, reverted] = await config.knex.migrate.rollback(
+    migrationConfig,
+    all
+  );
+  if (reverted.length === 0) {
+    console.log("Nothing to roll back.");
+  } else {
+    console.log(
+      `Batch ${batchNo} rolled back. Reverted ${reverted.length} migration(s):`
+    );
+    for (const m of reverted) console.log(`  \u2717 ${m}`);
+  }
+}
+export {
+  rollback
+};

package/dist/run-PSIPMF6V.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  buildMigrationConfig,
+  run
+} from "./chunk-E43XQHR3.js";
+export {
+  buildMigrationConfig,
+  run
+};

package/dist/status-W3A6JWR3.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import {
+  buildMigrationConfig
+} from "./chunk-E43XQHR3.js";
+
+// src/commands/status.ts
+async function status(config, flags) {
+  const migrationConfig = buildMigrationConfig(config, flags);
+  const [completed, pending] = await config.knex.migrate.list(migrationConfig);
+  if (completed.length === 0 && pending.length === 0) {
+    console.log("No migrations found in the configured directory.");
+    return;
+  }
+  if (completed.length > 0) {
+    console.log("\nApplied migrations:");
+    for (const m of completed) {
+      const name = typeof m === "string" ? m : m.name ?? m.file ?? m;
+      console.log(`  \u2713 ${name}`);
+    }
+  }
+  if (pending.length > 0) {
+    console.log("\nPending migrations:");
+    for (const m of pending) {
+      const name = typeof m === "string" ? m : m.file ?? m.name ?? m;
+      console.log(`  \u25CB ${name}`);
+    }
+  } else {
+    console.log("\nDatabase is up to date.");
+  }
+}
+export {
+  status
+};

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { Entity } from '@cleverbrush/knex-schema';
+import type { Knex } from 'knex';
+/**
+ * Migration-runner configuration block inside {@link OrmCliConfig}.
+ */
+export interface MigrationsConfig {
+    /** Directory where migration files are read from / written to. */
+    directory: string;
+    /**
+     * Knex migration tracking table name.
+     * @defaultValue `'knex_migrations'`
+     */
+    tableName?: string;
+    /**
+     * Path to the schema snapshot file.  Must be committed to version control
+     * — it is the source of truth for `migrate generate`.
+     * @defaultValue `<directory>/snapshot.json`
+     */
+    snapshot?: string;
+}
+/**
+ * Shape of the default export expected in `db.config.ts`.
+ *
+ * @example
+ * ```ts
+ * // db.config.ts
+ * import { defineConfig } from '@cleverbrush/orm-cli';
+ * import knex from './src/db/knex.js';
+ * import { UserEntity, TodoEntity } from './src/db/schemas.js';
+ *
+ * export default defineConfig({
+ *     knex,
+ *     entities: { users: UserEntity, todos: TodoEntity },
+ *     migrations: { directory: './migrations' },
+ * });
+ * ```
+ */
+export interface OrmCliConfig {
+    /** A live Knex instance connected to your database. */
+    knex: Knex;
+    /**
+     * Map of entity name to `Entity` definition.  The same map you pass to
+     * `createDb()` from `@cleverbrush/orm`.
+     */
+    entities: Record<string, Entity<any, any>>;
+    /** Migration configuration. */
+    migrations: MigrationsConfig;
+}
+/**
+ * Identity helper that provides TypeScript autocompletion for `db.config.ts`.
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({ knex, entities, migrations });
+ * ```
+ */
+export declare function defineConfig(config: OrmCliConfig): OrmCliConfig;

package/package.json

@@ -0,0 +1,52 @@
+{
+    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
+    "bugs": {
+        "url": "https://github.com/cleverbrush/framework/issues",
+        "email": "andrew_zol@cleverbrush.com"
+    },
+    "bin": {
+        "cb-orm": "./dist/bin.js"
+    },
+    "dependencies": {
+        "@cleverbrush/knex-schema": "0.0.0-beta-20260424142030",
+        "tsx": "^4.19.0"
+    },
+    "peerDependencies": {
+        "knex": ">=3.1.0"
+    },
+    "description": "CLI for @cleverbrush/orm — migrate generate/run/rollback/status and db push",
+    "files": [
+        "dist"
+    ],
+    "homepage": "https://github.com/cleverbrush/framework/tree/master/libs/orm-cli#readme",
+    "keywords": [
+        "orm",
+        "knex",
+        "typescript",
+        "migrations",
+        "cli",
+        "cleverbrush"
+    ],
+    "license": "BSD 3-Clause",
+    "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "sideEffects": false,
+    "name": "@cleverbrush/orm-cli",
+    "readme": "https://github.com/cleverbrush/framework/tree/master/libs/orm-cli#readme",
+    "repository": {
+        "type": "git",
+        "url": "github:cleverbrush/framework"
+    },
+    "scripts": {
+        "build": "tsup && tsc --project tsconfig.build.json --emitDeclarationOnly",
+        "clean": "rm -rf dist tsconfig.build.tsbuildinfo"
+    },
+    "type": "module",
+    "types": "./dist/index.d.ts",
+    "version": "0.0.0-beta-20260424142030"
+}