@spinajs/orm-cli 2.0.487

package/README.md

@@ -0,0 +1,247 @@
+# @spinajs/orm-cli
+
+Command line front end for spinajs ORM migrations. Five commands — apply, roll back, report,
+force a state, scaffold — over the `orm.Migration` facade in `@spinajs/orm`.
+
+The package is a thin wrapper on purpose. Everything that decides what a migration run means
+lives in `@spinajs/orm`; what lives here is the argument handling, the operator-facing wording
+and the exit codes. The dependency runs one way only — `orm-cli` → `orm` — so the ORM stays
+usable, and testable, with no CLI in its dependency tree.
+
+## Install
+
+```bash
+npm i @spinajs/orm-cli
+```
+
+The package ships a config fragment that appends its own command directory to
+`system.dirs.cli`, which is where `@spinajs/cli` looks for commands. Installing it is therefore
+enough — `spinajs migrate-status` works with no import and no wiring on your side. If your
+application builds its own command list instead, `import '@spinajs/orm-cli'` is all that is
+needed: `@Command` registers each class in DI the moment the module is evaluated.
+
+The commands are also plain DI classes, so a script can drive them without commander:
+
+```ts
+import { DI } from '@spinajs/di';
+import { MigrateStatusCommand } from '@spinajs/orm-cli';
+
+await (await DI.resolve(MigrateStatusCommand)).execute();
+```
+
+## Running a command never migrates anything
+
+Every command starts by resolving an `Orm`, and an ordinary `DI.resolve(Orm)` ends with the boot
+migration pass — every pending migration on every connection whose `Migration.OnStartup` is on.
+For an application that is the point. For a migration tool it is a trap, twice over:
+
+- a connection holding a **failed** migration refuses every migration run, so the resolve throws
+  before the command body starts. That took down every command on the row it was invoked about,
+  including `migrate-resolve` — the one command that clears it, and the one the refusal names as
+  the remedy.
+- `migrate-status` would apply everything pending and only then report, so the deploy gate asking
+  "is this database current?" made it current, answered "yes" and exited `0`, with the DDL it was
+  meant to hold back already run.
+
+So the commands resolve their Orm through `resolveCliOrm()`, which passes `MigrateOnStartup:
+false` (an `IOrmOptions` field of `@spinajs/orm`). Everything else about resolving happens —
+connections, models, value converters, `orm.Migration` — only the boot pass is skipped. It is
+opt-**in**: nothing changes for an application that resolves an Orm the ordinary way, and this
+package ships no configuration that would switch startup migrations off for anybody.
+
+Two consequences worth knowing:
+
+- `migrate-up --fake` means what it says on a `Migration.OnStartup` connection. A boot pass would
+  have really applied the migrations the flag promises only to record.
+- **A migration applied by the CLI never gets its `data()` hook.** Seeding belongs to the boot
+  pass: `Orm.resolve()` seeds what its own startup run applied, and a later boot finds the
+  migration already applied and seeds nothing. That was already true of every connection with
+  `Migration.OnStartup` off; it is now true of all of them. Migrations that must be seeded have to
+  be applied by an application boot, not by `migrate-up`.
+
+## Commands
+
+| Command | Options | Does |
+| --- | --- | --- |
+| `migrate-up` | `-n, --name [name]`, `-c, --connection [connection]`, `-f, --fake` | Applies pending migrations on every configured connection |
+| `migrate-down` | `-n, --name [name]`, `-c, --connection [connection]`, `-a, --all`, `-f, --fake` | Rolls back — **the last applied batch only** unless `--all` |
+| `migrate-status` | — | Prints one line per migration per connection; the deploy gate |
+| `migrate-resolve` | `-n, --name [name]` (required), `--applied`, `--rolled-back` | Records the outcome of a FAILED migration |
+| `migrate-create` | `-n, --name [name]` (required), `-d, --dir [dir]`, `-c, --connection [connection]` | Scaffolds a migration file |
+
+### `migrate-up`
+
+```bash
+spinajs migrate-up
+spinajs migrate-up --name AddUserTable_2026_07_29_10_00_00
+spinajs migrate-up --connection reporting   # this connection only
+spinajs migrate-up --fake            # record as applied without running anything
+```
+
+Without `--name` it applies everything pending, in `(timestamp, name)` order, across every
+configured connection. With `--name` it applies exactly that one.
+
+`--connection` limits the run to one connection. Every other configured connection is left
+completely untouched — its migration service is never reached, so its tracking table is not even
+created. The name is matched against the configured connections (aliases included, since they
+resolve to the same connection), and one nothing answers to **throws** rather than running
+nothing: a filter that silently matched nothing would exit `0` reporting "0 migrations applied".
+
+Two named-run outcomes are deliberately **not** reported as success:
+
+- the name matches nothing in the registry — the facade throws rather than returning an empty
+  list, because "0 migrations applied" from a typo is indistinguishable from "already current";
+- the name is registered but the connection it declares is not configured in this deployment.
+  The facade only warns and returns `[]` there, so this command checks `status()` afterwards and
+  exits non-zero with an explanation.
+
+### `migrate-down`
+
+```bash
+spinajs migrate-down                 # the LAST APPLIED BATCH, not everything
+spinajs migrate-down --all           # every applied migration, on every connection
+spinajs migrate-down --name AddUserTable_2026_07_29_10_00_00
+spinajs migrate-down --connection reporting --all   # everything, on one connection
+```
+
+The default scope is the last applied batch — one `migrate-up` run undone, not the whole
+history. `--all` reverses everything. `--connection` narrows whichever of those two applies, and
+is announced first for that reason: `--all --connection reporting` is "every applied migration on
+*one* connection". The command says which scope it is about to reverse *before* it does it,
+because by the time the result line prints, the schema has already changed.
+
+A rollback drops the tracking row rather than stamping it "rolled back": the table is meant to
+hold only migrations that are actually present in the database, and both a missing row and a
+rolled-back one read as pending to the next `migrate-up`.
+
+`--name` has a known sharp edge in the migration service: it is handed a one-element unit list,
+so every *other* applied row in the target batch looks unmatched and gets warned about as
+"no registered migration matches them (file deleted or renamed)". Those rows are healthy, and
+the remedy that warning suggests — removing the row by hand — is destructive here. This command
+prints a line saying exactly that before the run, so the warnings can be ignored.
+
+### `migrate-status`
+
+```bash
+spinajs migrate-status
+```
+
+```
+   STATE         BATCH  CONNECTION       MIGRATION
+   applied           1  default          AddUserTable_2026_07_29_10_00_00
+!! FAILED            0  default          AddOrderIndex_2026_07_29_11_00_00
+?? INTERRUPTED       0  default          BackfillTotals_2026_07_29_12_00_00
+   pending           -  default          AddInvoices_2026_07_30_09_00_00
+```
+
+Output goes to stdout via `console.log`, not through the framework logger: it is this command's
+*product*, something an operator greps and a script pipes, and routing it through the log would
+let a configured level or target swallow it.
+
+A failed row carries `!!` in the leftmost column, not just the word `FAILED`. That row is the
+one line in the report that stops every later `migrate-up` on its connection, and it has to
+survive being skimmed in a wall of `applied`. Below the table the command prints the two exact
+`migrate-resolve` invocations for each failed migration.
+
+`??` marks an **interrupted** migration — one that was started and never finished, because the
+process running it was killed before it could record either outcome. It carries the opposite
+warning to `FAILED`: it blocks nothing, and the next `migrate-up` re-runs it from the top, whether
+or not anybody looked. Under the default `Transaction.Mode: None` that means non-idempotent data
+changes get applied twice, silently. The same two `migrate-resolve` invocations are printed for
+it. See "Interrupted runs" in
+[the ORM migration docs](../orm/docs/10-schema-and-migrations.md#interrupted-runs).
+
+`[checksum mismatch]` marks a migration whose source changed after it was applied. It is
+reported but does **not** on its own make the command exit non-zero — only pending and failed
+work do.
+
+### `migrate-resolve`
+
+The escape hatch for a run that died halfway. Valid on the two row shapes whose real outcome
+nobody recorded — **failed** (`FinishedAt` NULL and `Logs` set) and **interrupted** (`StartedAt`
+set, `FinishedAt` and `Logs` both NULL). Anything healthy, rolled back or absent is refused rather
+than silently rewritten.
+
+```bash
+spinajs migrate-resolve --name AddOrderIndex_2026_07_29_11_00_00 --applied      # the change IS in the database
+spinajs migrate-resolve --name AddOrderIndex_2026_07_29_11_00_00 --rolled-back  # the change is NOT
+```
+
+Exactly one of the two flags, never both and never neither: the point of the command is to state
+which of the two things actually happened, and neither the CLI nor the ORM can find that out on
+its own. The refusal happens before any Orm is resolved, so a malformed command line never opens
+a database connection.
+
+`--rolled-back` makes the migration pending again — it *will* run on the next `migrate-up`.
+
+### `migrate-create`
+
+```bash
+spinajs migrate-create --name AddInvoices
+spinajs migrate-create --name AddInvoices --dir ./src/migrations --connection reporting
+```
+
+Prints the path it wrote, on its own line, so `$(spinajs migrate-create -n AddInvoices)` is
+usable. Defaults: `./src/migrations` and the `default` connection.
+
+`--name` takes the *prefix* only, letters and digits, starting with a letter. The
+`_yyyy_MM_dd_HH_mm_ss` suffix is appended here, and it is not decoration: that timestamp is the
+only ordering the migration runner has, and it is read back out of the class name. A name the
+runner cannot parse is refused up front, and an existing file is never overwritten.
+
+The generated class only takes effect once it is *imported* — the `@Migration` decorator has to
+run to register it. Re-export it from your package or application index, the way `src/migrations/*.ts`
+files are re-exported elsewhere in spinajs.
+
+## Exit codes
+
+| Command | `0` | non-zero |
+| --- | --- | --- |
+| `migrate-up` | migrations applied, or nothing was pending | a named run applied nothing because its connection is not configured, or it is still pending/failed; a `--connection` nothing answers to; any error from the run |
+| `migrate-down` | rollback completed, or nothing to roll back | a `--connection` nothing answers to; any error from the run |
+| `migrate-status` | every migration is applied | anything is pending or failed |
+| `migrate-resolve` | the state was recorded | both/neither flag given; the row is neither failed nor interrupted |
+| `migrate-create` | file written | invalid name or connection; the file already exists |
+
+`migrate-status` is meant to be a deploy gate — "is this database current?" — so an un-run
+migration is a "no", not just a failed one.
+
+Two things the table does not say:
+
+- **A `0` from `migrate-status` means "nothing is pending", not "the database is reachable and
+  configured".** With no connections configured, nothing is registered, so nothing is pending and
+  the command exits `0`. A gate that must also catch a failed config should check that the command
+  reported migrations at all.
+- **Requires a `@spinajs/cli` that propagates `process.exitCode`.** Earlier versions ended the
+  bin's success path with a bare `process.exit(0)`, which discards whatever a command set — driven
+  through such a bin, `migrate-status` exits `0` even with pending work. If you are pinned to one,
+  call the command class directly (see the snippet at the top) rather than going through the bin.
+
+## The blocking guarantee is best-effort
+
+A failed migration blocks every later `migrate-up` on its connection. That is what makes
+`migrate-status` + `migrate-resolve` a safe recovery loop instead of a suggestion: a half-applied
+schema change cannot be built on top of.
+
+The guarantee holds only as far as the bookkeeping does. When a migration fails, the ORM writes
+the failure into the tracking table — and if *that* write fails too (the connection dropped, the
+table is locked), the error is caught and logged rather than raised. The run still fails, but the
+row that would have blocked the next `migrate-up` was never written, and the next run proceeds as
+if nothing had happened.
+
+In practice this needs the database to fail twice, in a specific order. It matters when you are
+reading logs after an incident: a `migrate-up` that succeeded shortly after a failed one is not
+by itself proof that the failure was resolved. Check `migrate-status`.
+
+## Notes
+
+- Migrations run against a schema no model is wired to yet. Use the `OrmDriver` passed to `up()`,
+  never a model class. The `data()` hook runs later, once models are available.
+- `--fake` records the outcome without executing anything, on both `migrate-up` and
+  `migrate-down`. It is for a database that was changed out of band and needs the tracking table
+  brought in line.
+- `migrate-status` reports every configured connection, including ones whose
+  `Migration.OnStartup` is off — hiding those would answer "nothing to see" for exactly the
+  connections somebody is most likely asking about. It has no `--connection` of its own, for the
+  same reason: the report is the deploy gate, and a gate that can be narrowed is a gate that can
+  be talked past.

package/lib/cjs/cli/MigrateCreate.d.ts

@@ -0,0 +1,59 @@
+import { CliCommand } from '@spinajs/cli';
+import { Log } from '@spinajs/log-common';
+export interface IMigrateCreateCommandOptions {
+    name: string;
+    dir?: string;
+    connection?: string;
+    env?: string;
+}
+/**
+ * The prefix half of `Prefix_yyyy_MM_dd_HH_mm_ss`. Deliberately narrower than what a TS class
+ * name allows: underscores and digits are how the runner finds the timestamp - `MIGRATION_FILE_REGEXP`
+ * splits on the LAST `_yyyy_MM_dd_HH_mm_ss`-shaped run - so a prefix that carries its own
+ * underscore-digit groups is a name nobody can read back with confidence.
+ */
+export declare const MIGRATION_NAME_REGEXP: RegExp;
+/**
+ * The connection name is interpolated into `@Migration('...')`, so anything that could close that
+ * string literal has to be refused here rather than emitted into a file that will not parse.
+ */
+export declare const CONNECTION_NAME_REGEXP: RegExp;
+/**
+ * The env tag becomes a dot-segment in the file name AND a string literal inside `@Migration()`,
+ * so it may carry neither a dot ( which would read as a second tag ) nor anything that could close
+ * that literal.
+ */
+export declare const ENV_NAME_REGEXP: RegExp;
+/**
+ * Reads `--env` directly off `process.argv`, deliberately more flexible than `Configuration`'s own
+ * `parseArgv` ( `packages/configuration/src/util.ts` - not exported from that package's public surface,
+ * so this logic is duplicated rather than imported ).
+ *
+ * `parseArgv` handles only the space-separated form ( `--env local` ), but this helper also accepts
+ * the equals form ( `--env=local` ). This is correct here: `packages/cli/src/args.ts` strips both
+ * forms from commander's argv, because `Configuration` consumes the framework-level `--env` directly.
+ * With `--env=local`, the value is stripped but `Configuration`'s `parseArgv` cannot recognize the
+ * equals form, so the CLI process boots under the default environment while the scaffolded file gets
+ * its `.local` suffix — harmless for this command, which uses the value only as a filename tag and
+ * a decorator string. `-e` is untouched by the strip and reaches commander normally, so it needs no
+ * duplicate handling here.
+ */
+export declare function parseEnvArgv(argv?: string[]): string | undefined;
+export declare const DEFAULT_MIGRATION_DIR = "./src/migrations";
+export declare const DEFAULT_MIGRATION_CONNECTION = "default";
+/**
+ * The scaffold. `connection` is named ( rather than `_connection` ) in both hooks because both
+ * bodies are meant to be filled in immediately - and the eslint pragma on the first line is the
+ * repo's own convention for a migration whose `down()` legitimately ignores it.
+ */
+export declare function migrationTemplate(cls: string, connection: string, env?: string): string;
+/**
+ * The one command here that needs no database and no Orm: it writes a file. Keeping it free of
+ * `DI.resolve(Orm)` means a developer can scaffold a migration in a checkout whose connections
+ * are not configured, or not reachable, which is exactly when new migrations get written.
+ */
+export declare class MigrateCreateCommand extends CliCommand {
+    protected Log: Log;
+    execute(options: IMigrateCreateCommandOptions): Promise<void>;
+}
+//# sourceMappingURL=MigrateCreate.d.ts.map

package/lib/cjs/cli/MigrateCreate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateCreate.d.ts","sourceRoot":"","sources":["../../../src/cli/MigrateCreate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAC;AAE3D,OAAO,EAAE,GAAG,EAAU,MAAM,qBAAqB,CAAC;AAKlD,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAA2B,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAAiC,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAA4B,CAAC;AAYzD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,MAAM,GAAG,SAAS,CAc9E;AAED,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD,eAAO,MAAM,4BAA4B,YAAY,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CA0BvF;AAED;;;;GAIG;AACH,qBAKa,oBAAqB,SAAQ,UAAU;IAElD,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC;IAEN,OAAO,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,IAAI,CAAC;CA6D3E"}

package/lib/cjs/cli/MigrateCreate.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateCreateCommand = exports.DEFAULT_MIGRATION_CONNECTION = exports.DEFAULT_MIGRATION_DIR = exports.ENV_NAME_REGEXP = exports.CONNECTION_NAME_REGEXP = exports.MIGRATION_NAME_REGEXP = void 0;
+exports.parseEnvArgv = parseEnvArgv;
+exports.migrationTemplate = migrationTemplate;
+const cli_1 = require("@spinajs/cli");
+const exceptions_1 = require("@spinajs/exceptions");
+const log_common_1 = require("@spinajs/log-common");
+const luxon_1 = require("luxon");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * The prefix half of `Prefix_yyyy_MM_dd_HH_mm_ss`. Deliberately narrower than what a TS class
+ * name allows: underscores and digits are how the runner finds the timestamp - `MIGRATION_FILE_REGEXP`
+ * splits on the LAST `_yyyy_MM_dd_HH_mm_ss`-shaped run - so a prefix that carries its own
+ * underscore-digit groups is a name nobody can read back with confidence.
+ */
+exports.MIGRATION_NAME_REGEXP = /^[A-Za-z][A-Za-z0-9]*$/;
+/**
+ * The connection name is interpolated into `@Migration('...')`, so anything that could close that
+ * string literal has to be refused here rather than emitted into a file that will not parse.
+ */
+exports.CONNECTION_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+/**
+ * The env tag becomes a dot-segment in the file name AND a string literal inside `@Migration()`,
+ * so it may carry neither a dot ( which would read as a second tag ) nor anything that could close
+ * that literal.
+ */
+exports.ENV_NAME_REGEXP = /^[A-Za-z][A-Za-z0-9-]*$/;
+/**
+ * The three middle segments `parseMigrationFileEnv` provably cannot read back as an environment
+ * tag - they are carved out by name there ( a test suite named after its migration, a TypeScript
+ * declaration file ), not because they collide with a real tag but because a `<Name>.<tag>.ts` file
+ * whose tag is one of these is never read as tagged at all. `--env test` would therefore write a
+ * file whose suffix channel is silently dead - and one many projects' `**\/*.test.ts` globs would
+ * try to execute as a test suite besides. Refused here rather than left to surprise someone later.
+ */
+const RESERVED_ENV_NAMES = ['test', 'spec', 'd'];
+/**
+ * Reads `--env` directly off `process.argv`, deliberately more flexible than `Configuration`'s own
+ * `parseArgv` ( `packages/configuration/src/util.ts` - not exported from that package's public surface,
+ * so this logic is duplicated rather than imported ).
+ *
+ * `parseArgv` handles only the space-separated form ( `--env local` ), but this helper also accepts
+ * the equals form ( `--env=local` ). This is correct here: `packages/cli/src/args.ts` strips both
+ * forms from commander's argv, because `Configuration` consumes the framework-level `--env` directly.
+ * With `--env=local`, the value is stripped but `Configuration`'s `parseArgv` cannot recognize the
+ * equals form, so the CLI process boots under the default environment while the scaffolded file gets
+ * its `.local` suffix — harmless for this command, which uses the value only as a filename tag and
+ * a decorator string. `-e` is untouched by the strip and reaches commander normally, so it needs no
+ * duplicate handling here.
+ */
+function parseEnvArgv(argv = process.argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--env') {
+            return argv[i + 1];
+        }
+        if (arg.startsWith('--env=')) {
+            return arg.slice('--env='.length);
+        }
+    }
+    return undefined;
+}
+exports.DEFAULT_MIGRATION_DIR = './src/migrations';
+exports.DEFAULT_MIGRATION_CONNECTION = 'default';
+/**
+ * The scaffold. `connection` is named ( rather than `_connection` ) in both hooks because both
+ * bodies are meant to be filled in immediately - and the eslint pragma on the first line is the
+ * repo's own convention for a migration whose `down()` legitimately ignores it.
+ */
+function migrationTemplate(cls, connection, env) {
+    return `/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Migration, OrmDriver, OrmMigration } from '@spinajs/orm';
+
+/**
+ * TODO: describe the schema change this migration makes.
+ */
+@Migration('${connection}'${env ? `, { Env: '${env}' }` : ''})
+export class ${cls} extends OrmMigration {
+  /**
+   * Schema changes. Models are NOT wired up yet at this point - reach the database through
+   * \`connection\`, never through a model class.
+   */
+  public async up(connection: OrmDriver): Promise<void> {
+    // TODO: await connection.schema().createTable('table_name', (table) => { ... });
+  }
+
+  /**
+   * Undoes \`up()\`. Leave it empty only when the change genuinely cannot be reversed - an empty
+   * \`down()\` makes migrate-down report success while changing nothing.
+   */
+  public async down(connection: OrmDriver): Promise<void> {
+    // TODO: await connection.schema().dropTable('table_name');
+  }
+}
+`;
+}
+/**
+ * The one command here that needs no database and no Orm: it writes a file. Keeping it free of
+ * `DI.resolve(Orm)` means a developer can scaffold a migration in a checkout whose connections
+ * are not configured, or not reachable, which is exactly when new migrations get written.
+ */
+let MigrateCreateCommand = class MigrateCreateCommand extends cli_1.CliCommand {
+    async execute(options) {
+        const name = options.name ?? '';
+        const connection = options.connection ?? exports.DEFAULT_MIGRATION_CONNECTION;
+        // An explicit `options.env` wins - that is how the tests in this suite call `execute()`
+        // directly - and falls back to a direct argv read for the real CLI path, where
+        // `packages/cli/src/args.ts` has already stripped `--env <value>` out of what commander sees.
+        // See `parseEnvArgv()`.
+        const env = options.env ?? parseEnvArgv();
+        if (!exports.MIGRATION_NAME_REGEXP.test(name)) {
+            throw new exceptions_1.InvalidArgument(`Invalid migration name "${name}" - it must be a plain class-name prefix: a letter followed by letters or digits, no spaces, dashes or underscores. The _yyyy_MM_dd_HH_mm_ss suffix is appended here.`);
+        }
+        if (!exports.CONNECTION_NAME_REGEXP.test(connection)) {
+            throw new exceptions_1.InvalidArgument(`Invalid connection name "${connection}" - expected the name of a connection from db.Connections, eg. "default"`);
+        }
+        if (env !== undefined) {
+            if (!exports.ENV_NAME_REGEXP.test(env)) {
+                throw new exceptions_1.InvalidArgument(`Invalid environment name "${env}" - a letter followed by letters, digits or dashes. It becomes both a file suffix and a string inside @Migration().`);
+            }
+            if (RESERVED_ENV_NAMES.includes(env)) {
+                throw new exceptions_1.InvalidArgument(`Invalid environment name "${env}" - "test", "spec" and "d" are carved out by the migration file parser as file-kind markers (a test suite, a TypeScript declaration file), never read back as an environment tag. Choose a different name.`);
+            }
+        }
+        // The timestamp is not decoration: it is the ONLY ordering the migration runner has, and it is
+        // read back out of the class name rather than out of the file's mtime or its position on disk.
+        const cls = `${name}_${luxon_1.DateTime.now().toFormat('yyyy_MM_dd_HH_mm_ss')}`;
+        const dir = options.dir ?? exports.DEFAULT_MIGRATION_DIR;
+        const file = path.join(dir, `${cls}${env ? `.${env}` : ''}.ts`);
+        fs.mkdirSync(dir, { recursive: true });
+        try {
+            // 'wx' - never clobber. Two `migrate-create` runs inside the same second produce the same
+            // class name, and silently overwriting the first one would delete work that was just written.
+            fs.writeFileSync(file, migrationTemplate(cls, connection, env), { flag: 'wx', encoding: 'utf-8' });
+        }
+        catch (err) {
+            if (err.code === 'EEXIST') {
+                throw new exceptions_1.IOFail(`Migration file ${file} already exists - a migration with this name was created in the same second. Wait a second and run it again, or pass a different --name.`, err);
+            }
+            throw err;
+        }
+        // The path goes to stdout on its own line so `$(spinajs migrate-create -n Foo)` is usable;
+        // everything else is guidance and belongs in the log.
+        // eslint-disable-next-line no-console
+        console.log(file);
+        // The scan is about the APPLICATION's own directories ( `system.dirs.migrations`, resolved
+        // against ITS cwd at runtime ) - not about where this file happened to be scaffolded. Scaffold
+        // it inside a package under `<pkg>/src/migrations` and it sits in a directory this same list
+        // would scan too, but only when the consumer boots FROM that package's own cwd, which almost
+        // never happens: the running process's cwd is the application, not any of its dependencies. A
+        // package's migrations must always be re-exported from its own index, or they never run.
+        this.Log.info(`Created migration ${cls} for connection "${connection}"${env ? ` in environment "${env}"` : ''}. A file under the application's own system.dirs.migrations is discovered automatically. Inside a package, always re-export it from the package's index - a package's own directories are never scanned at a consumer's runtime - so the @Migration decorator runs and registers it.`);
+    }
+};
+exports.MigrateCreateCommand = MigrateCreateCommand;
+__decorate([
+    (0, log_common_1.Logger)('ORM-CLI'),
+    __metadata("design:type", log_common_1.Log)
+], MigrateCreateCommand.prototype, "Log", void 0);
+exports.MigrateCreateCommand = MigrateCreateCommand = __decorate([
+    (0, cli_1.Command)('migrate-create', 'Scaffolds a new migration file'),
+    (0, cli_1.Option)('-n, --name [name]', true, 'migration name prefix - a plain class-name prefix, letters and digits only'),
+    (0, cli_1.Option)('-d, --dir [dir]', false, `target directory, default ${exports.DEFAULT_MIGRATION_DIR}`),
+    (0, cli_1.Option)('-c, --connection [connection]', false, `connection the migration runs on, default "${exports.DEFAULT_MIGRATION_CONNECTION}"`),
+    (0, cli_1.Option)('-e, --env [env]', false, 'environment this migration belongs to, eg. local - omit to run it in every environment')
+], MigrateCreateCommand);
+//# sourceMappingURL=MigrateCreate.js.map

package/lib/cjs/cli/MigrateCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateCreate.js","sourceRoot":"","sources":["../../../src/cli/MigrateCreate.ts"],"names":[],"mappings":"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"}

package/lib/cjs/cli/MigrateDown.d.ts

@@ -0,0 +1,23 @@
+import { CliCommand } from '@spinajs/cli';
+import { Log } from '@spinajs/log-common';
+export interface IMigrateDownCommandOptions {
+    name?: string;
+    all?: boolean;
+    fake?: boolean;
+    connection?: string;
+}
+/**
+ * The description says LAST BATCH out loud, and so does the pre-run line below: `down()` defaults
+ * to the last applied batch, not to everything, and an operator who assumed otherwise would read
+ * a short "rolled back 1 migration" as a complete teardown.
+ */
+export declare class MigrateDownCommand extends CliCommand {
+    protected Log: Log;
+    execute(options: IMigrateDownCommandOptions): Promise<void>;
+    /**
+     * Says what scope is about to be reversed BEFORE it is reversed, because by the time the result
+     * line is printed the schema change has already happened.
+     */
+    protected announce(options: IMigrateDownCommandOptions): void;
+}
+//# sourceMappingURL=MigrateDown.d.ts.map

package/lib/cjs/cli/MigrateDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateDown.d.ts","sourceRoot":"","sources":["../../../src/cli/MigrateDown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAU,MAAM,qBAAqB,CAAC;AAGlD,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,qBAKa,kBAAmB,SAAQ,UAAU;IAEhD,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC;IAEN,OAAO,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxE;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;CAwB9D"}

package/lib/cjs/cli/MigrateDown.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateDownCommand = void 0;
+const cli_1 = require("@spinajs/cli");
+const log_common_1 = require("@spinajs/log-common");
+const orm_js_1 = require("../orm.js");
+/**
+ * The description says LAST BATCH out loud, and so does the pre-run line below: `down()` defaults
+ * to the last applied batch, not to everything, and an operator who assumed otherwise would read
+ * a short "rolled back 1 migration" as a complete teardown.
+ */
+let MigrateDownCommand = class MigrateDownCommand extends cli_1.CliCommand {
+    async execute(options) {
+        // Not `DI.resolve(Orm)`: a boot migration pass would apply the pending migrations on every
+        // `Migration.OnStartup` connection and this command would then roll back the batch it had
+        // just created. See `resolveCliOrm`.
+        const orm = await (0, orm_js_1.resolveCliOrm)();
+        this.announce(options);
+        const executed = await orm.Migration.down(options.name, { all: options.all, fake: options.fake, connection: options.connection });
+        if (executed.length === 0) {
+            const scope = options.connection ? ` on connection ${options.connection}` : ' on any configured connection';
+            this.Log.info(options.name ? `Nothing rolled back - ${options.name} is not applied${scope}` : `Nothing to roll back - no applied migrations found${options.connection ? scope : ''}`);
+            return;
+        }
+        this.Log.success(`${options.fake ? 'Recorded as rolled back ( --fake, nothing was executed )' : 'Rolled back'} ${executed.length} migration(s): ${executed.map((m) => m.constructor.name).join(', ')}`);
+    }
+    /**
+     * Says what scope is about to be reversed BEFORE it is reversed, because by the time the result
+     * line is printed the schema change has already happened.
+     */
+    announce(options) {
+        // first, and separate from the three below: it narrows all of them, and an operator reading
+        // "rolling back EVERY applied migration" needs to know it means every one on ONE connection
+        if (options.connection) {
+            this.Log.info(`Limited to connection ${options.connection} - no other configured connection is touched`);
+        }
+        if (options.name) {
+            // A named rollback hands the migration service a one-element unit list, so every other
+            // applied row in the target batch looks unmatched to it and it warns about them. Those rows
+            // are healthy - only the warning is wrong - and the remedy it suggests is destructive if
+            // followed here, which is why this line says what to do with those warnings instead of
+            // leaving the operator to act on them.
+            this.Log.warn(`Rolling back a single migration: ${options.name}. The migration service may warn during this run that other migrations have no matching registered class - that is an artifact of a named rollback, those rows are fine. Do not edit or delete them.`);
+            return;
+        }
+        if (options.all) {
+            this.Log.warn('Rolling back EVERY applied migration on every configured connection ( --all )');
+            return;
+        }
+        this.Log.info('Rolling back the LAST APPLIED BATCH only - pass --all to reverse every applied migration');
+    }
+};
+exports.MigrateDownCommand = MigrateDownCommand;
+__decorate([
+    (0, log_common_1.Logger)('ORM-CLI'),
+    __metadata("design:type", log_common_1.Log)
+], MigrateDownCommand.prototype, "Log", void 0);
+exports.MigrateDownCommand = MigrateDownCommand = __decorate([
+    (0, cli_1.Command)('migrate-down', 'Rolls ORM migrations back - the LAST APPLIED BATCH only, unless --all is given'),
+    (0, cli_1.Option)('-n, --name [name]', false, 'roll back a single migration, by class name'),
+    (0, cli_1.Option)('-c, --connection [connection]', false, 'limit the rollback to one connection, by name'),
+    (0, cli_1.Option)('-a, --all', false, 'roll back EVERY applied migration, not just the last batch'),
+    (0, cli_1.Option)('-f, --fake', false, 'record the migrations as rolled back without executing them')
+], MigrateDownCommand);
+//# sourceMappingURL=MigrateDown.js.map

package/lib/cjs/cli/MigrateDown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateDown.js","sourceRoot":"","sources":["../../../src/cli/MigrateDown.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,sCAA2D;AAC3D,oDAAkD;AAClD,sCAA0C;AAS1C;;;;GAIG;AAMI,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,gBAAU;IAIzC,KAAK,CAAC,OAAO,CAAC,OAAmC;QACtD,2FAA2F;QAC3F,0FAA0F;QAC1F,qCAAqC;QACrC,MAAM,GAAG,GAAG,MAAM,IAAA,sBAAa,GAAE,CAAC;QAElC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEvB,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAElI,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,kBAAkB,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,+BAA+B,CAAC;YAE5G,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,yBAAyB,OAAO,CAAC,IAAI,kBAAkB,KAAK,EAAE,CAAC,CAAC,CAAC,qDAAqD,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACtL,OAAO;QACT,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,0DAA0D,CAAC,CAAC,CAAC,aAAa,IAAI,QAAQ,CAAC,MAAM,kBAAkB,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1M,CAAC;IAED;;;OAGG;IACO,QAAQ,CAAC,OAAmC;QACpD,4FAA4F;QAC5F,4FAA4F;QAC5F,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,yBAAyB,OAAO,CAAC,UAAU,8CAA8C,CAAC,CAAC;QAC3G,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACjB,uFAAuF;YACvF,4FAA4F;YAC5F,yFAAyF;YACzF,uFAAuF;YACvF,uCAAuC;YACvC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,oCAAoC,OAAO,CAAC,IAAI,sMAAsM,CAAC,CAAC;YACtQ,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;YAChB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,+EAA+E,CAAC,CAAC;YAC/F,OAAO;QACT,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,0FAA0F,CAAC,CAAC;IAC5G,CAAC;CACF,CAAA;AApDY,gDAAkB;AAEnB;IADT,IAAA,mBAAM,EAAC,SAAS,CAAC;8BACH,gBAAG;+CAAC;6BAFR,kBAAkB;IAL9B,IAAA,aAAO,EAAC,cAAc,EAAE,gFAAgF,CAAC;IACzG,IAAA,YAAM,EAAC,mBAAmB,EAAE,KAAK,EAAE,6CAA6C,CAAC;IACjF,IAAA,YAAM,EAAC,+BAA+B,EAAE,KAAK,EAAE,+CAA+C,CAAC;IAC/F,IAAA,YAAM,EAAC,WAAW,EAAE,KAAK,EAAE,4DAA4D,CAAC;IACxF,IAAA,YAAM,EAAC,YAAY,EAAE,KAAK,EAAE,6DAA6D,CAAC;GAC9E,kBAAkB,CAoD9B"}