shokupan 0.13.1 → 0.14.0

package/dist/plugins/application/dashboard/static/tabs.js

@@ -3,8 +3,8 @@ function switchTab(tabId) {
     console.log('Switching to tab:', tabId);
     // Update buttons
     document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
-    // Find the button that was clicked
-    const btn = Array.from(document.querySelectorAll('.tab-btn')).find(b => b.getAttribute('onclick') === `switchTab('${tabId}')`);
+    // Find the button that was clicked using robust data-tab attribute
+    const btn = document.querySelector(`.tab-btn[data-tab="${tabId}"]`);
     if (btn) btn.classList.add('active');
 
     // Update content

package/dist/plugins/application/error-view/index.d.ts

@@ -5,6 +5,31 @@ export interface ErrorViewConfig {
      * Theme for syntax highlighting (default 'dark')
      */
     theme?: 'light' | 'dark';
+    /**
+     * Show the graphical status view instead of the error view if not in development mode.
+     * Default: true
+     */
+    productionStatusView?: boolean;
+    /**
+     * Show the detailed error view if in development mode.
+     * Default: true
+     */
+    developmentErrorView?: boolean;
+    /**
+     * Hide the code snippet from the detailed error view.
+     * Default: false
+     */
+    hideCode?: boolean;
+    /**
+     * Hide the stack trace from the detailed error view.
+     * Default: false
+     */
+    hideStacktrace?: boolean;
+    /**
+     * Hide the error message from the status view.
+     * Default: false
+     */
+    hideErrorMessage?: boolean;
 }
 export declare class ErrorView implements ShokupanPlugin {
     private config;

package/dist/plugins/application/error-view/reason-phrases.d.ts

@@ -0,0 +1 @@
+export declare function getReasonPhrase(status: number): string;

package/dist/plugins/application/openapi/analyzer.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from '../../../util/logger';
 import { ApplicationInstance } from './analyzer.impl';
 export type { ApplicationInstance, RouteInfo } from './analyzer.impl';
 /**
@@ -10,8 +11,9 @@ export type { ApplicationInstance, RouteInfo } from './analyzer.impl';
 export declare class OpenAPIAnalyzer {
     private rootDir;
     private entrypoint?;
+    private logger?;
     private analyzerImpl;
-    constructor(rootDir: string, entrypoint?: string);
+    constructor(rootDir: string, entrypoint?: string, logger?: Logger);
     /**
      * Main analysis entry point.
      * Dynamically imports the implementation and runs the analysis.

package/dist/plugins/application/openapi/analyzer.impl.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from '../../../util/logger';
 /**
  * Route information extracted from AST
  */
@@ -53,7 +54,7 @@ interface DependencyInfo {
 export interface ApplicationInstance {
     name: string;
     filePath: string;
-    className: 'Shokupan' | 'ShokupanRouter' | 'Controller';
+    className: 'Shokupan' | 'ShokupanRouter' | 'Controller' | 'ShokupanWebsocketRouter';
     controllerPrefix?: string;
     routes: RouteInfo[];
     mounted: MountInfo[];
@@ -100,12 +101,13 @@ export interface MiddlewareInfo {
  */
 export declare class OpenAPIAnalyzer {
     private rootDir;
+    private logger?;
     private files;
     private applications;
     private program?;
     private entrypoint?;
     private imports;
-    constructor(rootDir: string, entrypoint?: string);
+    constructor(rootDir: string, entrypoint?: string, logger?: Logger);
     /**
      * Main analysis entry point
      */

package/dist/router.d.ts

@@ -109,6 +109,8 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         blockOnOpenApiGen: boolean;
         enableAsyncApiGen: boolean;
         blockOnAsyncApiGen: boolean;
+        enableAsyncAstScanning?: boolean;
+        astAnalysisTimeout?: number;
         reusePort: boolean;
         controllersOnly: boolean;
         enableTracing?: boolean;
@@ -116,6 +118,8 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         jsonParser?: "native" | "parse-json" | "secure-json-parse";
         autoBackpressureFeedback?: boolean;
         autoBackpressureLevel?: number;
+        enableAutoContentNegotiation?: boolean;
+        defaultResponseTransformer?: string;
         enableMiddlewareTracking: boolean;
         middlewareTrackingMaxCapacity?: number;
         enableHTTPBridge?: boolean;
@@ -123,30 +127,21 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         idGenerator?: () => string;
         middlewareTrackingTTL?: number;
         httpLogger: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void;
-        logger: {
-            verbose: boolean;
-            info: (msg: string, props: Record<string, any>) => void;
-            debug: (msg: string, props: Record<string, any>) => void;
-            warning: (msg: string, props: Record<string, any>) => void;
-            error: (msg: string, props: Record<string, any>) => void;
-            fatal: (msg: string, props: Record<string, any>) => void;
-        };
+        logger: import('./util/logger').Logger;
         readTimeout: number;
         maxBodySize?: number;
         requestTimeout: number;
         writeTimeout: number;
         renderer: JSXRenderer;
         serverFactory: import('.').ServerFactory;
-        adapter?: "bun" | "node" | "wintercg" | import('./util/adapter').ServerAdapter;
+        adapter?: "bun" | "node" | "wintercg" | "h3" | import('./util/adapter').ServerAdapter;
         fileSystem?: import('./util/adapter/filesystem').FileSystemAdapter;
         hooks: ShokupanHooks<Record<string, any>> | ShokupanHooks<Record<string, any>>[];
         validateStatusCodes: boolean;
-        surreal?: {
-            engines?: import('surrealdb').Engines;
-            url?: string;
-            connectOptions?: import('surrealdb').ConnectOptions;
-            namespace?: string;
-            database?: string;
+        surreal?: any;
+        datastore?: {
+            adapter: "surreal" | "sqlite" | "level" | "knex";
+            options?: any;
         };
         aiPlugin?: {
             enabled?: boolean;
@@ -176,8 +171,10 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
             }>;
         };
         defaultSecurityHeaders?: boolean | any;
+        ide?: string;
     }>;
     get root(): Shokupan<any>;
+    get logger(): import('./util/logger').Logger;
     [$routes]: ShokupanRoute[];
     private trie;
     metadata?: RouteMetadata;
@@ -234,10 +231,6 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     };
     constructor(config?: ShokupanRouteConfig);
     private isRouterInstance;
-    /**
-     * Registers an event handler for WebSocket.
-     */
-    event(name: string, handler: ShokupanHandler<T>): this;
     /**
      * Registers a lifecycle hook dynamically.
      */
@@ -271,9 +264,9 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      */
     getEventHandlers(): Map<string, ShokupanHandler<T>[]>;
     /**
-     * Mounts a controller instance to a path prefix.
+     * Mounts a controller instance or WebSocket router to a path prefix.
      *
-     * Controller can be a convection router or an arbitrary class.
+     * Controller can be a convention router, WebSocket router, or an arbitrary class.
      *
      * Routes are derived from method names:
      * - get(ctx) -> GET /prefix/
@@ -281,6 +274,16 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * - postCreate(ctx) -> POST /prefix/create
      */
     mount(prefix: string, controller: ShokupanController | ShokupanController<T> | ShokupanRouter | ShokupanRouter<T> | Record<string, any>): this;
+    /**
+     * Mount a WebSocket router.
+     * @internal
+     */
+    private mountWebSocketRouter;
+    /**
+     * Mount a WebSocket controller (decorated with @WebsocketController).
+     * @internal
+     */
+    private mountWebSocketController;
     /**
      * Returns all routes attached to this router and its descendants.
      */
@@ -454,6 +457,34 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param handlers - Route handler functions
      */
     head<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    /**
+     * Adds a WebSocket route that handles its own upgrade logic.
+     *
+     * Unless you need to handle the upgrade manually, you should use a `ShokupanWebsocketRouter` or `WebsocketController` instead.
+     *
+     * Routes registered with `.socket()` will NOT be automatically upgraded by Shokupan's WebSocket handling. You must implement
+     * all event handlers manually. You have been warned.
+     *
+     * @param path - URL path for the WebSocket endpoint
+     * @param handler - Route handler that will manually handle the upgrade
+     *
+     * @example
+     * ```ts
+     * router.socket("/ws", (ctx) => {
+     *   const success = ctx.upgrade({
+     *     data: {
+     *       handler: {
+     *         open: (ws) => console.log("Connected"),
+     *         message: (ws, msg) => ws.send(msg),
+     *         close: (ws) => console.log("Disconnected")
+     *       }
+     *     }
+     *   });
+     *   if (!success) return ctx.text("Upgrade failed", 400);
+     * });
+     * ```
+     */
+    socket<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>): this;
     /**
      * Adds a guard to the router that applies to all routes added **after** this point.
      * Guards must return true or call `ctx.next()` to allow the request to continue.

package/dist/shokupan.d.ts

@@ -1,9 +1,10 @@
 import { Server } from 'bun';
 import { ShokupanRouter } from './router';
-import { SurrealDatastore } from './util/datastore';
+import { DatastoreAdapter } from './util/adapter/datastore';
 import { ShokupanRequest } from './util/request';
+import { ResponseTransformer, ResponseTransformerRegistry } from './util/response-transformer';
 import { $dispatch } from './util/symbol';
-import { Middleware, ProcessResult, RequestOptions, ShokupanConfig, ShokupanPlugin } from './util/types';
+import { ErrorHandler, Middleware, ProcessResult, RequestOptions, ShokupanConfig, ShokupanPlugin } from './util/types';
 /**
  * Shokupan Application
  *
@@ -80,17 +81,30 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
     private httpServer?;
     private datastore?;
     dbPromise?: Promise<any>;
+    responseTransformerRegistry: ResponseTransformerRegistry;
+    private errorHandlers;
     private rootTrie?;
-    get db(): SurrealDatastore | undefined;
-    get logger(): {
-        verbose: boolean;
-        info: (msg: string, props: Record<string, any>) => void;
-        debug: (msg: string, props: Record<string, any>) => void;
-        warning: (msg: string, props: Record<string, any>) => void;
-        error: (msg: string, props: Record<string, any>) => void;
-        fatal: (msg: string, props: Record<string, any>) => void;
-    };
+    get db(): DatastoreAdapter | undefined;
+    get logger(): import('./util/logger').Logger;
     constructor(applicationConfig?: ShokupanConfig);
+    /**
+     * Register a custom response transformer
+     * @param transformer The transformer to register
+     */
+    registerResponseTransformer(transformer: ResponseTransformer): this;
+    /**
+     * Register a global error handler for a specific error type.
+     * Handlers are checked in reverse order of registration (LIFO).
+     *
+     * @param type The error class constructor (e.g., Error, CustomError)
+     * @param handler The handler function
+     */
+    onStrictError<T>(type: new (...args: any[]) => T, handler: ErrorHandler<T>): this;
+    /**
+     * Set the default response transformer content type
+     * @param contentType The content type to use as default
+     */
+    setDefaultResponseType(contentType: string): this;
     private initDatastore;
     /**
      * Adds middleware to the application.

package/dist/sqlite-CLrcTkti.js

@@ -0,0 +1,180 @@
+import { Database } from "bun:sqlite";
+import { c as createLogger } from "./index-CUNBeZKj.js";
+class SqliteAdapter {
+  constructor(options = {}) {
+    this.options = options;
+    this.db = new Database(options.filename || ":memory:");
+    process.on("exit", async () => {
+      this.db.close();
+    });
+  }
+  name = "sqlite";
+  db;
+  logger = createLogger("sqlite-adapter");
+  tables = /* @__PURE__ */ new Set();
+  async connect() {
+    return;
+  }
+  async disconnect() {
+    this.db.close();
+  }
+  async setupSchema() {
+    const tables = [
+      "failed_requests",
+      "sessions",
+      "users",
+      "idempotency_keys",
+      "middleware_tracking",
+      "requests",
+      "metrics",
+      "idempotency"
+      // 'idempotency' used in plugin.ts but 'idempotency_keys' used elsewhere? Check code. 
+      // The plugin code used `new RecordId('idempotency', key)`, so table name is 'idempotency'.
+      // The shokupan.ts defined 'idempotency_keys'. 
+      // We'll create both or just handle lazily.
+    ];
+    for (const table of tables) {
+      await this.ensureTable(table);
+    }
+  }
+  ensureTable(table) {
+    if (this.tables.has(table)) return;
+    this.db.run(`CREATE TABLE IF NOT EXISTS "${table}" (
+            id TEXT PRIMARY KEY,
+            data JSON,
+            created_at INTEGER,
+            updated_at INTEGER
+        )`);
+    this.tables.add(table);
+  }
+  async get(table, id) {
+    this.ensureTable(table);
+    const stmt = this.db.prepare(`SELECT data FROM "${table}" WHERE id = ?`);
+    const res = stmt.get(id);
+    if (!res || !res.data) return null;
+    try {
+      return JSON.parse(res.data);
+    } catch (e) {
+      return null;
+    }
+  }
+  async create(table, id, data) {
+    this.ensureTable(table);
+    const now = Date.now();
+    const serialized = JSON.stringify(data);
+    try {
+      this.db.run(
+        `INSERT INTO "${table}" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+        [id, serialized, now, now]
+      );
+      return data;
+    } catch (err) {
+      if (err.message.includes("constraint failed")) {
+        throw new Error(`Record ${id} already exists`);
+      }
+      throw err;
+    }
+  }
+  async update(table, id, data) {
+    this.ensureTable(table);
+    const current = await this.get(table, id);
+    if (!current) throw new Error(`Record ${id} does not exist`);
+    const updated = { ...current, ...data };
+    const serialized = JSON.stringify(updated);
+    const now = Date.now();
+    this.db.run(
+      `UPDATE "${table}" SET data = ?, updated_at = ? WHERE id = ?`,
+      [serialized, now, id]
+    );
+    return updated;
+  }
+  async upsert(table, id, data) {
+    this.ensureTable(table);
+    const now = Date.now();
+    const serialized = JSON.stringify(data);
+    this.db.run(
+      `INSERT INTO "${table}" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`,
+      [id, serialized, now, now]
+    );
+    return data;
+  }
+  async delete(table, id) {
+    this.ensureTable(table);
+    this.db.run(`DELETE FROM "${table}" WHERE id = ?`, [id]);
+  }
+  async count(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    const res = this.db.prepare(`SELECT COUNT(*) as count FROM "${table}" ${sql}`).get(...params);
+    return res.count;
+  }
+  async deleteMany(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    if (query?.limit || query?.sort) {
+      const selectQ = this.buildWhere(query);
+      let orderSql = "";
+      if (query.sort) {
+        const parts = Object.entries(query.sort).map(([k, v]) => {
+          return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;
+        });
+        if (parts.length) orderSql = " ORDER BY " + parts.join(", ");
+      }
+      let limitSql = "";
+      if (query.limit) limitSql = ` LIMIT ${query.limit}`;
+      const rows = this.db.prepare(`SELECT id FROM "${table}" ${selectQ.sql} ${orderSql} ${limitSql}`).all(...selectQ.params);
+      if (rows.length === 0) return;
+      const ids = rows.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(",");
+      this.db.run(`DELETE FROM "${table}" WHERE id IN (${placeholders})`, ids);
+    } else {
+      this.db.run(`DELETE FROM "${table}" ${sql}`, params);
+    }
+  }
+  async findMany(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    let orderSql = "";
+    if (query?.sort) {
+      const parts = Object.entries(query.sort).map(([k, v]) => {
+        return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;
+      });
+      if (parts.length) orderSql = " ORDER BY " + parts.join(", ");
+    }
+    let limitSql = "";
+    if (query?.limit) limitSql = ` LIMIT ${query.limit}`;
+    if (query?.offset) limitSql += ` OFFSET ${query.offset}`;
+    const rows = this.db.prepare(`SELECT data FROM "${table}" ${sql} ${orderSql} ${limitSql}`).all(...params);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  buildWhere(query) {
+    if (!query) return { sql: "", params: [] };
+    let clauses = [];
+    let params = [];
+    if (query.where) {
+      Object.entries(query.where).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') = ?`);
+        params.push(v);
+      });
+    }
+    if (query.gt) {
+      Object.entries(query.gt).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') > ?`);
+        params.push(v);
+      });
+    }
+    if (query.lt) {
+      Object.entries(query.lt).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') < ?`);
+        params.push(v);
+      });
+    }
+    if (clauses.length === 0) return { sql: "", params: [] };
+    return { sql: "WHERE " + clauses.join(" AND "), params };
+  }
+}
+export {
+  SqliteAdapter
+};
+//# sourceMappingURL=sqlite-CLrcTkti.js.map

package/dist/sqlite-CLrcTkti.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-CLrcTkti.js","sources":["../src/util/adapter/datastore/sqlite.ts"],"sourcesContent":["import { Database } from 'bun:sqlite';\nimport { createLogger } from '../../logger';\nimport type { DatastoreAdapter, QueryOptions } from '../datastore';\n\nexport class SqliteAdapter implements DatastoreAdapter {\n    name = 'sqlite';\n    private db: Database;\n    private logger = createLogger('sqlite-adapter');\n    private tables = new Set<string>();\n\n    constructor(\n        private options: { filename?: string; } = {}\n    ) {\n        this.db = new Database(options.filename || ':memory:');\n        process.on(\"exit\", async () => {\n            this.db.close();\n        });\n    }\n\n    async connect(): Promise<void> {\n        // Bun SQLite is synchronous/immediate open\n        return;\n    }\n\n    async disconnect(): Promise<void> {\n        this.db.close();\n    }\n\n    async setupSchema(): Promise<void> {\n        // In SQLite we need to create tables eagerly or lazily. \n        // We'll pre-create standard tables but also ensureTable in methods.\n        // For 'schemaless' behavior, we use a single 'data' JSON column.\n        // Also 'id' as primary key.\n        // We might want created_at/updated_at.\n\n        const tables = [\n            'failed_requests', 'sessions', 'users', 'idempotency_keys',\n            'middleware_tracking', 'requests', 'metrics', 'idempotency' // 'idempotency' used in plugin.ts but 'idempotency_keys' used elsewhere? Check code. \n            // The plugin code used `new RecordId('idempotency', key)`, so table name is 'idempotency'.\n            // The shokupan.ts defined 'idempotency_keys'. \n            // We'll create both or just handle lazily.\n        ];\n\n        for (const table of tables) {\n            await this.ensureTable(table);\n        }\n    }\n\n    private ensureTable(table: string) {\n        if (this.tables.has(table)) return;\n\n        this.db.run(`CREATE TABLE IF NOT EXISTS \"${table}\" (\n            id TEXT PRIMARY KEY,\n            data JSON,\n            created_at INTEGER,\n            updated_at INTEGER\n        )`);\n\n        this.tables.add(table);\n    }\n\n    async get<T>(table: string, id: string): Promise<T | null> {\n        this.ensureTable(table);\n        const stmt = this.db.prepare(`SELECT data FROM \"${table}\" WHERE id = ?`);\n        const res = stmt.get(id) as { data: string; } | null;\n        if (!res || !res.data) return null;\n\n        try {\n            return JSON.parse(res.data) as T;\n        } catch (e) {\n            return null;\n        }\n    }\n\n    async create<T>(table: string, id: string, data: T): Promise<T> {\n        this.ensureTable(table);\n        const now = Date.now();\n        // data usually includes id in Shokupan logic? Or maybe not.\n        // We store full object in data, including id if present.\n        const serialized = JSON.stringify(data);\n\n        try {\n            this.db.run(\n                `INSERT INTO \"${table}\" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)`,\n                [id, serialized, now, now]\n            );\n            return data;\n        } catch (err: any) {\n            if (err.message.includes('constraint failed')) {\n                // Duplicate\n                throw new Error(`Record ${id} already exists`);\n            }\n            throw err;\n        }\n    }\n\n    async update<T>(table: string, id: string, data: Partial<T>): Promise<T> {\n        this.ensureTable(table);\n\n        // SQLite JSON patch is tricky without json_patch() extension or complex queries.\n        // Simplest is Read-Modify-Write for now, as concurrency is single-process-ish with Bun (mostly).\n        // Or usage of json_patch in newer SQLite versions (Bun uses recent sqlite).\n\n        // Let's try Read-Modify-Write for safety/simplicity first.\n        const current = await this.get<T>(table, id);\n        if (!current) throw new Error(`Record ${id} does not exist`);\n\n        const updated = { ...current, ...data };\n        const serialized = JSON.stringify(updated);\n        const now = Date.now();\n\n        this.db.run(\n            `UPDATE \"${table}\" SET data = ?, updated_at = ? WHERE id = ?`,\n            [serialized, now, id]\n        );\n\n        return updated;\n    }\n\n    async upsert<T>(table: string, id: string, data: T): Promise<T> {\n        this.ensureTable(table);\n        const now = Date.now();\n        const serialized = JSON.stringify(data);\n\n        // SQLite UPSERT syntax\n        this.db.run(\n            `INSERT INTO \"${table}\" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)\n             ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`,\n            [id, serialized, now, now]\n        );\n\n        return data;\n    }\n\n    async delete(table: string, id: string): Promise<void> {\n        this.ensureTable(table);\n        this.db.run(`DELETE FROM \"${table}\" WHERE id = ?`, [id]);\n    }\n\n    async count(table: string, query?: QueryOptions): Promise<number> {\n        this.ensureTable(table);\n        const { sql, params } = this.buildWhere(query);\n        const res = this.db.prepare(`SELECT COUNT(*) as count FROM \"${table}\" ${sql}`).get(...params) as { count: number; };\n        return res.count;\n    }\n\n    async deleteMany(table: string, query?: QueryOptions): Promise<void> {\n        this.ensureTable(table);\n        const { sql, params } = this.buildWhere(query);\n        // SQLite DELETE with LIMIT/ORDER is a compile-time option `SQLITE_ENABLE_UPDATE_DELETE_LIMIT`.\n        // Bun ships with it? Assuming yes, or standard DELETE WHERE works. \n        // If query has LIMIT/ORDER, we have to check support.\n        // Safest: SELECT ids -> DELETE by ids if LIMIT/ORDER used?\n\n        if (query?.limit || query?.sort) {\n            // Complex delete\n            const selectQ = this.buildWhere(query);\n            // We need to order/limit the selection of IDs\n            let orderSql = '';\n            if (query.sort) {\n                const parts = Object.entries(query.sort).map(([k, v]) => {\n                    return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;\n                });\n                if (parts.length) orderSql = ' ORDER BY ' + parts.join(', ');\n            }\n            let limitSql = '';\n            if (query.limit) limitSql = ` LIMIT ${query.limit}`;\n\n            const rows = this.db.prepare(`SELECT id FROM \"${table}\" ${selectQ.sql} ${orderSql} ${limitSql}`).all(...selectQ.params) as { id: string; }[];\n\n            if (rows.length === 0) return;\n\n            const ids = rows.map(r => r.id);\n            // Batch delete\n            const placeholders = ids.map(() => '?').join(',');\n            this.db.run(`DELETE FROM \"${table}\" WHERE id IN (${placeholders})`, ids);\n        } else {\n            this.db.run(`DELETE FROM \"${table}\" ${sql}`, params);\n        }\n    }\n\n    async findMany<T>(table: string, query?: QueryOptions): Promise<T[]> {\n        this.ensureTable(table);\n        const { sql, params } = this.buildWhere(query);\n\n        let orderSql = '';\n        if (query?.sort) {\n            const parts = Object.entries(query.sort).map(([k, v]) => {\n                // Extract from JSON\n                return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;\n            });\n            if (parts.length) orderSql = ' ORDER BY ' + parts.join(', ');\n        }\n\n        let limitSql = '';\n        if (query?.limit) limitSql = ` LIMIT ${query.limit}`;\n        if (query?.offset) limitSql += ` OFFSET ${query.offset}`;\n\n        const rows = this.db.prepare(`SELECT data FROM \"${table}\" ${sql} ${orderSql} ${limitSql}`).all(...params) as { data: string; }[];\n        return rows.map(r => JSON.parse(r.data));\n    }\n\n    private buildWhere(query?: QueryOptions): { sql: string, params: any[]; } {\n        if (!query) return { sql: '', params: [] };\n\n        let clauses: string[] = [];\n        let params: any[] = [];\n\n        if (query.where) {\n            Object.entries(query.where).forEach(([k, v]) => {\n                clauses.push(`json_extract(data, '$.${k}') = ?`);\n                params.push(v);\n            });\n        }\n\n        if (query.gt) {\n            Object.entries(query.gt).forEach(([k, v]) => {\n                clauses.push(`json_extract(data, '$.${k}') > ?`);\n                params.push(v);\n            });\n        }\n\n        if (query.lt) {\n            Object.entries(query.lt).forEach(([k, v]) => {\n                clauses.push(`json_extract(data, '$.${k}') < ?`);\n                params.push(v);\n            });\n        }\n\n        if (clauses.length === 0) return { sql: '', params: [] };\n        return { sql: 'WHERE ' + clauses.join(' AND '), params };\n    }\n}\n"],"names":[],"mappings":"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"}

package/dist/sqlite-n7FQ6Ja6.cjs

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const bun_sqlite = require("bun:sqlite");
+const index = require("./index-BP7v0Hiv.cjs");
+class SqliteAdapter {
+  constructor(options = {}) {
+    this.options = options;
+    this.db = new bun_sqlite.Database(options.filename || ":memory:");
+    process.on("exit", async () => {
+      this.db.close();
+    });
+  }
+  name = "sqlite";
+  db;
+  logger = index.createLogger("sqlite-adapter");
+  tables = /* @__PURE__ */ new Set();
+  async connect() {
+    return;
+  }
+  async disconnect() {
+    this.db.close();
+  }
+  async setupSchema() {
+    const tables = [
+      "failed_requests",
+      "sessions",
+      "users",
+      "idempotency_keys",
+      "middleware_tracking",
+      "requests",
+      "metrics",
+      "idempotency"
+      // 'idempotency' used in plugin.ts but 'idempotency_keys' used elsewhere? Check code. 
+      // The plugin code used `new RecordId('idempotency', key)`, so table name is 'idempotency'.
+      // The shokupan.ts defined 'idempotency_keys'. 
+      // We'll create both or just handle lazily.
+    ];
+    for (const table of tables) {
+      await this.ensureTable(table);
+    }
+  }
+  ensureTable(table) {
+    if (this.tables.has(table)) return;
+    this.db.run(`CREATE TABLE IF NOT EXISTS "${table}" (
+            id TEXT PRIMARY KEY,
+            data JSON,
+            created_at INTEGER,
+            updated_at INTEGER
+        )`);
+    this.tables.add(table);
+  }
+  async get(table, id) {
+    this.ensureTable(table);
+    const stmt = this.db.prepare(`SELECT data FROM "${table}" WHERE id = ?`);
+    const res = stmt.get(id);
+    if (!res || !res.data) return null;
+    try {
+      return JSON.parse(res.data);
+    } catch (e) {
+      return null;
+    }
+  }
+  async create(table, id, data) {
+    this.ensureTable(table);
+    const now = Date.now();
+    const serialized = JSON.stringify(data);
+    try {
+      this.db.run(
+        `INSERT INTO "${table}" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+        [id, serialized, now, now]
+      );
+      return data;
+    } catch (err) {
+      if (err.message.includes("constraint failed")) {
+        throw new Error(`Record ${id} already exists`);
+      }
+      throw err;
+    }
+  }
+  async update(table, id, data) {
+    this.ensureTable(table);
+    const current = await this.get(table, id);
+    if (!current) throw new Error(`Record ${id} does not exist`);
+    const updated = { ...current, ...data };
+    const serialized = JSON.stringify(updated);
+    const now = Date.now();
+    this.db.run(
+      `UPDATE "${table}" SET data = ?, updated_at = ? WHERE id = ?`,
+      [serialized, now, id]
+    );
+    return updated;
+  }
+  async upsert(table, id, data) {
+    this.ensureTable(table);
+    const now = Date.now();
+    const serialized = JSON.stringify(data);
+    this.db.run(
+      `INSERT INTO "${table}" (id, data, created_at, updated_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`,
+      [id, serialized, now, now]
+    );
+    return data;
+  }
+  async delete(table, id) {
+    this.ensureTable(table);
+    this.db.run(`DELETE FROM "${table}" WHERE id = ?`, [id]);
+  }
+  async count(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    const res = this.db.prepare(`SELECT COUNT(*) as count FROM "${table}" ${sql}`).get(...params);
+    return res.count;
+  }
+  async deleteMany(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    if (query?.limit || query?.sort) {
+      const selectQ = this.buildWhere(query);
+      let orderSql = "";
+      if (query.sort) {
+        const parts = Object.entries(query.sort).map(([k, v]) => {
+          return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;
+        });
+        if (parts.length) orderSql = " ORDER BY " + parts.join(", ");
+      }
+      let limitSql = "";
+      if (query.limit) limitSql = ` LIMIT ${query.limit}`;
+      const rows = this.db.prepare(`SELECT id FROM "${table}" ${selectQ.sql} ${orderSql} ${limitSql}`).all(...selectQ.params);
+      if (rows.length === 0) return;
+      const ids = rows.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(",");
+      this.db.run(`DELETE FROM "${table}" WHERE id IN (${placeholders})`, ids);
+    } else {
+      this.db.run(`DELETE FROM "${table}" ${sql}`, params);
+    }
+  }
+  async findMany(table, query) {
+    this.ensureTable(table);
+    const { sql, params } = this.buildWhere(query);
+    let orderSql = "";
+    if (query?.sort) {
+      const parts = Object.entries(query.sort).map(([k, v]) => {
+        return `json_extract(data, '$.${k}') ${v.toUpperCase()}`;
+      });
+      if (parts.length) orderSql = " ORDER BY " + parts.join(", ");
+    }
+    let limitSql = "";
+    if (query?.limit) limitSql = ` LIMIT ${query.limit}`;
+    if (query?.offset) limitSql += ` OFFSET ${query.offset}`;
+    const rows = this.db.prepare(`SELECT data FROM "${table}" ${sql} ${orderSql} ${limitSql}`).all(...params);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  buildWhere(query) {
+    if (!query) return { sql: "", params: [] };
+    let clauses = [];
+    let params = [];
+    if (query.where) {
+      Object.entries(query.where).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') = ?`);
+        params.push(v);
+      });
+    }
+    if (query.gt) {
+      Object.entries(query.gt).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') > ?`);
+        params.push(v);
+      });
+    }
+    if (query.lt) {
+      Object.entries(query.lt).forEach(([k, v]) => {
+        clauses.push(`json_extract(data, '$.${k}') < ?`);
+        params.push(v);
+      });
+    }
+    if (clauses.length === 0) return { sql: "", params: [] };
+    return { sql: "WHERE " + clauses.join(" AND "), params };
+  }
+}
+exports.SqliteAdapter = SqliteAdapter;
+//# sourceMappingURL=sqlite-n7FQ6Ja6.cjs.map