@prisma-next/target-sqlite 0.5.0-dev.9 → 0.5.1

package/src/core/migrations/sqlite-migration.ts

@@ -0,0 +1,13 @@
+import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
+import type { SqlitePlanTargetDetails } from './planner-target-details';
+
+/**
+ * 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.
+ */
+export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails> {
+  readonly targetId = 'sqlite' as const;
+}

package/src/core/migrations/statement-builders.ts

@@ -0,0 +1,212 @@
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+
+export { APP_SPACE_ID };
+
+export interface SqlStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+
+export const MARKER_TABLE_NAME = '_prisma_marker';
+export const LEDGER_TABLE_NAME = '_prisma_ledger';
+
+/**
+ * Control tables the runner creates/manages. The planner must not drop these
+ * when reconciling "extra" tables against the contract.
+ */
+export const CONTROL_TABLE_NAMES: ReadonlySet<string> = new Set([
+  MARKER_TABLE_NAME,
+  LEDGER_TABLE_NAME,
+]);
+
+/**
+ * Schema for `_prisma_marker`. The `space TEXT PRIMARY KEY` shape
+ * supports one row per loaded contract space (`'app'`,
+ * `'<extension-id>'`, …); brand-new databases create this shape
+ * directly. The migration runner detects pre-1.0 single-row markers
+ * (no `space` column) at boot and fails with a structured
+ * `LEGACY_MARKER_SHAPE` error rather than auto-rebuilding the table —
+ * see `specs/framework-mechanism.spec.md § 2`.
+ */
+export const ensureMarkerTableStatement: SqlStatement = {
+  sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (
+    space TEXT NOT NULL PRIMARY KEY DEFAULT '${APP_SPACE_ID}',
+    core_hash TEXT NOT NULL,
+    profile_hash TEXT NOT NULL,
+    contract_json TEXT,
+    canonical_version INTEGER,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    app_tag TEXT,
+    meta TEXT NOT NULL DEFAULT '{}',
+    invariants TEXT NOT NULL DEFAULT '[]'
+  )`,
+  params: [],
+};
+
+export const ensureLedgerTableStatement: SqlStatement = {
+  sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    origin_core_hash TEXT,
+    origin_profile_hash TEXT,
+    destination_core_hash TEXT NOT NULL,
+    destination_profile_hash TEXT,
+    contract_json_before TEXT,
+    contract_json_after TEXT,
+    operations TEXT NOT NULL
+  )`,
+  params: [],
+};
+
+export function readMarkerStatement(space: string): SqlStatement {
+  return {
+    sql: `SELECT
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta,
+      invariants
+    FROM _prisma_marker
+    WHERE space = ?`,
+    params: [space],
+  };
+}
+
+export interface WriteMarkerInput {
+  /**
+   * Logical space identifier for this marker row. Required at every
+   * call site so the type system surfaces every place that needs to
+   * thread the value (rather than letting an `?? APP_SPACE_ID`
+   * fall-through silently collapse multi-space markers onto the
+   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}
+   * (`'app'`); per-extension callers pass the extension's space id.
+   */
+  readonly space: string;
+  readonly storageHash: string;
+  readonly profileHash: string;
+  readonly contractJson?: unknown;
+  readonly canonicalVersion?: number | null;
+  readonly appTag?: string | null;
+  readonly meta?: Record<string, unknown>;
+  /**
+   * Invariants to write into `marker.invariants`. Stored as a JSON-encoded
+   * TEXT array — SQLite has no native array type. The runner is responsible
+   * for merging with the existing column (no SQL-side merge here, unlike
+   * Postgres) before passing them in: BEGIN EXCLUSIVE on the migration
+   * transaction makes the read-then-merge-then-write sequence safe.
+   */
+  readonly invariants: readonly string[];
+}
+
+export function buildWriteMarkerStatements(input: WriteMarkerInput): {
+  readonly insert: SqlStatement;
+  readonly update: SqlStatement;
+} {
+  const params: readonly unknown[] = [
+    input.space,
+    input.storageHash,
+    input.profileHash,
+    jsonParam(input.contractJson),
+    input.canonicalVersion ?? null,
+    input.appTag ?? null,
+    jsonParam(input.meta ?? {}),
+    jsonParam(input.invariants),
+  ];
+
+  return {
+    insert: {
+      sql: `INSERT INTO _prisma_marker (
+        space,
+        core_hash,
+        profile_hash,
+        contract_json,
+        canonical_version,
+        updated_at,
+        app_tag,
+        meta,
+        invariants
+      ) VALUES (
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        datetime('now'),
+        ?,
+        ?,
+        ?
+      )`,
+      params,
+    },
+    update: {
+      sql: `UPDATE _prisma_marker SET
+        core_hash = ?,
+        profile_hash = ?,
+        contract_json = ?,
+        canonical_version = ?,
+        updated_at = datetime('now'),
+        app_tag = ?,
+        meta = ?,
+        invariants = ?
+      WHERE space = ?`,
+      params: [
+        input.storageHash,
+        input.profileHash,
+        jsonParam(input.contractJson),
+        input.canonicalVersion ?? null,
+        input.appTag ?? null,
+        jsonParam(input.meta ?? {}),
+        jsonParam(input.invariants),
+        input.space,
+      ],
+    },
+  };
+}
+
+export interface LedgerInsertInput {
+  readonly originStorageHash?: string | null;
+  readonly originProfileHash?: string | null;
+  readonly destinationStorageHash: string;
+  readonly destinationProfileHash?: string | null;
+  readonly contractJsonBefore?: unknown;
+  readonly contractJsonAfter?: unknown;
+  readonly operations: unknown;
+}
+
+export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {
+  return {
+    sql: `INSERT INTO _prisma_ledger (
+      origin_core_hash,
+      origin_profile_hash,
+      destination_core_hash,
+      destination_profile_hash,
+      contract_json_before,
+      contract_json_after,
+      operations
+    ) VALUES (
+      ?,
+      ?,
+      ?,
+      ?,
+      ?,
+      ?,
+      ?
+    )`,
+    params: [
+      input.originStorageHash ?? null,
+      input.originProfileHash ?? null,
+      input.destinationStorageHash,
+      input.destinationProfileHash ?? null,
+      jsonParam(input.contractJsonBefore),
+      jsonParam(input.contractJsonAfter),
+      jsonParam(input.operations),
+    ],
+  };
+}
+
+function jsonParam(value: unknown): string {
+  return JSON.stringify(value ?? null);
+}

package/src/core/native-type-normalizer.ts

@@ -0,0 +1,9 @@
+/**
+ * Canonicalizes SQLite native-type tokens for verifier comparison.
+ * Lives target-side so the planner / runner / adapter all share the same
+ * normalization without crossing the `target-sqlite` ↔ `adapter-sqlite`
+ * boundary.
+ */
+export function normalizeSqliteNativeType(nativeType: string): string {
+  return nativeType.trim().toLowerCase();
+}

package/src/core/registry.ts

@@ -0,0 +1,11 @@
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
+import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { codecDescriptors } from './codecs';
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/target-sqlite`.
+ *
+ * Public consumer surface for the sqlite codec set: the sqlite adapter and any other consumer that needs to enumerate or look up a sqlite codec by id consumes this rather than the raw descriptor array. See ADR 208.
+ */
+export const sqliteCodecRegistry: CodecDescriptorRegistry =
+  buildCodecDescriptorRegistry(codecDescriptors);

package/src/core/runtime-target.ts

@@ -1,5 +1,4 @@
 import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
 
@@ -10,8 +9,7 @@ const sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<
   SqliteRuntimeTargetInstance
 > = {
   ...sqliteTargetDescriptorMeta,
-  codecs: () => createCodecRegistry(),
-  parameterizedCodecs: () => [],
+  codecs: () => [],
   create(): SqliteRuntimeTargetInstance {
     return {
       familyId: 'sql',

package/src/core/sql-utils.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared SQL utility functions for the SQLite target.
+ *
+ * These functions handle safe SQL identifier and literal escaping. They
+ * live in `target-sqlite` (mirroring `target-postgres/src/core/sql-utils.ts`)
+ * so both the control adapter (used at emit time) and the runtime adapter
+ * (used at execute time) can depend on them through a single one-way edge:
+ * `adapter-sqlite → target-sqlite`. Hosting them target-side avoids the
+ * cyclic workspace dependency that would arise if `target-sqlite` reached
+ * back into `adapter-sqlite` for these primitives.
+ */
+
+export class SqlEscapeError extends Error {
+  constructor(
+    message: string,
+    public readonly value: string,
+    public readonly kind: 'identifier' | 'literal',
+  ) {
+    super(message);
+    this.name = 'SqlEscapeError';
+  }
+}
+
+export function quoteIdentifier(identifier: string): string {
+  if (identifier.length === 0) {
+    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');
+  }
+  if (identifier.includes('\0')) {
+    throw new SqlEscapeError(
+      'Identifier cannot contain null bytes',
+      identifier.replace(/\0/g, '\\0'),
+      'identifier',
+    );
+  }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+export function escapeLiteral(value: string): string {
+  if (value.includes('\0')) {
+    throw new SqlEscapeError(
+      'Literal value cannot contain null bytes',
+      value.replace(/\0/g, '\\0'),
+      'literal',
+    );
+  }
+  return value.replace(/'/g, "''");
+}

package/src/exports/codec-ids.ts

@@ -0,0 +1,13 @@
+export {
+  SQL_CHAR_CODEC_ID,
+  SQL_FLOAT_CODEC_ID,
+  SQL_INT_CODEC_ID,
+  SQL_VARCHAR_CODEC_ID,
+  SQLITE_BIGINT_CODEC_ID,
+  SQLITE_BLOB_CODEC_ID,
+  SQLITE_DATETIME_CODEC_ID,
+  SQLITE_INTEGER_CODEC_ID,
+  SQLITE_JSON_CODEC_ID,
+  SQLITE_REAL_CODEC_ID,
+  SQLITE_TEXT_CODEC_ID,
+} from '../core/codec-ids';

package/src/exports/codec-types.ts

@@ -0,0 +1,43 @@
+/**
+ * Codec type definitions for the SQLite target.
+ *
+ * Defining `CodecTypes` here (rather than re-exporting from `core/codecs`) keeps the tsdown DTS bundler from emitting a private chunk path in downstream `.d.mts` files: consumers see `CodecTypes` resolved via this public entry point rather than via a hash-named internal chunk (TML-2357).
+ */
+
+import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
+import {
+  sqlCharDescriptor,
+  sqlFloatDescriptor,
+  sqlIntDescriptor,
+  sqlVarcharDescriptor,
+} from '@prisma-next/sql-relational-core/ast';
+import type { JsonValue } from '../core/codec-helpers';
+import {
+  sqliteBigintDescriptor,
+  sqliteBlobDescriptor,
+  sqliteDatetimeDescriptor,
+  sqliteIntegerDescriptor,
+  sqliteJsonDescriptor,
+  sqliteRealDescriptor,
+  sqliteTextDescriptor,
+} from '../core/codecs';
+
+const codecDescriptorMap = {
+  char: sqlCharDescriptor,
+  varchar: sqlVarcharDescriptor,
+  int: sqlIntDescriptor,
+  float: sqlFloatDescriptor,
+  text: sqliteTextDescriptor,
+  integer: sqliteIntegerDescriptor,
+  real: sqliteRealDescriptor,
+  blob: sqliteBlobDescriptor,
+  datetime: sqliteDatetimeDescriptor,
+  json: sqliteJsonDescriptor,
+  bigint: sqliteBigintDescriptor,
+} as const;
+
+type Resolve<T> = { readonly [K in keyof T]: { readonly [P in keyof T[K]]: T[K][P] } };
+
+export type CodecTypes = Resolve<ExtractCodecTypes<typeof codecDescriptorMap>>;
+
+export type { JsonValue };

package/src/exports/codecs.ts

@@ -0,0 +1,20 @@
+export type { JsonValue } from '../core/codec-helpers';
+export type {
+  SqliteBigintDescriptor,
+  SqliteBlobDescriptor,
+  SqliteDatetimeDescriptor,
+  SqliteIntegerDescriptor,
+  SqliteJsonDescriptor,
+  SqliteRealDescriptor,
+  SqliteTextDescriptor,
+} from '../core/codecs';
+export {
+  sqliteBigintColumn,
+  sqliteBlobColumn,
+  sqliteDatetimeColumn,
+  sqliteIntegerColumn,
+  sqliteJsonColumn,
+  sqliteRealColumn,
+  sqliteTextColumn,
+} from '../core/codecs';
+export { sqliteCodecRegistry } from '../core/registry';

package/src/exports/control.ts

@@ -1 +1,2 @@
 export { default } from '../core/control-target';
+export type { SqlitePlanTargetDetails } from '../core/migrations/planner-target-details';

package/src/exports/default-normalizer.ts

@@ -0,0 +1 @@
+export { parseSqliteDefault } from '../core/default-normalizer';

package/src/exports/migration.ts

@@ -0,0 +1,24 @@
+// Re-exported so a SQLite `migration.ts` only needs the single
+// `@prisma-next/target-sqlite/migration` import for its base class and
+// the CLI entrypoint, mirroring how `placeholder` is surfaced here. The
+// renderer emits the entrypoint call as
+// `MigrationCLI.run(import.meta.url, M)`.
+export { MigrationCLI } from '@prisma-next/cli/migration-cli';
+// Re-exported so user-edited migration.ts files only need to depend on
+// `@prisma-next/target-sqlite/migration` to fill in planner-emitted
+// `placeholder("…")` slots, instead of pulling in `@prisma-next/errors`
+// directly. The planner emits an import from this same module.
+export { placeholder } from '@prisma-next/errors/migration';
+export { addColumn, dropColumn } from '../core/migrations/operations/columns';
+export {
+  type DataTransformOptions,
+  dataTransform,
+} from '../core/migrations/operations/data-transform';
+export { createIndex, dropIndex } from '../core/migrations/operations/indexes';
+export { rawSql } from '../core/migrations/operations/raw';
+export { createTable, dropTable, recreateTable } from '../core/migrations/operations/tables';
+// Target-owned base class for migrations. Aliased to `Migration` so
+// user-edited migration.ts files (and the renderer's scaffold) read as
+// `class M extends Migration { … }` without having to thread the
+// target-details generic or redeclare `targetId`.
+export { SqliteMigration as Migration } from '../core/migrations/sqlite-migration';

package/src/exports/native-type-normalizer.ts

@@ -0,0 +1 @@
+export { normalizeSqliteNativeType } from '../core/native-type-normalizer';

package/src/exports/op-factory-call.ts

@@ -0,0 +1,12 @@
+export {
+  AddColumnCall,
+  CreateIndexCall,
+  CreateTableCall,
+  DataTransformCall,
+  DropColumnCall,
+  DropIndexCall,
+  DropTableCall,
+  RawSqlCall,
+  RecreateTableCall,
+  type SqliteOpFactoryCall,
+} from '../core/migrations/op-factory-call';

package/src/exports/planner-produced-sqlite-migration.ts

@@ -0,0 +1,4 @@
+export {
+  type SqliteMigrationDestinationInfo,
+  TypeScriptRenderableSqliteMigration,
+} from '../core/migrations/planner-produced-sqlite-migration';

package/src/exports/planner-target-details.ts

@@ -0,0 +1,2 @@
+export type { SqlitePlanTargetDetails } from '../core/migrations/planner-target-details';
+export { buildTargetDetails } from '../core/migrations/planner-target-details';

package/src/exports/planner.ts

@@ -0,0 +1,2 @@
+export type { SqlitePlanResult } from '../core/migrations/planner';
+export { createSqliteMigrationPlanner, SqliteMigrationPlanner } from '../core/migrations/planner';

package/src/exports/render-ops.ts

@@ -0,0 +1 @@
+export { renderOps } from '../core/migrations/render-ops';

package/src/exports/sql-utils.ts

@@ -0,0 +1 @@
+export { escapeLiteral, quoteIdentifier, SqlEscapeError } from '../core/sql-utils';

package/src/exports/statement-builders.ts

@@ -0,0 +1,12 @@
+export {
+  APP_SPACE_ID,
+  buildLedgerInsertStatement,
+  buildWriteMarkerStatements,
+  CONTROL_TABLE_NAMES,
+  ensureLedgerTableStatement,
+  ensureMarkerTableStatement,
+  LEDGER_TABLE_NAME,
+  MARKER_TABLE_NAME,
+  readMarkerStatement,
+  type SqlStatement,
+} from '../core/migrations/statement-builders';

package/dist/descriptor-meta-DbuuziYA.mjs

@@ -1,14 +0,0 @@
-//#region src/core/descriptor-meta.ts
-const sqliteTargetDescriptorMetaBase = {
-	kind: "target",
-	familyId: "sql",
-	targetId: "sqlite",
-	id: "sqlite",
-	version: "0.0.1",
-	capabilities: {}
-};
-const sqliteTargetDescriptorMeta = sqliteTargetDescriptorMetaBase;
-
-//#endregion
-export { sqliteTargetDescriptorMeta as t };
-//# sourceMappingURL=descriptor-meta-DbuuziYA.mjs.map

package/dist/descriptor-meta-DbuuziYA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-DbuuziYA.mjs","names":["sqliteTargetDescriptorMeta: typeof sqliteTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecTypes } from '@prisma-next/adapter-sqlite/codec-types';\n\nconst sqliteTargetDescriptorMetaBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'sqlite',\n  id: 'sqlite',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const sqliteTargetDescriptorMeta: typeof sqliteTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = sqliteTargetDescriptorMetaBase;\n"],"mappings":";AAEA,MAAM,iCAAiC;CACrC,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CACjB;AAED,MAAaA,6BAET"}