@orion-studios/cms 0.5.0

package/dist/blocks/index.js

@@ -0,0 +1,338 @@
+// src/blocks/deriveEditor.ts
+import { z as z2 } from "zod";
+
+// src/blocks/fieldTypes.ts
+import { z } from "zod";
+var LINK_MARKER = "__orion:link__";
+var MEDIA_MARKER = "__orion:media__";
+var RICHTEXT_MARKER = "__orion:richtext__";
+function link() {
+  return z.object({
+    label: z.string().default(""),
+    href: z.string().default(""),
+    variant: z.enum(["solid", "outline", "line"]).default("solid")
+  }).describe(LINK_MARKER);
+}
+function mediaRef() {
+  return z.object({
+    mediaId: z.string().nullable().default(null),
+    src: z.string().default(""),
+    alt: z.string().default(""),
+    caption: z.string().default("")
+  }).describe(MEDIA_MARKER);
+}
+function paragraphs() {
+  return z.array(z.string()).default([]).describe(RICHTEXT_MARKER);
+}
+var FILE_MARKER = "__orion:file__";
+function fileRef() {
+  return z.object({
+    mediaId: z.string().nullable().default(null),
+    src: z.string().default(""),
+    filename: z.string().default("")
+  }).describe(FILE_MARKER);
+}
+
+// src/blocks/deriveEditor.ts
+var TEXTAREA_KEY_HINTS = [
+  "answer",
+  "body",
+  "caption",
+  "description",
+  "intro",
+  "lead",
+  "message",
+  "note",
+  "quote",
+  "subtitle",
+  "text"
+];
+var ITEM_LABEL_KEY_PRIORITY = [
+  "title",
+  "label",
+  "caption",
+  "question",
+  "name",
+  "heading",
+  "value",
+  "alt",
+  "filename",
+  "description"
+];
+var labelForKey = (key) => key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+var unwrap = (schema) => {
+  let current = schema;
+  for (; ; ) {
+    if (current instanceof z2.ZodDefault) {
+      current = current._def.innerType;
+    } else if (current instanceof z2.ZodOptional || current instanceof z2.ZodNullable) {
+      current = current.unwrap();
+    } else {
+      return current;
+    }
+  }
+};
+var markerOf = (schema) => schema.description || unwrap(schema).description;
+var defaultsOf = (schema) => {
+  const parsed = schema.safeParse(void 0);
+  if (parsed.success) return parsed.data;
+  const inner = unwrap(schema);
+  if (inner instanceof z2.ZodObject) {
+    const objectParsed = inner.safeParse({});
+    if (objectParsed.success) return objectParsed.data;
+  }
+  return void 0;
+};
+function deriveField(key, schema) {
+  const label = labelForKey(key);
+  const marker = markerOf(schema);
+  if (marker === LINK_MARKER) return { key, label, input: "link" };
+  if (marker === MEDIA_MARKER) return { key, label, input: "media" };
+  if (marker === FILE_MARKER) return { key, label, input: "file" };
+  if (marker === RICHTEXT_MARKER) return { key, label, input: "paragraphs" };
+  const inner = unwrap(schema);
+  if (inner instanceof z2.ZodString) {
+    const lower = key.toLowerCase();
+    const isLong = TEXTAREA_KEY_HINTS.some((hint) => lower === hint || lower.endsWith(hint));
+    return { key, label, input: isLong ? "textarea" : "text", inline: true };
+  }
+  if (inner instanceof z2.ZodNumber) return { key, label, input: "number" };
+  if (inner instanceof z2.ZodBoolean) return { key, label, input: "checkbox" };
+  if (inner instanceof z2.ZodEnum) {
+    const values = inner._def.values;
+    return {
+      key,
+      label,
+      input: "select",
+      options: values.map((value) => ({ label: labelForKey(value), value }))
+    };
+  }
+  if (inner instanceof z2.ZodArray) {
+    const element = unwrap(inner._def.type);
+    if (element instanceof z2.ZodString) {
+      return { key, label, input: "stringList" };
+    }
+    if (element instanceof z2.ZodObject) {
+      const itemFields = deriveFields(element);
+      const itemTemplate = defaultsOf(element) || {};
+      const itemLabelKey = ITEM_LABEL_KEY_PRIORITY.map((key2) => itemFields.find((field) => field.key === key2)).find(Boolean)?.key || itemFields.find((field) => field.input === "text" || field.input === "textarea")?.key || itemFields[0]?.key;
+      return { key, label, input: "itemList", itemFields, itemTemplate, itemLabelKey };
+    }
+    return null;
+  }
+  if (inner instanceof z2.ZodObject) {
+    return null;
+  }
+  return null;
+}
+function deriveFields(schema) {
+  const fields = [];
+  for (const [key, value] of Object.entries(schema.shape)) {
+    const fieldSchema = value;
+    const derived = deriveField(key, fieldSchema);
+    if (derived) {
+      fields.push(derived);
+      continue;
+    }
+    const inner = unwrap(fieldSchema);
+    if (inner instanceof z2.ZodObject && !markerOf(fieldSchema)) {
+      for (const nested of deriveFields(inner)) {
+        fields.push({
+          ...nested,
+          key: `${key}.${nested.key}`,
+          label: `${labelForKey(key)} ${nested.label}`
+        });
+      }
+    }
+  }
+  return fields;
+}
+function mergeEditorFields(derived, overrides) {
+  if (!overrides || overrides.length === 0) return derived;
+  const byKey = new Map(derived.map((field) => [field.key, field]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const override of overrides) {
+    const base = byKey.get(override.key);
+    const merged = {
+      key: override.key,
+      label: override.label || base?.label || labelForKey(override.key),
+      input: override.input || base?.input || "text",
+      ...override.inline !== void 0 ? { inline: override.inline } : base?.inline !== void 0 ? { inline: base.inline } : {},
+      ...override.options || base?.options ? { options: override.options || base?.options } : {},
+      ...override.itemFields || base?.itemFields ? { itemFields: override.itemFields || base?.itemFields } : {},
+      ...override.itemTemplate || base?.itemTemplate ? { itemTemplate: override.itemTemplate || base?.itemTemplate } : {},
+      ...override.itemLabelKey || base?.itemLabelKey ? { itemLabelKey: override.itemLabelKey || base?.itemLabelKey } : {}
+    };
+    ordered.push(merged);
+    seen.add(override.key);
+  }
+  for (const field of derived) {
+    if (!seen.has(field.key)) ordered.push(field);
+  }
+  return ordered;
+}
+
+// src/blocks/globals.ts
+function defineGlobal(args) {
+  const parsedDefaults = args.schema.safeParse({});
+  if (!parsedDefaults.success) {
+    throw new Error(
+      `defineGlobal("${args.key}"): every field needs a .default() or .optional().`
+    );
+  }
+  return {
+    key: args.key,
+    label: args.label || labelForKey(args.key),
+    description: args.description,
+    schema: args.schema,
+    editor: { fields: mergeEditorFields(deriveFields(args.schema), args.editor?.fields) },
+    defaultData: parsedDefaults.data
+  };
+}
+function createGlobalRegistry(globals) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const definition of globals) {
+    if (byKey.has(definition.key)) {
+      throw new Error(`Duplicate global registered: "${definition.key}"`);
+    }
+    byKey.set(definition.key, definition);
+  }
+  return {
+    list: () => [...byKey.values()],
+    get: (key) => byKey.get(key),
+    normalize: (key, data) => {
+      const definition = byKey.get(key);
+      if (!definition) return data ?? {};
+      const parsed = definition.schema.safeParse(data ?? {});
+      return parsed.success ? parsed.data : definition.defaultData;
+    }
+  };
+}
+
+// src/blocks/index.ts
+function defineBlock(args) {
+  const parsedDefaults = args.schema.safeParse({});
+  if (!parsedDefaults.success) {
+    throw new Error(
+      `defineBlock("${args.type}"): every field needs a .default() or .optional() so the block can be created empty. ` + parsedDefaults.error.issues.map((issue) => issue.path.join(".")).join(", ")
+    );
+  }
+  const derived = deriveFields(args.schema);
+  return {
+    type: args.type,
+    label: args.label || labelForKey(args.type),
+    description: args.description,
+    category: args.category,
+    schema: args.schema,
+    editor: { fields: mergeEditorFields(derived, args.editor?.fields) },
+    defaultData: parsedDefaults.data,
+    preview: args.preview
+  };
+}
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var newBlockId = () => `b_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+function createBlockRegistry(blocks) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (byType.has(block.type)) {
+      throw new Error(`Duplicate block type registered: "${block.type}"`);
+    }
+    byType.set(block.type, block);
+  }
+  return {
+    list: () => [...byType.values()],
+    get: (type) => byType.get(type),
+    has: (type) => byType.has(type),
+    palette: () => [...byType.values()].map((block) => ({
+      type: block.type,
+      label: block.label,
+      description: block.description,
+      category: block.category,
+      defaultData: block.defaultData
+    })),
+    validateLayout: (layout) => {
+      const issues = [];
+      const normalized = [];
+      if (!Array.isArray(layout)) {
+        return {
+          ok: false,
+          layout: [],
+          issues: [{ blockId: "", blockType: "", path: "", message: "Layout must be an array of blocks." }]
+        };
+      }
+      for (const [index, raw] of layout.entries()) {
+        if (!isRecord(raw) || typeof raw.type !== "string") {
+          issues.push({
+            blockId: "",
+            blockType: "",
+            path: `[${index}]`,
+            message: 'Block must be an object with a "type".'
+          });
+          continue;
+        }
+        const definition = byType.get(raw.type);
+        const blockId = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : newBlockId();
+        if (!definition) {
+          issues.push({
+            blockId,
+            blockType: raw.type,
+            path: `[${index}]`,
+            message: `Unknown block type "${raw.type}".`
+          });
+          continue;
+        }
+        const parsed = definition.schema.safeParse(isRecord(raw.data) ? raw.data : {});
+        if (!parsed.success) {
+          for (const issue of parsed.error.issues) {
+            issues.push({
+              blockId,
+              blockType: raw.type,
+              path: issue.path.join("."),
+              message: issue.message
+            });
+          }
+          continue;
+        }
+        normalized.push({
+          id: blockId,
+          type: raw.type,
+          data: parsed.data,
+          ...isRecord(raw.settings) ? { settings: raw.settings } : {}
+        });
+      }
+      return { ok: issues.length === 0, layout: normalized, issues };
+    },
+    createInstance: (type) => {
+      const definition = byType.get(type);
+      if (!definition) throw new Error(`Unknown block type "${type}".`);
+      return {
+        id: newBlockId(),
+        type,
+        data: JSON.parse(JSON.stringify(definition.defaultData))
+      };
+    }
+  };
+}
+var instanceCounter = 0;
+function blockInstance(definition, data = {}, id) {
+  const parsed = definition.schema.parse(data);
+  instanceCounter += 1;
+  return {
+    id: id || `${definition.type}-${instanceCounter}`,
+    type: definition.type,
+    data: parsed
+  };
+}
+export {
+  blockInstance,
+  createBlockRegistry,
+  createGlobalRegistry,
+  defineBlock,
+  defineGlobal,
+  fileRef,
+  labelForKey,
+  link,
+  mediaRef,
+  paragraphs
+};

package/dist/chunk-HVJCF2IZ.js

@@ -0,0 +1,76 @@
+// src/content/index.ts
+import { createClient } from "@supabase/supabase-js";
+var CONTENT_CACHE_TAG = "orion-content";
+var toPublicPage = (row) => ({
+  id: String(row.id),
+  slug: String(row.slug),
+  path: String(row.path),
+  title: String(row.title ?? ""),
+  seo: row.seo ?? {},
+  layout: row.published_layout ?? []
+});
+function createContentClient(options = {}) {
+  const supabaseUrl = options.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || "";
+  const anonKey = options.anonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY || process.env.SUPABASE_PUBLISHABLE_KEY || "";
+  if (!supabaseUrl || !anonKey) {
+    throw new Error(
+      "Orion CMS: NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY (or NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY) must be set."
+    );
+  }
+  const client = createClient(supabaseUrl, anonKey, {
+    auth: { persistSession: false, autoRefreshToken: false }
+  });
+  const selectPage = "id, slug, path, title, seo, published_layout";
+  return {
+    async getPageByPath(path) {
+      const { data } = await client.from("cms_pages").select(selectPage).eq("path", path).eq("status", "published").maybeSingle();
+      return data ? toPublicPage(data) : null;
+    },
+    async getPageBySlug(slug) {
+      const { data } = await client.from("cms_pages").select(selectPage).eq("slug", slug).eq("status", "published").maybeSingle();
+      return data ? toPublicPage(data) : null;
+    },
+    async listPublishedPaths() {
+      const { data } = await client.from("cms_pages").select("path").eq("status", "published").limit(1e3);
+      return (data || []).map((row) => row.path).filter((path) => typeof path === "string" && path.length > 0);
+    },
+    async getGlobal(key) {
+      const { data } = await client.from("cms_globals").select("data").eq("key", key).maybeSingle();
+      return data?.data ?? {};
+    },
+    async getFormConfig(slug) {
+      const { data } = await client.from("cms_forms").select("slug, title, config, success_message").eq("slug", slug).maybeSingle();
+      if (!data) return null;
+      const config = { ...data.config ?? {} };
+      delete config.notify;
+      return {
+        slug: data.slug,
+        title: data.title ?? "",
+        config,
+        successMessage: data.success_message ?? ""
+      };
+    },
+    async getRedirect(path) {
+      const { data } = await client.from("cms_redirects").select("to_path, permanent").eq("from_path", path).maybeSingle();
+      if (!data) return null;
+      return { toPath: String(data.to_path), permanent: data.permanent !== false };
+    },
+    mediaUrl(storagePath, transform) {
+      if (storagePath.startsWith("data:")) return storagePath;
+      const base = `${supabaseUrl}/storage/v1`;
+      if (!transform || !transform.width && !transform.height) {
+        return `${base}/object/public/media/${storagePath}`;
+      }
+      const params = new URLSearchParams();
+      if (transform.width) params.set("width", String(transform.width));
+      if (transform.height) params.set("height", String(transform.height));
+      params.set("quality", String(transform.quality ?? 80));
+      return `${base}/render/image/public/media/${storagePath}?${params.toString()}`;
+    }
+  };
+}
+
+export {
+  CONTENT_CACHE_TAG,
+  createContentClient
+};