opacacms 0.2.1 → 0.3.0

package/dist/chunk-m5ems3hh.js

@@ -0,0 +1,410 @@
+import {
+  __esm,
+  __export
+} from "./chunk-6bywt602.js";
+
+// src/schema/zod.ts
+import * as zOriginal from "zod";
+var z, $ZodOptional, $ZodNullable, $ZodDefault, $ZodString, $ZodNumber, $ZodBoolean, $ZodDate, $ZodEnum, $ZodObject, $ZodArray, $ZodDiscriminatedUnion;
+var init_zod = __esm(() => {
+  zOriginal.ZodType.prototype.unique = function() {
+    return this.meta({ opaca: { unique: true } });
+  };
+  zOriginal.ZodType.prototype.localized = function() {
+    return this.meta({ opaca: { localized: true } });
+  };
+  zOriginal.ZodType.prototype.required = function(condition) {
+    if (condition) {
+      return this.optional().meta({ opaca: { requiredCondition: condition } });
+    }
+    return this;
+  };
+  zOriginal.ZodType.prototype.condition = function(fn) {
+    return this.meta({ opaca: { admin: { condition: fn } } });
+  };
+  zOriginal.ZodType.prototype.cms = function(meta) {
+    const current = this.meta() || {};
+    return this.meta({
+      ...current,
+      opaca: {
+        ...current.opaca,
+        ...meta,
+        admin: {
+          ...current.opaca?.admin,
+          ...meta?.admin
+        }
+      }
+    });
+  };
+  z = {
+    ...zOriginal,
+    helpers: (schemaOrType) => {
+      return {
+        condition: (schema, fn) => schema.condition(fn),
+        required: (schema, fn) => schema.required(fn),
+        meta: (schema, meta) => {
+          let s = schema;
+          if (meta.condition)
+            s = s.condition(meta.condition);
+          if (meta.required)
+            s = s.required(meta.required);
+          return s.cms(meta);
+        },
+        cms: function(schema, meta) {
+          return this.meta(schema, meta);
+        }
+      };
+    },
+    text: (options) => zOriginal.string().meta({
+      opaca: {
+        unique: options?.unique,
+        localized: options?.localized,
+        admin: { component: "text", label: options?.label, description: options?.description }
+      }
+    }),
+    slug: (options) => zOriginal.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Invalid slug format").meta({
+      opaca: {
+        admin: { component: "slug", label: options.label, slugOptions: options }
+      }
+    }),
+    relationship: (collection, options) => {
+      const base = zOriginal.string();
+      const schema = options?.hasMany ? zOriginal.array(base.optional().nullable()) : base;
+      return schema.meta({
+        opaca: {
+          admin: {
+            component: "relationship",
+            label: options?.label,
+            relationTo: collection,
+            hasMany: options?.hasMany || false,
+            displayField: options?.displayField
+          }
+        }
+      });
+    },
+    richText: (options) => zOriginal.union([zOriginal.string(), zOriginal.object({})]).meta({
+      opaca: {
+        admin: {
+          component: "richtext",
+          label: options?.label,
+          choices: options?.mode ? [options.mode] : undefined
+        }
+      }
+    }),
+    file: (options) => zOriginal.object({
+      id: zOriginal.string(),
+      url: zOriginal.string(),
+      filename: zOriginal.string(),
+      mime_type: zOriginal.string(),
+      filesize: zOriginal.number()
+    }).meta({
+      opaca: {
+        admin: { component: "file", label: options?.label, fileOptions: options }
+      }
+    }),
+    textarea: (options) => zOriginal.string().meta({
+      opaca: {
+        localized: options?.localized,
+        admin: { component: "textarea", label: options?.label, description: options?.description }
+      }
+    }),
+    number: (options) => zOriginal.number().meta({
+      opaca: {
+        admin: { component: "number", label: options?.label, description: options?.description }
+      }
+    }),
+    boolean: (options) => zOriginal.preprocess((val) => {
+      if (val === "true" || val === 1)
+        return true;
+      if (val === "false" || val === 0)
+        return false;
+      return val;
+    }, zOriginal.boolean()).meta({
+      opaca: {
+        admin: { component: "boolean", label: options?.label, description: options?.description }
+      }
+    }),
+    date: (options) => zOriginal.date().meta({
+      opaca: {
+        admin: { component: "date", label: options?.label, description: options?.description }
+      }
+    }),
+    select: (choices, options) => {
+      const values = choices.map((c) => typeof c === "string" ? c : c.value);
+      return zOriginal.enum(values).meta({
+        opaca: {
+          admin: {
+            component: "select",
+            label: options?.label,
+            description: options?.description,
+            choices: typeof choices[0] === "string" ? undefined : choices
+          }
+        }
+      });
+    },
+    radio: (choices, options) => {
+      const values = choices.map((c) => typeof c === "string" ? c : c.value);
+      return zOriginal.enum(values).meta({
+        opaca: {
+          admin: {
+            component: "radio",
+            label: options?.label,
+            description: options?.description,
+            choices: typeof choices[0] === "string" ? undefined : choices
+          }
+        }
+      });
+    },
+    password: (options) => zOriginal.string().meta({
+      opaca: {
+        hash: { algorithm: options?.algorithm || "argon2" },
+        admin: { component: "text", label: options?.label, hidden: true }
+      }
+    }),
+    join: (collection, on, options) => zOriginal.array(zOriginal.any()).optional().meta({
+      opaca: {
+        virtual: true,
+        admin: { component: "join", label: options?.label, relationTo: collection }
+      }
+    }),
+    group: (shape, options) => zOriginal.object(shape).meta({
+      opaca: { admin: { component: "group", label: options?.label } }
+    }),
+    row: (shape, options) => zOriginal.object(shape).meta({
+      opaca: { admin: { component: "row", label: options?.label } }
+    }),
+    collapsible: (shape, options) => zOriginal.object(shape).meta({
+      opaca: {
+        admin: {
+          component: "collapsible",
+          label: options?.label,
+          initiallyCollapsed: options?.initiallyCollapsed
+        }
+      }
+    }),
+    tabs: (tabsConfig, options) => {
+      let mergedShape = {};
+      const metaTabs = [];
+      for (const [tabLabel, zodObj] of Object.entries(tabsConfig)) {
+        mergedShape = { ...mergedShape, ...zodObj.shape };
+        metaTabs.push({ label: tabLabel, fields: Object.keys(zodObj.shape) });
+      }
+      return zOriginal.object(mergedShape).meta({
+        opaca: {
+          admin: { component: "tabs", label: options?.label, tabsConfig: metaTabs }
+        }
+      });
+    },
+    blocks: (blockSchemas, options) => zOriginal.array(zOriginal.discriminatedUnion("blockType", blockSchemas)).meta({
+      opaca: { admin: { component: "blocks", label: options?.label } }
+    }),
+    localized: (schema) => {
+      return schema.meta({
+        opaca: { localized: true }
+      });
+    },
+    ui: (component, adminConfig) => {
+      return zOriginal.any().meta({
+        opaca: {
+          admin: {
+            component: "ui",
+            customComponent: component,
+            ...adminConfig
+          }
+        }
+      });
+    },
+    cms: (schema, meta) => schema.meta({ opaca: meta })
+  };
+  $ZodOptional = zOriginal.ZodOptional;
+  $ZodNullable = zOriginal.ZodNullable;
+  $ZodDefault = zOriginal.ZodDefault;
+  $ZodString = zOriginal.ZodString;
+  $ZodNumber = zOriginal.ZodNumber;
+  $ZodBoolean = zOriginal.ZodBoolean;
+  $ZodDate = zOriginal.ZodDate;
+  $ZodEnum = zOriginal.ZodEnum;
+  $ZodObject = zOriginal.ZodObject;
+  $ZodArray = zOriginal.ZodArray;
+  $ZodDiscriminatedUnion = zOriginal.ZodDiscriminatedUnion;
+});
+
+// src/schema/compiler.ts
+var exports_compiler = {};
+__export(exports_compiler, {
+  zodToOpacaFields: () => zodToOpacaFields
+});
+function zodToOpacaFields(schema, currentPath = "") {
+  if (!schema || !schema._def) {
+    return [];
+  }
+  let innerSchema = schema;
+  let meta = {};
+  while (innerSchema && innerSchema._def && ["optional", "nullable", "default"].includes(innerSchema._def.type)) {
+    const currentMeta = typeof innerSchema.meta === "function" ? innerSchema.meta() : innerSchema._def.meta;
+    if (currentMeta?.opaca) {
+      meta = { ...currentMeta.opaca, ...meta };
+    }
+    innerSchema = innerSchema._def.innerType;
+  }
+  if (innerSchema && innerSchema._def) {
+    const finalMeta = typeof innerSchema.meta === "function" ? innerSchema.meta() : innerSchema._def.meta;
+    if (finalMeta?.opaca) {
+      meta = { ...finalMeta.opaca, ...meta };
+    }
+  }
+  const def = schema._def;
+  const defaultValue = def.type === "default" && typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  const baseConfig = {
+    name: currentPath,
+    label: meta.admin?.label || currentPath,
+    required: !schema.isOptional(),
+    unique: meta.unique || false,
+    localized: meta.localized || false,
+    virtual: meta.virtual || meta.isVirtual || false,
+    requiredCondition: meta.requiredCondition || meta.required,
+    condition: meta.condition || meta.admin?.condition,
+    defaultValue,
+    admin: {
+      ...meta.admin,
+      condition: meta.condition || meta.admin?.condition,
+      requiredCondition: meta.requiredCondition || meta.required
+    },
+    ...meta.admin,
+    ...meta
+  };
+  const OPACA_TYPES = [
+    "text",
+    "slug",
+    "textarea",
+    "number",
+    "richtext",
+    "relationship",
+    "select",
+    "radio",
+    "date",
+    "boolean",
+    "json",
+    "file",
+    "blocks",
+    "group",
+    "row",
+    "collapsible",
+    "tabs",
+    "join",
+    "array",
+    "virtual",
+    "ui"
+  ];
+  const type = innerSchema._def.type;
+  if (type === "string") {
+    const component = meta.admin?.component;
+    return [
+      {
+        ...baseConfig,
+        type: component && OPACA_TYPES.includes(component) ? component : "text"
+      }
+    ];
+  }
+  if (type === "number") {
+    return [{ ...baseConfig, type: "number" }];
+  }
+  if (type === "boolean") {
+    return [{ ...baseConfig, type: "boolean" }];
+  }
+  if (type === "date") {
+    return [{ ...baseConfig, type: "date" }];
+  }
+  if (type === "enum") {
+    const component = meta.admin?.component;
+    const choices = innerSchema._def.values || Object.values(innerSchema.enum || {});
+    return [
+      {
+        ...baseConfig,
+        type: component && OPACA_TYPES.includes(component) ? component : "select",
+        options: {
+          choices
+        }
+      }
+    ];
+  }
+  if (type === "object") {
+    const shape = innerSchema.shape;
+    const nestedFields = Object.entries(shape).flatMap(([key, val]) => zodToOpacaFields(val, key));
+    if (currentPath === "") {
+      return nestedFields;
+    }
+    const component = meta.admin?.component || "group";
+    if (component === "tabs" && meta.admin?.tabsConfig) {
+      return [
+        {
+          ...baseConfig,
+          type: "tabs",
+          tabs: meta.admin.tabsConfig.map((t) => ({
+            label: t.label,
+            fields: nestedFields.filter((f) => t.fields.includes(f.name))
+          }))
+        }
+      ];
+    }
+    return [
+      {
+        ...baseConfig,
+        type: component,
+        fields: nestedFields
+      }
+    ];
+  }
+  if (type === "array") {
+    const elementSchema = innerSchema._def.element;
+    const component = meta.admin?.component || "array";
+    const isDiscUnion = elementSchema && elementSchema._def.type === "union" && elementSchema._def.discriminator;
+    if (component === "blocks" || isDiscUnion) {
+      let blocks = [];
+      if (isDiscUnion) {
+        const options = elementSchema._def.options;
+        blocks = options.map((obj) => {
+          const discriminator = elementSchema._def.discriminator;
+          const shape = obj.shape;
+          const discriminatorField = shape?.[discriminator];
+          const slug = discriminatorField?._def.values?.[0] || "block";
+          return {
+            slug,
+            fields: zodToOpacaFields(obj)
+          };
+        });
+      }
+      return [
+        {
+          ...baseConfig,
+          type: "blocks",
+          blocks
+        }
+      ];
+    }
+    return [
+      {
+        ...baseConfig,
+        type: "array",
+        fields: elementSchema ? zodToOpacaFields(elementSchema, "") : []
+      }
+    ];
+  }
+  if (meta.admin?.component) {
+    return [
+      {
+        ...baseConfig,
+        type: meta.admin.component
+      }
+    ];
+  }
+  return [
+    {
+      ...baseConfig,
+      type: "json"
+    }
+  ];
+}
+var init_compiler = () => {};
+
+export { z, $ZodOptional, $ZodNullable, $ZodDefault, $ZodString, $ZodNumber, $ZodBoolean, $ZodDate, $ZodEnum, $ZodObject, $ZodArray, $ZodDiscriminatedUnion, init_zod, zodToOpacaFields, exports_compiler, init_compiler };

package/dist/{chunk-8scgdznr.js → chunk-m83ybzf8.js}

@@ -20,25 +20,22 @@ var $customSidebarItems = atom([]);
 function registerSidebarItem(item) {
   const current = $customSidebarItems.get();
   if (!current.find((i) => i.path === item.path)) {
-    if (item.render && !item.component) {
-      item.component = `opaca-plugin-render-${Math.random().toString(36).substring(2, 9)}`;
-      if (typeof customElements !== "undefined" && !customElements.get(item.component)) {
-        const componentName = item.component;
-        const renderFn = item.render;
-
-        class OpacaGenericPlugin extends HTMLElement {
-          connectedCallback() {
-            const serverUrl = this.getAttribute("server-url") || "";
-            const config = JSON.parse(this.getAttribute("config") || "{}");
-            const user = JSON.parse(this.getAttribute("user") || "{}");
-            this.innerHTML = renderFn(serverUrl, config, user);
-          }
-        }
-        customElements.define(componentName, OpacaGenericPlugin);
-      }
-    }
     $customSidebarItems.set([...current, item]);
   }
 }
+var $activeAlert = atom(null);
+function openAlert(options) {
+  $activeAlert.set(options);
+}
+function closeAlert() {
+  $activeAlert.set(null);
+}
+var $activeSheet = atom(null);
+function openSheet(options) {
+  $activeSheet.set(options);
+}
+function closeSheet() {
+  $activeSheet.set(null);
+}
 
-export { $toasts, $isSidebarCollapsed, toggleSidebar, notify, clearToast, $customSidebarItems, registerSidebarItem };
+export { $toasts, $isSidebarCollapsed, toggleSidebar, notify, clearToast, $customSidebarItems, registerSidebarItem, $activeAlert, openAlert, closeAlert, $activeSheet, openSheet, closeSheet };

package/dist/chunk-majsbncm.js

@@ -0,0 +1,98 @@
+import {
+  defineCommand,
+  runMain
+} from "./chunk-1qm0m8r8.js";
+import {
+  __require
+} from "./chunk-6bywt602.js";
+
+// src/cli/index.ts
+import fs from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found at ${configPath}`);
+  }
+  const configUrl = pathToFileURL(configPath).href;
+  const mod = await import(configUrl);
+  if (!mod.default) {
+    throw new Error(`The configuration file at ${configPath} must have a 'default' export.`);
+  }
+  const namedExports = Object.keys(mod).filter((k) => k !== "default" && k !== "__esModule");
+  if (namedExports.length > 0) {
+    throw new Error(`Named exports are not allowed in the configuration file. Found: ${namedExports.join(", ")}.`);
+  }
+  let opaca = mod.default;
+  if (typeof opaca === "function") {
+    const { createD1Mock } = await import("./chunk-h6dhexzr.js");
+    const { createR2Mock } = await import("./chunk-x7bnzswh.js");
+    const mockDb = createD1Mock();
+    const mockBucket = createR2Mock();
+    const mockSecureBucket = createR2Mock();
+    opaca = await opaca({
+      DB: mockDb,
+      BUCKET: mockBucket,
+      SECURE_BUCKET: mockSecureBucket,
+      OPACA_SECRET: "cli-secret"
+    }, { url: "http://localhost:3000" });
+  }
+  if (opaca?.fetch) {
+    throw new Error("Default export is a Hono application. The CLI requires the configuration object.");
+  }
+  if (!opaca.db) {
+    throw new Error("No database adapter found in config");
+  }
+  return opaca;
+}
+function resolveConfigPath(explicitPath) {
+  let configPath = explicitPath ? resolve(process.cwd(), explicitPath) : "";
+  if (!configPath) {
+    const defaults = [
+      "opaca.config.ts",
+      "opaca.config.js",
+      "opacacms.config.ts",
+      "opacacms.config.js",
+      "src/opaca.config.ts",
+      "src/opacacms.config.js"
+    ];
+    for (const d of defaults) {
+      if (fs.existsSync(resolve(process.cwd(), d))) {
+        configPath = resolve(process.cwd(), d);
+        break;
+      }
+    }
+  }
+  if (!configPath || !fs.existsSync(configPath)) {
+    throw new Error("Config file not found. Use -c or --config to specify path.");
+  }
+  return configPath;
+}
+var mainCommand = defineCommand({
+  meta: {
+    name: "opacacms",
+    version: "0.1.0",
+    description: "OpacaCMS CLI - The Headless CMS that doesn't get in your way."
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      description: "Path to the OpacaCMS configuration file"
+    }
+  },
+  subCommands: {
+    init: () => import("./chunk-fatyf6f7.js").then((m) => m.default),
+    migrate: () => import("./chunk-d7cgd6vn.js").then((m) => m.default),
+    seed: () => import("./chunk-d0tb1xjw.js").then((m) => m.default),
+    generate: () => import("./chunk-mp2gt9yh.js").then((m) => m.default),
+    plugin: () => import("./chunk-63yg00vx.js").then((m) => m.default),
+    doctor: () => import("./chunk-56n342hs.js").then((m) => m.default),
+    dev: () => import("./chunk-r0ms5tk1.js").then((m) => m.default)
+  }
+});
+if (__require.main == __require.module) {
+  runMain(mainCommand);
+}
+
+export { loadConfig, resolveConfigPath };