@shapecraft/core 1.0.0

package/src/shape/transforms/sql/parser/create-type.ts

@@ -0,0 +1,91 @@
+import { ParseError, TokenCursor } from "./cursor";
+import { Token } from "./lexer";
+
+export type EnumDef = {
+  schema?: string;
+  name: string;
+  values: string[];
+};
+
+export type CompositeDef = {
+  schema?: string;
+  name: string;
+  // raw field defs preserved as token slices for later mapping if we choose to
+  // unpack composites into mappings. v1 doesn't use these.
+  fields: Array<{ name: string; typeTokens: Token[] }>;
+};
+
+export type ParsedType =
+  | { kind: "enum"; def: EnumDef }
+  | { kind: "composite"; def: CompositeDef }
+  | null;
+
+const qualifiedName = (parts: string[]): { schema?: string; name: string } => {
+  if (parts.length === 1) return { name: parts[0]! };
+  return { schema: parts[0]!, name: parts.slice(1).join(".") };
+};
+
+export const parseCreateType = (tokens: Token[]): ParsedType => {
+  const c = new TokenCursor(tokens);
+  c.expectIdent("create");
+  // CREATE [OR REPLACE] TYPE
+  if (c.consumeIdent("or")) c.expectIdent("replace");
+  c.expectIdent("type");
+  if (c.consumeIdent("if")) {
+    c.expectIdent("not");
+    c.expectIdent("exists");
+  }
+
+  const nameParts = c.readDottedName();
+  const qn = qualifiedName(nameParts);
+
+  c.expectIdent("as");
+
+  if (c.consumeIdent("enum")) {
+    c.expectPunct("(");
+    const values: string[] = [];
+    while (!c.isPunct(")")) {
+      const t = c.peek();
+      if (t.kind !== "string") {
+        throw new ParseError(
+          `expected string literal in ENUM but found ${t.kind}`,
+          t.pos,
+        );
+      }
+      c.consume();
+      values.push(t.value);
+      if (!c.consumePunct(",")) break;
+    }
+    c.expectPunct(")");
+    const def: EnumDef = { name: qn.name, values };
+    if (qn.schema !== undefined) def.schema = qn.schema;
+    return { kind: "enum", def };
+  }
+
+  if (c.consumePunct("(")) {
+    const fields: Array<{ name: string; typeTokens: Token[] }> = [];
+    while (!c.isPunct(")")) {
+      const nameTok = c.expectAnyIdent();
+      const typeTokens: Token[] = [];
+      let depth = 0;
+      while (!c.done()) {
+        const t = c.peek();
+        if (t.kind === "punct" && t.value === "," && depth === 0) break;
+        if (t.kind === "punct" && t.value === ")" && depth === 0) break;
+        if (t.kind === "punct" && t.value === "(") depth += 1;
+        if (t.kind === "punct" && t.value === ")") depth -= 1;
+        typeTokens.push(t);
+        c.consume();
+      }
+      fields.push({ name: nameTok.name, typeTokens });
+      if (!c.consumePunct(",")) break;
+    }
+    c.expectPunct(")");
+    const def: CompositeDef = { name: qn.name, fields };
+    if (qn.schema !== undefined) def.schema = qn.schema;
+    return { kind: "composite", def };
+  }
+
+  // Unknown form (e.g. CREATE TYPE name AS RANGE (...)) — skip
+  return null;
+};

package/src/shape/transforms/sql/parser/cursor.ts

@@ -0,0 +1,179 @@
+import { Token } from "./lexer";
+
+export class ParseError extends Error {
+  constructor(
+    message: string,
+    public readonly pos: number,
+  ) {
+    super(`${message} at offset ${pos}`);
+    this.name = "ParseError";
+  }
+}
+
+export class TokenCursor {
+  private idx = 0;
+
+  constructor(private readonly tokens: Token[]) {}
+
+  get pos(): number {
+    return this.idx;
+  }
+
+  reset(idx: number): void {
+    this.idx = idx;
+  }
+
+  peek(off = 0): Token {
+    const t = this.tokens[this.idx + off];
+    if (t === undefined) {
+      const last = this.tokens[this.tokens.length - 1];
+      return { kind: "eof", value: "", pos: last?.pos ?? 0 };
+    }
+    return t;
+  }
+
+  consume(): Token {
+    const t = this.peek();
+    if (t.kind !== "eof") this.idx += 1;
+    return t;
+  }
+
+  done(): boolean {
+    return this.peek().kind === "eof";
+  }
+
+  isIdent(value: string, off = 0): boolean {
+    const t = this.peek(off);
+    return t.kind === "ident" && !t.quoted && t.value === value;
+  }
+
+  isPunct(value: string, off = 0): boolean {
+    const t = this.peek(off);
+    return t.kind === "punct" && t.value === value;
+  }
+
+  isOp(value: string, off = 0): boolean {
+    const t = this.peek(off);
+    return t.kind === "op" && t.value === value;
+  }
+
+  consumeIdent(value: string): boolean {
+    if (this.isIdent(value)) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+
+  consumePunct(value: string): boolean {
+    if (this.isPunct(value)) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+
+  consumeOp(value: string): boolean {
+    if (this.isOp(value)) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+
+  expectPunct(value: string): void {
+    if (!this.consumePunct(value)) {
+      const t = this.peek();
+      throw new ParseError(
+        `expected punct '${value}' but found ${describe(t)}`,
+        t.pos,
+      );
+    }
+  }
+
+  expectIdent(value: string): void {
+    if (!this.consumeIdent(value)) {
+      const t = this.peek();
+      throw new ParseError(
+        `expected keyword '${value}' but found ${describe(t)}`,
+        t.pos,
+      );
+    }
+  }
+
+  // Read a possibly-quoted ident. Throws if next token isn't an ident.
+  expectAnyIdent(): { name: string; quoted: boolean; pos: number } {
+    const t = this.peek();
+    if (t.kind !== "ident") {
+      throw new ParseError(
+        `expected identifier but found ${describe(t)}`,
+        t.pos,
+      );
+    }
+    this.consume();
+    return { name: t.value, quoted: t.quoted === true, pos: t.pos };
+  }
+
+  // Read a dotted ident chain (e.g. `shop.users` or `shop`.users) into [parts...]
+  readDottedName(): string[] {
+    const parts: string[] = [];
+    const first = this.expectAnyIdent();
+    parts.push(first.name);
+    while (this.consumePunct(".")) {
+      const next = this.expectAnyIdent();
+      parts.push(next.name);
+    }
+    return parts;
+  }
+
+  // Skip a balanced paren group. Cursor must be at the opening '('.
+  skipParens(): Token[] {
+    if (!this.isPunct("(")) {
+      const t = this.peek();
+      throw new ParseError(`expected '(' but found ${describe(t)}`, t.pos);
+    }
+    this.consume();
+    const collected: Token[] = [];
+    let depth = 1;
+    while (!this.done() && depth > 0) {
+      const t = this.peek();
+      if (t.kind === "punct" && t.value === "(") depth += 1;
+      else if (t.kind === "punct" && t.value === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          this.consume();
+          break;
+        }
+      }
+      collected.push(t);
+      this.consume();
+    }
+    return collected;
+  }
+
+  // Skip everything up to (but not including) a top-level matching token.
+  skipUntilTopLevel(pred: (t: Token) => boolean): void {
+    let depth = 0;
+    while (!this.done()) {
+      const t = this.peek();
+      if (t.kind === "punct" && t.value === "(") depth += 1;
+      else if (t.kind === "punct" && t.value === ")") {
+        if (depth === 0) return;
+        depth -= 1;
+      }
+      if (depth === 0 && pred(t)) return;
+      this.consume();
+    }
+  }
+}
+
+const describe = (t: Token): string => {
+  if (t.kind === "eof") return "end of input";
+  if (t.kind === "ident") return `ident '${t.value}'`;
+  if (t.kind === "punct") return `'${t.value}'`;
+  if (t.kind === "op") return `op '${t.value}'`;
+  if (t.kind === "number") return `number ${t.value}`;
+  if (t.kind === "string") return `string '${t.value}'`;
+  if (t.kind === "dollarString") return "dollar-quoted string";
+  return t.kind;
+};

package/src/shape/transforms/sql/parser/default-decoder.ts

@@ -0,0 +1,129 @@
+import { Token } from "./lexer";
+
+export type DecodedDefault =
+  | { kind: "literal"; value: unknown }
+  | { kind: "expr"; sql: string };
+
+const tokensToSql = (tokens: Token[]): string => {
+  const parts: string[] = [];
+  for (const t of tokens) {
+    if (t.kind === "string") parts.push(`'${t.value.replace(/'/g, "''")}'`);
+    else if (t.kind === "ident" && t.quoted)
+      parts.push(`"${t.value.replace(/"/g, '""')}"`);
+    else if (t.kind === "ident") parts.push(t.value.toUpperCase());
+    else parts.push(t.value);
+  }
+  return parts.join(" ").replace(/\s+::/g, "::").replace(/::\s+/g, "::");
+};
+
+// Single string-literal possibly followed by ::type
+const matchStringCast = (
+  tokens: Token[],
+): { value: string; castType?: string } | null => {
+  const t0 = tokens[0];
+  if (t0 === undefined || t0.kind !== "string") return null;
+  if (tokens.length === 1) return { value: t0.value };
+  const t1 = tokens[1];
+  if (t1 === undefined || t1.kind !== "op" || t1.value !== "::") return null;
+  // Collect remaining ident chain as the cast type
+  const parts: string[] = [];
+  let i = 2;
+  while (i < tokens.length) {
+    const t = tokens[i]!;
+    if (t.kind === "ident") parts.push(t.value);
+    else if (t.kind === "punct" && t.value === ".") parts.push(".");
+    else if (t.kind === "punct" && t.value === "(") {
+      // type args — skip
+      let depth = 1;
+      i += 1;
+      while (i < tokens.length && depth > 0) {
+        const tt = tokens[i]!;
+        if (tt.kind === "punct" && tt.value === "(") depth += 1;
+        if (tt.kind === "punct" && tt.value === ")") depth -= 1;
+        i += 1;
+      }
+      continue;
+    } else break;
+    i += 1;
+  }
+  if (i !== tokens.length) return null;
+  return { value: t0.value, castType: parts.join("").toLowerCase() };
+};
+
+const isTimestampType = (t: string): boolean =>
+  t === "timestamp" ||
+  t === "timestamptz" ||
+  t === "date" ||
+  t.startsWith("timestamp");
+
+export const decodeDefault = (
+  tokens: Token[],
+  columnPgType: string | null,
+): DecodedDefault => {
+  if (tokens.length === 0) return { kind: "expr", sql: "" };
+  const first = tokens[0]!;
+
+  // NULL
+  if (tokens.length === 1 && first.kind === "ident" && first.value === "null") {
+    return { kind: "literal", value: null };
+  }
+
+  // TRUE / FALSE
+  if (
+    tokens.length === 1 &&
+    first.kind === "ident" &&
+    (first.value === "true" || first.value === "false")
+  ) {
+    return { kind: "literal", value: first.value === "true" };
+  }
+
+  // Bare number (with optional leading sign)
+  if (tokens.length === 1 && first.kind === "number") {
+    const n = Number(first.value);
+    if (isFinite(n)) return { kind: "literal", value: n };
+  }
+  if (
+    tokens.length === 2 &&
+    first.kind === "op" &&
+    (first.value === "-" || first.value === "+") &&
+    tokens[1]?.kind === "number"
+  ) {
+    const n = Number(`${first.value}${tokens[1].value}`);
+    if (isFinite(n)) return { kind: "literal", value: n };
+  }
+
+  // String (possibly with cast)
+  const sc = matchStringCast(tokens);
+  if (sc !== null) {
+    const ct = sc.castType ?? "";
+    if (ct === "" || ct === "text" || ct === "varchar") {
+      return { kind: "literal", value: sc.value };
+    }
+    if (ct === "jsonb" || ct === "json") {
+      try {
+        return { kind: "literal", value: JSON.parse(sc.value) };
+      } catch {
+        return { kind: "expr", sql: tokensToSql(tokens) };
+      }
+    }
+    if (isTimestampType(ct)) {
+      const d = new Date(sc.value);
+      const t = d.getTime();
+      if (!isNaN(t) && isFinite(t)) return { kind: "literal", value: d };
+    }
+    // Fall through to expr for other casts
+  }
+
+  // Postgres array literal '{}' on a column declared as `T[]` — decode to []
+  if (
+    sc !== null &&
+    sc.castType === undefined &&
+    sc.value === "{}" &&
+    columnPgType !== null &&
+    columnPgType.endsWith("[]")
+  ) {
+    return { kind: "literal", value: [] };
+  }
+
+  return { kind: "expr", sql: tokensToSql(tokens) };
+};

package/src/shape/transforms/sql/parser/lexer.ts

@@ -0,0 +1,289 @@
+export type TokenKind =
+  | "ident"
+  | "string"
+  | "dollarString"
+  | "number"
+  | "punct"
+  | "op"
+  | "eof";
+
+export type Token = {
+  kind: TokenKind;
+  value: string;
+  quoted?: boolean;
+  pos: number;
+};
+
+const PUNCT_CHARS = new Set(["(", ")", ",", ";", "[", "]", "."]);
+
+const isIdentStart = (c: string): boolean =>
+  (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_";
+
+const isIdentCont = (c: string): boolean =>
+  isIdentStart(c) || (c >= "0" && c <= "9") || c === "$";
+
+const isDigit = (c: string): boolean => c >= "0" && c <= "9";
+
+const isSpace = (c: string): boolean =>
+  c === " " || c === "\t" || c === "\n" || c === "\r" || c === "\f";
+
+export class LexError extends Error {
+  constructor(
+    message: string,
+    public readonly pos: number,
+  ) {
+    super(`${message} at offset ${pos}`);
+    this.name = "LexError";
+  }
+}
+
+export const tokenize = (sql: string): Token[] => {
+  const tokens: Token[] = [];
+  let i = 0;
+  const N = sql.length;
+
+  const peek = (off = 0): string => sql[i + off] ?? "";
+
+  while (i < N) {
+    const c = peek();
+
+    // whitespace
+    if (isSpace(c)) {
+      i += 1;
+      continue;
+    }
+
+    // line comment
+    if (c === "-" && peek(1) === "-") {
+      while (i < N && sql[i] !== "\n") i += 1;
+      continue;
+    }
+
+    // block comment (nestable per pg)
+    if (c === "/" && peek(1) === "*") {
+      let depth = 1;
+      i += 2;
+      while (i < N && depth > 0) {
+        if (sql[i] === "/" && sql[i + 1] === "*") {
+          depth += 1;
+          i += 2;
+        } else if (sql[i] === "*" && sql[i + 1] === "/") {
+          depth -= 1;
+          i += 2;
+        } else {
+          i += 1;
+        }
+      }
+      if (depth > 0) throw new LexError("unterminated block comment", i);
+      continue;
+    }
+
+    // dollar-quoted string: $tag$...$tag$ (tag is empty or [A-Za-z_][A-Za-z0-9_]*)
+    if (c === "$") {
+      // try to read a tag (which may be empty)
+      let j = i + 1;
+      // first char of tag: letter or underscore
+      if (j < N && isIdentStart(sql[j] ?? "")) {
+        j += 1;
+        while (j < N) {
+          const cc = sql[j] ?? "";
+          if (
+            (cc >= "a" && cc <= "z") ||
+            (cc >= "A" && cc <= "Z") ||
+            (cc >= "0" && cc <= "9") ||
+            cc === "_"
+          )
+            j += 1;
+          else break;
+        }
+      }
+      if (sql[j] === "$") {
+        const tag = sql.slice(i + 1, j);
+        const opener = `$${tag}$`;
+        const start = j + 1;
+        const end = sql.indexOf(opener, start);
+        if (end < 0)
+          throw new LexError(
+            `unterminated dollar-quoted string with tag '${tag}'`,
+            i,
+          );
+        const body = sql.slice(start, end);
+        tokens.push({ kind: "dollarString", value: body, pos: i });
+        i = end + opener.length;
+        continue;
+      }
+      // not a dollar-quote — fall through to identifier handling? `$` isn't a
+      // valid leading char for a bare ident in pg, but parameter placeholders
+      // like $1 use it. Treat as punct.
+      tokens.push({ kind: "punct", value: "$", pos: i });
+      i += 1;
+      continue;
+    }
+
+    // single-quoted string
+    if (c === "'") {
+      const start = i;
+      i += 1;
+      let buf = "";
+      while (i < N) {
+        if (sql[i] === "'") {
+          if (sql[i + 1] === "'") {
+            buf += "'";
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        buf += sql[i];
+        i += 1;
+      }
+      if (sql[i] !== "'") throw new LexError("unterminated string", start);
+      i += 1;
+      tokens.push({ kind: "string", value: buf, pos: start });
+      continue;
+    }
+
+    // double-quoted identifier
+    if (c === '"') {
+      const start = i;
+      i += 1;
+      let buf = "";
+      while (i < N) {
+        if (sql[i] === '"') {
+          if (sql[i + 1] === '"') {
+            buf += '"';
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        buf += sql[i];
+        i += 1;
+      }
+      if (sql[i] !== '"')
+        throw new LexError("unterminated quoted identifier", start);
+      i += 1;
+      tokens.push({ kind: "ident", value: buf, quoted: true, pos: start });
+      continue;
+    }
+
+    // backtick-quoted identifier (SQLite/MySQL syntax)
+    if (c === "`") {
+      const start = i;
+      i += 1;
+      let buf = "";
+      while (i < N) {
+        if (sql[i] === "`") {
+          if (sql[i + 1] === "`") {
+            buf += "`";
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        buf += sql[i];
+        i += 1;
+      }
+      if (sql[i] !== "`")
+        throw new LexError("unterminated backtick-quoted identifier", start);
+      i += 1;
+      tokens.push({ kind: "ident", value: buf, quoted: true, pos: start });
+      continue;
+    }
+
+    // identifier / keyword
+    if (isIdentStart(c)) {
+      const start = i;
+      while (i < N && isIdentCont(sql[i] ?? "")) i += 1;
+      tokens.push({
+        kind: "ident",
+        value: sql.slice(start, i).toLowerCase(),
+        pos: start,
+      });
+      continue;
+    }
+
+    // number (no sign — sign is consumed by parser if needed)
+    if (isDigit(c) || (c === "." && isDigit(peek(1)))) {
+      const start = i;
+      while (i < N && isDigit(sql[i] ?? "")) i += 1;
+      if (sql[i] === ".") {
+        i += 1;
+        while (i < N && isDigit(sql[i] ?? "")) i += 1;
+      }
+      if (sql[i] === "e" || sql[i] === "E") {
+        i += 1;
+        if (sql[i] === "+" || sql[i] === "-") i += 1;
+        while (i < N && isDigit(sql[i] ?? "")) i += 1;
+      }
+      tokens.push({ kind: "number", value: sql.slice(start, i), pos: start });
+      continue;
+    }
+
+    // operators
+    // two-char first
+    const two = sql.slice(i, i + 2);
+    if (
+      two === "<=" ||
+      two === ">=" ||
+      two === "<>" ||
+      two === "!=" ||
+      two === "||" ||
+      two === "::" ||
+      two === "&&" ||
+      two === "@>" ||
+      two === "<@"
+    ) {
+      tokens.push({ kind: "op", value: two, pos: i });
+      i += 2;
+      continue;
+    }
+
+    if (PUNCT_CHARS.has(c)) {
+      tokens.push({ kind: "punct", value: c, pos: i });
+      i += 1;
+      continue;
+    }
+
+    if (
+      c === "=" ||
+      c === "<" ||
+      c === ">" ||
+      c === "+" ||
+      c === "-" ||
+      c === "*" ||
+      c === "/" ||
+      c === "%" ||
+      c === "~" ||
+      c === "!" ||
+      c === "@" ||
+      c === "#" ||
+      c === "&" ||
+      c === "|" ||
+      c === "^" ||
+      c === "?"
+    ) {
+      tokens.push({ kind: "op", value: c, pos: i });
+      i += 1;
+      continue;
+    }
+
+    throw new LexError(`unexpected character ${JSON.stringify(c)}`, i);
+  }
+
+  tokens.push({ kind: "eof", value: "", pos: i });
+  return tokens;
+};
+
+export const tokensToText = (tokens: Token[]): string => {
+  const parts: string[] = [];
+  for (const t of tokens) {
+    if (t.kind === "eof") continue;
+    if (t.kind === "string") parts.push(`'${t.value.replace(/'/g, "''")}'`);
+    else if (t.kind === "ident" && t.quoted)
+      parts.push(`"${t.value.replace(/"/g, '""')}"`);
+    else if (t.kind === "dollarString") parts.push(`$$${t.value}$$`);
+    else parts.push(t.value);
+  }
+  return parts.join(" ");
+};