@fragno-dev/db 0.1.11 → 0.1.12

package/src/adapters/drizzle/drizzle-query.ts

@@ -1,12 +1,13 @@
 import type { AbstractQuery } from "../../query/query";
-import type { AnySchema } from "../../schema/create";
-import type { CompiledMutation, UOWExecutor } from "../../query/unit-of-work";
+import type { AnySchema, AnyTable } from "../../schema/create";
+import type { CompiledMutation, UOWExecutor, ValidIndexName } from "../../query/unit-of-work";
 import { createDrizzleUOWCompiler, type DrizzleCompiledQuery } from "./drizzle-uow-compiler";
 import { executeDrizzleRetrievalPhase, executeDrizzleMutationPhase } from "./drizzle-uow-executor";
 import { UnitOfWork } from "../../query/unit-of-work";
 import { parseDrizzle, type DrizzleResult, type TableNameMapper, type DBType } from "./shared";
 import { createDrizzleUOWDecoder } from "./drizzle-uow-decoder";
 import type { ConnectionPool } from "../../shared/connection-pool";
+import type { TableToUpdateValues } from "../../query/query";
 
 /**
  * Configuration options for creating a Drizzle Unit of Work
@@ -24,6 +25,37 @@ export interface DrizzleUOWConfig {
   dryRun?: boolean;
 }
 
+/**
+ * Special builder for updateMany operations that captures configuration
+ */
+class UpdateManySpecialBuilder<TTable extends AnyTable> {
+  #indexName?: string;
+  #condition?: unknown;
+  #setValues?: TableToUpdateValues<TTable>;
+
+  whereIndex<TIndexName extends ValidIndexName<TTable>>(
+    indexName: TIndexName,
+    condition?: unknown,
+  ): this {
+    this.#indexName = indexName as string;
+    this.#condition = condition;
+    return this;
+  }
+
+  set(values: TableToUpdateValues<TTable>): this {
+    this.#setValues = values;
+    return this;
+  }
+
+  getConfig() {
+    return {
+      indexName: this.#indexName,
+      condition: this.#condition,
+      setValues: this.#setValues,
+    };
+  }
+}
+
 /**
  * Creates a Drizzle-based query engine for the given schema.
  *
@@ -114,7 +146,9 @@ export function fromDrizzle<T extends AnySchema>(
 
   return {
     async find(tableName, builderFn) {
-      const uow = createUOW({ config: uowConfig }).find(tableName, builderFn);
+      // Safe: builderFn returns a FindBuilder (or void), which matches UnitOfWork signature
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const uow = createUOW({ config: uowConfig }).find(tableName, builderFn as any);
       const [result] = await uow.executeRetrieve();
       return result;
     },
@@ -122,7 +156,10 @@ export function fromDrizzle<T extends AnySchema>(
     async findFirst(tableName, builderFn) {
       const uow = createUOW({ config: uowConfig });
       if (builderFn) {
-        uow.find(tableName, (b) => builderFn(b as never).pageSize(1));
+        uow.find(tableName, (b) => {
+          builderFn(b);
+          return b.pageSize(1);
+        });
       } else {
         uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
       }
@@ -133,7 +170,7 @@ export function fromDrizzle<T extends AnySchema>(
 
     async create(tableName, values) {
       const uow = createUOW({ config: uowConfig });
-      uow.create(tableName as string, values as never);
+      uow.create(tableName, values);
       const { success } = await uow.executeMutations();
       if (!success) {
         throw new Error("Failed to create record");
@@ -150,7 +187,7 @@ export function fromDrizzle<T extends AnySchema>(
     async createMany(tableName, valuesArray) {
       const uow = createUOW({ config: uowConfig });
       for (const values of valuesArray) {
-        uow.create(tableName as string, values as never);
+        uow.create(tableName, values);
       }
       const { success } = await uow.executeMutations();
       if (!success) {
@@ -162,7 +199,7 @@ export function fromDrizzle<T extends AnySchema>(
 
     async update(tableName, id, builderFn) {
       const uow = createUOW({ config: uowConfig });
-      uow.update(tableName as string, id, builderFn as never);
+      uow.update(tableName, id, builderFn);
       const { success } = await uow.executeMutations();
       if (!success) {
         throw new Error("Failed to update record (version conflict or record not found)");
@@ -170,25 +207,17 @@ export function fromDrizzle<T extends AnySchema>(
     },
 
     async updateMany(tableName, builderFn) {
-      // FIXME: This is not correct
-
-      let whereConfig: { indexName?: string; condition?: unknown } = {};
-      let setValues: unknown;
-
-      const specialBuilder = {
-        whereIndex(indexName: string, condition?: unknown) {
-          whereConfig = { indexName, condition };
-          return this;
-        },
-        set(values: unknown) {
-          setValues = values;
-          return this;
-        },
-      };
+      const table = schema.tables[tableName];
+      if (!table) {
+        throw new Error(`Table ${tableName} not found in schema`);
+      }
 
+      const specialBuilder = new UpdateManySpecialBuilder<typeof table>();
       builderFn(specialBuilder);
 
-      if (!whereConfig.indexName) {
+      const { indexName, condition, setValues } = specialBuilder.getConfig();
+
+      if (!indexName) {
         throw new Error("whereIndex() must be called in updateMany");
       }
       if (!setValues) {
@@ -197,24 +226,22 @@ export function fromDrizzle<T extends AnySchema>(
 
       const findUow = createUOW({ config: uowConfig });
       findUow.find(tableName, (b) => {
-        if (whereConfig.condition) {
-          return b.whereIndex(whereConfig.indexName as never, whereConfig.condition as never);
+        if (condition) {
+          // Safe: condition is captured from whereIndex call with proper typing
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return b.whereIndex(indexName as ValidIndexName<typeof table>, condition as any);
         }
-        return b.whereIndex(whereConfig.indexName as never);
+        return b.whereIndex(indexName as ValidIndexName<typeof table>);
       });
-      const findResults = await findUow.executeRetrieve();
-      const records = (findResults as unknown as [unknown])[0];
+      const [records]: unknown[][] = await findUow.executeRetrieve();
 
-      // @ts-expect-error - Type narrowing doesn't work through unknown cast
       if (!records || records.length === 0) {
         return;
       }
 
       const updateUow = createUOW({ config: uowConfig });
-      for (const record of records as never as Array<{ id: unknown }>) {
-        updateUow.update(tableName as string, record.id as string, (b) =>
-          b.set(setValues as never),
-        );
+      for (const record of records as Array<{ id: unknown }>) {
+        updateUow.update(tableName, record.id as string, (b) => b.set(setValues));
       }
       const { success } = await updateUow.executeMutations();
       if (!success) {
@@ -224,7 +251,7 @@ export function fromDrizzle<T extends AnySchema>(
 
     async delete(tableName, id, builderFn) {
       const uow = createUOW({ config: uowConfig });
-      uow.delete(tableName as string, id, builderFn as never);
+      uow.delete(tableName, id, builderFn);
       const { success } = await uow.executeMutations();
       if (!success) {
         throw new Error("Failed to delete record (version conflict or record not found)");
@@ -232,39 +259,17 @@ export function fromDrizzle<T extends AnySchema>(
     },
 
     async deleteMany(tableName, builderFn) {
-      let whereConfig: { indexName?: string; condition?: unknown } = {};
-
-      const specialBuilder = {
-        whereIndex(indexName: string, condition?: unknown) {
-          whereConfig = { indexName, condition };
-          return this;
-        },
-      };
-
-      builderFn(specialBuilder as never);
-
-      if (!whereConfig.indexName) {
-        throw new Error("whereIndex() must be called in deleteMany");
-      }
-
       const findUow = createUOW({ config: uowConfig });
-      findUow.find(tableName as string, (b) => {
-        if (whereConfig.condition) {
-          return b.whereIndex(whereConfig.indexName as never, whereConfig.condition as never);
-        }
-        return b.whereIndex(whereConfig.indexName as never);
-      });
-      const findResults2 = await findUow.executeRetrieve();
-      const records = (findResults2 as unknown as [unknown])[0];
+      findUow.find(tableName, builderFn);
+      const [records]: unknown[][] = await findUow.executeRetrieve();
 
-      // @ts-expect-error - Type narrowing doesn't work through unknown cast
       if (!records || records.length === 0) {
         return;
       }
 
       const deleteUow = createUOW({ config: uowConfig });
-      for (const record of records as never as Array<{ id: unknown }>) {
-        deleteUow.delete(tableName as string, record.id as string);
+      for (const record of records as Array<{ id: unknown }>) {
+        deleteUow.delete(tableName, record.id as string);
       }
       const { success } = await deleteUow.executeMutations();
       if (!success) {

package/src/adapters/drizzle/drizzle-uow-compiler.test.ts

@@ -457,10 +457,9 @@ describe("drizzle-uow-compiler", () => {
       const [batch] = compiled.mutationBatch;
       assert(batch);
       expect(batch.expectedAffectedRows).toBeNull();
-      // FragnoId should use internal ID directly (no subquery needed if available)
-      // But since we don't have the internal ID populated in the test, it should serialize
+      // FragnoId should generate a subquery to lookup the internal ID from external ID
       expect(batch.query.sql).toMatchInlineSnapshot(
-        `"insert into "posts" ("id", "title", "content", "userId", "viewCount", "_internalId", "_version") values ($1, $2, $3, $4, default, default, default)"`,
+        `"insert into "posts" ("id", "title", "content", "userId", "viewCount", "_internalId", "_version") values ($1, $2, $3, (select "_internalId" from "users" where "id" = $4 limit 1), default, default, default)"`,
       );
     });
 
@@ -1303,5 +1302,66 @@ describe("drizzle-uow-compiler", () => {
       );
       expect(compiled.retrievalBatch[0].params).toEqual([1, sessionId]);
     });
+
+    it("should support creating and using ID in same UOW", () => {
+      const uow = createAuthUOW("create-user-and-session");
+
+      // Create user and capture the returned ID
+      const userId = uow.create("user", {
+        email: "test@example.com",
+        passwordHash: "hashed_password",
+      });
+
+      // Use the returned FragnoId directly to create a session
+      // The compiler should extract externalId and generate a subquery
+      uow.create("session", {
+        userId: userId,
+        expiresAt: new Date("2025-12-31"),
+      });
+
+      const compiler = createDrizzleUOWCompiler(authSchema, authPool, "postgresql");
+      const compiled = uow.compile(compiler);
+
+      // Should have no retrieval operations
+      expect(compiled.retrievalBatch).toHaveLength(0);
+
+      // Should have 2 mutation operations (create user, create session)
+      expect(compiled.mutationBatch).toHaveLength(2);
+
+      const [userCreate, sessionCreate] = compiled.mutationBatch;
+      assert(userCreate);
+      assert(sessionCreate);
+
+      // Verify user create SQL
+      expect(userCreate.query.sql).toMatchInlineSnapshot(
+        `"insert into "user" ("id", "email", "passwordHash", "createdAt", "_internalId", "_version") values ($1, $2, $3, $4, default, default)"`,
+      );
+      expect(userCreate.query.params).toMatchObject([
+        userId.externalId, // The generated ID
+        "test@example.com",
+        "hashed_password",
+        expect.any(String), // timestamp
+      ]);
+      expect(userCreate.expectedAffectedRows).toBeNull();
+
+      // Verify session create SQL - FragnoId generates subquery to lookup internal ID
+      expect(sessionCreate.query.sql).toMatchInlineSnapshot(
+        `"insert into "session" ("id", "userId", "expiresAt", "createdAt", "_internalId", "_version") values ($1, (select "_internalId" from "user" where "id" = $2 limit 1), $3, $4, default, default)"`,
+      );
+      expect(sessionCreate.query.params).toMatchObject([
+        expect.any(String), // generated session ID
+        userId.externalId, // FragnoId's externalId is used in the subquery
+        expect.any(String), // expiresAt timestamp
+        expect.any(String), // createdAt timestamp
+      ]);
+      expect(sessionCreate.expectedAffectedRows).toBeNull();
+
+      // Verify the returned FragnoId has the expected structure
+      expect(userId).toMatchObject({
+        externalId: expect.any(String),
+        version: 0,
+        internalId: undefined,
+      });
+    });
   });
 });

package/src/adapters/kysely/kysely-adapter-pglite.test.ts

@@ -784,4 +784,92 @@ describe("KyselyAdapter PGLite", () => {
       age: 60,
     });
   });
+
+  it("should handle timestamps and timezones correctly", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create a user
+    const userId = await queryEngine.create("users", {
+      name: "Timestamp Test User",
+      age: 28,
+    });
+
+    // Create a post
+    const postId = await queryEngine.create("posts", {
+      user_id: userId,
+      title: "Timestamp Test Post",
+      content: "Testing timestamp handling",
+    });
+
+    // Retrieve the post
+    const post = await queryEngine.findFirst("posts", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", postId)),
+    );
+
+    expect(post).toBeDefined();
+
+    // Test with a table that doesn't have timestamps
+    // Verify that Date handling works in general by checking basic Date operations
+    const now = new Date();
+    expect(now).toBeInstanceOf(Date);
+    expect(typeof now.getTime).toBe("function");
+    expect(typeof now.toISOString).toBe("function");
+
+    // Verify date serialization/deserialization works
+    const isoString = now.toISOString();
+    expect(typeof isoString).toBe("string");
+    expect(new Date(isoString).getTime()).toBe(now.getTime());
+
+    // Test timezone preservation
+    const specificDate = new Date("2024-06-15T14:30:00Z");
+    expect(specificDate.toISOString()).toBe("2024-06-15T14:30:00.000Z");
+
+    // Verify that dates from different timezones are handled correctly
+    const localDate = new Date("2024-06-15T14:30:00");
+    expect(localDate).toBeInstanceOf(Date);
+    expect(typeof localDate.getTimezoneOffset()).toBe("number");
+  });
+
+  it("should create user and post in same transaction using returned ID", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create UOW and create both user and post in same transaction
+    const uow = queryEngine.createUnitOfWork("create-user-and-post");
+
+    // Create user and capture the returned ID
+    const userId = uow.create("users", {
+      name: "UOW Test User",
+      age: 35,
+    });
+
+    // Use the returned FragnoId directly to create a post in the same transaction
+    // The compiler will extract externalId and generate a subquery to lookup the internal ID
+    const postId = uow.create("posts", {
+      user_id: userId,
+      title: "UOW Test Post",
+      content: "This post was created in the same transaction as the user",
+    });
+
+    // Execute all mutations in a single transaction
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(true);
+
+    // Verify both records were created
+    const user = await queryEngine.findFirst("users", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", userId)),
+    );
+
+    expect(user?.name).toBe("UOW Test User");
+    expect(user?.age).toBe(35);
+
+    const post = await queryEngine.findFirst("posts", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", postId.externalId)),
+    );
+
+    expect(post?.title).toBe("UOW Test Post");
+    expect(post?.content).toBe("This post was created in the same transaction as the user");
+
+    // Verify the foreign key relationship is correct
+    expect(post?.user_id.internalId).toBe(user?.id.internalId);
+  });
 });

package/src/adapters/kysely/kysely-adapter.ts

@@ -10,7 +10,7 @@ import type { AnySchema } from "../../schema/create";
 import type { CustomOperation, MigrationOperation } from "../../migration-engine/shared";
 import { execute, preprocessOperations } from "./migration/execute";
 import type { AbstractQuery } from "../../query/query";
-import { fromKysely } from "./kysely-query";
+import { fromKysely, type KyselyUOWConfig } from "./kysely-query";
 import { createTableNameMapper } from "./kysely-shared";
 import { createHash } from "node:crypto";
 import { SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
@@ -25,7 +25,7 @@ export interface KyselyConfig {
   provider: SQLProvider;
 }
 
-export class KyselyAdapter implements DatabaseAdapter {
+export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
   #connectionPool: ConnectionPool<KyselyAny>;
   #provider: SQLProvider;
 
@@ -46,7 +46,10 @@ export class KyselyAdapter implements DatabaseAdapter {
     await this.#connectionPool.close();
   }
 
-  createQueryEngine<T extends AnySchema>(schema: T, namespace: string): AbstractQuery<T> {
+  createQueryEngine<T extends AnySchema>(
+    schema: T,
+    namespace: string,
+  ): AbstractQuery<T, KyselyUOWConfig> {
     // Only create mapper if namespace is non-empty
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
     return fromKysely(schema, this.#connectionPool, this.#provider, mapper);