sqlcx-orm 0.1.0

package/src/generator/typescript/schema/typebox.ts

@@ -0,0 +1,143 @@
+import type { SchemaGenerator } from "@/generator/interface";
+import type { SqlcxIR, TableDef, EnumDef, SqlType, ColumnDef, JsonShape } from "@/ir";
+import { pascalCase } from "@/utils";
+
+/** Safely escape a string for embedding in generated JS/TS double-quoted literals */
+function escapeString(str: string): string {
+  return JSON.stringify(str).slice(1, -1); // strip outer quotes from JSON.stringify
+}
+
+function jsonShapeToTypeBox(shape: JsonShape): string {
+  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: SqlType): string {
+  // Inline @enum annotation takes precedence
+  if (type.enumValues) {
+    const literals = type.enumValues
+      .map((v) => `Type.Literal("${escapeString(v)}")`)
+      .join(", ");
+    return `Type.Union([${literals}])`;
+  }
+
+  // Inline @json annotation takes precedence over generic json category
+  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: never = type.category;
+      return _exhaustive;
+    }
+  }
+}
+
+function selectColumn(col: ColumnDef): string {
+  const base = typeBoxType(col.type);
+  if (col.nullable) {
+    return `Type.Union([${base}, Type.Null()])`;
+  }
+  return base;
+}
+
+function insertColumn(col: ColumnDef): string {
+  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: ColumnDef[],
+  mapper: (col: ColumnDef) => string,
+): string {
+  const fields = columns
+    .map((col) => `  "${escapeString(col.name)}": ${mapper(col)}`)
+    .join(",\n");
+  return `{\n${fields}\n}`;
+}
+
+export function createTypeBoxGenerator(): SchemaGenerator {
+  return {
+    name: "typebox",
+
+    generateImports(): string {
+      return `import { Type, type Static } from "@sinclair/typebox";\n\n// Requires @sinclair/typebox >= 0.31.0 (for Type.Date and Type.Uint8Array)\n\ntype Prettify<T> = { [K in keyof T]: T[K] } & {};`;
+    },
+
+    generateEnumSchema(enumDef: EnumDef): string {
+      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: TableDef, _ir: SqlcxIR): string {
+      const name = `Select${pascalCase(table.name)}`;
+      const body = objectBody(table.columns, selectColumn);
+      return `export const ${name} = Type.Object(${body});`;
+    },
+
+    generateInsertSchema(table: TableDef, _ir: SqlcxIR): string {
+      const name = `Insert${pascalCase(table.name)}`;
+      const body = objectBody(table.columns, insertColumn);
+      return `export const ${name} = Type.Object(${body});`;
+    },
+
+    generateTypeAlias(name: string, schemaVarName: string): string {
+      return `export type ${name} = Prettify<Static<typeof ${schemaVarName}>>;`;
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+// Public API
+export { defineConfig } from "@/config";
+export type { SqlcxConfig } from "@/config";
+export type {
+  SqlcxIR,
+  TableDef,
+  ColumnDef,
+  QueryDef,
+  ParamDef,
+  EnumDef,
+  SqlType,
+  SqlTypeCategory,
+  QueryCommand,
+  JsonShape,
+} from "@/ir";
+export type { DatabaseParser } from "@/parser/interface";
+export type {
+  LanguagePlugin,
+  SchemaGenerator,
+  DriverGenerator,
+  GeneratedFile,
+  LanguageOptions,
+} from "@/generator/interface";

package/src/ir/index.ts

@@ -0,0 +1,72 @@
+export type SqlTypeCategory =
+  | "string"
+  | "number"
+  | "boolean"
+  | "date"
+  | "json"
+  | "uuid"
+  | "binary"
+  | "enum"
+  | "unknown";
+
+export type JsonShape =
+  | { kind: "string" }
+  | { kind: "number" }
+  | { kind: "boolean" }
+  | { kind: "object"; fields: Record<string, JsonShape> }
+  | { kind: "array"; element: JsonShape }
+  | { kind: "nullable"; inner: JsonShape };
+
+export interface SqlType {
+  raw: string;
+  normalized: string;
+  category: SqlTypeCategory;
+  elementType?: SqlType;
+  enumName?: string;
+  enumValues?: string[];
+  jsonShape?: JsonShape;
+}
+
+export interface ColumnDef {
+  name: string;
+  alias?: string;
+  sourceTable?: string;
+  type: SqlType;
+  nullable: boolean;
+  hasDefault: boolean;
+}
+
+export interface TableDef {
+  name: string;
+  columns: ColumnDef[];
+  primaryKey: string[];
+  uniqueConstraints: string[][];
+}
+
+export type QueryCommand = "one" | "many" | "exec" | "execresult";
+
+export interface ParamDef {
+  index: number;
+  name: string;
+  type: SqlType;
+}
+
+export interface QueryDef {
+  name: string;
+  command: QueryCommand;
+  sql: string;
+  params: ParamDef[];
+  returns: ColumnDef[];
+  sourceFile: string;
+}
+
+export interface EnumDef {
+  name: string;
+  values: string[];
+}
+
+export interface SqlcxIR {
+  tables: TableDef[];
+  queries: QueryDef[];
+  enums: EnumDef[];
+}

package/src/parser/interface.ts

@@ -0,0 +1,8 @@
+import type { TableDef, QueryDef, EnumDef } from "@/ir";
+
+export interface DatabaseParser {
+  dialect: string;
+  parseSchema(sql: string): TableDef[];
+  parseQueries(sql: string, tables: TableDef[]): QueryDef[];
+  parseEnums(sql: string): EnumDef[];
+}

package/src/parser/param-naming.ts

@@ -0,0 +1,49 @@
+export interface RawParam {
+  index: number;
+  column: string | null;
+  override?: string;
+}
+
+export function resolveParamNames(params: RawParam[]): string[] {
+  // Pass 1: count column frequency (needed to know which columns collide)
+  const freq = new Map<string, number>();
+  for (const p of params) {
+    if (!p.override && p.column) {
+      freq.set(p.column, (freq.get(p.column) ?? 0) + 1);
+    }
+  }
+
+  // Pass 2: assign names + dedup in one go
+  const counters = new Map<string, number>();
+  const seen = new Set<string>();
+  const result: string[] = new Array(params.length);
+
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
+    let name: string;
+
+    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;
+    }
+
+    // Dedup: resolve any remaining collisions (override-vs-inferred, suffix-vs-literal)
+    const base = name;
+    let suffix = 1;
+    while (seen.has(name)) {
+      name = `${base}_${suffix++}`;
+    }
+
+    seen.add(name);
+    result[i] = name;
+  }
+
+  return result;
+}