opacacms 0.2.0 → 0.3.0

package/dist/chunk-3j9zjfmn.js

@@ -0,0 +1,376 @@
+import {
+  logger
+} from "./chunk-jq1drsen.js";
+import {
+  __require
+} from "./chunk-6bywt602.js";
+
+// src/cli/core/seeding/auto-seed.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) {
+  const tryFetch = async (target) => {
+    try {
+      const result = await db.find(target, {}, { limit: 50 });
+      return result.docs || [];
+    } catch (e) {
+      const msg = String(e.message || e).toLowerCase();
+      if (msg.includes("no such table"))
+        return null;
+      throw e;
+    }
+  };
+  try {
+    let docs = await tryFetch(relationTo);
+    if (docs === null && relationTo === "users") {
+      docs = await tryFetch("_users");
+    }
+    if (!docs || docs.length === 0) {
+      if (!relationTo.startsWith("_") && docs !== null) {
+        console.warn(`[Seeding] No documents found in '${relationTo}' for relationship.`);
+      }
+      return [];
+    }
+    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) {
+    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)];
+              if (choice) {
+                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 = []) {
+  const autoData = await generateDataForFields(collection.fields, db, locales);
+  if (collection.seed && typeof collection.seed === "function") {
+    const seedData = await collection.seed(faker);
+    return { ...autoData, ...seedData };
+  }
+  return autoData;
+}
+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" && "relationTo" in f) {
+          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", targetTable) {
+  const { collections, db, globals, storages, serverURL } = config;
+  const locales = config.i18n?.locales || [];
+  logger.info(`Starting automatic seed (${logger.bold(countPerCollection.toString())} records per collection)...`);
+  const { getSystemCollections } = await import("./chunk-adq2b75c.js");
+  const systemCollections = getSystemCollections().filter((c) => c.slug === "_assets");
+  const allCollections = [...systemCollections, ...collections];
+  let collectionsToSeed = sortCollections(allCollections);
+  if (type === "assets") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug === "_assets");
+    logger.info("\uD83D\uDCC1 Seeding only assets...");
+  } else if (type === "collections") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug !== "_assets");
+    logger.info("\uD83D\uDCDA Seeding user collections...");
+  }
+  if (targetTable) {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug === targetTable);
+    if (collectionsToSeed.length === 0) {
+      console.warn(`[OpacaCMS] Collection/Table "${targetTable}" not found in schema. Skipping...`);
+      return;
+    }
+  } else {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.seed && typeof c.seed === "function" || c.slug === "_assets" || c.slug === "users" || c.slug === "_users");
+    logger.info(`\uD83D\uDD0D Seeding ${logger.bold(collectionsToSeed.length.toString())} collections with custom seed logic...`);
+  }
+  await db.connect();
+  await db.migrate(allCollections, globals || []);
+  try {
+    if (reset) {
+      logger.info("\uD83E\uDDF9 Resetting data (cleaning existing records)...");
+      const reversed = [...collectionsToSeed].reverse();
+      for (const collection of reversed) {
+        logger.log(`   ${logger.format("gray", "delete")} ${collection.slug}`);
+        await db.deleteMany?.(collection.slug, {});
+      }
+    }
+    const storageAdapter = storages.default || storages;
+    for (const collection of collectionsToSeed) {
+      logger.info(`Seeding ${logger.bold(collection.slug)}...`);
+      const isAssetCollection = collection.slug === "_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)
+          };
+          const uploadAdapter = storageAdapter;
+          const uploaded = await uploadAdapter.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";
+          logger.debug(`[Asset] Source: ${imageUrl}`);
+          logger.debug(`[Asset] Seeded: ${baseURL}/api/assets/${id}/view (${uploaded.filename})`);
+        } else {
+          data = await generateRecord(db, collection, locales);
+        }
+        await db.create(collection.slug, data);
+      }
+    }
+    if (globals && globals.length > 0) {
+      logger.info("\uD83C\uDF0D Seeding globals...");
+      for (const global of globals) {
+        if (!targetTable && (!global.seed || typeof global.seed !== "function")) {
+          continue;
+        }
+        logger.info(`Seeding global ${logger.bold(global.slug)}...`);
+        const autoData = await generateDataForFields(global.fields, db, locales);
+        let data;
+        if (global.seed && typeof global.seed === "function") {
+          const seedData = await global.seed(faker);
+          data = { ...autoData, ...seedData };
+        } else {
+          data = autoData;
+        }
+        const existing = await db.find(global.slug, {}, { limit: 1 });
+        if (existing.docs && existing.docs.length > 0) {
+          if (reset) {
+            await db.deleteMany?.(global.slug, {});
+            await db.create(global.slug, data);
+          } else {
+            await db.update(global.slug, existing.docs[0].id, data);
+          }
+        } else {
+          await db.create(global.slug, data);
+        }
+      }
+    }
+    logger.success("Seeding completed successfully! ✨");
+  } finally {}
+}
+export {
+  sortCollections,
+  getRandomIds,
+  generateRecord,
+  defaultFieldGenerators,
+  autoSeed
+};

package/dist/{chunk-byq8g0rd.js → chunk-48ywpd0a.js}

@@ -1,6 +1,7 @@
 import {
   notify
-} from "./chunk-8scgdznr.js";
+} from "./chunk-m83ybzf8.js";
+import"./chunk-6bywt602.js";
 
 // src/admin/stores/auth.ts
 import { atom, computed } from "nanostores";
@@ -9,24 +10,6 @@ import { atom, computed } from "nanostores";
 import { createAuthClient } from "better-auth/client";
 import { adminClient } from "better-auth/client/plugins";
 var client = null;
-var currentURL = null;
-var configureAuth = (serverUrl) => {
-  if (!serverUrl || !serverUrl.startsWith("http"))
-    return;
-  const url = serverUrl;
-  const baseURL = url.replace(/\/$/, "") + "/api/auth";
-  if (client && currentURL === baseURL)
-    return;
-  currentURL = baseURL;
-  client = createAuthClient({
-    baseURL,
-    autoRefresh: true,
-    fetchOptions: {
-      credentials: "include"
-    },
-    plugins: [adminClient()]
-  });
-};
 var authClient = new Proxy({}, {
   get(_, prop) {
     if (!client) {
@@ -62,7 +45,11 @@ async function login(data) {
     if (res.error) {
       throw new Error(res.error.message || "Invalid credentials");
     }
-    await syncSession();
+    if (res.data) {
+      $session.set(res.data);
+    } else {
+      await syncSession();
+    }
     notify("Logged in successfully", "success");
     return res;
   } catch (error) {
@@ -84,5 +71,12 @@ async function logout() {
     $isAuthPending.set(false);
   }
 }
-
-export { configureAuth, authClient, $session, $isAuthPending, $user, $isAuthenticated, syncSession, login, logout };
+export {
+  syncSession,
+  logout,
+  login,
+  $user,
+  $session,
+  $isAuthenticated,
+  $isAuthPending
+};