@acms-subir/core 0.3.15 → 0.3.17

package/src/lib/sync/catalog.ts

@@ -0,0 +1,250 @@
+import { z } from "zod";
+import {
+  Page,
+  Post,
+  Calendar,
+  CalEvent,
+  Resource,
+  BookingLink,
+  Place,
+  Media,
+  NavItem,
+  Redirect,
+  Tag,
+  Settings,
+  CalendarSettings,
+} from "../schema";
+import { SavedForm } from "../forms/schema";
+import { DesignPatch } from "../design-service";
+import { SectionPages } from "../../theme-sdk/contract.mjs";
+import { pickPageDraft, pickPostDraft, pickEventDraft } from "../drafts";
+import { ApiError } from "../api";
+
+export type Data = Record<string, any>;
+const common = { id: true, createdAt: true, updatedAt: true } as const;
+export const schemas = {
+  page: Page.omit({ ...common, draft: true })
+    .extend({ layout: z.unknown().nullable() })
+    .strict(),
+  post: Post.omit({ ...common, draft: true, authorId: true }).strict(),
+  calendar: Calendar.omit({
+    ...common,
+    feedToken: true,
+    feedUrl: true,
+  }).strict(),
+  event: CalEvent.omit({
+    ...common,
+    draft: true,
+    startAt: true,
+    endAt: true,
+    sourceUid: true,
+  }).strict(),
+  resource: Resource.omit({
+    ...common,
+    feedToken: true,
+    busyFeeds: true,
+    notifyEmails: true,
+  }).strict(),
+  booking: BookingLink.omit(common).strict(),
+  place: Place.omit(common).strict(),
+  form: SavedForm.omit({ ...common, draft: true, revision: true }).strict(),
+  media: Media.omit({ id: true, createdAt: true })
+    .extend({
+      objects: z
+        .array(
+          z
+            .object({
+              key: z.string(),
+              digest: z.string().regex(/^[a-f0-9]{64}$/),
+              size: z.number().int().nonnegative(),
+            })
+            .strict(),
+        )
+        .max(20),
+    })
+    .strict(),
+  nav: NavItem.omit({ id: true }).strict(),
+  redirect: Redirect.omit({ id: true, createdAt: true }).strict(),
+  tag: Tag.omit({ id: true }).strict(),
+  design: DesignPatch.omit({ sectionPages: true, navItems: true }).strict(),
+  settings: Settings.pick({
+    siteTitle: true,
+    tagline: true,
+    footerText: true,
+    timezone: true,
+    locale: true,
+    announcement: true,
+  }).strict(),
+  "booking-settings": CalendarSettings.strict(),
+  // Bylines can be linked to existing profiles; accounts never transfer.
+  author: z.object({ name: z.string(), slug: z.string() }).strict(),
+};
+export type Kind = keyof typeof schemas;
+export const tables: Partial<Record<Kind, string>> = {
+  page: "pages",
+  post: "posts",
+  calendar: "calendars",
+  event: "events",
+  resource: "resources",
+  booking: "booking_links",
+  place: "places",
+  form: "forms",
+  media: "media",
+  nav: "nav_items",
+  redirect: "redirects",
+  tag: "tags",
+  author: "users",
+};
+export const settingsKinds = new Set<Kind>([
+  "design",
+  "settings",
+  "booking-settings",
+]);
+export const draftKinds = new Set<Kind>([
+  "page",
+  "post",
+  "event",
+  "form",
+  "design",
+]);
+const special: Record<string, string> = {
+  order: "ord",
+  start: "starts",
+  end: "ends",
+};
+export const column = (field: string) =>
+  special[field] ?? field.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+const jsonFields = new Set([
+  "blocks",
+  "translations",
+  "tags",
+  "calendarIds",
+  "fields",
+  "location",
+  "cta",
+  "rsvp",
+  "roomHold",
+  "exdates",
+  "amenities",
+  "hours",
+  "overrides",
+  "lengths",
+  "approvalRules",
+  "questions",
+  "variants",
+  "definition",
+  "designOverrides",
+  "announcement",
+]);
+const boolFields = new Set([
+  "isHome",
+  "featured",
+  "allDay",
+  "cancelled",
+  "showOnCalendar",
+  "isDefault",
+  "autoConfirm",
+  "askPhone",
+  "active",
+]);
+export function fields(kind: Kind) {
+  return Object.keys(schemas[kind].shape).filter(
+    (k) => !["layout", "objects", "authorIds"].includes(k),
+  );
+}
+export const encode = (value: any) =>
+  value === null
+    ? null
+    : typeof value === "boolean"
+      ? Number(value)
+      : typeof value === "object"
+        ? JSON.stringify(value)
+        : value;
+export function rowData(kind: Kind, row: Data): Data {
+  const data: Data = {};
+  for (const key of fields(kind)) {
+    let value = row[column(key)];
+    if (value === undefined) continue;
+    if (jsonFields.has(key) && typeof value === "string")
+      value = JSON.parse(value);
+    if (boolFields.has(key)) value = Boolean(value);
+    data[key] = value;
+  }
+  return data;
+}
+export function parseData(kind: Kind, input: unknown): Data {
+  const data = schemas[kind].parse(input) as Data;
+  if (kind === "page" && data.layout !== null)
+    SectionPages.parse({ page: data.layout });
+  if (
+    ["page", "post", "calendar", "event", "resource", "booking"].includes(
+      kind,
+    ) &&
+    !/^[a-z0-9][a-z0-9-]{0,199}$/.test(data.slug)
+  )
+    throw new ApiError(400, "Sync requires a valid content slug.");
+  if (kind === "media") {
+    for (const key of [
+      data.key,
+      ...data.variants.map((v: Data) => v.key),
+      ...data.objects.map((o: Data) => o.key),
+    ])
+      safeMediaKey(key);
+    const required = [data.key, ...data.variants.map((v: Data) => v.key)];
+    if (
+      data.objects.length !== required.length ||
+      required.some(
+        (k) => data.objects.filter((o: Data) => o.key === k).length !== 1,
+      )
+    )
+      throw new ApiError(
+        400,
+        "Media checksums must cover each file exactly once.",
+      );
+  }
+  return data;
+}
+export function safeMediaKey(key: string) {
+  if (
+    !/^[a-zA-Z0-9_./-]+$/.test(key) ||
+    key.startsWith("/") ||
+    key.split("/").some((p) => !p || p === "." || p === "..") ||
+    key.length > 500
+  )
+    throw new ApiError(400, "Invalid media storage key.");
+  return key;
+}
+export function effective(kind: Kind, live: Data, draft: Data | null): Data {
+  if (!draft) return live;
+  const pick =
+    kind === "page"
+      ? pickPageDraft
+      : kind === "post"
+        ? pickPostDraft
+        : kind === "event"
+          ? pickEventDraft
+          : null;
+  if (pick) return { ...live, ...pick(draft) };
+  if (kind === "form") return { ...live, definition: draft };
+  if (kind === "design")
+    return {
+      ...live,
+      ...Object.fromEntries(
+        Object.entries(draft).filter(([k]) => fields("design").includes(k)),
+      ),
+    };
+  return live;
+}
+export function matchKey(kind: Kind, data: Data) {
+  if (kind === "post") return `${data.collection}/${data.slug}`;
+  if (kind === "booking") return `${data.resourceId}/${data.slug}`;
+  if (kind === "nav") return `${data.area}/${data.url}`;
+  if (kind === "redirect") return data.fromPath;
+  if (kind === "media") return data.objects?.[0]?.digest ?? data.key;
+  return data.slug || data.name || kind;
+}
+export function displayRef(kind: Kind, data: Data) {
+  if (settingsKinds.has(kind)) return `${kind}:site`;
+  if (kind === "post") return `post:${data.collection}/${data.slug}`;
+  return `${kind}:${data.slug || data.name || data.filename || data.fromPath || data.label}`;
+}

package/src/lib/sync/migration.ts

@@ -0,0 +1,51 @@
+const tables = [
+  "pages",
+  "posts",
+  "post_authors",
+  "calendars",
+  "events",
+  "resources",
+  "booking_links",
+  "places",
+  "forms",
+  "media",
+  "nav_items",
+  "redirects",
+  "tags",
+  "users",
+  "sync_aliases",
+  "bookings",
+  "form_submissions",
+];
+export const SYNC_MIGRATION = {
+  version: 52,
+  statements: [
+    `CREATE TABLE sync_state (id INTEGER PRIMARY KEY CHECK(id=1), site_id TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 0)`,
+    `INSERT INTO sync_state (id,site_id) VALUES (1,lower(hex(randomblob(16))))`,
+    `CREATE TABLE sync_aliases (alias TEXT PRIMARY KEY, kind TEXT NOT NULL, local_id TEXT NOT NULL, canonical INTEGER NOT NULL DEFAULT 0)`,
+    `CREATE UNIQUE INDEX sync_canonical ON sync_aliases(kind,local_id) WHERE canonical=1`,
+    `CREATE TABLE sync_versions (entity TEXT PRIMARY KEY, revision INTEGER NOT NULL)`,
+    `CREATE INDEX sync_aliases_local ON sync_aliases(kind,local_id)`,
+    `CREATE TABLE sync_plans (id TEXT PRIMARY KEY, digest TEXT NOT NULL, actor TEXT NOT NULL, body TEXT NOT NULL, result TEXT, created_at INTEGER NOT NULL)`,
+    ...tables.flatMap((table) =>
+      ["INSERT", "UPDATE", "DELETE"].map((op) => {
+        // Operational activity invalidates a plan without being copied into
+        // content history. Deleted content does not need permanent tombstones.
+        const operational = [
+          "bookings",
+          "form_submissions",
+          "sync_aliases",
+        ].includes(table);
+        const entity = `'${table}:' || ${op === "DELETE" ? "OLD" : "NEW"}.${table === "post_authors" ? "post_id" : "id"}`;
+        const version = operational
+          ? ""
+          : op === "DELETE" && table !== "post_authors"
+            ? `DELETE FROM sync_versions WHERE entity=${entity};`
+            : `INSERT INTO sync_versions(entity,revision) SELECT ${entity},revision FROM sync_state WHERE id=1 ON CONFLICT(entity) DO UPDATE SET revision=excluded.revision;`;
+        return `CREATE TRIGGER sync_${table}_${op.toLowerCase()} AFTER ${op} ON ${table} BEGIN UPDATE sync_state SET revision=revision+1 WHERE id=1; ${version} END`;
+      }),
+    ),
+    // Ignore cache counters and scheduler/integration bookkeeping.
+    `CREATE TRIGGER sync_settings_update AFTER UPDATE OF site_title,tagline,footer_text,timezone,locale,announcement,active_theme,design_overrides,section_pages,site_logo,site_logo_dark,site_favicon,site_cover,draft_design,calendar ON settings BEGIN UPDATE sync_state SET revision=revision+1 WHERE id=1; INSERT INTO sync_versions(entity,revision) SELECT 'settings:1',revision FROM sync_state WHERE id=1 ON CONFLICT(entity) DO UPDATE SET revision=excluded.revision; END`,
+  ],
+};

package/src/lib/sync/protocol.mjs

@@ -0,0 +1,125 @@
+// Shared, runtime-independent sync vocabulary. This module ships with the CLI.
+export const PROTOCOL = 1;
+export const TYPES = {
+  pages: "page",
+  posts: "post",
+  design: "design",
+  navigation: "nav",
+  media: "media",
+  redirects: "redirect",
+  calendars: "calendar",
+  events: "event",
+  resources: "resource",
+  forms: "form",
+  "booking-config": "booking",
+  "site-settings": "settings",
+  places: "place",
+  tags: "tag",
+};
+export const canonical = (value) => JSON.stringify(sort(value));
+function sort(value) {
+  if (Array.isArray(value)) return value.map(sort);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((k) => [k, sort(value[k])]),
+    );
+  return value;
+}
+export async function hash(value) {
+  const bytes =
+    typeof value === "string"
+      ? new TextEncoder().encode(value)
+      : value instanceof Uint8Array
+        ? value
+        : new TextEncoder().encode(canonical(value));
+  return Array.from(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)),
+    (b) => b.toString(16).padStart(2, "0"),
+  ).join("");
+}
+export function differences(before, after, path = "") {
+  if (canonical(before ?? null) === canonical(after ?? null)) return [];
+  if (
+    before &&
+    after &&
+    !Array.isArray(before) &&
+    !Array.isArray(after) &&
+    typeof before === "object" &&
+    typeof after === "object"
+  ) {
+    return [
+      ...new Set([...Object.keys(before), ...Object.keys(after)]),
+    ].flatMap((k) =>
+      differences(before[k], after[k], path ? `${path}.${k}` : k),
+    );
+  }
+  return [
+    { field: path || "(item)", before: before ?? null, after: after ?? null },
+  ];
+}
+export function matchEntity(source, destination) {
+  const identity = destination.filter(
+    (d) =>
+      d.kind === source.kind &&
+      d.aliases.some((a) => source.aliases.includes(a)),
+  );
+  if (identity.length > 1) return { ambiguous: true };
+  if (identity.length) return { entity: identity[0], linked: true };
+  const named = destination.filter(
+    (d) => d.kind === source.kind && d.match === source.match,
+  );
+  return named.length > 1
+    ? { ambiguous: true }
+    : { entity: named[0], linked: false };
+}
+export function classify(source, match, baseline, resolution) {
+  if (match.ambiguous)
+    return {
+      action: "conflict",
+      reason:
+        "Ambiguous destination match; resolve duplicate names on the destination.",
+    };
+  const target = match.entity;
+  if (resolution?.use === "destination")
+    return { action: "preserve", reason: "Keep destination" };
+  if (!target)
+    return baseline && resolution?.use !== "source"
+      ? {
+          action: "conflict",
+          reason: "Previously transferred item was deleted on the destination.",
+        }
+      : { action: "create", reason: "New item" };
+  if (source.hash === target.hash)
+    return { action: "skip", reason: "Unchanged" };
+  if (resolution?.use === "source" || resolution?.data)
+    return { action: "update", reason: "Explicitly resolved" };
+  if (!match.linked && !baseline)
+    return {
+      action: "conflict",
+      reason:
+        "First sync: confirm the existing destination item before linking it.",
+    };
+  if (!baseline)
+    return {
+      action: "conflict",
+      reason: "No baseline for this direction; review before overwriting.",
+    };
+  if (source.hash === baseline.source)
+    return { action: "preserve", reason: "Only destination changed" };
+  if (target.hash !== baseline.destination)
+    return { action: "conflict", reason: "Both environments changed" };
+  return { action: "update", reason: "Source changed" };
+}
+// References are explicit tokens, never guessed from titles on the receiving site.
+export const reference = (key) => `acms-sync:${key}`;
+export function transform(value, visit) {
+  if (typeof value === "string") return visit(value);
+  if (Array.isArray(value)) return value.map((v) => transform(v, visit));
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, transform(v, visit)]),
+    );
+  return value;
+}