@cequrebackends/plugin-turso 0.14.0

package/README.md

@@ -0,0 +1,21 @@
+# @cequrebackends/plugin-turso
+
+Turso LibSQL database driver plugin for Cequre backends.
+
+## Installation
+
+```bash
+bun add @cequrebackends/plugin-turso @libsql/client
+```
+
+## Usage
+
+```typescript
+import { CequreRuntime } from "@cequrebackends/cequre-ts";
+import { turso } from "@cequrebackends/plugin-turso";
+
+const runtime = new CequreRuntime(schema, {
+  adapter: turso({ url: process.env.TURSO_DATABASE_URL, authToken: process.env.TURSO_AUTH_TOKEN }),
+  plugins: []
+});
+```

package/dist/adapter.d.ts

@@ -0,0 +1,47 @@
+import type { CequreAdapter, QueryArgs, PaginatedResult as QueryResult } from "@cequrebackends/cequre-ts";
+import { BaseSqlAdapter } from "@cequrebackends/cequre-ts";
+export interface TursoConfig {
+    /** libSQL URL — e.g. `libsql://your-db.turso.io` or `file:./local.db` for embedded */
+    url: string;
+    /** Auth token for remote Turso/libSQL servers. Omit for local file mode. */
+    authToken?: string;
+    /** Optional sync interval in ms for embedded replicas. 0 = no auto-sync. */
+    syncIntervalMs?: number;
+}
+export declare class TursoAdapter extends BaseSqlAdapter {
+    readonly adapterType = "turso";
+    readonly supportsGeneratedConstraintSQL = true;
+    private client;
+    private config;
+    private _syncTimer;
+    constructor(config: TursoConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction<R>(callback: (trxAdapter: CequreAdapter) => Promise<R>): Promise<R>;
+    ping(): Promise<void>;
+    getSystemTableStatements(): string[];
+    getCurrentSchema(): Promise<{
+        tables: string[];
+        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,5 @@
+import { TursoAdapter, type TursoConfig } from "./adapter";
+export declare function turso(config: TursoConfig): TursoAdapter;
+export { TursoAdapter };
+export type { TursoConfig };
+//# 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,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE3D,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,gBAExC;AAED,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,YAAY,EAAE,WAAW,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,590 @@
+// @bun
+var __require = import.meta.require;
+
+// src/adapter.ts
+import { ulid, BaseSqlAdapter, sqlIdentifier } from "@cequrebackends/cequre-ts";
+import { createLogger } 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
+var _libsqlModule = null;
+async function loadLibSQL() {
+  if (_libsqlModule)
+    return _libsqlModule;
+  try {
+    _libsqlModule = await import("@libsql/client");
+    return _libsqlModule;
+  } catch {
+    throw new Error("@libsql/client is not installed. Run: bun add @libsql/client");
+  }
+}
+var logger = createLogger("TursoAdapter");
+
+class TursoAdapter extends BaseSqlAdapter {
+  adapterType = "turso";
+  supportsGeneratedConstraintSQL = true;
+  client = null;
+  config;
+  _syncTimer = null;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async connect() {
+    const libsql = await loadLibSQL();
+    const isDev = process.env.CEQURE_DEV === "1";
+    const cacheKey = `__cequre_turso_${this.config.url}`;
+    const globalState = isDev ? globalThis[cacheKey] : null;
+    if (globalState && globalState.client) {
+      this.client = globalState.client;
+      this._syncTimer = globalState.syncTimer;
+      logger.info({ url: this.config.url }, "Reusing existing Turso/libSQL connection");
+      return;
+    }
+    this.client = libsql.createClient({
+      url: this.config.url,
+      authToken: this.config.authToken
+    });
+    await this.client.execute("SELECT 1");
+    logger.info({ url: this.config.url }, "Connected to Turso/libSQL");
+    if (this.config.syncIntervalMs && this.config.syncIntervalMs > 0) {
+      this._syncTimer = setInterval(() => {
+        this.client?.sync().catch((err) => logger.error({ err }, "Turso embedded replica sync failed"));
+      }, this.config.syncIntervalMs);
+    }
+    if (isDev) {
+      globalThis[cacheKey] = {
+        client: this.client,
+        syncTimer: this._syncTimer
+      };
+    }
+  }
+  async disconnect() {
+    const isDev = process.env.CEQURE_DEV === "1";
+    if (isDev) {
+      return;
+    }
+    if (this._syncTimer) {
+      clearInterval(this._syncTimer);
+      this._syncTimer = null;
+    }
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+    }
+  }
+  async transaction(callback) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    const tx = await this.client.transaction();
+    try {
+      const trxAdapter = Object.create(this);
+      trxAdapter.client = tx;
+      const result = await callback(trxAdapter);
+      await tx.commit();
+      return result;
+    } catch (err) {
+      await tx.rollback();
+      throw err;
+    }
+  }
+  async ping() {
+    await this.client.execute("SELECT 1");
+  }
+  getSystemTableStatements() {
+    return generateSystemTables();
+  }
+  async getCurrentSchema() {
+    const tablesResult = await this.client.execute("SELECT name FROM sqlite_master WHERE type='table'");
+    const tables = tablesResult.rows.map((r) => r.name);
+    const columns = {};
+    for (const table of tables) {
+      const colsResult = await this.client.execute({
+        sql: `PRAGMA table_info(${sqlIdentifier(table)})`,
+        args: []
+      });
+      columns[table] = colsResult.rows.map((c) => c.name);
+    }
+    return { tables, columns };
+  }
+  async recordMigration(version, description) {
+    const id = ulid();
+    await this.client.execute({
+      sql: "INSERT INTO cequre_migrations (id, version, description) VALUES (?, ?, ?)",
+      args: [id, version, description]
+    });
+  }
+  async getCurrentMigrationVersion() {
+    const result = await this.client.execute("SELECT version FROM cequre_migrations ORDER BY applied_at DESC LIMIT 1");
+    return result.rows[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 ")})`);
+    }
+    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(`"${key}" = ?`);
+      }
+    }
+    return clauses.join(" AND ");
+  }
+  async find(collection, query) {
+    if (!this.client)
+      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 result = await this.client.execute({ sql: sqlStr, args: params });
+    let countSql = `SELECT COUNT(*) as count FROM ${sqlIdentifier(collection)}`;
+    if (whereStr)
+      countSql += ` WHERE ${whereStr}`;
+    const countResult = await this.client.execute({ sql: countSql, args: params });
+    const totalDocs = Number(countResult.rows[0]?.count || 0);
+    const totalPages = Math.ceil(totalDocs / limit);
+    return {
+      docs: result.rows.map((r) => this.deserializeRow(collection, r)),
+      totalDocs,
+      limit,
+      page,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPrevPage: page > 1
+    };
+  }
+  async findById(collection, id) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${sqlIdentifier(collection)} WHERE id = ?`,
+      args: [id]
+    });
+    if (!result.rows || result.rows.length === 0)
+      return null;
+    return this.deserializeRow(collection, result.rows[0]);
+  }
+  async findByIds(collection, ids) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    if (!ids.length)
+      return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${sqlIdentifier(collection)} WHERE id IN (${placeholders})`,
+      args: ids
+    });
+    return result.rows.map((r) => this.deserializeRow(collection, r));
+  }
+  async create(collection, data) {
+    if (!this.client)
+      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 result = await this.client.execute({ sql: sqlStr, args: values });
+    return this.deserializeRow(collection, result.rows[0]);
+  }
+  async createMany(collection, docs) {
+    if (!this.client)
+      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 result = await this.client.execute({ sql: sqlStr, args: allValues });
+    return result.rows.map((r) => this.deserializeRow(collection, r));
+  }
+  async update(collection, id, data) {
+    if (!this.client)
+      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 result = await this.client.execute({ sql: sqlStr, args: values });
+    if (!result.rows || result.rows.length === 0)
+      throw new Error("Document not found");
+    return this.deserializeRow(collection, result.rows[0]);
+  }
+  async delete(collection, id) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    await this.client.execute({
+      sql: `DELETE FROM ${sqlIdentifier(collection)} WHERE id = ?`,
+      args: [id]
+    });
+  }
+  async deleteMany(collection, ids) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    if (!ids.length)
+      return;
+    const placeholders = ids.map(() => "?").join(", ");
+    await this.client.execute({
+      sql: `DELETE FROM ${sqlIdentifier(collection)} WHERE id IN (${placeholders})`,
+      args: ids
+    });
+  }
+  async count(collection, query) {
+    if (!this.client)
+      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 result = await this.client.execute({ sql: sqlStr, args: params });
+    return Number(result.rows[0]?.count || 0);
+  }
+  async raw(sql, params) {
+    if (!this.client)
+      throw new Error("Database not connected");
+    try {
+      const result = await this.client.execute({ sql, args: params || [] });
+      return result.rows;
+    } catch (e) {
+      if (e.code === "SQL_MANY_STATEMENTS" || e.message && e.message.includes("more than one statement")) {
+        if (params && params.length > 0) {
+          throw new Error("Cannot execute multiple statements with parameterized queries.");
+        }
+        await this.client.executeMultiple(sql);
+        return [];
+      }
+      throw e;
+    }
+  }
+}
+
+// src/index.ts
+function turso(config) {
+  return new TursoAdapter(config);
+}
+export {
+  turso,
+  TursoAdapter
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cequrebackends/plugin-turso",
+  "version": "0.14.0",
+  "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",
+    "dev": "bun build ./src/index.ts --outdir ./dist --target bun --packages external --watch"
+  },
+  "peerDependencies": {
+    "@libsql/client": "^0.17.4",
+    "@cequrebackends/cequre-ts": "0.13.0"
+  },
+  "devDependencies": {
+    "typescript": "^7.0.1-rc",
+    "@cequrebackends/cequre-ts": "0.13.0"
+  },
+  "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"
+  }
+}