sqlcx-orm 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,306 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname, basename, extname, relative } from "path";
+import { computeHash, readCache, writeCache } from "@/cache";
+import { createPostgresParser } from "@/parser/postgres";
+import { createTypeScriptPlugin } from "@/generator/typescript";
+import { createTypeBoxGenerator } from "@/generator/typescript/schema/typebox";
+import { createBunSqlGenerator } from "@/generator/typescript/driver/bun-sql";
+import type { SqlcxIR, TableDef, QueryDef, EnumDef } from "@/ir";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function globSqlFiles(dir: string): string[] {
+  const glob = new Bun.Glob("**/*.sql");
+  const paths: string[] = [];
+  for (const match of glob.scanSync({ cwd: dir, absolute: true })) {
+    paths.push(match);
+  }
+  return paths.sort();
+}
+
+function isSchemaFile(content: string): boolean {
+  return /CREATE\s+TABLE/i.test(content);
+}
+
+function isQueryFile(content: string): boolean {
+  return /--\s*name:/i.test(content);
+}
+
+function getFlag(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Generate
+// ---------------------------------------------------------------------------
+
+export interface GenerateOptions {
+  sqlDir: string;
+  outDir: string;
+  cacheDir: string;
+}
+
+export async function generate(options: GenerateOptions): Promise<void> {
+  const { sqlDir, outDir, cacheDir } = options;
+
+  // 1. Glob all .sql files
+  const sqlFiles = globSqlFiles(sqlDir);
+  if (sqlFiles.length === 0) {
+    console.log("No .sql files found in", sqlDir);
+    return;
+  }
+
+  // 2. Read all SQL files
+  const fileContents = sqlFiles.map((f) => ({
+    path: relative(sqlDir, f),
+    content: readFileSync(f, "utf-8"),
+  }));
+
+  // 3. Compute content hash
+  const hash = computeHash(fileContents);
+
+  // 4. Check cache
+  let ir = readCache(cacheDir, hash);
+
+  if (!ir) {
+    // 5. Parse
+    ir = parse(fileContents);
+
+    // 6. Write cache
+    writeCache(cacheDir, ir, hash);
+  }
+
+  // 7. Generate output
+  const plugin = createTypeScriptPlugin({
+    schema: createTypeBoxGenerator(),
+    driver: createBunSqlGenerator(),
+  });
+  const generatedFiles = plugin.generate(ir, { out: outDir });
+
+  // 8. Write files to disk
+  for (const file of generatedFiles) {
+    const dir = dirname(file.path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(file.path, file.content, "utf-8");
+  }
+
+  // 9. Log success
+  console.log(`Generated ${generatedFiles.length} files to ${outDir}`);
+}
+
+// ---------------------------------------------------------------------------
+// Check
+// ---------------------------------------------------------------------------
+
+export interface CheckOptions {
+  sqlDir: string;
+  cacheDir: string;
+}
+
+export interface CheckResult {
+  valid: boolean;
+  tables: number;
+  queries: number;
+  errors: string[];
+}
+
+export async function check(options: CheckOptions): Promise<CheckResult> {
+  const { sqlDir, cacheDir } = options;
+  const errors: string[] = [];
+
+  // 1. Glob all .sql files
+  const sqlFiles = globSqlFiles(sqlDir);
+  if (sqlFiles.length === 0) {
+    return { valid: true, tables: 0, queries: 0, errors: [] };
+  }
+
+  // 2. Read all SQL files
+  const fileContents = sqlFiles.map((f) => ({
+    path: relative(sqlDir, f),
+    content: readFileSync(f, "utf-8"),
+  }));
+
+  // 3. Compute hash and check cache
+  const hash = computeHash(fileContents);
+  let ir = readCache(cacheDir, hash);
+
+  if (!ir) {
+    // 4. Parse
+    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,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Shared parse logic
+// ---------------------------------------------------------------------------
+
+function parse(
+  fileContents: { path: string; content: string }[],
+): SqlcxIR {
+  const parser = createPostgresParser();
+
+  const schemaFiles = fileContents.filter((f) => isSchemaFile(f.content));
+  const queryFiles = fileContents.filter((f) => isQueryFile(f.content));
+
+  // Parse enums from all schema files
+  const allSchemaSql = schemaFiles.map((f) => f.content).join("\n\n");
+  const enums: EnumDef[] = parser.parseEnums(allSchemaSql);
+
+  // Parse tables from all schema files
+  const tables: TableDef[] = parser.parseSchema(allSchemaSql);
+
+  // Parse queries from each query file
+  const queries: QueryDef[] = [];
+  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 };
+}
+
+// ---------------------------------------------------------------------------
+// Init
+// ---------------------------------------------------------------------------
+
+async function init(): Promise<void> {
+  // Create sql/ directory with example files
+  const sqlDir = "sql";
+  const queriesDir = join(sqlDir, "queries");
+
+  if (!existsSync(sqlDir)) {
+    mkdirSync(queriesDir, { recursive: true });
+  } else if (!existsSync(queriesDir)) {
+    mkdirSync(queriesDir, { recursive: true });
+  }
+
+  const schemaPath = join(sqlDir, "schema.sql");
+  if (!existsSync(schemaPath)) {
+    writeFileSync(
+      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 = join(queriesDir, "users.sql");
+  if (!existsSync(queryPath)) {
+    writeFileSync(
+      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 (!existsSync(configPath)) {
+    writeFileSync(
+      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("\nProject initialized! Run 'sqlcx generate' to generate types.");
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+function printHelp(): void {
+  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();
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,19 @@
+import type { DatabaseParser } from "@/parser/interface";
+import type { LanguagePlugin } from "@/generator/interface";
+
+export interface SqlcxConfig {
+  sql: string;
+  parser: DatabaseParser;
+  targets: LanguagePlugin[];
+  overrides?: Record<string, string>;
+}
+
+export function defineConfig(config: SqlcxConfig): SqlcxConfig {
+  return config;
+}
+
+export async function loadConfig(configPath: string): Promise<SqlcxConfig> {
+  const resolved = Bun.resolveSync(configPath, process.cwd());
+  const mod = await import(resolved);
+  return mod.default as SqlcxConfig;
+}

package/src/generator/interface.ts

@@ -0,0 +1,36 @@
+import type { SqlcxIR, TableDef, QueryDef, EnumDef } from "@/ir";
+
+export interface LanguageOptions {
+  out: string;
+  overrides?: Record<string, string>;
+}
+
+export interface GeneratedFile {
+  path: string;
+  content: string;
+}
+
+export interface SchemaGenerator {
+  name: string;
+  generateImports(): string;
+  generateEnumSchema(enumDef: EnumDef): string;
+  generateSelectSchema(table: TableDef, ir: SqlcxIR): string;
+  generateInsertSchema(table: TableDef, ir: SqlcxIR): string;
+  generateTypeAlias(name: string, schemaVarName: string): string;
+}
+
+export interface DriverGenerator {
+  name: string;
+  generateImports(): string;
+  generateClientAdapter(): string;
+  generateQueryFunction(query: QueryDef): string;
+}
+
+// DatabaseClient interface is generated by the LanguagePlugin (not the DriverGenerator).
+// This prevents collisions when multiple drivers target the same output dir.
+
+export interface LanguagePlugin {
+  language: string;
+  fileExtension: string;
+  generate(ir: SqlcxIR, options: LanguageOptions): GeneratedFile[];
+}

package/src/generator/typescript/driver/bun-sql.ts

@@ -0,0 +1,157 @@
+import type { DriverGenerator } from "@/generator/interface";
+import type { QueryDef, SqlType } from "@/ir";
+import { camelCase, pascalCase } from "@/utils";
+
+/** Split PascalCase/camelCase into words before applying case utils */
+function splitWords(str: string): string {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2");
+}
+
+function toCamel(str: string): string {
+  return camelCase(splitWords(str));
+}
+
+function toPascal(str: string): string {
+  return pascalCase(splitWords(str));
+}
+
+function tsType(type: SqlType): string {
+  // Handle arrays
+  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: QueryDef): string {
+  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("\n");
+  return `export interface ${typeName} {\n${fields}\n}`;
+}
+
+function generateParamsType(query: QueryDef): string {
+  if (query.params.length === 0) return "";
+  const typeName = `${toPascal(query.name)}Params`;
+  const fields = query.params
+    .map((p) => `  ${p.name}: ${tsType(p.type)};`)
+    .join("\n");
+  return `export interface ${typeName} {\n${fields}\n}`;
+}
+
+export function createBunSqlGenerator(): DriverGenerator {
+  return {
+    name: "bun-sql",
+
+    generateImports(): string {
+      return "";
+    },
+
+    generateClientAdapter(): string {
+      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: QueryDef): string {
+      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`;
+      // JSON.stringify handles newlines, quotes, backslashes safely
+      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: string;
+      let body: string;
+
+      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: string[] = [];
+      if (rowType) parts.push(rowType);
+      if (paramsInterface) parts.push(paramsInterface);
+      parts.push(sqlConst);
+      parts.push(
+        `export async function ${fnName}(client: DatabaseClient${paramsSig}): ${returnType} {\n${body}\n}`
+      );
+
+      return parts.join("\n\n");
+    },
+  };
+}

package/src/generator/typescript/index.ts

@@ -0,0 +1,144 @@
+import type {
+  LanguagePlugin,
+  SchemaGenerator,
+  DriverGenerator,
+  GeneratedFile,
+  LanguageOptions,
+} from "@/generator/interface";
+import type { SqlcxIR } from "@/ir";
+import { pascalCase } from "@/utils";
+import path from "node:path";
+
+function joinPath(base: string, filename: string): string {
+  const joined = path.join(base, filename);
+  // Preserve leading "./" if the base had it
+  if (base.startsWith("./") && !joined.startsWith("./")) {
+    return "./" + joined;
+  }
+  return joined;
+}
+
+interface TypeScriptPluginOptions {
+  schema: SchemaGenerator;
+  driver: DriverGenerator;
+}
+
+function generateSchemaFile(
+  schema: SchemaGenerator,
+  ir: SqlcxIR,
+): string {
+  const parts: string[] = [];
+
+  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("\n\n") + "\n";
+}
+
+const 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: DriverGenerator): string {
+  const parts: string[] = [];
+
+  const driverImports = driver.generateImports();
+  if (driverImports) {
+    parts.push(driverImports);
+  }
+
+  parts.push(DATABASE_CLIENT_INTERFACE);
+  parts.push(driver.generateClientAdapter());
+
+  return parts.join("\n\n") + "\n";
+}
+
+function generateQueryFiles(
+  driver: DriverGenerator,
+  ir: SqlcxIR,
+  outDir: string,
+): GeneratedFile[] {
+  const grouped = new Map<string, typeof ir.queries>();
+
+  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: GeneratedFile[] = [];
+
+  for (const [sourceFile, queries] of grouped) {
+    const basename = path.basename(sourceFile, path.extname(sourceFile));
+    const filename = `${basename}.queries.ts`;
+
+    const parts: string[] = [];
+    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("\n\n") + "\n",
+    });
+  }
+
+  return files;
+}
+
+export function createTypeScriptPlugin(
+  options: TypeScriptPluginOptions,
+): LanguagePlugin {
+  const { schema, driver } = options;
+
+  return {
+    language: "typescript",
+    fileExtension: ".ts",
+
+    generate(ir: SqlcxIR, langOptions: LanguageOptions): GeneratedFile[] {
+      const outDir = langOptions.out;
+      const files: GeneratedFile[] = [];
+
+      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;
+    },
+  };
+}