@telorun/sql 0.8.0 → 0.10.0

package/src/sql-selection-controller.ts

@@ -1,5 +1,5 @@
 import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
-import type { SqlConnectionResource } from "./sql-connection-controller.js";
+import type { SqlConnection, SqlDialect } from "./sql-connection.js";
 import { resolveSqlConnection } from "./sql-connection-ref.js";
 import type { SqlResult } from "./sql-query-controller.js";
 import type { SqlTransactionResource } from "./sql-transaction-controller.js";
@@ -59,7 +59,7 @@ interface OrderByItem {
 
 interface SelectManifest {
   metadata: { name: string; module: string };
-  connection?: SqlConnectionResource;
+  connection?: SqlConnection;
   transaction?: SqlTransactionResource;
   from: string;
   columns?: ColumnDef[];
@@ -96,12 +96,14 @@ class SqlSelectionResource implements ResourceInstance {
     const limit = m.limit != null ? ctx.expandValue(m.limit, expandCtx) : undefined;
     const offset = m.offset != null ? ctx.expandValue(m.offset, expandCtx) : undefined;
 
-    const connection = resolveSqlConnection(m.connection, ctx) ?? m.transaction?.getConnection();
+    const connection =
+      resolveSqlConnection(m.connection, ctx, () => `Sql.Selection "${m.metadata.name}": 'connection'`) ??
+      m.transaction?.getConnection();
     if (!connection) {
       throw new Error("Sql.Selection: either 'connection' or 'transaction' must be set");
     }
 
-    const { sql, params } = buildSelect(m, where, having, limit, offset, connection.driver);
+    const { sql, params } = buildSelect(m, where, having, limit, offset, connection.dialect);
     const result = await connection.execute<Record<string, unknown>>(sql, params, m.transaction);
     return { rows: result.rows, rowCount: result.rows.length };
   }
@@ -109,21 +111,20 @@ class SqlSelectionResource implements ResourceInstance {
 
 // ── SQL building ──────────────────────────────────────────────────────────────
 
-type Driver = "postgres" | "sqlite";
-
 function buildSelect(
   m: SelectManifest,
   where: WhereNode[],
   having: WhereNode[],
   limit: unknown,
   offset: unknown,
-  driver: Driver,
+  dialect: SqlDialect,
 ): { sql: string; params: unknown[] } {
   const params: unknown[] = [];
   const addParam = (value: unknown): string => {
     params.push(value);
-    return `$${params.length}`;
+    return dialect.placeholderStyle === "numbered" ? `$${params.length}` : "?";
   };
+  const quoteIdent = (name: string): string => dialect.quoteIdentifier(name);
 
   const parts: string[] = [];
 
@@ -134,14 +135,14 @@ function buildSelect(
   } else if (m.distinctOn && m.distinctOn.length > 0) {
     selectClause += ` DISTINCT ON (${m.distinctOn.map(quoteIdent).join(", ")})`;
   }
-  const colList = m.columns && m.columns.length > 0 ? buildColumns(m.columns) : "*";
+  const colList = m.columns && m.columns.length > 0 ? buildColumns(m.columns, dialect) : "*";
   parts.push(`${selectClause} ${colList}`);
 
   // FROM
   parts.push(`FROM ${quoteIdent(m.from)}`);
 
   // WHERE
-  const whereStr = buildClauses(where, "AND", driver, addParam);
+  const whereStr = buildClauses(where, "AND", dialect, addParam);
   if (whereStr) parts.push(`WHERE ${whereStr}`);
 
   // GROUP BY
@@ -150,7 +151,7 @@ function buildSelect(
   }
 
   // HAVING
-  const havingStr = buildClauses(having, "AND", driver, addParam);
+  const havingStr = buildClauses(having, "AND", dialect, addParam);
   if (havingStr) parts.push(`HAVING ${havingStr}`);
 
   // ORDER BY
@@ -168,7 +169,8 @@ function buildSelect(
   return { sql: parts.join("\n"), params };
 }
 
-function buildColumns(columns: ColumnDef[]): string {
+function buildColumns(columns: ColumnDef[], dialect: SqlDialect): string {
+  const quoteIdent = (name: string): string => dialect.quoteIdentifier(name);
   return columns
     .map((c) => {
       if (typeof c === "string") return quoteIdent(c);
@@ -181,13 +183,13 @@ function buildColumns(columns: ColumnDef[]): string {
 function buildClauses(
   clauses: WhereNode[],
   join: "AND" | "OR",
-  driver: Driver,
+  dialect: SqlDialect,
   addParam: (v: unknown) => string,
 ): string | null {
   const parts: string[] = [];
   for (const clause of clauses) {
     if (clause.when === false) continue;
-    const built = buildClause(clause, driver, addParam);
+    const built = buildClause(clause, dialect, addParam);
     if (built !== null) parts.push(built);
   }
   if (parts.length === 0) return null;
@@ -197,46 +199,45 @@ function buildClauses(
 
 function buildClause(
   node: WhereNode,
-  driver: Driver,
+  dialect: SqlDialect,
   addParam: (v: unknown) => string,
 ): string | null {
   if ("not" in node) {
-    const inner = buildClause(node.not, driver, addParam);
+    const inner = buildClause(node.not, dialect, addParam);
     return inner ? `NOT (${inner})` : null;
   }
   if ("or" in node) {
-    const inner = buildClauses(node.or, "OR", driver, addParam);
+    const inner = buildClauses(node.or, "OR", dialect, addParam);
     return inner ? `(${inner})` : null;
   }
   if ("and" in node) {
-    const inner = buildClauses(node.and, "AND", driver, addParam);
+    const inner = buildClauses(node.and, "AND", dialect, addParam);
     return inner ? `(${inner})` : null;
   }
   if ("sql" in node) {
     return renumberFragment(node.sql, node.bindings ?? [], addParam);
   }
   if ("column" in node) {
-    return buildCondition(node, driver, addParam);
+    return buildCondition(node, dialect, addParam);
   }
   return null;
 }
 
-function buildCondition(c: Condition, driver: Driver, addParam: (v: unknown) => string): string {
-  const col = quoteIdent(c.column);
+function buildCondition(
+  c: Condition,
+  dialect: SqlDialect,
+  addParam: (v: unknown) => string,
+): string {
+  const col = dialect.quoteIdentifier(c.column);
   switch (c.op) {
     case "is_null":
       return `${col} IS NULL`;
     case "is_not_null":
       return `${col} IS NOT NULL`;
-    case "in": {
-      if (driver === "postgres") {
-        return `${col} = ANY(${addParam(c.value)})`;
-      }
-      const placeholders = (c.value as unknown[]).map((v) => addParam(v)).join(", ");
-      return `${col} IN (${placeholders})`;
-    }
+    case "in":
+      return dialect.renderIn(col, c.value as unknown[], addParam);
     default: {
-      const rhs = c.ref !== undefined ? quoteIdent(c.ref) : addParam(c.value);
+      const rhs = c.ref !== undefined ? dialect.quoteIdentifier(c.ref) : addParam(c.value);
       return `${col} ${opToSql(c.op)} ${rhs}`;
     }
   }
@@ -250,10 +251,6 @@ function renumberFragment(
   return sql.replace(/\$(\d+)/g, (_, idx) => addParam(bindings[Number(idx) - 1]));
 }
 
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
-}
-
 function opToSql(op: Op): string {
   const map: Record<string, string> = {
     eq: "=",

package/src/sql-transaction-controller.ts

@@ -1,11 +1,11 @@
 import type { Invocable, ResourceContext, ResourceInstance } from "@telorun/sdk";
-import type { SqlConnectionResource } from "./sql-connection-controller.js";
+import type { SqlConnection } from "./sql-connection.js";
 import { resolveSqlConnection } from "./sql-connection-ref.js";
 import { currentTxId } from "./transaction-store.js";
 
 interface SqlTransactionManifest {
   metadata: { name: string; module: string };
-  connection: SqlConnectionResource;
+  connection: SqlConnection;
   steps: Invocable;
   inputs?: Record<string, unknown>;
 }
@@ -16,10 +16,13 @@ export class SqlTransactionResource implements ResourceInstance {
     private readonly ctx: ResourceContext,
   ) {}
 
-  getConnection(): SqlConnectionResource {
+  getConnection(): SqlConnection {
     return (
-      resolveSqlConnection(this.manifest.connection, this.ctx) ??
-      failMissingConnection(this.manifest.metadata.name)
+      resolveSqlConnection(
+        this.manifest.connection,
+        this.ctx,
+        () => `Sql.Transaction "${this.manifest.metadata.name}": 'connection'`,
+      ) ?? failMissingConnection(this.manifest.metadata.name)
     );
   }
 

package/dist/sql-connection-controller.d.ts

@@ -1,43 +0,0 @@
-import type { ResourceInstance } from "@telorun/sdk";
-import { Kysely, type QueryResult } from "kysely";
-import type { SqlTransactionResource } from "./sql-transaction-controller.js";
-import type { SqliteDb } from "./sqlite-driver-interface.js";
-export type SqlDriver = "postgres" | "sqlite";
-/** Native bind-placeholder syntax per driver: SQLite binds anonymous `?`,
- *  PostgreSQL binds numbered `$1`, `$2`, … */
-export type PlaceholderStyle = "qmark" | "numbered";
-/**
- * Driver-agnostic SQL connection. The kysely instance (and, for SQLite, the
- * underlying database handle used by `executeScript`) is built by the driver
- * backend (`sql-postgres`, `sql-sqlite`) and handed in via
- * {@link createSqlConnection}. Everything here — execution, transactions,
- * placeholder style, row-count normalization — is transport-neutral.
- */
-export declare class SqlConnectionResource implements ResourceInstance {
-    readonly driver: SqlDriver;
-    private readonly db;
-    private readonly sqlite?;
-    constructor(driver: SqlDriver, db: Kysely<any>, sqlite?: SqliteDb);
-    init(): Promise<void>;
-    teardown(): Promise<void>;
-    transaction<T>(cb: () => Promise<T>): Promise<T>;
-    execute<T>(sql: string, params?: unknown[], transaction?: SqlTransactionResource): Promise<QueryResult<T>>;
-    get placeholderStyle(): PlaceholderStyle;
-    /** Assemble SQL from literal fragments by interleaving driver-native
-     *  placeholders, then bind `values` positionally. `fragments.length` must
-     *  equal `values.length + 1`. */
-    executeTemplate<T>(fragments: string[], values: unknown[], transaction?: SqlTransactionResource): Promise<QueryResult<T>>;
-    private placeholder;
-    executeScript(sql: string): Promise<void>;
-    toRowCount(result: QueryResult<unknown>): number;
-    get kysely(): Kysely<any>;
-    snapshot(): Record<string, unknown>;
-    private resolveExecutor;
-}
-/**
- * Build a connection from a driver-constructed kysely instance. Driver backends
- * (`sql-postgres`, `sql-sqlite`) own dialect construction and call this; the
- * `sqlite` handle is required only for SQLite (its `executeScript` runs through
- * the native handle).
- */
-export declare function createSqlConnection(driver: SqlDriver, db: Kysely<any>, sqlite?: SqliteDb): SqlConnectionResource;

package/dist/sqlite-driver-interface.d.ts

@@ -1,14 +0,0 @@
-export interface SqliteStatement {
-    readonly reader: boolean;
-    all(params: ReadonlyArray<unknown>): unknown[];
-    run(params: ReadonlyArray<unknown>): {
-        changes: number | bigint;
-        lastInsertRowid: number | bigint;
-    };
-    iterate(params: ReadonlyArray<unknown>): IterableIterator<unknown>;
-}
-export interface SqliteDb {
-    prepare(sql: string): SqliteStatement;
-    exec(sql: string): void;
-    close(): void;
-}

package/dist/sqlite-driver-interface.js

@@ -1 +0,0 @@
-export {};

package/src/sqlite-driver-interface.ts

@@ -1,15 +0,0 @@
-export interface SqliteStatement {
-  readonly reader: boolean;
-  all(params: ReadonlyArray<unknown>): unknown[];
-  run(params: ReadonlyArray<unknown>): {
-    changes: number | bigint;
-    lastInsertRowid: number | bigint;
-  };
-  iterate(params: ReadonlyArray<unknown>): IterableIterator<unknown>;
-}
-
-export interface SqliteDb {
-  prepare(sql: string): SqliteStatement;
-  exec(sql: string): void;
-  close(): void;
-}