@cequrebackends/plugin-sqlite 0.12.2

package/README.md

@@ -0,0 +1,21 @@
+# @cequrebackends/plugin-sqlite
+
+SQLite database driver plugin for Cequre backends.
+
+## Installation
+
+```bash
+bun add @cequrebackends/plugin-sqlite
+```
+
+## Usage
+
+```typescript
+import { CequreRuntime } from "@cequrebackends/cequre-ts";
+import { sqlite } from "@cequrebackends/plugin-sqlite";
+
+const runtime = new CequreRuntime(schema, {
+  adapter: sqlite({ filename: "app.db" }),
+  plugins: []
+});
+```

package/dist/adapter.d.ts

@@ -0,0 +1,40 @@
+import type { CequreAdapter, QueryArgs, PaginatedResult as QueryResult } from "@cequrebackends/cequre-ts";
+import { BaseSqlAdapter } from "@cequrebackends/cequre-ts";
+export declare class SQLiteAdapter extends BaseSqlAdapter {
+    readonly adapterType = "sqlite";
+    readonly supportsGeneratedConstraintSQL = true;
+    private db;
+    private url;
+    constructor(url: string);
+    private initDb;
+    private closeDb;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction<R>(callback: (trxAdapter: CequreAdapter) => Promise<R>): Promise<R>;
+    ping(): Promise<void>;
+    getSystemTableStatements(): string[];
+    getCurrentSchema(): Promise<{
+        tables: any[];
+        columns: Record<string, string[]>;
+    }>;
+    recordMigration(version: string, description: string): Promise<void>;
+    getCurrentMigrationVersion(): Promise<string | null>;
+    createTableDDL(table: unknown): string;
+    renameColumnDDL(table: string, oldName: string, newName: string): string;
+    addColumnDDL(table: string, column: unknown): string | null;
+    dropColumnDDL(table: string, column: string): string;
+    dropTableDDL(table: string): string;
+    private deserializeRow;
+    private buildWhere;
+    find(collection: string, query: QueryArgs<any>): Promise<QueryResult>;
+    findById(collection: string, id: string): Promise<Record<string, unknown> | null>;
+    findByIds(collection: string, ids: string[]): Promise<Record<string, unknown>[]>;
+    create(collection: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createMany(collection: string, docs: Record<string, unknown>[]): Promise<Record<string, unknown>[]>;
+    update(collection: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    delete(collection: string, id: string): Promise<void>;
+    deleteMany(collection: string, ids: string[]): Promise<void>;
+    count(collection: string, query?: Pick<QueryArgs<any>, "where">): Promise<number>;
+    raw(sql: string, params?: unknown[]): Promise<unknown>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/dist/ddl/schema.d.ts

@@ -0,0 +1,27 @@
+import type { CollectionConfig, FieldConfig } from "@cequrebackends/cequre-ts";
+export type SQLiteType = "TEXT" | "INTEGER" | "REAL" | "BLOB";
+export interface ColumnDefinition {
+    name: string;
+    type: SQLiteType;
+    required: boolean;
+    unique: boolean;
+    defaultValue?: any;
+    foreignKey?: {
+        table: string;
+        column: string;
+        onDelete?: string;
+    };
+}
+export interface TableDefinition {
+    name: string;
+    columns: ColumnDefinition[];
+    primaryKey: string[];
+}
+export declare function fieldTypeToSQLite(field: FieldConfig): SQLiteType;
+export declare function buildColumns(collection: CollectionConfig): ColumnDefinition[];
+export declare function buildTable(collection: CollectionConfig): TableDefinition;
+export declare function generateCreateTable(table: TableDefinition): string;
+export declare function generateRenameColumn(tableName: string, oldName: string, newName: string): string;
+export declare function generateAddColumn(tableName: string, column: ColumnDefinition): string;
+export declare function generateSystemTables(): string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/ddl/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/ddl/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE/E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,UAAU,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnE;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAUhE;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAiD7E;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,gBAAgB,GAAG,eAAe,CAMxE;AAsBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAuBlE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhG;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAErF;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAsB/C"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { SQLiteAdapter } from "./adapter";
+export interface SQLiteConfig {
+    url: string;
+}
+export declare function sqlite(config: SQLiteConfig): SQLiteAdapter;
+export { SQLiteAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,YAAY,iBAE1C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,551 @@
+// @bun
+// src/adapter.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { ulid, BaseSqlAdapter, sqlIdentifier } from "@cequrebackends/cequre-ts";
+
+// src/ddl/schema.ts
+function fieldTypeToSQLite(field) {
+  switch (field.type) {
+    case "boolean":
+    case "integer":
+      return "INTEGER";
+    case "number":
+      return "REAL";
+    default:
+      return "TEXT";
+  }
+}
+function buildColumns(collection) {
+  const columns = [];
+  columns.push({
+    name: "id",
+    type: "TEXT",
+    required: true,
+    unique: false
+  });
+  for (const field of collection.fields) {
+    if (field.type === "link")
+      continue;
+    const col = {
+      name: field.name,
+      type: fieldTypeToSQLite(field),
+      required: !field.optional,
+      unique: field.unique || false,
+      defaultValue: field.default
+    };
+    if (field.type === "relationship" && field.target) {
+      col.foreignKey = {
+        table: field.target,
+        column: "id",
+        onDelete: "SET NULL"
+      };
+    }
+    columns.push(col);
+  }
+  columns.push({
+    name: "createdAt",
+    type: "TEXT",
+    required: true,
+    unique: false,
+    defaultValue: "CURRENT_TIMESTAMP"
+  });
+  columns.push({
+    name: "updatedAt",
+    type: "TEXT",
+    required: true,
+    unique: false,
+    defaultValue: "CURRENT_TIMESTAMP"
+  });
+  return columns;
+}
+function buildTable(collection) {
+  return {
+    name: collection.slug,
+    columns: buildColumns(collection),
+    primaryKey: ["id"]
+  };
+}
+function formatDefaultValue(value) {
+  if (value === "CURRENT_TIMESTAMP")
+    return "CURRENT_TIMESTAMP";
+  if (value === undefined || value === null)
+    return "NULL";
+  if (typeof value === "string")
+    return `'${value.replace(/'/g, "''")}'`;
+  if (typeof value === "boolean")
+    return value ? "1" : "0";
+  if (typeof value === "number")
+    return String(value);
+  if (value instanceof Date)
+    return `'${value.toISOString()}'`;
+  return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+}
+function generateColumnDefinition(column) {
+  let def = `"${column.name}" ${column.type}`;
+  if (column.required)
+    def += " NOT NULL";
+  if (column.defaultValue !== undefined) {
+    def += ` DEFAULT ${formatDefaultValue(column.defaultValue)}`;
+  }
+  if (column.unique)
+    def += " UNIQUE";
+  return def;
+}
+function generateCreateTable(table) {
+  const columnDefs = table.columns.map((col) => generateColumnDefinition(col)).join(`,
+  `);
+  const fkConstraints = table.columns.filter((col) => col.foreignKey).map((col) => {
+    const fk = col.foreignKey;
+    return `  CONSTRAINT ${table.name}_${col.name}_fkey FOREIGN KEY ("${col.name}") REFERENCES ${fk.table}("${fk.column}") ON DELETE ${fk.onDelete || "SET NULL"}`;
+  });
+  const allDefs = [
+    `  ${columnDefs}`,
+    `  PRIMARY KEY (${table.primaryKey.map((pk) => `"${pk}"`).join(", ")})`,
+    ...fkConstraints
+  ].join(`,
+`);
+  const fkIndexes = table.columns.filter((col) => col.foreignKey).map((col) => `CREATE INDEX IF NOT EXISTS ${table.name}_${col.name}_idx ON ${table.name}("${col.name}");`);
+  return [
+    `CREATE TABLE IF NOT EXISTS ${table.name} (
+${allDefs}
+);`,
+    ...fkIndexes
+  ].join(`
+`);
+}
+function generateRenameColumn(tableName, oldName, newName) {
+  return `ALTER TABLE ${tableName} RENAME COLUMN "${oldName}" TO "${newName}";`;
+}
+function generateAddColumn(tableName, column) {
+  return `ALTER TABLE ${tableName} ADD COLUMN ${generateColumnDefinition(column)};`;
+}
+function generateSystemTables() {
+  const statements = [];
+  statements.push(`CREATE TABLE IF NOT EXISTS cequre_migrations (
+  id TEXT PRIMARY KEY,
+  version TEXT NOT NULL UNIQUE,
+  applied_at TEXT DEFAULT CURRENT_TIMESTAMP,
+  description TEXT
+);`);
+  statements.push(`CREATE TABLE IF NOT EXISTS cequre_refresh_tokens (
+  id TEXT PRIMARY KEY,
+  "tokenHash" TEXT NOT NULL,
+  "userId" TEXT NOT NULL,
+  collection TEXT NOT NULL,
+  role TEXT,
+  "expiresAt" INTEGER NOT NULL,
+  "createdAt" TEXT DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" TEXT DEFAULT CURRENT_TIMESTAMP
+);`);
+  return statements;
+}
+
+// src/adapter.ts
+class SQLiteAdapter extends BaseSqlAdapter {
+  adapterType = "sqlite";
+  supportsGeneratedConstraintSQL = true;
+  db = null;
+  url;
+  constructor(url) {
+    super();
+    this.url = url === "sqlite::memory:" ? ":memory:" : url;
+  }
+  initDb() {
+    let finalPath = this.url;
+    if (this.url !== ":memory:") {
+      let filepath = this.url.split("?")[0] || "";
+      if (filepath.startsWith("sqlite:"))
+        filepath = filepath.slice(7);
+      if (filepath.startsWith("file:"))
+        filepath = filepath.slice(5);
+      if (filepath.startsWith("//"))
+        filepath = filepath.slice(2);
+      const dir = dirname(filepath);
+      if (dir && dir !== "." && dir !== "/") {
+        try {
+          mkdirSync(dir, { recursive: true });
+        } catch {}
+      }
+      finalPath = filepath;
+    }
+    this.db = new Database(finalPath);
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA synchronous = NORMAL;");
+  }
+  async closeDb(dbInstance) {
+    if (dbInstance)
+      dbInstance.close();
+  }
+  async connect() {
+    this.initDb();
+    this.db.query("SELECT 1").get();
+  }
+  async disconnect() {
+    await this.closeDb(this.db);
+    this.db = null;
+  }
+  async transaction(callback) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    this.db.query("BEGIN TRANSACTION").run();
+    try {
+      const trxAdapter = Object.create(this);
+      const result = await callback(trxAdapter);
+      this.db.query("COMMIT").run();
+      return result;
+    } catch (err) {
+      if (this.db) {
+        try {
+          this.db.query("ROLLBACK").run();
+        } catch {}
+      }
+      throw err;
+    }
+  }
+  async ping() {
+    try {
+      this.db.query("SELECT 1").get();
+    } catch (err) {
+      throw err;
+    }
+  }
+  getSystemTableStatements() {
+    return generateSystemTables();
+  }
+  async getCurrentSchema() {
+    const tablesRaw = this.db.query("SELECT name FROM sqlite_master WHERE type='table'").all();
+    const tables = tablesRaw.map((r) => r.name);
+    const columns = {};
+    for (const table of tables) {
+      const colsRaw = this.db.query(`PRAGMA table_info("${table}")`).all();
+      columns[table] = colsRaw.map((c) => c.name);
+    }
+    return { tables, columns };
+  }
+  async recordMigration(version, description) {
+    const id = ulid();
+    this.db.query(`INSERT INTO cequre_migrations (id, version, description) VALUES (?, ?, ?)`).run(id, version, description);
+  }
+  async getCurrentMigrationVersion() {
+    const res = this.db.query(`SELECT version FROM cequre_migrations ORDER BY applied_at DESC LIMIT 1`).all();
+    return res[0]?.version || null;
+  }
+  createTableDDL(table) {
+    return generateCreateTable(buildTable(table));
+  }
+  renameColumnDDL(table, oldName, newName) {
+    return generateRenameColumn(table, oldName, newName);
+  }
+  addColumnDDL(table, column) {
+    const cols = buildColumns({ slug: table, fields: [column] });
+    const colDef = cols.find((c) => c.name === column.name);
+    if (!colDef)
+      return null;
+    return generateAddColumn(table, colDef);
+  }
+  dropColumnDDL(table, column) {
+    return `ALTER TABLE ${sqlIdentifier(table)} DROP COLUMN "${column}";`;
+  }
+  dropTableDDL(table) {
+    return `DROP TABLE IF EXISTS ${sqlIdentifier(table)};`;
+  }
+  deserializeRow(collection, row) {
+    if (!row)
+      return row;
+    const nums = this._numericFields.get(collection);
+    const jsons = this._jsonFields.get(collection);
+    const obj = { ...row };
+    if (nums) {
+      for (const k of nums) {
+        if (typeof obj[k] === "string") {
+          const parsed = Number(obj[k]);
+          if (!isNaN(parsed))
+            obj[k] = parsed;
+        }
+      }
+    }
+    if (jsons) {
+      for (const k of jsons) {
+        if (typeof obj[k] === "string") {
+          try {
+            obj[k] = JSON.parse(obj[k]);
+          } catch {}
+        }
+      }
+    }
+    return obj;
+  }
+  buildWhere(where, collection, params) {
+    if (!where || Object.keys(where).length === 0)
+      return "";
+    const clauses = [];
+    if (where.OR) {
+      const orClauses = where.OR.map((cond) => this.buildWhere(cond, collection, params)).filter(Boolean);
+      if (orClauses.length > 0)
+        clauses.push(`(${orClauses.join(" OR ")})`);
+    }
+    if (where.AND) {
+      const andClauses = where.AND.map((cond) => this.buildWhere(cond, collection, params)).filter(Boolean);
+      if (andClauses.length > 0)
+        clauses.push(`(${andClauses.join(" AND ")})`);
+    }
+    const known = this._knownFields.get(collection);
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "OR" || key === "AND")
+        continue;
+      let columnRef = `"${key}"`;
+      if (key.includes(".")) {
+        const parts = key.split(".");
+        const root = parts.shift();
+        const path = `$.${parts.join(".")}`;
+        columnRef = `json_extract("${root}", '${path}')`;
+      }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const ops = value;
+        const isSensitive = ops.mode === "sensitive";
+        for (const [op, val] of Object.entries(ops)) {
+          if (op === "mode")
+            continue;
+          if (op === "eq") {
+            params.push(val);
+            clauses.push(`${columnRef} = ?`);
+          } else if (op === "neq") {
+            params.push(val);
+            clauses.push(`${columnRef} != ?`);
+          } else if (op === "gt") {
+            params.push(val);
+            clauses.push(`${columnRef} > ?`);
+          } else if (op === "gte") {
+            params.push(val);
+            clauses.push(`${columnRef} >= ?`);
+          } else if (op === "lt") {
+            params.push(val);
+            clauses.push(`${columnRef} < ?`);
+          } else if (op === "lte") {
+            params.push(val);
+            clauses.push(`${columnRef} <= ?`);
+          } else if (op === "in" && Array.isArray(val) && val.length > 0) {
+            const placeholders = val.map((v) => {
+              params.push(v);
+              return "?";
+            }).join(", ");
+            clauses.push(`${columnRef} IN (${placeholders})`);
+          } else if (op === "nin" && Array.isArray(val) && val.length > 0) {
+            const placeholders = val.map((v) => {
+              params.push(v);
+              return "?";
+            }).join(", ");
+            clauses.push(`${columnRef} NOT IN (${placeholders})`);
+          } else if (op === "any" && Array.isArray(val) && val.length > 0) {
+            const placeholders = val.map((v) => {
+              params.push(v);
+              return "?";
+            }).join(", ");
+            clauses.push(`EXISTS (SELECT 1 FROM json_each(${columnRef}) WHERE value IN (${placeholders}))`);
+          } else if (op === "all" && Array.isArray(val) && val.length > 0) {
+            const allClauses = val.map((v) => {
+              params.push(v);
+              return `EXISTS (SELECT 1 FROM json_each(${columnRef}) WHERE value = ?)`;
+            });
+            clauses.push(`(${allClauses.join(" AND ")})`);
+          } else if (op === "like") {
+            params.push(val);
+            clauses.push(`${columnRef} ${isSensitive ? "GLOB" : "LIKE"} ?`);
+          } else if (op === "contains") {
+            params.push(isSensitive ? `*${val}*` : `%${val}%`);
+            clauses.push(`${columnRef} ${isSensitive ? "GLOB" : "LIKE"} ?`);
+          } else if (op === "startsWith") {
+            params.push(isSensitive ? `${val}*` : `${val}%`);
+            clauses.push(`${columnRef} ${isSensitive ? "GLOB" : "LIKE"} ?`);
+          } else if (op === "endsWith") {
+            params.push(isSensitive ? `*${val}` : `%${val}`);
+            clauses.push(`${columnRef} ${isSensitive ? "GLOB" : "LIKE"} ?`);
+          }
+        }
+      } else {
+        params.push(value);
+        clauses.push(`${columnRef} = ?`);
+      }
+    }
+    return clauses.join(" AND ");
+  }
+  async find(collection, query) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    const params = [];
+    let sqlStr = `SELECT * FROM ${sqlIdentifier(collection)}`;
+    const whereStr = this.buildWhere(query.where, collection, params);
+    if (whereStr)
+      sqlStr += ` WHERE ${whereStr}`;
+    if (query.sort) {
+      const isDesc = query.sort.startsWith("-");
+      const field = isDesc ? query.sort.substring(1) : query.sort;
+      sqlStr += ` ORDER BY "${field}" ${isDesc ? "DESC" : "ASC"}`;
+    }
+    const limit = query.limit || 10;
+    const page = query.page || 1;
+    const offset = (page - 1) * limit;
+    sqlStr += ` LIMIT ${limit} OFFSET ${offset}`;
+    const stmt = this.db.query(sqlStr);
+    const results = stmt.all(...params);
+    let countSql = `SELECT COUNT(*) as count FROM ${sqlIdentifier(collection)}`;
+    if (whereStr)
+      countSql += ` WHERE ${whereStr}`;
+    const countRes = this.db.query(countSql).all(...params);
+    const totalDocs = Number(countRes[0]?.count || 0);
+    const totalPages = Math.ceil(totalDocs / limit);
+    return {
+      docs: results.map((r) => this.deserializeRow(collection, r)),
+      totalDocs,
+      limit,
+      page,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPrevPage: page > 1
+    };
+  }
+  async findById(collection, id) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    const results = this.db.query(`SELECT * FROM ${sqlIdentifier(collection)} WHERE id = ?`).all(id);
+    if (!results || results.length === 0)
+      return null;
+    return this.deserializeRow(collection, results[0]);
+  }
+  async findByIds(collection, ids) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    if (!ids.length)
+      return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    const results = this.db.query(`SELECT * FROM ${sqlIdentifier(collection)} WHERE id IN (${placeholders})`).all(...ids);
+    return results.map((r) => this.deserializeRow(collection, r));
+  }
+  async create(collection, data) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    if (!("id" in data) || data.id === undefined || data.id === null) {
+      data = { id: ulid(), ...data };
+    }
+    const keys = Object.keys(data);
+    const values = Object.values(data).map((v) => typeof v === "object" && v !== null && !(v instanceof Date) ? JSON.stringify(v) : v);
+    const keyStr = keys.map((k) => `"${k}"`).join(", ");
+    const valStr = keys.map(() => "?").join(", ");
+    const sqlStr = `INSERT INTO ${sqlIdentifier(collection)} (${keyStr}) VALUES (${valStr}) RETURNING *`;
+    const results = this.db.query(sqlStr).all(...values);
+    return this.deserializeRow(collection, results[0]);
+  }
+  async createMany(collection, docs) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    if (!docs.length)
+      return [];
+    const knownFields = this._knownFields.get(collection);
+    const now = new Date().toISOString();
+    docs = docs.map((doc) => {
+      const paddedDoc = { ...doc };
+      if (!("id" in paddedDoc) || paddedDoc.id === undefined || paddedDoc.id === null) {
+        paddedDoc.id = ulid();
+      }
+      if (knownFields) {
+        for (const field of knownFields) {
+          if (!(field in paddedDoc))
+            paddedDoc[field] = null;
+        }
+      }
+      if (!knownFields || knownFields.has("createdAt"))
+        paddedDoc.createdAt = paddedDoc.createdAt ?? now;
+      if (!knownFields || knownFields.has("updatedAt"))
+        paddedDoc.updatedAt = now;
+      return paddedDoc;
+    });
+    const keys = Object.keys(docs[0]);
+    const keyStr = keys.map((k) => `"${k}"`).join(", ");
+    const allValues = [];
+    const valStrs = docs.map((doc) => {
+      keys.forEach((k) => {
+        const v = doc[k];
+        allValues.push(typeof v === "object" && v !== null && !(v instanceof Date) ? JSON.stringify(v) : v);
+      });
+      return `(${keys.map(() => "?").join(", ")})`;
+    });
+    const sqlStr = `INSERT INTO ${sqlIdentifier(collection)} (${keyStr}) VALUES ${valStrs.join(", ")} RETURNING *`;
+    const results = this.db.query(sqlStr).all(...allValues);
+    return results.map((r) => this.deserializeRow(collection, r));
+  }
+  async update(collection, id, data) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    const keys = Object.keys(data);
+    if (!keys.length)
+      return this.findById(collection, id);
+    const jsonFields = this._jsonFields.get(collection);
+    const setStrs = [];
+    const values = [];
+    for (const [k, v] of Object.entries(data)) {
+      const isJson = jsonFields?.has(k);
+      const isObject = typeof v === "object" && v !== null && !(v instanceof Date);
+      if (isJson && isObject) {
+        setStrs.push(`"${k}" = json_patch(IFNULL("${k}", '{}'), ?)`);
+        values.push(JSON.stringify(v));
+      } else {
+        setStrs.push(`"${k}" = ?`);
+        values.push(isObject ? JSON.stringify(v) : v);
+      }
+    }
+    values.push(id);
+    const setStr = setStrs.join(", ");
+    const sqlStr = `UPDATE ${sqlIdentifier(collection)} SET ${setStr} WHERE id = ? RETURNING *`;
+    const results = this.db.query(sqlStr).all(...values);
+    if (!results || results.length === 0)
+      throw new Error("Document not found");
+    return this.deserializeRow(collection, results[0]);
+  }
+  async delete(collection, id) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    this.db.query(`DELETE FROM ${sqlIdentifier(collection)} WHERE id = ?`).run(id);
+  }
+  async deleteMany(collection, ids) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    if (!ids.length)
+      return;
+    const placeholders = ids.map(() => "?").join(", ");
+    this.db.query(`DELETE FROM ${sqlIdentifier(collection)} WHERE id IN (${placeholders})`).run(...ids);
+  }
+  async count(collection, query) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    const params = [];
+    let sqlStr = `SELECT COUNT(*) as count FROM ${sqlIdentifier(collection)}`;
+    if (query?.where) {
+      const whereStr = this.buildWhere(query.where, collection, params);
+      if (whereStr)
+        sqlStr += ` WHERE ${whereStr}`;
+    }
+    const countRes = this.db.query(sqlStr).all(...params);
+    return Number(countRes[0]?.count || 0);
+  }
+  async raw(sql, params) {
+    if (!this.db)
+      throw new Error("Database not connected");
+    const bindings = params || [];
+    if (sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("PRAGMA")) {
+      return this.db.query(sql).all(...bindings);
+    } else {
+      return this.db.query(sql).run(...bindings);
+    }
+  }
+}
+
+// src/index.ts
+function sqlite(config) {
+  return new SQLiteAdapter(config.url);
+}
+export {
+  sqlite,
+  SQLiteAdapter
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cequrebackends/plugin-sqlite",
+  "version": "0.12.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target bun --packages external && tsc --emitDeclarationOnly"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.1-rc",
+    "@cequrebackends/cequre-ts": "0.12.2"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cequrebackends/cequre.git"
+  },
+  "peerDependencies": {
+    "@cequrebackends/cequre-ts": "0.12.2"
+  }
+}