@kyro-cms/core 0.5.5 → 0.7.0

package/dist/{chunk-XU7AFF6V.js → chunk-35U3FROB.js}

@@ -1,9 +1,12 @@
 import { createKyroServer } from './chunk-3AJE4SEG.js';
-import { createHonoApp } from './chunk-AM4JKIPP.js';
+import { createHonoApp } from './chunk-HXRD4B37.js';
 import { createWebhookService, API_KEY_COLLECTION, WEBHOOK_COLLECTION, WEBHOOK_DELIVERY_COLLECTION } from './chunk-QXIQWPAP.js';
 import { buildGraphQLSchema } from './chunk-REK7AYOC.js';
 import { KyroPubSub, createWSServer } from './chunk-3TPQ2BU6.js';
+import { AbstractBaseAdapter, applyRLS, DEFAULT_RLS_CONFIG, canAccessDocument } from './chunk-3ZFYL34R.js';
 import { z } from 'zod';
+import { createRequire } from 'module';
+import { randomBytes } from 'crypto';
 
 // src/registry/validator.ts
 function findFieldByName(fields, name) {
@@ -1252,7 +1255,982 @@ var Kyro = class {
 function createKyro(config) {
   return new Kyro(config);
 }
+var _require = createRequire(import.meta.url);
+var modPath = "node:sqlite";
+var { DatabaseSync } = _require(modPath);
+function flattenFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs" && "tabs" in field) {
+      for (const tab of field.tabs) {
+        result.push(...flattenFields(tab.fields));
+      }
+    } else if (field.type === "row" && "fields" in field) {
+      result.push(...flattenFields(field.fields));
+    } else if (field.type === "collapsible" && "fields" in field) {
+      result.push(...flattenFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+function processFieldValue(row, field) {
+  const f = field;
+  let value = row[f.name];
+  if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
+    try {
+      value = value ? JSON.parse(value) : null;
+    } catch {
+      value = null;
+    }
+  }
+  if (f.type === "checkbox") {
+    value = Boolean(value);
+  }
+  if (f.type === "date" && value) {
+    try {
+      const d = new Date(value);
+      if (isNaN(d.getTime())) {
+        value = null;
+      } else {
+        value = d.toISOString();
+      }
+    } catch {
+      value = null;
+    }
+  }
+  if ((f.type === "upload" || f.type === "image") && value) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        value = parsed.map((item) => {
+          if (typeof item === "object" && item !== null) {
+            return item;
+          }
+          return { id: item };
+        });
+      } else {
+        value = typeof parsed === "object" ? parsed : { id: parsed };
+      }
+    } catch {
+      value = { id: value };
+    }
+  }
+  if (f.type === "relationship" && value) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        value = parsed;
+      } else {
+        value = parsed;
+      }
+    } catch {
+      value = { relationTo: Array.isArray(f.relationTo) ? f.relationTo[0] : f.relationTo, value };
+    }
+  }
+  if (f.type === "list" && value) {
+    try {
+      const parsed = JSON.parse(value);
+      value = Array.isArray(parsed) ? parsed : [];
+    } catch {
+      value = [];
+    }
+  }
+  if (f.type === "relationship-block" && value) {
+    try {
+      const parsed = JSON.parse(value);
+      value = Array.isArray(parsed) ? parsed : [];
+    } catch {
+      value = [];
+    }
+  }
+  return value;
+}
+function getTableColumns(db, tableName) {
+  try {
+    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    return rows.map((r) => r.name);
+  } catch {
+    return [];
+  }
+}
+var LocalAdapter = class extends AbstractBaseAdapter {
+  db;
+  path;
+  migrations = /* @__PURE__ */ new Map();
+  draftsTableName = "kyro_drafts";
+  versionsTableName = "kyro_versions";
+  tenantContext;
+  setTenantContext(context) {
+    this.tenantContext = context;
+  }
+  getTenantContext() {
+    return this.tenantContext;
+  }
+  constructor(options) {
+    super();
+    this.path = options.path;
+    if (options.db) {
+      this.db = options.db;
+    } else {
+      this.db = null;
+    }
+  }
+  async connect() {
+    if (!this.db) {
+      this.db = new DatabaseSync(this.path || ":memory:");
+    }
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.connected = true;
+    console.log(
+      `[LocalAdapter] Connected to SQLite (${this.path || "memory"})`
+    );
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+    }
+    this.connected = false;
+    console.log("[LocalAdapter] Disconnected");
+  }
+  // ========================================================================
+  // Schema Management
+  // ========================================================================
+  ensureTable(config, tableName) {
+    const name = tableName || this.getTableNameFor(config.slug);
+    const columns = [`id TEXT PRIMARY KEY`];
+    for (const field of flattenFields(config.fields)) {
+      if (!field.name || field.name === "id") continue;
+      const colDef = this.fieldToSQL(field);
+      if (colDef) columns.push(colDef);
+    }
+    columns.push(`${this.col("createdAt")} TEXT DEFAULT (datetime('now'))`);
+    columns.push(`${this.col("updatedAt")} TEXT DEFAULT (datetime('now'))`);
+    columns.push(`_status TEXT DEFAULT 'published'`);
+    columns.push(`_has_draft INTEGER DEFAULT 0`);
+    if (config.tenantScoped) {
+      columns.push(`tenant_id TEXT NOT NULL`);
+    }
+    const existingColumns = getTableColumns(this.db, name);
+    if (existingColumns.length === 0) {
+      const createSQL = `CREATE TABLE IF NOT EXISTS ${name} (${columns.join(", ")})`;
+      this.db.exec(createSQL);
+      this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${name}__status ON ${name}(_status)`);
+      for (const field of flattenFields(config.fields)) {
+        if (field.name && field.indexed) {
+          this.db.exec(
+            `CREATE INDEX IF NOT EXISTS idx_${name}_${field.name} ON ${name}(${this.col(field.name)})`
+          );
+        }
+        if (field.name && field.unique) {
+          this.db.exec(
+            `CREATE UNIQUE INDEX IF NOT EXISTS idx_${name}_${field.name}_unique ON ${name}(${this.col(field.name)})`
+          );
+        }
+      }
+    } else {
+      const existingSet = new Set(existingColumns);
+      for (const colDef of columns) {
+        const colName = colDef.split(" ")[0].replace(/^"/, "").replace(/"$/, "");
+        if (!existingSet.has(colName) && colName !== "id") {
+          try {
+            if (colName === "_status") {
+              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} TEXT DEFAULT 'published'`);
+            } else if (colName === "_has_draft") {
+              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} INTEGER DEFAULT 0`);
+            } else {
+              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} TEXT`);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    this.migrations.set(name, true);
+  }
+  ensureVersionsTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.versionsTableName} (
+        id TEXT PRIMARY KEY,
+        collection_slug TEXT NOT NULL,
+        document_id TEXT NOT NULL,
+        tenant_id TEXT,
+        version INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'draft',
+        data TEXT NOT NULL,
+        created_by TEXT,
+        change_description TEXT,
+        published_at TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_${this.versionsTableName}_doc ON ${this.versionsTableName}(collection_slug, document_id)`
+    );
+    this.db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_${this.versionsTableName}_status ON ${this.versionsTableName}(status)`
+    );
+  }
+  ensureDraftsTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.draftsTableName} (
+        id TEXT PRIMARY KEY,
+        collection_slug TEXT NOT NULL,
+        document_id TEXT NOT NULL,
+        tenant_id TEXT,
+        data TEXT NOT NULL,
+        base_updated_at TEXT,
+        draft_updated_at TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_${this.draftsTableName}_document ON ${this.draftsTableName}(collection_slug, document_id, tenant_id)`
+    );
+  }
+  // ========================================================================
+  // SQL Quoting
+  // ========================================================================
+  col(name) {
+    return `"${name}"`;
+  }
+  fieldToSQL(field) {
+    switch (field.type) {
+      case "text":
+      case "email":
+      case "password":
+      case "textarea":
+      case "color":
+      case "code":
+      case "markdown":
+      case "url":
+        return this.col(field.name) + " TEXT";
+      case "number":
+        return this.col(field.name) + " REAL";
+      case "checkbox":
+        return this.col(field.name) + " INTEGER DEFAULT 0";
+      case "date":
+        return this.col(field.name) + " TEXT";
+      case "select":
+      case "radio":
+        return this.col(field.name) + " TEXT";
+      case "relationship":
+      case "upload":
+        return this.col(field.name) + " TEXT";
+      case "json":
+      case "richtext":
+      case "array":
+      case "group":
+      case "blocks":
+        return this.col(field.name) + " TEXT";
+      default:
+        return null;
+    }
+  }
+  // ========================================================================
+  // CRUD Operations
+  // ========================================================================
+  parseGlobalsSlug(slug) {
+    if (slug.startsWith("_globals_")) {
+      const globalSlug = slug.replace("_globals_", "");
+      return {
+        isGlobal: true,
+        globalSlug,
+        tableName: `global_${globalSlug.replace(/-/g, "_")}`
+      };
+    }
+    return {
+      isGlobal: false,
+      globalSlug: "",
+      tableName: this.getTableNameFor(slug)
+    };
+  }
+  async find(args) {
+    const {
+      collection: slug,
+      where = {},
+      sort,
+      limit = 10,
+      page = 1,
+      tenantID,
+      draft = false
+    } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const tableName = parsed.tableName;
+    let sql = `SELECT * FROM ${tableName}`;
+    const params = [];
+    const conditions = [];
+    let effectiveWhere = { ...where };
+    if (this.tenantContext && config.tenantScoped) {
+      const rlsQuery = applyRLS({ where: effectiveWhere }, slug, this.tenantContext, DEFAULT_RLS_CONFIG);
+      effectiveWhere = rlsQuery.where || {};
+    }
+    if (!draft && config.versions?.drafts) {
+      conditions.push(`_status = ?`);
+      params.push("published");
+    }
+    if (tenantID && config.tenantScoped) {
+      conditions.push(`tenant_id = ?`);
+      params.push(tenantID);
+    }
+    for (const [key, value] of Object.entries(effectiveWhere)) {
+      if (key === "AND" || key === "OR") continue;
+      if (typeof value === "object" && value !== null) {
+        if (value.equals !== void 0) {
+          conditions.push(`${this.col(key)} = ?`);
+          params.push(value.equals);
+        }
+        if (value.in !== void 0) {
+          conditions.push(`${this.col(key)} IN (${value.in.map(() => "?").join(", ")})`);
+          params.push(...value.in);
+        }
+        if (value.not_equals !== void 0) {
+          conditions.push(`${this.col(key)} != ?`);
+          params.push(value.not_equals);
+        }
+      } else {
+        conditions.push(`${this.col(key)} = ?`);
+        params.push(value);
+      }
+    }
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    const sortField = this.col(sort?.replace("-", "") || "createdAt");
+    const sortDir = sort?.startsWith("-") ? "DESC" : "ASC";
+    sql += ` ORDER BY ${sortField} ${sortDir}`;
+    const countSql = sql.replace("SELECT *", "SELECT COUNT(*) as count");
+    const countResult = this.db.prepare(countSql).get(...params);
+    const totalDocs = countResult?.count || 0;
+    sql += ` LIMIT ? OFFSET ?`;
+    params.push(limit, (page - 1) * limit);
+    const rows = this.db.prepare(sql).all(...params);
+    let docs = rows.map((row) => this.rowToDoc(row, config));
+    if (this.tenantContext && !this.tenantContext.isSuperAdmin) {
+      docs = docs.filter((doc) => canAccessDocument(doc, slug, this.tenantContext, DEFAULT_RLS_CONFIG));
+    }
+    if (draft) {
+      docs = await Promise.all(docs.map(async (doc) => {
+        if (doc._has_draft) {
+          const versions = await this.findVersions({
+            collection: slug,
+            documentId: doc.id,
+            limit: 1,
+            sort: "-createdAt"
+          });
+          if (versions.docs.length > 0 && versions.docs[0].status === "draft") {
+            return { ...doc, ...versions.docs[0].data, _has_draft: true, _status: doc._status };
+          }
+        }
+        return doc;
+      }));
+    }
+    return {
+      docs,
+      totalDocs,
+      limit,
+      totalPages: Math.ceil(totalDocs / limit),
+      page,
+      pagingCounter: (page - 1) * limit + 1,
+      hasPrevPage: page > 1,
+      hasNextPage: page < Math.ceil(totalDocs / limit),
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < Math.ceil(totalDocs / limit) ? page + 1 : null
+    };
+  }
+  async findByID(args) {
+    const { collection: slug, id, tenantID, draft = false } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const tableName = parsed.tableName;
+    let sql = `SELECT * FROM ${tableName} WHERE id = ?`;
+    const params = [id];
+    if (this.tenantContext && config.tenantScoped) {
+      const tempDoc = { id, tenant_id: this.tenantContext.tenantId };
+      if (!canAccessDocument(tempDoc, slug, this.tenantContext, DEFAULT_RLS_CONFIG)) {
+        return null;
+      }
+    }
+    if (!draft && config.versions?.drafts) {
+      sql += ` AND _status = ?`;
+      params.push("published");
+    }
+    if (tenantID && config.tenantScoped) {
+      sql += ` AND tenant_id = ?`;
+      params.push(tenantID);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return null;
+    let doc = this.rowToDoc(row, config);
+    if (draft && doc._has_draft) {
+      const versions = await this.findVersions({
+        collection: slug,
+        documentId: doc.id,
+        limit: 1,
+        sort: "-createdAt"
+      });
+      if (versions.docs.length > 0 && versions.docs[0].status === "draft") {
+        doc = { ...doc, ...versions.docs[0].data, _has_draft: true, _status: doc._status };
+      }
+    }
+    return doc;
+  }
+  async create(args) {
+    const { collection: slug, data, tenantID } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const tableName = parsed.tableName;
+    const id = parsed.isGlobal ? parsed.globalSlug : data.id || this.generateId();
+    const insertData = this.prepareData(data, config);
+    insertData.id = id;
+    insertData.created_at = (/* @__PURE__ */ new Date()).toISOString();
+    insertData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    if (tenantID && config.tenantScoped) {
+      insertData.tenant_id = tenantID;
+    }
+    const columns = Object.keys(insertData);
+    const validColumns = getTableColumns(this.db, tableName);
+    const filteredData = {};
+    for (const key of columns) {
+      if (validColumns.includes(key)) {
+        filteredData[key] = insertData[key];
+      }
+    }
+    const filteredColumns = Object.keys(filteredData);
+    const quotedColumns = filteredColumns.map((c) => this.col(c));
+    const placeholders = filteredColumns.map(() => "?").join(", ");
+    const values = Object.values(filteredData).map(
+      (v) => typeof v === "object" ? JSON.stringify(v) : v
+    );
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${tableName} (${quotedColumns.join(", ")}) VALUES (${placeholders})`
+    ).run(...values);
+    return this.findByID({ collection: slug, id, tenantID });
+  }
+  async update(args) {
+    const { collection: slug, id, data, tenantID } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const tableName = parsed.tableName;
+    const updateData = this.prepareData(data, config);
+    updateData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const validColumns = getTableColumns(this.db, tableName);
+    const filteredData = {};
+    for (const key of Object.keys(updateData)) {
+      if (validColumns.includes(key)) {
+        filteredData[key] = updateData[key];
+      }
+    }
+    const columns = Object.keys(filteredData);
+    const setClause = columns.map((c) => `${this.col(c)} = ?`).join(", ");
+    const values = Object.values(filteredData).map(
+      (v) => v !== null && typeof v === "object" ? JSON.stringify(v) : v
+    );
+    let sql = `UPDATE ${tableName} SET ${setClause} WHERE id = ?`;
+    const params = [...values, id];
+    if (tenantID && config.tenantScoped) {
+      sql += ` AND tenant_id = ?`;
+      params.push(tenantID);
+    }
+    this.db.prepare(sql).run(...params);
+    return this.findByID({ collection: slug, id, tenantID, draft: true });
+  }
+  async delete(args) {
+    const { collection: slug, id, tenantID } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const doc = await this.findByID({ collection: slug, id, tenantID });
+    if (!doc) throw new Error(`Document not found: ${slug}/${id}`);
+    const tableName = parsed.tableName;
+    let sql = `DELETE FROM ${tableName} WHERE id = ?`;
+    const params = [id];
+    if (tenantID && config.tenantScoped) {
+      sql += ` AND tenant_id = ?`;
+      params.push(tenantID);
+    }
+    this.db.prepare(sql).run(...params);
+    return doc;
+  }
+  async count(args) {
+    const { collection: slug, tenantID } = args;
+    const parsed = this.parseGlobalsSlug(slug);
+    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
+    this.ensureTable(config, parsed.tableName);
+    const tableName = parsed.tableName;
+    let sql = `SELECT COUNT(*) as count FROM ${tableName}`;
+    const params = [];
+    if (tenantID && config.tenantScoped) {
+      sql += ` WHERE tenant_id = ?`;
+      params.push(tenantID);
+    }
+    const result = this.db.prepare(sql).get(...params);
+    return result?.count || 0;
+  }
+  async findOne(args) {
+    const parsed = this.parseGlobalsSlug(args.collection);
+    if (parsed.isGlobal) {
+      const globalConfig = this.globals.get(parsed.globalSlug);
+      if (!globalConfig) {
+        throw new Error(`Global "${parsed.globalSlug}" not found in adapter`);
+      }
+      this.ensureTable(globalConfig, parsed.tableName);
+      let sql = `SELECT * FROM ${parsed.tableName}`;
+      const conditions = [];
+      const params = [];
+      if (!args.draft && globalConfig.versions) {
+        conditions.push("_status = 'published'");
+      }
+      if (conditions.length > 0) {
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      }
+      sql += " LIMIT 1";
+      const result2 = this.db.prepare(sql).get(...params);
+      if (result2) {
+        let doc = this.rowToDoc(result2, globalConfig);
+        if (args.draft && doc._has_draft) {
+          const versions = await this.findVersions({
+            collection: args.collection,
+            documentId: parsed.globalSlug,
+            limit: 1,
+            sort: "-createdAt"
+          });
+          if (versions.docs.length > 0 && versions.docs[0].status === "draft") {
+            doc = { ...doc, ...versions.docs[0].data, _has_draft: true, _status: doc._status };
+          }
+        }
+        return doc;
+      }
+      return null;
+    }
+    const result = await this.find({ ...args, limit: 1 });
+    return result.docs[0] || null;
+  }
+  // ========================================================================
+  // Version History
+  // ========================================================================
+  async findVersions(args) {
+    this.ensureVersionsTable();
+    const { collection, documentId, tenantID, limit = 20, page = 1 } = args;
+    const conditions = [`collection_slug = ?`, `document_id = ?`];
+    const params = [collection, documentId];
+    if (tenantID) {
+      conditions.push(`tenant_id = ?`);
+      params.push(tenantID);
+    } else {
+      conditions.push(`tenant_id IS NULL`);
+    }
+    const where = `WHERE ${conditions.join(" AND ")}`;
+    const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${this.versionsTableName} ${where}`).get(...params);
+    const totalDocs = countResult?.count || 0;
+    const offset = (page - 1) * limit;
+    const rows = this.db.prepare(`SELECT * FROM ${this.versionsTableName} ${where} ORDER BY version DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+    const docs = rows.map((r) => this.rowToVersion(r));
+    return {
+      docs,
+      totalDocs,
+      limit,
+      totalPages: Math.ceil(totalDocs / limit),
+      page,
+      pagingCounter: (page - 1) * limit + 1,
+      hasPrevPage: page > 1,
+      hasNextPage: page < Math.ceil(totalDocs / limit),
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < Math.ceil(totalDocs / limit) ? page + 1 : null
+    };
+  }
+  async findVersionByID(args) {
+    this.ensureVersionsTable();
+    const row = this.db.prepare(`SELECT * FROM ${this.versionsTableName} WHERE id = ? AND collection_slug = ? LIMIT 1`).get(args.versionId, args.collection);
+    return row ? this.rowToVersion(row) : null;
+  }
+  async createVersion(args) {
+    this.ensureVersionsTable();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateId();
+    const latestRow = this.db.prepare(`SELECT version FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? ORDER BY version DESC LIMIT 1`).get(args.collection, args.documentId);
+    const nextVersion = (latestRow?.version ?? 0) + 1;
+    this.db.prepare(
+      `INSERT INTO ${this.versionsTableName} (
+          id, collection_slug, document_id, tenant_id, version, status, data, created_by, change_description, published_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      args.collection,
+      args.documentId,
+      args.tenantID ?? null,
+      nextVersion,
+      args.status,
+      JSON.stringify(args.data),
+      args.createdBy ?? null,
+      args.changeDescription ?? null,
+      args.status === "published" ? now : null,
+      now,
+      now
+    );
+    const collectionConfig = this.collections.get(args.collection);
+    const maxPerDoc = collectionConfig?.versions?.maxPerDoc;
+    if (maxPerDoc && maxPerDoc > 0) {
+      await this.deleteVersions({ collection: args.collection, documentId: args.documentId, keepLatest: maxPerDoc, tenantID: args.tenantID });
+    }
+    const saved = await this.findVersionByID({ collection: args.collection, versionId: id });
+    return saved;
+  }
+  async deleteVersions(args) {
+    this.ensureVersionsTable();
+    const { collection, documentId, keepLatest, tenantID } = args;
+    if (keepLatest && keepLatest > 0) {
+      const rows = this.db.prepare(`SELECT id, status FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? ORDER BY version DESC`).all(collection, documentId);
+      let draftCount = 0;
+      const toDelete = [];
+      for (const row of rows) {
+        if (row.status === "published") continue;
+        draftCount++;
+        if (draftCount > keepLatest) toDelete.push(row.id);
+      }
+      for (const vid of toDelete) {
+        this.db.prepare(`DELETE FROM ${this.versionsTableName} WHERE id = ?`).run(vid);
+      }
+    } else {
+      let sql = `DELETE FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ?`;
+      const params = [collection, documentId];
+      if (tenantID) {
+        sql += ` AND tenant_id = ?`;
+        params.push(tenantID);
+      }
+      this.db.prepare(sql).run(...params);
+    }
+  }
+  rowToVersion(row) {
+    return {
+      id: String(row.id),
+      collection: row.collection_slug,
+      documentId: row.document_id,
+      version: row.version,
+      status: row.status,
+      data: row.data ? JSON.parse(row.data) : {},
+      createdBy: row.created_by ?? void 0,
+      changeDescription: row.change_description ?? void 0,
+      publishedAt: row.published_at ?? null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  async findDraft(args) {
+    this.ensureDraftsTable();
+    let sql = `SELECT * FROM ${this.draftsTableName} WHERE collection_slug = ? AND document_id = ?`;
+    const params = [args.collection, args.documentId];
+    if (args.tenantID) {
+      sql += ` AND tenant_id = ?`;
+      params.push(args.tenantID);
+    } else {
+      sql += ` AND tenant_id IS NULL`;
+    }
+    sql += ` LIMIT 1`;
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return null;
+    return this.rowToDraft(row);
+  }
+  async upsertDraft(args) {
+    this.ensureDraftsTable();
+    const existing = await this.findDraft(args);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const draftUpdatedAt = args.draftUpdatedAt || now;
+    const id = existing?.id || this.generateId();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${this.draftsTableName} (
+          id, collection_slug, document_id, tenant_id, data, base_updated_at, draft_updated_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      args.collection,
+      args.documentId,
+      args.tenantID ?? null,
+      JSON.stringify(args.data),
+      args.baseUpdatedAt ?? null,
+      draftUpdatedAt,
+      existing?.createdAt || now,
+      now
+    );
+    const saved = await this.findDraft(args);
+    if (!saved) {
+      throw new Error("Failed to persist draft snapshot");
+    }
+    return saved;
+  }
+  async deleteDraft(args) {
+    this.ensureDraftsTable();
+    let sql = `DELETE FROM ${this.draftsTableName} WHERE collection_slug = ? AND document_id = ?`;
+    const params = [args.collection, args.documentId];
+    if (args.tenantID) {
+      sql += ` AND tenant_id = ?`;
+      params.push(args.tenantID);
+    } else {
+      sql += ` AND tenant_id IS NULL`;
+    }
+    this.db.prepare(sql).run(...params);
+  }
+  // ========================================================================
+  // Helpers
+  // ========================================================================
+  prepareData(data, config) {
+    const result = {};
+    const fields = flattenFields(config.fields);
+    const processValue = (field, value) => {
+      const f = field;
+      if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
+        return value !== null && value !== void 0 ? JSON.stringify(value) : null;
+      } else if (f.type === "checkbox") {
+        return value ? 1 : 0;
+      } else if (f.type === "number") {
+        return value !== null && value !== "" ? Number(value) : null;
+      } else if (f.type === "upload" || f.type === "image") {
+        if (value === null || value === void 0) return null;
+        if (Array.isArray(value)) {
+          const items = value.map((v) => {
+            if (typeof v === "string") return v;
+            if (typeof v === "object") return v.id || v._id || v;
+            return String(v);
+          });
+          return JSON.stringify(items);
+        }
+        if (typeof value === "string") return value;
+        if (typeof value === "object") return JSON.stringify(value);
+        return String(value);
+      } else if (field.type === "relationship") {
+        if (value === null || value === void 0) return null;
+        if (Array.isArray(value)) {
+          const rels = value.map((v) => {
+            if (typeof v === "string") return v;
+            if (typeof v === "object") return JSON.stringify({ relationTo: field.relationTo, value: v.id || v });
+            return String(v);
+          });
+          return JSON.stringify(rels);
+        }
+        if (typeof value === "string") return value;
+        if (typeof value === "object") return JSON.stringify({ relationTo: field.relationTo, value: value.id || value });
+        return String(value);
+      }
+      return value;
+    };
+    for (const field of fields) {
+      if (!field.name || field.name === "id") continue;
+      const isInTab = config.fields.some(
+        (f) => f.type === "tabs" && "tabs" in f && f.tabs.some((t) => t.fields.some((tf) => tf.name === field.name))
+      );
+      if (isInTab) continue;
+      const value = data[field.name];
+      if (value !== void 0) {
+        result[field.name] = processValue(field, value);
+      }
+    }
+    for (const field of config.fields) {
+      if (field.type === "tabs" && "tabs" in field && field.name) {
+        const tabData = data[field.name];
+        if (tabData && typeof tabData === "object") {
+          for (const tab of field.tabs) {
+            for (const tabField of tab.fields) {
+              if (tabField.name && tabField.name !== "id") {
+                const value = tabData[tabField.name];
+                if (value !== void 0) {
+                  result[tabField.name] = processValue(tabField, value);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return result;
+  }
+  rowToDoc(row, config) {
+    const doc = { id: row.id };
+    for (const field of flattenFields(config.fields)) {
+      if (!field.name || field.name === "id") continue;
+      const f = field;
+      let value = row[f.name];
+      if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
+        try {
+          value = value ? JSON.parse(value) : null;
+        } catch {
+          value = null;
+        }
+      }
+      if (field.type === "checkbox") {
+        value = Boolean(value);
+      }
+      if (field.type === "date" && value) {
+        try {
+          const d = new Date(value);
+          if (isNaN(d.getTime())) {
+            console.warn(`[LocalAdapter] Invalid date value for field "${field.name}":`, value);
+            value = null;
+          } else {
+            value = d.toISOString();
+          }
+        } catch {
+          value = null;
+        }
+      }
+      if ((field.type === "upload" || field.type === "image") && value) {
+        try {
+          const parsed = JSON.parse(value);
+          if (Array.isArray(parsed)) {
+            value = parsed.map((item) => {
+              if (typeof item === "object" && item !== null) {
+                return item;
+              }
+              return { id: item };
+            });
+          } else {
+            value = typeof parsed === "object" ? parsed : { id: parsed };
+          }
+        } catch {
+          value = { id: value };
+        }
+      }
+      if (field.type === "relationship" && value) {
+        try {
+          const parsed = JSON.parse(value);
+          if (Array.isArray(parsed)) {
+            value = parsed;
+          } else {
+            value = parsed;
+          }
+        } catch {
+          value = { relationTo: Array.isArray(field.relationTo) ? field.relationTo[0] : field.relationTo, value };
+        }
+      }
+      doc[field.name] = value;
+    }
+    for (const field of config.fields) {
+      if (!field.name || field.name === "id" || field.name === "row" || field.name === "collapsible") continue;
+      if (field.type === "tabs" && "tabs" in field) {
+        const tabData = {};
+        for (const tab of field.tabs) {
+          for (const tabField of tab.fields) {
+            if (tabField.name && tabField.name !== "id") {
+              tabData[tabField.name] = processFieldValue(row, tabField);
+            }
+          }
+        }
+        doc[field.name] = tabData;
+      }
+    }
+    if (config.timestamps) {
+      const cAt = row.createdAt || row.created_at;
+      const uAt = row.updatedAt || row.updated_at;
+      if (cAt) {
+        try {
+          const d = new Date(cAt);
+          if (!isNaN(d.getTime())) doc.createdAt = d.toISOString();
+        } catch {
+        }
+      }
+      if (uAt) {
+        try {
+          const d = new Date(uAt);
+          if (!isNaN(d.getTime())) doc.updatedAt = d.toISOString();
+        } catch {
+        }
+      }
+    }
+    if (config.tenantScoped) {
+      doc.tenantID = row.tenant_id;
+    }
+    return doc;
+  }
+  generateId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = randomBytes(6).toString("hex");
+    return timestamp + random;
+  }
+  getMediaById(mediaId) {
+    try {
+      const tableName = this.getTableNameFor("media");
+      const row = this.db.prepare(`SELECT id, url, thumbnail_url FROM ${tableName} WHERE id = ?`).get(mediaId);
+      if (row) {
+        return {
+          id: row.id,
+          url: row.url,
+          thumbnailUrl: row.thumbnail_url || row.url
+        };
+      }
+    } catch (err) {
+    }
+    return null;
+  }
+  getTableNameFor(slug) {
+    return slug.replace(/-/g, "_");
+  }
+  rowToDraft(row) {
+    return {
+      id: row.id,
+      collection: row.collection_slug,
+      documentId: row.document_id,
+      tenantID: row.tenant_id ?? void 0,
+      data: row.data ? JSON.parse(row.data) : {},
+      baseUpdatedAt: row.base_updated_at ?? null,
+      draftUpdatedAt: row.draft_updated_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  // ========================================================================
+  // Migrations
+  // ========================================================================
+  async migrate() {
+    for (const config of this.collections.values()) {
+      this.ensureTable(config);
+    }
+    this.ensureDraftsTable();
+    console.log("[LocalAdapter] Migrations complete");
+  }
+  async rollback() {
+    console.log("[LocalAdapter] Rollback not supported for schema changes");
+  }
+  // ========================================================================
+  // Transaction Support
+  // ========================================================================
+  async transaction(fn) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(async () => {
+        return fn({ db: this.db });
+      });
+      try {
+        const result = tx();
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  // ========================================================================
+  // Direct DB Access
+  // ========================================================================
+  getDatabase() {
+    return this.db;
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+};
+function createLocalAdapter(options) {
+  return new LocalAdapter(options || {});
+}
 
-export { ConfigValidationError, Kyro, Registry, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createKyro, createRegistry, fieldToZod, getRegistry, globalToZod, resetRegistry, validateCollection, validateConfig, validateFields, validateGlobal };
-//# sourceMappingURL=chunk-XU7AFF6V.js.map
-//# sourceMappingURL=chunk-XU7AFF6V.js.map
+export { ConfigValidationError, Kyro, LocalAdapter, Registry, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createKyro, createLocalAdapter, createRegistry, fieldToZod, getRegistry, globalToZod, resetRegistry, validateCollection, validateConfig, validateFields, validateGlobal };
+//# sourceMappingURL=chunk-35U3FROB.js.map
+//# sourceMappingURL=chunk-35U3FROB.js.map