@happyvertical/smrt-cli 0.51.31 → 0.51.33

package/dist/commands/db-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-history.d.ts","sourceRoot":"","sources":["../../src/commands/db-history.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AA2DtD,eAAO,MAAM,gBAAgB,EAAE,UAgV9B,CAAC"}

package/dist/commands/db-materialize-tenant-hierarchy.d.ts

@@ -0,0 +1,12 @@
+import type { CLICommand } from '../cli-generator.js';
+/**
+ * `smrt db:materialize-tenant-hierarchy` (smrt#3036).
+ *
+ * Backfills `tenants.hierarchy_path` / `hierarchy_level` from each row's
+ * `parent_tenant_id` chain. `Tenant.save()` in `@happyvertical/smrt-users`
+ * now maintains both; this repairs rows written before it did, which left `inheritsToDescendants` and the declared ancestor-read
+ * policy failing closed. Idempotent; refuses (writing nothing) when any
+ * tenant's parent chain is broken.
+ */
+export declare const dbMaterializeTenantHierarchyCommand: CLICommand;
+//# sourceMappingURL=db-materialize-tenant-hierarchy.d.ts.map

package/dist/commands/db-materialize-tenant-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-materialize-tenant-hierarchy.d.ts","sourceRoot":"","sources":["../../src/commands/db-materialize-tenant-hierarchy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAYtD;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,EAAE,UAgGjD,CAAC"}

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

@@ -0,0 +1,338 @@
+/**
+ * Which column property an `alter_column` change repairs (mirrors
+ * `ColumnAlteration` in @happyvertical/smrt-core).
+ */
+export type ColumnAlterationLike = 'set_not_null' | 'drop_not_null' | 'set_default' | 'drop_default';
+/**
+ * Report-only detail attached to a change the differ surfaces but does not
+ * execute (mirrors `SchemaChangeAdvisory` in @happyvertical/smrt-core).
+ */
+export interface SchemaChangeAdvisoryLike {
+    severity: 'warning' | 'info';
+    message: string;
+    suggestedSql?: string[];
+}
+/** Mirrors core's `ForeignKeyAction` (see `@happyvertical/smrt-core/schema`). */
+export type ForeignKeyActionLike = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+/**
+ * Local mirror of core's `ForeignKeyDefinition` — just enough shape for
+ * dependency analysis (#2748) and for rebuilding the `ADD CONSTRAINT`
+ * statements after an orphan-FK disposition repairs the blocking rows.
+ */
+export interface ForeignKeyDefinitionLike {
+    column: string;
+    referencesTable: string;
+    referencesColumn: string;
+    onDelete?: ForeignKeyActionLike;
+    onUpdate?: ForeignKeyActionLike;
+}
+export interface MigrationAction {
+    type: 'add_column' | 'drop_column' | 'alter_column' | 'add_foreign_key' | 'drop_foreign_key' | 'add_index' | 'drop_index' | 'type_mismatch' | 'type_upgrade';
+    tableName: string;
+    className: string;
+    column?: {
+        name: string;
+        type: string;
+        notNull?: boolean;
+        defaultValue?: unknown;
+        unique?: boolean;
+    };
+    index?: {
+        name: string;
+        columns: string[];
+        unique?: boolean;
+    };
+    /**
+     * Set on `drop_index` actions — the index name being dropped. We track
+     * this separately from `index` because the differ does not (and cannot,
+     * for the orphan-drop case) always know the original column list of a
+     * DB-side index that's being removed.
+     */
+    indexName?: string;
+    /**
+     * Set on `drop_column` / `alter_column` actions — the live column name.
+     * `column` is only populated when the differ had a manifest definition.
+     */
+    columnName?: string;
+    /** Set on `alter_column` actions (#2369). */
+    alteration?: ColumnAlterationLike;
+    /**
+     * Ordering phase carried through from `SchemaChange.phase` (#2608).
+     * `pre_foreign_key` marks the pre-R11 `text` -> `uuid` convergence, which
+     * must run before every `CREATE TABLE` (an acyclic new child keeps its
+     * foreign key inline) and before every foreign-key statement in the batch.
+     */
+    phase?: 'pre_foreign_key';
+    mismatch?: {
+        column: string;
+        expected: string;
+        actual: string;
+    };
+    sql?: string;
+    sqlStatements?: string[];
+    advisory?: SchemaChangeAdvisoryLike;
+    /** Set on `add_foreign_key` / `drop_foreign_key` actions (#2748). */
+    foreignKey?: ForeignKeyDefinitionLike;
+    /** See `SchemaChangeLike.orphanBlocked` (#2748). */
+    orphanBlocked?: boolean;
+    /** See `SchemaChangeLike.orphanNullable` (#2748). */
+    orphanNullable?: boolean;
+    /** See `SchemaChangeLike.engineUnsupported` (#2748). */
+    engineUnsupported?: boolean;
+}
+/**
+ * A change the differ reports but does not execute: orphan columns/indexes
+ * and relaxations not opted into (#2369). Surfaced by db:migrate/db:diff/
+ * db:status; never turned into a tracker migration.
+ */
+export interface SchemaAdvisory {
+    type: 'orphan_column' | 'orphan_index' | 'alter_column' | 'type_upgrade' | 'rename_data_pending';
+    tableName: string;
+    className: string;
+    name: string;
+    alteration?: ColumnAlterationLike;
+    actual?: string;
+    advisory: SchemaChangeAdvisoryLike;
+}
+export interface SchemaChangeLike {
+    type: 'add_table' | 'drop_table' | 'add_column' | 'drop_column' | 'alter_column' | 'orphan_column' | 'add_foreign_key' | 'drop_foreign_key' | 'add_index' | 'drop_index' | 'orphan_index' | 'type_mismatch' | 'type_upgrade' | 'rename_data_pending';
+    table: string;
+    name?: string;
+    column?: {
+        type: string;
+        notNull?: boolean;
+        defaultValue?: unknown;
+        unique?: boolean;
+    };
+    index?: {
+        name: string;
+        columns: string[];
+        unique?: boolean;
+    };
+    mismatch?: {
+        expected: string;
+        actual: string;
+    };
+    alteration?: ColumnAlterationLike;
+    /** See `MigrationAction.phase` (#2608). */
+    phase?: 'pre_foreign_key';
+    advisory?: SchemaChangeAdvisoryLike;
+    sql?: string;
+    sqlStatements?: string[];
+    /** Set on `add_foreign_key` / `drop_foreign_key` changes (#2748). */
+    foreignKey?: ForeignKeyDefinitionLike;
+    /**
+     * True on an advisory-only `add_foreign_key` change specifically blocked
+     * by live orphan child rows (#2748), as opposed to any other manual-repair
+     * reason. Mirrors core's `SchemaChange.orphanBlocked`.
+     */
+    orphanBlocked?: boolean;
+    /**
+     * Present alongside `orphanBlocked: true`: whether the child column
+     * allows NULL. Mirrors core's `SchemaChange.orphanNullable`.
+     */
+    orphanNullable?: boolean;
+    /**
+     * True on an advisory-only `add_foreign_key` change blocked because this
+     * engine cannot express the constraint at all (SQLite/DuckDB), as opposed
+     * to a data or type problem with the column itself. Mirrors core's
+     * `SchemaChange.engineUnsupported`.
+     */
+    engineUnsupported?: boolean;
+}
+/** True when a change carries an advisory and no executable statement. */
+export declare function isAdvisoryOnlyChangeLike(change: {
+    advisory?: SchemaChangeAdvisoryLike;
+    sql?: string;
+    sqlStatements?: string[];
+}): boolean;
+export type TypeUpgradeExecutionKind = 'executable' | 'manual' | 'noop';
+export type FailedMigrationClassification = 'unresolved' | 'superseded' | 'other';
+export interface FailedMigrationLike {
+    name: string;
+    error_message?: string | null;
+}
+export interface FailedMigrationSummaryItem {
+    name: string;
+    classification: FailedMigrationClassification;
+    recommendation: string;
+    errorMessage: string | null;
+}
+export interface FailedMigrationBuckets {
+    unresolved: FailedMigrationSummaryItem[];
+    superseded: FailedMigrationSummaryItem[];
+    other: FailedMigrationSummaryItem[];
+}
+export interface DbMigrateFailureState {
+    manualInterventionCount?: number;
+    tableErrorCount?: number;
+    migrationErrorCount?: number;
+    stiErrorCount?: number;
+    dryRun?: boolean;
+}
+export declare function classifyTypeUpgradeSql(sql?: string): TypeUpgradeExecutionKind;
+export declare function getSyntheticMigrationNameForAction(action: MigrationAction): string | null;
+export declare function getSyntheticMigrationNameForChange(change: SchemaChangeLike): string | null;
+/**
+ * Return every tracker name that can represent the current schema change.
+ *
+ * New type upgrades use a fingerprinted id, but releases before #2111 wrote
+ * failures under the bare table-and-column id. Keep that old id as a
+ * classification alias only: execution always uses the fingerprinted id, so
+ * no applied migration record is rewritten or reused for a new conversion.
+ */
+export declare function getSyntheticMigrationNamesForChange(change: SchemaChangeLike): string[];
+export declare function shouldFailDbMigrate(state: DbMigrateFailureState): boolean;
+export declare function shouldApplySchemaMigrations(state: {
+    dryRun?: boolean;
+}): boolean;
+export declare function classifyFailedMigration(migrationName: string, unresolvedSyntheticMigrationNames: Set<string>): FailedMigrationClassification;
+export declare function getUnresolvedGeneratedMigrationNames(changes: SchemaChangeLike[]): Set<string>;
+export declare const getUnresolvedAdditiveMigrationNames: typeof getUnresolvedGeneratedMigrationNames;
+export declare function getFailedMigrationRecommendation(classification: FailedMigrationClassification, liveSchemaCompared?: boolean): string;
+export declare function summarizeFailedMigrations(failedMigrations: FailedMigrationLike[], unresolvedSyntheticMigrationNames: Set<string> | null): FailedMigrationBuckets;
+export declare function partitionSchemaChanges(changes: SchemaChangeLike[], getClassForTable: (tableName: string) => string): {
+    migrations: MigrationAction[];
+    manualInterventions: MigrationAction[];
+    /**
+     * Report-only findings (#2369): orphan columns/indexes and relaxations the
+     * operator has not opted into. Printed, never executed, and they never
+     * fail db:migrate on their own.
+     */
+    advisories: SchemaAdvisory[];
+};
+/**
+ * Print report-only schema findings (#2369) in a stable order: warnings
+ * first (an orphan NOT NULL column that breaks inserts, a stale unique
+ * constraint, a relaxation not opted into), then info, then orphan tables
+ * (verbose only — shared databases legitimately hold tables from other
+ * apps). Shared by db:migrate and db:diff so both commands report the same
+ * findings the same way.
+ */
+export declare function printSchemaAdvisories(advisories: SchemaAdvisory[], options?: {
+    orphanTables?: string[];
+    verbose?: boolean;
+    log?: (line: string) => void;
+}): void;
+/**
+ * Every column a manual intervention blocks, keyed `table.column`, with the
+ * human-readable reason (the action's advisory message, or a description of
+ * the type mismatch) a dependent change is withheld for. `advisories`
+ * includes only report-only `type_upgrade` findings (the #2608 refused
+ * uuid convergence) — that shape is a genuine, permanent column-state block
+ * that names a column just as concretely as a manual intervention does, so
+ * omitting it let `--apply-unblocked` apply an index/alter/drop against a
+ * column whose type convergence is itself blocked (review finding, #2748).
+ *
+ * `alter_column` advisories are deliberately excluded even though the type
+ * exists on `SchemaAdvisory`: an advisory-only `alter_column` is produced
+ * only by an un-opted-into relaxation (`drop_default`/`drop_not_null` when
+ * `--relax-columns` was not passed) — it says the live column is *stricter*
+ * than the manifest, not that the column's state blocks anything, and it
+ * reappears on every run regardless of `--apply-unblocked`. Treating it as
+ * a blocked column reproduced the exact defect this function's
+ * `engineUnsupported` exclusion fixed for `add_foreign_key`: permanently
+ * withholding unrelated executable DDL on that column (review finding,
+ * #2748, second pass). A genuinely blocked `alter_column` (e.g. NOT NULL
+ * required with live NULLs and no default) carries executable-looking SQL
+ * as a comment and already reaches `manualInterventions` instead, where it
+ * is covered by the loop above via `columnName`.
+ */
+export declare function computeBlockedColumns(manualInterventions: MigrationAction[], advisories?: SchemaAdvisory[]): Map<string, string>;
+/**
+ * `table.column` keys whose only manual-intervention block is an
+ * orphan-blocked `add_foreign_key` on that same (child) column — a
+ * row-data condition (existing rows don't match a parent), not a
+ * column-state one. An un-opted-into `--relax-columns` relaxation on that
+ * column (`DROP NOT NULL`/`DROP DEFAULT`) is not unsafe against orphan
+ * rows; it is in fact the exact remediation that makes a NOT-NULL-child
+ * orphan block eventually resolvable by `--null-orphans` on a later run.
+ * Gating that `alter_column` on the orphan block made `--apply-unblocked
+ * --relax-columns` withhold it forever — the relaxation never applies, the
+ * live column never becomes nullable, the orphan block never clears, in a
+ * stable non-converging loop (review finding, #2748). Every other
+ * dependent shape on that column (an index, an unrelated foreign key, a
+ * `drop_column`) still correctly stays gated by the orphan block; this set
+ * narrows the exclusion to `alter_column` alone at the call site.
+ */
+export declare function computeOrphanOnlyBlockedColumns(manualInterventions: MigrationAction[]): Set<string>;
+/** One migration withheld under `--apply-unblocked` and why. */
+export interface WithheldMigration {
+    action: MigrationAction;
+    /** `table.column` of the blocked change this one depends on. */
+    dependsOn: string;
+    reason: string;
+}
+/**
+ * Partition executable migrations (the differ's "safe DDL" bucket) into
+ * those independent of every blocked column and those that depend on one
+ * (#2748's dependency rule): an index or foreign key on a column whose type
+ * upgrade is blocked, or a foreign key whose orphan rows block it, stays
+ * withheld; everything else is applied. Pure and order-preserving so a
+ * dry-run preview and a real apply partition identically.
+ *
+ * A `drop_index` carries no column list of its own (a DB-side index being
+ * removed; see `MigrationAction.indexName`'s doc comment), so it is never
+ * itself a dependency target — EXCEPT when it is the drop half of the
+ * #1165 shape-drift recreate pair (`drop_index` then `add_index` for the
+ * SAME name, in that order, in the same batch). Withholding the `add_index`
+ * half alone while letting its paired `drop_index` proceed would remove the
+ * existing index/uniqueness enforcement with no replacement — reachable and
+ * unsafe (review, #2748) — so a `drop_index` withholds together with any
+ * `add_index` of the same name that this partition withheld.
+ */
+export declare function partitionUnblockedMigrations(migrations: MigrationAction[], blockedColumns: Map<string, string>, orphanOnlyBlockedColumns?: Set<string>): {
+    applied: MigrationAction[];
+    withheld: WithheldMigration[];
+};
+/**
+ * Drop any pending post-apply report entry whose `action` reference was
+ * withheld by `partitionUnblockedMigrations()` (review finding, #2748): a
+ * `--null-orphans` combined null+add-FK migration can itself depend on a
+ * separately blocked *parent* column and get withheld under
+ * `--apply-unblocked` even though it already resolved out of
+ * `manualInterventions`. Without this filter, the post-apply report printed
+ * a `✓ ... resolved` line for a disposition that never executed — the same
+ * relationship the `🔒 Withheld` listing (from `withheld`) already names.
+ * Matches by object identity, not by table/column, since the caller pushed
+ * the exact `MigrationAction` reference into both `migrations` and the
+ * pending entry.
+ */
+export declare function filterUnresolvedOrphanDispositions<T extends {
+    action: MigrationAction;
+}>(pending: T[], withheld: WithheldMigration[]): T[];
+/** One orphan-blocked FK the child column allows nulling out. */
+export interface OrphanDispositionPlanItem {
+    action: MigrationAction;
+    tableName: string;
+    column: string;
+    /** `SELECT ... orphan_key ...` probe the differ generated (read-only). */
+    detectorSql: string;
+    /** Executable `UPDATE ... SET <column> = NULL WHERE ...` statement. */
+    repairSql: string;
+}
+/**
+ * Split `manualInterventions` into orphan-blocked `add_foreign_key` actions
+ * whose child column is nullable (an opt-in `--null-orphans` disposition can
+ * null the references and proceed) and every other manual intervention,
+ * including orphan-blocked FKs on a NOT NULL child column, which keep the
+ * existing "Manual repair required" refusal (#2748) unconditionally — a
+ * caller must never delete rows to make room for one of these.
+ *
+ * Reuses the differ's own rendered `advisory.suggestedSql` (detector at
+ * index 0, repair at index 1) rather than re-deriving the orphan probe's
+ * uuid-cast options, so the disposition always runs exactly the SQL the
+ * differ already decided on.
+ */
+export declare function planOrphanDispositions(manualInterventions: MigrationAction[]): {
+    nullable: OrphanDispositionPlanItem[];
+    notNullable: MigrationAction[];
+};
+/**
+ * Wrap an orphan-probe `SELECT` (the differ's `renderForeignKeyOrphanDetector`
+ * output, a bare `SELECT ... orphan_key ...` with no `LIMIT`) as a
+ * `COUNT(*)` so `--null-orphans` can report before/after counts without
+ * re-deriving the probe's own uuid-cast options.
+ */
+export declare function orphanCountSql(detectorSql: string): string;
+//# sourceMappingURL=db-migrate-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-actions.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-actions.ts"],"names":[],"mappings":"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"}

package/dist/commands/db-migrate-agent-schedule-slugs.d.ts

@@ -0,0 +1,3 @@
+import type { CLICommand } from '../cli-generator.js';
+export declare const dbMigrateAgentScheduleSlugsCommand: CLICommand;
+//# sourceMappingURL=db-migrate-agent-schedule-slugs.d.ts.map

package/dist/commands/db-migrate-agent-schedule-slugs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-agent-schedule-slugs.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-agent-schedule-slugs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAWtD,eAAO,MAAM,kCAAkC,EAAE,UA6EhD,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * db:migrate-int8 Command
+ *
+ * Explicitly widens legacy PostgreSQL/DuckDB int4 columns created before
+ * #2373. This is deliberately separate from `db:migrate`: PostgreSQL rewrites
+ * each table, so an operator must review the row-count preflight and schedule
+ * a maintenance window before opting in.
+ */
+import type { CLICommand } from '../cli-generator.js';
+export declare const dbMigrateInt8Command: CLICommand;
+//# sourceMappingURL=db-migrate-int8.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-int8.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-int8.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAiBtD,eAAO,MAAM,oBAAoB,EAAE,UA0IlC,CAAC"}

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

@@ -0,0 +1,8 @@
+import type { CLICommand } from '../cli-generator.js';
+/**
+ * Move ledger accounts out of the `accounts` table they shared with
+ * smrt-messages before #3098. Run between two `db:migrate` passes; see the
+ * smrt-ledgers README.
+ */
+export declare const dbMigrateLedgerAccountsCommand: CLICommand;
+//# sourceMappingURL=db-migrate-ledger-accounts.d.ts.map

package/dist/commands/db-migrate-ledger-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-ledger-accounts.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-ledger-accounts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAYtD;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,UAkF5C,CAAC"}

package/dist/commands/db-migrate-null-equal-indexes.d.ts

@@ -0,0 +1,3 @@
+import type { CLICommand } from '../cli-generator.js';
+export declare const dbMigrateNullEqualIndexesCommand: CLICommand;
+//# sourceMappingURL=db-migrate-null-equal-indexes.d.ts.map

package/dist/commands/db-migrate-null-equal-indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-null-equal-indexes.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-null-equal-indexes.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAQtD,eAAO,MAAM,gCAAgC,EAAE,UA8E9C,CAAC"}

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

@@ -0,0 +1,171 @@
+/**
+ * db:migrate-uuid Command
+ *
+ * relationships-v2 (0.27.0) data migration helper.
+ *
+ * The 0.27.0 release makes `@foreignKey()` / `@crossPackageRef()` (and primary
+ * `id`) columns native `uuid` on PostgreSQL. The structural migration
+ * (`smrt db:migrate`) is *additive* — it cannot rename or change a column's
+ * type in place — so two pieces of per-project DATA migration remain:
+ *
+ *  1. **R3 column renames** (e.g. `tags.parent_slug → parent_id`,
+ *     `facts.parent_id → previous_fact_id`, `assets.parent_id →
+ *     source_asset_id`). The new column is added empty and the old column is
+ *     left orphaned. Use `--rename "old:new[,old2:new2]"` (optionally with
+ *     `--table <name>`) to copy old → new (only where new is still empty) and
+ *     drop the old column.
+ *
+ *  2. **TEXT → native uuid conversion**. Most existing `id`/FK columns already
+ *     hold UUID-shaped strings in TEXT columns and can be promoted to native
+ *     `uuid`. Conversion is gated on TWO independent checks, BOTH of which must
+ *     pass for a column to be converted:
+ *
+ *       (a) **Schema-declared UUID** — the column is one the SMRT manifest
+ *           declares as a `UUID` type (primary `id`, `@foreignKey()` /
+ *           `@crossPackageRef()` columns). The declared types come from
+ *           `ObjectRegistry.getAllSchemasAsDefinitions()` — the SAME source
+ *           `smrt db:migrate` / `db:diff` use. Columns the schema intentionally
+ *           keeps TEXT (`external_id`, `message_id`, provider/oauth ids, …) are
+ *           NEVER converted even when their current data happens to be
+ *           uuid-shaped, because a future non-uuid insert must still succeed.
+ *           Tables not present in the manifest (non-SMRT tables in the `public`
+ *           schema) drop out automatically.
+ *
+ *       (b) **Data-shape** — every non-empty value is already UUID-shaped.
+ *           A declared-UUID column that still holds genuine non-uuid values
+ *           (legacy unhyphenated ids, partially-migrated data, …) is SKIPPED and
+ *           reported so the operator can clean it before re-running.
+ *
+ *     **Fail-closed:** if the manifest/registry can't be loaded or declares no
+ *     UUID columns, NOTHING is converted (the operator is told to run from the
+ *     project root). There is deliberately no name-regex fallback — over-
+ *     converting a TEXT column the schema tolerates as TEXT (the differ treats
+ *     uuid/text as equivalent, so it would never self-repair) is irreversible
+ *     prod-data damage.
+ *
+ * When BOTH the rename backfills and the uuid conversion run in one invocation
+ * they share a SINGLE transaction (one `BEGIN`, one `COMMIT`, one `ROLLBACK` on
+ * any failure) so a conversion failure can never leave a half-applied migration
+ * with the old columns already dropped. Postgres DDL is transactional, so this
+ * holds. With `--skip-convert` the rename phase commits on its own. Both steps
+ * are idempotent — re-running is a no-op once the renames are done and the
+ * columns are already `uuid`.
+ *
+ * PostgreSQL only: SQLite and DuckDB store SMRT uuid columns as TEXT (SQLite)
+ * or accept uuid strings transparently, so no `ALTER COLUMN TYPE uuid` step is
+ * needed there. On a non-Postgres database this command performs the rename
+ * backfills (if requested) and then reports that the uuid conversion is a no-op.
+ *
+ * Run AFTER `smrt db:migrate`.
+ *
+ * Usage:
+ *   smrt db:migrate-uuid --dry-run
+ *   smrt db:migrate-uuid
+ *   smrt db:migrate-uuid --rename "parent_id:source_asset_id" --table assets
+ *   smrt db:migrate-uuid --rename "parent_slug:parent_id" --table tags --skip-convert
+ */
+import type { CLICommand } from '../cli-generator.js';
+/**
+ * Build the set of schema-declared UUID columns from a manifest's
+ * `getAllSchemasAsDefinitions()` output.
+ *
+ * Only columns whose declared `type === 'UUID'` are included. The returned set
+ * uses `${table}|${column}` keys for O(1) membership tests. Pure and
+ * DB-independent so the gating semantics can be unit-tested without a database.
+ */
+export declare function buildDeclaredUuidColumnSet(schemaDefinitions: Record<string, {
+    columns?: Record<string, {
+        type?: string;
+    }>;
+}>): Set<string>;
+/** A live TEXT column scheduled for `ALTER COLUMN … TYPE uuid`. */
+interface ConvertCandidate {
+    table: string;
+    column: string;
+    hasDefault: boolean;
+}
+/**
+ * A live TEXT `id`/FK column discovered in the database, annotated with how
+ * many of its non-empty values are NOT UUID-shaped.
+ */
+export interface LiveTextColumn {
+    table: string;
+    column: string;
+    hasDefault: boolean;
+    /** Count of non-empty values that are not UUID-shaped. */
+    nonUuid: number;
+    /**
+     * Count of normalized-value groups with more than one distinct TEXT row
+     * mapping to the same uuid (e.g. one hyphenated, one bare-hex row for the
+     * same value) — a many-to-one collision the widened shape probe admits.
+     * Optional/defaults to 0 so existing call sites need not set it.
+     */
+    duplicateNormalized?: number;
+}
+/**
+ * The outcome of classifying live TEXT columns against the declared-UUID set.
+ */
+export interface ConversionPlan {
+    convert: ConvertCandidate[];
+    /**
+     * Declared-UUID columns whose data still has non-uuid values, and/or two or
+     * more TEXT rows that normalize to the same uuid (a post-normalization
+     * collision — `duplicateNormalized` is present only when > 0).
+     */
+    skipDirtyData: Array<{
+        table: string;
+        column: string;
+        nonUuid: number;
+        duplicateNormalized?: number;
+    }>;
+    /** Live TEXT columns the schema does NOT declare as UUID (left as TEXT). */
+    skipNotDeclared: Array<{
+        table: string;
+        column: string;
+    }>;
+    /**
+     * Otherwise-convertible columns blocked because a foreign-key partner
+     * (transitively) will not convert. Populated by
+     * `propagateBlockedForeignKeyPartners`; absent/empty before that step runs.
+     */
+    skipBlockedPartner?: Array<{
+        table: string;
+        column: string;
+        reason: string;
+    }>;
+}
+/** A single-column foreign key edge between two candidate columns. */
+export interface ForeignKeyEdge {
+    name: string;
+    childTable: string;
+    childColumn: string;
+    parentTable: string;
+    parentColumn: string;
+}
+export declare function propagateBlockedForeignKeyPartners(plan: ConversionPlan, edges: ForeignKeyEdge[]): ConversionPlan;
+/**
+ * Decide which live TEXT columns to convert to native `uuid`.
+ *
+ * A column is converted ONLY if BOTH gates pass:
+ *   1. it is in the schema-declared-UUID set, AND
+ *   2. all of its non-empty values are already UUID-shaped.
+ *
+ * Declared-UUID columns with dirty data are reported in `skipDirtyData`;
+ * undeclared columns (schema-intentional TEXT, or non-SMRT tables) are reported
+ * in `skipNotDeclared`. Pure so the gating can be unit-tested without a DB.
+ */
+export declare function planUuidConversions(liveColumns: LiveTextColumn[], declaredUuid: Set<string>): ConversionPlan;
+interface RenameSpec {
+    table: string;
+    from: string;
+    to: string;
+}
+/**
+ * Parse `--rename "old:new,old2:new2"` plus the optional default `--table`
+ * into structured rename specs. A pair may carry its own table via
+ * `table.old:new`; otherwise it falls back to `--table`.
+ */
+export declare function parseRenameSpecs(renameArg: string | undefined, defaultTable: string | undefined): RenameSpec[];
+export declare const dbMigrateUuidCommand: CLICommand;
+export {};
+//# sourceMappingURL=db-migrate-uuid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate-uuid.d.ts","sourceRoot":"","sources":["../../src/commands/db-migrate-uuid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAqCtD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,iBAAiB,EAAE,MAAM,CACvB,MAAM,EACN;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAChD,GACA,GAAG,CAAC,MAAM,CAAC,CAWb;AAYD,mEAAmE;AACnE,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,aAAa,EAAE,KAAK,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC,CAAC;IACH,4EAA4E;IAC5E,eAAe,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/E;AAED,sEAAsE;AACtE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AA+BD,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,cAAc,EAAE,GACtB,cAAc,CA6EhB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,cAAc,EAAE,EAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,cAAc,CAgChB;AAED,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,UAAU,EAAE,CA2Bd;AAED,eAAO,MAAM,oBAAoB,EAAE,UA4JlC,CAAC"}

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

@@ -0,0 +1,39 @@
+/**
+ * db:orphans Command (#2753)
+ *
+ * Read-only per-foreign-key orphan count report. `db:migrate`'s orphan probe
+ * already gates `ADD CONSTRAINT` with a `LIMIT 1` existence check and prints a
+ * suggested repair; this command runs the identical probe as `COUNT(*)` for
+ * every manifest-declared foreign key, so planning a repair no longer starts
+ * with hand-writing the same SQL against the live database.
+ *
+ * Strictly diagnostic: it never repairs anything, and the orphan counts
+ * themselves never affect the exit code — a database full of orphans still
+ * exits 0. It exits non-zero only on a configuration or runtime error (no
+ * database configured, or the report itself could not run), the same
+ * contract every other `db:*` command uses. The existing "no foreign-key
+ * orphan repair, by design" boundary stays exactly where it is. Use `--json`
+ * for scripting.
+ */
+import { type ForeignKeyOrphanCount, type ForeignKeyOrphanCountReport, type ForeignKeyOrphanSkipped } from '@happyvertical/smrt-core';
+import type { CLICommand } from '../cli-generator.js';
+/** Render one count row as a compact, script-friendly line. */
+export declare function formatOrphanCountLine(count: ForeignKeyOrphanCount): string;
+/**
+ * Scrub connection-string credentials from each skipped relationship's
+ * `reason`. A `probe_failed` reason is the database driver's error text,
+ * which can echo the DSN, so both the JSON and human outputs render this
+ * redacted copy.
+ */
+export declare function redactOrphanReport(report: ForeignKeyOrphanCountReport): ForeignKeyOrphanCountReport;
+/** Render the full report as console lines. */
+export declare function formatOrphanReport(report: ForeignKeyOrphanCountReport, options?: {
+    verbose?: boolean;
+}): string[];
+/** One-line summary used by `db:status`. */
+export declare function summarizeOrphanReport(report: ForeignKeyOrphanCountReport): string;
+/** Foreign keys with at least one orphan row, for `db:status`'s summary. */
+export declare function affectedOrphanCounts(report: ForeignKeyOrphanCountReport): ForeignKeyOrphanCount[];
+export type { ForeignKeyOrphanCount, ForeignKeyOrphanCountReport, ForeignKeyOrphanSkipped, };
+export declare const dbOrphansCommand: CLICommand;
+//# sourceMappingURL=db-orphans.d.ts.map

package/dist/commands/db-orphans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-orphans.d.ts","sourceRoot":"","sources":["../../src/commands/db-orphans.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAE7B,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAatD,+DAA+D;AAC/D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,2BAA2B,GAClC,2BAA2B,CAQ7B;AAED,+CAA+C;AAC/C,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,2BAA2B,EACnC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAClC,MAAM,EAAE,CAgDV;AAED,4CAA4C;AAC5C,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,2BAA2B,GAClC,MAAM,CAGR;AAED,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,2BAA2B,GAClC,qBAAqB,EAAE,CAEzB;AAED,YAAY,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,uBAAuB,GACxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UA0F9B,CAAC"}