opacacms 0.3.1 → 0.3.3

package/dist/chunk-3j9zjfmn.js

@@ -1,376 +0,0 @@
-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-56n342hs.js

@@ -1,95 +0,0 @@
-import {
-  require_picocolors
-} from "./chunk-rwqwsanx.js";
-import {
-  Gt,
-  R,
-  Vt,
-  Wt,
-  be
-} from "./chunk-ec4jhybj.js";
-import {
-  loadConfig,
-  resolveConfigPath
-} from "./chunk-majsbncm.js";
-import {
-  defineCommand
-} from "./chunk-1qm0m8r8.js";
-import {
-  __toESM
-} from "./chunk-6bywt602.js";
-
-// src/cli/commands/doctor.ts
-import fs from "node:fs";
-var import_picocolors = __toESM(require_picocolors(), 1);
-var doctor_default = defineCommand({
-  meta: {
-    name: "doctor",
-    description: "Diagnose your OpacaCMS project configuration and database connection"
-  },
-  args: {
-    config: {
-      type: "string",
-      alias: "c",
-      description: "Path to the OpacaCMS configuration file"
-    }
-  },
-  async run({ args }) {
-    console.log();
-    Wt(import_picocolors.default.bgMagenta(import_picocolors.default.white(" OpacaCMS Doctor ")));
-    const s = be();
-    s.start("Locating configuration file...");
-    let configPath;
-    try {
-      configPath = resolveConfigPath(args.config);
-      s.stop(`Config found at ${import_picocolors.default.green(configPath)}`);
-    } catch (err) {
-      s.stop(import_picocolors.default.red("Config file not found."));
-      R.error("Could not find opacacms.config.ts or similar.");
-      Gt(import_picocolors.default.red("Diagnosis failed."));
-      process.exit(1);
-    }
-    s.start("Loading configuration...");
-    let opaca;
-    try {
-      opaca = await loadConfig(configPath);
-      s.stop(`Configuration loaded successfully. App Name: ${import_picocolors.default.cyan(opaca.appName || "Unknown")}`);
-    } catch (err) {
-      s.stop(import_picocolors.default.red("Failed to load configuration."));
-      R.error(err.message);
-      Gt(import_picocolors.default.red("Diagnosis failed."));
-      process.exit(1);
-    }
-    s.start("Verifying database connection...");
-    try {
-      if (!opaca.db)
-        throw new Error("No database configured in config.db");
-      const tables = await opaca.db.kysely.introspection.getTables();
-      s.stop(`Database connected successfully. Found ${import_picocolors.default.green(tables.length)} tables.`);
-    } catch (err) {
-      s.stop(import_picocolors.default.red("Database connection failed."));
-      R.error(err.message);
-    }
-    s.start("Checking dependencies...");
-    try {
-      const pkgPath = `${process.cwd()}/package.json`;
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        if (!deps.opacacms) {
-          R.warn(import_picocolors.default.yellow("opacacms is missing from package.json"));
-        }
-        s.stop(`Dependencies checked.`);
-      } else {
-        s.stop(import_picocolors.default.yellow("package.json not found."));
-      }
-    } catch (err) {
-      s.stop(import_picocolors.default.red("Error checking dependencies."));
-    }
-    Vt(`Everything seems to be in order! Run \`opacacms dev\` to start.`, "Diagnosis Complete");
-    Gt("Doctor out.");
-  }
-});
-export {
-  doctor_default as default
-};

package/dist/chunk-5b8r0v8c.js

@@ -1,47 +0,0 @@
-// src/utils/string.ts
-function sanitizeGraphQLName(name) {
-  return name.replace(/[^_a-zA-Z0-9]/g, "_");
-}
-function getRandomMigrationName() {
-  const adjectives = [
-    "vibrant",
-    "snarky",
-    "brave",
-    "swift",
-    "silent",
-    "funky",
-    "mystic",
-    "loyal",
-    "nimble",
-    "eager",
-    "wild",
-    "chill",
-    "golden",
-    "magic",
-    "smart",
-    "fierce"
-  ];
-  const nouns = [
-    "vulture",
-    "badger",
-    "falcon",
-    "otter",
-    "lynx",
-    "panda",
-    "fox",
-    "lemur",
-    "cobra",
-    "whale",
-    "eagle",
-    "tiger",
-    "koala",
-    "bison",
-    "raven",
-    "shark"
-  ];
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
-  return `${adj}_${noun}`;
-}
-
-export { sanitizeGraphQLName, getRandomMigrationName };