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

package/src/core/codecs.ts

@@ -0,0 +1,337 @@
+/**
+ * Native SQLite target codecs (TML-2357). Mirrors the Postgres codec class form in `packages/3-targets/3-targets/postgres/src/core/codecs.ts`.
+ *
+ * Each codec ships as three artifacts:
+ *
+ * 1. A `SqliteXCodec` class extending {@link CodecImpl} that wraps the encode/decode/encodeJson/decodeJson conversions inline. SQLite's runtime conversions are simple enough that there is no shared helper module; the class bodies are the single source of truth. 2. A `SqliteXDescriptor` class extending {@link CodecDescriptorImpl} declaring the codec id, traits, target types, and params schema. SQLite codecs do not carry
+ * `meta` (no per-target native-type meta today) and are all non-parameterized. 3. A per-codec column helper (`sqliteXColumn`) that calls `descriptor.factory()` directly and packages the result into a {@link ColumnSpec} via the framework {@link column} packager. The helper is tied to its descriptor with `satisfies ColumnHelperFor` + `ColumnHelperForStrict` (every SQLite codec's resolved type is well-defined).
+ *
+ * After TML-2357 this is the canonical source of SQLite codec metadata and runtime behaviour — the legacy `mkCodec` / `defineCodec` carriers (and the parallel `byScalar` / `codecDescriptorDefinitions` collection exports) retired with the deletion sweep.
+ *
+ * Audit: every SQLite codec is non-parameterized and parameter-stateless; `factory()` takes no params (`P = void`) and returns a fresh codec constructed solely from `this`.
+ */
+
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type CodecCallContext,
+  CodecDescriptorImpl,
+  CodecImpl,
+  type CodecInstanceContext,
+  type ColumnHelperFor,
+  type ColumnHelperForStrict,
+  column,
+  voidParamsSchema,
+} from '@prisma-next/framework-components/codec';
+import {
+  sqlCharDescriptor,
+  sqlFloatDescriptor,
+  sqlIntDescriptor,
+  sqlVarcharDescriptor,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  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 './codec-ids';
+
+export class SqliteTextCodec extends CodecImpl<
+  typeof SQLITE_TEXT_CODEC_ID,
+  readonly ['equality', 'order', 'textual'],
+  string,
+  string
+> {
+  async encode(value: string, _ctx: CodecCallContext): Promise<string> {
+    return value;
+  }
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
+  }
+  encodeJson(value: string): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): string {
+    return json as string;
+  }
+}
+
+export class SqliteTextDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_TEXT_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'textual'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteTextCodec {
+    return () => new SqliteTextCodec(this);
+  }
+}
+
+export const sqliteTextDescriptor = new SqliteTextDescriptor();
+
+export const sqliteTextColumn = () =>
+  column(sqliteTextDescriptor.factory(), sqliteTextDescriptor.codecId, undefined, 'text');
+
+sqliteTextColumn satisfies ColumnHelperFor<SqliteTextDescriptor>;
+sqliteTextColumn satisfies ColumnHelperForStrict<SqliteTextDescriptor>;
+
+export class SqliteIntegerCodec extends CodecImpl<
+  typeof SQLITE_INTEGER_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number,
+  number
+> {
+  async encode(value: number, _ctx: CodecCallContext): Promise<number> {
+    return value;
+  }
+  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {
+    return wire;
+  }
+  encodeJson(value: number): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): number {
+    return json as number;
+  }
+}
+
+export class SqliteIntegerDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_INTEGER_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['integer'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteIntegerCodec {
+    return () => new SqliteIntegerCodec(this);
+  }
+}
+
+export const sqliteIntegerDescriptor = new SqliteIntegerDescriptor();
+
+export const sqliteIntegerColumn = () =>
+  column(sqliteIntegerDescriptor.factory(), sqliteIntegerDescriptor.codecId, undefined, 'integer');
+
+sqliteIntegerColumn satisfies ColumnHelperFor<SqliteIntegerDescriptor>;
+sqliteIntegerColumn satisfies ColumnHelperForStrict<SqliteIntegerDescriptor>;
+
+export class SqliteRealCodec extends CodecImpl<
+  typeof SQLITE_REAL_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number,
+  number
+> {
+  async encode(value: number, _ctx: CodecCallContext): Promise<number> {
+    return value;
+  }
+  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {
+    return wire;
+  }
+  encodeJson(value: number): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): number {
+    return json as number;
+  }
+}
+
+export class SqliteRealDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_REAL_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['real'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteRealCodec {
+    return () => new SqliteRealCodec(this);
+  }
+}
+
+export const sqliteRealDescriptor = new SqliteRealDescriptor();
+
+export const sqliteRealColumn = () =>
+  column(sqliteRealDescriptor.factory(), sqliteRealDescriptor.codecId, undefined, 'real');
+
+sqliteRealColumn satisfies ColumnHelperFor<SqliteRealDescriptor>;
+sqliteRealColumn satisfies ColumnHelperForStrict<SqliteRealDescriptor>;
+
+export class SqliteBlobCodec extends CodecImpl<
+  typeof SQLITE_BLOB_CODEC_ID,
+  readonly ['equality'],
+  Uint8Array,
+  Uint8Array
+> {
+  async encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {
+    return value;
+  }
+  async decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {
+    return wire;
+  }
+  encodeJson(value: Uint8Array): JsonValue {
+    return Buffer.from(value).toString('base64');
+  }
+  decodeJson(json: JsonValue): Uint8Array {
+    if (typeof json !== 'string') {
+      throw new TypeError('sqlite/blob@1 contract value must be a base64 string');
+    }
+    return new Uint8Array(Buffer.from(json, 'base64'));
+  }
+}
+
+export class SqliteBlobDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_BLOB_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['blob'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteBlobCodec {
+    return () => new SqliteBlobCodec(this);
+  }
+}
+
+export const sqliteBlobDescriptor = new SqliteBlobDescriptor();
+
+export const sqliteBlobColumn = () =>
+  column(sqliteBlobDescriptor.factory(), sqliteBlobDescriptor.codecId, undefined, 'blob');
+
+sqliteBlobColumn satisfies ColumnHelperFor<SqliteBlobDescriptor>;
+sqliteBlobColumn satisfies ColumnHelperForStrict<SqliteBlobDescriptor>;
+
+export class SqliteDatetimeCodec extends CodecImpl<
+  typeof SQLITE_DATETIME_CODEC_ID,
+  readonly ['equality', 'order'],
+  string,
+  Date
+> {
+  // Reject `Invalid Date` (NaN-time) at every decode ingress so consumers never receive a Date object whose downstream operations silently produce NaN. Mirrors the stricter ISO-8601 validation on the postgres timestamp helpers.
+  private parseDate(value: string): Date {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError(`sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`);
+    }
+    return date;
+  }
+  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {
+    return value.toISOString();
+  }
+  async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {
+    return this.parseDate(wire);
+  }
+  encodeJson(value: Date): JsonValue {
+    return value.toISOString();
+  }
+  decodeJson(json: JsonValue): Date {
+    if (typeof json !== 'string') {
+      throw new TypeError('sqlite/datetime@1 contract value must be an ISO-8601 string');
+    }
+    return this.parseDate(json);
+  }
+}
+
+export class SqliteDatetimeDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_DATETIME_CODEC_ID;
+  override readonly traits = ['equality', 'order'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteDatetimeCodec {
+    return () => new SqliteDatetimeCodec(this);
+  }
+}
+
+export const sqliteDatetimeDescriptor = new SqliteDatetimeDescriptor();
+
+export const sqliteDatetimeColumn = () =>
+  column(sqliteDatetimeDescriptor.factory(), sqliteDatetimeDescriptor.codecId, undefined, 'text');
+
+sqliteDatetimeColumn satisfies ColumnHelperFor<SqliteDatetimeDescriptor>;
+sqliteDatetimeColumn satisfies ColumnHelperForStrict<SqliteDatetimeDescriptor>;
+
+export class SqliteJsonCodec extends CodecImpl<
+  typeof SQLITE_JSON_CODEC_ID,
+  readonly ['equality'],
+  string | JsonValue,
+  JsonValue
+> {
+  async encode(value: JsonValue, _ctx: CodecCallContext): Promise<string> {
+    return JSON.stringify(value);
+  }
+  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue> {
+    return typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire;
+  }
+  encodeJson(value: JsonValue): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): JsonValue {
+    return json;
+  }
+}
+
+export class SqliteJsonDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_JSON_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteJsonCodec {
+    return () => new SqliteJsonCodec(this);
+  }
+}
+
+export const sqliteJsonDescriptor = new SqliteJsonDescriptor();
+
+export const sqliteJsonColumn = () =>
+  column(sqliteJsonDescriptor.factory(), sqliteJsonDescriptor.codecId, undefined, 'text');
+
+sqliteJsonColumn satisfies ColumnHelperFor<SqliteJsonDescriptor>;
+sqliteJsonColumn satisfies ColumnHelperForStrict<SqliteJsonDescriptor>;
+
+export class SqliteBigintCodec extends CodecImpl<
+  typeof SQLITE_BIGINT_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number | bigint,
+  bigint
+> {
+  async encode(value: bigint, _ctx: CodecCallContext): Promise<number | bigint> {
+    return value;
+  }
+  async decode(wire: number | bigint, _ctx: CodecCallContext): Promise<bigint> {
+    return BigInt(wire);
+  }
+  encodeJson(value: bigint): JsonValue {
+    return value.toString();
+  }
+  decodeJson(json: JsonValue): bigint {
+    if (typeof json !== 'string' && typeof json !== 'number') {
+      throw new TypeError('sqlite/bigint@1 contract value must be a string or number');
+    }
+    return BigInt(json);
+  }
+}
+
+export class SqliteBigintDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_BIGINT_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['integer'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteBigintCodec {
+    return () => new SqliteBigintCodec(this);
+  }
+}
+
+export const sqliteBigintDescriptor = new SqliteBigintDescriptor();
+
+export const sqliteBigintColumn = () =>
+  column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, undefined, 'integer');
+
+sqliteBigintColumn satisfies ColumnHelperFor<SqliteBigintDescriptor>;
+sqliteBigintColumn satisfies ColumnHelperForStrict<SqliteBigintDescriptor>;
+
+export const codecDescriptors: readonly AnyCodecDescriptor[] = [
+  sqlCharDescriptor,
+  sqlVarcharDescriptor,
+  sqlIntDescriptor,
+  sqlFloatDescriptor,
+  sqliteTextDescriptor,
+  sqliteIntegerDescriptor,
+  sqliteRealDescriptor,
+  sqliteBlobDescriptor,
+  sqliteDatetimeDescriptor,
+  sqliteJsonDescriptor,
+  sqliteBigintDescriptor,
+];

package/src/core/control-target.ts

@@ -1,18 +1,60 @@
+import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type {
+  SqlControlFamilyInstance,
+  SqlControlTargetDescriptor,
+} from '@prisma-next/family-sql/control';
+import { contractToSchemaIR } from '@prisma-next/family-sql/control';
 import type {
-  ControlTargetDescriptor,
   ControlTargetInstance,
+  MigrationPlanner,
+  MigrationRunner,
 } from '@prisma-next/framework-components/control';
+import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+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';
+
+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: ControlTargetDescriptor<
-  'sql',
-  'sqlite',
-  ControlTargetInstance<'sql', 'sqlite'>
-> = {
-  ...sqliteTargetDescriptorMeta,
-  create(): ControlTargetInstance<'sql', 'sqlite'> {
-    return { familyId: 'sql', targetId: 'sqlite' };
-  },
-};
+const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', SqlitePlanTargetDetails> =
+  {
+    ...sqliteTargetDescriptorMeta,
+    migrations: {
+      createPlanner(_family: SqlControlFamilyInstance): MigrationPlanner<'sql', 'sqlite'> {
+        return createSqliteMigrationPlanner();
+      },
+      createRunner(family) {
+        return createSqliteMigrationRunner(family) as MigrationRunner<'sql', 'sqlite'>;
+      },
+      contractToSchema(contract, _frameworkComponents) {
+        return contractToSchemaIR(contract as Contract<SqlStorage> | null, {
+          annotationNamespace: 'sqlite',
+          renderDefault: sqliteRenderDefault,
+        });
+      },
+    },
+    create(): ControlTargetInstance<'sql', 'sqlite'> {
+      return {
+        familyId: 'sql',
+        targetId: 'sqlite',
+      };
+    },
+    createPlanner(_family: SqlControlFamilyInstance) {
+      return createSqliteMigrationPlanner();
+    },
+    createRunner(family) {
+      return createSqliteMigrationRunner(family);
+    },
+  };
 
 export default sqliteControlTargetDescriptor;

package/src/core/default-normalizer.ts

@@ -0,0 +1,92 @@
+/**
+ * Normalizes SQLite's stored default expressions back into the
+ * `ColumnDefault` shape the verifier compares against. Lives target-side
+ * (mirroring Postgres's `target-postgres/src/core/default-normalizer.ts`)
+ * so both the control adapter (`SqliteControlAdapter.introspect`) and the
+ * planner / runner schema-verify path can consume it without
+ * `target-sqlite` reaching into `adapter-sqlite`.
+ */
+
+import type { ColumnDefault } from '@prisma-next/contract/types';
+
+const NULL_PATTERN = /^NULL$/i;
+const INTEGER_PATTERN = /^-?\d+$/;
+const REAL_PATTERN = /^-?\d+\.\d+(?:[eE][+-]?\d+)?$/;
+const HEX_PATTERN = /^0[xX][\dA-Fa-f]+$/;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'$/;
+
+function isNumericLiteral(value: string): boolean {
+  return INTEGER_PATTERN.test(value) || REAL_PATTERN.test(value) || HEX_PATTERN.test(value);
+}
+
+/**
+ * Strips a single matched wrapping pair of outer parens from `s`. Conservative:
+ * only strips when the leading `(` is matched by the trailing `)` (so
+ * `(a) + (b)` is returned unchanged). Mirrors SQLite's own
+ * `pragma_table_info.dflt_value` normalization for expression defaults, and
+ * is shared with the recreate-table postcheck builder so both sides agree
+ * on the canonical form.
+ */
+export function stripOuterParens(s: string): string {
+  if (!s.startsWith('(') || !s.endsWith(')')) return s;
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '(') depth += 1;
+    else if (s[i] === ')') {
+      depth -= 1;
+      if (depth === 0 && i < s.length - 1) return s;
+    }
+  }
+  return s.slice(1, -1);
+}
+
+export function parseSqliteDefault(
+  rawDefault: string,
+  nativeType?: string,
+): ColumnDefault | undefined {
+  let trimmed = rawDefault.trim();
+
+  // Strip outer parentheses that SQLite adds around expressions. Iterate to
+  // fixpoint so accidental double-wrapping (e.g. `((expr))`) collapses too.
+  while (true) {
+    const stripped = stripOuterParens(trimmed).trim();
+    if (stripped === trimmed) break;
+    trimmed = stripped;
+  }
+
+  // SQLite has several spellings for "current timestamp" — `CURRENT_TIMESTAMP`
+  // (keyword) and `datetime('now')` / `datetime("now")` (function call). The
+  // contract authoring side canonicalizes `dbgenerated("CURRENT_TIMESTAMP")`
+  // (and friends) to `now()` via `lowerDbgenerated`; mirror that here so a
+  // schema produced by either spelling round-trips to the same canonical
+  // form for verification.
+  const lower = trimmed.toLowerCase();
+  if (lower === 'current_timestamp' || lower === "datetime('now')" || lower === 'datetime("now")') {
+    return { kind: 'function', expression: 'now()' };
+  }
+
+  if (NULL_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: null };
+  }
+
+  // SQLite integers are 64-bit, so values outside the JS safe-integer range can't
+  // be faithfully represented as `number`. Mirror `parsePostgresDefault`'s bigint
+  // handling: parse as JS `number` when safe, fall back to the raw text otherwise.
+  if (isNumericLiteral(trimmed)) {
+    const num = Number(trimmed);
+    if (!Number.isFinite(num)) return undefined;
+    if (nativeType?.toLowerCase() === 'integer' && !Number.isSafeInteger(num)) {
+      return { kind: 'literal', value: trimmed };
+    }
+    return { kind: 'literal', value: num };
+  }
+
+  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
+  if (stringMatch?.[1] !== undefined) {
+    const unescaped = stringMatch[1].replace(/''/g, "'");
+    return { kind: 'literal', value: unescaped };
+  }
+
+  // Unrecognized expression — preserve as function
+  return { kind: 'function', expression: trimmed };
+}

package/src/core/descriptor-meta.ts

@@ -1,4 +1,5 @@
-import type { CodecTypes } from '@prisma-next/adapter-sqlite/codec-types';
+import type { CodecTypes } from '../exports/codec-types';
+import { sqliteAuthoringFieldPresets } from './authoring';
 
 const sqliteTargetDescriptorMetaBase = {
   kind: 'target',
@@ -7,6 +8,9 @@ const sqliteTargetDescriptorMetaBase = {
   id: 'sqlite',
   version: '0.0.1',
   capabilities: {},
+  authoring: {
+    field: sqliteAuthoringFieldPresets,
+  },
 } as const;
 
 export const sqliteTargetDescriptorMeta: typeof sqliteTargetDescriptorMetaBase & {