@fragno-dev/db 0.1.14 → 0.2.0

package/src/adapters/drizzle/drizzle-uow-decoder.ts

@@ -1,218 +0,0 @@
-import type { AnySchema, AnyTable } from "../../schema/create";
-import type { SQLProvider } from "../../shared/providers";
-import type { RetrievalOperation, UOWDecoder } from "../../query/unit-of-work";
-import { decodeResult } from "../../query/result-transform";
-import { getOrderedJoinColumns } from "./join-column-utils";
-import type { DrizzleResult } from "./shared";
-import { createCursorFromRecord, Cursor, type CursorResult } from "../../query/cursor";
-
-/**
- * Join information with nested join support
- */
-interface JoinInfo {
-  relation: { name: string; table: AnyTable };
-  options:
-    | {
-        select: true | string[];
-        join?: JoinInfo[];
-      }
-    | false;
-}
-
-/**
- * Recursively transform join arrays to objects, handling nested joins.
- *
- * Drizzle joins use `json_build_array` where nested join data is appended after the parent's columns.
- * For example, if post has columns [id, title, content, _internalId, _version] and a nested author join,
- * the array will be: [id, title, content, _internalId, _version, authorArray]
- *
- * @param value - The join array from Drizzle
- * @param joinInfo - Join metadata including nested joins
- * @param relationName - Name of the current relation (for prefixing column names)
- * @returns Object with flattened keys (relationName:columnName) for all levels
- */
-function transformJoinArray(
-  value: unknown[],
-  joinInfo: JoinInfo,
-  relationName: string,
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-
-  if (joinInfo.options === false) {
-    return result;
-  }
-
-  const targetTable = joinInfo.relation.table;
-
-  // Get ordered columns using shared utility (must match compiler's column order)
-  const orderedSelectedColumns = getOrderedJoinColumns(targetTable, joinInfo.options.select);
-
-  // Map column values to flattened format: relationName:columnName
-  for (let i = 0; i < orderedSelectedColumns.length && i < value.length; i++) {
-    const columnName = orderedSelectedColumns[i];
-    if (columnName) {
-      result[`${relationName}:${columnName}`] = value[i];
-    }
-  }
-
-  // Handle nested joins - they appear after all columns in the array
-  if (joinInfo.options.join && joinInfo.options.join.length > 0) {
-    let nestedArrayIndex = orderedSelectedColumns.length;
-
-    for (const nestedJoin of joinInfo.options.join) {
-      const nestedRelationName = `${relationName}:${nestedJoin.relation.name}`;
-      const nestedValue = value[nestedArrayIndex];
-
-      if (Array.isArray(nestedValue)) {
-        // Recursively transform nested join
-        const nestedResult = transformJoinArray(nestedValue, nestedJoin, nestedRelationName);
-        Object.assign(result, nestedResult);
-      }
-
-      nestedArrayIndex++;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Drizzle joins using `json_build_array` so the result is a tuple of values that we need to map to
- * the correct columns. This function handles nested joins recursively.
- *
- * @param row - Raw database result row that may contain join arrays
- * @param op - The retrieval operation containing join information
- * @returns Transformed row with join arrays converted to objects
- */
-function transformJoinArraysToObjects(
-  row: Record<string, unknown>,
-  op: {
-    type: string;
-    table: AnyTable;
-    options?: {
-      joins?: JoinInfo[];
-    };
-  },
-  provider: SQLProvider,
-): Record<string, unknown> {
-  // Only process find operations with joins
-  if (op.type !== "find" || !op.options?.joins) {
-    return row;
-  }
-
-  const transformedRow = { ...row };
-
-  for (const join of op.options.joins) {
-    const relationName = join.relation.name;
-    let value = row[relationName];
-
-    // For SQLite, json_array returns a JSON string that needs to be parsed
-    if (provider === "sqlite" && typeof value === "string") {
-      try {
-        value = JSON.parse(value) as unknown;
-      } catch {
-        // If parsing fails, skip this join
-        continue;
-      }
-    }
-
-    // Skip if not an array (join didn't return data)
-    if (!Array.isArray(value)) {
-      continue;
-    }
-
-    // Skip if join options are false (join was disabled)
-    if (join.options === false) {
-      continue;
-    }
-
-    // Get the target table for this relation
-    const relation = op.table.relations[relationName];
-    if (!relation) {
-      continue;
-    }
-
-    // Recursively transform this join and its nested joins
-    const joinResult = transformJoinArray(value, join, relationName);
-    Object.assign(transformedRow, joinResult);
-
-    // Remove the original array property
-    delete transformedRow[relationName];
-  }
-
-  return transformedRow;
-}
-
-export function createDrizzleUOWDecoder(provider: SQLProvider): UOWDecoder<DrizzleResult> {
-  return (rawResults, ops) => {
-    if (rawResults.length !== ops.length) {
-      throw new Error("rawResults and ops must have the same length");
-    }
-
-    return rawResults.map((result, index) => {
-      const op = ops[index] as RetrievalOperation<AnySchema>;
-      if (!op) {
-        throw new Error("op must be defined");
-      }
-
-      // Handle count operations - return the count value directly
-      if (op.type === "count") {
-        if (result.rows.length > 0 && result.rows[0]) {
-          const row = result.rows[0] as Record<string, unknown>;
-          const countValue = row["count"] ?? row["count(*)"];
-
-          if (typeof countValue !== "number") {
-            throw new Error(`Unexpected result for count, received: ${countValue}`);
-          }
-
-          return countValue;
-        }
-        return 0;
-      }
-
-      // Handle find operations - decode each row
-      const decodedRows = result.rows.map((row) => {
-        const transformedRow = transformJoinArraysToObjects(row, op, provider);
-        return decodeResult(transformedRow, op.table, provider);
-      });
-
-      // If cursor generation is requested, wrap in CursorResult
-      if (op.withCursor) {
-        let cursor: Cursor | undefined;
-
-        // Generate cursor from last item if results exist
-        if (decodedRows.length > 0 && op.options.orderByIndex && op.options.pageSize) {
-          const lastItem = decodedRows[decodedRows.length - 1];
-          const indexName = op.options.orderByIndex.indexName;
-
-          // Get index columns
-          let indexColumns;
-          if (indexName === "_primary") {
-            indexColumns = [op.table.getIdColumn()];
-          } else {
-            const index = op.table.indexes[indexName];
-            if (index) {
-              indexColumns = index.columns;
-            }
-          }
-
-          if (indexColumns && lastItem) {
-            cursor = createCursorFromRecord(lastItem as Record<string, unknown>, indexColumns, {
-              indexName: op.options.orderByIndex.indexName,
-              orderDirection: op.options.orderByIndex.direction,
-              pageSize: op.options.pageSize,
-            });
-          }
-        }
-
-        const cursorResult: CursorResult<unknown> = {
-          items: decodedRows,
-          cursor,
-        };
-        return cursorResult;
-      }
-
-      return decodedRows;
-    });
-  };
-}

package/src/adapters/drizzle/drizzle-uow-executor.ts

@@ -1,276 +0,0 @@
-import { SQL, StringChunk, sql, type SQLChunk } from "drizzle-orm";
-import type { CompiledMutation, MutationResult } from "../../query/unit-of-work";
-import type { DBType } from "./shared";
-import type { DrizzleCompiledQuery } from "./drizzle-uow-compiler";
-import type { DrizzleResult } from "./shared";
-import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
-import { SQLiteSyncDialect } from "drizzle-orm/sqlite-core";
-
-type SyncSQLiteDB = BaseSQLiteDatabase<
-  "sync",
-  unknown,
-  Record<string, never>,
-  Record<string, never>
->;
-
-function isSyncSQLite(db: unknown): boolean {
-  return (
-    db instanceof BaseSQLiteDatabase &&
-    "dialect" in db &&
-    (db as { dialect?: unknown }).dialect instanceof SQLiteSyncDialect
-  );
-}
-
-function assertSyncSQLite(db: unknown): asserts db is SyncSQLiteDB {
-  if (!isSyncSQLite(db)) {
-    throw new Error("Expected synchronous SQLite database (better-sqlite3)");
-  }
-}
-
-function postgresToSQL(sqlString: string, params: unknown[]): SQLChunk[] {
-  const placeholderRegex = /\$(\d+)/g;
-  const queryChunks: SQLChunk[] = [];
-  let lastIndex = 0;
-  let match: RegExpExecArray | null;
-
-  while ((match = placeholderRegex.exec(sqlString)) !== null) {
-    const textBefore = sqlString.substring(lastIndex, match.index);
-    if (textBefore) {
-      queryChunks.push(new StringChunk(textBefore));
-    }
-
-    const paramIndex = parseInt(match[1]!, 10) - 1;
-    queryChunks.push(sql.param(params[paramIndex]));
-
-    lastIndex = match.index + match[0].length;
-  }
-
-  const textAfter = sqlString.substring(lastIndex);
-  if (textAfter) {
-    queryChunks.push(new StringChunk(textAfter));
-  }
-
-  return queryChunks;
-}
-
-function sqliteToSQL(sqlString: string, params: unknown[]): SQLChunk[] {
-  const chunks: SQLChunk[] = [];
-  let currentIndex = 0;
-
-  const parts = sqlString.split("?");
-  for (let i = 0; i < parts.length; i++) {
-    if (parts[i]) {
-      chunks.push(new StringChunk(parts[i]));
-    }
-    if (i < parts.length - 1 && currentIndex < params.length) {
-      chunks.push(sql.param(params[currentIndex++]));
-    }
-  }
-
-  return chunks;
-}
-
-function toSQL(query: DrizzleCompiledQuery, provider: "sqlite" | "mysql" | "postgresql"): SQL {
-  const { sql: sqlString, params } = query;
-
-  const queryChunks =
-    provider === "sqlite" ? sqliteToSQL(sqlString, params) : postgresToSQL(sqlString, params);
-
-  return new SQL(queryChunks);
-}
-
-function getAffectedRows(result: unknown): number {
-  if (Array.isArray(result)) {
-    return result.length;
-  }
-
-  if (result && typeof result === "object") {
-    // libsql uses rowsAffected
-    if ("rowsAffected" in result && typeof result["rowsAffected"] === "number") {
-      return result["rowsAffected"];
-    }
-
-    if ("affectedRows" in result && typeof result["affectedRows"] === "number") {
-      return result["affectedRows"];
-    }
-
-    if (
-      "rowCount" in result &&
-      (typeof result["rowCount"] === "number" || typeof result["rowCount"] === "bigint")
-    ) {
-      const rowCount = result["rowCount"];
-      if (rowCount > Number.MAX_SAFE_INTEGER) {
-        throw new Error(
-          `rowCount BigInt value ${rowCount.toString()} exceeds JS safe integer range`,
-        );
-      }
-      return Number(rowCount);
-    }
-
-    if ("changes" in result && typeof result["changes"] === "number") {
-      return result["changes"];
-    }
-  }
-
-  throw new Error(`Unable to determine affected rows from result: ${JSON.stringify(result)}`);
-}
-
-async function executeInTransaction(
-  db: DBType,
-  provider: "sqlite" | "mysql" | "postgresql",
-  syncExecutor: (db: SyncSQLiteDB) => void,
-  asyncExecutor: (tx: {
-    execute?: (sql: SQL) => Promise<unknown>;
-    run?: (sql: SQL) => Promise<unknown>;
-  }) => Promise<void>,
-): Promise<void> {
-  if (provider === "sqlite" && isSyncSQLite(db)) {
-    assertSyncSQLite(db);
-    db.transaction(() => syncExecutor(db));
-  } else {
-    await db.transaction(
-      async (tx) =>
-        await asyncExecutor(
-          tx as { execute?: (sql: SQL) => Promise<unknown>; run?: (sql: SQL) => Promise<unknown> },
-        ),
-    );
-  }
-}
-
-function extractCreatedInternalId(result: unknown): bigint | null {
-  if (result && typeof result === "object" && "lastInsertRowid" in result) {
-    if (typeof result.lastInsertRowid === "bigint") {
-      return result.lastInsertRowid;
-    }
-
-    if (typeof result.lastInsertRowid === "number") {
-      return BigInt(result.lastInsertRowid);
-    }
-
-    throw new Error(`Unexpected lastInsertRowid type: ${typeof result.lastInsertRowid}`);
-  }
-
-  if (Array.isArray(result) && result.length > 0) {
-    const row = result[0] as Record<string, unknown>;
-    if ("_internalId" in row || "_internal_id" in row) {
-      return (row["_internalId"] ?? row["_internal_id"]) as bigint;
-    }
-  }
-
-  return null;
-}
-
-function validateAffectedRows(result: unknown, expected: number): void {
-  const actual = getAffectedRows(result);
-  if (actual !== expected) {
-    throw new Error(`Version conflict: expected ${expected} rows affected, but got ${actual}`);
-  }
-}
-
-/**
- * Execute the retrieval phase of a Unit of Work using Drizzle
- *
- * All retrieval queries are executed inside a single transaction to ensure
- * snapshot isolation - all reads see a consistent view of the database.
- */
-export async function executeDrizzleRetrievalPhase(
-  db: DBType,
-  retrievalBatch: DrizzleCompiledQuery[],
-  provider: "sqlite" | "mysql" | "postgresql",
-): Promise<DrizzleResult[]> {
-  if (retrievalBatch.length === 0) {
-    return [];
-  }
-
-  const retrievalResults: DrizzleResult[] = [];
-
-  await executeInTransaction(
-    db,
-    provider,
-    (syncDb) => {
-      for (const query of retrievalBatch) {
-        const sqlObj = toSQL(query, provider);
-        const rows = syncDb.all(sqlObj as never) as Record<string, unknown>[];
-        const result: DrizzleResult = { rows, affectedRows: 0 };
-        retrievalResults.push(result);
-      }
-    },
-    async (tx) => {
-      for (const query of retrievalBatch) {
-        const sqlObj = toSQL(query, provider);
-        // Fallback to run when execute is not available (e.g., libsql)
-        const executeMethod = tx.execute ?? tx.run;
-        if (!executeMethod) {
-          throw new Error("Transaction object has neither execute nor run method");
-        }
-        const result = (await executeMethod.call(tx, sqlObj)) as DrizzleResult;
-        retrievalResults.push(result);
-      }
-    },
-  );
-
-  return retrievalResults;
-}
-
-/**
- * Execute the mutation phase of a Unit of Work using Drizzle
- *
- * All mutation queries are executed in a transaction with optimistic locking.
- * If any version check fails, the entire transaction is rolled back and
- * success=false is returned.
- */
-export async function executeDrizzleMutationPhase(
-  db: DBType,
-  mutationBatch: CompiledMutation<DrizzleCompiledQuery>[],
-  provider: "sqlite" | "mysql" | "postgresql",
-): Promise<MutationResult> {
-  if (mutationBatch.length === 0) {
-    return { success: true, createdInternalIds: [] };
-  }
-
-  const createdInternalIds: (bigint | null)[] = [];
-
-  try {
-    await executeInTransaction(
-      db,
-      provider,
-      (syncDb) => {
-        for (const { query, expectedAffectedRows } of mutationBatch) {
-          const sqlObj = toSQL(query, provider);
-          // Type assertion needed due to drizzle-orm version mismatch in dependencies
-          const result = syncDb.run(sqlObj as never);
-
-          if (expectedAffectedRows === null) {
-            createdInternalIds.push(extractCreatedInternalId(result));
-          } else {
-            validateAffectedRows(result, expectedAffectedRows);
-          }
-        }
-      },
-      async (tx) => {
-        for (const { query, expectedAffectedRows } of mutationBatch) {
-          const sqlObj = toSQL(query, provider);
-          // Fallback to run when execute is not available (e.g., libsql)
-          const executeMethod = tx.execute ?? tx.run;
-          if (!executeMethod) {
-            throw new Error("Transaction object has neither execute nor run method");
-          }
-          const result = await executeMethod.call(tx, sqlObj);
-
-          if (expectedAffectedRows === null) {
-            createdInternalIds.push(extractCreatedInternalId(result));
-          } else {
-            validateAffectedRows(result, expectedAffectedRows);
-          }
-        }
-      },
-    );
-
-    return { success: true, createdInternalIds };
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Version conflict")) {
-      return { success: false };
-    }
-    throw error;
-  }
-}

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

@@ -1,79 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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;
-}

package/src/adapters/kysely/kysely-connection-pool.ts

@@ -1,70 +0,0 @@
-import type { Kysely } from "kysely";
-import type { ConnectionPool } from "../../shared/connection-pool";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type KyselyAny = Kysely<any>;
-
-/**
- * Creates a Kysely-specific connection pool with proper cleanup.
- * Calls db.destroy() when the pool is closed to properly release database connections.
- */
-export function createKyselyConnectionPool(
-  dbOrFactory: KyselyAny | (() => KyselyAny | Promise<KyselyAny>),
-): ConnectionPool<KyselyAny> {
-  let cachedDb: KyselyAny | undefined;
-  let initPromise: Promise<KyselyAny> | undefined;
-
-  const ensureInitialized = async (): Promise<KyselyAny> => {
-    if (cachedDb) {
-      return cachedDb;
-    }
-
-    if (!initPromise) {
-      initPromise = (async () => {
-        const db =
-          typeof dbOrFactory === "function"
-            ? await (dbOrFactory as () => KyselyAny | Promise<KyselyAny>)()
-            : dbOrFactory;
-        cachedDb = db;
-        return db;
-      })();
-    }
-
-    return initPromise;
-  };
-
-  // Eagerly start initialization if it's a factory function
-  if (typeof dbOrFactory === "function") {
-    void ensureInitialized();
-  } else {
-    // Direct instance - cache it immediately
-    cachedDb = dbOrFactory;
-  }
-
-  return {
-    async connect() {
-      const db = await ensureInitialized();
-
-      return {
-        db,
-        release: async () => {},
-      };
-    },
-
-    getDatabaseSync() {
-      if (!cachedDb) {
-        throw new Error("Cannot get database synchronously: database not initialized.");
-      }
-      return cachedDb;
-    },
-
-    async close() {
-      if (cachedDb) {
-        // Properly destroy Kysely instance to close all connections
-        await cachedDb.destroy();
-      }
-      cachedDb = undefined;
-      initPromise = undefined;
-    },
-  };
-}