@kyro-cms/core 0.3.2 → 0.3.5

package/dist/chunk-R4C4O4SE.cjs

@@ -0,0 +1,622 @@
+'use strict';
+
+var chunkKOCTZKPV_cjs = require('./chunk-KOCTZKPV.cjs');
+var drizzleOrm = require('drizzle-orm');
+
+function fieldToDrizzleType(field, dialect = "postgres") {
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "password":
+    case "textarea":
+    case "color":
+    case "code":
+    case "markdown":
+      return dialect === "sqlite" ? "text" : "varchar";
+    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 dialect === "sqlite" ? "text" : "varchar";
+    default:
+      return "jsonb";
+  }
+}
+function collectionToDrizzleSchema(collection, dialect = "postgres") {
+  const tableName = collection.slug.replace(/-/g, "_");
+  const lines = [];
+  lines.push(`export const ${tableName} = ${dialect === "mysql" ? "mysqlTable" : "pgTable"}('${tableName}', {`);
+  lines.push(`  id: ${dialect === "mysql" ? "varchar" : "uuid"}('${dialect === "mysql" ? "id" : "id"}').${dialect === "mysql" ? "primaryKey().default(sql`UUID()`)" : "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}: ${dialect === "mysql" ? "mysql" : "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: ${dialect === "mysql" ? "mysql" : "pg"}.timestamp('created_at').defaultNow(),`);
+    lines.push(`  updatedAt: ${dialect === "mysql" ? "mysql" : "pg"}.timestamp('updated_at').defaultNow(),`);
+  }
+  lines.push(`  _status: ${dialect === "sqlite" ? "mysql" : "pg"}.varchar('_status').default('published'),`);
+  lines.push(`  _has_draft: ${dialect === "sqlite" ? "mysql" : "pg"}.boolean('_has_draft').default(false),`);
+  lines.push("});");
+  return lines.join("\n");
+}
+var DrizzleAdapter = class extends chunkKOCTZKPV_cjs.AbstractBaseAdapter {
+  client;
+  schema;
+  dialect;
+  draftsTableReady = false;
+  versionsTableReady = false;
+  constructor(options) {
+    super();
+    this.client = options.client;
+    this.schema = options.schema || {};
+    this.dialect = options.type;
+  }
+  prepareData(data, config) {
+    const result = super.prepareData(data, config);
+    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") {
+          const processedTabData = {};
+          for (const [key, value] of Object.entries(tabData)) {
+            const tabField = field.tabs.flatMap((t) => t.fields).find((f) => f.name === key);
+            if ((tabField?.type === "upload" || tabField?.type === "image" || tabField?.type === "list" || tabField?.type === "relationship-block") && value) {
+              if (Array.isArray(value)) {
+                processedTabData[key] = JSON.stringify(value);
+              } else if (typeof value === "object") {
+                processedTabData[key] = JSON.stringify(value);
+              } else {
+                processedTabData[key] = value;
+              }
+            } else {
+              processedTabData[key] = value;
+            }
+          }
+          result[field.name] = JSON.stringify(processedTabData);
+        }
+      }
+      if (["upload", "image", "list", "relationship-block"].includes(field.type) && field.name) {
+        const value = data[field.name];
+        if (value) {
+          if (Array.isArray(value)) {
+            result[field.name] = JSON.stringify(value);
+          } else if (typeof value === "object") {
+            result[field.name] = JSON.stringify(value);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async connect() {
+    this.connected = true;
+    console.log(`[DrizzleAdapter] Connected to ${this.dialect}`);
+  }
+  async disconnect() {
+    this.connected = false;
+    console.log(`[DrizzleAdapter] Disconnected from ${this.dialect}`);
+  }
+  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);
+    const filters = this.buildWhereClause(where, config, table, tenantID);
+    if (!draft) {
+      filters.push(table._status.equals("published"));
+    }
+    const sortOption = this.parseSort(sort);
+    const totalDocs = await this.count({ collection: slug, where: { ...where, _status: draft ? void 0 : "published" }, tenantID });
+    const offset = (page - 1) * limit;
+    let results = [];
+    try {
+      results = await this.client.select().from(table).where(filters).orderBy(sortOption.direction === "asc" ? table[sortOption.field] : void 0).limit(limit).offset(offset);
+    } catch (error) {
+      console.error(`[DrizzleAdapter] Query error:`, error);
+    }
+    let docs = results.map((doc) => this.processResult(doc, 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,
+      ...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);
+    let query = this.client.select().from(table).where(table.id.equals(id));
+    if (tenantID) {
+      query = query.where(table.tenantId.equals(tenantID));
+    }
+    if (!draft) {
+      query = query.where(table._status.equals("published"));
+    }
+    const results = await query.limit(1);
+    if (results.length === 0) return null;
+    let doc = this.processResult(results[0], 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 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);
+    if (tenantID) {
+      updateData.tenantId = tenantID;
+    }
+    const result = await this.client.update(table).set(updateData).where(drizzleOrm.eq(table.id, id)).returning();
+    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);
+    let query = this.client.delete(table).where(drizzleOrm.eq(table.id, id)).returning();
+    if (tenantID) {
+      query = query.where(table.tenantId.equals(tenantID));
+    }
+    const result = await query;
+    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 {
+      const result = await this.client.select({ count: `count(*)` }).from(table).where(filters);
+      return parseInt(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) {
+        query = query.where(table._status.equals("published"));
+      }
+      const results = await query.limit(1);
+      if (results.length === 0) return null;
+      let doc = this.processResult(results[0], globalConfig);
+      if (draft && doc._has_draft) {
+        const versions = await this.findVersions({
+          collection: slug,
+          documentId: 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;
+    }
+    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}
+      ${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}
+      ${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 id = Math.random().toString(36).substring(2, 15);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.executeRaw(drizzleOrm.sql`
+      INSERT INTO kyro_versions (
+        id, collection_slug, document_id, tenant_id, data, status, created_by, change_description, created_at, updated_at
+      ) VALUES (
+        ${id}, ${args.collection}, ${args.documentId}, ${args.tenantID || null}, 
+        ${JSON.stringify(args.data)}, ${args.status}, ${args.createdBy || null}, 
+        ${args.changeDescription || null}, ${now}, ${now}
+      )
+    `);
+    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 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}
+        ${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 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``}
+      `);
+    }
+  }
+  async findDraft(args) {
+    await this.ensureDraftsTable();
+    const draftId = this.getDraftId(args.collection, args.documentId, args.tenantID);
+    const rows = await this.executeRaw(drizzleOrm.sql`
+      SELECT *
+      FROM kyro_drafts
+      WHERE id = ${draftId}
+      LIMIT 1
+    `);
+    const row = rows[0];
+    return row ? this.rowToDraft(row) : null;
+  }
+  async upsertDraft(args) {
+    await this.ensureDraftsTable();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const draftUpdatedAt = args.draftUpdatedAt || now;
+    const draftId = this.getDraftId(args.collection, args.documentId, args.tenantID);
+    const existing = await this.findDraft(args);
+    if (existing) {
+      await this.executeRaw(drizzleOrm.sql`
+        UPDATE kyro_drafts
+        SET
+          data = ${JSON.stringify(args.data)},
+          base_updated_at = ${args.baseUpdatedAt ?? null},
+          draft_updated_at = ${draftUpdatedAt},
+          updated_at = ${now}
+        WHERE id = ${draftId}
+      `);
+    } else {
+      await this.executeRaw(drizzleOrm.sql`
+        INSERT INTO kyro_drafts (
+          id, collection_slug, document_id, tenant_id, data, base_updated_at, draft_updated_at, created_at, updated_at
+        ) VALUES (
+          ${draftId},
+          ${args.collection},
+          ${args.documentId},
+          ${args.tenantID ?? null},
+          ${JSON.stringify(args.data)},
+          ${args.baseUpdatedAt ?? null},
+          ${draftUpdatedAt},
+          ${now},
+          ${now}
+        )
+      `);
+    }
+    const saved = await this.findDraft(args);
+    if (!saved) {
+      throw new Error("Failed to persist draft snapshot");
+    }
+    return saved;
+  }
+  async deleteDraft(args) {
+    await this.ensureDraftsTable();
+    const draftId = this.getDraftId(args.collection, args.documentId, args.tenantID);
+    await this.executeRaw(drizzleOrm.sql`
+      DELETE FROM kyro_drafts
+      WHERE id = ${draftId}
+    `);
+  }
+  // ========================================================================
+  // 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) {
+      conditions.push({ tenantId: tenantID });
+    }
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "AND" && Array.isArray(value)) {
+        for (const subCondition of value) {
+          conditions.push(...Object.entries(subCondition).map(([k, v]) => ({ [k]: v })));
+        }
+      } else if (key === "OR" && Array.isArray(value)) {
+        conditions.push(...value.flatMap(
+          (v) => Object.entries(v).map(([k, val]) => ({ [k]: val }))
+        ));
+      } else if (typeof value === "object" && value !== null) {
+        if (value.equals !== void 0) conditions.push(drizzleOrm.eq(table[key], value.equals));
+        if (value.not_equals !== void 0) conditions.push({ [key]: { not: value.not_equals } });
+        if (value.in) conditions.push({ [key]: { in: value.in } });
+        if (value.like) conditions.push({ [key]: { like: value.like } });
+        if (value.greater_than !== void 0) conditions.push({ [key]: { gt: value.greater_than } });
+        if (value.greater_than_equal !== void 0) conditions.push({ [key]: { gte: value.greater_than_equal } });
+        if (value.less_than !== void 0) conditions.push({ [key]: { lt: value.less_than } });
+        if (value.less_than_equal !== void 0) conditions.push({ [key]: { lte: value.less_than_equal } });
+      } else {
+        conditions.push({ [key]: value });
+      }
+    }
+    return conditions.length > 0 ? conditions : void 0;
+  }
+  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 (["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) {
+        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 {
+                  }
+                }
+              }
+              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 ensureDraftsTable() {
+    if (this.draftsTableReady) return;
+    const createTableSQL = this.dialect === "mysql" ? drizzleOrm.sql.raw(`
+        CREATE TABLE IF NOT EXISTS kyro_drafts (
+          id varchar(255) PRIMARY KEY,
+          collection_slug varchar(255) NOT NULL,
+          document_id varchar(255) NOT NULL,
+          tenant_id varchar(255),
+          data longtext NOT NULL,
+          base_updated_at varchar(255),
+          draft_updated_at varchar(255) NOT NULL,
+          created_at varchar(255) NOT NULL,
+          updated_at varchar(255) NOT NULL
+        )
+      `) : drizzleOrm.sql.raw(`
+        CREATE TABLE IF NOT EXISTS kyro_drafts (
+          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 NOT NULL,
+          updated_at text NOT NULL
+        )
+      `);
+    await this.executeRaw(createTableSQL);
+    this.draftsTableReady = true;
+  }
+  async ensureVersionsTable() {
+    if (this.versionsTableReady) return;
+    const createTableSQL = this.dialect === "mysql" ? drizzleOrm.sql.raw(`
+        CREATE TABLE IF NOT EXISTS kyro_versions (
+          id varchar(255) PRIMARY KEY,
+          collection_slug varchar(255) NOT NULL,
+          document_id varchar(255) NOT NULL,
+          tenant_id varchar(255),
+          data longtext NOT NULL,
+          status varchar(50) NOT NULL,
+          created_by varchar(255),
+          change_description text,
+          created_at varchar(255) NOT NULL,
+          updated_at varchar(255) NOT NULL
+        )
+      `) : drizzleOrm.sql.raw(`
+        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,
+          created_by text,
+          change_description text,
+          created_at text NOT NULL,
+          updated_at text NOT NULL
+        )
+      `);
+    await this.executeRaw(createTableSQL);
+    this.versionsTableReady = true;
+  }
+  getDraftId(collection, documentId, tenantID) {
+    return `${collection}::${documentId}::${tenantID || "global"}`;
+  }
+  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 [];
+  }
+  rowToDraft(row) {
+    return {
+      id: String(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
+    };
+  }
+};
+function createDrizzleAdapter(options) {
+  return new DrizzleAdapter(options);
+}
+
+exports.DrizzleAdapter = DrizzleAdapter;
+exports.collectionToDrizzleSchema = collectionToDrizzleSchema;
+exports.createDrizzleAdapter = createDrizzleAdapter;
+exports.fieldToDrizzleType = fieldToDrizzleType;
+//# sourceMappingURL=chunk-R4C4O4SE.cjs.map
+//# sourceMappingURL=chunk-R4C4O4SE.cjs.map