@zintrust/db-d1 0.1.8

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export interface ID1Database {
+    prepare(sql: string): {
+        bind(...values: unknown[]): {
+            all<T = unknown>(): Promise<{
+                results?: T[];
+                success: boolean;
+                error?: string;
+            }>;
+            first<T = unknown>(): Promise<T | null>;
+            run(): Promise<{
+                success: boolean;
+                error?: string;
+            }>;
+        };
+    };
+}
+export type DatabaseConfig = {
+    d1?: ID1Database;
+    driver: 'sqlite' | 'postgresql' | 'mysql' | 'sqlserver' | 'd1';
+    database?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+    readHosts?: string[];
+};
+export type QueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+};
+export interface IDatabaseAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query(sql: string, parameters: unknown[]): Promise<QueryResult>;
+    queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null>;
+    ping(): Promise<void>;
+    transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T>;
+    rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    getType(): string;
+    isConnected(): boolean;
+    getPlaceholder(index: number): string;
+}
+export declare const D1Adapter: Readonly<{
+    create: (config: DatabaseConfig) => IDatabaseAdapter;
+}>;
+export default D1Adapter;

package/dist/index.js

@@ -0,0 +1,107 @@
+import { Cloudflare, ErrorFactory, FeatureFlags, Logger, QueryBuilder } from '@zintrust/core';
+function getD1Binding(config) {
+    return Cloudflare.getD1Binding(config);
+}
+function ensureConnected(state) {
+    if (!state.connected)
+        throw ErrorFactory.createConnectionError('Database not connected');
+}
+function requireD1(config) {
+    const db = getD1Binding(config);
+    if (db === null)
+        throw ErrorFactory.createConfigError('D1 database binding not found');
+    return db;
+}
+async function queryD1(config, sql, parameters) {
+    const db = requireD1(config);
+    try {
+        const stmt = db.prepare(sql);
+        const result = await stmt.bind(...parameters).all();
+        const rows = result.results ?? [];
+        return { rows, rowCount: rows.length };
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError(`D1 query failed: ${sql}`, error);
+    }
+}
+async function queryOneD1(config, sql, parameters) {
+    const db = requireD1(config);
+    try {
+        const stmt = db.prepare(sql);
+        const result = await stmt.bind(...parameters).first();
+        return result ?? null;
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError(`D1 queryOne failed: ${sql}`, error);
+    }
+}
+async function pingD1(config) {
+    const db = requireD1(config);
+    try {
+        await db.prepare(QueryBuilder.create('').select('1').toSQL()).bind().first();
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('D1 ping failed', error);
+    }
+}
+async function rawQueryD1(config, sql, parameters) {
+    if (!FeatureFlags.isRawQueryEnabled()) {
+        throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
+    }
+    const db = requireD1(config);
+    try {
+        Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
+        const stmt = db.prepare(sql);
+        const result = await stmt.bind(...(parameters ?? [])).all();
+        return result.results ?? [];
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError(`Raw SQL query failed: ${sql}`, error);
+    }
+}
+function createD1Adapter(config) {
+    const state = { connected: false, config };
+    const adapter = {
+        connect: async () => {
+            state.connected = true;
+            Logger.info('✓ D1 connected');
+        },
+        disconnect: async () => {
+            state.connected = false;
+            Logger.info('✓ D1 disconnected');
+        },
+        query: async (sql, parameters) => {
+            ensureConnected(state);
+            return queryD1(state.config, sql, parameters);
+        },
+        queryOne: async (sql, parameters) => {
+            ensureConnected(state);
+            return queryOneD1(state.config, sql, parameters);
+        },
+        ping: async () => {
+            ensureConnected(state);
+            return pingD1(state.config);
+        },
+        transaction: async (callback) => {
+            ensureConnected(state);
+            try {
+                return await callback(adapter);
+            }
+            catch (error) {
+                throw ErrorFactory.createTryCatchError('Transaction failed', error);
+            }
+        },
+        getType: () => 'd1',
+        isConnected: () => state.connected,
+        rawQuery: async (sql, parameters) => {
+            ensureConnected(state);
+            return rawQueryD1(state.config, sql, parameters);
+        },
+        getPlaceholder: (_index) => '?',
+    };
+    return adapter;
+}
+export const D1Adapter = Object.freeze({
+    create: (config) => createD1Adapter(config),
+});
+export default D1Adapter;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type Registry = {
+    register: (driver: string, factory: (cfg: unknown) => unknown) => void;
+};
+export declare function registerD1Adapter(registry: Registry): void;
+export {};

package/dist/register.js

@@ -0,0 +1,8 @@
+import { D1Adapter } from './index.js';
+export function registerD1Adapter(registry) {
+    registry.register('d1', (config) => D1Adapter.create(config));
+}
+const core = (await import('@zintrust/core'));
+if (core.DatabaseAdapterRegistry !== undefined) {
+    registerD1Adapter(core.DatabaseAdapterRegistry);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zintrust/db-d1",
+  "version": "0.1.8",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}