sqlcx-orm 0.1.0

package/dist/config/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  defineConfig,
+  loadConfig
+} from "../chunk-3qq0zjsm.js";
+export {
+  loadConfig,
+  defineConfig
+};

package/dist/generator/typescript/driver/bun-sql.js

@@ -0,0 +1,151 @@
+// @bun
+import {
+  camelCase,
+  pascalCase
+} from "../../../chunk-49wq4032.js";
+
+// 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(`
+
+`);
+    }
+  };
+}
+export {
+  createBunSqlGenerator
+};

package/dist/generator/typescript/index.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  pascalCase
+} from "../../chunk-49wq4032.js";
+
+// 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;
+    }
+  };
+}
+export {
+  createTypeScriptPlugin
+};

package/dist/generator/typescript/schema/typebox.js

@@ -0,0 +1,127 @@
+// @bun
+import {
+  pascalCase
+} from "../../../chunk-49wq4032.js";
+
+// 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}>>;`;
+    }
+  };
+}
+export {
+  createTypeBoxGenerator
+};

package/dist/index.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  defineConfig
+} from "./chunk-3qq0zjsm.js";
+export {
+  defineConfig
+};