@telorun/sql 0.1.1 → 0.1.3

package/src/sql-connection-controller.ts

@@ -0,0 +1,169 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import { randomUUID } from "crypto";
+import {
+  CompiledQuery,
+  Kysely,
+  PostgresDialect,
+  SqliteDialect,
+  type QueryResult,
+  type Transaction,
+} from "kysely";
+import { Pool } from "pg";
+import type { SqlTransactionResource } from "./sql-transaction-controller.js";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
+import { currentTxId, deleteTx, getTx, setTx, txStorage } from "./transaction-store.js";
+
+interface PoolConfig {
+  min?: number;
+  max?: number;
+  idleTimeoutMs?: number;
+  connectionTimeoutMs?: number;
+}
+
+interface SqlConnectionManifest {
+  metadata: { name: string; module: string };
+  driver: "postgres" | "sqlite";
+  connectionString?: string;
+  host?: string;
+  port?: number;
+  database?: string;
+  user?: string;
+  password?: string;
+  ssl?: boolean;
+  file?: string;
+  pool?: PoolConfig;
+}
+
+export type SqlDriver = SqlConnectionManifest["driver"];
+
+export class SqlConnectionResource implements ResourceInstance {
+  readonly driver: SqlDriver;
+  private readonly db: Kysely<any>;
+  private readonly sqlite?: SqliteDb;
+
+  constructor(m: SqlConnectionManifest, sqlite?: SqliteDb) {
+    this.driver = m.driver;
+
+    if (m.driver === "postgres") {
+      this.db = new Kysely({
+        dialect: new PostgresDialect({
+          pool: new Pool({
+            ...(m.connectionString
+              ? { connectionString: m.connectionString }
+              : { host: m.host, port: m.port ?? 5432, database: m.database, user: m.user, password: m.password }),
+            ssl: m.ssl ? { rejectUnauthorized: false } : false,
+            min: m.pool?.min ?? 1,
+            max: m.pool?.max ?? 10,
+            idleTimeoutMillis: m.pool?.idleTimeoutMs,
+            connectionTimeoutMillis: m.pool?.connectionTimeoutMs,
+          }),
+        }),
+      });
+    } else if (m.driver === "sqlite") {
+      if (!sqlite) {
+        throw new Error("Sql: sqlite database was not initialized");
+      }
+      this.sqlite = sqlite;
+      this.db = new Kysely({
+        dialect: new SqliteDialect({
+          database: this.sqlite,
+        }),
+      });
+    } else {
+      throw new Error("Invalid SQL Connection driver");
+    }
+  }
+
+  async init() {
+    await this.db.connection().execute(async () => {
+      // just checking
+    });
+  }
+
+  async teardown(): Promise<void> {
+    await this.db.destroy();
+  }
+
+  async transaction<T>(cb: () => Promise<T>): Promise<T> {
+    const txId = randomUUID();
+
+    return this.db.transaction().execute(async (trx: Transaction<any>) => {
+      setTx(txId, { executor: trx });
+      try {
+        return await txStorage.run(txId, cb);
+      } finally {
+        deleteTx(txId);
+      }
+    });
+  }
+
+  async execute<T>(
+    sql: string,
+    params: unknown[] = [],
+    transaction?: SqlTransactionResource,
+  ): Promise<QueryResult<T>> {
+    const executor = this.resolveExecutor(transaction);
+    return executor.executeQuery<T>(CompiledQuery.raw(sql, params));
+  }
+
+  async executeScript(sql: string): Promise<void> {
+    if (this.driver === "sqlite") {
+      this.sqlite?.exec(sql);
+      return;
+    }
+
+    await this.execute(sql);
+  }
+
+  toRowCount(result: QueryResult<unknown>): number {
+    if (result.numAffectedRows !== undefined) {
+      return Number(result.numAffectedRows);
+    }
+
+    return result.rows.length;
+  }
+
+  get kysely(): Kysely<any> {
+    return this.db;
+  }
+
+  snapshot(): Record<string, unknown> {
+    return {};
+  }
+
+  private resolveExecutor(transaction?: SqlTransactionResource): Kysely<any> {
+    if (transaction) {
+      transaction.assertActive();
+    }
+
+    const txId = currentTxId();
+    if (txId) {
+      const entry = getTx(txId);
+      if (entry) {
+        return entry.executor as Kysely<any>;
+      }
+    }
+
+    return this.db;
+  }
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: SqlConnectionManifest,
+  ctx: ResourceContext,
+): Promise<SqlConnectionResource> {
+  const sqlite = resource.driver === "sqlite" ? await openSqliteDatabase(resource.file) : undefined;
+  return new SqlConnectionResource(resource, sqlite);
+}
+
+async function openSqliteDatabase(file = ":memory:"): Promise<SqliteDb> {
+  if (typeof Bun !== "undefined") {
+    const { openDatabase } = await import("./sqlite-driver-bun.js");
+    return openDatabase(file);
+  }
+
+  const { openDatabase } = await import("./sqlite-driver-node.js");
+  return openDatabase(file);
+}

package/src/sql-connection-ref.ts

@@ -0,0 +1,25 @@
+import type { ResourceContext } from "@telorun/sdk";
+import type { SqlConnectionResource } from "./sql-connection-controller.js";
+
+interface ConnectionRef {
+  name: string;
+}
+
+export function resolveSqlConnection(
+  value: SqlConnectionResource | ConnectionRef | undefined,
+  ctx: ResourceContext,
+): SqlConnectionResource | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (typeof (value as SqlConnectionResource).execute === "function") {
+    return value as SqlConnectionResource;
+  }
+
+  if (typeof (value as ConnectionRef).name !== "string") {
+    throw new Error("Sql: invalid connection reference");
+  }
+
+  return ctx.moduleContext.getInstance((value as ConnectionRef).name) as SqlConnectionResource;
+}

package/src/sql-exec-controller.ts

@@ -0,0 +1,54 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import type { SqlConnectionResource } from "./sql-connection-controller.js";
+import { resolveSqlConnection } from "./sql-connection-ref.js";
+import type { SqlResult } from "./sql-query-controller.js";
+import type { SqlTransactionResource } from "./sql-transaction-controller.js";
+
+interface SqlExecManifest {
+  metadata: { name: string; module: string };
+  connection?: SqlConnectionResource;
+  transaction?: SqlTransactionResource;
+  inputs: {
+    sql: string;
+    bindings?: unknown[];
+  };
+}
+
+class SqlExecResource implements ResourceInstance {
+  constructor(
+    private readonly manifest: SqlExecManifest,
+    private readonly ctx: ResourceContext,
+  ) {}
+
+  async invoke(input: any): Promise<SqlResult> {
+    const m = this.manifest;
+    const ctx = this.ctx;
+    const expandedInput = ctx.expandValue(input, {});
+
+    const connection = resolveSqlConnection(m.connection, ctx) ?? m.transaction?.getConnection();
+    if (!connection) {
+      throw new Error("Sql: either 'connection' or 'transaction' must be set");
+    }
+
+    return runExec(connection, m.transaction, expandedInput.sql, expandedInput.bindings ?? []);
+  }
+}
+
+async function runExec(
+  connection: SqlConnectionResource,
+  transaction: SqlTransactionResource | undefined,
+  sql: string,
+  params: unknown[],
+): Promise<SqlResult> {
+  const result = await connection.execute<Record<string, unknown>>(sql, params, transaction);
+  return { rows: result.rows, rowCount: connection.toRowCount(result) };
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: SqlExecManifest,
+  ctx: ResourceContext,
+): Promise<SqlExecResource> {
+  return new SqlExecResource(resource, ctx);
+}

package/src/sql-migration-controller.ts

@@ -0,0 +1,20 @@
+import type { ResourceInstance } from "@telorun/sdk";
+
+interface SqlMigrationManifest {
+  metadata: { name: string; module: string };
+  sql: string;
+}
+
+class SqlMigrationResource implements ResourceInstance {
+  constructor(readonly manifest: SqlMigrationManifest) {}
+
+  snapshot(): Record<string, unknown> {
+    return {};
+  }
+}
+
+export function register(): void {}
+
+export async function create(resource: SqlMigrationManifest): Promise<SqlMigrationResource> {
+  return new SqlMigrationResource(resource);
+}

package/src/sql-migrations-controller.ts

@@ -0,0 +1,85 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import {
+  CompiledQuery,
+  Migrator,
+  type Kysely,
+  type Migration,
+  type MigrationProvider,
+} from "kysely";
+import type { SqlConnectionResource } from "./sql-connection-controller.js";
+import { resolveSqlConnection } from "./sql-connection-ref.js";
+
+interface SqlMigrationsManifest {
+  metadata: { name: string; module: string };
+  connection: SqlConnectionResource;
+}
+
+interface MigrationEntry {
+  name: string;
+  sql: string;
+}
+
+class TeloMigrationProvider implements MigrationProvider {
+  constructor(private readonly migrations: MigrationEntry[]) {}
+
+  async getMigrations(): Promise<Record<string, Migration>> {
+    return Object.fromEntries(
+      this.migrations.map((m) => [
+        m.name,
+        {
+          async up(db: Kysely<any>): Promise<void> {
+            await db.executeQuery(CompiledQuery.raw(m.sql));
+          },
+        },
+      ]),
+    );
+  }
+}
+
+class SqlMigrationsResource implements ResourceInstance {
+  constructor(
+    private readonly manifest: SqlMigrationsManifest,
+    private readonly ctx: ResourceContext,
+  ) {}
+
+  async run(): Promise<void> {
+    const conn =
+      resolveSqlConnection(this.manifest.connection, this.ctx) ?? failMissingConnection();
+
+    const migrations: MigrationEntry[] = [];
+    for (const [, { resource }] of this.ctx.moduleContext.resourceInstances) {
+      if (resource.kind === "Sql.Migration") {
+        migrations.push({
+          name: resource.metadata.name as string,
+          sql: resource.sql as string,
+        });
+      }
+    }
+    migrations.sort((a, b) => a.name.localeCompare(b.name));
+
+    const migrator = new Migrator({
+      db: conn.kysely,
+      provider: new TeloMigrationProvider(migrations),
+      migrationTableName: "migrations",
+      migrationLockTableName: "migration_locks",
+    });
+
+    const { error } = await migrator.migrateToLatest();
+    if (error) {
+      throw error;
+    }
+  }
+}
+
+function failMissingConnection(): never {
+  throw new Error("Sql.Migrations: missing connection");
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: SqlMigrationsManifest,
+  ctx: ResourceContext,
+): Promise<SqlMigrationsResource> {
+  return new SqlMigrationsResource(resource, ctx);
+}

package/src/sql-query-controller.ts

@@ -0,0 +1,68 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import type { SqlConnectionResource } from "./sql-connection-controller.js";
+import { resolveSqlConnection } from "./sql-connection-ref.js";
+import type { SqlTransactionResource } from "./sql-transaction-controller.js";
+
+interface SqlQueryManifest {
+  metadata: { name: string; module: string };
+  connection?: SqlConnectionResource;
+  transaction?: SqlTransactionResource;
+  inputs: {
+    sql: string;
+    bindings?: unknown[];
+  };
+}
+
+export interface SqlResult {
+  rows: Record<string, unknown>[];
+  rowCount: number;
+}
+
+class SqlQueryResource implements ResourceInstance {
+  constructor(
+    private readonly manifest: SqlQueryManifest,
+    private readonly ctx: ResourceContext,
+  ) {}
+
+  async invoke(input: unknown): Promise<SqlResult> {
+    const m = this.manifest;
+    const ctx = this.ctx;
+    const expandedInput = ctx.expandValue(input, {});
+
+    const connection = resolveConnection(m.connection, m.transaction, ctx);
+    return runQuery(connection, m.transaction, expandedInput.sql, expandedInput.bindings);
+  }
+}
+
+function resolveConnection(
+  connection: SqlConnectionResource | undefined,
+  transaction: SqlTransactionResource | undefined,
+  ctx: ResourceContext,
+): SqlConnectionResource {
+  return (
+    resolveSqlConnection(connection, ctx) ?? transaction?.getConnection() ?? failMissingConnection()
+  );
+}
+
+async function runQuery(
+  connection: SqlConnectionResource,
+  transaction: SqlTransactionResource | undefined,
+  sql: string,
+  params: unknown[],
+): Promise<SqlResult> {
+  const result = await connection.execute<Record<string, unknown>>(sql, params, transaction);
+  return { rows: result.rows, rowCount: result.rows.length };
+}
+
+function failMissingConnection(): never {
+  throw new Error("Sql: either 'connection' or 'transaction' must be set");
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: SqlQueryManifest,
+  ctx: ResourceContext,
+): Promise<SqlQueryResource> {
+  return new SqlQueryResource(resource, ctx);
+}