@fragno-dev/db 0.1.14 → 0.2.0

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

@@ -0,0 +1,56 @@
+import type { AnyColumn } from "../../../schema/create";
+import type { Condition } from "../../../query/condition-builder";
+import { decodeCursor, serializeCursorValues, type Cursor } from "../../../query/cursor";
+import type { DriverConfig } from "../driver-config";
+
+/**
+ * Build a cursor condition for pagination.
+ *
+ * Handles both single-column and multi-column cursor comparisons.
+ * For single columns: uses simple comparison (col > value)
+ * For multi-columns: builds tuple comparison ((col1, col2) > (val1, val2))
+ *
+ * @param cursor - The cursor string or object
+ * @param indexColumns - Columns used in the index for ordering
+ * @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
+ * @returns A Condition object for the cursor, or undefined if no cursor
+ * @throws Error if multi-column cursors are not supported by the implementation
+ */
+export function buildCursorCondition(
+  cursor: string | Cursor | undefined,
+  indexColumns: AnyColumn[],
+  orderDirection: "asc" | "desc",
+  isAfter: boolean,
+  driverConfig: DriverConfig,
+): Condition | undefined {
+  if (!cursor || indexColumns.length === 0) {
+    return undefined;
+  }
+
+  // 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);
+
+  // Determine comparison operator based on direction and after/before
+  const useGreaterThan =
+    (isAfter && orderDirection === "asc") || (!isAfter && orderDirection === "desc");
+
+  if (indexColumns.length === 1) {
+    // Simple single-column case
+    const col = indexColumns[0]!;
+    const val = serializedValues[col.ormName];
+    const operator = useGreaterThan ? ">" : "<";
+    return {
+      type: "compare",
+      a: col,
+      operator,
+      b: val,
+    };
+  } else {
+    throw new Error(
+      "Multi-column cursor pagination is not yet supported in Generic SQL implementation",
+    );
+  }
+}

package/src/adapters/generic-sql/query/dialect/mysql.ts

@@ -0,0 +1,34 @@
+import { SQLQueryCompiler } from "../sql-query-compiler";
+
+/**
+ * MySQL-specific query compiler.
+ *
+ * MySQL does not support RETURNING clause, so inserts return empty results.
+ */
+export class MySQLQueryCompiler extends SQLQueryCompiler {
+  /**
+   * MySQL uses standard .limit()
+   */
+  protected applyLimit<T>(query: T & { limit(limit: number): T }, limit: number): T {
+    return query.limit(limit);
+  }
+
+  /**
+   * MySQL uses standard .offset()
+   */
+  protected applyOffset<T>(query: T & { offset(offset: number): T }, offset: number): T {
+    return query.offset(offset);
+  }
+
+  /**
+   * MySQL does not support RETURNING clause.
+   * Return the query as-is without RETURNING.
+   */
+  protected applyReturning<T>(
+    query: T & { returning(columns: string[]): T },
+    _columns: string[],
+  ): T {
+    // MySQL doesn't support RETURNING, just return the query unchanged
+    return query;
+  }
+}

package/src/adapters/generic-sql/query/dialect/postgres.ts

@@ -0,0 +1,32 @@
+import { SQLQueryCompiler } from "../sql-query-compiler";
+
+/**
+ * PostgreSQL-specific query compiler.
+ *
+ * Uses standard SQL with full RETURNING support.
+ */
+export class PostgreSQLQueryCompiler extends SQLQueryCompiler {
+  /**
+   * PostgreSQL uses standard .limit()
+   */
+  protected applyLimit<T>(query: T & { limit(limit: number): T }, limit: number): T {
+    return query.limit(limit);
+  }
+
+  /**
+   * PostgreSQL uses standard .offset()
+   */
+  protected applyOffset<T>(query: T & { offset(offset: number): T }, offset: number): T {
+    return query.offset(offset);
+  }
+
+  /**
+   * PostgreSQL supports full RETURNING clause
+   */
+  protected applyReturning<T>(
+    query: T & { returning(columns: string[]): T },
+    columns: string[],
+  ): T {
+    return query.returning(columns);
+  }
+}

package/src/adapters/generic-sql/query/dialect/sqlite.ts

@@ -0,0 +1,32 @@
+import { SQLQueryCompiler } from "../sql-query-compiler";
+
+/**
+ * SQLite-specific query compiler.
+ *
+ * SQLite supports RETURNING and uses standard limit/offset.
+ */
+export class SQLiteQueryCompiler extends SQLQueryCompiler {
+  /**
+   * SQLite uses standard .limit()
+   */
+  protected applyLimit<T>(query: T & { limit(limit: number): T }, limit: number): T {
+    return query.limit(limit);
+  }
+
+  /**
+   * SQLite uses standard .offset()
+   */
+  protected applyOffset<T>(query: T & { offset(offset: number): T }, offset: number): T {
+    return query.offset(offset);
+  }
+
+  /**
+   * SQLite supports RETURNING clause (since version 3.35.0)
+   */
+  protected applyReturning<T>(
+    query: T & { returning(columns: string[]): T },
+    columns: string[],
+  ): T {
+    return query.returning(columns);
+  }
+}