opacacms 0.2.1 → 0.3.0

package/dist/chunk-1qm0m8r8.js

@@ -0,0 +1,413 @@
+// ../../node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char))
+    return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string")
+    return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = undefined;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+
+// ../../node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "node:util";
+function toArray(val) {
+  if (Array.isArray(val))
+    return val;
+  return val === undefined ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines)
+    for (const [i, element] of line.entries())
+      maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join(`
+`);
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map;
+  const mainToAliases = /* @__PURE__ */ new Map;
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target))
+        mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key))
+        mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name))
+      return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases)
+      if (booleans.has(alias))
+        return "boolean";
+    return "string";
+  }
+  const allOptions = new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions)
+    if (!options[name])
+      options[name] = {
+        type: getType(name),
+        default: defaults[name]
+      };
+  for (const [alias, main] of aliasToMain.entries())
+    if (alias.length === 1 && options[main] && !options[main].short)
+      options[main].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : undefined,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values))
+    out[key] = value;
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName)
+      out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases)
+      for (const alias of aliases)
+        out[alias] = false;
+  }
+  for (const [alias, main] of aliasToMain.entries()) {
+    if (out[alias] !== undefined && out[main] === undefined)
+      out[main] = out[alias];
+    if (out[main] !== undefined && out[alias] === undefined)
+      out[alias] = out[main];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional")
+      continue;
+    if (arg.type === "string" || arg.type === "enum")
+      parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean")
+      parseOptions.boolean.push(arg.name);
+    if (arg.default !== undefined)
+      parseOptions.default[arg.name] = arg.default;
+    if (arg.alias)
+      parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName))
+        existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName))
+        existingAliases.push(kebabName);
+      if (existingAliases.length > 0)
+        parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries())
+    if (arg.type === "positional") {
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== undefined)
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      else if (arg.default === undefined && arg.required !== false)
+        throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+      else
+        parsedArgsProxy[arg.name] = arg.default;
+    } else if (arg.type === "enum") {
+      const argument = parsedArgsProxy[arg.name];
+      const options = arg.options || [];
+      if (argument !== undefined && options.length > 0 && !options.includes(argument))
+        throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+    } else if (arg.required && parsedArgsProxy[arg.name] === undefined)
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {}))
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray(argDef.alias)
+    });
+  return args;
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  if (typeof cmd.setup === "function")
+    await cmd.setup(context);
+  let result;
+  try {
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
+      const subCommandName = opts.rawArgs[subCommandArgIndex];
+      if (subCommandName) {
+        if (!subCommands[subCommandName])
+          throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
+        const subCommand = await resolveValue(subCommands[subCommandName]);
+        if (subCommand)
+          await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else if (!cmd.run)
+        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+    }
+    if (typeof cmd.run === "function")
+      result = await cmd.run(context);
+  } finally {
+    if (typeof cmd.cleanup === "function")
+      await cmd.cleanup(context);
+  }
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand)
+      return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + `
+`);
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs)
+    if (arg.type === "positional") {
+      const name = arg.name.toUpperCase();
+      const isRequired = arg.required !== false && arg.default === undefined;
+      const defaultHint = arg.default ? `="${arg.default}"` : "";
+      posLines.push([
+        cyan(name + defaultHint),
+        arg.description || "",
+        arg.valueHint ? `<${arg.valueHint}>` : ""
+      ]);
+      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+    } else {
+      const isRequired = arg.required === true && arg.default === undefined;
+      const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
+      argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+      if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+        const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+        argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+      }
+      if (isRequired)
+        usageLine.push(argStr);
+    }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden)
+        continue;
+      commandsLines.push([cyan(name), meta?.description || ""]);
+      commandNames.push(name);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join(`
+`);
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version)
+        throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else
+      await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else
+      console.error(error, `
+`);
+    process.exit(1);
+  }
+}
+
+export { defineCommand, runMain };

package/dist/chunk-2k3ysje3.js

@@ -0,0 +1,31 @@
+import {
+  $activeAlert,
+  $activeSheet,
+  $customSidebarItems,
+  $isSidebarCollapsed,
+  $toasts,
+  clearToast,
+  closeAlert,
+  closeSheet,
+  notify,
+  openAlert,
+  openSheet,
+  registerSidebarItem,
+  toggleSidebar
+} from "./chunk-m83ybzf8.js";
+import"./chunk-6bywt602.js";
+export {
+  toggleSidebar,
+  registerSidebarItem,
+  openSheet,
+  openAlert,
+  notify,
+  closeSheet,
+  closeAlert,
+  clearToast,
+  $toasts,
+  $isSidebarCollapsed,
+  $customSidebarItems,
+  $activeSheet,
+  $activeAlert
+};

package/dist/{chunk-jdfw4v3r.js → chunk-3j9zjfmn.js}

@@ -1,8 +1,11 @@
+import {
+  logger
+} from "./chunk-jq1drsen.js";
 import {
   __require
-} from "./chunk-8sqjbsgt.js";
+} from "./chunk-6bywt602.js";
 
-// src/cli/seeding.ts
+// src/cli/core/seeding/auto-seed.ts
 import { faker } from "@faker-js/faker";
 var defaultFieldGenerators = {
   text: () => faker.lorem.words(3),
@@ -65,9 +68,28 @@ var defaultFieldGenerators = {
   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 {
-    const result = await db.find(relationTo, {}, { limit: 50 });
-    const docs = result.docs || [];
+    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.`);
@@ -77,8 +99,7 @@ async function getRandomIds(db, relationTo, count = 1) {
     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);
+  } catch (_e) {
     return [];
   }
 }
@@ -133,7 +154,9 @@ async function generateDataForFields(fields, db, locales = []) {
             const choices = options?.choices || [];
             if (choices.length > 0) {
               const choice = choices[Math.floor(Math.random() * choices.length)];
-              return typeof choice === "string" ? choice : choice.value;
+              if (choice) {
+                return typeof choice === "string" ? choice : choice.value;
+              }
             }
           }
           return generator();
@@ -154,7 +177,12 @@ async function generateDataForFields(fields, db, locales = []) {
   return record;
 }
 async function generateRecord(db, collection, locales = []) {
-  return generateDataForFields(collection.fields, db, 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 = [];
@@ -170,7 +198,7 @@ function sortCollections(collections) {
     const deps = [];
     const findDeps = (fields) => {
       for (const f of fields) {
-        if (f.type === "relationship") {
+        if (f.type === "relationship" && "relationTo" in f) {
           deps.push(f.relationTo);
         } else if (f.type === "blocks" && f.blocks) {
           for (const b of f.blocks) {
@@ -200,36 +228,46 @@ function sortCollections(collections) {
   }
   return sorted;
 }
-async function autoSeed(config, countPerCollection = 10, reset = false, type = "all") {
+async function autoSeed(config, countPerCollection = 10, reset = false, type = "all", targetTable) {
   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 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 === "_opaca_assets");
-    console.log("\uD83D\uDCC1 Seeding only 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 !== "_opaca_assets");
-    console.log("\uD83D\uDCDA Seeding only user 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) {
-      console.log("\uD83E\uDDF9 Resetting data (deleting existing records)...");
+      logger.info("\uD83E\uDDF9 Resetting data (cleaning existing records)...");
       const reversed = [...collectionsToSeed].reverse();
       for (const collection of reversed) {
-        console.log(`Cleaning ${collection.slug}...`);
+        logger.log(`   ${logger.format("gray", "delete")} ${collection.slug}`);
         await db.deleteMany?.(collection.slug, {});
       }
     }
-    const storageAdapter = storages?.default || storages;
-    const locales = config.i18n?.locales || [];
+    const storageAdapter = storages.default || storages;
     for (const collection of collectionsToSeed) {
-      console.log(`Seeding ${collection.slug}...`);
-      const isAssetCollection = collection.slug === "_opaca_assets";
+      logger.info(`Seeding ${logger.bold(collection.slug)}...`);
+      const isAssetCollection = collection.slug === "_assets";
       for (let i = 0;i < countPerCollection; i++) {
         let data;
         if (isAssetCollection) {
@@ -268,10 +306,8 @@ async function autoSeed(config, countPerCollection = 10, reset = false, 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, {
+          const uploadAdapter = storageAdapter;
+          const uploaded = await uploadAdapter.upload(fileRecord, {
             generateUniqueName: true,
             customMetadata: {
               sourceUrl: imageUrl
@@ -292,19 +328,48 @@ async function autoSeed(config, countPerCollection = 10, reset = false, type = "
             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})`);
+          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);
       }
     }
-    console.log("✅ Seeding completed.");
+    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