opacacms 0.2.0 → 0.2.1

package/dist/{chunk-gmee4mdc.js → chunk-bygjkgrx.js}

@@ -22,15 +22,12 @@ import {
 // src/db/better-sqlite.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createRequire } from "node:module";
 import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect } from "kysely";
-var require2 = createRequire(import.meta.url);
-var Database = require2("better-sqlite3");
-
 class BetterSQLiteAdapter extends BaseDatabaseAdapter {
+  path;
   name = "better-sqlite3";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -40,27 +37,39 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     return this._rawDb;
   }
   get db() {
+    if (!this._db)
+      throw new Error("Database not connected. Call connect() first.");
     return this._db;
   }
   constructor(path2, options) {
     super();
-    this._rawDb = new Database(path2);
+    this.path = path2;
+    this.push = options?.push ?? true;
+    this.pushDestructive = options?.pushDestructive ?? false;
+    this.migrationDir = options?.migrationDir ?? "./migrations";
+  }
+  async connect() {
+    if (this._db)
+      return;
+    const { createRequire } = await import("node:module");
+    const require2 = createRequire(import.meta.url);
+    const Database = require2("better-sqlite3");
+    this._rawDb = new Database(this.path);
     this._db = new Kysely({
       dialect: new SqliteDialect({
         database: this._rawDb
       })
     });
-    this.push = options?.push ?? true;
-    this.pushDestructive = options?.pushDestructive ?? false;
-    this.migrationDir = options?.migrationDir ?? "./migrations";
   }
-  async connect() {}
   async disconnect() {
-    await this._db.destroy();
+    if (this._db)
+      await this.db.destroy();
   }
   async unsafe(query, params) {
+    if (!this._db)
+      await this.connect();
     const compiled = CompiledQuery.raw(query, params || []);
-    const result = await this._db.executeQuery(compiled);
+    const result = await this.db.executeQuery(compiled);
     return result.rows;
   }
   async coerceData(collection, data) {
@@ -104,7 +113,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async count(collection, query) {
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
+    let qb = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -113,7 +122,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async create(collection, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       const jsonFields = colDef?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -194,7 +203,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async findOne(collection, query, tx) {
     const tableName = toSnakeCase(collection);
-    const executor = tx || this._db;
+    const executor = tx || this.db;
     let qb = executor.selectFrom(tableName).selectAll();
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -247,7 +256,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     const offset = (page - 1) * limit;
     const total = await this.count(collection, query);
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
+    let qb = this.db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -286,7 +295,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
         if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
           const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
           try {
-            const allRelations = await this._db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
+            const allRelations = await this.db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
             const relationsBySource = allRelations.reduce((acc, r) => {
               if (!acc[r.source_id])
                 acc[r.source_id] = [];
@@ -310,7 +319,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
           for (const b of field.blocks) {
             const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
             try {
-              const allBlocks = await this._db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
+              const allBlocks = await this.db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
               for (const blk of allBlocks) {
                 const uf = unflattenRow(blk);
                 uf.blockType = blk.block_type;
@@ -356,7 +365,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async update(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let normalizedQuery = query;
       if (typeof query !== "object" || query === null) {
         normalizedQuery = { id: query };
@@ -447,7 +456,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     const current = await this.findOne(collection, normalizedQuery);
     if (!current)
       return false;
-    await this._db.transaction().execute(async (tx) => {
+    await this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       if (colDef) {
         for (const field of colDef.fields) {
@@ -473,7 +482,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async updateMany(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let qb = tx.updateTable(tableName);
       if (query && Object.keys(query).length > 0) {
         qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -502,7 +511,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async deleteMany(collection, query) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let selectQb = tx.selectFrom(tableName).select("id");
       if (query && Object.keys(query).length > 0) {
         selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -536,7 +545,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async findGlobal(slug) {
     const tableName = toSnakeCase(slug);
-    const row = await this._db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
+    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
     return row ? unflattenRow(row) : null;
   }
   async updateGlobal(slug, data) {
@@ -550,15 +559,15 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
       if (!flatData.id)
         flatData.id = "global";
       flatData[toSnakeCase("createdAt")] = now;
-      await this._db.insertInto(tableName).values(flatData).execute();
+      await this.db.insertInto(tableName).values(flatData).execute();
     } else {
-      await this._db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
+      await this.db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
     }
     return this.findGlobal(slug);
   }
   async runMigrations() {
     const migrator = new Migrator({
-      db: this._db,
+      db: this.db,
       provider: new FileMigrationProvider({
         fs,
         path,
@@ -581,7 +590,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     this._collections = collections;
     this._globals = globals;
     if (this.push) {
-      await pushSchema(this._db, "sqlite", collections, globals, {
+      await pushSchema(this.db, "sqlite", collections, globals, {
         pushDestructive: this.pushDestructive
       });
     }

package/dist/{chunk-qb6ztvw9.js → chunk-g1jb60xd.js}

@@ -4,7 +4,7 @@ import {
 
 // src/cli/commands/seed-command.ts
 async function seedCommand(opaca, count, reset, type) {
-  const { autoSeed } = await import("./chunk-swtcpvhf.js");
+  const { autoSeed } = await import("./chunk-jdfw4v3r.js");
   try {
     await autoSeed(opaca, count, reset, type);
   } catch (error) {

package/dist/chunk-jdfw4v3r.js

@@ -0,0 +1,311 @@
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
+
+// src/cli/seeding.ts
+import { faker } from "@faker-js/faker";
+var defaultFieldGenerators = {
+  text: () => faker.lorem.words(3),
+  textarea: () => faker.lorem.paragraph(),
+  number: () => faker.number.int({ min: 1, max: 1000 }),
+  richtext: () => JSON.stringify({
+    root: {
+      children: [
+        {
+          children: [
+            {
+              detail: 0,
+              format: 0,
+              mode: "normal",
+              style: "",
+              text: faker.lorem.sentence(),
+              type: "text",
+              version: 1
+            }
+          ],
+          direction: "ltr",
+          format: "",
+          indent: 0,
+          type: "heading",
+          tag: "h1",
+          version: 1
+        },
+        {
+          children: [
+            {
+              detail: 0,
+              format: 0,
+              mode: "normal",
+              style: "",
+              text: faker.lorem.paragraphs(2),
+              type: "text",
+              version: 1
+            }
+          ],
+          direction: "ltr",
+          format: "",
+          indent: 0,
+          type: "paragraph",
+          version: 1
+        }
+      ],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "root",
+      version: 1
+    }
+  }),
+  boolean: () => faker.datatype.boolean(),
+  date: () => faker.date.recent().toISOString(),
+  email: () => faker.internet.email(),
+  json: () => ({ [faker.lorem.word()]: faker.lorem.sentence() }),
+  select: () => faker.lorem.word(),
+  radio: () => faker.lorem.word(),
+  blocks: () => []
+};
+async function getRandomIds(db, relationTo, count = 1) {
+  try {
+    const result = await db.find(relationTo, {}, { limit: 50 });
+    const docs = result.docs || [];
+    if (docs.length === 0) {
+      if (!relationTo.startsWith("_")) {
+        console.warn(`[Seeding] No documents found in '${relationTo}' for relationship.`);
+      }
+      return [];
+    }
+    const shuffled = [...docs].sort(() => 0.5 - Math.random());
+    const selected = shuffled.slice(0, count).map((doc) => doc.id);
+    return selected;
+  } catch (e) {
+    console.error(`[Seeding] Failed to fetch random IDs for ${relationTo}:`, e);
+    return [];
+  }
+}
+async function generateDataForFields(fields, db, locales = []) {
+  const record = {};
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      Object.assign(record, await generateDataForFields(field.fields, db, locales));
+      continue;
+    }
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        Object.assign(record, await generateDataForFields(tab.fields, db, locales));
+      }
+      continue;
+    }
+    if (field.type === "group" && field.name) {
+      record[field.name] = await generateDataForFields(field.fields, db, locales);
+      continue;
+    }
+    if (field.name) {
+      const isLocalized = !!field.localized && locales.length > 0;
+      const generateFieldValue = async () => {
+        if (field.type === "relationship" && "relationTo" in field) {
+          if (field.hasMany) {
+            const count = faker.number.int({ min: 1, max: 3 });
+            return await getRandomIds(db, field.relationTo, count);
+          }
+          const ids = await getRandomIds(db, field.relationTo, 1);
+          return ids[0] || null;
+        }
+        if (field.type === "blocks" && field.blocks) {
+          const blockCount = faker.number.int({ min: 1, max: 3 });
+          const generatedBlocks = [];
+          for (let i = 0;i < blockCount; i++) {
+            const blockType = field.blocks[faker.number.int({ min: 0, max: field.blocks.length - 1 })];
+            if (!blockType)
+              continue;
+            const blockData = await generateDataForFields(blockType.fields, db, locales);
+            generatedBlocks.push({
+              ...blockData,
+              blockType: blockType.slug,
+              id: faker.string.uuid()
+            });
+          }
+          return generatedBlocks;
+        }
+        const generator = defaultFieldGenerators[field.type];
+        if (generator) {
+          if (field.type === "select" || field.type === "radio") {
+            const options = field.options;
+            const choices = options?.choices || [];
+            if (choices.length > 0) {
+              const choice = choices[Math.floor(Math.random() * choices.length)];
+              return typeof choice === "string" ? choice : choice.value;
+            }
+          }
+          return generator();
+        }
+        return null;
+      };
+      if (isLocalized) {
+        const localizedValue = {};
+        for (const locale of locales) {
+          localizedValue[locale] = await generateFieldValue();
+        }
+        record[field.name] = localizedValue;
+      } else {
+        record[field.name] = await generateFieldValue();
+      }
+    }
+  }
+  return record;
+}
+async function generateRecord(db, collection, locales = []) {
+  return generateDataForFields(collection.fields, db, locales);
+}
+function sortCollections(collections) {
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  const visit = (collection) => {
+    if (visited.has(collection.slug))
+      return;
+    if (visiting.has(collection.slug)) {
+      throw new Error(`Circular dependency detected: ${collection.slug}`);
+    }
+    visiting.add(collection.slug);
+    const deps = [];
+    const findDeps = (fields) => {
+      for (const f of fields) {
+        if (f.type === "relationship") {
+          deps.push(f.relationTo);
+        } else if (f.type === "blocks" && f.blocks) {
+          for (const b of f.blocks) {
+            findDeps(b.fields);
+          }
+        } else if ("fields" in f && f.fields) {
+          findDeps(f.fields);
+        } else if ("tabs" in f && f.tabs) {
+          for (const t of f.tabs) {
+            findDeps(t.fields);
+          }
+        }
+      }
+    };
+    findDeps(collection.fields);
+    for (const depSlug of deps) {
+      const depColl = collections.find((c) => c.slug === depSlug);
+      if (depColl)
+        visit(depColl);
+    }
+    visiting.delete(collection.slug);
+    visited.add(collection.slug);
+    sorted.push(collection);
+  };
+  for (const collection of collections) {
+    visit(collection);
+  }
+  return sorted;
+}
+async function autoSeed(config, countPerCollection = 10, reset = false, type = "all") {
+  const { collections, db, globals, storages, serverURL } = config;
+  console.log(`\uD83C\uDF31 Starting automatic seed (${countPerCollection} records per collection)...`);
+  const { getSystemCollections } = await import("./chunk-3rdhbedb.js");
+  const systemCollections = getSystemCollections().filter((c) => c.slug === "_opaca_assets");
+  const allCollections = [...systemCollections, ...collections];
+  let collectionsToSeed = sortCollections(allCollections);
+  if (type === "assets") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug === "_opaca_assets");
+    console.log("\uD83D\uDCC1 Seeding only assets...");
+  } else if (type === "collections") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug !== "_opaca_assets");
+    console.log("\uD83D\uDCDA Seeding only user collections...");
+  }
+  await db.connect();
+  await db.migrate(allCollections, globals || []);
+  try {
+    if (reset) {
+      console.log("\uD83E\uDDF9 Resetting data (deleting existing records)...");
+      const reversed = [...collectionsToSeed].reverse();
+      for (const collection of reversed) {
+        console.log(`Cleaning ${collection.slug}...`);
+        await db.deleteMany?.(collection.slug, {});
+      }
+    }
+    const storageAdapter = storages?.default || storages;
+    const locales = config.i18n?.locales || [];
+    for (const collection of collectionsToSeed) {
+      console.log(`Seeding ${collection.slug}...`);
+      const isAssetCollection = collection.slug === "_opaca_assets";
+      for (let i = 0;i < countPerCollection; i++) {
+        let data;
+        if (isAssetCollection) {
+          const id = faker.string.uuid();
+          const width = faker.number.int({ min: 400, max: 1200 });
+          const height = faker.number.int({ min: 300, max: 800 });
+          const color = faker.color.rgb({ prefix: "" });
+          const textColor = faker.color.rgb({ prefix: "" });
+          const usePicsum = Math.random() > 0.5;
+          let imageUrl = "";
+          if (usePicsum) {
+            const categories = ["nature", "city", "tech", "people", "animals", "architecture"];
+            const category = faker.helpers.arrayElement(categories);
+            imageUrl = `https://picsum.photos/seed/${category}-${id}/${width}/${height}`;
+          } else {
+            imageUrl = `https://placehold.co/${width}x${height}/${color}/${textColor}.png?text=Seed+${i}`;
+          }
+          const res = await fetch(imageUrl);
+          if (!res.ok) {
+            throw new Error(`Failed to fetch placeholder image: ${imageUrl}`);
+          }
+          const arrayBuffer = await res.arrayBuffer();
+          const mime_type = res.headers.get("content-type")?.split(";")[0] || "image/png";
+          const extMap = {
+            "image/jpeg": "jpg",
+            "image/png": "png",
+            "image/webp": "webp",
+            "image/gif": "gif",
+            "image/svg+xml": "svg"
+          };
+          const ext = extMap[mime_type] || "png";
+          const fileRecord = {
+            filename: `seed-image-${i}.${ext}`,
+            original_filename: `seed-image-${i}.${ext}`,
+            mime_type,
+            filesize: arrayBuffer.byteLength,
+            buffer: new Uint8Array(arrayBuffer)
+          };
+          if (!storageAdapter || typeof storageAdapter.upload !== "function") {
+            throw new Error("Storage adapter is required for seeding assets and must have an 'upload' method.");
+          }
+          const uploaded = await storageAdapter.upload(fileRecord, {
+            generateUniqueName: true,
+            customMetadata: {
+              sourceUrl: imageUrl
+            }
+          });
+          data = {
+            id,
+            key: uploaded.filename,
+            filename: uploaded.filename,
+            originalFilename: fileRecord.original_filename,
+            mimeType: uploaded.mime_type,
+            filesize: uploaded.filesize,
+            width,
+            height,
+            bucket: "default",
+            url: uploaded.url,
+            thumbnailUrl: uploaded.url,
+            altText: faker.lorem.sentence()
+          };
+          const baseURL = serverURL || "http://localhost:8787";
+          console.log(`[Asset] Source: ${imageUrl}`);
+          console.log(`[Asset] Seeded: ${baseURL}/api/assets/${id}/view (${uploaded.filename})`);
+        } else {
+          data = await generateRecord(db, collection, locales);
+        }
+        await db.create(collection.slug, data);
+      }
+    }
+    console.log("✅ Seeding completed.");
+  } finally {}
+}
+export {
+  sortCollections,
+  generateRecord,
+  defaultFieldGenerators,
+  autoSeed
+};