@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/generic-sql/query/cursor-utils.test.ts

@@ -0,0 +1,272 @@
+import { describe, expect, it } from "vitest";
+
+import type { Condition } from "../../../query/condition-builder";
+import { Cursor } from "../../../query/cursor";
+import { column, idColumn, schema } from "../../../schema/create";
+import { NodePostgresDriverConfig } from "../driver-config";
+import { buildCursorCondition } from "./cursor-utils";
+
+const testSchema = schema("workflow", (s) => {
+  return s.addTable("workflow_step", (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("workflowName", column("string"))
+      .addColumn("instanceId", column("string"))
+      .addColumn("runNumber", column("integer"))
+      .addColumn("createdAt", column("timestamp"));
+  });
+});
+
+const table = testSchema.tables.workflow_step;
+const indexColumns = [
+  table.columns.workflowName,
+  table.columns.instanceId,
+  table.columns.runNumber,
+  table.columns.createdAt,
+];
+
+type NormalizedCondition =
+  | { type: "compare"; column: string; operator: string; value: unknown }
+  | { type: "and" | "or"; items: NormalizedCondition[] }
+  | { type: "not"; item: NormalizedCondition };
+
+const normalizeCondition = (condition?: Condition): NormalizedCondition | null => {
+  if (!condition) {
+    return null;
+  }
+
+  switch (condition.type) {
+    case "compare":
+      return {
+        type: "compare",
+        column: condition.a.name,
+        operator: condition.operator,
+        value: condition.b,
+      };
+    case "and":
+    case "or":
+      return {
+        type: condition.type,
+        items: condition.items.map((item) => normalizeCondition(item) as NormalizedCondition),
+      };
+    case "not":
+      return {
+        type: "not",
+        item: normalizeCondition(condition.item) as NormalizedCondition,
+      };
+    default: {
+      const exhaustiveCheck: never = condition;
+      throw new Error(`Unsupported condition type: ${JSON.stringify(exhaustiveCheck)}`);
+    }
+  }
+};
+
+describe("buildCursorCondition", () => {
+  it("builds lexicographic conditions for composite asc cursors", () => {
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const cursor = new Cursor({
+      indexName: "idx_workflow_step_history_createdAt",
+      orderDirection: "asc",
+      pageSize: 10,
+      indexValues: {
+        workflowName: "wf",
+        instanceId: "inst",
+        runNumber: 2,
+        createdAt,
+      },
+    });
+
+    const condition = buildCursorCondition(
+      cursor,
+      indexColumns,
+      "asc",
+      true,
+      new NodePostgresDriverConfig(),
+    );
+
+    expect(normalizeCondition(condition)).toEqual({
+      type: "or",
+      items: [
+        {
+          type: "compare",
+          column: "workflowName",
+          operator: ">",
+          value: "wf",
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: ">",
+              value: "inst",
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: ">",
+              value: 2,
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "=",
+              value: 2,
+            },
+            {
+              type: "compare",
+              column: "createdAt",
+              operator: ">",
+              value: createdAt,
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("builds lexicographic conditions for composite desc cursors", () => {
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const cursor = new Cursor({
+      indexName: "idx_workflow_step_history_createdAt",
+      orderDirection: "desc",
+      pageSize: 10,
+      indexValues: {
+        workflowName: "wf",
+        instanceId: "inst",
+        runNumber: 2,
+        createdAt,
+      },
+    });
+
+    const condition = buildCursorCondition(
+      cursor,
+      indexColumns,
+      "desc",
+      true,
+      new NodePostgresDriverConfig(),
+    );
+
+    expect(normalizeCondition(condition)).toEqual({
+      type: "or",
+      items: [
+        {
+          type: "compare",
+          column: "workflowName",
+          operator: "<",
+          value: "wf",
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "<",
+              value: "inst",
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "<",
+              value: 2,
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "=",
+              value: 2,
+            },
+            {
+              type: "compare",
+              column: "createdAt",
+              operator: "<",
+              value: createdAt,
+            },
+          ],
+        },
+      ],
+    });
+  });
+});

package/src/adapters/generic-sql/query/cursor-utils.ts

@@ -1,7 +1,8 @@
-import type { AnyColumn } from "../../../schema/create";
 import type { Condition } from "../../../query/condition-builder";
 import { decodeCursor, serializeCursorValues, type Cursor } from "../../../query/cursor";
+import type { AnyColumn } from "../../../schema/create";
 import type { DriverConfig } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 
 /**
  * Build a cursor condition for pagination.
@@ -15,6 +16,7 @@ import type { DriverConfig } from "../driver-config";
  * @param orderDirection - Direction of ordering (asc/desc)
  * @param isAfter - True for "after" cursor (forward pagination), false for "before" (backward)
  * @param driverConfig - The driver configuration for value serialization
+ * @param sqliteStorageMode - Optional SQLite storage mode for date/bigint serialization
  * @returns A Condition object for the cursor, or undefined if no cursor
  * @throws Error if multi-column cursors are not supported by the implementation
  */
@@ -24,6 +26,7 @@ export function buildCursorCondition(
   orderDirection: "asc" | "desc",
   isAfter: boolean,
   driverConfig: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
 ): Condition | undefined {
   if (!cursor || indexColumns.length === 0) {
     return undefined;
@@ -31,7 +34,12 @@ export function buildCursorCondition(
 
   // Decode cursor if it's a string, otherwise use it as-is
   const cursorObj = typeof cursor === "string" ? decodeCursor(cursor) : cursor;
-  const serializedValues = serializeCursorValues(cursorObj, indexColumns, driverConfig);
+  const serializedValues = serializeCursorValues(
+    cursorObj,
+    indexColumns,
+    driverConfig,
+    sqliteStorageMode,
+  );
 
   // Determine comparison operator based on direction and after/before
   const useGreaterThan =
@@ -40,7 +48,7 @@ export function buildCursorCondition(
   if (indexColumns.length === 1) {
     // Simple single-column case
     const col = indexColumns[0]!;
-    const val = serializedValues[col.ormName];
+    const val = serializedValues[col.name];
     const operator = useGreaterThan ? ">" : "<";
     return {
       type: "compare",
@@ -48,9 +56,36 @@ export function buildCursorCondition(
       operator,
       b: val,
     };
-  } else {
-    throw new Error(
-      "Multi-column cursor pagination is not yet supported in Generic SQL implementation",
-    );
   }
+
+  const operator = useGreaterThan ? ">" : "<";
+  const orConditions: Condition[] = [];
+  const isNullish = (value: unknown): value is null | undefined =>
+    value === null || value === undefined;
+  const buildEqualityCondition = (column: AnyColumn, value: unknown): Condition =>
+    isNullish(value)
+      ? { type: "compare", a: column, operator: "is", b: null }
+      : { type: "compare", a: column, operator: "=", b: value };
+
+  for (let i = 0; i < indexColumns.length; i += 1) {
+    const col = indexColumns[i]!;
+    const val = serializedValues[col.name];
+    const andItems: Condition[] = [];
+
+    for (let j = 0; j < i; j += 1) {
+      const prevCol = indexColumns[j]!;
+      andItems.push(buildEqualityCondition(prevCol, serializedValues[prevCol.name]));
+    }
+
+    andItems.push({
+      type: "compare",
+      a: col,
+      operator,
+      b: val,
+    });
+
+    orConditions.push(andItems.length === 1 ? andItems[0]! : { type: "and", items: andItems });
+  }
+
+  return { type: "or", items: orConditions };
 }

package/src/adapters/generic-sql/query/db-now-sql.ts

@@ -0,0 +1,49 @@
+import { sql } from "kysely";
+
+import type { AnyColumn } from "../../../schema/create";
+import type { DriverConfig } from "../driver-config";
+import { sqliteStorageDefault, type SQLiteStorageMode } from "../sqlite-storage";
+
+type ColumnType = AnyColumn["type"];
+
+type BuildDbNowSqlOptions = {
+  driverConfig: DriverConfig;
+  columnType: ColumnType;
+  offsetMs: number;
+  sqliteStorageMode?: SQLiteStorageMode;
+};
+
+export const buildDbNowSql = ({
+  driverConfig,
+  columnType,
+  offsetMs,
+  sqliteStorageMode,
+}: BuildDbNowSqlOptions) => {
+  if (driverConfig.databaseType === "sqlite") {
+    const storageMode = sqliteStorageMode ?? sqliteStorageDefault;
+    const storage = columnType === "date" ? storageMode.dateStorage : storageMode.timestampStorage;
+    if ((columnType === "timestamp" || columnType === "date") && storage === "epoch-ms") {
+      const base = sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
+      return offsetMs === 0 ? base : sql`${base} + ${offsetMs}`;
+    }
+    if (offsetMs === 0) {
+      return sql`CURRENT_TIMESTAMP`;
+    }
+    const roundedSeconds = Math.round((offsetMs / 1000) * 1000) / 1000;
+    const modifier = `${roundedSeconds >= 0 ? "+" : ""}${roundedSeconds} seconds`;
+    return sql`datetime('now', ${modifier})`;
+  }
+
+  if (driverConfig.databaseType === "mysql") {
+    if (offsetMs === 0) {
+      return sql`CURRENT_TIMESTAMP`;
+    }
+    const micros = Math.trunc(offsetMs * 1000);
+    return sql`TIMESTAMPADD(MICROSECOND, ${micros}, CURRENT_TIMESTAMP)`;
+  }
+
+  if (offsetMs === 0) {
+    return sql`CURRENT_TIMESTAMP`;
+  }
+  return sql`(CURRENT_TIMESTAMP + (${offsetMs} * interval '1 millisecond'))`;
+};