@telorun/sql 0.5.1 → 0.6.0

package/README.md

@@ -54,20 +54,13 @@ metadata:
   description: |
     A complete feedback collection REST API — no code, pure YAML.
     Persists entries to SQLite and serves them over HTTP.
+imports:
+  Http: std/http-server@0.8.0
+  Sql: std/sql@0.5.1
 targets:
   - Migrations
   - Server
 ---
-kind: Telo.Import
-metadata:
-  name: Http
-source: std/http-server@0.5.0
----
-kind: Telo.Import
-metadata:
-  name: Sql
-source: std/sql@0.3.0
----
 # SQLite database — swap driver/host/database for PostgreSQL with zero YAML changes
 kind: Sql.Connection
 metadata:
@@ -127,7 +120,7 @@ routes:
               minLength: 1
             source:
               type: string
-          required: [text]
+          required: [ text ]
     handler:
       kind: Sql.Exec
       connection:
@@ -157,7 +150,7 @@ routes:
         kind: Sql.Connection
         name: Db
       from: feedback
-      columns: [id, text, source, score, created_at]
+      columns: [ id, text, source, score, created_at ]
       orderBy:
         - { column: created_at, direction: desc }
     response:
@@ -176,14 +169,14 @@ routes:
           properties:
             id:
               type: integer
-          required: [id]
+          required: [ id ]
     handler:
       kind: Sql.Select
       connection:
         kind: Sql.Connection
         name: Db
       from: feedback
-      columns: [id, text, source, score, created_at]
+      columns: [ id, text, source, score, created_at ]
       where:
         - { column: id, op: "=", value: "${{ request.params.id }}" }
     response:

package/dist/sql-connection-controller.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "crypto";
-import { CompiledQuery, Kysely, PostgresDialect, SqliteDialect, } from "kysely";
+import { CompiledQuery, Kysely, PostgresDialect, SqliteAdapter, SqliteDialect, } from "kysely";
 import { Pool } from "pg";
 import { currentTxId, deleteTx, getTx, setTx, txStorage } from "./transaction-store.js";
 export class SqlConnectionResource {
@@ -31,7 +31,7 @@ export class SqlConnectionResource {
             }
             this.sqlite = sqlite;
             this.db = new Kysely({
-                dialect: new SqliteDialect({
+                dialect: new TransactionalSqliteDialect({
                     database: this.sqlite,
                 }),
             });
@@ -94,6 +94,20 @@ export class SqlConnectionResource {
         return this.db;
     }
 }
+// Kysely's stock SQLite adapter reports `supportsTransactionalDdl = false`, so
+// its Migrator runs migrations without a transaction. SQLite does support
+// transactional DDL, so we flip the flag — letting the Migrator wrap the whole
+// migration batch in a single transaction, matching PostgreSQL.
+class TransactionalSqliteAdapter extends SqliteAdapter {
+    get supportsTransactionalDdl() {
+        return true;
+    }
+}
+class TransactionalSqliteDialect extends SqliteDialect {
+    createAdapter() {
+        return new TransactionalSqliteAdapter();
+    }
+}
 export function register() { }
 export async function create(resource, ctx) {
     const sqlite = driverFromConnectionString(resource.connectionString) === "sqlite"

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

@@ -1,11 +1,16 @@
 import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
 import type { SqlConnectionResource } from "./sql-connection-controller.js";
+interface MigrationEntry {
+    statement?: string;
+    statements?: string[];
+}
 interface SqlMigrationsManifest {
     metadata: {
         name: string;
         module: string;
     };
     connection: SqlConnectionResource;
+    migrations?: Record<string, MigrationEntry>;
 }
 declare class SqlMigrationsResource implements ResourceInstance {
     private readonly manifest;

package/dist/sql-migrations-controller.js

@@ -1,16 +1,24 @@
 import { CompiledQuery, Migrator, } from "kysely";
 import { resolveSqlConnection } from "./sql-connection-ref.js";
+function entryStatements(entry) {
+    return entry.statements ?? (entry.statement != null ? [entry.statement] : []);
+}
 class TeloMigrationProvider {
     migrations;
     constructor(migrations) {
         this.migrations = migrations;
     }
     async getMigrations() {
-        return Object.fromEntries(this.migrations.map((m) => [
-            m.name,
+        return Object.fromEntries(Object.entries(this.migrations).map(([name, statements]) => [
+            name,
             {
+                // Each statement runs as its own prepared statement on the migration
+                // transaction's connection, so a migration may hold multiple
+                // statements while the whole batch stays a single transaction.
                 async up(db) {
-                    await db.executeQuery(CompiledQuery.raw(m.sql));
+                    for (const statement of statements) {
+                        await db.executeQuery(CompiledQuery.raw(statement));
+                    }
                 },
             },
         ]));
@@ -25,17 +33,23 @@ class SqlMigrationsResource {
     }
     async run() {
         const conn = resolveSqlConnection(this.manifest.connection, this.ctx) ?? failMissingConnection();
-        const migrations = [];
+        const migrations = {};
+        // Legacy: standalone `Sql.Migration` resources in the same module scope.
         for (const [, { resource }] of this.ctx.moduleContext.resourceInstances) {
             if (resource.kind === "Sql.Migration") {
                 const version = (resource.version ?? resource.metadata.name);
-                migrations.push({
-                    name: version,
-                    sql: resource.sql,
-                });
+                migrations[version] = [resource.sql];
+            }
+        }
+        // Preferred: the keyed `migrations` map on this resource.
+        for (const [name, entry] of Object.entries(this.manifest.migrations ?? {})) {
+            const statements = entryStatements(entry);
+            if (statements.length === 0) {
+                throw new Error(`Sql.Migrations: migration '${name}' has no statement(s) — ` +
+                    `set 'statement' or a non-empty 'statements'`);
             }
+            migrations[name] = statements;
         }
-        migrations.sort((a, b) => a.name.localeCompare(b.name));
         const migrator = new Migrator({
             db: conn.kysely,
             provider: new TeloMigrationProvider(migrations),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/sql",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Telo SQL module - SQL database resource kinds for Telo manifests.",
   "keywords": [
     "telo",
@@ -70,7 +70,7 @@
     "@types/node": "^20.0.0",
     "@types/pg": "^8.0.0",
     "typescript": "^5.0.0",
-    "@telorun/sdk": "0.16.0"
+    "@telorun/sdk": "0.19.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/sql-connection-controller.ts

@@ -4,6 +4,7 @@ import {
   CompiledQuery,
   Kysely,
   PostgresDialect,
+  SqliteAdapter,
   SqliteDialect,
   type QueryResult,
   type Transaction,
@@ -58,7 +59,7 @@ export class SqlConnectionResource implements ResourceInstance {
       }
       this.sqlite = sqlite;
       this.db = new Kysely({
-        dialect: new SqliteDialect({
+        dialect: new TransactionalSqliteDialect({
           database: this.sqlite,
         }),
       });
@@ -139,6 +140,22 @@ export class SqlConnectionResource implements ResourceInstance {
   }
 }
 
+// Kysely's stock SQLite adapter reports `supportsTransactionalDdl = false`, so
+// its Migrator runs migrations without a transaction. SQLite does support
+// transactional DDL, so we flip the flag — letting the Migrator wrap the whole
+// migration batch in a single transaction, matching PostgreSQL.
+class TransactionalSqliteAdapter extends SqliteAdapter {
+  override get supportsTransactionalDdl(): boolean {
+    return true;
+  }
+}
+
+class TransactionalSqliteDialect extends SqliteDialect {
+  override createAdapter(): SqliteAdapter {
+    return new TransactionalSqliteAdapter();
+  }
+}
+
 export function register(): void {}
 
 export async function create(

package/src/sql-migrations-controller.ts

@@ -9,26 +9,38 @@ import {
 import type { SqlConnectionResource } from "./sql-connection-controller.js";
 import { resolveSqlConnection } from "./sql-connection-ref.js";
 
+// A migration entry is one statement or an ordered list of statements; both
+// forms normalize to a non-empty array of single statements.
+interface MigrationEntry {
+  statement?: string;
+  statements?: string[];
+}
+
 interface SqlMigrationsManifest {
   metadata: { name: string; module: string };
   connection: SqlConnectionResource;
+  migrations?: Record<string, MigrationEntry>;
 }
 
-interface MigrationEntry {
-  name: string;
-  sql: string;
+function entryStatements(entry: MigrationEntry): string[] {
+  return entry.statements ?? (entry.statement != null ? [entry.statement] : []);
 }
 
 class TeloMigrationProvider implements MigrationProvider {
-  constructor(private readonly migrations: MigrationEntry[]) {}
+  constructor(private readonly migrations: Record<string, string[]>) {}
 
   async getMigrations(): Promise<Record<string, Migration>> {
     return Object.fromEntries(
-      this.migrations.map((m) => [
-        m.name,
+      Object.entries(this.migrations).map(([name, statements]) => [
+        name,
         {
+          // Each statement runs as its own prepared statement on the migration
+          // transaction's connection, so a migration may hold multiple
+          // statements while the whole batch stays a single transaction.
           async up(db: Kysely<any>): Promise<void> {
-            await db.executeQuery(CompiledQuery.raw(m.sql));
+            for (const statement of statements) {
+              await db.executeQuery(CompiledQuery.raw(statement));
+            }
           },
         },
       ]),
@@ -46,17 +58,25 @@ class SqlMigrationsResource implements ResourceInstance {
     const conn =
       resolveSqlConnection(this.manifest.connection, this.ctx) ?? failMissingConnection();
 
-    const migrations: MigrationEntry[] = [];
+    const migrations: Record<string, string[]> = {};
+    // Legacy: standalone `Sql.Migration` resources in the same module scope.
     for (const [, { resource }] of this.ctx.moduleContext.resourceInstances) {
       if (resource.kind === "Sql.Migration") {
         const version = (resource.version ?? resource.metadata.name) as string;
-        migrations.push({
-          name: version,
-          sql: resource.sql as string,
-        });
+        migrations[version] = [resource.sql as string];
+      }
+    }
+    // Preferred: the keyed `migrations` map on this resource.
+    for (const [name, entry] of Object.entries(this.manifest.migrations ?? {})) {
+      const statements = entryStatements(entry);
+      if (statements.length === 0) {
+        throw new Error(
+          `Sql.Migrations: migration '${name}' has no statement(s) — ` +
+            `set 'statement' or a non-empty 'statements'`,
+        );
       }
+      migrations[name] = statements;
     }
-    migrations.sort((a, b) => a.name.localeCompare(b.name));
 
     const migrator = new Migrator({
       db: conn.kysely,