@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/{kysely/kysely-adapter-sqlocal.test.ts → generic-sql/sql-adapter-sqlocal.test.ts}

@@ -1,11 +1,13 @@
-import { SQLocalKysely } from "sqlocal/kysely";
 import { beforeAll, describe, expect, it } from "vitest";
-import { KyselyAdapter } from "./kysely-adapter";
+
+import { SQLocalKysely } from "sqlocal/kysely";
+
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { SQLocalDriverConfig } from "../generic-sql/driver-config";
+import { SQLocalDriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
-describe("KyselyAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("accounts", (t) => {
         return t
@@ -33,11 +35,11 @@ describe("KyselyAdapter SQLite", () => {
       });
   });
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(async () => {
     const { dialect } = new SQLocalKysely(":memory:");
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
     });

package/src/adapters/generic-sql/sqlite-storage.ts

@@ -0,0 +1,20 @@
+export type SQLiteDateStorage = "epoch-ms" | "iso-text";
+export type SQLiteBigintStorage = "blob" | "integer";
+
+export interface SQLiteStorageMode {
+  timestampStorage: SQLiteDateStorage;
+  dateStorage: SQLiteDateStorage;
+  bigintStorage: SQLiteBigintStorage;
+}
+
+export const sqliteStorageDefault: SQLiteStorageMode = {
+  timestampStorage: "epoch-ms",
+  dateStorage: "epoch-ms",
+  bigintStorage: "blob",
+};
+
+export const sqliteStoragePrisma: SQLiteStorageMode = {
+  timestampStorage: "iso-text",
+  dateStorage: "iso-text",
+  bigintStorage: "integer",
+};

package/src/adapters/generic-sql/uow-decoder.test.ts

@@ -1,14 +1,15 @@
 import { describe, it, expect } from "vitest";
-import { schema, idColumn, column, FragnoId } from "../../schema/create";
-import { UnitOfWorkDecoder } from "./uow-decoder";
-import { SQLocalDriverConfig } from "./driver-config";
+
 import type { RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
+import { schema, idColumn, column, FragnoId } from "../../schema/create";
 import type { AnySchema } from "../../schema/create";
+import { SQLocalDriverConfig } from "./driver-config";
+import { UnitOfWorkDecoder } from "./uow-decoder";
 
 describe("UnitOfWorkDecoder", () => {
   const driverConfig = new SQLocalDriverConfig();
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t

package/src/adapters/generic-sql/uow-decoder.ts

@@ -1,9 +1,11 @@
+import type { NamingResolver } from "../../naming/sql-naming";
+import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
 import type { UOWDecoder } from "../../query/unit-of-work/unit-of-work";
 import type { RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
-import type { AnySchema, AnyTable } from "../../schema/create";
 import { decodeResult } from "../../query/value-decoding";
-import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
+import type { AnySchema, AnyTable } from "../../schema/create";
 import type { DriverConfig } from "./driver-config";
+import type { SQLiteStorageMode } from "./sqlite-storage";
 
 /**
  * Decoder class for Unit of Work retrieval results.
@@ -13,9 +15,17 @@ import type { DriverConfig } from "./driver-config";
  */
 export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
   readonly #driverConfig: DriverConfig;
-
-  constructor(driverConfig: DriverConfig) {
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
+
+  constructor(
+    driverConfig: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
+  ) {
     this.#driverConfig = driverConfig;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -60,7 +70,15 @@ export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
       return this.decodeCountResult(rows);
     }
 
-    const decodedRows = rows.map((row) => decodeResult(row, operation.table, this.#driverConfig));
+    const decodedRows = rows.map((row) =>
+      decodeResult(
+        row,
+        operation.table,
+        this.#driverConfig,
+        this.#sqliteStorageMode,
+        this.#resolver,
+      ),
+    );
 
     if (operation.withCursor) {
       return this.decodeCursorResult(decodedRows, operation.table, operation);

package/src/adapters/generic-sql/uow-encoder.test.ts

@@ -1,14 +1,18 @@
 import { describe, it, expect } from "vitest";
-import { UnitOfWorkEncoder } from "./uow-encoder";
+
+import { Kysely, PostgresDialect } from "kysely";
+
+import { dbNow } from "../../query/db-now";
 import { schema, column, idColumn, referenceColumn } from "../../schema/create";
 import {
   BetterSQLite3DriverConfig,
   MySQL2DriverConfig,
   NodePostgresDriverConfig,
 } from "./driver-config";
+import { UnitOfWorkEncoder } from "./uow-encoder";
 
 describe("UnitOfWorkEncoder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -16,7 +20,8 @@ describe("UnitOfWorkEncoder", () => {
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
           .addColumn("isActive", column("bool"))
-          .addColumn("createdAt", column("timestamp"));
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("birthDate", column("date").nullable());
       })
       .addTable("posts", (t) => {
         return t
@@ -111,6 +116,34 @@ describe("UnitOfWorkEncoder", () => {
       expect(typeof result["id"]).toBe("string");
       expect(result["title"]).toBe("Test");
     });
+
+    it("should use sqlite dateStorage for dbNow date columns", () => {
+      type TestDB = { users: { id: string; birthDate: unknown } };
+      const dialectConfig = {} as unknown as ConstructorParameters<typeof PostgresDialect>[0];
+      const sqliteDb = new Kysely<TestDB>({
+        dialect: new PostgresDialect(dialectConfig),
+      });
+      const encoderWithStorage = new UnitOfWorkEncoder(sqliteConfig, sqliteDb, {
+        timestampStorage: "epoch-ms",
+        dateStorage: "iso-text",
+        bigintStorage: "blob",
+      });
+
+      const result = encoderWithStorage.encodeForDatabase({
+        values: { birthDate: dbNow() },
+        table: usersTable,
+        generateDefaults: false,
+      });
+
+      const query = sqliteDb
+        .updateTable("users")
+        .set({ birthDate: result["birthDate"] as unknown })
+        .where("id", "=", "test");
+
+      const sqlText = query.compile().sql;
+      expect(sqlText).toContain("CURRENT_TIMESTAMP");
+      expect(sqlText).not.toContain("julianday");
+    });
   });
 
   describe("PostgreSQL encoding", () => {

package/src/adapters/generic-sql/uow-encoder.ts

@@ -1,13 +1,17 @@
-import type { AnyTable, AnyColumn } from "../../schema/create";
-import type { DriverConfig } from "./driver-config";
+import type { Kysely } from "kysely";
+
+import type { NamingResolver } from "../../naming/sql-naming";
+import { getDbNowOffsetMs, isDbNow } from "../../query/db-now";
 import {
   createSQLSerializer,
   type SQLSerializer,
 } from "../../query/serialize/create-sql-serializer";
 import { encodeValues } from "../../query/value-encoding";
+import type { AnyTable, AnyColumn } from "../../schema/create";
+import type { DriverConfig } from "./driver-config";
+import { buildDbNowSql } from "./query/db-now-sql";
 import { processReferenceSubqueries } from "./query/where-builder";
-import type { TableNameMapper } from "../shared/table-name-mapper";
-import type { Kysely } from "kysely";
+import type { SQLiteStorageMode } from "./sqlite-storage";
 
 /**
  * Encoder class for Unit of Work mutation operations.
@@ -21,18 +25,23 @@ import type { Kysely } from "kysely";
  * This class mirrors the UnitOfWorkDecoder pattern for symmetry.
  */
 export class UnitOfWorkEncoder {
+  readonly #driverConfig: DriverConfig;
   readonly #serializer: SQLSerializer;
   readonly #db: Kysely<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-  readonly #mapper?: TableNameMapper;
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
 
   constructor(
     driverConfig: DriverConfig,
     db: Kysely<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
-    mapper?: TableNameMapper,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
   ) {
-    this.#serializer = createSQLSerializer(driverConfig);
+    this.#driverConfig = driverConfig;
+    this.#serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
     this.#db = db;
-    this.#mapper = mapper;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -66,10 +75,16 @@ export class UnitOfWorkEncoder {
     generateDefaults: boolean;
   }): Record<string, unknown> {
     // Step 1: Resolution - Resolve FragnoId/FragnoReference and generate defaults
-    const resolved = encodeValues(options.values, options.table, options.generateDefaults);
+    const resolved = encodeValues(
+      options.values,
+      options.table,
+      options.generateDefaults,
+      {},
+      this.#resolver,
+    );
 
     // Step 2: Reference Processing - Convert external IDs to subqueries
-    const processed = processReferenceSubqueries(resolved, this.#db, this.#mapper);
+    const processed = processReferenceSubqueries(resolved, this.#db, this.#resolver);
 
     // Step 3: Serialization - Apply database-specific type conversions
     const serialized = this.serializeValues(processed, options.table);
@@ -94,10 +109,11 @@ export class UnitOfWorkEncoder {
     table: AnyTable,
   ): Record<string, unknown> {
     const result: Record<string, unknown> = {};
+    const columnMap = this.#resolver ? this.#resolver.getColumnNameMap(table) : undefined;
 
     for (const [dbColumnName, value] of Object.entries(values)) {
       // Find the column definition by database column name
-      const col = this.findColumnByDbName(table, dbColumnName);
+      const col = this.findColumnByDbName(table, dbColumnName, columnMap);
 
       if (!col) {
         // Not a regular column (might be a special value like sql.raw())
@@ -106,6 +122,16 @@ export class UnitOfWorkEncoder {
         continue;
       }
 
+      if (isDbNow(value)) {
+        result[dbColumnName] = buildDbNowSql({
+          driverConfig: this.#driverConfig,
+          columnType: col.type,
+          offsetMs: getDbNowOffsetMs(value),
+          sqliteStorageMode: this.#sqliteStorageMode,
+        });
+        continue;
+      }
+
       // Serialize the value using the column definition and database type
       result[dbColumnName] = this.#serializer.serialize(value, col);
     }
@@ -120,9 +146,18 @@ export class UnitOfWorkEncoder {
    * @param dbColumnName - The database column name (e.g., "user_id")
    * @returns The column definition or undefined if not found
    */
-  private findColumnByDbName(table: AnyTable, dbColumnName: string): AnyColumn | undefined {
+  private findColumnByDbName(
+    table: AnyTable,
+    dbColumnName: string,
+    columnMap?: Record<string, string>,
+  ): AnyColumn | undefined {
+    const logicalName = columnMap?.[dbColumnName] ?? dbColumnName;
+    const direct = table.columns[logicalName];
+    if (direct) {
+      return direct;
+    }
     for (const col of Object.values(table.columns)) {
-      if (col.name === dbColumnName) {
+      if (col.name === logicalName) {
         return col;
       }
     }

package/src/adapters/in-memory/condition-evaluator.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, it } from "vitest";
+
+import type { Condition } from "../../query/condition-builder";
+import { buildCondition } from "../../query/condition-builder";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import { evaluateCondition } from "./condition-evaluator";
+import { createNamespaceStore } from "./store";
+
+describe("in-memory condition evaluator", () => {
+  it("evaluates SQLite-normalized comparisons and LIKE semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("isActive", column("bool"))
+          .addColumn("payload", column("json"))
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const payload = { ok: true, count: 2 };
+    const row = {
+      id: "evt_1",
+      name: "Test User",
+      createdAt,
+      isActive: true,
+      payload,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("createdAt", "=", createdAt)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    const numericBooleanCondition: Condition = {
+      type: "compare",
+      a: table.columns.isActive,
+      operator: "=",
+      b: 1,
+    };
+    expect(evaluateCondition(numericBooleanCondition, table, row)).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("payload", "=", payload)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", ">", 8n)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "contains", "test")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "starts with", "TEST")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "ends with", "user")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("handles null and IN semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("age", column("integer").nullable())
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const row = {
+      id: "evt_2",
+      age: null,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is", null)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "=", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is not", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+
+    const inCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "in",
+      b: [1n, null],
+    };
+    const notInCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "not in",
+      b: [1n, null],
+    };
+
+    expect(evaluateCondition(inCondition, table, row)).toBe(false);
+    expect(evaluateCondition(notInCondition, table, row)).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", "not in", [1n, 2n])),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("resolves reference values against the namespace store", () => {
+    const refSchema = schema("ref", (s) =>
+      s
+        .addTable("users", (t) =>
+          t.addColumn("id", idColumn()).addColumn("email", column("string")),
+        )
+        .addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("userId", referenceColumn()),
+        )
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "userId" },
+          to: { table: "users", column: "id" },
+        }),
+    );
+
+    const namespaceStore = createNamespaceStore(refSchema);
+    const usersStore = namespaceStore.tables.get("users");
+    const postsTable = refSchema.tables.posts;
+
+    if (!usersStore) {
+      throw new Error("users table missing from namespace store");
+    }
+
+    usersStore.rows.set(1n, {
+      id: "user_1",
+      email: "user@example.com",
+      _internalId: 1n,
+      _version: 0,
+    });
+
+    const postRow = {
+      id: "post_1",
+      title: "Hello",
+      userId: 1n,
+      _internalId: 10n,
+      _version: 0,
+    };
+
+    const condition = buildCondition(postsTable.columns, (eb) => eb("userId", "=", "user_1"));
+    expect(evaluateCondition(condition, postsTable, postRow, namespaceStore)).toBe(true);
+  });
+});