shapecraft 1.0.0

package/packages/core/src/shape/transforms/sql/parser/pg-types.ts

@@ -0,0 +1,247 @@
+import { annotate, shapes } from "../../../shape";
+import { CompositeDef, EnumDef } from "./create-type";
+import {
+  numberShapeForTag,
+  numIntArg,
+  parseTypeSpec,
+  ParsedTypeSpec,
+} from "./type-spec";
+
+// Re-export under the legacy names so existing callers keep working.
+export { parseTypeSpec as parsePgType } from "./type-spec";
+export type { ParsedTypeSpec as ParsedPgType } from "./type-spec";
+
+export type Registries = {
+  enums: Map<string, EnumDef>;
+  composites: Map<string, CompositeDef>;
+  domains: Map<string, ResolvedDomain>;
+};
+
+// Resolved (post-pg-type-resolution) domain — after we've consumed the base
+// type and folded the CHECK into an Annotation.
+export type ResolvedDomain = {
+  schema?: string;
+  name: string;
+  shape: shapes.Shape;
+};
+
+const UUID_PATTERN_RE =
+  /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+
+export type ResolveResult = {
+  shape: shapes.Shape;
+  // True if this type implies an auto-incrementing column (SERIAL family)
+  autoIncrement?: boolean;
+};
+
+export const resolvePgType = (
+  spec: ParsedTypeSpec,
+  registries: Registries,
+): ResolveResult => {
+  if (spec.isArray) {
+    const inner = resolvePgType({ ...spec, isArray: false }, registries);
+    return { shape: shapes.array(inner.shape) };
+  }
+
+  // Domain lookup first (qualified or bare)
+  if (spec.qualified !== undefined) {
+    const d = registries.domains.get(spec.qualified);
+    if (d !== undefined) return { shape: d.shape };
+  }
+  {
+    const d = registries.domains.get(spec.baseName);
+    if (d !== undefined) return { shape: d.shape };
+  }
+
+  // Enum lookup (qualified or bare)
+  if (spec.qualified !== undefined) {
+    const e = registries.enums.get(spec.qualified);
+    if (e !== undefined) return { shape: enumToShape(e) };
+  }
+  {
+    const e = registries.enums.get(spec.baseName);
+    if (e !== undefined) return { shape: enumToShape(e) };
+  }
+
+  // Composite lookup: v1 falls back to unknown + format hint
+  if (spec.qualified !== undefined) {
+    const comp = registries.composites.get(spec.qualified);
+    if (comp !== undefined) {
+      return {
+        shape: annotate.as(shapes.unknown(), {
+          format: `pgtype:${spec.qualified}`,
+        }),
+      };
+    }
+  }
+
+  // Built-in types
+  const name = spec.baseName;
+
+  switch (name) {
+    case "uuid": {
+      const s = annotate.format(
+        annotate.pattern(shapes.string(), UUID_PATTERN_RE),
+        "uuid",
+      );
+      return { shape: s };
+    }
+    case "text": {
+      return { shape: shapes.string() };
+    }
+    case "citext": {
+      return {
+        shape: annotate.as(shapes.string(), { format: "pgtype:citext" }),
+      };
+    }
+    case "varchar":
+    case "character varying": {
+      const n = numIntArg(spec.args[0]);
+      if (n !== null) {
+        return { shape: annotate.max(shapes.string(), n) };
+      }
+      return { shape: shapes.string() };
+    }
+    case "char":
+    case "character":
+    case "bpchar": {
+      const n = numIntArg(spec.args[0]);
+      const len = n ?? 1;
+      return {
+        shape: annotate.min(annotate.max(shapes.string(), len), len),
+      };
+    }
+    case "smallint":
+    case "int2": {
+      return { shape: numberShapeForTag("int16") };
+    }
+    case "integer":
+    case "int":
+    case "int4": {
+      return { shape: numberShapeForTag("int32") };
+    }
+    case "bigint":
+    case "int8": {
+      return { shape: numberShapeForTag("int64") };
+    }
+    case "smallserial":
+    case "serial2": {
+      return { shape: numberShapeForTag("int16"), autoIncrement: true };
+    }
+    case "serial":
+    case "serial4": {
+      return { shape: numberShapeForTag("int32"), autoIncrement: true };
+    }
+    case "bigserial":
+    case "serial8": {
+      return { shape: numberShapeForTag("int64"), autoIncrement: true };
+    }
+    case "numeric":
+    case "decimal": {
+      const p = numIntArg(spec.args[0]);
+      const s = numIntArg(spec.args[1]);
+      if (p === 20 && s === 0) {
+        return { shape: numberShapeForTag("uint64") };
+      }
+      if (p !== null) {
+        const fmt =
+          s !== null ? `pgtype:numeric(${p},${s})` : `pgtype:numeric(${p})`;
+        return { shape: annotate.as(shapes.number(), { format: fmt }) };
+      }
+      return { shape: shapes.number() };
+    }
+    case "real":
+    case "float4": {
+      return { shape: numberShapeForTag("float32") };
+    }
+    case "double precision":
+    case "float8": {
+      return { shape: numberShapeForTag("float64") };
+    }
+    case "float": {
+      const p = numIntArg(spec.args[0]);
+      if (p !== null && p <= 24) return { shape: numberShapeForTag("float32") };
+      return { shape: numberShapeForTag("float64") };
+    }
+    case "boolean":
+    case "bool": {
+      return { shape: shapes.boolean() };
+    }
+    case "date":
+    case "time":
+    case "timetz":
+    case "timestamp":
+    case "timestamptz":
+    case "timestamp with time zone":
+    case "timestamp without time zone":
+    case "time with time zone":
+    case "time without time zone": {
+      const fmt = `pgtype:${name.replace(/ /g, "_")}`;
+      return { shape: annotate.as(shapes.date(), { format: fmt }) };
+    }
+    case "jsonb":
+    case "json": {
+      return {
+        shape: annotate.as(shapes.unknown(), { format: `pgtype:${name}` }),
+      };
+    }
+    case "bytea": {
+      return { shape: shapes.binary() };
+    }
+    case "vector": {
+      const n = numIntArg(spec.args[0]);
+      if (n !== null) return { shape: shapes.vector(n, shapes.float()) };
+      return { shape: shapes.vector(0, shapes.float()) };
+    }
+    case "tstzrange": {
+      return {
+        shape: annotate.as(shapes.range(shapes.date()), {
+          format: "pgtype:tstzrange",
+        }),
+      };
+    }
+    case "tsrange": {
+      return {
+        shape: annotate.as(shapes.range(shapes.date()), {
+          format: "pgtype:tsrange",
+        }),
+      };
+    }
+    case "daterange": {
+      return {
+        shape: annotate.as(shapes.range(shapes.date()), {
+          format: "pgtype:daterange",
+        }),
+      };
+    }
+    case "int4range": {
+      return { shape: shapes.range(shapes.int32()) };
+    }
+    case "int8range": {
+      return { shape: shapes.range(shapes.int64()) };
+    }
+    case "numrange": {
+      return { shape: shapes.range(shapes.number()) };
+    }
+  }
+
+  // Fall back: unknown + format hint preserving the original
+  const original =
+    spec.qualified !== undefined ? spec.qualified : spec.baseName;
+  const argsSuffix = spec.args.length > 0 ? `(${spec.args.join(",")})` : "";
+  return {
+    shape: annotate.as(shapes.unknown(), {
+      format: `pgtype:${original}${argsSuffix}`,
+    }),
+  };
+};
+
+const enumToShape = (e: EnumDef): shapes.Shape => {
+  const literals = e.values.map((v) => shapes.literal(v));
+  let u: shapes.Shape = shapes.union(literals);
+  u = annotate.titled(u, e.name);
+  if (e.schema !== undefined) {
+    u = annotate.as(u, { schema: e.schema });
+  }
+  return u;
+};

package/packages/core/src/shape/transforms/sql/parser/sqlite-types.ts

@@ -0,0 +1,103 @@
+import { annotate, shapes } from "../../../shape";
+import { numIntArg, ParsedTypeSpec } from "./type-spec";
+
+export type SqliteResolveResult = {
+  shape: shapes.Shape;
+  // True when the source type implies an auto-incrementing column. For SQLite
+  // this is left for the column-constraint parser to populate from
+  // `INTEGER PRIMARY KEY AUTOINCREMENT` — but we keep the field for symmetry
+  // with resolvePgType.
+  autoIncrement?: boolean;
+};
+
+// Resolve a SQLite type spec to a shape. SQLite has type affinity rather than
+// a strict type system, so we accept many synonyms (VARCHAR, BOOLEAN, FLOAT,
+// DATETIME, …) the engine itself accepts via affinity.
+export const resolveSqliteType = (
+  spec: ParsedTypeSpec,
+): SqliteResolveResult => {
+  if (spec.isArray) {
+    // SQLite has no native array type; if we see `T[]` in input (unusual)
+    // fall back to a typed array shape.
+    const inner = resolveSqliteType({ ...spec, isArray: false });
+    return { shape: shapes.array(inner.shape) };
+  }
+
+  const name = spec.baseName.toLowerCase();
+
+  switch (name) {
+    case "integer":
+    case "int":
+    case "bigint":
+    case "int8":
+    case "int4":
+    case "int2":
+    case "smallint":
+    case "tinyint":
+    case "mediumint":
+    case "unsigned big int": {
+      return { shape: shapes.int64() };
+    }
+    case "text":
+    case "clob": {
+      return { shape: shapes.string() };
+    }
+    case "varchar":
+    case "character varying":
+    case "nvarchar":
+    case "varying character": {
+      const n = numIntArg(spec.args[0]);
+      if (n !== null) return { shape: annotate.max(shapes.string(), n) };
+      return { shape: shapes.string() };
+    }
+    case "char":
+    case "character":
+    case "nchar":
+    case "bpchar": {
+      const n = numIntArg(spec.args[0]);
+      const len = n ?? 1;
+      return {
+        shape: annotate.min(annotate.max(shapes.string(), len), len),
+      };
+    }
+    case "real":
+    case "float":
+    case "double":
+    case "double precision": {
+      return { shape: shapes.float64() };
+    }
+    case "numeric":
+    case "decimal": {
+      return { shape: shapes.number() };
+    }
+    case "boolean":
+    case "bool": {
+      return { shape: shapes.boolean() };
+    }
+    case "blob": {
+      return { shape: shapes.binary() };
+    }
+    case "date":
+    case "datetime":
+    case "timestamp":
+    case "timestamptz": {
+      return { shape: shapes.date() };
+    }
+    case "json":
+    case "jsonb": {
+      return {
+        shape: annotate.as(shapes.unknown(), { format: `sqlitetype:${name}` }),
+      };
+    }
+  }
+
+  // Fall back: unknown + format hint preserving the original.
+  const original =
+    spec.qualified !== undefined ? spec.qualified : spec.baseName;
+  const argsSuffix = spec.args.length > 0 ? `(${spec.args.join(",")})` : "";
+  return {
+    shape: annotate.as(shapes.unknown(), {
+      format: `sqlitetype:${original}${argsSuffix}`,
+    }),
+  };
+};

package/packages/core/src/shape/transforms/sql/parser/statements.ts

@@ -0,0 +1,127 @@
+import { Token } from "./lexer";
+
+export type StatementKind =
+  | "createType"
+  | "createDomain"
+  | "createTable"
+  | "createTablePartitionOf"
+  | "skip";
+
+export type Statement = {
+  kind: StatementKind;
+  tokens: Token[];
+};
+
+export const splitStatements = (tokens: Token[]): Token[][] => {
+  const out: Token[][] = [];
+  let current: Token[] = [];
+  let depth = 0;
+  for (const t of tokens) {
+    if (t.kind === "eof") break;
+    if (t.kind === "punct" && t.value === "(") depth += 1;
+    else if (t.kind === "punct" && t.value === ")") depth -= 1;
+    if (t.kind === "punct" && t.value === ";" && depth === 0) {
+      if (current.length > 0) out.push(current);
+      current = [];
+      continue;
+    }
+    current.push(t);
+  }
+  if (current.length > 0) out.push(current);
+  return out;
+};
+
+const peekIdent = (tokens: Token[], idx: number): string | null => {
+  const t = tokens[idx];
+  if (t === undefined) return null;
+  if (t.kind === "ident") return t.value;
+  return null;
+};
+
+export const classifyStatement = (tokens: Token[]): Statement => {
+  const k0 = peekIdent(tokens, 0);
+
+  if (k0 === "create") {
+    let k1 = peekIdent(tokens, 1);
+    // CREATE OR REPLACE ...
+    if (k1 === "or" && peekIdent(tokens, 2) === "replace") {
+      k1 = peekIdent(tokens, 3);
+    }
+    // CREATE [UNIQUE] INDEX ...
+    if (k1 === "unique" && peekIdent(tokens, 2) === "index")
+      return { kind: "skip", tokens };
+    if (k1 === "index") return { kind: "skip", tokens };
+    if (k1 === "trigger") return { kind: "skip", tokens };
+    if (k1 === "function") return { kind: "skip", tokens };
+    if (k1 === "procedure") return { kind: "skip", tokens };
+    if (k1 === "view") return { kind: "skip", tokens };
+    if (k1 === "materialized") return { kind: "skip", tokens };
+    if (k1 === "policy") return { kind: "skip", tokens };
+    if (k1 === "extension") return { kind: "skip", tokens };
+    if (k1 === "schema") return { kind: "skip", tokens };
+    if (k1 === "sequence") return { kind: "skip", tokens };
+    if (k1 === "language") return { kind: "skip", tokens };
+    if (k1 === "rule") return { kind: "skip", tokens };
+    if (k1 === "aggregate") return { kind: "skip", tokens };
+    if (k1 === "operator") return { kind: "skip", tokens };
+    if (k1 === "cast") return { kind: "skip", tokens };
+    if (k1 === "role") return { kind: "skip", tokens };
+    if (k1 === "user") return { kind: "skip", tokens };
+    if (k1 === "domain") return { kind: "createDomain", tokens };
+    if (k1 === "type") return { kind: "createType", tokens };
+    if (k1 === "virtual" && peekIdent(tokens, 2) === "table")
+      return { kind: "skip", tokens };
+    if (k1 === "table") {
+      // Look ahead for "PARTITION OF" to distinguish partition children
+      // (`CREATE TABLE name PARTITION OF parent ...`) from parents
+      // (which have `PARTITION BY` *inside or after* the column list).
+      // Children we skip; parents we parse normally (partition spec is dropped).
+      const partitionOfIdx = findPartitionOfIndex(tokens);
+      if (partitionOfIdx >= 0)
+        return { kind: "createTablePartitionOf", tokens };
+      return { kind: "createTable", tokens };
+    }
+    return { kind: "skip", tokens };
+  }
+
+  if (k0 === "alter") return { kind: "skip", tokens };
+  if (k0 === "insert") return { kind: "skip", tokens };
+  if (k0 === "select") return { kind: "skip", tokens };
+  if (k0 === "set") return { kind: "skip", tokens };
+  if (k0 === "comment") return { kind: "skip", tokens };
+  if (k0 === "grant") return { kind: "skip", tokens };
+  if (k0 === "revoke") return { kind: "skip", tokens };
+  if (k0 === "drop") return { kind: "skip", tokens };
+  if (k0 === "begin") return { kind: "skip", tokens };
+  if (k0 === "commit") return { kind: "skip", tokens };
+  if (k0 === "rollback") return { kind: "skip", tokens };
+  if (k0 === "with") return { kind: "skip", tokens };
+  if (k0 === "update") return { kind: "skip", tokens };
+  if (k0 === "delete") return { kind: "skip", tokens };
+  if (k0 === "truncate") return { kind: "skip", tokens };
+  if (k0 === "vacuum") return { kind: "skip", tokens };
+  if (k0 === "analyze") return { kind: "skip", tokens };
+  if (k0 === "explain") return { kind: "skip", tokens };
+  if (k0 === "refresh") return { kind: "skip", tokens };
+
+  return { kind: "skip", tokens };
+};
+
+// Search for `PARTITION OF` only outside parens (since CREATE TABLE columns
+// could contain those keywords in weird places).
+const findPartitionOfIndex = (tokens: Token[]): number => {
+  let depth = 0;
+  for (let i = 0; i < tokens.length; i += 1) {
+    const t = tokens[i]!;
+    if (t.kind === "punct" && t.value === "(") depth += 1;
+    else if (t.kind === "punct" && t.value === ")") depth -= 1;
+    if (
+      depth === 0 &&
+      t.kind === "ident" &&
+      t.value === "partition" &&
+      peekIdent(tokens, i + 1) === "of"
+    )
+      return i;
+  }
+  return -1;
+};

package/packages/core/src/shape/transforms/sql/parser/type-spec.ts

@@ -0,0 +1,159 @@
+import { shapes } from "../../../shape";
+import { Token } from "./lexer";
+
+// Type spec parsed from a sequence of tokens — base name (lowercased), optional
+// qualified prefix (schema.name), parenthesised args, optional [] array suffix.
+// This is dialect-agnostic; resolution to a shape happens in the per-dialect
+// resolver.
+export type ParsedTypeSpec = {
+  baseName: string;
+  qualified?: string;
+  args: string[];
+  isArray: boolean;
+};
+
+const MULTI_WORD_TYPES = new Set<string>([
+  "double precision",
+  "character varying",
+  "bit varying",
+  "timestamp with time zone",
+  "timestamp without time zone",
+  "time with time zone",
+  "time without time zone",
+]);
+
+export const parseTypeSpec = (tokens: Token[]): ParsedTypeSpec => {
+  let i = 0;
+  const peek = (off = 0): Token | undefined => tokens[i + off];
+
+  const parts: string[] = [];
+  const t0 = tokens[i];
+  if (t0 === undefined || t0.kind !== "ident") {
+    return { baseName: "unknown", args: [], isArray: false };
+  }
+  parts.push(t0.value);
+  i += 1;
+  while (peek()?.kind === "punct" && peek()?.value === ".") {
+    i += 1;
+    const next = peek();
+    if (next === undefined || next.kind !== "ident") break;
+    parts.push(next.value);
+    i += 1;
+  }
+  let baseName = parts.join(".");
+  const qualified: string | undefined =
+    parts.length >= 2 ? parts.join(".") : undefined;
+
+  const second = peek();
+  if (parts.length === 1 && second?.kind === "ident" && !second.quoted) {
+    const combo = `${parts[0]} ${second.value}`;
+    const third = peek(2);
+    const fourth = peek(3);
+    if (
+      third?.kind === "ident" &&
+      fourth?.kind === "ident" &&
+      MULTI_WORD_TYPES.has(`${combo} ${third.value} ${fourth.value}`)
+    ) {
+      baseName = `${combo} ${third.value} ${fourth.value}`;
+      i += 3;
+    } else if (MULTI_WORD_TYPES.has(combo)) {
+      baseName = combo;
+      i += 1;
+    }
+  }
+
+  const args: string[] = [];
+  if (peek()?.kind === "punct" && peek()?.value === "(") {
+    i += 1;
+    let depth = 1;
+    let argBuf = "";
+    while (i < tokens.length && depth > 0) {
+      const t = tokens[i]!;
+      if (t.kind === "punct" && t.value === "(") {
+        depth += 1;
+        argBuf += "(";
+      } else if (t.kind === "punct" && t.value === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          if (argBuf.length > 0) args.push(argBuf.trim());
+          argBuf = "";
+          i += 1;
+          break;
+        }
+        argBuf += ")";
+      } else if (t.kind === "punct" && t.value === "," && depth === 1) {
+        args.push(argBuf.trim());
+        argBuf = "";
+      } else if (t.kind === "string") {
+        argBuf += `'${t.value}'`;
+      } else {
+        argBuf += t.value;
+      }
+      i += 1;
+    }
+  }
+
+  let isArray = false;
+  if (
+    peek()?.kind === "punct" &&
+    peek()?.value === "[" &&
+    peek(1)?.kind === "punct" &&
+    peek(1)?.value === "]"
+  ) {
+    isArray = true;
+  }
+
+  return {
+    baseName,
+    ...(qualified !== undefined ? { qualified } : {}),
+    args,
+    isArray,
+  };
+};
+
+export const numIntArg = (s: string | undefined): number | null => {
+  if (s === undefined) return null;
+  const n = Number(s);
+  if (!isFinite(n) || Math.floor(n) !== n) return null;
+  return n;
+};
+
+export const numberShapeForTag = (
+  tag:
+    | "int8"
+    | "uint8"
+    | "int16"
+    | "uint16"
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "float32"
+    | "float64",
+): shapes.ShapeNumber => {
+  switch (tag) {
+    case "int8":
+      return shapes.int8();
+    case "uint8":
+      return shapes.uint8();
+    case "int16":
+      return shapes.int16();
+    case "uint16":
+      return shapes.uint16();
+    case "int32":
+      return shapes.int32();
+    case "uint32":
+      return shapes.uint32();
+    case "int64":
+      return shapes.int64();
+    case "uint64":
+      return shapes.uint64();
+    case "float":
+      return shapes.float();
+    case "float32":
+      return shapes.float32();
+    case "float64":
+      return shapes.float64();
+  }
+};