cogsbox-shape 0.5.206 → 0.5.207

package/README.md

@@ -469,6 +469,22 @@ const user = await userView.findById(1);
 // user.posts is loaded and validated as part of the view shape
 ```
 
+Cloudflare D1 uses the same SQLite schema dialect with a D1 connection helper:
+
+```typescript
+import { connect } from "cogsbox-shape/db";
+import { createD1Db } from "cogsbox-shape/db/cloudflare-d1";
+
+export default {
+  async fetch(_request, env) {
+    const db = createD1Db(env.DB);
+    const bx = connect(box, db);
+
+    return Response.json(await bx.users.findMany());
+  },
+};
+```
+
 Use `insert(data).ids()` when you only need the database identity, or `insert(data).full()` when you want optimistic client IDs reconciled back into the submitted client object. `create()` is kept as an alias for older code; prefer `insert()` in new code.
 
 ### 5. Nested Defaults and Form Definitions (`defaultsDefinition`)

package/cogsbox-shape-db/dist/cloudflare-d1/d1-driver.d.ts

@@ -0,0 +1,29 @@
+import { Kysely } from "kysely";
+import type { DatabaseIntrospector, Dialect, DialectAdapter, Driver, QueryCompiler } from "kysely";
+export interface D1Result<T = Record<string, unknown>> {
+    success: boolean;
+    error?: string;
+    results?: T[];
+    meta?: {
+        changes?: number;
+        last_row_id?: number;
+        rows_written?: number;
+    };
+}
+export interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    all<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+    run<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+}
+export interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+}
+export declare class D1Dialect implements Dialect {
+    #private;
+    constructor(database: D1Database);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+export declare function createD1Db<TDb = unknown>(database: D1Database): Kysely<TDb>;

package/cogsbox-shape-db/dist/cloudflare-d1/d1-driver.js

@@ -0,0 +1,100 @@
+import { CompiledQuery, Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+export class D1Dialect {
+    #database;
+    constructor(database) {
+        this.#database = database;
+    }
+    createDriver() {
+        return new D1Driver(this.#database);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}
+export function createD1Db(database) {
+    return new Kysely({
+        dialect: new D1Dialect(database),
+    });
+}
+class D1Driver {
+    #connection;
+    constructor(database) {
+        this.#connection = new D1Connection(database);
+    }
+    async init(_options) {
+        // Cloudflare D1 bindings are already initialized by the Worker runtime.
+    }
+    async acquireConnection(_options) {
+        return this.#connection;
+    }
+    async beginTransaction(connection, _settings) {
+        await connection.executeQuery(CompiledQuery.raw("begin"));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw("commit"));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw("rollback"));
+    }
+    async releaseConnection(_connection, _options) {
+        // D1 exposes a stateless binding instead of pooled connections.
+    }
+    async destroy(_options) {
+        // Nothing to close for a Worker binding.
+    }
+}
+class D1Connection {
+    #database;
+    constructor(database) {
+        this.#database = database;
+    }
+    async executeQuery(compiledQuery) {
+        const statement = this.#prepare(compiledQuery);
+        const result = shouldReturnRows(compiledQuery.sql)
+            ? await statement.all()
+            : await statement.run();
+        assertD1Success(result, compiledQuery.sql);
+        return {
+            insertId: result.meta?.last_row_id != null
+                ? BigInt(result.meta.last_row_id)
+                : undefined,
+            numAffectedRows: affectedRows(result),
+            rows: (result.results ?? []),
+        };
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const result = await this.executeQuery(compiledQuery);
+        for (const row of result.rows) {
+            yield { rows: [row] };
+        }
+    }
+    #prepare(compiledQuery) {
+        const statement = this.#database.prepare(compiledQuery.sql);
+        return compiledQuery.parameters.length > 0
+            ? statement.bind(...compiledQuery.parameters)
+            : statement;
+    }
+}
+function shouldReturnRows(sql) {
+    const trimmed = sql.trim().toLowerCase();
+    return (trimmed.startsWith("select") ||
+        trimmed.startsWith("with") ||
+        trimmed.startsWith("pragma") ||
+        trimmed.startsWith("explain") ||
+        /\breturning\b/i.test(sql));
+}
+function affectedRows(result) {
+    const count = result.meta?.changes ?? result.meta?.rows_written;
+    return count != null ? BigInt(count) : undefined;
+}
+function assertD1Success(result, sql) {
+    if (!result.success) {
+        throw new Error(result.error ?? `D1 query failed: ${sql}`);
+    }
+}

package/cogsbox-shape-db/dist/cloudflare-d1/index.d.ts

@@ -0,0 +1 @@
+export { createD1Db, D1Dialect, type D1Database, type D1PreparedStatement, type D1Result, } from "./d1-driver.js";

package/cogsbox-shape-db/dist/cloudflare-d1/index.js

@@ -0,0 +1 @@
+export { createD1Db, D1Dialect, } from "./d1-driver.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.206",
+  "version": "0.5.207",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,6 +37,11 @@
       "import": "./cogsbox-shape-db/dist/sqlite/index.js",
       "default": "./cogsbox-shape-db/dist/sqlite/index.js"
     },
+    "./db/cloudflare-d1": {
+      "types": "./cogsbox-shape-db/dist/cloudflare-d1/index.d.ts",
+      "import": "./cogsbox-shape-db/dist/cloudflare-d1/index.js",
+      "default": "./cogsbox-shape-db/dist/cloudflare-d1/index.js"
+    },
     "./state": {
       "types": "./cogsbox-shape-state/dist/index.d.ts",
       "import": "./cogsbox-shape-state/dist/index.js",