@kyro-cms/core 0.10.3 → 0.10.5

package/dist/chunk-GYIJ3JJM.cjs

@@ -1,1069 +0,0 @@
-'use strict';
-
-var chunkGUUB5EAG_cjs = require('./chunk-GUUB5EAG.cjs');
-var drizzleOrm = require('drizzle-orm');
-var pgCore = require('drizzle-orm/pg-core');
-var sqliteCore = require('drizzle-orm/sqlite-core');
-var postgresJs = require('drizzle-orm/postgres-js');
-var postgres = require('postgres');
-var crypto = require('crypto');
-var promises = require('fs/promises');
-var path = require('path');
-var module$1 = require('module');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var postgres__default = /*#__PURE__*/_interopDefault(postgres);
-
-var _schemaEnsured = false;
-function fieldToDrizzleType(field, dialect = "postgres") {
-  switch (field.type) {
-    case "text":
-    case "email":
-    case "password":
-    case "color":
-      return dialect === "sqlite" ? "text" : "varchar";
-    case "textarea":
-    case "code":
-    case "markdown":
-    case "secret":
-      return "text";
-    case "number":
-      return field.integer ? "integer" : "decimal";
-    case "checkbox":
-      return "boolean";
-    case "date":
-      return "timestamp";
-    case "select":
-    case "radio":
-      return dialect === "sqlite" ? "text" : "varchar";
-    case "richtext":
-    case "json":
-    case "array":
-    case "group":
-    case "blocks":
-    case "row":
-    case "collapsible":
-    case "tabs":
-      return "jsonb";
-    case "relationship":
-      return dialect === "sqlite" ? "text" : "varchar";
-    case "upload":
-      return "jsonb";
-    default:
-      return "jsonb";
-  }
-}
-function collectionToDrizzleSchema(collection, dialect = "postgres") {
-  const tableName = collection.slug.replace(/-/g, "_");
-  const lines = [];
-  lines.push(`export const ${tableName} = pgTable('${tableName}', {`);
-  lines.push(`  id: uuid('id').primaryKey().defaultRandom(),`);
-  for (const field of collection.fields) {
-    if (field.name === "id") continue;
-    const dbType = fieldToDrizzleType(field, dialect);
-    const isRequired = field.required;
-    let fieldDef = `  ${field.name}: pg.${dbType}('${field.name}')`;
-    if (field.unique) fieldDef += ".unique()";
-    if (!isRequired) fieldDef += ".nullable()";
-    if (field.defaultValue !== void 0) {
-      if (typeof field.defaultValue === "string") {
-        fieldDef += `.default('${field.defaultValue}')`;
-      } else if (typeof field.defaultValue === "boolean") {
-        fieldDef += `.default(${field.defaultValue})`;
-      } else {
-        fieldDef += `.default(sql\`${JSON.stringify(field.defaultValue)}\`)`;
-      }
-    }
-    fieldDef += ",";
-    lines.push(fieldDef);
-  }
-  if (collection.timestamps) {
-    lines.push(`  createdAt: pg.timestamp('created_at').defaultNow(),`);
-    lines.push(`  updatedAt: pg.timestamp('updated_at').defaultNow(),`);
-  }
-  lines.push(`  status: ${dialect === "sqlite" ? "sqlite" : "pg"}.varchar('status').default('draft'),`);
-  lines.push(`  hasDraft: ${dialect === "sqlite" ? "sqlite" : "pg"}.boolean('hasDraft').default(false),`);
-  lines.push("});");
-  return lines.join("\n");
-}
-var DrizzleAdapter = class extends chunkGUUB5EAG_cjs.AbstractBaseAdapter {
-  client;
-  schema;
-  dialect;
-  connectionString;
-  versionsTableReady = false;
-  constructor(options) {
-    super();
-    this.schema = options.schema || {};
-    if (options.connectionString) {
-      this.connectionString = options.connectionString;
-      const connStr = options.connectionString.toLowerCase();
-      if (connStr.startsWith("postgres://") || connStr.startsWith("postgresql://")) {
-        this.dialect = "postgres";
-      } else if (connStr.includes(".db") || connStr.includes("sqlite") || connStr.includes("file:")) {
-        this.dialect = "sqlite";
-      } else {
-        this.dialect = options.type || "postgres";
-      }
-    } else {
-      this.client = options.client;
-      this.dialect = options.type || "sqlite";
-    }
-  }
-  prepareData(data, config) {
-    const result = super.prepareData(data, config);
-    if (result.createdAt && typeof result.createdAt === "string") {
-      result.createdAt = new Date(result.createdAt);
-    }
-    if (result.updatedAt && typeof result.updatedAt === "string") {
-      result.updatedAt = new Date(result.updatedAt);
-    }
-    for (const field of config.fields) {
-      if (field.type === "date" && field.name) {
-        const value = result[field.name];
-        if (value && typeof value === "string") {
-          result[field.name] = new Date(value);
-        }
-      }
-    }
-    for (const field of config.fields) {
-      const dbType = fieldToDrizzleType(field, this.dialect);
-      const isJsonb = dbType === "jsonb";
-      if (field.type === "tabs" && "tabs" in field && field.name) {
-        const tabData = data[field.name];
-        if (tabData && typeof tabData === "object") {
-          const processedTabData = {};
-          for (const [key, value] of Object.entries(tabData)) {
-            const tabField = field.tabs.flatMap((t) => t.fields).find((f) => f.name === key);
-            const needsStringify = (tabField?.type === "upload" || tabField?.type === "image" || tabField?.type === "list" || tabField?.type === "relationship-block") && value;
-            if (needsStringify) {
-              processedTabData[key] = Array.isArray(value) ? JSON.stringify(value) : typeof value === "object" ? JSON.stringify(value) : value;
-            } else {
-              processedTabData[key] = value;
-            }
-          }
-          result[field.name] = isJsonb ? processedTabData : JSON.stringify(processedTabData);
-        }
-      }
-      if (field.type === "upload" || field.type === "image" || field.type === "list" || field.type === "relationship-block") {
-        if (field.name) {
-          const value = data[field.name];
-          if (value) {
-            result[field.name] = isJsonb ? value : Array.isArray(value) ? JSON.stringify(value) : typeof value === "object" ? JSON.stringify(value) : value;
-          }
-        }
-      }
-    }
-    for (const field of config.fields) {
-      if (field.name && result[field.name] === "") {
-        const dbType = fieldToDrizzleType(field, this.dialect);
-        if (dbType === "timestamp" || dbType === "jsonb" || dbType === "decimal" || dbType === "integer" || dbType === "numeric" || dbType === "boolean") {
-          result[field.name] = null;
-        }
-      }
-    }
-    return result;
-  }
-  async connect() {
-    if (this.connectionString && !this.client) {
-      if (this.dialect === "postgres") {
-        const { default: postgres2 } = await import('postgres');
-        const { drizzle: drizzle2 } = await import('drizzle-orm/postgres-js');
-        const sql2 = postgres2(this.connectionString, { onnotice: () => {
-        } });
-        this.client = drizzle2(sql2, { schema: this.schema });
-      } else if (this.dialect === "sqlite") {
-        const { default: betterSqlite3 } = await import('better-sqlite3');
-        const { drizzle: drizzle2 } = await import('drizzle-orm/better-sqlite3');
-        const db = new betterSqlite3(this.connectionString.replace("file:", ""));
-        this.client = drizzle2(db, { schema: this.schema });
-      }
-    }
-    this.connected = true;
-  }
-  async init(collections, globals = []) {
-    await super.init(collections, globals);
-    if (this.connectionString && !this.client) {
-      await this.connect();
-    }
-    if (this.client && !_schemaEnsured) {
-      for (const config of collections) {
-        const tableName = this.getTableName(config.slug);
-        if (!this.schema[tableName]) {
-          this.schema[tableName] = this.createTableFromConfig(config);
-        }
-      }
-      await this.ensureCollectionTables(collections);
-      const globalCollections = globals.map((g) => ({
-        slug: `_globals_${g.slug}`,
-        fields: g.fields,
-        label: g.label
-      }));
-      for (const gc of globalCollections) {
-        const tableName = this.getTableName(gc.slug);
-        if (!this.schema[tableName]) {
-          this.schema[tableName] = this.createTableFromConfig(gc, true);
-        }
-        if (!this.collections.has(gc.slug)) {
-          this.collections.set(gc.slug, gc);
-        }
-      }
-      await this.ensureCollectionTables(globalCollections);
-      _schemaEnsured = true;
-    }
-  }
-  createTableFromConfig(config, useTextId = false) {
-    const tableName = this.getTableName(config.slug);
-    const columns = {
-      id: useTextId ? pgCore.text("id").primaryKey() : pgCore.uuid("id").primaryKey().defaultRandom()
-    };
-    for (const field of config.fields) {
-      if (!field.name || field.name === "id") continue;
-      const dbType = fieldToDrizzleType(field, this.dialect);
-      const propName = field.name.replace(/-/g, "_");
-      const sqlName = propName.replace(/([A-Z])/g, "_$1").toLowerCase();
-      let col;
-      if (this.dialect === "sqlite") {
-        switch (dbType) {
-          case "varchar":
-          case "text":
-            col = sqliteCore.text(sqlName);
-            break;
-          case "integer":
-            col = sqliteCore.integer(sqlName);
-            break;
-          case "decimal":
-          case "numeric":
-            col = sqliteCore.numeric(sqlName);
-            break;
-          case "boolean":
-            col = sqliteCore.integer(sqlName, { mode: "boolean" });
-            break;
-          case "timestamp":
-            col = sqliteCore.text(sqlName);
-            break;
-          case "jsonb":
-            col = sqliteCore.text(sqlName);
-            break;
-          default:
-            col = sqliteCore.text(sqlName);
-        }
-      } else {
-        switch (dbType) {
-          case "varchar":
-            col = pgCore.varchar(sqlName, { length: 255 });
-            break;
-          case "integer":
-            col = pgCore.integer(sqlName);
-            break;
-          case "decimal":
-            col = pgCore.decimal(sqlName);
-            break;
-          case "boolean":
-            col = pgCore.boolean(sqlName);
-            break;
-          case "timestamp":
-            col = pgCore.timestamp(sqlName);
-            break;
-          case "jsonb":
-            col = pgCore.jsonb(sqlName);
-            break;
-          default:
-            col = pgCore.text(sqlName);
-        }
-      }
-      if (!field.required) col = col.default(null);
-      columns[propName] = col;
-    }
-    if (!columns.createdAt) columns.createdAt = this.dialect === "sqlite" ? sqliteCore.text("created_at").default((/* @__PURE__ */ new Date()).toISOString()) : pgCore.timestamp("created_at").defaultNow();
-    if (!columns.updatedAt) columns.updatedAt = this.dialect === "sqlite" ? sqliteCore.text("updated_at").default((/* @__PURE__ */ new Date()).toISOString()) : pgCore.timestamp("updated_at").defaultNow();
-    columns.status = this.dialect === "sqlite" ? sqliteCore.text("status").default("draft") : pgCore.varchar("status", { length: 20 }).default("draft");
-    columns.hasDraft = this.dialect === "sqlite" ? sqliteCore.integer("hasDraft", { mode: "boolean" }).default(false) : pgCore.boolean("hasDraft").default(false);
-    return this.dialect === "sqlite" ? sqliteCore.sqliteTable(tableName, columns) : pgCore.pgTable(tableName, columns);
-  }
-  async ensureCollectionTables(collections) {
-    const statements = [];
-    for (const config of collections) {
-      const isGlobal = config.slug.startsWith("_globals_");
-      const tableName = this.getTableName(config.slug);
-      const colDefs = this.generateCreateColumns(config);
-      const hasCreated = config.fields.some((f) => f.name === "createdAt");
-      const hasUpdated = config.fields.some((f) => f.name === "updatedAt");
-      if (this.dialect === "postgres") {
-        const idCol = isGlobal ? '"id" TEXT PRIMARY KEY' : '"id" UUID PRIMARY KEY DEFAULT gen_random_uuid()';
-        statements.push(`
-          CREATE TABLE IF NOT EXISTS "${tableName}" (
-            ${idCol},
-            ${colDefs}
-            ${hasCreated ? "" : '"created_at" TIMESTAMP NOT NULL DEFAULT NOW(),'}
-            ${hasUpdated ? "" : '"updated_at" TIMESTAMP NOT NULL DEFAULT NOW(),'}
-            "status" VARCHAR(20) DEFAULT 'draft',
-            "hasDraft" BOOLEAN DEFAULT false
-          )
-        `);
-      } else {
-        const idCol = isGlobal ? '"id" TEXT PRIMARY KEY' : '"id" TEXT PRIMARY KEY';
-        statements.push(`
-          CREATE TABLE IF NOT EXISTS "${tableName}" (
-            ${idCol},
-            ${colDefs}
-            ${hasCreated ? "" : `"created_at" TEXT NOT NULL DEFAULT (datetime('now')),`}
-            ${hasUpdated ? "" : `"updated_at" TEXT NOT NULL DEFAULT (datetime('now')),`}
-            "status" TEXT DEFAULT 'draft',
-            "hasDraft" INTEGER DEFAULT 0
-          )
-        `);
-      }
-    }
-    if (statements.length > 0) {
-      if (this.dialect === "postgres") {
-        await this.client.execute(drizzleOrm.sql.raw(statements.join(";\n")));
-      } else {
-        for (const stmt of statements) {
-          await this.client.execute(drizzleOrm.sql.raw(stmt));
-        }
-      }
-    }
-    for (const config of collections) {
-      const tableName = this.getTableName(config.slug);
-      if (tableName === "users" || tableName === "audit_logs") continue;
-      await this.syncTableColumns(config, tableName);
-    }
-  }
-  getColumnSqlDefinition(field, dialect) {
-    const dbType = fieldToDrizzleType(field, dialect);
-    const sqlName = field.name.replace(/-/g, "_").replace(/([A-Z])/g, "_$1").toLowerCase();
-    const sqlType = this.columnSqlType(dbType, dialect);
-    return `"${sqlName}" ${sqlType} DEFAULT NULL`;
-  }
-  columnSqlType(dbType, dialect) {
-    if (dialect === "sqlite") {
-      switch (dbType) {
-        case "varchar":
-          return "TEXT";
-        case "text":
-          return "TEXT";
-        case "integer":
-          return "INTEGER";
-        case "decimal":
-        case "numeric":
-          return "NUMERIC";
-        case "boolean":
-          return "INTEGER";
-        case "timestamp":
-          return "TEXT";
-        case "jsonb":
-          return "TEXT";
-        default:
-          return "TEXT";
-      }
-    }
-    switch (dbType) {
-      case "varchar":
-        return "VARCHAR(255)";
-      case "text":
-        return "TEXT";
-      case "integer":
-        return "INTEGER";
-      case "decimal":
-      case "numeric":
-        return "DECIMAL";
-      case "boolean":
-        return "BOOLEAN";
-      case "timestamp":
-        return "TIMESTAMP";
-      case "jsonb":
-        return "JSONB";
-      default:
-        return "TEXT";
-    }
-  }
-  getExpectedColumnDefs(config, tableName) {
-    const defs = {};
-    const isGlobal = config.slug.startsWith("_globals_");
-    const hasCreated = config.fields.some((f) => f.name === "createdAt");
-    const hasUpdated = config.fields.some((f) => f.name === "updatedAt");
-    if (this.dialect === "postgres") {
-      defs["id"] = isGlobal ? '"id" TEXT PRIMARY KEY' : '"id" UUID PRIMARY KEY DEFAULT gen_random_uuid()';
-      if (!hasCreated) defs["created_at"] = '"created_at" TIMESTAMP DEFAULT NULL';
-      if (!hasUpdated) defs["updated_at"] = '"updated_at" TIMESTAMP DEFAULT NULL';
-      defs["status"] = '"status" VARCHAR(20) DEFAULT NULL';
-      defs["hasDraft"] = '"hasDraft" BOOLEAN DEFAULT NULL';
-    } else {
-      defs["id"] = '"id" TEXT PRIMARY KEY';
-      if (!hasCreated) defs["created_at"] = '"created_at" TEXT DEFAULT NULL';
-      if (!hasUpdated) defs["updated_at"] = '"updated_at" TEXT DEFAULT NULL';
-      defs["status"] = '"status" TEXT DEFAULT NULL';
-      defs["hasDraft"] = '"hasDraft" INTEGER DEFAULT NULL';
-    }
-    for (const field of config.fields) {
-      if (!field.name || field.name === "id") continue;
-      const def = this.getColumnSqlDefinition(field, this.dialect);
-      const sqlName = field.name.replace(/-/g, "_").replace(/([A-Z])/g, "_$1").toLowerCase();
-      defs[sqlName] = def;
-    }
-    return defs;
-  }
-  async syncTableColumns(config, tableName) {
-    let existingCols;
-    try {
-      if (this.dialect === "postgres") {
-        const result = await this.client.execute(
-          drizzleOrm.sql`SELECT column_name, data_type, character_maximum_length FROM information_schema.columns WHERE table_name = ${tableName}`
-        );
-        existingCols = new Map(result.map((r) => [r.column_name, { type: r.data_type, maxLen: r.character_maximum_length }]));
-      } else {
-        const result = await this.client.execute(
-          drizzleOrm.sql`PRAGMA table_info("${drizzleOrm.sql.raw(tableName)}")`
-        );
-        existingCols = new Map(result.map((r) => [r.name, { type: r.type, maxLen: null }]));
-      }
-    } catch {
-      return;
-    }
-    const expected = this.getExpectedColumnDefs(config, tableName);
-    const missing = Object.keys(expected).filter((k) => !existingCols.has(k));
-    if (missing.length > 0) {
-      const alterStmts = missing.map((k) => `ALTER TABLE "${tableName}" ADD COLUMN ${expected[k]}`);
-      await this.executeRaw(drizzleOrm.sql.raw(alterStmts.join(";\n")));
-    }
-    if (this.dialect === "postgres") {
-      for (const field of config.fields) {
-        if (!field.name || field.name === "id") continue;
-        const expectedDbType = fieldToDrizzleType(field, this.dialect);
-        const sqlName = field.name.replace(/-/g, "_").replace(/([A-Z])/g, "_$1").toLowerCase();
-        const info = existingCols.get(sqlName);
-        if (!info || info.type !== "character varying") continue;
-        if (expectedDbType === "text") {
-          await this.executeRaw(drizzleOrm.sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "${sqlName}" TYPE TEXT`));
-        } else if (expectedDbType === "jsonb") {
-          await this.executeRaw(drizzleOrm.sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "${sqlName}" DROP DEFAULT`));
-          await this.executeRaw(drizzleOrm.sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "${sqlName}" TYPE JSONB USING (CASE WHEN "${sqlName}" IS NULL THEN NULL WHEN "${sqlName}"::text ~ '^\\s*\\{' THEN "${sqlName}"::jsonb ELSE jsonb_build_object('id', "${sqlName}"::text) END)`));
-        }
-      }
-    }
-  }
-  generateCreateColumns(config) {
-    const cols = [];
-    for (const field of config.fields) {
-      if (!field.name || field.name === "id") continue;
-      const dbType = fieldToDrizzleType(field, this.dialect);
-      const sqlName = field.name.replace(/-/g, "_").replace(/([A-Z])/g, "_$1").toLowerCase();
-      const nullable = field.required ? "NOT NULL" : "DEFAULT NULL";
-      let sqlType;
-      if (this.dialect === "sqlite") {
-        switch (dbType) {
-          case "varchar":
-          case "text":
-            sqlType = `TEXT ${nullable}`;
-            break;
-          case "integer":
-            sqlType = `INTEGER ${nullable}`;
-            break;
-          case "decimal":
-          case "numeric":
-            sqlType = `NUMERIC ${nullable}`;
-            break;
-          case "boolean":
-            sqlType = `INTEGER ${nullable}`;
-            break;
-          case "timestamp":
-            sqlType = `TEXT ${nullable}`;
-            break;
-          case "jsonb":
-            sqlType = `TEXT ${nullable}`;
-            break;
-          default:
-            sqlType = `TEXT ${nullable}`;
-        }
-      } else {
-        switch (dbType) {
-          case "varchar":
-            sqlType = `VARCHAR(255) ${nullable}`;
-            break;
-          case "integer":
-            sqlType = `INTEGER ${nullable}`;
-            break;
-          case "decimal":
-            sqlType = `DECIMAL ${nullable}`;
-            break;
-          case "boolean":
-            sqlType = `BOOLEAN ${nullable}`;
-            break;
-          case "timestamp":
-            sqlType = `TIMESTAMP ${nullable}`;
-            break;
-          case "jsonb":
-            sqlType = `JSONB ${nullable}`;
-            break;
-          default:
-            sqlType = `TEXT ${nullable}`;
-        }
-      }
-      cols.push(`"${sqlName}" ${sqlType}`);
-    }
-    return cols.join(",\n          ") + (cols.length > 0 ? "," : "");
-  }
-  async disconnect() {
-    this.connected = false;
-  }
-  async find(args) {
-    const { collection: slug, where = {}, sort, limit = 10, page = 1, tenantID, select, draft } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    let effectiveWhere = { ...where };
-    if (this.tenantContext && config.tenantScoped) {
-      const rlsQuery = chunkGUUB5EAG_cjs.applyRLS({ where: effectiveWhere }, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG);
-      effectiveWhere = rlsQuery.where || {};
-    }
-    const filters = this.buildWhereClause(effectiveWhere, config, table, tenantID);
-    if (!draft && table.status) {
-      filters.push(drizzleOrm.eq(table.status, "published"));
-    }
-    const sortOption = this.parseSort(sort);
-    const countWhere = !draft && table.status ? { ...effectiveWhere, status: "published" } : effectiveWhere;
-    const totalDocs = await this.count({ collection: slug, where: countWhere, tenantID });
-    const offset = (page - 1) * limit;
-    let results = [];
-    try {
-      const sortCol = table[sortOption.field] || table.createdAt || table.id;
-      const sorted = sortOption.direction === "asc" ? sortCol : drizzleOrm.desc(sortCol);
-      let query = this.client.select().from(table);
-      if (filters.length > 0) {
-        query = query.where(drizzleOrm.and(...filters));
-      }
-      results = await query.orderBy(sorted).limit(limit).offset(offset);
-    } catch (error) {
-      console.error(`[DrizzleAdapter] Query error:`, error);
-    }
-    let docs = results.map((doc) => this.processResult(doc, config));
-    if (this.tenantContext && !this.tenantContext.isSuperAdmin) {
-      docs = docs.filter((doc) => chunkGUUB5EAG_cjs.canAccessDocument(doc, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG));
-    }
-    if (draft) {
-      docs = await Promise.all(docs.map(async (doc) => {
-        const versions = await this.executeRaw(drizzleOrm.sql`
-          SELECT * FROM kyro_versions
-          WHERE collection_slug = ${slug}
-          AND document_id = ${doc.id}
-          ORDER BY created_at DESC
-          LIMIT 1
-        `);
-        if (versions.length > 0) {
-          const ver = versions[0];
-          const versionData = typeof ver.data === "string" ? JSON.parse(ver.data) : ver.data;
-          return { ...doc, ...versionData, status: doc.status };
-        }
-        return doc;
-      }));
-    }
-    return {
-      docs,
-      ...this.calculatePagination(page, limit, totalDocs)
-    };
-  }
-  async findByID(args) {
-    const { collection: slug, id, tenantID, draft } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    if (this.tenantContext && config.tenantScoped) {
-      const tempDoc = { id, tenantId: this.tenantContext.tenantId };
-      if (!chunkGUUB5EAG_cjs.canAccessDocument(tempDoc, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG)) {
-        return null;
-      }
-    }
-    const conditions = [drizzleOrm.eq(table.id, id)];
-    if (tenantID && table.tenantId) conditions.push(drizzleOrm.eq(table.tenantId, tenantID));
-    if (!draft && table.status) conditions.push(drizzleOrm.eq(table.status, "published"));
-    const whereClause = conditions.length > 1 ? drizzleOrm.and(...conditions) : conditions[0];
-    let allRows = await this.client.select().from(table).where(whereClause);
-    if (allRows.length === 0) return null;
-    let doc = this.processResult(allRows[0], config);
-    if (draft) {
-      const versions = await this.executeRaw(drizzleOrm.sql`
-        SELECT * FROM kyro_versions
-        WHERE collection_slug = ${slug}
-        AND document_id = ${doc.id}
-        ORDER BY created_at DESC
-        LIMIT 1
-      `);
-      if (versions.length > 0) {
-        const ver = versions[0];
-        const versionData = typeof ver.data === "string" ? JSON.parse(ver.data) : ver.data;
-        doc = { ...doc, ...versionData, status: doc.status };
-      }
-    }
-    return doc;
-  }
-  async create(args) {
-    const { collection: slug, data, tenantID } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    const insertData = this.prepareData(data, config);
-    if (tenantID) {
-      insertData.tenantId = tenantID;
-    }
-    const result = await this.client.insert(table).values(insertData).returning();
-    return this.processResult(result[0], config);
-  }
-  async update(args) {
-    const { collection: slug, id, data, tenantID } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    const updateData = this.prepareData(data, config);
-    delete updateData.id;
-    const conditions = [drizzleOrm.eq(table.id, id)];
-    if (tenantID && table.tenantId) {
-      conditions.push(drizzleOrm.eq(table.tenantId, tenantID));
-    }
-    const result = await this.client.update(table).set(updateData).where(drizzleOrm.and(...conditions)).returning();
-    if (result.length === 0) {
-      throw new Error(`Document not found: ${slug}/${id}`);
-    }
-    return this.processResult(result[0], config);
-  }
-  async delete(args) {
-    const { collection: slug, id, tenantID } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    const conditions = [drizzleOrm.eq(table.id, id)];
-    if (tenantID && table.tenantId) {
-      conditions.push(drizzleOrm.eq(table.tenantId, tenantID));
-    }
-    const result = await this.client.delete(table).where(drizzleOrm.and(...conditions)).returning();
-    if (result.length === 0) {
-      throw new Error(`Document not found: ${slug}/${id}`);
-    }
-    return this.processResult(result[0], config);
-  }
-  async count(args) {
-    const { collection: slug, where = {}, tenantID } = args;
-    const config = this.getCollection(slug);
-    const table = this.getTable(slug);
-    const filters = this.buildWhereClause(where, config, table, tenantID);
-    try {
-      let query = this.client.select({ count: drizzleOrm.sql`count(*)` }).from(table);
-      if (filters.length > 0) {
-        query = query.where(drizzleOrm.and(...filters));
-      }
-      const result = await query;
-      return Number(result[0]?.count || 0);
-    } catch {
-      return 0;
-    }
-  }
-  async findOne(args) {
-    const { collection: slug, where = {}, tenantID, draft } = args;
-    if (slug.startsWith("_globals_")) {
-      const globalSlug = slug.replace("_globals_", "");
-      const globalConfig = this.globals.get(globalSlug);
-      if (!globalConfig) throw new Error(`Global "${globalSlug}" not found`);
-      const table = this.getTable(slug);
-      let query = this.client.select().from(table);
-      if (!draft && table.status) {
-        query = query.where(drizzleOrm.eq(table.status, "published"));
-      }
-      const results = await query.limit(1);
-      if (results.length === 0) return null;
-      let doc = this.processResult(results[0], globalConfig);
-      if (draft) {
-        const versions = await this.executeRaw(drizzleOrm.sql`
-          SELECT * FROM kyro_versions
-          WHERE collection_slug = ${slug}
-          AND document_id = ${globalSlug}
-          ORDER BY created_at DESC
-          LIMIT 1
-        `);
-        if (versions.length > 0) {
-          const ver = versions[0];
-          const versionData = typeof ver.data === "string" ? JSON.parse(ver.data) : ver.data;
-          doc = { ...doc, ...versionData, status: doc.status };
-        }
-      }
-      return doc;
-    }
-    const result = await this.find({ ...args, limit: 1 });
-    return result.docs[0] || null;
-  }
-  async findVersions(args) {
-    await this.ensureVersionsTable();
-    const { collection: slug, documentId, limit = 10, page = 1, tenantID } = args;
-    const offset = (page - 1) * limit;
-    const countResult = await this.executeRaw(drizzleOrm.sql`
-      SELECT count(*) as count 
-      FROM kyro_versions 
-      WHERE collection_slug = ${slug} 
-      AND document_id = ${documentId}
-      AND autosave = 0
-      ${tenantID ? drizzleOrm.sql`AND tenant_id = ${tenantID}` : drizzleOrm.sql``}
-    `);
-    const totalDocs = parseInt(countResult[0]?.count || "0");
-    const results = await this.executeRaw(drizzleOrm.sql`
-      SELECT * 
-      FROM kyro_versions 
-      WHERE collection_slug = ${slug} 
-      AND document_id = ${documentId}
-      AND autosave = 0
-      ${tenantID ? drizzleOrm.sql`AND tenant_id = ${tenantID}` : drizzleOrm.sql``}
-      ORDER BY created_at DESC
-      LIMIT ${limit}
-      OFFSET ${offset}
-    `);
-    return {
-      docs: results.map((row) => ({
-        ...row,
-        data: typeof row.data === "string" ? JSON.parse(row.data) : row.data
-      })),
-      ...this.calculatePagination(page, limit, totalDocs)
-    };
-  }
-  async findVersionByID(args) {
-    await this.ensureVersionsTable();
-    const results = await this.executeRaw(drizzleOrm.sql`
-      SELECT * FROM kyro_versions 
-      WHERE id = ${args.versionId} 
-      AND collection_slug = ${args.collection}
-      ${args.tenantID ? drizzleOrm.sql`AND tenant_id = ${args.tenantID}` : drizzleOrm.sql``}
-      LIMIT 1
-    `);
-    if (results.length === 0) return null;
-    const row = results[0];
-    return {
-      ...row,
-      data: typeof row.data === "string" ? JSON.parse(row.data) : row.data
-    };
-  }
-  async createVersion(args) {
-    await this.ensureVersionsTable();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (args.autosave) {
-      const existing = await this.executeRaw(drizzleOrm.sql`
-        SELECT * FROM kyro_versions
-        WHERE collection_slug = ${args.collection}
-        AND document_id = ${args.documentId}
-        AND autosave = 1
-        ${args.tenantID ? drizzleOrm.sql`AND tenant_id = ${args.tenantID}` : drizzleOrm.sql``}
-        LIMIT 1
-      `);
-      if (existing.length > 0) {
-        await this.executeRaw(drizzleOrm.sql`
-          UPDATE kyro_versions
-          SET data = ${JSON.stringify(args.data)},
-              status = ${args.status},
-              updated_at = ${now}
-          WHERE id = ${existing[0].id}
-        `);
-        return this.findVersionByID({ collection: args.collection, versionId: existing[0].id, tenantID: args.tenantID });
-      }
-    }
-    const id = Math.random().toString(36).substring(2, 15);
-    await this.executeRaw(drizzleOrm.sql`
-      INSERT INTO kyro_versions (
-        id, collection_slug, document_id, tenant_id, data, status, autosave, created_by, change_description, created_at, updated_at
-      ) VALUES (
-        ${id}, ${args.collection}, ${args.documentId}, ${args.tenantID || null}, 
-        ${JSON.stringify(args.data)}, ${args.status}, ${args.autosave ? 1 : 0}, ${args.createdBy || null}, 
-        ${args.changeDescription || null}, ${now}, ${now}
-      )
-    `);
-    if (!args.autosave) {
-      const config = this.getCollection(args.collection);
-      if (config.versions?.maxPerDoc) {
-        await this.deleteVersions({
-          collection: args.collection,
-          documentId: args.documentId,
-          keepLatest: config.versions.maxPerDoc,
-          tenantID: args.tenantID
-        });
-      }
-    }
-    return this.findVersionByID({ collection: args.collection, versionId: id, tenantID: args.tenantID });
-  }
-  async updateLatestVersion(args) {
-    return this.createVersion({ ...args, autosave: true });
-  }
-  async deleteVersions(args) {
-    await this.ensureVersionsTable();
-    if (args.keepLatest) {
-      const toKeep = await this.executeRaw(drizzleOrm.sql`
-        SELECT id FROM kyro_versions
-        WHERE collection_slug = ${args.collection}
-        AND document_id = ${args.documentId}
-        AND autosave = 0
-        ${args.tenantID ? drizzleOrm.sql`AND tenant_id = ${args.tenantID}` : drizzleOrm.sql``}
-        ORDER BY created_at DESC
-        LIMIT ${args.keepLatest}
-      `);
-      const keepIds = toKeep.map((r) => r.id);
-      if (keepIds.length > 0) {
-        await this.executeRaw(drizzleOrm.sql`
-          DELETE FROM kyro_versions
-          WHERE collection_slug = ${args.collection}
-          AND document_id = ${args.documentId}
-          AND autosave = 0
-          AND id NOT IN (${drizzleOrm.sql.join(keepIds.map((id) => drizzleOrm.sql`${id}`), drizzleOrm.sql`, `)})
-        `);
-      }
-    } else {
-      await this.executeRaw(drizzleOrm.sql`
-        DELETE FROM kyro_versions
-        WHERE collection_slug = ${args.collection}
-        AND document_id = ${args.documentId}
-        ${args.tenantID ? drizzleOrm.sql`AND tenant_id = ${args.tenantID}` : drizzleOrm.sql``}
-      `);
-    }
-  }
-  // ========================================================================
-  // Helper Methods
-  // ========================================================================
-  getTable(slug) {
-    const tableName = this.getTableName(slug);
-    const table = this.schema[tableName];
-    if (!table) {
-      throw new Error(`Table "${tableName}" not found in schema`);
-    }
-    return table;
-  }
-  buildWhereClause(where, config, table, tenantID) {
-    const conditions = [];
-    if (tenantID && config.tenantScoped && table.tenantId) {
-      conditions.push(drizzleOrm.eq(table.tenantId, tenantID));
-    }
-    for (const [key, value] of Object.entries(where)) {
-      if (key === "AND" && Array.isArray(value)) {
-        const andConditions = value.map((sub) => this.buildWhereClause(sub, config, table)).flat().filter(Boolean);
-        if (andConditions.length > 0) {
-          conditions.push(drizzleOrm.and(...andConditions));
-        }
-      } else if (key === "OR" && Array.isArray(value)) {
-        const orConditions = value.map((sub) => this.buildWhereClause(sub, config, table)).flat().filter(Boolean);
-        if (orConditions.length > 0) {
-          conditions.push(drizzleOrm.or(...orConditions));
-        }
-      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        const col = table[key];
-        if (!col) continue;
-        if (value.equals !== void 0) conditions.push(drizzleOrm.eq(col, value.equals));
-        if (value.not_equals !== void 0) conditions.push(drizzleOrm.ne(col, value.not_equals));
-        if (value.in && Array.isArray(value.in)) conditions.push(drizzleOrm.inArray(col, value.in));
-        if (value.like !== void 0) conditions.push(drizzleOrm.like(col, value.like));
-        if (value.contains !== void 0) conditions.push(drizzleOrm.like(col, `%${value.contains}%`));
-        if (value.greater_than !== void 0) conditions.push(drizzleOrm.gt(col, value.greater_than));
-        if (value.greater_than_equal !== void 0) conditions.push(drizzleOrm.gte(col, value.greater_than_equal));
-        if (value.less_than !== void 0) conditions.push(drizzleOrm.lt(col, value.less_than));
-        if (value.less_than_equal !== void 0) conditions.push(drizzleOrm.lte(col, value.less_than_equal));
-      } else {
-        const col = table[key];
-        if (col) conditions.push(drizzleOrm.eq(col, value));
-      }
-    }
-    return conditions;
-  }
-  processResult(data, config) {
-    if (!data) return null;
-    const result = { ...data };
-    if (data.id) {
-      result.id = String(data.id);
-    }
-    for (const field of config.fields) {
-      if (!field.name) continue;
-      const sqlKey = field.name.replace(/-/g, "_").replace(/([A-Z])/g, "_$1").toLowerCase();
-      if (sqlKey !== field.name && result[sqlKey] !== void 0 && result[field.name] === void 0) {
-        result[field.name] = result[sqlKey];
-        delete result[sqlKey];
-      }
-    }
-    for (const field of config.fields) {
-      if (["json", "richtext", "array", "group", "blocks", "upload", "image", "list", "relationship-block"].includes(field.type)) {
-        const f = field;
-        if (result[f.name] && typeof result[f.name] === "string") {
-          try {
-            const parsed = JSON.parse(result[f.name]);
-            result[f.name] = parsed;
-          } catch {
-          }
-        }
-      }
-      if (field.type === "tabs" && "tabs" in field && field.name) {
-        if (typeof result[field.name] === "object" && result[field.name] !== null && !Array.isArray(result[field.name])) {
-          for (const tab of field.tabs) {
-            for (const tabField of tab.fields) {
-              if ((tabField.type === "upload" || tabField.type === "image") && tabField.name) {
-                const val = result[field.name][tabField.name];
-                if (typeof val === "string") {
-                  try {
-                    const parsed = JSON.parse(val);
-                    result[field.name][tabField.name] = Array.isArray(parsed) ? parsed.map((item) => item && typeof item === "object" && typeof item.id === "string" ? item.id : String(item || "")) : typeof parsed.id === "string" ? parsed.id : String(parsed.id || "");
-                  } catch {
-                  }
-                } else if (val && typeof val === "object") {
-                  result[field.name][tabField.name] = Array.isArray(val) ? val.map((item) => item && typeof item === "object" && typeof item.id === "string" ? item.id : String(item || "")) : typeof val.id === "string" ? val.id : String(val.id || "");
-                }
-              }
-            }
-          }
-          continue;
-        }
-        if (typeof result[field.name] === "string") {
-          try {
-            const parsed = JSON.parse(result[field.name]);
-            if (typeof parsed === "object" && parsed !== null) {
-              result[field.name] = parsed;
-              continue;
-            }
-          } catch {
-          }
-        }
-        const tabData = {};
-        for (const tab of field.tabs) {
-          for (const tabField of tab.fields) {
-            if (tabField.name && result[tabField.name] !== void 0) {
-              let value = result[tabField.name];
-              if (["json", "richtext", "array", "group", "blocks", "upload", "image", "list", "relationship-block"].includes(tabField.type)) {
-                if (value && typeof value === "string") {
-                  try {
-                    value = JSON.parse(value);
-                  } catch {
-                  }
-                }
-                if ((tabField.type === "upload" || tabField.type === "image") && value && typeof value === "object") {
-                  value = Array.isArray(value) ? value.map((item) => item && typeof item === "object" && typeof item.id === "string" ? item.id : String(item || "")) : typeof value.id === "string" ? value.id : String(value.id || "");
-                }
-              }
-              tabData[tabField.name] = value;
-              delete result[tabField.name];
-            }
-          }
-        }
-        result[field.name] = tabData;
-      }
-    }
-    if (result.createdAt) {
-      result.createdAt = new Date(result.createdAt).toISOString();
-    }
-    if (result.updatedAt) {
-      result.updatedAt = new Date(result.updatedAt).toISOString();
-    }
-    return result;
-  }
-  async ensureVersionsTable() {
-    if (this.versionsTableReady) return;
-    let createTableSQL;
-    if (this.dialect === "sqlite") {
-      createTableSQL = `
-        CREATE TABLE IF NOT EXISTS kyro_versions (
-          id text PRIMARY KEY,
-          collection_slug text NOT NULL,
-          document_id text NOT NULL,
-          tenant_id text,
-          data text NOT NULL,
-          status text NOT NULL DEFAULT 'draft',
-          autosave integer NOT NULL DEFAULT 0,
-          created_by text,
-          change_description text,
-          created_at text DEFAULT (datetime('now')),
-          updated_at text DEFAULT (datetime('now'))
-        )
-      `;
-    } else {
-      createTableSQL = `
-        CREATE TABLE IF NOT EXISTS kyro_versions (
-          id text PRIMARY KEY,
-          collection_slug text NOT NULL,
-          document_id text NOT NULL,
-          tenant_id text,
-          data text NOT NULL,
-          status text NOT NULL,
-          autosave integer NOT NULL DEFAULT 0,
-          created_by text,
-          change_description text,
-          created_at text NOT NULL,
-          updated_at text NOT NULL
-        )
-      `;
-    }
-    await this.executeRaw(drizzleOrm.sql.raw(createTableSQL));
-    try {
-      if (this.dialect === "postgres") {
-        await this.executeRaw(drizzleOrm.sql.raw(`ALTER TABLE kyro_versions ADD COLUMN IF NOT EXISTS autosave integer NOT NULL DEFAULT 0`));
-      } else {
-        await this.executeRaw(drizzleOrm.sql.raw(`ALTER TABLE kyro_versions ADD COLUMN autosave integer NOT NULL DEFAULT 0`));
-      }
-    } catch {
-    }
-    this.versionsTableReady = true;
-  }
-  async executeRaw(query) {
-    const result = await this.client.execute(query);
-    if (Array.isArray(result)) {
-      return result;
-    }
-    if (Array.isArray(result?.rows)) {
-      return result.rows;
-    }
-    if (Array.isArray(result?.[0])) {
-      return result[0];
-    }
-    return [];
-  }
-};
-function createDrizzleAdapter(options) {
-  return new DrizzleAdapter(options);
-}
-var _require = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-GYIJ3JJM.cjs', document.baseURI).href)));
-var modPath = "node:sqlite";
-var { DatabaseSync } = _require(modPath);
-function getDialect() {
-  const val = process.env.DB_TYPE;
-  if (val === "postgres") return "postgres";
-  return "sqlite";
-}
-function genId() {
-  return crypto.randomBytes(16).toString("hex");
-}
-async function createDatabase() {
-  const dialect = getDialect();
-  if (dialect === "sqlite") {
-    const dbPath = path.resolve(process.cwd(), "data", "kyro.db");
-    await promises.mkdir(path.dirname(dbPath), { recursive: true });
-    const db2 = new DatabaseSync(dbPath);
-    db2.exec("PRAGMA journal_mode = WAL");
-    return { db: db2, dialect, genId };
-  }
-  const databaseUrl = process.env.DATABASE_URL || "postgresql://postgres:postgres@localhost:5432/kyro_cms";
-  const maxConnections = parseInt(process.env.DB_POOL_MAX || "10", 10);
-  const ssl = process.env.DB_SSL === "true";
-  const client = postgres__default.default(databaseUrl, {
-    max: maxConnections,
-    ssl: ssl ? "require" : false,
-    onnotice: () => {
-    }
-  });
-  const db = postgresJs.drizzle(client);
-  return { db, dialect, genId };
-}
-async function runMigrations(_db, _dialect) {
-}
-async function seedDefaultRoles(db) {
-  const { roles } = await import('./schema-6QL3USNB.cjs');
-  await db.insert(roles).values({
-    name: "super_admin",
-    level: 100,
-    inherits: [],
-    description: "Full system access across all tenants",
-    isSystem: true
-  }).onConflictDoNothing();
-}
-
-exports.DrizzleAdapter = DrizzleAdapter;
-exports.collectionToDrizzleSchema = collectionToDrizzleSchema;
-exports.createDatabase = createDatabase;
-exports.createDrizzleAdapter = createDrizzleAdapter;
-exports.fieldToDrizzleType = fieldToDrizzleType;
-exports.genId = genId;
-exports.runMigrations = runMigrations;
-exports.seedDefaultRoles = seedDefaultRoles;
-//# sourceMappingURL=chunk-GYIJ3JJM.cjs.map
-//# sourceMappingURL=chunk-GYIJ3JJM.cjs.map