@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/generic-sql/query/where-builder.test.ts

@@ -1,12 +1,16 @@
-import { Kysely, PostgresDialect } from "kysely";
 import { beforeAll, describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
-import { fullSQLName, buildWhere, processReferenceSubqueries } from "./where-builder";
+
+import { Kysely, PostgresDialect } from "kysely";
+
+import { createNamingResolver, type SqlNamingStrategy } from "../../../naming/sql-naming";
+import { dbNow } from "../../../query/db-now";
 import { ReferenceSubquery } from "../../../query/value-encoding";
+import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
 import { BetterSQLite3DriverConfig, NodePostgresDriverConfig } from "../driver-config";
+import { fullSQLName, buildWhere, processReferenceSubqueries } from "./where-builder";
 
 describe("where-builder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -15,7 +19,8 @@ describe("where-builder", () => {
           .addColumn("email", 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
@@ -52,12 +57,18 @@ describe("where-builder", () => {
       expect(result).toBe("users.id");
     });
 
-    it("should work with table name mapper", () => {
-      const mapper = {
-        toPhysical: (ormName: string) => `prefix_${ormName}`,
-        toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+    it("should work with naming resolver", () => {
+      const namingStrategy: SqlNamingStrategy = {
+        namespaceScope: "suffix",
+        namespaceToSchema: (namespace) => namespace,
+        tableName: (logicalTable) => `prefix_${logicalTable}`,
+        columnName: (logicalColumn) => logicalColumn,
+        indexName: (logicalIndex) => logicalIndex,
+        uniqueIndexName: (logicalIndex) => logicalIndex,
+        foreignKeyName: ({ referenceName }) => referenceName,
       };
-      const result = fullSQLName(usersTable.columns.name, mapper);
+      const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
+      const result = fullSQLName(usersTable.columns.name, resolver);
       expect(result).toBe("prefix_users.name");
     });
   });
@@ -111,6 +122,56 @@ describe("where-builder", () => {
     };
 
     describe("comparison operators", () => {
+      it("should serialize dbNow to CURRENT_TIMESTAMP", () => {
+        const condition = {
+          type: "compare" as const,
+          a: usersTable.columns.createdAt,
+          operator: "<=" as const,
+          b: dbNow(),
+        };
+
+        type TestDB = { users: { id: string } };
+        const db = new Kysely<TestDB>({
+          dialect: new PostgresDialect({ pool: {} as any }), // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+
+        const query = db
+          .selectFrom("users")
+          .select("id")
+          .where((eb) => buildWhere(condition, eb, new NodePostgresDriverConfig()));
+
+        expect(query.compile().sql).toContain("CURRENT_TIMESTAMP");
+      });
+
+      it("should respect sqlite date storage for dbNow", () => {
+        const condition = {
+          type: "compare" as const,
+          a: usersTable.columns.birthDate,
+          operator: "<=" as const,
+          b: dbNow(),
+        };
+
+        type TestDB = { users: { id: string } };
+        const db = new Kysely<TestDB>({
+          dialect: new PostgresDialect({ pool: {} as any }), // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+
+        const query = db
+          .selectFrom("users")
+          .select("id")
+          .where((eb) =>
+            buildWhere(condition, eb, new BetterSQLite3DriverConfig(), {
+              timestampStorage: "epoch-ms",
+              dateStorage: "iso-text",
+              bigintStorage: "blob",
+            }),
+          );
+
+        const sqlText = query.compile().sql;
+        expect(sqlText).toContain("CURRENT_TIMESTAMP");
+        expect(sqlText).not.toContain("julianday");
+      });
+
       it("should build simple equality comparison", () => {
         const condition = {
           type: "compare" as const,
@@ -532,6 +593,7 @@ describe("where-builder", () => {
           eb,
           new NodePostgresDriverConfig(),
           undefined,
+          undefined,
           postsTable,
         );
 
@@ -561,6 +623,7 @@ describe("where-builder", () => {
           createMockEB(),
           new NodePostgresDriverConfig(),
           undefined,
+          undefined,
           postsTable,
         );
 
@@ -573,11 +636,17 @@ describe("where-builder", () => {
         });
       });
 
-      it("should generate subquery with table name mapper", () => {
-        const mapper = {
-          toPhysical: (ormName: string) => `prefix_${ormName}`,
-          toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+      it("should generate subquery with naming resolver", () => {
+        const namingStrategy: SqlNamingStrategy = {
+          namespaceScope: "suffix",
+          namespaceToSchema: (namespace) => namespace,
+          tableName: (logicalTable) => `prefix_${logicalTable}`,
+          columnName: (logicalColumn) => logicalColumn,
+          indexName: (logicalIndex) => logicalIndex,
+          uniqueIndexName: (logicalIndex) => logicalIndex,
+          foreignKeyName: ({ referenceName }) => referenceName,
         };
+        const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
 
         const condition = {
           type: "compare" as const,
@@ -591,7 +660,8 @@ describe("where-builder", () => {
           condition,
           eb,
           new NodePostgresDriverConfig(),
-          mapper,
+          undefined,
+          resolver,
           postsTable,
         );
 
@@ -682,17 +752,23 @@ describe("where-builder", () => {
       expect(processed).toEqual(values);
     });
 
-    it("should use table name mapper when provided", () => {
-      const mapper = {
-        toPhysical: (ormName: string) => `prefix_${ormName}`,
-        toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+    it("should use naming resolver when provided", () => {
+      const namingStrategy: SqlNamingStrategy = {
+        namespaceScope: "suffix",
+        namespaceToSchema: (namespace) => namespace,
+        tableName: (logicalTable) => `prefix_${logicalTable}`,
+        columnName: (logicalColumn) => logicalColumn,
+        indexName: (logicalIndex) => logicalIndex,
+        uniqueIndexName: (logicalIndex) => logicalIndex,
+        foreignKeyName: ({ referenceName }) => referenceName,
       };
+      const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
 
       const values = {
         userId: new ReferenceSubquery(usersTable, "user-123"),
       };
 
-      const processed = processReferenceSubqueries(values, kysely, mapper);
+      const processed = processReferenceSubqueries(values, kysely, resolver);
 
       // Compile the subquery to check it uses the mapped table name
       const subquery = processed["userId"] as unknown as { compile: () => { sql: string } };

package/src/adapters/generic-sql/query/where-builder.ts

@@ -1,4 +1,10 @@
 import { sql, type BinaryOperator } from "kysely";
+
+import type { NamingResolver } from "../../../naming/sql-naming";
+import type { Condition } from "../../../query/condition-builder";
+import { getDbNowOffsetMs, isDbNow } from "../../../query/db-now";
+import { createSQLSerializer } from "../../../query/serialize/create-sql-serializer";
+import { ReferenceSubquery, resolveFragnoIdValue } from "../../../query/value-encoding";
 import {
   type AnyColumn,
   type AnyTable,
@@ -6,24 +12,38 @@ import {
   FragnoId,
   FragnoReference,
 } from "../../../schema/create";
-import type { Condition } from "../../../query/condition-builder";
-import { createSQLSerializer } from "../../../query/serialize/create-sql-serializer";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
 import type { DriverConfig } from "../driver-config";
-import { ReferenceSubquery, resolveFragnoIdValue } from "../../../query/value-encoding";
+import type { SQLiteStorageMode } from "../sqlite-storage";
+import { buildDbNowSql } from "./db-now-sql";
 import type { AnyKysely, AnyExpressionBuilder, AnyExpressionWrapper } from "./sql-query-compiler";
 
 /**
  * Returns the fully qualified SQL name for a column (table.column).
  *
  * @param column - The column to get the full name for
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @returns The fully qualified SQL name in the format "tableName.columnName"
  * @internal
  */
-export function fullSQLName(column: AnyColumn, mapper?: TableNameMapper): string {
-  const tableName = mapper ? mapper.toPhysical(column.tableName) : column.tableName;
-  return `${tableName}.${column.name}`;
+export function fullSQLName(column: AnyColumn, resolver?: NamingResolver): string {
+  const tableName = resolver ? resolver.getTableName(column.tableName) : column.tableName;
+  const columnName = resolver ? resolver.getColumnName(column.tableName, column.name) : column.name;
+  return `${tableName}.${columnName}`;
+}
+
+function fullSQLNameWithAlias(
+  column: AnyColumn,
+  resolver?: NamingResolver,
+  table?: AnyTable,
+  tableAlias?: string,
+): string {
+  if (table && tableAlias && column.tableName === table.name) {
+    const columnName = resolver
+      ? resolver.getColumnName(column.tableName, column.name)
+      : column.name;
+    return `${tableAlias}.${columnName}`;
+  }
+  return fullSQLName(column, resolver);
 }
 
 /**
@@ -36,7 +56,7 @@ export function fullSQLName(column: AnyColumn, mapper?: TableNameMapper): string
  * @param condition - The condition tree to build the WHERE clause from
  * @param eb - Kysely expression builder for constructing SQL expressions
  * @param database - The database type (affects SQL generation)
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @param table - The table being queried (used for resolving reference columns)
  * @returns A Kysely expression wrapper representing the WHERE clause
  * @internal
@@ -45,10 +65,12 @@ export function buildWhere(
   condition: Condition,
   eb: AnyExpressionBuilder,
   driverConfig: DriverConfig,
-  mapper?: TableNameMapper,
+  sqliteStorageMode?: SQLiteStorageMode,
+  resolver?: NamingResolver,
   table?: AnyTable,
+  tableAlias?: string,
 ): AnyExpressionWrapper {
-  const serializer = createSQLSerializer(driverConfig);
+  const serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
 
   if (condition.type === "compare") {
     const left = condition.a;
@@ -56,25 +78,40 @@ export function buildWhere(
     let val = condition.b;
 
     if (!(val instanceof Column)) {
-      // Handle reference columns specially
-      if (left.role === "reference" && table) {
+      if (isDbNow(val)) {
+        val = buildDbNowSql({
+          driverConfig,
+          columnType: left.type,
+          offsetMs: getDbNowOffsetMs(val),
+          sqliteStorageMode,
+        });
+      } else if (left.role === "reference" && table) {
+        // Handle reference columns specially
         if (typeof val === "string") {
           // String external ID - create subquery to lookup internal ID
           const relation = Object.values(table.relations).find((rel) =>
-            rel.on.some(([localCol]) => localCol === left.ormName),
+            rel.on.some(([localCol]) => localCol === left.name),
           );
           if (relation) {
             const refTable = relation.table;
             const internalIdCol = refTable.getInternalIdColumn();
             const idCol = refTable.getIdColumn();
-            const physicalTableName = mapper
-              ? mapper.toPhysical(refTable.ormName)
-              : refTable.ormName;
+            const physicalTableName = resolver
+              ? resolver.getTableName(refTable.name)
+              : refTable.name;
 
             val = eb
               .selectFrom(physicalTableName)
-              .select(internalIdCol.name)
-              .where(idCol.name, "=", val)
+              .select(
+                resolver
+                  ? resolver.getColumnName(refTable.name, internalIdCol.name)
+                  : internalIdCol.name,
+              )
+              .where(
+                resolver ? resolver.getColumnName(refTable.name, idCol.name) : idCol.name,
+                "=",
+                val,
+              )
               .limit(1);
           }
         } else if (val instanceof FragnoId && val.internalId !== undefined) {
@@ -83,20 +120,28 @@ export function buildWhere(
         } else if (val instanceof FragnoId && val.internalId === undefined) {
           // FragnoId without internal ID - create subquery using external ID
           const relation = Object.values(table.relations).find((rel) =>
-            rel.on.some(([localCol]) => localCol === left.ormName),
+            rel.on.some(([localCol]) => localCol === left.name),
           );
           if (relation) {
             const refTable = relation.table;
             const internalIdCol = refTable.getInternalIdColumn();
             const idCol = refTable.getIdColumn();
-            const physicalTableName = mapper
-              ? mapper.toPhysical(refTable.ormName)
-              : refTable.ormName;
+            const physicalTableName = resolver
+              ? resolver.getTableName(refTable.name)
+              : refTable.name;
 
             val = eb
               .selectFrom(physicalTableName)
-              .select(internalIdCol.name)
-              .where(idCol.name, "=", val.externalId)
+              .select(
+                resolver
+                  ? resolver.getColumnName(refTable.name, internalIdCol.name)
+                  : internalIdCol.name,
+              )
+              .where(
+                resolver ? resolver.getColumnName(refTable.name, idCol.name) : idCol.name,
+                "=",
+                val.externalId,
+              )
               .limit(1);
           }
         } else if (val instanceof FragnoReference) {
@@ -122,54 +167,75 @@ export function buildWhere(
         v = "like";
         rhs =
           val instanceof Column
-            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            ? sql`concat('%', ${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))}, '%')`
             : `%${val}%`;
         break;
       case "not contains":
         v = "not like";
         rhs =
           val instanceof Column
-            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            ? sql`concat('%', ${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))}, '%')`
             : `%${val}%`;
         break;
       case "starts with":
         v = "like";
         rhs =
-          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
+          val instanceof Column
+            ? sql`concat(${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))}, '%')`
+            : `${val}%`;
         break;
       case "not starts with":
         v = "not like";
         rhs =
-          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
+          val instanceof Column
+            ? sql`concat(${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))}, '%')`
+            : `${val}%`;
         break;
       case "ends with":
         v = "like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))})`
+            : `%${val}`;
         break;
       case "not ends with":
         v = "not like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))})`
+            : `%${val}`;
         break;
       default:
         v = op;
-        rhs = val instanceof Column ? eb.ref(fullSQLName(val, mapper)) : val;
+        rhs =
+          val instanceof Column
+            ? eb.ref(fullSQLNameWithAlias(val, resolver, table, tableAlias))
+            : val;
     }
 
-    return eb(fullSQLName(left, mapper), v, rhs);
+    return eb(fullSQLNameWithAlias(left, resolver, table, tableAlias), v, rhs);
   }
 
   // Nested conditions
   if (condition.type === "and") {
-    return eb.and(condition.items.map((v) => buildWhere(v, eb, driverConfig, mapper, table)));
+    return eb.and(
+      condition.items.map((v) =>
+        buildWhere(v, eb, driverConfig, sqliteStorageMode, resolver, table, tableAlias),
+      ),
+    );
   }
 
   if (condition.type === "not") {
-    return eb.not(buildWhere(condition.item, eb, driverConfig, mapper, table));
+    return eb.not(
+      buildWhere(condition.item, eb, driverConfig, sqliteStorageMode, resolver, table, tableAlias),
+    );
   }
 
-  return eb.or(condition.items.map((v) => buildWhere(v, eb, driverConfig, mapper, table)));
+  return eb.or(
+    condition.items.map((v) =>
+      buildWhere(v, eb, driverConfig, sqliteStorageMode, resolver, table, tableAlias),
+    ),
+  );
 }
 
 /**
@@ -177,17 +243,18 @@ export function buildWhere(
  *
  * @param values - The encoded values that may contain ReferenceSubquery objects
  * @param kysely - The Kysely database instance for building subqueries
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @returns Processed values with subqueries in place of ReferenceSubquery markers
  * @internal
  */
 export function processReferenceSubqueries(
   values: Record<string, unknown>,
   kysely: AnyKysely,
-  mapper?: TableNameMapper,
+  resolver?: NamingResolver,
 ): Record<string, unknown> {
   const processed: Record<string, unknown> = {};
-  const getTableName = (table: AnyTable) => (mapper ? mapper.toPhysical(table.name) : table.name);
+  const getTableName = (table: AnyTable) =>
+    resolver ? resolver.getTableName(table.name) : table.name;
 
   for (const [key, value] of Object.entries(values)) {
     if (value instanceof ReferenceSubquery) {
@@ -196,11 +263,15 @@ export function processReferenceSubqueries(
       const tableName = getTableName(refTable);
       const internalIdCol = refTable.getInternalIdColumn().name;
       const idCol = refTable.getIdColumn().name;
+      const internalIdColumnName = resolver
+        ? resolver.getColumnName(refTable.name, internalIdCol)
+        : internalIdCol;
+      const idColumnName = resolver ? resolver.getColumnName(refTable.name, idCol) : idCol;
 
       processed[key] = kysely
         .selectFrom(tableName)
-        .select(internalIdCol)
-        .where(idCol, "=", externalId)
+        .select(internalIdColumnName)
+        .where(idColumnName, "=", externalId)
         .limit(1);
     } else {
       processed[key] = value;

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

@@ -1,20 +1,15 @@
-import { KyselyPGlite } from "kysely-pglite";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { KyselyAdapter } from "./kysely-adapter";
-import {
-  column,
-  idColumn,
-  referenceColumn,
-  schema,
-  type FragnoId,
-  type FragnoReference,
-} from "../../schema/create";
-import { Cursor } from "../../query/cursor";
-import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+
+import { KyselyPGlite } from "kysely-pglite";
+
 import { internalSchema } from "../../fragments/internal-fragment";
+import { Cursor } from "../../query/cursor";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+import { PGLiteDriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
-describe("KyselyAdapter PGLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter PGLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -96,12 +91,12 @@ describe("KyselyAdapter PGLite", () => {
       });
   });
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(async () => {
     const { dialect } = await KyselyPGlite.create();
 
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
     });
@@ -478,7 +473,6 @@ describe("KyselyAdapter PGLite", () => {
     type PostTag = Prettify<InferArrayElement<typeof postTags>>;
     type Tag = Prettify<RemoveIndex<PostTag["tag"]>>;
     expectTypeOf<Tag>().toEqualTypeOf<{
-      id: FragnoId;
       name: string;
     } | null>();
 
@@ -487,10 +481,7 @@ describe("KyselyAdapter PGLite", () => {
     expect(typeScriptPosts).toHaveLength(1);
     type Post = Prettify<(typeof typeScriptPosts)[number]["post"]>;
     expectTypeOf<Post>().toEqualTypeOf<{
-      id: FragnoId;
-      user_id: FragnoReference;
       title: string;
-      content: string;
     } | null>();
     expect(typeScriptPosts[0]!.post!.title).toBe("TypeScript Tips");