@prisma-next/target-sqlite 0.14.0-dev.6 → 0.14.0-dev.61

package/dist/sqlite-contract-view-J32K82Gi.d.mts

@@ -0,0 +1,29 @@
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSingleNamespaceView } from "@prisma-next/sql-contract/contract-view";
+import { Contract } from "@prisma-next/contract/types";
+
+//#region src/core/sqlite-contract-view.d.ts
+/**
+ * A SQLite contract view: the deserialized contract intersected with by-name
+ * accessors. It is substitutable for `Contract` (carries `storage`, `domain`,
+ * …) and also exposes the single default namespace unwrapped with the SQL
+ * built-in kinds promoted:
+ *
+ * ```ts
+ * const view = SqliteContractView.fromJson<Contract>(contractJson);
+ * view.table.users      // typed table leaf
+ * view.entries.policy.X // pack-contributed kind (singular key)
+ * view.storage          // the full contract is still present
+ * ```
+ *
+ * SQLite has `sql.enums: false`, so it never emits `valueSet` entries; the
+ * `valueSet` slot is therefore an empty map.
+ */
+type SqliteContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> = SqlSingleNamespaceView<TContract>;
+declare const SqliteContractView: {
+  /** Wrap an already-deserialized SQLite contract in a view. */from<TContract extends Contract<SqlStorage>>(contract: TContract): SqliteContractView<TContract>; /** Deserialize a SQLite contract JSON envelope and wrap it in a view. */
+  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage<string>>>(json: unknown): SqliteContractView<TContract>;
+};
+//#endregion
+export { SqliteContractView as t };
+//# sourceMappingURL=sqlite-contract-view-J32K82Gi.d.mts.map

package/dist/sqlite-contract-view-J32K82Gi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-contract-view-J32K82Gi.d.mts","names":[],"sources":["../src/core/sqlite-contract-view.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;KAAY,kBAAA,mBAAqC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,KAC/E,sBAAA,CAAuB,SAAA;AAAA,cAEZ,kBAAA;EAFX,qFAIuB,QAAA,CAAS,UAAA,GAAW,QAAA,EAAY,SAAA,GAAY,kBAAA,CAAmB,SAAA,GAJtD;6BASL,QAAA,CAAS,UAAA,IAAW,QAAA,CAAA,UAAA,WAAA,IAAA,YAE5C,kBAAA,CAAmB,SAAA;AAAA"}

package/dist/sqlite-migration-BNiSiP0z.mjs

@@ -0,0 +1,123 @@
+import { a as DropColumnCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-Do03QgD9.mjs";
+import { t as SqliteContractView } from "./sqlite-contract-view-BEwi0mUC.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { MigrationContractViews } from "@prisma-next/migration-tools/migration";
+import { CliStructuredError } from "@prisma-next/errors/control";
+//#region src/core/errors.ts
+/**
+* A `SqliteMigration` operation that needs the materialized control adapter
+* — named by `operation` (e.g. `createTable`, `dropColumn`, `recreateTable`) —
+* was invoked, but the migration was constructed without a `ControlStack`.
+* Concrete authoring usage always goes through the migration CLI entrypoint,
+* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+* error means a test fixture or ad-hoc consumer instantiated `SqliteMigration`
+* with the no-arg form (legal for `operations` / `describe` introspection only).
+*
+* The `operation` argument is required so every throw site names the operation
+* that actually failed; a new operation cannot inherit a misattributed message.
+*
+* Distinct from `PN-MIG-2001` (placeholder not filled) because the missing
+* input is the stack itself, not the per-operation contract.
+*
+* Lives in `@prisma-next/target-sqlite/errors` rather than the shared
+* framework migration errors module because the failure is target-specific:
+* the contract it talks about (`SqliteMigration`, the SQLite control
+* adapter, the SQLite-target stack) only exists in this package.
+*/
+function errorSqliteMigrationStackMissing(operation) {
+	return new CliStructuredError("2008", `SqliteMigration.${operation} requires a control adapter`, {
+		domain: "MIG",
+		why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,
+		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.",
+		meta: { operation }
+	});
+}
+//#endregion
+//#region src/core/migrations/sqlite-migration.ts
+/**
+* Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
+* generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
+* SQLite literal, so both user-authored migrations and renderer-generated
+* scaffolds can extend `SqliteMigration` directly without redeclaring
+* target-local identity.
+*
+* The constructor materializes a single SQLite `SqlControlAdapter` from
+* `stack.adapter.create(stack)` and stores it; the protected instance methods
+* forward to the corresponding `*Call` with that stored adapter, so user
+* migrations can write `this.createTable({...})` without threading the adapter
+* through every call.
+*
+* Binds the framework base's `Start` / `End` contract generics so a subclass
+* that assigns its `start-contract.json` / `end-contract.json` imports gets
+* fully-typed view accessors: `this.endContract` is a `SqliteContractView<End>`
+* (sole namespace unwrapped to the root — `this.endContract.table.<name>`),
+* built lazily from the JSON fields via the shared `MigrationContractViews`
+* helper. Mirrors `MongoMigration`'s view getters; the framework base derives
+* `describe()` from the same JSON.
+*/
+var SqliteMigration = class extends Migration {
+	targetId = "sqlite";
+	/**
+	* Materialized SQLite control adapter, created once per migration
+	* instance from the injected stack. `undefined` only when the migration
+	* was instantiated without a stack (test fixtures); `controlAdapterFor`
+	* throws a PN-MIG-2008 in that case to surface the misuse.
+	*/
+	controlAdapter;
+	#endView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	#startView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
+	}
+	/**
+	* Returns the materialized control adapter, or throws a PN-MIG-2008 naming
+	* `operation` when the migration was constructed without a `ControlStack`.
+	* Single home for the null-check that every DDL/DML method shares.
+	*/
+	controlAdapterFor(operation) {
+		if (!this.controlAdapter) throw errorSqliteMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	/**
+	* The typed SQLite view over this migration's end-state contract — sole
+	* namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+	* Throws if no `endContractJson` was provided.
+	*/
+	get endContract() {
+		return this.#endView.endContract;
+	}
+	/**
+	* The typed SQLite view over this migration's start-state contract, or
+	* `null` for a baseline migration (no `startContractJson`).
+	*/
+	get startContract() {
+		return this.#startView.startContract;
+	}
+	createTable(options) {
+		return new CreateTableCall(options.table, options.columns, options.constraints).toOp(this.controlAdapterFor("createTable"));
+	}
+	dropTable(options) {
+		return new DropTableCall(options.table).toOp(this.controlAdapterFor("dropTable"));
+	}
+	addColumn(options) {
+		return new AddColumnCall(options.table, options.column).toOp(this.controlAdapterFor("addColumn"));
+	}
+	dropColumn(options) {
+		return new DropColumnCall(options.table, options.column).toOp(this.controlAdapterFor("dropColumn"));
+	}
+	createIndex(options) {
+		return new CreateIndexCall(options.table, options.index, options.columns).toOp(this.controlAdapterFor("createIndex"));
+	}
+	dropIndex(options) {
+		return new DropIndexCall(options.table, options.index).toOp(this.controlAdapterFor("dropIndex"));
+	}
+	recreateTable(options) {
+		return new RecreateTableCall(options).toOp(this.controlAdapterFor("recreateTable"));
+	}
+};
+//#endregion
+export { SqliteMigration as t };
+
+//# sourceMappingURL=sqlite-migration-BNiSiP0z.mjs.map

package/dist/sqlite-migration-BNiSiP0z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-BNiSiP0z.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/errors.ts","../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `SqliteMigration` operation that needs the materialized control adapter\n * — named by `operation` (e.g. `createTable`, `dropColumn`, `recreateTable`) —\n * was invoked, but the migration was constructed without a `ControlStack`.\n * Concrete authoring usage always goes through the migration CLI entrypoint,\n * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n * error means a test fixture or ad-hoc consumer instantiated `SqliteMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection only).\n *\n * The `operation` argument is required so every throw site names the operation\n * that actually failed; a new operation cannot inherit a misattributed message.\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-sqlite/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`SqliteMigration`, the SQLite control\n * adapter, the SQLite-target stack) only exists in this package.\n */\nexport function errorSqliteMigrationStackMissing(operation: string): CliStructuredError {\n  return new CliStructuredError('2008', `SqliteMigration.${operation} requires a control adapter`, {\n    domain: 'MIG',\n    why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,\n    fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',\n    meta: { operation },\n  });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationClass,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { errorSqliteMigrationStackMissing } from '../errors';\nimport { SqliteContractView } from '../sqlite-contract-view';\nimport {\n  AddColumnCall,\n  CreateIndexCall,\n  CreateTableCall,\n  DropColumnCall,\n  DropIndexCall,\n  DropTableCall,\n  RecreateTableCall,\n} from './op-factory-call';\nimport type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\n/**\n * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`\n * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the\n * SQLite literal, so both user-authored migrations and renderer-generated\n * scaffolds can extend `SqliteMigration` directly without redeclaring\n * target-local identity.\n *\n * The constructor materializes a single SQLite `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected instance methods\n * forward to the corresponding `*Call` with that stored adapter, so user\n * migrations can write `this.createTable({...})` without threading the adapter\n * through every call.\n *\n * Binds the framework base's `Start` / `End` contract generics so a subclass\n * that assigns its `start-contract.json` / `end-contract.json` imports gets\n * fully-typed view accessors: `this.endContract` is a `SqliteContractView<End>`\n * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),\n * built lazily from the JSON fields via the shared `MigrationContractViews`\n * helper. Mirrors `MongoMigration`'s view getters; the framework base derives\n * `describe()` from the same JSON.\n */\nexport abstract class SqliteMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<SqlitePlanTargetDetails, 'sqlite', Start, End> {\n  readonly targetId = 'sqlite' as const;\n\n  /**\n   * Materialized SQLite control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a PN-MIG-2008 in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;\n\n  #endView = new MigrationContractViews<SqliteContractView<End>>(this, 'SqliteMigration', (json) =>\n    SqliteContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<SqliteContractView<Start>>(\n    this,\n    'SqliteMigration',\n    (json) => SqliteContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'sqlite'>) {\n    super(stack);\n    this.controlAdapter = stack?.adapter\n      ? blindCast<\n          SqlControlAdapter<'sqlite'>,\n          'The SQLite descriptor create() returns SqlControlAdapter<sqlite>; typed as wider ControlAdapterInstance at the framework boundary'\n        >(stack.adapter.create(stack))\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a PN-MIG-2008 naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'sqlite'> {\n    if (!this.controlAdapter) {\n      throw errorSqliteMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed SQLite view over this migration's end-state contract — sole\n   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.\n   * Throws if no `endContractJson` was provided.\n   */\n  get endContract(): SqliteContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed SQLite view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): SqliteContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  protected createTable(options: {\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<Op> {\n    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(\n      this.controlAdapterFor('createTable'),\n    );\n  }\n\n  protected dropTable(options: { readonly table: string }): Promise<Op> {\n    return new DropTableCall(options.table).toOp(this.controlAdapterFor('dropTable'));\n  }\n\n  protected addColumn(options: {\n    readonly table: string;\n    readonly column: SqliteColumnSpec;\n  }): Promise<Op> {\n    return new AddColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {\n    return new DropColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected createIndex(options: {\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n  }): Promise<Op> {\n    return new CreateIndexCall(options.table, options.index, options.columns).toOp(\n      this.controlAdapterFor('createIndex'),\n    );\n  }\n\n  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {\n    return new DropIndexCall(options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected recreateTable(options: {\n    readonly tableName: string;\n    readonly contractTable: SqliteTableSpec;\n    readonly schemaColumnNames: readonly string[];\n    readonly indexes: readonly SqliteIndexSpec[];\n    readonly summary: string;\n    readonly postchecks: readonly { readonly description: string; readonly sql: string }[];\n    readonly operationClass: MigrationOperationClass;\n  }): Promise<Op> {\n    return new RecreateTableCall(options).toOp(this.controlAdapterFor('recreateTable'));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iCAAiC,WAAuC;CACtF,OAAO,IAAI,mBAAmB,QAAQ,mBAAmB,UAAU,8BAA8B;EAC/F,QAAQ;EACR,KAAK,mBAAmB,UAAU;EAClC,KAAK;EACL,MAAM,EAAE,UAAU;CACpB,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;ACoBA,IAAsB,kBAAtB,cAGUA,UAA4D;CACpE,WAAoB;;;;;;;CAQpB;CAEA,WAAW,IAAI,uBAAgD,MAAM,oBAAoB,SACvF,mBAAmB,SAAc,IAAI,CACvC;CACA,aAAa,IAAI,uBACf,MACA,oBACC,SAAS,mBAAmB,SAAgB,IAAI,CACnD;CAEA,YAAY,OAAuC;EACjD,MAAM,KAAK;EACX,KAAK,iBAAiB,OAAO,UACzB,UAGE,MAAM,QAAQ,OAAO,KAAK,CAAC,IAC7B,KAAA;CACN;;;;;;CAOA,kBAA0B,WAAgD;EACxE,IAAI,CAAC,KAAK,gBACR,MAAM,iCAAiC,SAAS;EAElD,OAAO,KAAK;CACd;;;;;;CAOA,IAAI,cAAuC;EACzC,OAAO,KAAKC,SAAS;CACvB;;;;;CAMA,IAAI,gBAAkD;EACpD,OAAO,KAAKC,WAAW;CACzB;CAEA,YAAsB,SAKN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,SAAS,QAAQ,WAAW,CAAC,CAAC,KAC9E,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAAkD;EACpE,OAAO,IAAI,cAAc,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK,kBAAkB,WAAW,CAAC;CAClF;CAEA,UAAoB,SAGJ;EACd,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACtD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,WAAqB,SAA2E;EAC9F,OAAO,IAAI,eAAe,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACvD,KAAK,kBAAkB,YAAY,CACrC;CACF;CAEA,YAAsB,SAIN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,OAAO,QAAQ,OAAO,CAAC,CAAC,KACxE,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAA0E;EAC5F,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,KAAK,CAAC,CAAC,KACrD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,cAAwB,SAQR;EACd,OAAO,IAAI,kBAAkB,OAAO,CAAC,CAAC,KAAK,KAAK,kBAAkB,eAAe,CAAC;CACpF;AACF"}

package/dist/{sqlite-migration-DVfhQwN_.d.mts → sqlite-migration-BYbzskpE.d.mts}

@@ -1,9 +1,12 @@
 import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz.mjs";
-import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-Dhc8mLK1.mjs";
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-C6sM-wel.mjs";
+import { t as SqliteContractView } from "./sqlite-contract-view-J32K82Gi.mjs";
 import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
-import { Migration } from "@prisma-next/family-sql/migration";
 import { ControlStack } from "@prisma-next/framework-components/control";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { Contract } from "@prisma-next/contract/types";
 import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
 
 //#region src/core/migrations/sqlite-migration.d.ts
@@ -20,17 +23,43 @@ type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
  * forward to the corresponding `*Call` with that stored adapter, so user
  * migrations can write `this.createTable({...})` without threading the adapter
  * through every call.
+ *
+ * Binds the framework base's `Start` / `End` contract generics so a subclass
+ * that assigns its `start-contract.json` / `end-contract.json` imports gets
+ * fully-typed view accessors: `this.endContract` is a `SqliteContractView<End>`
+ * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),
+ * built lazily from the JSON fields via the shared `MigrationContractViews`
+ * helper. Mirrors `MongoMigration`'s view getters; the framework base derives
+ * `describe()` from the same JSON.
  */
-declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails, 'sqlite'> {
+declare abstract class SqliteMigration<Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlitePlanTargetDetails, 'sqlite', Start, End> {
+  #private;
   readonly targetId: "sqlite";
   /**
    * Materialized SQLite control adapter, created once per migration
    * instance from the injected stack. `undefined` only when the migration
-   * was instantiated without a stack (test fixtures); the operation methods
-   * throw in that case to surface the misuse.
+   * was instantiated without a stack (test fixtures); `controlAdapterFor`
+   * throws a PN-MIG-2008 in that case to surface the misuse.
    */
   protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
   constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  /**
+   * Returns the materialized control adapter, or throws a PN-MIG-2008 naming
+   * `operation` when the migration was constructed without a `ControlStack`.
+   * Single home for the null-check that every DDL/DML method shares.
+   */
+  private controlAdapterFor;
+  /**
+   * The typed SQLite view over this migration's end-state contract — sole
+   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+   * Throws if no `endContractJson` was provided.
+   */
+  get endContract(): SqliteContractView<End>;
+  /**
+   * The typed SQLite view over this migration's start-state contract, or
+   * `null` for a baseline migration (no `startContractJson`).
+   */
+  get startContract(): SqliteContractView<Start> | null;
   protected createTable(options: {
     readonly table: string;
     readonly ifNotExists?: boolean;
@@ -72,4 +101,4 @@ declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails
 }
 //#endregion
 export { SqliteMigration as t };
-//# sourceMappingURL=sqlite-migration-DVfhQwN_.d.mts.map
+//# sourceMappingURL=sqlite-migration-BYbzskpE.d.mts.map

package/dist/sqlite-migration-BYbzskpE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-BYbzskpE.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;;;;;;;KA0BK,EAAA,GAAK,yBAAyB,CAAC,uBAAA;;AAFoC;;;;AAEb;AAuB3D;;;;;;;;;;;;;;;uBAAsB,eAAA,eACN,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,eAClC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,WACpC,SAAA,CAAa,uBAAA,YAAmC,KAAA,EAAO,GAAA;EAAA;WACtD,QAAA;EAsD+B;;;;;;EAAA,mBA9CrB,cAAA,EAAgB,iBAAA;cAWvB,KAAA,GAAQ,YAAA;EAwDD;;;;;EAAA,QAzCX,iBAAA;EA0DJ;;;;;EAAA,IA9CA,WAAA,IAAe,kBAAA,CAAmB,GAAA;EAkE1B;;;;EAAA,IA1DR,aAAA,IAAiB,kBAAA,CAAmB,KAAA;EAAA,UAI9B,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,OAAA,CAAQ,EAAA;EAAA,UAMF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAIxD,SAAA,CAAU,OAAA;IAAA,SACT,KAAA;IAAA,SACA,MAAA,EAAQ,gBAAA;EAAA,IACf,OAAA,CAAQ,EAAA;EAAA,UAMF,UAAA,CAAW,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,MAAA;EAAA,IAAmB,OAAA,CAAQ,EAAA;EAAA,UAMlF,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA,IACP,OAAA,CAAQ,EAAA;EAAA,UAMF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAMhF,aAAA,CAAc,OAAA;IAAA,SACb,SAAA;IAAA,SACA,aAAA,EAAe,eAAA;IAAA,SACf,iBAAA;IAAA,SACA,OAAA,WAAkB,eAAA;IAAA,SAClB,OAAA;IAAA,SACA,UAAA;MAAA,SAAgC,WAAA;MAAA,SAA8B,GAAA;IAAA;IAAA,SAC9D,cAAA,EAAgB,uBAAA;EAAA,IACvB,OAAA,CAAQ,EAAA;AAAA"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.14.0-dev.6",
+  "version": "0.14.0-dev.61",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.14.0-dev.6",
-    "@prisma-next/contract": "0.14.0-dev.6",
-    "@prisma-next/errors": "0.14.0-dev.6",
-    "@prisma-next/family-sql": "0.14.0-dev.6",
-    "@prisma-next/framework-components": "0.14.0-dev.6",
-    "@prisma-next/migration-tools": "0.14.0-dev.6",
-    "@prisma-next/sql-contract": "0.14.0-dev.6",
-    "@prisma-next/sql-errors": "0.14.0-dev.6",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.6",
-    "@prisma-next/sql-runtime": "0.14.0-dev.6",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.6",
-    "@prisma-next/ts-render": "0.14.0-dev.6",
-    "@prisma-next/utils": "0.14.0-dev.6",
+    "@prisma-next/cli": "0.14.0-dev.61",
+    "@prisma-next/contract": "0.14.0-dev.61",
+    "@prisma-next/errors": "0.14.0-dev.61",
+    "@prisma-next/family-sql": "0.14.0-dev.61",
+    "@prisma-next/framework-components": "0.14.0-dev.61",
+    "@prisma-next/migration-tools": "0.14.0-dev.61",
+    "@prisma-next/sql-contract": "0.14.0-dev.61",
+    "@prisma-next/sql-errors": "0.14.0-dev.61",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.61",
+    "@prisma-next/sql-runtime": "0.14.0-dev.61",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.61",
+    "@prisma-next/ts-render": "0.14.0-dev.61",
+    "@prisma-next/utils": "0.14.0-dev.61",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.14.0-dev.6",
-    "@prisma-next/test-utils": "0.14.0-dev.6",
-    "@prisma-next/tsconfig": "0.14.0-dev.6",
-    "@prisma-next/tsdown": "0.14.0-dev.6",
+    "@prisma-next/driver-sqlite": "0.14.0-dev.61",
+    "@prisma-next/test-utils": "0.14.0-dev.61",
+    "@prisma-next/tsconfig": "0.14.0-dev.61",
+    "@prisma-next/tsdown": "0.14.0-dev.61",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/core/control-target.ts

@@ -1,16 +1,19 @@
-import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type { Contract } from '@prisma-next/contract/types';
 import type { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
-import { contractToSchemaIR } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import type {
   ControlTargetInstance,
   MigrationPlanner,
   MigrationRunner,
 } from '@prisma-next/framework-components/control';
-import { SqlStorage, type StorageColumn } from '@prisma-next/sql-contract/types';
+import { SqlStorage } from '@prisma-next/sql-contract/types';
+import {
+  relationalNodeEntityKind,
+  relationalNodeGranularity,
+} from '@prisma-next/sql-schema-ir/types';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+import { diffSqliteSchema, sqliteContractToSchema } from './migrations/diff-database-schema';
 import { createSqliteMigrationPlanner } from './migrations/planner';
-import { renderDefaultLiteral } from './migrations/planner-ddl-builders';
 import type { SqlitePlanTargetDetails } from './migrations/planner-target-details';
 import { createSqliteMigrationRunner } from './migrations/runner';
 import { SqliteContractSerializer } from './sqlite-contract-serializer';
@@ -20,21 +23,16 @@ function isSqlContract(contract: Contract | null): contract is Contract<SqlStora
   return contract === null || contract.storage instanceof SqlStorage;
 }
 
-function sqliteRenderDefault(def: ColumnDefault, _column: StorageColumn): string {
-  if (def.kind === 'function') {
-    if (def.expression === 'now()') {
-      return "datetime('now')";
-    }
-    return def.expression;
-  }
-  return renderDefaultLiteral(def.value);
-}
-
 const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', SqlitePlanTargetDetails> =
   {
     ...sqliteTargetDescriptorMeta,
     contractSerializer: new SqliteContractSerializer(),
     schemaVerifier: new SqliteSchemaVerifier(),
+    diffSchema(input) {
+      return diffSqliteSchema(input);
+    },
+    classifySubjectGranularity: relationalNodeGranularity,
+    classifyEntityKind: relationalNodeEntityKind,
     migrations: {
       createPlanner(adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
         return createSqliteMigrationPlanner(adapter);
@@ -55,10 +53,7 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
             'sqliteControlTargetDescriptor.contractToSchema received a non-SQL contract; expected Contract<SqlStorage>',
           );
         }
-        return contractToSchemaIR(contract, {
-          annotationNamespace: 'sqlite',
-          renderDefault: sqliteRenderDefault,
-        });
+        return sqliteContractToSchema(contract);
       },
     },
     create(): ControlTargetInstance<'sql', 'sqlite'> {

package/src/core/errors.ts

@@ -1,14 +1,16 @@
 import { CliStructuredError } from '@prisma-next/errors/control';
 
 /**
- * A `SqliteMigration` instance method that needs the materialized control
- * adapter (currently only `this.createTable(...)`) was invoked, but the
- * migration was constructed without a `ControlStack`. Concrete authoring
- * usage always goes through the migration CLI entrypoint, which assembles
- * a stack from the loaded `prisma-next.config.ts`; reaching this error
- * means a test fixture or ad-hoc consumer instantiated `SqliteMigration`
- * with the no-arg form (legal for `operations` / `describe` introspection
- * only).
+ * A `SqliteMigration` operation that needs the materialized control adapter
+ * — named by `operation` (e.g. `createTable`, `dropColumn`, `recreateTable`) —
+ * was invoked, but the migration was constructed without a `ControlStack`.
+ * Concrete authoring usage always goes through the migration CLI entrypoint,
+ * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+ * error means a test fixture or ad-hoc consumer instantiated `SqliteMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection only).
+ *
+ * The `operation` argument is required so every throw site names the operation
+ * that actually failed; a new operation cannot inherit a misattributed message.
  *
  * Distinct from `PN-MIG-2001` (placeholder not filled) because the missing
  * input is the stack itself, not the per-operation contract.
@@ -18,11 +20,11 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * the contract it talks about (`SqliteMigration`, the SQLite control
  * adapter, the SQLite-target stack) only exists in this package.
  */
-export function errorSqliteMigrationStackMissing(): CliStructuredError {
-  return new CliStructuredError('2008', 'SqliteMigration.createTable requires a control adapter', {
+export function errorSqliteMigrationStackMissing(operation: string): CliStructuredError {
+  return new CliStructuredError('2008', `SqliteMigration.${operation} requires a control adapter`, {
     domain: 'MIG',
-    why: 'SqliteMigration.createTable was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so createTable cannot lower its DDL node.',
+    why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,
     fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',
-    meta: {},
+    meta: { operation },
   });
 }

package/src/core/migrations/column-ddl-rendering.ts

@@ -0,0 +1,177 @@
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import {
+  DdlColumn,
+  type DdlTableConstraint,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlColumnIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { SqliteColumnSpec } from './operations/shared';
+import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
+
+/**
+ * Reconstructs the `StorageColumn`-shaped fields `buildColumnTypeSql` /
+ * `buildColumnDefaultSql` expect, from a column node's own stamped codec
+ * identity (`codecRef` / `codecBaseNativeType`, Decision 5) — never the
+ * contract. SQLite's type renderer only uppercases the resolved base type
+ * (no parameterized expansion, no named-type quoting), so `typeRef` is
+ * deliberately left unset here: setting it would send `buildColumnTypeSql`
+ * back through a live `storageTypes` lookup the node's fields have already
+ * resolved past, which throws for an unrecognized reference (unlike
+ * Postgres's lenient fallback).
+ */
+function columnLike(
+  column: SqlColumnIR,
+): Pick<StorageColumn, 'nativeType' | 'codecId' | 'nullable' | 'many' | 'typeParams' | 'default'> {
+  if (column.codecRef === undefined || column.codecBaseNativeType === undefined) {
+    throw new Error(
+      `columnLike: expected column "${column.name}" carries no codec identity — the expected tree must be derived via contractToSchemaIR for planning`,
+    );
+  }
+  return {
+    nativeType: column.codecBaseNativeType,
+    codecId: column.codecRef.codecId,
+    nullable: column.nullable,
+    // `column.many` is unset on contract-derived columns (array-ness rides
+    // on the `nativeType` `[]` suffix there instead) — `codecRef.many`
+    // carries it. Hand-built/introspected columns set `column.many` directly.
+    ...((column.many ?? column.codecRef.many) !== undefined
+      ? { many: column.many ?? column.codecRef.many }
+      : {}),
+    ...(column.codecRef.typeParams !== undefined
+      ? {
+          typeParams: blindCast<
+            Record<string, unknown>,
+            'CodecRef.typeParams is JsonValue-shaped; the DDL builders only ever read it as the Record the contract column originally carried'
+          >(column.codecRef.typeParams),
+        }
+      : {}),
+    ...(column.resolvedDefault !== undefined ? { default: column.resolvedDefault } : {}),
+  };
+}
+
+function sqliteDefaultToDdlColumnDefault(
+  columnDefault: StorageColumn['default'],
+): DdlColumn['default'] {
+  if (!columnDefault) return undefined;
+  switch (columnDefault.kind) {
+    case 'literal':
+      return new LiteralColumnDefault(columnDefault.value);
+    case 'function':
+      // `autoincrement()` is not a DEFAULT clause — SQLite encodes it as
+      // `INTEGER PRIMARY KEY AUTOINCREMENT` inline on the column. Skip it
+      // here; the renderer also has a defensive guard for the same case.
+      if (columnDefault.expression === 'autoincrement()') return undefined;
+      return new FunctionColumnDefault(columnDefault.expression);
+    default: {
+      const exhaustive: never = columnDefault;
+      throw new Error(
+        `sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
+      );
+    }
+  }
+}
+
+/**
+ * True when the column is rendered inline as `INTEGER PRIMARY KEY
+ * AUTOINCREMENT` — the sole member of the table's primary key with an
+ * `autoincrement()` default. Node-based sibling of the retired
+ * `isInlineAutoincrementPrimaryKey` (which read the raw `StorageTable`);
+ * reads the table/column nodes instead.
+ */
+export function isInlineAutoincrementPrimaryKeyNode(
+  table: SqlTableIR,
+  column: SqlColumnIR,
+): boolean {
+  if (table.primaryKey?.columns.length !== 1) return false;
+  if (table.primaryKey.columns[0] !== column.name) return false;
+  return (
+    column.resolvedDefault?.kind === 'function' &&
+    column.resolvedDefault.expression === 'autoincrement()'
+  );
+}
+
+/**
+ * Builds the flat `SqliteColumnSpec` `AddColumnCall` / `RecreateTableCall`
+ * need, resolved from the column node's codec identity — the same builders
+ * the pre-`plan(start, end)` op-path called, so the output is
+ * byte-identical.
+ */
+export function columnSpecFromNode(column: SqlColumnIR, inline: boolean): SqliteColumnSpec {
+  const like = columnLike(column);
+  const typeSql = buildColumnTypeSql(like, {});
+  const defaultSql = buildColumnDefaultSql(like.default);
+  return {
+    name: column.name,
+    typeSql,
+    defaultSql,
+    nullable: column.nullable,
+    ...(inline ? { inlineAutoincrementPrimaryKey: true } : {}),
+  };
+}
+
+/**
+ * Builds the `DdlColumn` the `CreateTableCall` path needs, resolved from the
+ * column node's codec identity.
+ */
+export function ddlColumnFromNode(column: SqlColumnIR, inline: boolean): DdlColumn {
+  const like = columnLike(column);
+  const typeSql = buildColumnTypeSql(like, {});
+  if (inline) {
+    // `DdlColumn` has no SQLite-specific autoincrement flag, so the full
+    // `PRIMARY KEY AUTOINCREMENT` clause is embedded in the `type` string.
+    // The DDL renderer (`ddl-renderer.ts`) substring-detects `AUTOINCREMENT`
+    // to suppress the normal NOT NULL / PRIMARY KEY / DEFAULT clause rendering
+    // and emit the entire type string verbatim. Both sites must stay in sync.
+    // The structural fix (a SQLite-specific column option) is tracked in TML-2866.
+    return new DdlColumn({ name: column.name, type: `${typeSql} PRIMARY KEY AUTOINCREMENT` });
+  }
+  const colDefault = sqliteDefaultToDdlColumnDefault(like.default);
+  return new DdlColumn({
+    name: column.name,
+    type: typeSql,
+    ...(!column.nullable ? { notNull: true } : {}),
+    ...(colDefault !== undefined ? { default: colDefault } : {}),
+    ...(column.codecRef !== undefined ? { codecRef: column.codecRef } : {}),
+  });
+}
+
+/**
+ * Builds the table-level constraints (PK / unique / FK) for a `CreateTable`
+ * path from the table node — the node-sourced sibling of the retired
+ * contract-based `tableToDdlParts`'s constraint half.
+ */
+export function tableConstraintsFromNode(
+  table: SqlTableIR,
+  hasInlinePk: boolean,
+): DdlTableConstraint[] {
+  const constraints: DdlTableConstraint[] = [];
+  if (table.primaryKey && !hasInlinePk) {
+    constraints.push(new PrimaryKeyConstraint({ columns: table.primaryKey.columns }));
+  }
+  for (const u of table.uniques) {
+    constraints.push(
+      new UniqueConstraint({
+        columns: u.columns,
+        ...(u.name !== undefined ? { name: u.name } : {}),
+      }),
+    );
+  }
+  for (const fk of table.foreignKeys) {
+    constraints.push(
+      new ForeignKeyConstraint({
+        columns: fk.columns,
+        refTable: fk.referencedTable,
+        refColumns: fk.referencedColumns,
+        ...(fk.name !== undefined ? { name: fk.name } : {}),
+        ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),
+        ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),
+      }),
+    );
+  }
+  return constraints;
+}