@fragno-dev/db 0.0.1 → 0.1.0

package/src/adapters/drizzle/generate.ts

@@ -0,0 +1,481 @@
+import { importGenerator } from "../../util/import-generator";
+import { ident, parseVarchar } from "../../util/parse";
+import {
+  type AnyColumn,
+  type AnySchema,
+  type AnyTable,
+  InternalIdColumn,
+} from "../../schema/create";
+import type { SQLProvider } from "../../shared/providers";
+import { schemaToDBType, type DBTypeLiteral } from "../../schema/serialize";
+
+// ============================================================================
+// PROVIDER CONFIGURATION
+// ============================================================================
+
+const PROVIDER_IMPORTS = {
+  mysql: "drizzle-orm/mysql-core",
+  postgresql: "drizzle-orm/pg-core",
+  sqlite: "drizzle-orm/sqlite-core",
+} as const;
+
+const PROVIDER_TABLE_FUNCTIONS = {
+  mysql: "mysqlTable",
+  postgresql: "pgTable",
+  sqlite: "sqliteTable",
+} as const;
+
+export type SupportedProvider = Exclude<SQLProvider, "cockroachdb" | "mssql">;
+
+// ============================================================================
+// CONTEXT
+// ============================================================================
+
+interface GeneratorContext {
+  provider: SupportedProvider;
+  imports: ReturnType<typeof importGenerator>;
+  importSource: string;
+  generatedCustomTypes: Set<string>;
+  idGeneratorImport?: { name: string; from: string };
+}
+
+function createContext(
+  provider: SupportedProvider,
+  idGeneratorImport?: { name: string; from: string },
+): GeneratorContext {
+  return {
+    provider,
+    imports: importGenerator(),
+    importSource: PROVIDER_IMPORTS[provider],
+    generatedCustomTypes: new Set<string>(),
+    idGeneratorImport,
+  };
+}
+
+// ============================================================================
+// CUSTOM TYPE GENERATION
+// ============================================================================
+
+interface CustomTypeOptions {
+  dataType: string;
+  driverDataType: string;
+  databaseDataType: string;
+  fromDriverCode: string;
+  toDriverCode: string;
+}
+
+function generateCustomType(
+  ctx: GeneratorContext,
+  name: string,
+  options: CustomTypeOptions,
+): string | undefined {
+  if (ctx.generatedCustomTypes.has(name)) {
+    return undefined;
+  }
+
+  ctx.imports.addImport("customType", ctx.importSource);
+  ctx.generatedCustomTypes.add(name);
+
+  return `const ${name} = customType<
+  {
+    data: ${options.dataType};
+    driverData: ${options.driverDataType};
+  }
+>({
+  dataType() {
+    return "${options.databaseDataType}";
+  },
+  fromDriver(value) {
+    ${options.fromDriverCode}
+  },
+  toDriver(value) {
+    ${options.toDriverCode}
+  }
+});`;
+}
+
+function generateBinaryCustomType(ctx: GeneratorContext, customTypes: string[]): string {
+  const name = "customBinary";
+  const code = generateCustomType(ctx, name, {
+    dataType: "Uint8Array",
+    driverDataType: "Buffer",
+    databaseDataType: schemaToDBType({ type: "binary" }, ctx.provider),
+    fromDriverCode: "return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)",
+    toDriverCode: `return value instanceof Buffer? value : Buffer.from(value)`,
+  });
+
+  if (code) {
+    customTypes.push(code);
+  }
+  return name;
+}
+
+// ============================================================================
+// COLUMN TYPE MAPPING
+// ============================================================================
+
+interface ColumnTypeFunction {
+  name: string;
+  isCustomType?: boolean;
+  params?: string[];
+}
+
+/**
+ * Maps SQL database types to Drizzle function names and parameters.
+ * Uses schemaToDBType as the source of truth for type conversion.
+ */
+function getColumnTypeFunction(
+  ctx: GeneratorContext,
+  column: AnyColumn,
+  customTypes: string[],
+): ColumnTypeFunction {
+  // Get the canonical database type from schemaToDBType
+  const dbType = schemaToDBType(column, ctx.provider);
+
+  // Map database types to Drizzle function names
+  return mapDBTypeToDrizzleFunction(ctx, dbType, column, customTypes);
+}
+
+/**
+ * Maps a database type string to a Drizzle function name and parameters.
+ */
+function mapDBTypeToDrizzleFunction(
+  ctx: GeneratorContext,
+  dbType: DBTypeLiteral,
+  column: AnyColumn,
+  customTypes: string[],
+): ColumnTypeFunction {
+  // Handle provider-specific types
+  if (ctx.provider === "postgresql") {
+    switch (dbType) {
+      case "bigserial":
+        // bigserial requires a mode parameter in Drizzle
+        return { name: "bigserial", params: [`{ mode: "number" }`] };
+      case "serial":
+        return { name: "serial" };
+      case "boolean":
+        return { name: "boolean" };
+      case "bytea":
+        return { name: generateBinaryCustomType(ctx, customTypes), isCustomType: true };
+      case "json":
+        return { name: "json" };
+      case "text":
+        return { name: "text" };
+      case "bigint":
+        return { name: "bigint", params: [`{ mode: "number" }`] };
+      default:
+        if (dbType.startsWith("varchar(")) {
+          const length = parseVarchar(dbType);
+          return { name: "varchar", params: [`{ length: ${length} }`] };
+        }
+        return { name: dbType };
+    }
+  }
+
+  if (ctx.provider === "mysql") {
+    switch (dbType) {
+      case "boolean":
+        return { name: "boolean" };
+      case "text":
+        return { name: "text" };
+      case "longblob":
+        return { name: generateBinaryCustomType(ctx, customTypes), isCustomType: true };
+      case "bigint":
+        return { name: "bigint" };
+      default:
+        if (dbType.startsWith("varchar(")) {
+          const length = parseVarchar(dbType);
+          return { name: "varchar", params: [`{ length: ${length} }`] };
+        }
+        return { name: dbType };
+    }
+  }
+
+  if (ctx.provider === "sqlite") {
+    switch (dbType) {
+      case "integer":
+        // Need to determine the mode based on the original column type
+        if (column.type === "bool") {
+          return { name: "integer", params: [`{ mode: "boolean" }`] };
+        }
+        if (column.type === "timestamp" || column.type === "date") {
+          return { name: "integer", params: [`{ mode: "timestamp" }`] };
+        }
+        return { name: "integer" };
+      case "blob":
+        // Need to determine the mode based on the original column type
+        if (column.type === "bigint") {
+          return { name: "blob", params: [`{ mode: "bigint" }`] };
+        }
+        return { name: generateBinaryCustomType(ctx, customTypes), isCustomType: true };
+      case "text":
+        // Check if it's JSON
+        if (column.type === "json") {
+          return { name: "blob", params: [`{ mode: "json" }`] };
+        }
+        return { name: "text" };
+      case "real":
+        return { name: "real" };
+      default:
+        return { name: dbType };
+    }
+  }
+
+  // Fallback for other providers
+  return { name: dbType };
+}
+
+// ============================================================================
+// COLUMN GENERATION
+// ============================================================================
+
+function generateColumnDefinition(
+  ctx: GeneratorContext,
+  column: AnyColumn,
+  customTypes: string[],
+): string {
+  const parts: string[] = [];
+  const typeFn = getColumnTypeFunction(ctx, column, customTypes);
+
+  // Column type with parameters
+  const params: string[] = [`"${column.name}"`, ...(typeFn.params ?? [])];
+  if (!typeFn.isCustomType) {
+    ctx.imports.addImport(typeFn.name, ctx.importSource);
+  }
+  parts.push(`${typeFn.name}(${params.join(", ")})`);
+
+  // Primary key for internal ID
+  if (column instanceof InternalIdColumn || column.role === "internal-id") {
+    parts.push("primaryKey()");
+
+    // Auto-increment based on provider
+    // Note: PostgreSQL uses bigserial/serial which handle auto-increment automatically
+    if (ctx.provider === "mysql" || ctx.provider === "sqlite") {
+      parts.push("autoincrement()");
+    }
+  }
+
+  // Nullability
+  if (!column.isNullable) {
+    parts.push("notNull()");
+  }
+
+  // Default values
+  if (column.default) {
+    if ("value" in column.default) {
+      let value: string;
+      if (typeof column.default.value === "bigint") {
+        ctx.imports.addImport("sql", "drizzle-orm");
+        value = `sql\`${column.default.value.toString()}\``;
+      } else {
+        value = JSON.stringify(column.default.value);
+      }
+      parts.push(`default(${value})`);
+    } else if (column.default.runtime === "auto") {
+      const idGen = ctx.idGeneratorImport ?? { name: "createId", from: "@fragno-dev/db/id" };
+      ctx.imports.addImport(idGen.name, idGen.from);
+      parts.push(`$defaultFn(() => ${idGen.name}())`);
+    } else if (column.default.runtime === "now") {
+      parts.push("defaultNow()");
+    }
+  }
+
+  return `  ${column.ormName}: ${parts.join(".")}`;
+}
+
+function generateAllColumns(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  customTypes: string[],
+): string[] {
+  return Object.values(table.columns).map((column) =>
+    generateColumnDefinition(ctx, column, customTypes),
+  );
+}
+
+// ============================================================================
+// CONSTRAINT GENERATION
+// ============================================================================
+
+function generateForeignKeys(ctx: GeneratorContext, table: AnyTable): string[] {
+  const keys: string[] = [];
+
+  for (const relation of Object.values(table.relations)) {
+    // Only "one" relations generate foreign keys
+    // "many" relations don't have foreign keys (they're on the other side)
+    if (relation.type === "many") {
+      continue;
+    }
+
+    const columns: string[] = [];
+    const foreignColumns: string[] = [];
+    const isSelfReference = relation.table.ormName === table.ormName;
+
+    for (const [localCol, refCol] of relation.on) {
+      columns.push(`table.${localCol}`);
+      // Foreign keys always reference internal IDs
+      const actualRefCol = refCol === "id" ? "_internalId" : refCol;
+      // For self-referencing foreign keys, use table parameter instead of table constant
+      if (isSelfReference) {
+        foreignColumns.push(`table.${actualRefCol}`);
+      } else {
+        foreignColumns.push(`${relation.table.ormName}.${actualRefCol}`);
+      }
+    }
+
+    ctx.imports.addImport("foreignKey", ctx.importSource);
+    const fkName = `${table.ormName}_${relation.table.ormName}_${relation.name}_fk`;
+
+    keys.push(`foreignKey({
+  columns: [${columns.join(", ")}],
+  foreignColumns: [${foreignColumns.join(", ")}],
+  name: "${fkName}"
+})`);
+  }
+
+  return keys;
+}
+
+function generateIndexes(ctx: GeneratorContext, table: AnyTable): string[] {
+  const indexes: string[] = [];
+
+  for (const idx of Object.values(table.indexes)) {
+    const columns = idx.columns.map((col) => `table.${col.ormName}`).join(", ");
+
+    if (idx.unique) {
+      ctx.imports.addImport("uniqueIndex", ctx.importSource);
+      indexes.push(`uniqueIndex("${idx.name}").on(${columns})`);
+    } else {
+      ctx.imports.addImport("index", ctx.importSource);
+      indexes.push(`index("${idx.name}").on(${columns})`);
+    }
+  }
+
+  return indexes;
+}
+
+function generateTableConstraints(ctx: GeneratorContext, table: AnyTable): string[] {
+  return [...generateForeignKeys(ctx, table), ...generateIndexes(ctx, table)];
+}
+
+// ============================================================================
+// TABLE GENERATION
+// ============================================================================
+
+function generateTable(ctx: GeneratorContext, table: AnyTable, customTypes: string[]): string {
+  const tableFn = PROVIDER_TABLE_FUNCTIONS[ctx.provider];
+  ctx.imports.addImport(tableFn, ctx.importSource);
+
+  const columns = generateAllColumns(ctx, table, customTypes);
+  const constraints = generateTableConstraints(ctx, table);
+
+  const args: string[] = [`"${table.ormName}"`, `{\n${columns.join(",\n")}\n}`];
+
+  if (constraints.length > 0) {
+    args.push(`(table) => [\n${ident(constraints.join(",\n"))}\n]`);
+  }
+
+  return `export const ${table.ormName} = ${tableFn}(${args.join(", ")})`;
+}
+
+// ============================================================================
+// RELATION GENERATION
+// ============================================================================
+
+function generateRelation(ctx: GeneratorContext, table: AnyTable): string | undefined {
+  const relations: string[] = [];
+  let hasOne = false;
+  let hasMany = false;
+
+  for (const relation of Object.values(table.relations)) {
+    const options: string[] = [`relationName: "${relation.id}"`];
+
+    // Track which relation types are used
+    if (relation.type === "one") {
+      hasOne = true;
+    } else if (relation.type === "many") {
+      hasMany = true;
+    }
+
+    // For "one" relations, specify fields and references
+    if (relation.type === "one") {
+      const fields: string[] = [];
+      const references: string[] = [];
+
+      for (const [left, right] of relation.on) {
+        fields.push(`${table.ormName}.${left}`);
+        // Relations reference internal IDs
+        const actualRight = right === "id" ? "_internalId" : right;
+        references.push(`${relation.table.ormName}.${actualRight}`);
+      }
+
+      options.push(`fields: [${fields.join(", ")}]`, `references: [${references.join(", ")}]`);
+    }
+
+    const args: string[] = [relation.table.ormName];
+    if (options.length > 0) {
+      args.push(`{\n${ident(options.join(",\n"))}\n}`);
+    }
+
+    relations.push(ident(`${relation.name}: ${relation.type}(${args.join(", ")})`));
+  }
+
+  if (relations.length === 0) {
+    return undefined;
+  }
+
+  // Only include the relation types that are actually used
+  const params: string[] = [];
+  if (hasOne) {
+    params.push("one");
+  }
+  if (hasMany) {
+    params.push("many");
+  }
+  const relationParams = params.length > 0 ? `{ ${params.join(", ")} }` : "{}";
+
+  ctx.imports.addImport("relations", "drizzle-orm");
+  return `export const ${table.ormName}Relations = relations(${table.ormName}, (${relationParams}) => ({
+${relations.join(",\n")}
+}));`;
+}
+
+// ============================================================================
+// MAIN GENERATION
+// ============================================================================
+
+export interface GenerateSchemaOptions {
+  /** Custom ID generator import configuration */
+  idGeneratorImport?: {
+    /** Function name to import */
+    name: string;
+    /** Module to import from */
+    from: string;
+  };
+}
+
+export function generateSchema(
+  schema: AnySchema,
+  provider: SupportedProvider,
+  options?: GenerateSchemaOptions,
+): string {
+  const ctx = createContext(provider, options?.idGeneratorImport);
+  const customTypes: string[] = [];
+  const tables: string[] = [];
+
+  // Generate tables and collect custom types
+  for (const table of Object.values(schema.tables)) {
+    // Custom types might be generated during column processing
+    const tableCode = generateTable(ctx, table, customTypes);
+    tables.push(tableCode);
+
+    const relationCode = generateRelation(ctx, table);
+    if (relationCode) {
+      tables.push(relationCode);
+    }
+  }
+
+  // Assemble final output
+  const lines: string[] = [ctx.imports.format(), ...customTypes, ...tables];
+  return lines.join("\n\n");
+}

package/src/adapters/drizzle/join-column-utils.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { getOrderedJoinColumns } from "./join-column-utils";
+import { schema, column, idColumn } from "../../schema/create";
+
+describe("getOrderedJoinColumns", () => {
+  const testSchema = schema((s) => {
+    return s
+      .addTable("users", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("email", column("string"))
+          .addColumn("age", column("integer").nullable());
+      })
+      .addTable("posts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("title", column("string"))
+          .addColumn("content", column("string"));
+      });
+  });
+
+  const usersTable = testSchema.tables["users"];
+  const postsTable = testSchema.tables["posts"];
+
+  it("should return all columns when select is true", () => {
+    const columns = getOrderedJoinColumns(usersTable, true);
+
+    // Should include all columns including hidden ones (_internalId, _version)
+    expect(columns).toEqual(["id", "name", "email", "age", "_internalId", "_version"]);
+  });
+
+  it("should return selected columns plus hidden columns when select is array", () => {
+    const columns = getOrderedJoinColumns(usersTable, ["name", "email"]);
+
+    // Selected columns first, then hidden columns
+    expect(columns).toEqual(["name", "email", "_internalId", "_version"]);
+  });
+
+  it("should return only id plus hidden columns when selecting just id", () => {
+    const columns = getOrderedJoinColumns(usersTable, ["id"]);
+
+    expect(columns).toEqual(["id", "_internalId", "_version"]);
+  });
+
+  it("should handle table with no nullable columns", () => {
+    const columns = getOrderedJoinColumns(postsTable, true);
+
+    expect(columns).toEqual(["id", "title", "content", "_internalId", "_version"]);
+  });
+
+  it("should handle selecting specific columns from different table", () => {
+    const columns = getOrderedJoinColumns(postsTable, ["title"]);
+
+    expect(columns).toEqual(["title", "_internalId", "_version"]);
+  });
+
+  it("should deduplicate hidden columns if already selected", () => {
+    // This shouldn't happen in practice, but the function should handle it
+    const columns = getOrderedJoinColumns(usersTable, ["name", "_internalId"]);
+
+    // _internalId should not be duplicated
+    expect(columns).toEqual(["name", "_internalId", "_version"]);
+  });
+
+  it("should maintain column order as defined in table", () => {
+    const columns = getOrderedJoinColumns(usersTable, ["email", "name", "id"]);
+
+    // Even though we select in different order, should follow selected order
+    expect(columns).toEqual(["email", "name", "id", "_internalId", "_version"]);
+  });
+
+  it("should skip unknown column keys", () => {
+    const columns = getOrderedJoinColumns(usersTable, ["name", "unknownColumn", "email"]);
+
+    // Should only include known columns
+    expect(columns).toEqual(["name", "email", "_internalId", "_version"]);
+  });
+});

package/src/adapters/drizzle/join-column-utils.ts

@@ -0,0 +1,39 @@
+import type { AnyTable } from "../../schema/create";
+
+/**
+ * Determine the ordered list of columns for a join selection.
+ *
+ * This logic is shared between the compiler (which builds the SQL)
+ * and the decoder (which maps the result array back to objects).
+ * The order MUST match exactly for the decoder to work correctly.
+ *
+ * @param targetTable - The table being joined
+ * @param select - Selection options (true for all columns, or array of column keys)
+ * @returns Array of column ORM names in the order they appear in the SQL/result
+ */
+export function getOrderedJoinColumns(targetTable: AnyTable, select: true | string[]): string[] {
+  const orderedColumns: string[] = [];
+
+  if (select === true) {
+    // All columns selected - iterate in the order they appear in targetTable.columns
+    for (const col of Object.values(targetTable.columns)) {
+      orderedColumns.push(col.ormName);
+    }
+  } else {
+    // Specific columns selected
+    for (const colKey of select) {
+      const col = targetTable.columns[colKey];
+      if (col) {
+        orderedColumns.push(col.ormName);
+      }
+    }
+    // Add hidden columns at the end (for FragnoId construction)
+    for (const col of Object.values(targetTable.columns)) {
+      if (col && col.isHidden && !orderedColumns.includes(col.ormName)) {
+        orderedColumns.push(col.ormName);
+      }
+    }
+  }
+
+  return orderedColumns;
+}