@prisma-next/target-sqlite 0.5.0-dev.19 → 0.5.0-dev.20

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

@@ -0,0 +1,190 @@
+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,
+]);
+
+export const ensureMarkerTableStatement: SqlStatement = {
+  sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    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(): SqlStatement {
+  return {
+    sql: `SELECT
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta,
+      invariants
+    FROM _prisma_marker
+    WHERE id = ?`,
+    params: [1],
+  };
+}
+
+export interface WriteMarkerInput {
+  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[] = [
+    1,
+    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 (
+        id,
+        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 id = ?`,
+      params: [
+        input.storageHash,
+        input.profileHash,
+        jsonParam(input.contractJson),
+        input.canonicalVersion ?? null,
+        input.appTag ?? null,
+        jsonParam(input.meta ?? {}),
+        jsonParam(input.invariants),
+        1,
+      ],
+    },
+  };
+}
+
+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/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,6 @@
+import type { CodecTypes as CoreCodecTypes, JsonValue } from '../core/codecs';
+
+export type CodecTypes = CoreCodecTypes;
+
+export type { JsonValue };
+export { dataTypes } from '../core/codecs';

package/src/exports/codecs.ts

@@ -0,0 +1 @@
+export { type CodecTypes, codecDefinitions, dataTypes, type JsonValue } from '../core/codecs';

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,23 @@
+// 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 { 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,11 @@
+export {
+  AddColumnCall,
+  CreateIndexCall,
+  CreateTableCall,
+  DataTransformCall,
+  DropColumnCall,
+  DropIndexCall,
+  DropTableCall,
+  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,11 @@
+export {
+  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.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"}