sqlcx-orm 0.1.0

package/dist/cli.js

@@ -0,0 +1,1226 @@
+// @bun
+// src/cli/index.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, dirname, basename, extname, relative } from "path";
+
+// src/cache/index.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { join } from "path";
+function computeHash(files) {
+  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+  const hash = createHash("sha256");
+  for (const f of sorted) {
+    hash.update(f.path);
+    hash.update("\x00");
+    hash.update(f.content);
+    hash.update("\x00");
+  }
+  return hash.digest("hex");
+}
+function writeCache(cacheDir, ir, hash) {
+  if (!existsSync(cacheDir))
+    mkdirSync(cacheDir, { recursive: true });
+  const data = { hash, ir };
+  const cachePath = join(cacheDir, "ir.json");
+  const tempPath = cachePath + ".tmp";
+  writeFileSync(tempPath, JSON.stringify(data, null, 2));
+  renameSync(tempPath, cachePath);
+}
+function readCache(cacheDir, expectedHash) {
+  const cachePath = join(cacheDir, "ir.json");
+  if (!existsSync(cachePath))
+    return null;
+  try {
+    const data = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (data.hash !== expectedHash)
+      return null;
+    return data.ir;
+  } catch {
+    return null;
+  }
+}
+
+// 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: ""
+        };
+      });
+    }
+  };
+}
+
+// src/utils/index.ts
+function pascalCase(str) {
+  return str.split(/[_\-\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function camelCase(str) {
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+// src/generator/typescript/index.ts
+import path from "path";
+function joinPath(base, filename) {
+  const joined = path.join(base, filename);
+  if (base.startsWith("./") && !joined.startsWith("./")) {
+    return "./" + joined;
+  }
+  return joined;
+}
+function generateSchemaFile(schema, ir) {
+  const parts = [];
+  parts.push(schema.generateImports());
+  for (const enumDef of ir.enums) {
+    parts.push(schema.generateEnumSchema(enumDef));
+  }
+  for (const table of ir.tables) {
+    parts.push(schema.generateSelectSchema(table, ir));
+    parts.push(schema.generateInsertSchema(table, ir));
+  }
+  for (const table of ir.tables) {
+    const selectName = `Select${pascalCase(table.name)}`;
+    const insertName = `Insert${pascalCase(table.name)}`;
+    parts.push(schema.generateTypeAlias(selectName, selectName));
+    parts.push(schema.generateTypeAlias(insertName, insertName));
+  }
+  for (const enumDef of ir.enums) {
+    const name = pascalCase(enumDef.name);
+    parts.push(schema.generateTypeAlias(name, name));
+  }
+  return parts.join(`
+
+`) + `
+`;
+}
+var DATABASE_CLIENT_INTERFACE = `export interface DatabaseClient {
+  query<T>(sql: string, params: unknown[]): Promise<T[]>;
+  queryOne<T>(sql: string, params: unknown[]): Promise<T | null>;
+  execute(sql: string, params: unknown[]): Promise<{ rowsAffected: number }>;
+}`;
+function generateClientFile(driver) {
+  const parts = [];
+  const driverImports = driver.generateImports();
+  if (driverImports) {
+    parts.push(driverImports);
+  }
+  parts.push(DATABASE_CLIENT_INTERFACE);
+  parts.push(driver.generateClientAdapter());
+  return parts.join(`
+
+`) + `
+`;
+}
+function generateQueryFiles(driver, ir, outDir) {
+  const grouped = new Map;
+  for (const query of ir.queries) {
+    const existing = grouped.get(query.sourceFile);
+    if (existing) {
+      existing.push(query);
+    } else {
+      grouped.set(query.sourceFile, [query]);
+    }
+  }
+  const files = [];
+  for (const [sourceFile, queries] of grouped) {
+    const basename = path.basename(sourceFile, path.extname(sourceFile));
+    const filename = `${basename}.queries.ts`;
+    const parts = [];
+    parts.push(`import type { DatabaseClient } from "./client";`);
+    for (const query of queries) {
+      parts.push(driver.generateQueryFunction(query));
+    }
+    files.push({
+      path: joinPath(outDir, filename),
+      content: parts.join(`
+
+`) + `
+`
+    });
+  }
+  return files;
+}
+function createTypeScriptPlugin(options) {
+  const { schema, driver } = options;
+  return {
+    language: "typescript",
+    fileExtension: ".ts",
+    generate(ir, langOptions) {
+      const outDir = langOptions.out;
+      const files = [];
+      files.push({
+        path: joinPath(outDir, "schema.ts"),
+        content: generateSchemaFile(schema, ir)
+      });
+      files.push({
+        path: joinPath(outDir, "client.ts"),
+        content: generateClientFile(driver)
+      });
+      files.push(...generateQueryFiles(driver, ir, outDir));
+      return files;
+    }
+  };
+}
+
+// src/generator/typescript/schema/typebox.ts
+function escapeString(str) {
+  return JSON.stringify(str).slice(1, -1);
+}
+function jsonShapeToTypeBox(shape) {
+  switch (shape.kind) {
+    case "string":
+      return "Type.String()";
+    case "number":
+      return "Type.Number()";
+    case "boolean":
+      return "Type.Boolean()";
+    case "object": {
+      const fields = Object.entries(shape.fields).map(([key, val]) => `"${escapeString(key)}": ${jsonShapeToTypeBox(val)}`).join(", ");
+      return `Type.Object({ ${fields} })`;
+    }
+    case "array":
+      return `Type.Array(${jsonShapeToTypeBox(shape.element)})`;
+    case "nullable":
+      return `Type.Union([${jsonShapeToTypeBox(shape.inner)}, Type.Null()])`;
+  }
+}
+function typeBoxType(type) {
+  if (type.enumValues) {
+    const literals = type.enumValues.map((v) => `Type.Literal("${escapeString(v)}")`).join(", ");
+    return `Type.Union([${literals}])`;
+  }
+  if (type.jsonShape) {
+    return jsonShapeToTypeBox(type.jsonShape);
+  }
+  if (type.elementType) {
+    return `Type.Array(${typeBoxType(type.elementType)})`;
+  }
+  switch (type.category) {
+    case "string":
+      return "Type.String()";
+    case "number":
+      return "Type.Number()";
+    case "boolean":
+      return "Type.Boolean()";
+    case "date":
+      return "Type.Date()";
+    case "json":
+      return "Type.Any()";
+    case "uuid":
+      return "Type.String()";
+    case "binary":
+      return "Type.Uint8Array()";
+    case "enum": {
+      if (type.enumName) {
+        return pascalCase(type.enumName);
+      }
+      return "Type.String()";
+    }
+    case "unknown":
+      return "Type.Unknown()";
+    default: {
+      const _exhaustive = type.category;
+      return _exhaustive;
+    }
+  }
+}
+function selectColumn(col) {
+  const base = typeBoxType(col.type);
+  if (col.nullable) {
+    return `Type.Union([${base}, Type.Null()])`;
+  }
+  return base;
+}
+function insertColumn(col) {
+  const base = typeBoxType(col.type);
+  if (col.hasDefault) {
+    if (col.nullable) {
+      return `Type.Optional(Type.Union([${base}, Type.Null()]))`;
+    }
+    return `Type.Optional(${base})`;
+  }
+  if (col.nullable) {
+    return `Type.Optional(Type.Union([${base}, Type.Null()]))`;
+  }
+  return base;
+}
+function objectBody(columns, mapper) {
+  const fields = columns.map((col) => `  "${escapeString(col.name)}": ${mapper(col)}`).join(`,
+`);
+  return `{
+${fields}
+}`;
+}
+function createTypeBoxGenerator() {
+  return {
+    name: "typebox",
+    generateImports() {
+      return `import { Type, type Static } from "@sinclair/typebox";
+
+// Requires @sinclair/typebox >= 0.31.0 (for Type.Date and Type.Uint8Array)
+
+type Prettify<T> = { [K in keyof T]: T[K] } & {};`;
+    },
+    generateEnumSchema(enumDef) {
+      const name = pascalCase(enumDef.name);
+      const literals = enumDef.values.map((v) => `Type.Literal("${escapeString(v)}")`).join(", ");
+      return `export const ${name} = Type.Union([${literals}]);`;
+    },
+    generateSelectSchema(table, _ir) {
+      const name = `Select${pascalCase(table.name)}`;
+      const body = objectBody(table.columns, selectColumn);
+      return `export const ${name} = Type.Object(${body});`;
+    },
+    generateInsertSchema(table, _ir) {
+      const name = `Insert${pascalCase(table.name)}`;
+      const body = objectBody(table.columns, insertColumn);
+      return `export const ${name} = Type.Object(${body});`;
+    },
+    generateTypeAlias(name, schemaVarName) {
+      return `export type ${name} = Prettify<Static<typeof ${schemaVarName}>>;`;
+    }
+  };
+}
+
+// src/generator/typescript/driver/bun-sql.ts
+function splitWords(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2");
+}
+function toCamel(str) {
+  return camelCase(splitWords(str));
+}
+function toPascal(str) {
+  return pascalCase(splitWords(str));
+}
+function tsType(type) {
+  if (type.elementType) {
+    return `${tsType(type.elementType)}[]`;
+  }
+  switch (type.category) {
+    case "string":
+    case "uuid":
+    case "enum":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "json":
+      return "unknown";
+    case "binary":
+      return "Uint8Array";
+    case "unknown":
+      return "unknown";
+  }
+}
+function generateRowType(query) {
+  if (query.returns.length === 0)
+    return "";
+  const typeName = `${toPascal(query.name)}Row`;
+  const fields = query.returns.map((col) => {
+    const fieldName = col.alias ?? col.name;
+    const type = tsType(col.type);
+    const nullable = col.nullable ? " | null" : "";
+    return `  ${fieldName}: ${type}${nullable};`;
+  }).join(`
+`);
+  return `export interface ${typeName} {
+${fields}
+}`;
+}
+function generateParamsType(query) {
+  if (query.params.length === 0)
+    return "";
+  const typeName = `${toPascal(query.name)}Params`;
+  const fields = query.params.map((p) => `  ${p.name}: ${tsType(p.type)};`).join(`
+`);
+  return `export interface ${typeName} {
+${fields}
+}`;
+}
+function createBunSqlGenerator() {
+  return {
+    name: "bun-sql",
+    generateImports() {
+      return "";
+    },
+    generateClientAdapter() {
+      return `interface BunSqlDriver {
+  unsafe(query: string, values?: unknown[]): Promise<any[] & { count: number }>;
+}
+
+export class BunSqlClient implements DatabaseClient {
+  private sql: BunSqlDriver;
+
+  constructor(sql: BunSqlDriver) {
+    this.sql = sql;
+  }
+
+  async query<T>(text: string, values?: unknown[]): Promise<T[]> {
+    const result = await this.sql.unsafe(text, values);
+    return [...result] as T[];
+  }
+
+  async queryOne<T>(text: string, values?: unknown[]): Promise<T | null> {
+    const rows = await this.query<T>(text, values);
+    return rows[0] ?? null;
+  }
+
+  async execute(text: string, values?: unknown[]): Promise<{ rowsAffected: number }> {
+    const result = await this.sql.unsafe(text, values);
+    return { rowsAffected: result.count };
+  }
+}`;
+    },
+    generateQueryFunction(query) {
+      const fnName = toCamel(query.name);
+      const rowType = generateRowType(query);
+      const hasParams = query.params.length > 0;
+      const paramsInterface = generateParamsType(query);
+      const paramsTypeName = `${toPascal(query.name)}Params`;
+      const sqlConst = `export const ${fnName}Sql = ${JSON.stringify(query.sql)};`;
+      const paramsSig = hasParams ? `, params: ${paramsTypeName}` : "";
+      const valuesArg = hasParams ? `[${query.params.map((p) => `params.${p.name}`).join(", ")}]` : "[]";
+      let returnType;
+      let body;
+      switch (query.command) {
+        case "one": {
+          const typeName = `${toPascal(query.name)}Row`;
+          returnType = `Promise<${typeName} | null>`;
+          body = `  return client.queryOne<${typeName}>(${fnName}Sql, ${valuesArg});`;
+          break;
+        }
+        case "many": {
+          const typeName = `${toPascal(query.name)}Row`;
+          returnType = `Promise<${typeName}[]>`;
+          body = `  return client.query<${typeName}>(${fnName}Sql, ${valuesArg});`;
+          break;
+        }
+        case "exec": {
+          returnType = "Promise<void>";
+          body = `  await client.execute(${fnName}Sql, ${valuesArg});`;
+          break;
+        }
+        case "execresult": {
+          returnType = "Promise<{ rowsAffected: number }>";
+          body = `  return client.execute(${fnName}Sql, ${valuesArg});`;
+          break;
+        }
+      }
+      const parts = [];
+      if (rowType)
+        parts.push(rowType);
+      if (paramsInterface)
+        parts.push(paramsInterface);
+      parts.push(sqlConst);
+      parts.push(`export async function ${fnName}(client: DatabaseClient${paramsSig}): ${returnType} {
+${body}
+}`);
+      return parts.join(`
+
+`);
+    }
+  };
+}
+
+// src/cli/index.ts
+function globSqlFiles(dir) {
+  const glob = new Bun.Glob("**/*.sql");
+  const paths = [];
+  for (const match of glob.scanSync({ cwd: dir, absolute: true })) {
+    paths.push(match);
+  }
+  return paths.sort();
+}
+function isSchemaFile(content) {
+  return /CREATE\s+TABLE/i.test(content);
+}
+function isQueryFile(content) {
+  return /--\s*name:/i.test(content);
+}
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+async function generate(options) {
+  const { sqlDir, outDir, cacheDir } = options;
+  const sqlFiles = globSqlFiles(sqlDir);
+  if (sqlFiles.length === 0) {
+    console.log("No .sql files found in", sqlDir);
+    return;
+  }
+  const fileContents = sqlFiles.map((f) => ({
+    path: relative(sqlDir, f),
+    content: readFileSync2(f, "utf-8")
+  }));
+  const hash = computeHash(fileContents);
+  let ir = readCache(cacheDir, hash);
+  if (!ir) {
+    ir = parse(fileContents);
+    writeCache(cacheDir, ir, hash);
+  }
+  const plugin = createTypeScriptPlugin({
+    schema: createTypeBoxGenerator(),
+    driver: createBunSqlGenerator()
+  });
+  const generatedFiles = plugin.generate(ir, { out: outDir });
+  for (const file of generatedFiles) {
+    const dir = dirname(file.path);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(file.path, file.content, "utf-8");
+  }
+  console.log(`Generated ${generatedFiles.length} files to ${outDir}`);
+}
+async function check(options) {
+  const { sqlDir, cacheDir } = options;
+  const errors = [];
+  const sqlFiles = globSqlFiles(sqlDir);
+  if (sqlFiles.length === 0) {
+    return { valid: true, tables: 0, queries: 0, errors: [] };
+  }
+  const fileContents = sqlFiles.map((f) => ({
+    path: relative(sqlDir, f),
+    content: readFileSync2(f, "utf-8")
+  }));
+  const hash = computeHash(fileContents);
+  let ir = readCache(cacheDir, hash);
+  if (!ir) {
+    try {
+      ir = parse(fileContents);
+      writeCache(cacheDir, ir, hash);
+    } catch (err) {
+      errors.push(String(err));
+      return { valid: false, tables: 0, queries: 0, errors };
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    tables: ir.tables.length,
+    queries: ir.queries.length,
+    errors
+  };
+}
+function parse(fileContents) {
+  const parser = createPostgresParser();
+  const schemaFiles = fileContents.filter((f) => isSchemaFile(f.content));
+  const queryFiles = fileContents.filter((f) => isQueryFile(f.content));
+  const allSchemaSql = schemaFiles.map((f) => f.content).join(`
+
+`);
+  const enums = parser.parseEnums(allSchemaSql);
+  const tables = parser.parseSchema(allSchemaSql);
+  const queries = [];
+  for (const file of queryFiles) {
+    const parsed = parser.parseQueries(file.content, tables);
+    for (const q of parsed) {
+      q.sourceFile = basename(file.path, extname(file.path));
+      queries.push(q);
+    }
+  }
+  return { tables, queries, enums };
+}
+async function init() {
+  const sqlDir = "sql";
+  const queriesDir = join2(sqlDir, "queries");
+  if (!existsSync2(sqlDir)) {
+    mkdirSync2(queriesDir, { recursive: true });
+  } else if (!existsSync2(queriesDir)) {
+    mkdirSync2(queriesDir, { recursive: true });
+  }
+  const schemaPath = join2(sqlDir, "schema.sql");
+  if (!existsSync2(schemaPath)) {
+    writeFileSync2(schemaPath, `CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT NOT NULL UNIQUE,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+`, "utf-8");
+    console.log("Created", schemaPath);
+  }
+  const queryPath = join2(queriesDir, "users.sql");
+  if (!existsSync2(queryPath)) {
+    writeFileSync2(queryPath, `-- name: GetUserById :one
+SELECT * FROM users WHERE id = $1;
+
+-- name: ListUsers :many
+SELECT * FROM users ORDER BY created_at DESC;
+
+-- name: CreateUser :exec
+INSERT INTO users (name, email) VALUES ($1, $2);
+`, "utf-8");
+    console.log("Created", queryPath);
+  }
+  const configPath = "sqlcx.config.ts";
+  if (!existsSync2(configPath)) {
+    writeFileSync2(configPath, `import { defineConfig } from "sqlcx";
+import { createPostgresParser } from "sqlcx/parser/postgres";
+import { createTypeScriptPlugin } from "sqlcx/generator/typescript";
+import { createTypeBoxGenerator } from "sqlcx/generator/typescript/schema/typebox";
+import { createBunSqlGenerator } from "sqlcx/generator/typescript/driver/bun-sql";
+
+export default defineConfig({
+  sql: "./sql",
+  parser: createPostgresParser(),
+  targets: [
+    createTypeScriptPlugin({
+      schema: createTypeBoxGenerator(),
+      driver: createBunSqlGenerator(),
+    }),
+  ],
+});
+`, "utf-8");
+    console.log("Created", configPath);
+  }
+  console.log(`
+Project initialized! Run 'sqlcx generate' to generate types.`);
+}
+function printHelp() {
+  console.log("Usage: sqlcx <generate|check|init> [options]");
+  console.log("");
+  console.log("Commands:");
+  console.log("  generate    Parse SQL and generate typed code");
+  console.log("  check       Validate SQL files without generating (CI-friendly)");
+  console.log("  init        Scaffold sql/ directory with example files");
+  console.log("");
+  console.log("Options:");
+  console.log("  --sql <dir>    SQL directory (default: ./sql)");
+  console.log("  --out <dir>    Output directory (default: ./src/db)");
+  console.log("  --cache <dir>  Cache directory (default: .sqlcx)");
+}
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (command === "generate") {
+    await generate({
+      sqlDir: getFlag(args, "--sql") ?? "./sql",
+      outDir: getFlag(args, "--out") ?? "./src/db",
+      cacheDir: getFlag(args, "--cache") ?? ".sqlcx"
+    });
+  } else if (command === "check") {
+    const result = await check({
+      sqlDir: getFlag(args, "--sql") ?? "./sql",
+      cacheDir: getFlag(args, "--cache") ?? ".sqlcx"
+    });
+    if (!result.valid) {
+      console.error("Check failed:", result.errors);
+      process.exit(1);
+    }
+    console.log(`Check passed: ${result.tables} tables, ${result.queries} queries`);
+  } else if (command === "init") {
+    await init();
+  } else {
+    printHelp();
+  }
+}
+export {
+  generate,
+  check
+};