sqlcx-orm 0.1.0

package/dist/parser/postgres.js

@@ -0,0 +1,615 @@
+// @bun
+// src/parser/param-naming.ts
+function resolveParamNames(params) {
+  const freq = new Map;
+  for (const p of params) {
+    if (!p.override && p.column) {
+      freq.set(p.column, (freq.get(p.column) ?? 0) + 1);
+    }
+  }
+  const counters = new Map;
+  const seen = new Set;
+  const result = new Array(params.length);
+  for (let i = 0;i < params.length; i++) {
+    const p = params[i];
+    let name;
+    if (p.override) {
+      name = p.override;
+    } else if (!p.column) {
+      name = `param_${p.index}`;
+    } else if ((freq.get(p.column) ?? 0) > 1) {
+      const n = (counters.get(p.column) ?? 0) + 1;
+      counters.set(p.column, n);
+      name = `${p.column}_${n}`;
+    } else {
+      name = p.column;
+    }
+    const base = name;
+    let suffix = 1;
+    while (seen.has(name)) {
+      name = `${base}_${suffix++}`;
+    }
+    seen.add(name);
+    result[i] = name;
+  }
+  return result;
+}
+
+// src/parser/postgres.ts
+var TYPE_CATEGORY_MAP = new Map([
+  ["text", "string"],
+  ["varchar", "string"],
+  ["char", "string"],
+  ["character varying", "string"],
+  ["character", "string"],
+  ["name", "string"],
+  ["integer", "number"],
+  ["int", "number"],
+  ["int2", "number"],
+  ["int4", "number"],
+  ["int8", "number"],
+  ["smallint", "number"],
+  ["bigint", "number"],
+  ["serial", "number"],
+  ["bigserial", "number"],
+  ["real", "number"],
+  ["double precision", "number"],
+  ["numeric", "number"],
+  ["decimal", "number"],
+  ["float", "number"],
+  ["float4", "number"],
+  ["float8", "number"],
+  ["boolean", "boolean"],
+  ["bool", "boolean"],
+  ["timestamp", "date"],
+  ["timestamptz", "date"],
+  ["date", "date"],
+  ["time", "date"],
+  ["timetz", "date"],
+  ["timestamp without time zone", "date"],
+  ["timestamp with time zone", "date"],
+  ["json", "json"],
+  ["jsonb", "json"],
+  ["uuid", "uuid"],
+  ["bytea", "binary"]
+]);
+var SERIAL_TYPES = new Set(["serial", "bigserial"]);
+function resolveType(raw, enumNames) {
+  const trimmed = raw.trim();
+  if (trimmed.endsWith("[]")) {
+    const baseRaw = trimmed.slice(0, -2);
+    const elementType = resolveType(baseRaw, enumNames);
+    return {
+      raw: trimmed,
+      normalized: trimmed.toLowerCase(),
+      category: elementType.category,
+      elementType
+    };
+  }
+  const normalized = trimmed.toLowerCase();
+  const category = TYPE_CATEGORY_MAP.get(normalized);
+  if (category) {
+    return { raw: trimmed, normalized, category };
+  }
+  if (enumNames.has(normalized)) {
+    return { raw: trimmed, normalized, category: "enum", enumName: normalized };
+  }
+  return { raw: trimmed, normalized, category: "unknown" };
+}
+var ENUM_RE_SOURCE = /CREATE\s+TYPE\s+(\w+)\s+AS\s+ENUM\s*\(\s*((?:'[^']*'(?:\s*,\s*'[^']*')*)?)\s*\)/i.source;
+function parseEnumDefs(sql) {
+  const re = new RegExp(ENUM_RE_SOURCE, "gi");
+  const enums = [];
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const name = m[1].toLowerCase();
+    const valuesRaw = m[2];
+    const values = [...valuesRaw.matchAll(/'([^']*)'/g)].map((v) => v[1]);
+    enums.push({ name, values });
+  }
+  return enums;
+}
+var CREATE_TABLE_RE_SOURCE = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\(([\s\S]*?)\)\s*;/i.source;
+function splitColumnDefs(body) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of body) {
+    if (ch === "(") {
+      depth++;
+      current += ch;
+    } else if (ch === ")") {
+      depth--;
+      current += ch;
+    } else if (ch === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim())
+    parts.push(current.trim());
+  return parts;
+}
+var MULTI_WORD_TYPES = [
+  "character varying",
+  "double precision",
+  "timestamp without time zone",
+  "timestamp with time zone"
+];
+function parseColumnLine(line, enumNames) {
+  line = line.trim();
+  if (!line)
+    return null;
+  if (/^(PRIMARY\s+KEY|CONSTRAINT|UNIQUE|CHECK|FOREIGN\s+KEY)/i.test(line)) {
+    return null;
+  }
+  const nameMatch = line.match(/^(\w+)\s+/);
+  if (!nameMatch)
+    return null;
+  const colName = nameMatch[1].toLowerCase();
+  const afterName = line.slice(nameMatch[0].length);
+  let rawType = null;
+  for (const mwt of MULTI_WORD_TYPES) {
+    if (afterName.toLowerCase().startsWith(mwt)) {
+      rawType = mwt;
+      break;
+    }
+  }
+  if (!rawType) {
+    const typeMatch = afterName.match(/^(\w+(?:\[\])?)/);
+    rawType = typeMatch ? typeMatch[1] : "unknown";
+  }
+  const restAfterType = afterName.slice(rawType.length).trim();
+  const isNotNull = /\bNOT\s+NULL\b/i.test(restAfterType);
+  const hasDefaultKeyword = /\bDEFAULT\b/i.test(restAfterType);
+  const isSerial = SERIAL_TYPES.has(rawType.toLowerCase());
+  const isPK = /\bPRIMARY\s+KEY\b/i.test(restAfterType);
+  const isUnique = /\bUNIQUE\b/i.test(restAfterType);
+  const type = resolveType(rawType, enumNames);
+  return {
+    col: {
+      name: colName,
+      type,
+      nullable: !isNotNull,
+      hasDefault: hasDefaultKeyword || isSerial
+    },
+    isPK,
+    isUnique
+  };
+}
+function parseEnumAnnotation(comment) {
+  const match = comment.match(/--\s*@enum\s*\(\s*(.*?)\s*\)/);
+  if (!match)
+    return;
+  const inner = match[1];
+  const values = [];
+  const re = /"([^"]*?)"/g;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    values.push(m[1]);
+  }
+  return values.length > 0 ? values : undefined;
+}
+
+class JsonShapeParser {
+  input;
+  pos = 0;
+  constructor(input) {
+    this.input = input;
+  }
+  parse() {
+    const shape = this.parseType();
+    this.skipWs();
+    if (this.pos < this.input.length) {
+      throw new Error(`@json parse error: unexpected trailing content at position ${this.pos}: "${this.input.slice(this.pos, this.pos + 10)}"`);
+    }
+    return shape;
+  }
+  parseType() {
+    this.skipWs();
+    let shape;
+    if (this.peek() === "{") {
+      shape = this.parseObject();
+    } else {
+      shape = this.parsePrimitive();
+    }
+    this.skipWs();
+    while (this.lookAhead("[]")) {
+      this.pos += 2;
+      this.skipWs();
+      shape = { kind: "array", element: shape };
+    }
+    if (this.peek() === "?") {
+      this.pos++;
+      shape = { kind: "nullable", inner: shape };
+    }
+    return shape;
+  }
+  parsePrimitive() {
+    this.skipWs();
+    if (this.matchWord("string"))
+      return { kind: "string" };
+    if (this.matchWord("number"))
+      return { kind: "number" };
+    if (this.matchWord("boolean"))
+      return { kind: "boolean" };
+    throw new Error(`@json parse error: unexpected token at position ${this.pos}: "${this.input.slice(this.pos, this.pos + 10)}"`);
+  }
+  parseObject() {
+    this.consume("{");
+    this.skipWs();
+    const fields = {};
+    if (this.peek() !== "}") {
+      this.parseField(fields);
+      while (this.peek() === ",") {
+        this.pos++;
+        this.skipWs();
+        if (this.peek() === "}")
+          break;
+        this.parseField(fields);
+      }
+    }
+    this.consume("}");
+    return { kind: "object", fields };
+  }
+  parseField(fields) {
+    this.skipWs();
+    const name = this.readIdentifier();
+    this.skipWs();
+    this.consume(":");
+    this.skipWs();
+    fields[name] = this.parseType();
+    this.skipWs();
+  }
+  readIdentifier() {
+    this.skipWs();
+    const start = this.pos;
+    while (this.pos < this.input.length && /[\w]/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+    if (this.pos === start) {
+      throw new Error(`@json parse error: expected identifier at position ${this.pos}`);
+    }
+    return this.input.slice(start, this.pos);
+  }
+  skipWs() {
+    while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  peek() {
+    this.skipWs();
+    return this.input[this.pos];
+  }
+  lookAhead(s) {
+    return this.input.startsWith(s, this.pos);
+  }
+  matchWord(word) {
+    if (this.input.startsWith(word, this.pos)) {
+      const afterPos = this.pos + word.length;
+      if (afterPos >= this.input.length || !/\w/.test(this.input[afterPos])) {
+        this.pos = afterPos;
+        return true;
+      }
+    }
+    return false;
+  }
+  consume(ch) {
+    this.skipWs();
+    if (this.input[this.pos] !== ch) {
+      throw new Error(`@json parse error: expected '${ch}' at position ${this.pos}, got '${this.input[this.pos]}'`);
+    }
+    this.pos++;
+  }
+}
+function parseJsonAnnotation(comment) {
+  const match = comment.match(/--\s*@json\s*\(\s*([\s\S]+)\s*\)\s*$/);
+  if (!match)
+    return;
+  const body = match[1].trim();
+  try {
+    const parser = new JsonShapeParser(body);
+    return parser.parse();
+  } catch {
+    return;
+  }
+}
+function parseSchemaDefs(sql, enumNames) {
+  const re = new RegExp(CREATE_TABLE_RE_SOURCE, "gi");
+  const tables = [];
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const tableName = m[1].toLowerCase();
+    const body = m[2];
+    const columns = [];
+    const primaryKey = [];
+    const uniqueConstraints = [];
+    const rawLines = body.split(`
+`);
+    let pendingComment = "";
+    let nonCommentBuffer = "";
+    const commentMap = new Map;
+    for (const rawLine of rawLines) {
+      const trimmedLine = rawLine.trim();
+      if (trimmedLine.startsWith("--")) {
+        pendingComment += (pendingComment ? `
+` : "") + trimmedLine;
+      } else {
+        const beforeDefs = splitColumnDefs(nonCommentBuffer).filter((d) => d.trim().length > 0).length;
+        nonCommentBuffer += (nonCommentBuffer ? `
+` : "") + rawLine;
+        const afterDefs = splitColumnDefs(nonCommentBuffer).filter((d) => d.trim().length > 0).length;
+        if (afterDefs > beforeDefs && pendingComment) {
+          commentMap.set(beforeDefs, pendingComment);
+          pendingComment = "";
+        } else if (afterDefs === beforeDefs) {} else {
+          pendingComment = "";
+        }
+      }
+    }
+    const lines = splitColumnDefs(nonCommentBuffer);
+    for (let i = 0;i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      const pkMatch = trimmed.match(/^PRIMARY\s+KEY\s*\(\s*([\w\s,]+)\s*\)/i);
+      if (pkMatch) {
+        primaryKey.push(...pkMatch[1].split(",").map((s) => s.trim().toLowerCase()));
+        continue;
+      }
+      const result = parseColumnLine(trimmed, enumNames);
+      if (!result)
+        continue;
+      const comment = commentMap.get(i);
+      if (comment) {
+        const enumValues = parseEnumAnnotation(comment);
+        if (enumValues) {
+          result.col.type = {
+            ...result.col.type,
+            category: "enum",
+            enumValues
+          };
+        }
+        const jsonShape = parseJsonAnnotation(comment);
+        if (jsonShape) {
+          result.col.type = {
+            ...result.col.type,
+            jsonShape
+          };
+        }
+      }
+      columns.push(result.col);
+      if (result.isPK) {
+        primaryKey.push(result.col.name);
+      }
+      if (result.isUnique) {
+        uniqueConstraints.push([result.col.name]);
+      }
+    }
+    for (const col of columns) {
+      if (primaryKey.includes(col.name)) {
+        col.nullable = false;
+        col.hasDefault = col.hasDefault || SERIAL_TYPES.has(col.type.normalized);
+      }
+    }
+    tables.push({ name: tableName, columns, primaryKey, uniqueConstraints });
+  }
+  return tables;
+}
+var QUERY_ANNOTATION_RE = /--\s*name:\s*(\w+)\s+:(one|many|execresult|exec)/;
+var PARAM_OVERRIDE_RE = /--\s*@param\s+\$(\d+)\s+(\w+)/g;
+var DOLLAR_PARAM_RE = /\$(\d+)/g;
+function splitQueryBlocks(sql) {
+  const lines = sql.split(`
+`);
+  const blocks = [];
+  let current = null;
+  let commentBuffer = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const annotationMatch = trimmed.match(QUERY_ANNOTATION_RE);
+    if (annotationMatch) {
+      if (current)
+        blocks.push(current);
+      current = {
+        name: annotationMatch[1],
+        command: annotationMatch[2],
+        sql: "",
+        comments: commentBuffer + trimmed + `
+`
+      };
+      commentBuffer = "";
+    } else if (trimmed.startsWith("--")) {
+      if (current) {
+        current.comments += trimmed + `
+`;
+      } else {
+        commentBuffer += trimmed + `
+`;
+      }
+    } else if (current && trimmed) {
+      current.sql += (current.sql ? " " : "") + trimmed;
+    }
+  }
+  if (current)
+    blocks.push(current);
+  return blocks;
+}
+function extractParamOverrides(comments) {
+  const overrides = new Map;
+  let m;
+  const re = new RegExp(PARAM_OVERRIDE_RE.source, "g");
+  while ((m = re.exec(comments)) !== null) {
+    overrides.set(parseInt(m[1], 10), m[2]);
+  }
+  return overrides;
+}
+function extractParamIndices(sql) {
+  const indices = new Set;
+  let m;
+  const re = new RegExp(DOLLAR_PARAM_RE.source, "g");
+  while ((m = re.exec(sql)) !== null) {
+    indices.add(parseInt(m[1], 10));
+  }
+  return [...indices].sort((a, b) => a - b);
+}
+function inferParamColumns(sql) {
+  const result = new Map;
+  const insertMatch = sql.match(/INSERT\s+INTO\s+\w+\s*\(\s*([\w\s,]+)\s*\)\s*VALUES\s*\(\s*([\$\d\s,]+)\s*\)/i);
+  if (insertMatch) {
+    const cols = insertMatch[1].split(",").map((s) => s.trim().toLowerCase());
+    const params = [...insertMatch[2].matchAll(/\$(\d+)/g)].map((m2) => parseInt(m2[1], 10));
+    for (let i = 0;i < Math.min(cols.length, params.length); i++) {
+      result.set(params[i], cols[i]);
+    }
+    return result;
+  }
+  const SQL_KEYWORDS = new Set([
+    "not",
+    "and",
+    "or",
+    "where",
+    "set",
+    "when",
+    "then",
+    "else",
+    "case",
+    "between",
+    "exists",
+    "any",
+    "all",
+    "some",
+    "having"
+  ]);
+  const wherePatterns = /(?:(\w+)\s*\(\s*(\w+)\s*\)|(\w+))\s*(?:=|!=|<>|<=?|>=?|(?:NOT\s+)?(?:I?LIKE|IN|IS))\s*\$(\d+)/gi;
+  let m;
+  while ((m = wherePatterns.exec(sql)) !== null) {
+    const paramIdx = parseInt(m[4], 10);
+    if (m[1] && m[2]) {
+      result.set(paramIdx, m[2].toLowerCase());
+    } else if (m[3]) {
+      const word = m[3].toLowerCase();
+      if (!SQL_KEYWORDS.has(word)) {
+        result.set(paramIdx, word);
+      }
+    }
+  }
+  return result;
+}
+function findFromTable(sql, tables) {
+  const fromMatch = sql.match(/(?:FROM|INTO|UPDATE)\s+(\w+)/i);
+  if (!fromMatch)
+    return;
+  const tableName = fromMatch[1].toLowerCase();
+  return tables.find((t) => t.name === tableName);
+}
+function resolveReturningColumns(sql, table) {
+  const returningMatch = sql.match(/\bRETURNING\s+([\s\S]+?)(?:;?\s*)$/i);
+  if (!returningMatch)
+    return null;
+  const colsPart = returningMatch[1].trim();
+  if (colsPart === "*") {
+    return table ? [...table.columns] : [];
+  }
+  if (!table)
+    return [];
+  return colsPart.split(",").map((s) => {
+    const name = s.trim().toLowerCase();
+    const tableCol = table.columns.find((c) => c.name === name);
+    return tableCol ? { ...tableCol } : { name, type: { raw: "unknown", normalized: "unknown", category: "unknown" }, nullable: true, hasDefault: false };
+  });
+}
+function resolveReturnColumns(sql, table) {
+  const returning = resolveReturningColumns(sql, table);
+  if (returning)
+    return returning;
+  if (!/^\s*SELECT\b/i.test(sql))
+    return [];
+  const selectMatch = sql.match(/SELECT\s+([\s\S]+?)\s+FROM\b/i);
+  if (!selectMatch)
+    return [];
+  const colsPart = selectMatch[1].trim();
+  if (colsPart === "*") {
+    return table ? [...table.columns] : [];
+  }
+  if (!table)
+    return [];
+  const colNames = colsPart.split(",").map((s) => s.trim().toLowerCase());
+  const resolved = [];
+  for (const colExpr of colNames) {
+    const aliasMatch = colExpr.match(/^(\w+)\s+as\s+(\w+)$/i);
+    const actualName = aliasMatch ? aliasMatch[1] : colExpr;
+    const tableCol = table.columns.find((c) => c.name === actualName);
+    if (tableCol) {
+      resolved.push(aliasMatch ? { ...tableCol, alias: aliasMatch[2].toLowerCase() } : { ...tableCol });
+    } else {
+      resolved.push({
+        name: actualName,
+        type: { raw: "unknown", normalized: "unknown", category: "unknown" },
+        nullable: true,
+        hasDefault: false
+      });
+    }
+  }
+  return resolved;
+}
+function buildParams(sql, comments, table) {
+  const paramIndices = extractParamIndices(sql);
+  if (paramIndices.length === 0)
+    return [];
+  const overrides = extractParamOverrides(comments);
+  const inferredCols = inferParamColumns(sql);
+  const rawParams = paramIndices.map((idx) => ({
+    index: idx,
+    column: inferredCols.get(idx) ?? null,
+    override: overrides.get(idx)
+  }));
+  const names = resolveParamNames(rawParams);
+  return paramIndices.map((idx, i) => {
+    const colName = inferredCols.get(idx);
+    let type = {
+      raw: "unknown",
+      normalized: "unknown",
+      category: "unknown"
+    };
+    if (table && colName) {
+      const tableCol = table.columns.find((c) => c.name === colName);
+      if (tableCol) {
+        type = tableCol.type;
+      }
+    }
+    return { index: idx, name: names[i], type };
+  });
+}
+function createPostgresParser() {
+  return {
+    dialect: "postgresql",
+    parseEnums(sql) {
+      return parseEnumDefs(sql);
+    },
+    parseSchema(sql) {
+      const enums = parseEnumDefs(sql);
+      const enumNames = new Set(enums.map((e) => e.name));
+      return parseSchemaDefs(sql, enumNames);
+    },
+    parseQueries(sql, tables) {
+      const blocks = splitQueryBlocks(sql);
+      return blocks.map((block) => {
+        const table = findFromTable(block.sql, tables);
+        const params = buildParams(block.sql, block.comments, table);
+        const returns = resolveReturnColumns(block.sql, table);
+        return {
+          name: block.name,
+          command: block.command,
+          sql: block.sql.replace(/;\s*$/, ""),
+          params,
+          returns,
+          sourceFile: ""
+        };
+      });
+    }
+  };
+}
+export {
+  createPostgresParser
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "sqlcx-orm",
+  "version": "0.1.0",
+  "description": "SQL-first cross-language type-safe code generator",
+  "type": "module",
+  "bin": {
+    "sqlcx": "dist/cli.js"
+  },
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./src/config/index.ts",
+      "import": "./dist/config/index.js"
+    },
+    "./parser/postgres": {
+      "types": "./src/parser/postgres.ts",
+      "import": "./dist/parser/postgres.js"
+    },
+    "./generator/typescript": {
+      "types": "./src/generator/typescript/index.ts",
+      "import": "./dist/generator/typescript/index.js"
+    },
+    "./generator/typescript/schema/typebox": {
+      "types": "./src/generator/typescript/schema/typebox.ts",
+      "import": "./dist/generator/typescript/schema/typebox.js"
+    },
+    "./generator/typescript/driver/bun-sql": {
+      "types": "./src/generator/typescript/driver/bun-sql.ts",
+      "import": "./dist/generator/typescript/driver/bun-sql.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "test": "bun test",
+    "generate": "bun run src/cli/index.ts generate",
+    "check": "bun run src/cli/index.ts check",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": ["sql", "codegen", "typescript", "typebox", "orm", "type-safe", "bun"],
+  "license": "MIT",
+  "dependencies": {
+    "node-sql-parser": "^5.4.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.10",
+    "typescript": "^5.9.3"
+  }
+}

package/src/cache/index.ts

@@ -0,0 +1,46 @@
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { join } from "path";
+import type { SqlcxIR } from "@/ir";
+
+interface CacheFile {
+  hash: string;
+  ir: SqlcxIR;
+}
+
+export function computeHash(files: { path: string; content: string }[]): string {
+  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+  // Include both path and content in hash, with null byte separators
+  // to avoid collisions from file splits/merges/renames
+  const hash = createHash("sha256");
+  for (const f of sorted) {
+    hash.update(f.path);
+    hash.update("\0");
+    hash.update(f.content);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function writeCache(cacheDir: string, ir: SqlcxIR, hash: string): void {
+  if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
+  const data: CacheFile = { hash, ir };
+  const cachePath = join(cacheDir, "ir.json");
+  const tempPath = cachePath + ".tmp";
+  // Write to temp file then atomic rename — safe against interruptions
+  writeFileSync(tempPath, JSON.stringify(data, null, 2));
+  renameSync(tempPath, cachePath);
+}
+
+export function readCache(cacheDir: string, expectedHash: string): SqlcxIR | null {
+  const cachePath = join(cacheDir, "ir.json");
+  if (!existsSync(cachePath)) return null;
+  try {
+    const data: CacheFile = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (data.hash !== expectedHash) return null;
+    return data.ir;
+  } catch {
+    // Corrupted cache file — treat as cache miss
+    return null;
+  }
+}