@batterai/strapi-plugin-canvas 0.1.0

package/src/server/content-types/canvas-page/schema.ts

@@ -0,0 +1,20 @@
+export default {
+  kind: "collectionType",
+  collectionName: "canvas_plugin_pages",
+  info: {
+    singularName: "canvas-page",
+    pluralName: "canvas-pages",
+    displayName: "Canvas page",
+  },
+  options: { draftAndPublish: false },
+  pluginOptions: {
+    "content-manager": { visible: false },
+    "content-type-builder": { visible: false },
+  },
+  attributes: {
+    pageKey: { type: "string", required: true, unique: true, configurable: false },
+    docVersion: { type: "integer", required: true, default: 0, configurable: false },
+    latestVersion: { type: "string", configurable: false },
+    document: { type: "json", required: true, configurable: false },
+  },
+} as const;

package/src/server/content-types/canvas-site/schema.ts

@@ -0,0 +1,19 @@
+export default {
+  kind: "collectionType",
+  collectionName: "canvas_plugin_sites",
+  info: {
+    singularName: "canvas-site",
+    pluralName: "canvas-sites",
+    displayName: "Canvas site",
+  },
+  options: { draftAndPublish: false },
+  pluginOptions: {
+    "content-manager": { visible: false },
+    "content-type-builder": { visible: false },
+  },
+  attributes: {
+    siteKey: { type: "string", required: true, unique: true, configurable: false },
+    docVersion: { type: "integer", required: true, default: 0, configurable: false },
+    document: { type: "json", required: true, configurable: false },
+  },
+} as const;

package/src/server/content-types/index.ts

@@ -0,0 +1,7 @@
+import canvasPage from "./canvas-page/schema";
+import canvasSite from "./canvas-site/schema";
+
+export default {
+  "canvas-page": { schema: canvasPage },
+  "canvas-site": { schema: canvasSite },
+};

package/src/server/controllers/canvas.ts

@@ -0,0 +1,468 @@
+import type {
+  CanvasPage,
+  EditorShellBootstrap,
+  EditorShellContent,
+  EditorShellRoute,
+  EditorShellSharedBlock,
+  EditorShellSiteMetadata,
+  EditorShellTranslations,
+} from "@batterai/editor-shell";
+import { parseCanvasDocument, type CanvasDocument, type CanvasHostResult, type HostPageState } from "@batterai/contract";
+import { CANVAS_PAGE_PREFIX, canvasPageKey } from "../../constants";
+import { evaluateStrapiCanvasLicense } from "../license";
+import { strapiCanvasConcurrency } from "../services/document-command-service";
+import { CanvasPageValidationError } from "../services/page-doc-store";
+import {
+  defaultHomePage,
+  defaultSiteDocument,
+  normalizeLibrary,
+  type CanvasSiteDocument,
+} from "../services/site-store";
+
+type KoaContext = {
+  params: Record<string, string | undefined>;
+  query: Record<string, unknown>;
+  get?: (name: string) => string;
+  request: {
+    body?: unknown;
+    files?: unknown;
+    header?: Record<string, string | string[] | undefined>;
+    headers?: Record<string, string | string[] | undefined>;
+  };
+  body?: unknown;
+  status?: number;
+  state?: { user?: { id: string | number; firstname?: string; lastname?: string; username?: string } };
+  badRequest?: (message: string) => void;
+};
+
+function pluginService(strapi: any, serviceName: string) {
+  return strapi.plugin("canvas").service(serviceName);
+}
+
+function bodyRecord(ctx: KoaContext): Record<string, unknown> {
+  const body = ctx.request.body;
+  return body && typeof body === "object" && !Array.isArray(body) ? body as Record<string, unknown> : {};
+}
+
+function sitePages(site: CanvasSiteDocument, rows: Array<{ document?: { page?: CanvasPage }; docVersion?: number }>) {
+  const byId = new Map<string, CanvasPage>();
+  const pageVersions: Record<string, number> = {};
+  for (const row of rows) {
+    const page = row.document?.page;
+    if (!page?.id) continue;
+    byId.set(page.id, page);
+    pageVersions[page.id] = row.docVersion ?? 0;
+  }
+  if (!byId.size) {
+    const home = defaultHomePage();
+    byId.set(home.id, home);
+    pageVersions[home.id] = 0;
+  }
+  const ordered = site.pageOrder.map((id) => byId.get(id)).filter(Boolean) as CanvasPage[];
+  const orderedIds = new Set(ordered.map((page) => page.id));
+  const extras = [...byId.values()].filter((page) => !orderedIds.has(page.id));
+  return { pages: [...ordered, ...extras], pageVersions };
+}
+
+function canvasDocument(pages: readonly CanvasPage[], site: CanvasSiteDocument): CanvasDocument {
+  const canvas = site.canvas ?? defaultSiteDocument().canvas;
+  return {
+    schemaVersion: 1,
+    pages,
+    ...canvas,
+    layout: canvas.layout ?? { pageOrder: pages.map((page) => page.id as never) },
+  };
+}
+
+type PageRow = {
+  docVersion?: number;
+  document?: {
+    page?: CanvasPage;
+    updatedAt?: string;
+    staged?: { page?: CanvasPage; stagedAt?: string; sourceDocVersion?: number };
+    published?: { page?: CanvasPage; publishedAt?: string; sourceDocVersion?: number };
+  };
+};
+
+function hostPageStates(rows: PageRow[], pages: readonly CanvasPage[]): Record<string, HostPageState> {
+  const rowsById = new Map(rows.flatMap((row) => row.document?.page?.id ? [[row.document.page.id, row] as const] : []));
+  return Object.fromEntries(pages.map((page) => {
+    const row = rowsById.get(page.id);
+    const published = row?.document?.published;
+    const staged = row?.document?.staged;
+    const draftDiffersFromPublished = Boolean(published?.page && JSON.stringify(page) !== JSON.stringify(published.page));
+    const draftDiffersFromStaged = Boolean(staged?.page && JSON.stringify(page) !== JSON.stringify(staged.page));
+    const workflowLabel = staged
+      ? (draftDiffersFromStaged ? "Staged · newer draft changes" : "Staged")
+      : published
+        ? (draftDiffersFromPublished ? "Draft changes" : undefined)
+        : "Not published";
+    return [page.id, {
+      publication: published ? "published" as const : "draft" as const,
+      hasPublishedVersion: Boolean(published),
+      hasStagedVersion: Boolean(staged),
+      draftDiffersFromPublished,
+      draftDiffersFromStaged,
+      ...(workflowLabel ? { workflowLabel } : {}),
+      ...(published?.publishedAt ? { lastSavedLabel: published.publishedAt } : {}),
+    }];
+  }));
+}
+
+async function pageRows(strapi: any) {
+  const rows = await strapi.entityService.findMany("plugin::canvas.canvas-page", { limit: 1000 });
+  return rows.filter((row: { pageKey?: unknown }) =>
+    typeof row.pageKey === "string" && row.pageKey.startsWith(CANVAS_PAGE_PREFIX)
+  );
+}
+
+function applyContentPatch(content: EditorShellContent, patch: Partial<EditorShellContent>): EditorShellContent {
+  return {
+    ...content,
+    ...patch,
+    media: patch.media ?? content.media ?? [],
+    routes: patch.routes ?? content.routes ?? [],
+    sharedBlocks: patch.sharedBlocks ?? content.sharedBlocks ?? [],
+    siteMetadata: patch.siteMetadata ?? content.siteMetadata ?? {},
+    translations: patch.translations ?? content.translations ?? {},
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function publishedSiteSnapshot(site: CanvasSiteDocument): CanvasSiteDocument["published"] | undefined {
+  const snapshot = site.published;
+  if (!snapshot || !isRecord(snapshot.content) || !isRecord(snapshot.library)) return undefined;
+  if (typeof snapshot.publishedAt !== "string" || !Number.isInteger(snapshot.sourceDocVersion)) return undefined;
+  const parsed = parseCanvasDocument(snapshot.document);
+  if (!parsed.ok) return undefined;
+  return { ...snapshot, document: parsed.document };
+}
+
+function emptyPublicDelivery(site: CanvasSiteDocument) {
+  const defaults = defaultSiteDocument();
+  return {
+    content: { ...defaults.content, routes: [] },
+    library: defaults.library,
+    document: {
+      ...canvasDocument([], defaults),
+      layout: { pageOrder: [] },
+    },
+    status: {
+      ...site.status,
+      connected: true,
+      lastSyncedAt: new Date().toISOString(),
+      runtimeModel: "strapi-public-delivery",
+      source: "plugin::canvas.delivery",
+    },
+  };
+}
+
+function commandResponse(ctx: KoaContext, result: CanvasHostResult<unknown>): void {
+  if (!result.ok) {
+    ctx.status = result.error.kind === "conflict" ? 409
+      : result.error.kind === "validation" ? 400
+        : result.error.kind === "forbidden" ? 403
+          : result.error.kind === "not-found" ? 404
+            : result.error.kind === "unsupported" ? 501
+              : 503;
+  }
+  ctx.body = result;
+}
+
+export default ({ strapi }: { strapi: any }) => ({
+  async collabToken(ctx: KoaContext) {
+    const service = pluginService(strapi, "collaboration");
+    if (!service) {
+      ctx.status = 404;
+      ctx.body = { error: "Collaboration is not enabled." };
+      return;
+    }
+    const user = ctx.state?.user;
+    if (!user) {
+      ctx.status = 401;
+      ctx.body = { error: "Authenticated Strapi admin required." };
+      return;
+    }
+    ctx.body = service.mintToken(user);
+  },
+
+  async collab(ctx: KoaContext) {
+    const service = pluginService(strapi, "collaboration");
+    if (!service) {
+      ctx.status = 404;
+      ctx.body = { error: "Collaboration is not enabled." };
+      return;
+    }
+    const action = ctx.params.action;
+    if (!action) throw new CanvasPageValidationError("Collaboration action is required.");
+    const body = bodyRecord(ctx);
+    const user = ctx.state?.user;
+    if (!user) {
+      ctx.status = 401;
+      ctx.body = { error: "Authenticated Strapi admin required." };
+      return;
+    }
+    try {
+      if (action === "hello") {
+        if (typeof body.token !== "string" || typeof body.pageId !== "string") throw new CanvasPageValidationError("Collaboration hello is malformed.");
+        service.assertTokenOwner(body.token, user.id);
+        await service.ensurePage(body.pageId);
+      } else if (typeof body.sessionId === "string") {
+        service.assertSessionOwner(body.sessionId, user.id);
+      }
+    } catch (error) {
+      if (error instanceof CanvasPageValidationError) throw error;
+      ctx.status = 403;
+      ctx.body = { error: error instanceof Error ? error.message : "Collaboration access denied." };
+      return;
+    }
+    const originHeader = ctx.request.headers?.origin ?? ctx.request.header?.origin;
+    const origin = Array.isArray(originHeader)
+      ? originHeader[0]
+      : originHeader ?? (typeof body.__canvasOrigin === "string" ? body.__canvasOrigin : undefined);
+    const response = await service.handler(new Request(`http://canvas.local/collab/${encodeURIComponent(action)}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(origin ? { origin } : {}),
+      },
+      body: JSON.stringify(body),
+    }));
+    if (!response) {
+      ctx.status = 404;
+      ctx.body = { error: "Unknown collaboration action." };
+      return;
+    }
+    ctx.status = response.status;
+    ctx.body = await response.json();
+    if (action === "hello" && (ctx.body as any)?.ok && (ctx.body as any)?.welcome?.sessionId) {
+      service.claimSession((ctx.body as any).welcome.sessionId, user.id);
+    }
+  },
+
+  async collabAudit(ctx: KoaContext) {
+    const service = pluginService(strapi, "collaboration");
+    if (!service) {
+      ctx.status = 404;
+      ctx.body = { error: "Collaboration is not enabled." };
+      return;
+    }
+    const canvasPageId = ctx.params.pageId;
+    if (!canvasPageId) throw new CanvasPageValidationError("Audit page id is required.");
+    ctx.body = { events: await service.readAudit(canvasPageId) };
+  },
+
+  async delivery(ctx: KoaContext) {
+    const site = await pluginService(strapi, "siteStore").readOrCreate();
+    const published = publishedSiteSnapshot(site);
+    if (!published) {
+      ctx.body = emptyPublicDelivery(site);
+      return;
+    }
+    const documentService = pluginService(strapi, "documentService");
+    const config = strapi.config.get("plugin::canvas") ?? {};
+    const boundContent: Record<string, unknown[]> = {};
+    for (const collection of documentService.collectionNames?.() ?? Object.keys(config.boundCollections ?? {})) {
+      boundContent[collection] = await documentService.listCollection(collection, { status: "published" });
+    }
+    ctx.body = {
+      content: applyContentPatch(published.content, boundContent),
+      library: published.library,
+      document: published.document,
+      status: {
+        ...site.status,
+        connected: true,
+        lastSyncedAt: new Date().toISOString(),
+        runtimeModel: "strapi-public-delivery",
+        source: "plugin::canvas.delivery",
+      },
+    };
+  },
+
+  async bootstrap(ctx: KoaContext) {
+    const site = await pluginService(strapi, "siteStore").readOrCreate();
+    const rows = await pageRows(strapi);
+    const { pages, pageVersions } = sitePages(site, rows);
+    const collaboration = pluginService(strapi, "collaboration");
+    if (collaboration) {
+      await Promise.all(pages.map((page) => collaboration.ensurePage(page.id)));
+    }
+    const documentService = pluginService(strapi, "documentService");
+    const config = strapi.config.get("plugin::canvas") ?? {};
+    const configuredLibrary = normalizeLibrary(config.seedLibrary);
+    const license = await evaluateStrapiCanvasLicense(config, ctx);
+    const boundContent: Record<string, unknown[]> = {};
+    for (const collection of documentService.collectionNames?.() ?? Object.keys(config.boundCollections ?? {})) {
+      boundContent[collection] = await documentService.listCollection(collection);
+    }
+    ctx.body = {
+      content: applyContentPatch(site.content, boundContent),
+      contentTypes: documentService.listContentTypes?.() ?? site.contentTypes,
+      library: configuredLibrary ?? site.library,
+      document: canvasDocument(pages, site),
+      pageStates: hostPageStates(rows, pages),
+      capabilities: {
+        canSave: true,
+        canPublish: true,
+        supportsPageStaging: true,
+        canUploadAssets: false,
+        canEditRoutes: true,
+        supportsPreview: true,
+        supportsAtomicMultiPageSave: true,
+      },
+      documentConcurrency: strapiCanvasConcurrency(site.docVersion),
+      pageVersions,
+      status: {
+        ...site.status,
+        connected: true,
+        license,
+        lastSyncedAt: new Date().toISOString(),
+      },
+    } satisfies EditorShellBootstrap & { pageVersions: Record<string, number> };
+  },
+
+  async findPage(ctx: KoaContext) {
+    const pageId = ctx.params.pageId;
+    if (!pageId) throw new CanvasPageValidationError("pageId is required.");
+    const row = await pluginService(strapi, "pageDocStore").read(canvasPageKey(pageId));
+    ctx.body = row?.document ?? null;
+  },
+
+  async findPageRevision(ctx: KoaContext) {
+    const pageId = ctx.params.pageId;
+    const revision = ctx.params.revision;
+    if (!pageId) throw new CanvasPageValidationError("pageId is required.");
+    if (revision !== "draft" && revision !== "staged" && revision !== "published") {
+      throw new CanvasPageValidationError("revision must be draft, staged, or published.");
+    }
+    const row = await pluginService(strapi, "pageDocStore").read(canvasPageKey(pageId));
+    const page = revision === "draft" ? row?.document?.page
+      : revision === "staged" ? row?.document?.staged?.page
+        : row?.document?.published?.page;
+    if (!page) {
+      ctx.status = 404;
+      ctx.body = { ok: false, error: { kind: "not-found" } };
+      return;
+    }
+    const createdAt = revision === "draft" ? row?.document?.updatedAt
+      : revision === "staged" ? row?.document?.staged?.stagedAt
+        : row?.document?.published?.publishedAt;
+    ctx.body = { ok: true, value: { kind: revision, page, ...(createdAt ? { createdAt } : {}) } };
+  },
+
+  async saveDocument(ctx: KoaContext) {
+    const result = await pluginService(strapi, "documentCommand").saveDocument(bodyRecord(ctx));
+    commandResponse(ctx, result);
+  },
+
+  async publishDocument(ctx: KoaContext) {
+    const result = await pluginService(strapi, "documentCommand").publishDocument(bodyRecord(ctx));
+    commandResponse(ctx, result);
+  },
+
+  async stagePage(ctx: KoaContext) {
+    const result = await pluginService(strapi, "documentCommand").stagePage({
+      ...bodyRecord(ctx),
+      pageId: ctx.params.pageId,
+    });
+    commandResponse(ctx, result);
+  },
+
+  async unstagePage(ctx: KoaContext) {
+    const result = await pluginService(strapi, "documentCommand").unstagePage({
+      ...bodyRecord(ctx),
+      pageId: ctx.params.pageId,
+    });
+    commandResponse(ctx, result);
+  },
+
+  async saveContent(ctx: KoaContext) {
+    const collection = ctx.params.collection;
+    if (!collection) throw new CanvasPageValidationError("collection is required.");
+    const items = bodyRecord(ctx).items;
+    if (!Array.isArray(items)) throw new CanvasPageValidationError("items must be an array.");
+    await pluginService(strapi, "documentService").saveCollection(collection, items);
+    ctx.body = { saved: true };
+  },
+
+  async listMedia(ctx: KoaContext) {
+    ctx.body = { items: [], nextCursor: undefined };
+  },
+
+  async uploadMedia(ctx: KoaContext) {
+    throw new CanvasPageValidationError("Canvas media upload is not configured for this Strapi plugin instance.");
+  },
+
+  async saveMedia(ctx: KoaContext) {
+    const media = bodyRecord(ctx).media;
+    await updateSite(strapi, (site) => ({
+      ...site,
+      docVersion: site.docVersion + 1,
+      content: applyContentPatch(site.content, { media: Array.isArray(media) ? media as never : [] }),
+    }));
+    ctx.body = { saved: true };
+  },
+
+  async saveRoutes(ctx: KoaContext) {
+    const routes = bodyRecord(ctx).routes;
+    await updateSite(strapi, (site) => ({
+      ...site,
+      docVersion: site.docVersion + 1,
+      content: applyContentPatch(site.content, { routes: Array.isArray(routes) ? routes as EditorShellRoute[] : [] }),
+    }));
+    ctx.body = { saved: true };
+  },
+
+  async saveSharedBlocks(ctx: KoaContext) {
+    const sharedBlocks = bodyRecord(ctx).sharedBlocks;
+    await updateSite(strapi, (site) => ({
+      ...site,
+      docVersion: site.docVersion + 1,
+      content: applyContentPatch(site.content, {
+        sharedBlocks: Array.isArray(sharedBlocks) ? sharedBlocks as EditorShellSharedBlock[] : [],
+      }),
+    }));
+    ctx.body = { saved: true };
+  },
+
+  async saveTranslations(ctx: KoaContext) {
+    const translations = bodyRecord(ctx).translations;
+    await updateSite(strapi, (site) => ({
+      ...site,
+      docVersion: site.docVersion + 1,
+      content: applyContentPatch(site.content, {
+        translations: translations && typeof translations === "object"
+          ? translations as EditorShellTranslations
+          : {},
+      }),
+    }));
+    ctx.body = { saved: true };
+  },
+
+  async saveSiteMetadata(ctx: KoaContext) {
+    const siteMetadata = bodyRecord(ctx).siteMetadata;
+    await updateSite(strapi, (site) => ({
+      ...site,
+      docVersion: site.docVersion + 1,
+      content: applyContentPatch(site.content, {
+        siteMetadata: siteMetadata && typeof siteMetadata === "object"
+          ? siteMetadata as EditorShellSiteMetadata
+          : {},
+      }),
+    }));
+    ctx.body = { saved: true };
+  },
+
+  async savePreset(ctx: KoaContext) {
+    const preset = bodyRecord(ctx).preset;
+    const site = await pluginService(strapi, "siteStore").readOrCreate();
+    ctx.body = { library: site.library, preset };
+  },
+});
+
+async function updateSite(strapi: any, mutator: (site: CanvasSiteDocument) => CanvasSiteDocument) {
+  await pluginService(strapi, "siteStore").update(mutator);
+}

package/src/server/controllers/index.ts

@@ -0,0 +1,5 @@
+import canvas from "./canvas";
+
+export default {
+  canvas,
+};

package/src/server/index.ts

@@ -0,0 +1,21 @@
+import config from "./config";
+import bootstrap from "./bootstrap";
+import register from "./register";
+import contentTypes from "./content-types";
+import controllers from "./controllers";
+import policies from "./policies/is-admin-authenticated";
+import routes from "./routes";
+import services from "./services";
+
+export default () => ({
+  register,
+  bootstrap,
+  config,
+  routes,
+  controllers,
+  contentTypes,
+  policies: {
+    "is-admin-authenticated": policies,
+  },
+  services,
+});

package/src/server/license.ts

@@ -0,0 +1,42 @@
+import {
+  evaluateBatteraiAuthoringLicense,
+  type LicenseEvaluation,
+} from "@batterai/trust";
+
+export type CanvasLicenseConfig = {
+  licenseKey?: string;
+};
+
+export type CanvasLicenseContext = {
+  get?: (name: string) => string;
+  request?: {
+    header?: Record<string, string | string[] | undefined>;
+    headers?: Record<string, string | string[] | undefined>;
+  };
+};
+
+export async function evaluateStrapiCanvasLicense(
+  config: CanvasLicenseConfig,
+  ctx: CanvasLicenseContext,
+): Promise<LicenseEvaluation> {
+  return evaluateBatteraiAuthoringLicense({
+    hostname: requestHostname(ctx),
+    licenseKey: config.licenseKey,
+  });
+}
+
+function requestHostname(ctx: CanvasLicenseContext): string {
+  const forwarded = headerValue(ctx, "x-forwarded-host");
+  const host = forwarded?.split(",")[0]?.trim() || headerValue(ctx, "host");
+  return host ?? "";
+}
+
+function headerValue(ctx: CanvasLicenseContext, name: string): string | undefined {
+  const fromGetter = ctx.get?.(name);
+  if (fromGetter) return fromGetter;
+  const lower = name.toLowerCase();
+  const headers = ctx.request?.headers ?? ctx.request?.header ?? {};
+  const value = headers[lower] ?? headers[name];
+  if (Array.isArray(value)) return value[0];
+  return value;
+}

package/src/server/policies/is-admin-authenticated.ts

@@ -0,0 +1,3 @@
+export default function isAdminAuthenticated(policyContext: any) {
+  return Boolean(policyContext?.state?.user);
+}

package/src/server/register.ts

@@ -0,0 +1,3 @@
+export default function register() {
+  // Strapi loads plugin content-types from the exported contentTypes map.
+}

package/src/server/routes/admin.ts

@@ -0,0 +1,40 @@
+import { CANVAS_PERMISSIONS } from "../../constants";
+
+function permissions(actions: readonly string[]) {
+  return [
+    "admin::isAuthenticatedAdmin",
+    {
+      name: "admin::hasPermissions",
+      config: { actions },
+    },
+  ];
+}
+
+const read = permissions([CANVAS_PERMISSIONS.access]);
+const write = permissions([CANVAS_PERMISSIONS.write]);
+const audit = permissions([CANVAS_PERMISSIONS.audit]);
+
+export default {
+  type: "admin",
+  routes: [
+    { method: "GET", path: "/bootstrap", handler: "canvas.bootstrap", config: { policies: read } },
+    { method: "POST", path: "/collab-token", handler: "canvas.collabToken", config: { policies: write } },
+    { method: "POST", path: "/collab/:action", handler: "canvas.collab", config: { policies: write } },
+    { method: "GET", path: "/collab-audit/:pageId", handler: "canvas.collabAudit", config: { policies: audit } },
+    { method: "GET", path: "/pages/:pageId", handler: "canvas.findPage", config: { policies: read } },
+    { method: "GET", path: "/pages/:pageId/revisions/:revision", handler: "canvas.findPageRevision", config: { policies: read } },
+    { method: "POST", path: "/pages/:pageId/stage", handler: "canvas.stagePage", config: { policies: write } },
+    { method: "POST", path: "/pages/:pageId/unstage", handler: "canvas.unstagePage", config: { policies: write } },
+    { method: "PUT", path: "/document", handler: "canvas.saveDocument", config: { policies: write } },
+    { method: "POST", path: "/document/publish", handler: "canvas.publishDocument", config: { policies: write } },
+    { method: "PUT", path: "/content/:collection", handler: "canvas.saveContent", config: { policies: write } },
+    { method: "GET", path: "/media", handler: "canvas.listMedia", config: { policies: read } },
+    { method: "POST", path: "/media", handler: "canvas.uploadMedia", config: { policies: write } },
+    { method: "PUT", path: "/media", handler: "canvas.saveMedia", config: { policies: write } },
+    { method: "PUT", path: "/routes", handler: "canvas.saveRoutes", config: { policies: write } },
+    { method: "PUT", path: "/shared-blocks", handler: "canvas.saveSharedBlocks", config: { policies: write } },
+    { method: "PUT", path: "/translations", handler: "canvas.saveTranslations", config: { policies: write } },
+    { method: "PUT", path: "/site-metadata", handler: "canvas.saveSiteMetadata", config: { policies: write } },
+    { method: "POST", path: "/presets", handler: "canvas.savePreset", config: { policies: write } },
+  ],
+};

package/src/server/routes/index.ts

@@ -0,0 +1,7 @@
+import admin from "./admin";
+import publicRoutes from "./public";
+
+export default {
+  admin,
+  "content-api": publicRoutes,
+};

package/src/server/routes/public.ts

@@ -0,0 +1,6 @@
+export default {
+  type: "content-api",
+  routes: [
+    { method: "GET", path: "/delivery", handler: "canvas.delivery", config: { auth: false } },
+  ],
+};