@drawnagency/primitives 0.1.49 → 0.1.51

package/src/schemas/link.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const LinkTargetSchema = z.enum(["_self", "_blank"]);
+
+export const LinkValueSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("external"), href: z.string(), target: LinkTargetSchema }),
+  z.object({
+    kind: z.literal("internal"),
+    pageId: z.string(),
+    anchorSectionId: z.string().nullable().optional(),
+    target: LinkTargetSchema,
+  }),
+]);
+
+export type LinkValue = z.infer<typeof LinkValueSchema>;
+
+export const DEFAULT_LINK: LinkValue = { kind: "external", href: "", target: "_self" };

package/src/schemas/site-config.ts

@@ -14,21 +14,123 @@ export const SectionMetaSchema = z.object({
 
 export type SectionMeta = z.infer<typeof SectionMetaSchema>;
 
-export const IndexSchema = z.object({
-  siteId: z.string(),
+// Page slugs that would shadow a platform route. KEEP IN SYNC with the root and
+// /edit/* route patterns injected in packages/core/src/integration.ts — if a new
+// root-level route is added there, add its first segment here (the test in Step 1
+// guards the known set). This is the single source of truth for reserved slugs;
+// the schema, uniquePageSlug, and /api/save all import it.
+export const RESERVED_SLUGS = ["edit", "api", "login", "set-password", "404"] as const;
+
+export const PageStatusSchema = z.enum(["live", "archived"]);
+
+export const PageSchema = z.object({
+  id: z.string().min(1),
+  title: z.string(),
+  slug: z.string(),
+  isHome: z.boolean(),
+  showInNav: z.boolean(),
+  status: PageStatusSchema,
+  access: z.array(z.string()),
   order: z.array(z.string()),
+});
+
+export type Page = z.infer<typeof PageSchema>;
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+// Raw input: accepts legacy (order[]) OR canonical (pages[]).
+const RawIndexSchema = z.object({
+  siteId: z.string(),
+  order: z.array(z.string()).optional(),
+  pages: z.array(PageSchema).optional(),
   sections: z.record(z.string(), SectionMetaSchema),
   lastModified: z.string().nullable().optional(),
-}).refine(
-  (data) => {
-    const orderSet = new Set(data.order);
-    return data.order.every((id) => id in data.sections) &&
-      Object.keys(data.sections).every((key) => orderSet.has(key));
-  },
-  { message: "Every id in order must have a sections entry and vice versa" }
-);
+});
+
+function normalizeRawIndex(data: z.infer<typeof RawIndexSchema>): z.input<typeof CanonicalIndexSchema> {
+  if (data.pages && data.pages.length > 0) {
+    return {
+      siteId: data.siteId,
+      pages: data.pages,
+      sections: data.sections,
+      lastModified: data.lastModified ?? null,
+    };
+  }
+  const order = data.order ?? Object.keys(data.sections);
+  return {
+    siteId: data.siteId,
+    pages: [
+      {
+        id: "home",
+        title: "Home",
+        slug: "",
+        isHome: true,
+        showInNav: true,
+        status: "live" as const,
+        access: [],
+        order,
+      },
+    ],
+    sections: data.sections,
+    lastModified: data.lastModified ?? null,
+  };
+}
+
+const CanonicalIndexSchema = z
+  .object({
+    siteId: z.string(),
+    pages: z.array(PageSchema),
+    sections: z.record(z.string(), SectionMetaSchema),
+    lastModified: z.string().nullable().optional(),
+  })
+  .superRefine((data, ctx) => {
+    const homes = data.pages.filter((p) => p.isHome);
+    if (homes.length !== 1) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Exactly one page must be the home page" });
+    }
+    if (homes[0]?.status === "archived") {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "The home page cannot be archived" });
+    }
+    if (homes[0] && homes[0].slug !== "") {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "The home page slug must be empty" });
+    }
+
+    const seenSlugs = new Set<string>();
+    for (const p of data.pages) {
+      if (!p.isHome) {
+        if (!SLUG_RE.test(p.slug)) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, message: `Invalid slug "${p.slug}"` });
+        }
+        if ((RESERVED_SLUGS as readonly string[]).includes(p.slug)) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, message: `Slug "${p.slug}" is reserved` });
+        }
+      }
+      if (seenSlugs.has(p.slug)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `Duplicate slug "${p.slug}"` });
+      }
+      seenSlugs.add(p.slug);
+    }
+
+    const fromPages: string[] = [];
+    for (const p of data.pages) fromPages.push(...p.order);
+    const fromPagesSet = new Set(fromPages);
+    if (fromPages.length !== fromPagesSet.size) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "A section id appears in more than one page" });
+    }
+    const sectionKeys = Object.keys(data.sections);
+    if (fromPagesSet.size !== sectionKeys.length || !sectionKeys.every((k) => fromPagesSet.has(k))) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Page section orders must partition sections{} exactly" });
+    }
+  });
 
-export type SiteIndex = z.infer<typeof IndexSchema>;
+export const IndexSchema = RawIndexSchema.transform(normalizeRawIndex).pipe(CanonicalIndexSchema);
+
+export type SiteIndex = z.infer<typeof CanonicalIndexSchema>;
+
+/** Parse + normalize any raw index (legacy or canonical) to the canonical shape. */
+export function normalizeSiteIndex(raw: unknown): SiteIndex {
+  return IndexSchema.parse(raw);
+}
 
 export const SiteConfigSchema = z.object({
   siteName: z.string().default("Brand Portal"),
@@ -44,6 +146,12 @@ export const SiteConfigSchema = z.object({
     .refine(url => url.startsWith("https://fonts.googleapis.com/"), "Must be a Google Fonts URL")
     .nullable()
     .default(null),
+  // Favicon stored as a data URL (SVG/PNG, small) so it travels with
+  // site-config.json — no media manifest or CDN round-trip needed.
+  favicon: z.string()
+    .refine((v) => v.startsWith("data:image/"), "Favicon must be an image data URL")
+    .nullable()
+    .default(null),
   media: MediaConfigSchema.default(MediaConfigSchema.parse({})),
 });