@telorun/sql-sqlite 0.2.1 → 0.3.0

package/README.md

@@ -44,146 +44,7 @@ $ telo ./examples/hello-api
 
 ## Example manifest
 
-Here is an example Telo application that defines a simple HTTP API:
-
-```yaml
-kind: Telo.Application
-metadata:
-  name: feedback
-  version: 1.0.0
-  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.12.0
-  Sql: std/sql@0.9.2
-targets:
-  - !ref Migrations
-  - !ref Server
----
-# SQLite database — swap driver/host/database for PostgreSQL with zero YAML changes
-kind: Sql.Connection
-metadata:
-  name: Db
-driver: sqlite
-file: ./tmp/feedback.db
----
-# Migrations: applied automatically before the server starts
-kind: Sql.Migrations
-metadata:
-  name: Migrations
-connection: !ref Db
----
-kind: Sql.Migration
-metadata:
-  name: Migration_20260413_182154_CreateFeedback
-version: 20260413_182154_CreateFeedback
-sql: |
-  CREATE TABLE IF NOT EXISTS feedback (
-    id        INTEGER PRIMARY KEY AUTOINCREMENT,
-    text      TEXT    NOT NULL,
-    source    TEXT,
-    score     INTEGER NOT NULL DEFAULT 0,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-  )
----
-kind: Http.Server
-metadata:
-  name: Server
-baseUrl: http://localhost:8844
-port: 8844
-logger: true
-openapi:
-  info:
-    title: Feedback API
-    version: 1.0.0
-mounts:
-  - path: /v1
-    mount: !ref FeedbackRoutes
----
-kind: Http.Api
-metadata:
-  name: FeedbackRoutes
-routes:
-  # POST /v1/feedback — insert a new entry, score derived from body length heuristic
-  - request:
-      path: /feedback
-      method: POST
-      schema:
-        body:
-          type: object
-          properties:
-            text:
-              type: string
-              minLength: 1
-            source:
-              type: string
-          required: [ text ]
-    handler:
-      kind: Sql.Exec
-      connection: !ref Db
-    inputs:
-      sql: "INSERT INTO feedback (text, source, score) VALUES (?, ?, ?)"
-      bindings:
-        - "${{ request.body.text }}"
-        - "${{ request.body.source }}"
-        - "${{ size(request.body.text) }}"
-    response:
-      - status: 201
-        headers:
-          Content-Type: application/json
-        body:
-          ok: true
-          message: Feedback received
-
-  # GET /v1/feedback — list all entries, newest first
-  - request:
-      path: /feedback
-      method: GET
-    handler:
-      kind: Sql.Select
-      connection: !ref Db
-      from: feedback
-      columns: [ id, text, source, score, created_at ]
-      orderBy:
-        - { column: created_at, direction: desc }
-    response:
-      - status: 200
-        headers:
-          Content-Type: application/json
-        body: "${{ result.rows }}"
-
-  # GET /v1/feedback/{id} — fetch a single entry
-  - request:
-      path: /feedback/{id}
-      method: GET
-      schema:
-        params:
-          type: object
-          properties:
-            id:
-              type: integer
-          required: [ id ]
-    handler:
-      kind: Sql.Select
-      connection: !ref Db
-      from: feedback
-      columns: [ id, text, source, score, created_at ]
-      where:
-        - { column: id, op: "=", value: "${{ request.params.id }}" }
-    response:
-      - status: 200
-        when: "size(result.rows) > 0"
-        headers:
-          Content-Type: application/json
-        body: "${{ result.rows[0] }}"
-      - status: 404
-        headers:
-          Content-Type: application/json
-        body:
-          ok: false
-          message: Not found
-```
+See [examples/](./examples/) for a list of working applications.
 
 ## Status
 

package/dist/connection-controller.d.ts

@@ -1,5 +1,7 @@
 import type { ResourceContext } from "@telorun/sdk";
-import { type SqlConnectionResource } from "@telorun/sql";
+import { SqlConnectionBase } from "@telorun/sql";
+import { Kysely } from "kysely";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 interface SqliteConnectionManifest {
     metadata: {
         name: string;
@@ -8,6 +10,13 @@ interface SqliteConnectionManifest {
     /** File path, or omitted / `:memory:` for an in-memory database. */
     file?: string;
 }
+declare class SqliteConnection extends SqlConnectionBase {
+    private readonly sqlite;
+    constructor(db: Kysely<any>, sqlite: SqliteDb);
+    /** The driver's native multi-statement entry point — kysely binds one
+     *  statement per call. */
+    executeScript(sql: string): Promise<void>;
+}
 export declare function register(): void;
-export declare function create(resource: SqliteConnectionManifest, _ctx: ResourceContext): Promise<SqlConnectionResource>;
+export declare function create(resource: SqliteConnectionManifest, _ctx: ResourceContext): Promise<SqliteConnection>;
 export {};

package/dist/connection-controller.js

@@ -1,5 +1,26 @@
-import { createSqlConnection } from "@telorun/sql";
+import { quoteAnsiIdentifier, SqlConnectionBase } from "@telorun/sql";
 import { Kysely, SqliteAdapter, SqliteDialect } from "kysely";
+const sqliteDialect = {
+    placeholderStyle: "qmark",
+    quoteIdentifier: quoteAnsiIdentifier,
+    // SQLite has no array type, so set membership expands to one placeholder per
+    // element.
+    renderIn(column, values, addParam) {
+        return `${column} IN (${values.map((value) => addParam(value)).join(", ")})`;
+    },
+};
+class SqliteConnection extends SqlConnectionBase {
+    sqlite;
+    constructor(db, sqlite) {
+        super(db, sqliteDialect);
+        this.sqlite = sqlite;
+    }
+    /** The driver's native multi-statement entry point — kysely binds one
+     *  statement per call. */
+    async executeScript(sql) {
+        this.sqlite.exec(sql);
+    }
+}
 // 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
@@ -42,5 +63,5 @@ export async function create(resource, _ctx) {
     const db = new Kysely({
         dialect: new TransactionalSqliteDialect({ database: sqlite }),
     });
-    return createSqlConnection("sqlite", db, sqlite);
+    return new SqliteConnection(db, sqlite);
 }

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

@@ -1,2 +1,2 @@
-import type { SqliteDb } from "@telorun/sql";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 export declare function openDatabase(file: string): SqliteDb;

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

@@ -0,0 +1,14 @@
+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

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

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

@@ -1,2 +1,2 @@
-import type { SqliteDb } from "@telorun/sql";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 export declare function openDatabase(file: string): SqliteDb;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/sql-sqlite",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Telo SqlSqlite.Connection — SQLite backend for the Sql.Connection abstract (better-sqlite3 / bun:sqlite, transactional DDL).",
   "keywords": [
     "telo",
@@ -36,14 +36,14 @@
   "dependencies": {
     "better-sqlite3": "^12.8.0",
     "kysely": "^0.28.15",
-    "@telorun/sql": "0.8.0"
+    "@telorun/sql": "0.10.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.0.0",
     "@types/bun": "^1.3.10",
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
-    "@telorun/sdk": "0.34.0"
+    "@telorun/sdk": "0.58.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/connection-controller.ts

@@ -1,6 +1,7 @@
 import type { ResourceContext } from "@telorun/sdk";
-import { createSqlConnection, type SqlConnectionResource, type SqliteDb } from "@telorun/sql";
+import { quoteAnsiIdentifier, SqlConnectionBase, type SqlDialect } from "@telorun/sql";
 import { Kysely, SqliteAdapter, SqliteDialect } from "kysely";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 
 interface SqliteConnectionManifest {
   metadata: { name: string; module: string };
@@ -8,6 +9,31 @@ interface SqliteConnectionManifest {
   file?: string;
 }
 
+const sqliteDialect: SqlDialect = {
+  placeholderStyle: "qmark",
+  quoteIdentifier: quoteAnsiIdentifier,
+  // SQLite has no array type, so set membership expands to one placeholder per
+  // element.
+  renderIn(column, values, addParam) {
+    return `${column} IN (${values.map((value) => addParam(value)).join(", ")})`;
+  },
+};
+
+class SqliteConnection extends SqlConnectionBase {
+  constructor(
+    db: Kysely<any>,
+    private readonly sqlite: SqliteDb,
+  ) {
+    super(db, sqliteDialect);
+  }
+
+  /** The driver's native multi-statement entry point — kysely binds one
+   *  statement per call. */
+  override async executeScript(sql: string): Promise<void> {
+    this.sqlite.exec(sql);
+  }
+}
+
 // 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
@@ -53,10 +79,10 @@ export function register(): void {}
 export async function create(
   resource: SqliteConnectionManifest,
   _ctx: ResourceContext,
-): Promise<SqlConnectionResource> {
+): Promise<SqliteConnection> {
   const sqlite = await openSqliteDatabase(resource.file ?? ":memory:");
   const db = new Kysely<any>({
     dialect: new TransactionalSqliteDialect({ database: sqlite }),
   });
-  return createSqlConnection("sqlite", db, sqlite);
+  return new SqliteConnection(db, sqlite);
 }

package/src/sqlite-driver-bun.ts

@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import type { SqliteDb } from "@telorun/sql";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 
 export function openDatabase(file: string): SqliteDb {
   const db = new Database(file);

package/src/sqlite-driver-interface.ts

@@ -0,0 +1,15 @@
+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/src/sqlite-driver-node.ts

@@ -1,5 +1,5 @@
 import Database from "better-sqlite3";
-import type { SqliteDb } from "@telorun/sql";
+import type { SqliteDb } from "./sqlite-driver-interface.js";
 
 export function openDatabase(file: string): SqliteDb {
   const db = new Database(file);