@shapecraft/core 1.0.0

package/src/shape/transforms/sql/dialects/sqlite.ts

@@ -0,0 +1,333 @@
+import { R } from "../../../../common/result";
+import { shapes } from "../../../shape";
+import { NumberTag } from "../../../tags";
+import {
+  ColumnDef,
+  Dialect,
+  FormatDefault,
+  Prelude,
+  quoteIdent,
+  quoteLit,
+  TypeRendering,
+} from "./dialect";
+
+const INT_RANGES: Record<string, { minimum?: number; maximum?: number }> = {
+  int8: { minimum: -128, maximum: 127 },
+  uint8: { minimum: 0, maximum: 255 },
+  int16: { minimum: -32768, maximum: 32767 },
+  uint16: { minimum: 0, maximum: 65535 },
+  int32: { minimum: -2_147_483_648, maximum: 2_147_483_647 },
+  uint32: { minimum: 0, maximum: 4_294_967_295 },
+  uint64: { minimum: 0 },
+};
+
+const INT_TAGS = new Set([
+  "int",
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+]);
+
+const isIntTag = (tag: NumberTag): boolean => INT_TAGS.has(tag);
+
+// SQLite's INTEGER affinity stores values up to 8 bytes (signed 64-bit). We
+// model its natural range so the int-tag-range intersection logic only emits
+// CHECKs when the tag's range is tighter than SQLite's.
+const SQLITE_INTEGER_MIN = -9_223_372_036_854_775_808;
+const SQLITE_INTEGER_MAX = 9_223_372_036_854_775_807;
+
+const formatNumberLit = (n: number): string => {
+  if (!isFinite(n)) return quoteLit(String(n));
+  return String(n);
+};
+
+const unionEnumValues = (u: shapes.ShapeUnion): string[] | null => {
+  const variants = Array.from(u.input) as shapes.Shape[];
+  if (variants.length === 0) return null;
+  const values: string[] = [];
+  for (const v of variants) {
+    if (v.type !== "string" || v.literal !== true) return null;
+    values.push(v.input as string);
+  }
+  return values;
+};
+
+const renderType = (
+  name: string,
+  shape: shapes.Shape,
+): R.Result<TypeRendering, string[]> => {
+  const errors: string[] = [];
+  const prelude: Prelude[] = [];
+  const checks: string[] = [];
+  let sqlType: string | null = null;
+
+  const col = quoteIdent(name);
+
+  if (shape.type === "union") {
+    const values = unionEnumValues(shape);
+    if (values !== null) {
+      sqlType = "TEXT";
+      checks.push(`${col} IN (${values.map(quoteLit).join(", ")})`);
+    } else {
+      sqlType = "TEXT";
+      checks.push(`json_valid(${col})`);
+    }
+  } else {
+    switch (shape.type) {
+      case "string": {
+        sqlType = "TEXT";
+        if (shape.literal) {
+          checks.push(`${col} = ${quoteLit(shape.input as string)}`);
+        } else {
+          if (shape.anno.max !== undefined)
+            checks.push(`length(${col}) <= ${shape.anno.max}`);
+          if (shape.anno.min !== undefined)
+            checks.push(`length(${col}) >= ${shape.anno.min}`);
+          if (shape.anno.pattern !== undefined) {
+            const src =
+              shape.anno.pattern instanceof RegExp ?
+                shape.anno.pattern.source
+              : shape.anno.pattern;
+            checks.push(`${col} REGEXP ${quoteLit(src)}`);
+          }
+        }
+        break;
+      }
+      case "boolean": {
+        sqlType = "INTEGER";
+        if (shape.literal) {
+          const v = shape.input as boolean;
+          checks.push(`${col} = ${v ? "1" : "0"}`);
+        } else {
+          checks.push(`${col} IN (0, 1)`);
+        }
+        break;
+      }
+      case "number": {
+        if (shape.literal) {
+          sqlType = isIntTag(shape.tag) ? "INTEGER" : "REAL";
+          checks.push(`${col} = ${formatNumberLit(shape.input as number)}`);
+        } else if (isIntTag(shape.tag)) {
+          sqlType = "INTEGER";
+          const natural = INT_RANGES[shape.tag];
+          let effMin: number | undefined = natural?.minimum;
+          let effMax: number | undefined = natural?.maximum;
+          if (shape.anno.min !== undefined) {
+            effMin =
+              effMin === undefined ?
+                shape.anno.min
+              : Math.max(effMin, shape.anno.min);
+          }
+          if (shape.anno.max !== undefined) {
+            effMax =
+              effMax === undefined ?
+                shape.anno.max
+              : Math.min(effMax, shape.anno.max);
+          }
+          if (effMin !== undefined && effMin > SQLITE_INTEGER_MIN) {
+            checks.push(`${col} >= ${effMin}`);
+          }
+          if (effMax !== undefined && effMax < SQLITE_INTEGER_MAX) {
+            checks.push(`${col} <= ${effMax}`);
+          }
+        } else {
+          sqlType = "REAL";
+          if (shape.anno.min !== undefined)
+            checks.push(`${col} >= ${shape.anno.min}`);
+          if (shape.anno.max !== undefined)
+            checks.push(`${col} <= ${shape.anno.max}`);
+        }
+        break;
+      }
+      case "date":
+        sqlType = "TEXT";
+        break;
+      case "binary":
+        sqlType = "BLOB";
+        break;
+      case "unknown":
+        sqlType = "TEXT";
+        checks.push(`json_valid(${col})`);
+        break;
+      case "nil":
+        errors.push(`field '${name}': nil cannot be a column`);
+        break;
+      case "undefined":
+        errors.push(`field '${name}': undefined cannot be a column`);
+        break;
+      case "array": {
+        sqlType = "TEXT";
+        checks.push(`json_valid(${col})`);
+        if (shape.anno.min !== undefined)
+          checks.push(`json_array_length(${col}) >= ${shape.anno.min}`);
+        if (shape.anno.max !== undefined)
+          checks.push(`json_array_length(${col}) <= ${shape.anno.max}`);
+        if (shape.anno.uniqueItems === true) {
+          checks.push(
+            `(SELECT COUNT(*) FROM json_each(${col})) = (SELECT COUNT(DISTINCT value) FROM json_each(${col}))`,
+          );
+        }
+        break;
+      }
+      case "vector": {
+        sqlType = "BLOB";
+        checks.push(`length(${col}) = ${shape.input.dims * 4}`);
+        break;
+      }
+      case "range": {
+        sqlType = "TEXT";
+        checks.push(`json_valid(${col})`);
+        break;
+      }
+      case "mapping":
+      case "record":
+        sqlType = "TEXT";
+        checks.push(`json_valid(${col})`);
+        break;
+      case "tuple": {
+        sqlType = "TEXT";
+        const len = shape.input.length;
+        checks.push(
+          `json_valid(${col}) AND json_array_length(${col}) = ${len}`,
+        );
+        break;
+      }
+    }
+  }
+
+  if (sqlType === null) {
+    return R.err(errors);
+  }
+  if (errors.length > 0) return R.err(errors);
+
+  return R.ok({ type: sqlType, checks, prelude });
+};
+
+const formatDefault = (v: unknown, _columnType: string): FormatDefault => {
+  if (v === null) return { ok: true, expr: "NULL" };
+  if (typeof v === "string") return { ok: true, expr: quoteLit(v) };
+  if (typeof v === "number") return { ok: true, expr: formatNumberLit(v) };
+  if (typeof v === "boolean") return { ok: true, expr: v ? "1" : "0" };
+  if (v instanceof Date) return { ok: true, expr: quoteLit(v.toISOString()) };
+  if (typeof v === "object") {
+    try {
+      return { ok: true, expr: quoteLit(JSON.stringify(v)) };
+    } catch {
+      return { ok: false, reason: "default value could not be JSON-encoded" };
+    }
+  }
+  return {
+    ok: false,
+    reason: `default value of type ${typeof v} is not supported`,
+  };
+};
+
+const applyAutoIncrement = (
+  name: string,
+  shape: shapes.Shape,
+  col: ColumnDef,
+): string[] => {
+  if (shape.type !== "number" || !isIntTag(shape.tag)) {
+    return [`field '${name}': autoIncrement requires an integer type`];
+  }
+  if (shape.tag === "uint64") {
+    return [
+      `field '${name}': autoIncrement is not supported on uint64 in sqlite`,
+    ];
+  }
+  // SQLite's AUTOINCREMENT only works with INTEGER PRIMARY KEY. Auto-promote
+  // to primary (per SQLite's INTEGER PRIMARY KEY auto-increment semantics)
+  // and force NOT NULL.
+  col.identity = true;
+  col.primary = true;
+  col.notNull = true;
+  return [];
+};
+
+const renderColumn = (c: ColumnDef): string => {
+  const parts: string[] = [quoteIdent(c.name)];
+
+  if (c.identity && c.primary) {
+    // INTEGER PRIMARY KEY AUTOINCREMENT must appear as a single contiguous
+    // column-level clause in SQLite. NOT NULL is implied; UNIQUE is implied.
+    parts.push("INTEGER", "PRIMARY", "KEY", "AUTOINCREMENT");
+    if (c.defaultExpr !== undefined) parts.push(`DEFAULT ${c.defaultExpr}`);
+    if (c.references !== undefined) parts.push(`REFERENCES ${c.references}`);
+    for (const chk of c.checks) parts.push(`CHECK (${chk})`);
+    return parts.join(" ");
+  }
+
+  parts.push(c.type);
+
+  if (c.generated !== undefined) {
+    parts.push(
+      `GENERATED ALWAYS AS (${c.generated.expression}) ${c.generated.stored ? "STORED" : "VIRTUAL"}`,
+    );
+    if (c.primary) parts.push("PRIMARY KEY");
+    if (c.unique) parts.push("UNIQUE");
+    if (c.references !== undefined) parts.push(`REFERENCES ${c.references}`);
+    for (const chk of c.checks) parts.push(`CHECK (${chk})`);
+    return parts.join(" ");
+  }
+  if (c.notNull) parts.push("NOT NULL");
+  if (c.primary) parts.push("PRIMARY KEY");
+  if (c.unique) parts.push("UNIQUE");
+  if (c.defaultExpr !== undefined) parts.push(`DEFAULT ${c.defaultExpr}`);
+  if (c.references !== undefined) parts.push(`REFERENCES ${c.references}`);
+  for (const chk of c.checks) parts.push(`CHECK (${chk})`);
+  return parts.join(" ");
+};
+
+const validateMappingAnno = (
+  anno: shapes.Shape["anno"],
+  title: string,
+): string[] => {
+  const errors: string[] = [];
+  if (anno.schema !== undefined) {
+    errors.push(
+      `table '${title}': sqlite has no schemas; remove anno.schema or use dialect='postgres'`,
+    );
+  }
+  return errors;
+};
+
+const finalizeColumns = (cols: ColumnDef[]): string[] => {
+  const identityCols = cols.filter((c) => c.identity);
+  if (identityCols.length === 0) return [];
+  if (identityCols.length > 1) {
+    return [
+      `multiple autoIncrement columns are not supported in sqlite: ${identityCols
+        .map((c) => `'${c.name}'`)
+        .join(", ")}`,
+    ];
+  }
+  const ai = identityCols[0]!;
+  const otherPrimaries = cols.filter((c) => c !== ai && c.primary);
+  if (otherPrimaries.length > 0) {
+    return [
+      `autoIncrement column '${ai.name}' must be the sole primary key in sqlite, but also: ${otherPrimaries
+        .map((c) => `'${c.name}'`)
+        .join(", ")}`,
+    ];
+  }
+  return [];
+};
+
+export const sqliteDialect: Dialect = {
+  name: "sqlite",
+  supportsSchema: false,
+  tableTrailer: " STRICT",
+  renderType,
+  applyAutoIncrement,
+  formatDefault,
+  validateMappingAnno,
+  schemaPrelude: () => "",
+  qualifiedTable: (_schema, title) => quoteIdent(title),
+  renderColumn,
+  finalizeColumns,
+};