@kyro-cms/core 0.6.0 → 0.7.0

package/dist/{chunk-6WXQRYTW.js → chunk-QPPDLRNR.js}

@@ -1,6 +1,7 @@
-import { AbstractBaseAdapter } from './chunk-A4USRVTQ.js';
-import { sql, eq, desc, and } from 'drizzle-orm';
-import { text, uuid, jsonb, timestamp, boolean, decimal, integer, varchar, pgTable } from 'drizzle-orm/pg-core';
+import { AbstractBaseAdapter, applyRLS, DEFAULT_RLS_CONFIG, canAccessDocument } from './chunk-3ZFYL34R.js';
+import { sql, eq, desc, and, or, ne, inArray, like, gt, gte, lt, lte } from 'drizzle-orm';
+import { text, uuid, jsonb, timestamp, boolean, decimal, integer as integer$1, varchar, pgTable } from 'drizzle-orm/pg-core';
+import { text as text$1, integer, numeric, sqliteTable } from 'drizzle-orm/sqlite-core';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
 import { randomBytes } from 'crypto';
@@ -85,6 +86,13 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
   connectionString;
   draftsTableReady = false;
   versionsTableReady = false;
+  tenantContext;
+  setTenantContext(context) {
+    this.tenantContext = context;
+  }
+  getTenantContext() {
+    return this.tenantContext;
+  }
   constructor(options) {
     super();
     this.schema = options.schema || {};
@@ -93,8 +101,10 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
       const connStr = options.connectionString.toLowerCase();
       if (connStr.startsWith("postgres://") || connStr.startsWith("postgresql://")) {
         this.dialect = "postgres";
-      } else {
+      } 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;
@@ -110,7 +120,7 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
       result.updatedAt = new Date(result.updatedAt);
     }
     for (const field of config.fields) {
-      const dbType = fieldToDrizzleType(field, "postgres");
+      const dbType = fieldToDrizzleType(field, this.dialect);
       const isJsonb = dbType === "jsonb";
       if (field.type === "tabs" && "tabs" in field && field.name) {
         const tabData = data[field.name];
@@ -141,18 +151,28 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
   }
   async connect() {
     if (this.connectionString && !this.client) {
-      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 });
+      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;
     console.log(`[DrizzleAdapter] Connected to ${this.dialect}`);
   }
   async init(collections, globals = []) {
     await super.init(collections, globals);
-    if (this.dialect === "postgres" && this.client && !_schemaEnsured) {
+    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]) {
@@ -185,91 +205,168 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
     };
     for (const field of config.fields) {
       if (!field.name || field.name === "id") continue;
-      const dbType = fieldToDrizzleType(field, "postgres");
+      const dbType = fieldToDrizzleType(field, this.dialect);
       const propName = field.name.replace(/-/g, "_");
       const sqlName = propName.replace(/([A-Z])/g, "_$1").toLowerCase();
       let col;
-      switch (dbType) {
-        case "varchar":
-          col = varchar(sqlName, { length: 255 });
-          break;
-        case "integer":
-          col = integer(sqlName);
-          break;
-        case "decimal":
-          col = decimal(sqlName);
-          break;
-        case "boolean":
-          col = boolean(sqlName);
-          break;
-        case "timestamp":
-          col = timestamp(sqlName);
-          break;
-        case "jsonb":
-          col = jsonb(sqlName);
-          break;
-        default:
-          col = text(sqlName);
+      if (this.dialect === "sqlite") {
+        switch (dbType) {
+          case "varchar":
+          case "text":
+            col = text$1(sqlName);
+            break;
+          case "integer":
+            col = integer(sqlName);
+            break;
+          case "decimal":
+          case "numeric":
+            col = numeric(sqlName);
+            break;
+          case "boolean":
+            col = integer(sqlName, { mode: "boolean" });
+            break;
+          case "timestamp":
+            col = text$1(sqlName);
+            break;
+          case "jsonb":
+            col = text$1(sqlName);
+            break;
+          default:
+            col = text$1(sqlName);
+        }
+      } else {
+        switch (dbType) {
+          case "varchar":
+            col = varchar(sqlName, { length: 255 });
+            break;
+          case "integer":
+            col = integer$1(sqlName);
+            break;
+          case "decimal":
+            col = decimal(sqlName);
+            break;
+          case "boolean":
+            col = boolean(sqlName);
+            break;
+          case "timestamp":
+            col = timestamp(sqlName);
+            break;
+          case "jsonb":
+            col = jsonb(sqlName);
+            break;
+          default:
+            col = text(sqlName);
+        }
       }
       if (!field.required) col = col.default(null);
       columns[propName] = col;
     }
-    if (!columns.createdAt) columns.createdAt = timestamp("created_at").defaultNow();
-    if (!columns.updatedAt) columns.updatedAt = timestamp("updated_at").defaultNow();
-    columns._status = varchar("_status", { length: 20 }).default("published");
-    columns._has_draft = boolean("_has_draft").default(false);
-    return pgTable(tableName, columns);
+    if (!columns.createdAt) columns.createdAt = this.dialect === "sqlite" ? text$1("created_at").default((/* @__PURE__ */ new Date()).toISOString()) : timestamp("created_at").defaultNow();
+    if (!columns.updatedAt) columns.updatedAt = this.dialect === "sqlite" ? text$1("updated_at").default((/* @__PURE__ */ new Date()).toISOString()) : timestamp("updated_at").defaultNow();
+    columns._status = this.dialect === "sqlite" ? text$1("_status").default("published") : varchar("_status", { length: 20 }).default("published");
+    columns._has_draft = this.dialect === "sqlite" ? integer("_has_draft", { mode: "boolean" }).default(false) : boolean("_has_draft").default(false);
+    return this.dialect === "sqlite" ? sqliteTable(tableName, columns) : 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 tableIdent = sql.identifier(tableName);
       const colDefs = this.generateCreateColumns(config);
       const hasCreated = config.fields.some((f) => f.name === "createdAt");
       const hasUpdated = config.fields.some((f) => f.name === "updatedAt");
-      const idCol = isGlobal ? '"id" TEXT PRIMARY KEY' : '"id" UUID PRIMARY KEY DEFAULT gen_random_uuid()';
-      await this.client.execute(sql`
-        CREATE TABLE IF NOT EXISTS ${tableIdent} (
-          ${sql.raw(idCol)},
-          ${sql.raw(colDefs)}
-          ${hasCreated ? sql.raw("") : sql.raw('"created_at" TIMESTAMP NOT NULL DEFAULT NOW(),')}
-          ${hasUpdated ? sql.raw("") : sql.raw('"updated_at" TIMESTAMP NOT NULL DEFAULT NOW(),')}
-          "_status" VARCHAR(20) DEFAULT 'published',
-          "_has_draft" BOOLEAN DEFAULT false
-        )
-      `);
+      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 'published',
+            "_has_draft" 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 'published',
+            "_has_draft" INTEGER DEFAULT 0
+          )
+        `);
+      }
+    }
+    if (statements.length > 0) {
+      if (this.dialect === "postgres") {
+        await this.client.execute(sql.raw(statements.join(";\n")));
+      } else {
+        for (const stmt of statements) {
+          await this.client.execute(sql.raw(stmt));
+        }
+      }
     }
   }
   generateCreateColumns(config) {
     const cols = [];
     for (const field of config.fields) {
       if (!field.name || field.name === "id") continue;
-      const dbType = fieldToDrizzleType(field, "postgres");
+      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;
-      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}`;
+      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}`);
     }
@@ -283,22 +380,34 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
     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) || [];
+    let effectiveWhere = { ...where };
+    if (this.tenantContext && config.tenantScoped) {
+      const rlsQuery = applyRLS({ where: effectiveWhere }, slug, this.tenantContext, DEFAULT_RLS_CONFIG);
+      effectiveWhere = rlsQuery.where || {};
+    }
+    const filters = this.buildWhereClause(effectiveWhere, config, table, tenantID);
     if (!draft && table._status) {
       filters.push(eq(table._status, "published"));
     }
     const sortOption = this.parseSort(sort);
-    const totalDocs = await this.count({ collection: slug, where: { ...where, _status: draft ? void 0 : "published" }, tenantID });
+    const totalDocs = await this.count({ collection: slug, where: effectiveWhere, tenantID });
     const offset = (page - 1) * limit;
     let results = [];
     try {
       const sortCol = table[sortOption.field] || table.createdAt || table.id;
       const sorted = sortOption.direction === "asc" ? sortCol : desc(sortCol);
-      results = await this.client.select().from(table).where(filters).orderBy(sorted).limit(limit).offset(offset);
+      let query = this.client.select().from(table);
+      if (filters.length > 0) {
+        query = query.where(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) => canAccessDocument(doc, slug, this.tenantContext, DEFAULT_RLS_CONFIG));
+    }
     if (draft) {
       docs = await Promise.all(docs.map(async (doc) => {
         if (doc._has_draft) {
@@ -324,6 +433,12 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
     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 (!canAccessDocument(tempDoc, slug, this.tenantContext, DEFAULT_RLS_CONFIG)) {
+        return null;
+      }
+    }
     const conditions = [eq(table.id, id)];
     if (tenantID && table.tenantId) conditions.push(eq(table.tenantId, tenantID));
     if (!draft && table._status) conditions.push(eq(table._status, "published"));
@@ -386,8 +501,12 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
     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 || void 0);
-      return parseInt(result[0]?.count || "0");
+      let query = this.client.select({ count: sql`count(*)` }).from(table);
+      if (filters.length > 0) {
+        query = query.where(and(...filters));
+      }
+      const result = await query;
+      return Number(result[0]?.count || 0);
     } catch {
       return 0;
     }
@@ -593,32 +712,38 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
   }
   buildWhereClause(where, config, table, tenantID) {
     const conditions = [];
-    if (tenantID && config.tenantScoped) {
-      conditions.push({ tenantId: tenantID });
+    if (tenantID && config.tenantScoped && table.tenantId) {
+      conditions.push(eq(table.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 })));
+        const andConditions = value.map((sub) => this.buildWhereClause(sub, config, table)).flat().filter(Boolean);
+        if (andConditions.length > 0) {
+          conditions.push(and(...andConditions));
         }
       } 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(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 } });
+        const orConditions = value.map((sub) => this.buildWhereClause(sub, config, table)).flat().filter(Boolean);
+        if (orConditions.length > 0) {
+          conditions.push(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(eq(col, value.equals));
+        if (value.not_equals !== void 0) conditions.push(ne(col, value.not_equals));
+        if (value.in && Array.isArray(value.in)) conditions.push(inArray(col, value.in));
+        if (value.like !== void 0) conditions.push(like(col, value.like));
+        if (value.contains !== void 0) conditions.push(like(col, `%${value.contains}%`));
+        if (value.greater_than !== void 0) conditions.push(gt(col, value.greater_than));
+        if (value.greater_than_equal !== void 0) conditions.push(gte(col, value.greater_than_equal));
+        if (value.less_than !== void 0) conditions.push(lt(col, value.less_than));
+        if (value.less_than_equal !== void 0) conditions.push(lte(col, value.less_than_equal));
       } else {
-        conditions.push({ [key]: value });
+        const col = table[key];
+        if (col) conditions.push(eq(col, value));
       }
     }
-    return conditions.length > 0 ? conditions : void 0;
+    return conditions;
   }
   processResult(data, config) {
     if (!data) return null;
@@ -690,39 +815,74 @@ var DrizzleAdapter = class extends AbstractBaseAdapter {
   }
   async ensureDraftsTable() {
     if (_schemaEnsured || this.draftsTableReady) return;
-    const createTableSQL = 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);
+    let createTableSQL;
+    if (this.dialect === "sqlite") {
+      createTableSQL = `
+        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 DEFAULT (datetime('now')),
+          updated_at text DEFAULT (datetime('now'))
+        )
+      `;
+    } else {
+      createTableSQL = `
+        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(sql.raw(createTableSQL));
     this.draftsTableReady = true;
   }
   async ensureVersionsTable() {
     if (_schemaEnsured || this.versionsTableReady) return;
-    const createTableSQL = 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);
+    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',
+          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,
+          created_by text,
+          change_description text,
+          created_at text NOT NULL,
+          updated_at text NOT NULL
+        )
+      `;
+    }
+    await this.executeRaw(sql.raw(createTableSQL));
     this.versionsTableReady = true;
   }
   getDraftId(collection, documentId, tenantID) {
@@ -807,5 +967,5 @@ async function seedDefaultRoles(db) {
 }
 
 export { DrizzleAdapter, collectionToDrizzleSchema, createDatabase, createDrizzleAdapter, fieldToDrizzleType, genId, runMigrations, seedDefaultRoles };
-//# sourceMappingURL=chunk-6WXQRYTW.js.map
-//# sourceMappingURL=chunk-6WXQRYTW.js.map
+//# sourceMappingURL=chunk-QPPDLRNR.js.map
+//# sourceMappingURL=chunk-QPPDLRNR.js.map