@fragno-dev/db 0.1.15 → 0.2.0

package/src/adapters/kysely/migration/kysely-migrator.test.ts

@@ -1,261 +0,0 @@
-import { Kysely, PostgresDialect, SqliteDialect } from "kysely";
-import { describe, expect, beforeAll, test } from "vitest";
-import { KyselyAdapter } from "../kysely-adapter";
-import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
-
-describe("KyselyMigrator", () => {
-  const testSchema = schema((s) => {
-    return s
-      .addTable("users", (t) => {
-        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
-      })
-      .alterTable("users", (t) => {
-        return t
-          .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"])
-          .createIndex("age_idx", ["age"]);
-      })
-      .addTable("posts", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("title", column("string"))
-          .addColumn("user_id", column("string"));
-      })
-      .addReference("author", {
-        type: "one",
-        from: { table: "posts", column: "user_id" },
-        to: { table: "users", column: "id" },
-      });
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let db: Kysely<any>;
-  let adapter: KyselyAdapter;
-
-  beforeAll(async () => {
-    // Create a Kysely instance with a PostgresDialect, but not actually connected to a database
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    db = new Kysely({ dialect: new PostgresDialect({} as any) });
-    adapter = new KyselyAdapter({ db, provider: "postgresql" });
-  });
-
-  test("generate SQL for migration 0 -> 1 (create users table)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(1, {
-      updateSettings: true,
-      fromVersion: 0,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toMatchInlineSnapshot(`
-      "create table "users_test_namespace" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
-
-      insert into "fragno_db_settings" ("id", "key", "value") values ('jprP_43K5uMwxAFiepbbrQ', 'test_namespace.schema_version', '1');"
-    `);
-  });
-
-  test("generate SQL for migration 0 -> 2 (create users table and add age)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(2, {
-      updateSettings: true,
-      fromVersion: 0,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toMatchInlineSnapshot(`
-      "create table "users_test_namespace" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
-
-      alter table "users_test_namespace" add column "age" integer;
-
-      create index "name_idx" on "users_test_namespace" ("name");
-
-      create index "age_idx" on "users_test_namespace" ("age");
-
-      insert into "fragno_db_settings" ("id", "key", "value") values ('jprP_43K5uMwxAFiepbbrQ', 'test_namespace.schema_version', '2');"
-    `);
-  });
-
-  test("generate SQL for migration 1 -> 2 (add age column and indexes)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(2, {
-      updateSettings: true,
-      fromVersion: 1,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toMatchInlineSnapshot(`
-      "alter table "users_test_namespace" add column "age" integer;
-
-      create index "name_idx" on "users_test_namespace" ("name");
-
-      create index "age_idx" on "users_test_namespace" ("age");
-
-      update "fragno_db_settings" set "value" = '2' where "key" = 'test_namespace.schema_version';"
-    `);
-  });
-
-  test("generate SQL for migration 0 -> 3 (full schema)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(3, {
-      updateSettings: true,
-      fromVersion: 0,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toMatchInlineSnapshot(`
-      "create table "users_test_namespace" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
-
-      alter table "users_test_namespace" add column "age" integer;
-
-      create index "name_idx" on "users_test_namespace" ("name");
-
-      create index "age_idx" on "users_test_namespace" ("age");
-
-      create table "posts_test_namespace" ("id" varchar(30) not null unique, "title" text not null, "user_id" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
-
-      insert into "fragno_db_settings" ("id", "key", "value") values ('jprP_43K5uMwxAFiepbbrQ', 'test_namespace.schema_version', '3');"
-    `);
-  });
-
-  test("generate SQL for migration 2 -> 3 (add posts table)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(3, {
-      updateSettings: true,
-      fromVersion: 2,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toMatchInlineSnapshot(`
-      "create table "posts_test_namespace" ("id" varchar(30) not null unique, "title" text not null, "user_id" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
-
-      update "fragno_db_settings" set "value" = '3' where "key" = 'test_namespace.schema_version';"
-    `);
-  });
-
-  test("generate empty SQL for migration 2 -> 2 (no changes)", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-    const preparedMigration = await migrator.prepareMigrationTo(2, {
-      updateSettings: true,
-      fromVersion: 2,
-    });
-
-    expect(preparedMigration.operations.length).toBe(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-    expect(sql).toBe("");
-  });
-
-  test("throw error for backward migration", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-
-    await expect(
-      migrator.prepareMigrationTo(1, {
-        updateSettings: true,
-        fromVersion: 2,
-      }),
-    ).rejects.toThrow("Cannot migrate backwards");
-  });
-
-  test("throw error for version beyond schema", async () => {
-    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
-
-    await expect(
-      migrator.prepareMigrationTo(10, {
-        updateSettings: true,
-        fromVersion: 0,
-      }),
-    ).rejects.toThrow("schema only has version 4");
-  });
-});
-
-describe("KyselyMigrator - SQLite Foreign Key Merging", () => {
-  // Test the user's exact example schema
-  const userExampleSchema = schema((s) => {
-    return s
-      .addTable("users", (t) => {
-        return t.addColumn("id", idColumn());
-      })
-      .addTable("posts", (t) => {
-        return t.addColumn("id", idColumn()).addColumn("authorId", referenceColumn());
-      })
-      .addReference("author", {
-        type: "one",
-        from: { table: "posts", column: "authorId" },
-        to: { table: "users", column: "id" },
-      });
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let db: Kysely<any>;
-  let adapter: KyselyAdapter;
-
-  beforeAll(async () => {
-    // Create a Kysely instance with SQLite dialect
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    db = new Kysely({ dialect: new SqliteDialect({} as any) });
-    adapter = new KyselyAdapter({ db, provider: "sqlite" });
-  });
-
-  test("SQLite should merge foreign keys into create-table operations", async () => {
-    const migrator = adapter.createMigrationEngine(userExampleSchema, "test");
-
-    // Migrate from 0 -> 3 (all tables + FK in one batch)
-    const preparedMigration = await migrator.prepareMigrationTo(3, {
-      updateSettings: true,
-      fromVersion: 0,
-    });
-
-    expect(preparedMigration.operations.length).toBeGreaterThan(0);
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-
-    // The SQL should have PRAGMA defer_foreign_keys
-    expect(sql).toContain("PRAGMA defer_foreign_keys = ON");
-
-    // Should create users table
-    expect(sql).toContain('create table "users_test"');
-
-    // Should create posts table WITH inline foreign key constraint
-    expect(sql).toContain('create table "posts_test"');
-    expect(sql).toContain("foreign key");
-    expect(sql).toContain("authorId");
-    expect(sql).toContain('references "users_test"');
-
-    // Should NOT have a separate ALTER TABLE ADD FOREIGN KEY
-    // (SQLite doesn't support it, and we've merged it into create-table)
-    expect(sql).not.toMatch(/alter table.*add.*foreign key/i);
-  });
-
-  test("SQLite FK merging full schema verification", async () => {
-    const migrator = adapter.createMigrationEngine(userExampleSchema, "test");
-
-    const preparedMigration = await migrator.prepareMigrationTo(3, {
-      updateSettings: true,
-      fromVersion: 0,
-    });
-
-    const sql = preparedMigration.getSQL?.();
-    expect(sql).toBeDefined();
-
-    // Verify the complete SQL snapshot
-    expect(sql).toMatchInlineSnapshot(`
-      "PRAGMA defer_foreign_keys = ON;
-
-      create table "users_test" ("id" text not null unique, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null);
-
-      create table "posts_test" ("id" text not null unique, "authorId" integer not null, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null, constraint "posts_users_author_fk" foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict);
-
-      insert into "fragno_db_settings" ("id", "key", "value") values ('BflimUWc1NbCMMDD9SM3gQ', 'test.schema_version', '3');"
-    `);
-  });
-});

package/src/query/result-transform.ts

@@ -1,274 +0,0 @@
-import type { AnyColumn, AnyTable } from "../schema/create";
-import type { SQLProvider } from "../shared/providers";
-import { deserialize, serialize } from "../schema/serialize";
-import { FragnoId, FragnoReference } from "../schema/create";
-import { createId } from "../id";
-
-/**
- * Marker class for reference column values that need subquery resolution.
- * When a reference column receives a string (external ID), this marker tells
- * the query builder to generate a subquery to look up the internal ID.
- * @internal
- */
-export class ReferenceSubquery {
-  #referencedTable: AnyTable;
-  #externalIdValue: string;
-
-  constructor(referencedTable: AnyTable, externalIdValue: string) {
-    this.#referencedTable = referencedTable;
-    this.#externalIdValue = externalIdValue;
-  }
-
-  get referencedTable() {
-    return this.#referencedTable;
-  }
-
-  get externalIdValue() {
-    return this.#externalIdValue;
-  }
-}
-
-/**
- * Generate a runtime default value for a column that has defaultTo$()
- *
- * Only generates values for runtime defaults (defaultTo$), NOT static defaults (defaultTo).
- * Static defaults should be handled by the database via DEFAULT constraints.
- *
- * @param column - The column with a default value configuration
- * @returns The generated default value, or undefined if the column has no runtime default
- *
- * @internal
- */
-export function generateRuntimeDefault(column: AnyColumn): unknown {
-  // Check if column has a default value configuration
-  if (!column.default) {
-    return undefined;
-  }
-
-  // If it's a static default value (defaultTo), return undefined
-  // as the database should handle this via DEFAULT constraint
-  if ("value" in column.default) {
-    return undefined;
-  }
-
-  // If it's a database-level special function (defaultTo(b => b.now())), return undefined
-  // as the database should handle this via DEFAULT NOW() or equivalent
-  if ("dbSpecial" in column.default) {
-    return undefined;
-  }
-
-  // Handle runtime defaults (defaultTo$)
-  const runtime = column.default.runtime;
-
-  if (runtime === "cuid") {
-    return createId();
-  }
-
-  if (runtime === "now") {
-    return new Date();
-  }
-
-  if (typeof runtime === "function") {
-    return runtime();
-  }
-
-  return undefined;
-}
-
-/**
- * Encodes a record of values from the application format to database format.
- *
- * This function transforms object keys to match SQL column names and serializes
- * values according to the database provider's requirements (e.g., converting
- * JavaScript Date objects to numbers for SQLite).
- *
- * @param values - The record of values to encode in application format
- * @param table - The table schema definition containing column information
- * @param generateDefault - Whether to generate default values for undefined columns
- * @param provider - The SQL provider (sqlite, postgresql, mysql, etc.)
- * @param skipDriverConversions - Skip driver-level type conversions (Date->number, boolean->0/1, bigint->Buffer).
- *                                 Set to true when using ORMs like Drizzle that handle these conversions internally.
- * @returns A record with database-compatible column names and serialized values
- *
- * @example
- * ```ts
- * const encoded = encodeValues(
- *   { userId: 123, createdAt: new Date() },
- *   userTable,
- *   true,
- *   'sqlite'
- * );
- * // Returns: { user_id: 123, created_at: 1234567890 }
- * ```
- */
-export function encodeValues(
-  values: Record<string, unknown>,
-  table: AnyTable,
-  generateDefault: boolean,
-  provider: SQLProvider,
-  skipDriverConversions = false,
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-
-  for (const k in table.columns) {
-    const col = table.columns[k];
-
-    // Skip internal ID - never provided by user, auto-generated by database
-    if (col.role === "internal-id") {
-      continue;
-    }
-    let value = values[k];
-
-    if (generateDefault && value === undefined) {
-      // Only generate runtime defaults (defaultTo$), not static defaults (defaultTo).
-      // Static defaults should be handled by the database via DEFAULT constraints.
-      value = generateRuntimeDefault(col);
-    }
-
-    if (value !== undefined) {
-      // Handle string references and FragnoId objects
-      if (col.role === "reference") {
-        if (typeof value === "string") {
-          // String external ID - generate subquery
-          const relation = Object.values(table.relations).find((rel) =>
-            rel.on.some(([localCol]) => localCol === k),
-          );
-          if (relation) {
-            result[col.name] = new ReferenceSubquery(relation.table, value);
-            continue;
-          }
-          throw new Error(`Reference column ${k} not found in table ${table.name}`);
-        } else if (value instanceof FragnoId) {
-          // FragnoId object
-          if (value.internalId !== undefined) {
-            // If internal ID is populated, use it directly (no subquery needed)
-            result[col.name] = value.internalId;
-            continue;
-          } else {
-            // If internal ID is not populated, use external ID via subquery
-            const relation = Object.values(table.relations).find((rel) =>
-              rel.on.some(([localCol]) => localCol === k),
-            );
-            if (relation) {
-              result[col.name] = new ReferenceSubquery(relation.table, value.externalId);
-              continue;
-            }
-            throw new Error(`Reference column ${k} not found in table ${table.name}`);
-          }
-        }
-      }
-
-      result[col.name] = serialize(value, col, provider, skipDriverConversions);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Decodes a database result record to application format.
- *
- * This function transforms database column names back to application property names
- * and deserializes values according to the database provider's format (e.g., converting
- * SQLite integers back to JavaScript Date objects).
- *
- * Supports relation data encoded with the pattern `relationName:columnName`.
- *
- * @param result - The raw database result record
- * @param table - The table schema definition containing column and relation information
- * @param provider - The SQL provider (sqlite, postgresql, mysql, etc.)
- * @returns A record in application format with deserialized values
- *
- * @example
- * ```ts
- * const decoded = decodeResult(
- *   { user_id: 123, created_at: 1234567890, 'posts:title': 'Hello' },
- *   userTable,
- *   'sqlite'
- * );
- * // Returns: { userId: 123, createdAt: Date, posts: { title: 'Hello' } }
- * ```
- */
-export function decodeResult(
-  result: Record<string, unknown>,
-  table: AnyTable,
-  provider: SQLProvider,
-): Record<string, unknown> {
-  const output: Record<string, unknown> = {};
-  // First pass: collect all column values
-  const columnValues: Record<string, unknown> = {};
-
-  // Collect all relation data (including nested) keyed by relation name
-  const relationData: Record<string, Record<string, unknown>> = {};
-
-  for (const k in result) {
-    const colonIndex = k.indexOf(":");
-    const value = result[k];
-
-    // Direct column (no colon)
-    if (colonIndex === -1) {
-      const col = table.columns[k];
-      if (!col) {
-        continue;
-      }
-
-      // Store all column values (including hidden ones for FragnoId creation)
-      columnValues[k] = deserialize(value, col, provider);
-      continue;
-    }
-
-    // Relation column (has colon)
-    const relationName = k.slice(0, colonIndex);
-    const remainder = k.slice(colonIndex + 1);
-
-    const relation = table.relations[relationName];
-    if (relation === undefined) {
-      continue;
-    }
-
-    // Collect relation data with the remaining key path
-    relationData[relationName] ??= {};
-    relationData[relationName][remainder] = value;
-  }
-
-  // Process each relation's data recursively
-  for (const relationName in relationData) {
-    const relation = table.relations[relationName];
-    if (!relation) {
-      continue;
-    }
-
-    // Recursively decode the relation data
-    output[relationName] = decodeResult(relationData[relationName], relation.table, provider);
-  }
-
-  // Second pass: create output with FragnoId objects where appropriate
-  for (const k in columnValues) {
-    const col = table.columns[k];
-    if (!col) {
-      continue;
-    }
-
-    // Filter out hidden columns (like _internalId, _version) from results
-    if (col.isHidden) {
-      continue;
-    }
-
-    // For external ID columns, create FragnoId if we have both external and internal IDs
-    if (col.role === "external-id" && columnValues["_internalId"] !== undefined) {
-      output[k] = new FragnoId({
-        externalId: columnValues[k] as string,
-        internalId: columnValues["_internalId"] as bigint,
-        // _version is always selected as a hidden column, so it should always be present
-        version: columnValues["_version"] as number,
-      });
-    } else if (col.role === "reference") {
-      // For reference columns, create FragnoReference with internal ID
-      output[k] = FragnoReference.fromInternal(columnValues[k] as bigint);
-    } else {
-      output[k] = columnValues[k];
-    }
-  }
-
-  return output;
-}