@prisma-next/target-sqlite 0.13.0-dev.12 → 0.13.0-dev.14

package/dist/{sqlite-contract-serializer-jcRu8aHh.mjs.map → sqlite-contract-serializer-C41PO7DT.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"sqlite-contract-serializer-jcRu8aHh.mjs","names":[],"sources":["../src/core/sqlite-unbound-database.ts","../src/core/sqlite-contract-serializer.ts"],"sourcesContent":["import {\n  freezeNode,\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast, castAs } from '@prisma-next/utils/casts';\n\nexport type SqliteDatabaseInput = {\n  readonly id: string;\n  readonly entries: {\n    readonly table: Readonly<Record<string, StorageTable | StorageTableInput>>;\n  };\n};\n\nconst SQLITE_NAMESPACE_KIND = 'sqlite-namespace' as const;\n\nfunction isMaterializedSqliteNamespace(\n  ns: Namespace | SqlNamespaceTablesInput,\n): ns is SqliteDatabase | SqliteUnboundDatabase {\n  if (typeof ns !== 'object' || ns === null) {\n    return false;\n  }\n  const proto = Object.getPrototypeOf(ns);\n  if (proto === Object.prototype || proto === null) {\n    return false;\n  }\n  return (ns as { kind?: unknown }).kind === SQLITE_NAMESPACE_KIND;\n}\n\n/**\n * SQLite namespace concretion carrying table metadata under\n * `entries.table` and unqualified `qualifyTable()` emission for runtime\n * SQL rendering.\n */\nexport class SqliteDatabase extends NamespaceBase {\n  declare readonly kind: string;\n\n  readonly id: string;\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n  }>;\n\n  constructor(input: SqliteDatabaseInput) {\n    super();\n    this.id = input.id;\n    this.entries = Object.freeze({\n      table: Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.entries.table).map(([k, v]) => [\n            k,\n            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),\n          ]),\n        ),\n      ),\n    });\n    Object.defineProperty(this, 'kind', {\n      value: SQLITE_NAMESPACE_KIND,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  qualifier(): string {\n    return '';\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n}\n\n/**\n * SQLite target `Namespace` concretion. SQLite has no schema or\n * database-namespacing concept at the SQL level — there is exactly one\n * effective namespace per connection, so the target ships a single\n * singleton bound to the framework's `UNBOUND_NAMESPACE_ID` slot.\n *\n * Qualifier emission elides the prefix entirely: rendered DDL and\n * queries look unqualified (`CREATE TABLE \"users\" (...)`), matching\n * SQLite's native dialect. Call sites stay polymorphic — they ask the\n * namespace for its qualifier and consume the empty/unqualified result\n * the same way Postgres consumes a `\"schema\"` prefix.\n *\n * The SQLite PSL interpreter rejects every explicit `namespace { … }`\n * block with a diagnostic naming SQLite; only the implicit\n * `__unspecified__` AST bucket reaches the SQLite interpreter, which\n * lowers it to this singleton.\n */\nexport class SqliteUnboundDatabase extends SqliteDatabase {\n  static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();\n\n  private constructor() {\n    super({ id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n}\n\nexport function buildSqliteNamespace(\n  input: SqlNamespaceTablesInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  if (input.id !== UNBOUND_NAMESPACE_ID) {\n    throw new Error(\n      `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${input.id}\").`,\n    );\n  }\n  if (Object.keys(input.entries.table).length === 0) {\n    return castAs<SqliteUnboundDatabase>(SqliteUnboundDatabase.instance);\n  }\n  return new SqliteDatabase({ id: input.id, entries: input.entries });\n}\n\nexport function buildSqliteNamespaceMap(\n  namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>,\n): Readonly<Record<string, SqliteDatabase | SqliteUnboundDatabase>> {\n  return Object.fromEntries(\n    Object.entries(namespaces).map(([nsKey, ns]) => [\n      nsKey,\n      isMaterializedSqliteNamespace(ns)\n        ? ns\n        : buildSqliteNamespace(\n            blindCast<\n              SqlNamespaceTablesInput,\n              'non-materialized SQLite namespace map entry is a SqlNamespaceTablesInput'\n            >(ns),\n          ),\n    ]),\n  );\n}\n\n/**\n * Target-supplied `Namespace` factory the SQLite target plumbs through\n * `defineContract({ createNamespace })`. SQLite has only one\n * effective namespace slot — the framework `UNBOUND_NAMESPACE_ID`\n * sentinel — so the factory always returns the singleton or a fresh\n * `SqliteDatabase` for the unbound slot with tables. The SQL family's\n * defensive validation in `defineContract` already rejects\n * user-declared SQLite namespaces, so this throw is a structural\n * safety net rather than a user-facing surface.\n */\nexport function sqliteCreateNamespace(\n  input: SqlNamespaceTablesInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  return buildSqliteNamespace(input);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { buildSqliteNamespace } from './sqlite-unbound-database';\n\n/**\n * SQLite target `ContractSerializer` concretion. Mirrors the Postgres\n * shape: inherits the full SQL-family deserialization pipeline and\n * materialises namespace entries as SQLite database concretions that\n * expose `qualifyTable()` for runtime SQL rendering.\n */\nexport class SqliteContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const hydrated = blindCast<\n      SqlNamespaceTablesInput,\n      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    return buildSqliteNamespace(hydrated);\n  }\n}\n"],"mappings":";;;;;AAoBA,MAAM,wBAAwB;;;;;;AAoB9B,IAAa,iBAAb,cAAoC,cAAc;CAGhD;CACA;CAIA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAChB,KAAK,UAAU,OAAO,OAAO,EAC3B,OAAO,OAAO,OACZ,OAAO,YACL,OAAO,QAAQ,MAAM,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CAClD,GACA,aAAa,eAAe,IAAI,IAAI,aAAa,CAAsB,CACzE,CAAC,CACH,CACF,EACF,CAAC;EACD,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;CAEA,YAAoB;EAClB,OAAO;CACT;CAEA,aAAa,WAA2B;EACtC,OAAO,IAAI,UAAU;CACvB;AACF;;;;;;;;;;;;;;;;;;AAmBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,cAAsB;EACpB,MAAM;GAAE,IAAI;GAAsB,SAAS,EAAE,OAAO,CAAC,EAAE;EAAE,CAAC;CAC5D;AACF;AAEA,SAAgB,qBACd,OACwC;CACxC,IAAI,MAAM,OAAO,sBACf,MAAM,IAAI,MACR,uFAAuF,qBAAqB,eAAe,MAAM,GAAG,IACtI;CAEF,IAAI,OAAO,KAAK,MAAM,QAAQ,KAAK,CAAC,CAAC,WAAW,GAC9C,OAAO,OAA8B,sBAAsB,QAAQ;CAErE,OAAO,IAAI,eAAe;EAAE,IAAI,MAAM;EAAI,SAAS,MAAM;CAAQ,CAAC;AACpE;;;;;;;;;;;AA8BA,SAAgB,sBACd,OACwC;CACxC,OAAO,qBAAqB,KAAK;AACnC;;;;;;;;;ACzIA,IAAa,2BAAb,cAA8C,0BAAgD;CAC5F,cAAc;EACZ,sBAAM,IAAI,IAAI,CAAC;CACjB;CAEA,yBACE,MACA,KACqC;EACrC,IAAI,eAAe,eACjB,OAAO;EAMT,OAAO,qBAJU,UAGf,MAAM,yBAAyB,MAAM,GAAG,CACP,CAAC;CACtC;AACF"}
+{"version":3,"file":"sqlite-contract-serializer-C41PO7DT.mjs","names":[],"sources":["../src/core/sqlite-unbound-database.ts","../src/core/sqlite-contract-serializer.ts"],"sourcesContent":["import {\n  freezeNode,\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast, castAs } from '@prisma-next/utils/casts';\n\nexport type SqliteDatabaseInput = {\n  readonly id: string;\n  readonly entries: {\n    readonly table: Readonly<Record<string, StorageTable | StorageTableInput>>;\n  };\n};\n\nconst SQLITE_NAMESPACE_KIND = 'sqlite-namespace' as const;\n\nfunction isMaterializedSqliteNamespace(\n  ns: Namespace | SqlNamespaceTablesInput,\n): ns is SqliteDatabase | SqliteUnboundDatabase {\n  if (typeof ns !== 'object' || ns === null) {\n    return false;\n  }\n  const proto = Object.getPrototypeOf(ns);\n  if (proto === Object.prototype || proto === null) {\n    return false;\n  }\n  return (ns as { kind?: unknown }).kind === SQLITE_NAMESPACE_KIND;\n}\n\n/**\n * SQLite namespace concretion carrying table metadata under\n * `entries.table` and unqualified `qualifyTable()` emission for runtime\n * SQL rendering.\n */\nexport class SqliteDatabase extends NamespaceBase {\n  declare readonly kind: string;\n\n  readonly id: string;\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n  }>;\n\n  constructor(input: SqliteDatabaseInput) {\n    super();\n    this.id = input.id;\n    this.entries = Object.freeze({\n      table: Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.entries.table).map(([k, v]) => [\n            k,\n            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),\n          ]),\n        ),\n      ),\n    });\n    Object.defineProperty(this, 'kind', {\n      value: SQLITE_NAMESPACE_KIND,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  qualifier(): string {\n    return '';\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n}\n\n/**\n * SQLite target `Namespace` concretion. SQLite has no schema or\n * database-namespacing concept at the SQL level — there is exactly one\n * effective namespace per connection, so the target ships a single\n * singleton bound to the framework's `UNBOUND_NAMESPACE_ID` slot.\n *\n * Qualifier emission elides the prefix entirely: rendered DDL and\n * queries look unqualified (`CREATE TABLE \"users\" (...)`), matching\n * SQLite's native dialect. Call sites stay polymorphic — they ask the\n * namespace for its qualifier and consume the empty/unqualified result\n * the same way Postgres consumes a `\"schema\"` prefix.\n *\n * The SQLite PSL interpreter rejects every explicit `namespace { … }`\n * block with a diagnostic naming SQLite; only the implicit\n * `__unspecified__` AST bucket reaches the SQLite interpreter, which\n * lowers it to this singleton.\n */\nexport class SqliteUnboundDatabase extends SqliteDatabase {\n  static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();\n\n  private constructor() {\n    super({ id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n}\n\nexport function buildSqliteNamespace(\n  input: SqlNamespaceTablesInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  if (input.id !== UNBOUND_NAMESPACE_ID) {\n    throw new Error(\n      `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${input.id}\").`,\n    );\n  }\n  if (Object.keys(input.entries.table).length === 0) {\n    return castAs<SqliteUnboundDatabase>(SqliteUnboundDatabase.instance);\n  }\n  return new SqliteDatabase({ id: input.id, entries: input.entries });\n}\n\nexport function buildSqliteNamespaceMap(\n  namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>,\n): Readonly<Record<string, SqliteDatabase | SqliteUnboundDatabase>> {\n  return Object.fromEntries(\n    Object.entries(namespaces).map(([nsKey, ns]) => [\n      nsKey,\n      isMaterializedSqliteNamespace(ns)\n        ? ns\n        : buildSqliteNamespace(\n            blindCast<\n              SqlNamespaceTablesInput,\n              'non-materialized SQLite namespace map entry is a SqlNamespaceTablesInput'\n            >(ns),\n          ),\n    ]),\n  );\n}\n\n/**\n * Target-supplied `Namespace` factory the SQLite target plumbs through\n * `defineContract({ createNamespace })`. SQLite has only one\n * effective namespace slot — the framework `UNBOUND_NAMESPACE_ID`\n * sentinel — so the factory always returns the singleton or a fresh\n * `SqliteDatabase` for the unbound slot with tables. The SQL family's\n * defensive validation in `defineContract` already rejects\n * user-declared SQLite namespaces, so this throw is a structural\n * safety net rather than a user-facing surface.\n */\nexport function sqliteCreateNamespace(\n  input: SqlNamespaceTablesInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  return buildSqliteNamespace(input);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { buildSqliteNamespace } from './sqlite-unbound-database';\n\n/**\n * SQLite target `ContractSerializer` concretion. Mirrors the Postgres\n * shape: inherits the full SQL-family deserialization pipeline and\n * materialises namespace entries as SQLite database concretions that\n * expose `qualifyTable()` for runtime SQL rendering.\n */\nexport class SqliteContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const hydrated = blindCast<\n      SqlNamespaceTablesInput,\n      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    return buildSqliteNamespace(hydrated);\n  }\n}\n"],"mappings":";;;;;AAoBA,MAAM,wBAAwB;;;;;;AAoB9B,IAAa,iBAAb,cAAoC,cAAc;CAGhD;CACA;CAIA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAChB,KAAK,UAAU,OAAO,OAAO,EAC3B,OAAO,OAAO,OACZ,OAAO,YACL,OAAO,QAAQ,MAAM,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CAClD,GACA,aAAa,eAAe,IAAI,IAAI,aAAa,CAAsB,CACzE,CAAC,CACH,CACF,EACF,CAAC;EACD,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;CAEA,YAAoB;EAClB,OAAO;CACT;CAEA,aAAa,WAA2B;EACtC,OAAO,IAAI,UAAU;CACvB;AACF;;;;;;;;;;;;;;;;;;AAmBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,cAAsB;EACpB,MAAM;GAAE,IAAI;GAAsB,SAAS,EAAE,OAAO,CAAC,EAAE;EAAE,CAAC;CAC5D;AACF;AAEA,SAAgB,qBACd,OACwC;CACxC,IAAI,MAAM,OAAO,sBACf,MAAM,IAAI,MACR,uFAAuF,qBAAqB,eAAe,MAAM,GAAG,IACtI;CAEF,IAAI,OAAO,KAAK,MAAM,QAAQ,KAAK,CAAC,CAAC,WAAW,GAC9C,OAAO,OAA8B,sBAAsB,QAAQ;CAErE,OAAO,IAAI,eAAe;EAAE,IAAI,MAAM;EAAI,SAAS,MAAM;CAAQ,CAAC;AACpE;;;;;;;;;;;AA8BA,SAAgB,sBACd,OACwC;CACxC,OAAO,qBAAqB,KAAK;AACnC;;;;;;;;;ACzIA,IAAa,2BAAb,cAA8C,0BAAgD;CAC5F,cAAc;EACZ,sBAAM,IAAI,IAAI,CAAC;CACjB;CAEA,yBACE,MACA,KACqC;EACrC,IAAI,eAAe,eACjB,OAAO;EAMT,OAAO,qBAJU,UAGf,MAAM,yBAAyB,MAAM,GAAG,CACP,CAAC;CACtC;AACF"}

package/dist/sqlite-migration-CteI6Mrg.mjs

@@ -0,0 +1,73 @@
+import { r as CreateTableCall } from "./op-factory-call-Cc-rDnXB.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { CliStructuredError } from "@prisma-next/errors/control";
+//#region src/core/errors.ts
+/**
+* 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).
+*
+* 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() {
+	return new CliStructuredError("2008", "SqliteMigration.createTable 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.",
+		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: {}
+	});
+}
+//#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 `createTable`
+* instance method forwards to `CreateTableCall` with that stored adapter,
+* so user migrations can write `this.createTable({...})` without threading
+* the adapter through every call.
+*/
+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); `createTable`
+	* throws in that case to surface the misuse.
+	*/
+	controlAdapter;
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
+	}
+	/**
+	* Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createTable(options) {
+		if (!this.controlAdapter) throw errorSqliteMigrationStackMissing();
+		return new CreateTableCall(options.table, options.columns, options.constraints).toOp(this.controlAdapter);
+	}
+};
+//#endregion
+export { SqliteMigration as t };
+
+//# sourceMappingURL=sqlite-migration-CteI6Mrg.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-CteI6Mrg.mjs","names":["SqlMigration"],"sources":["../src/core/errors.ts","../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `SqliteMigration` instance method that needs the materialized control\n * adapter (currently only `this.createTable(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `SqliteMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\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(): CliStructuredError {\n  return new CliStructuredError('2008', 'SqliteMigration.createTable requires a control adapter', {\n    domain: 'MIG',\n    why: 'SqliteMigration.createTable was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so createTable 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: {},\n  });\n}\n","import type { SqlMigrationPlanOperation } 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 type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { errorSqliteMigrationStackMissing } from '../errors';\nimport { CreateTableCall } from './op-factory-call';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\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 `createTable`\n * instance method forwards to `CreateTableCall` with that stored adapter,\n * so user migrations can write `this.createTable({...})` without threading\n * the adapter through every call.\n */\nexport abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails, 'sqlite'> {\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); `createTable`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;\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   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): SqlMigrationPlanOperation<SqlitePlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorSqliteMigrationStackMissing();\n    }\n    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(\n      this.controlAdapter,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mCAAuD;CACrE,OAAO,IAAI,mBAAmB,QAAQ,0DAA0D;EAC9F,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,CAAC;CACT,CAAC;AACH;;;;;;;;;;;;;;;;ACJA,IAAsB,kBAAtB,cAA8CA,UAAgD;CAC5F,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAuC;EACjD,MAAM,KAAK;EACX,KAAK,iBAAiB,OAAO,UACzB,UAGE,MAAM,QAAQ,OAAO,KAAK,CAAC,IAC7B,KAAA;CACN;;;;;;CAOA,YAAsB,SAKiC;EACrD,IAAI,CAAC,KAAK,gBACR,MAAM,iCAAiC;EAEzC,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,SAAS,QAAQ,WAAW,CAAC,CAAC,KAC9E,KAAK,cACP;CACF;AACF"}

package/dist/sqlite-migration-znjM-dc_.d.mts

@@ -0,0 +1,46 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { ControlStack } from "@prisma-next/framework-components/control";
+import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+
+//#region src/core/migrations/sqlite-migration.d.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 `createTable`
+ * instance method forwards to `CreateTableCall` with that stored adapter,
+ * so user migrations can write `this.createTable({...})` without threading
+ * the adapter through every call.
+ */
+declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails, 'sqlite'> {
+  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); `createTable`
+   * throws in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+}
+//#endregion
+export { SqliteMigration as t };
+//# sourceMappingURL=sqlite-migration-znjM-dc_.d.mts.map

package/dist/sqlite-migration-znjM-dc_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-znjM-dc_.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;;;;;AAuBA;;;;;;;;;;;uBAAsB,eAAA,SAAwB,SAAA,CAAa,uBAAA;EAAA,SAChD,QAAA;EADmC;;;;;;EAAA,mBASzB,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAeV;;;;;EAAA,UAAA,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,yBAAA,CAA0B,uBAAA;AAAA"}

package/package.json

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

package/src/core/control-target.ts

@@ -36,8 +36,8 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
     contractSerializer: new SqliteContractSerializer(),
     schemaVerifier: new SqliteSchemaVerifier(),
     migrations: {
-      createPlanner(_adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
-        return createSqliteMigrationPlanner();
+      createPlanner(adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
+        return createSqliteMigrationPlanner(adapter);
       },
       createRunner(family) {
         return createSqliteMigrationRunner(family) as MigrationRunner<'sql', 'sqlite'>;
@@ -67,8 +67,8 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
         targetId: 'sqlite',
       };
     },
-    createPlanner(_adapter: SqlControlAdapter<'sqlite'>) {
-      return createSqliteMigrationPlanner();
+    createPlanner(adapter: SqlControlAdapter<'sqlite'>) {
+      return createSqliteMigrationPlanner(adapter);
     },
     createRunner(family) {
       return createSqliteMigrationRunner(family);

package/src/core/errors.ts

@@ -0,0 +1,28 @@
+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).
+ *
+ * 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.
+ */
+export function errorSqliteMigrationStackMissing(): CliStructuredError {
+  return new CliStructuredError('2008', 'SqliteMigration.createTable 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.',
+    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: {},
+  });
+}

package/src/core/migrations/issue-planner.ts

@@ -24,8 +24,19 @@ import type {
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import type { DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import {
+  DdlColumn,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '@prisma-next/sql-relational-core/ast';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { CONTROL_TABLE_NAMES } from '../control-tables';
@@ -256,6 +267,98 @@ export function toTableSpec(
   };
 }
 
+// ============================================================================
+// StorageTable / StorageColumn → DdlColumn[] + DdlTableConstraint[] (for CreateTableCall)
+// ============================================================================
+
+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}"`,
+      );
+    }
+  }
+}
+
+/**
+ * Converts a `StorageTable` to the `DdlColumn[]` + `DdlTableConstraint[]`
+ * pair used by `CreateTableCall`. This is the structured form consumed by
+ * the DDL lowering path; `toTableSpec` / `toColumnSpec` remain in use for
+ * `RecreateTableCall` and `AddColumnCall` (Phase 2).
+ */
+export function tableToDdlParts(
+  table: StorageTable,
+  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+): { columns: DdlColumn[]; constraints: DdlTableConstraint[] } {
+  const columns: DdlColumn[] = Object.entries(table.columns).map(([name, column]) => {
+    const inlineAutoincrement = isInlineAutoincrementPrimaryKey(table, name);
+    const typeSql = buildColumnTypeSql(column, storageTypes);
+    if (inlineAutoincrement) {
+      // `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, type: `${typeSql} PRIMARY KEY AUTOINCREMENT` });
+    }
+    const colDefault = sqliteDefaultToDdlColumnDefault(column.default);
+    return new DdlColumn({
+      name,
+      type: typeSql,
+      ...(!column.nullable ? { notNull: true } : {}),
+      ...(colDefault !== undefined ? { default: colDefault } : {}),
+    });
+  });
+
+  const constraints: DdlTableConstraint[] = [];
+
+  const hasInlinePk = Object.entries(table.columns).some(([name]) =>
+    isInlineAutoincrementPrimaryKey(table, name),
+  );
+  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) {
+    if (fk.constraint === false) continue;
+    constraints.push(
+      new ForeignKeyConstraint({
+        columns: fk.source.columns,
+        refTable: fk.target.tableName,
+        refColumns: fk.target.columns,
+        ...ifDefined('name', fk.name),
+        ...ifDefined('onDelete', fk.onDelete),
+        ...ifDefined('onUpdate', fk.onUpdate),
+      }),
+    );
+  }
+
+  return { columns, constraints };
+}
+
 // ============================================================================
 // Issue planner
 // ============================================================================
@@ -309,8 +412,17 @@ function mapIssueToCall(
           ),
         );
       }
-      const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
-      const calls: SqliteOpFactoryCall[] = [new CreateTableCall(issue.table, tableSpec)];
+      const { columns: ddlColumns, constraints: ddlConstraints } = tableToDdlParts(
+        contractTable,
+        ctx.storageTypes,
+      );
+      const calls: SqliteOpFactoryCall[] = [
+        new CreateTableCall(
+          issue.table,
+          ddlColumns,
+          ddlConstraints.length > 0 ? ddlConstraints : undefined,
+        ),
+      ];
       const declaredIndexColumnKeys = new Set<string>();
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? defaultIndexName(issue.table, index.columns);