@batterai/strapi-plugin-canvas 0.1.0

package/src/server/services/site-store.ts

@@ -0,0 +1,243 @@
+import { randomUUID } from "node:crypto";
+import type { BlockLibrary, CanvasPage, EditorShellBootstrap, EditorShellContent } from "@batterai/editor-shell";
+import { BATTERY_THEME_DEFAULT_TOKENS, type CanvasDocument } from "@batterai/contract";
+import { CANVAS_SITE_UID, DEFAULT_SITE_KEY } from "../../constants";
+import type { CanvasPluginConfig } from "../config";
+
+export type CanvasSiteDocument = {
+  kind: "canvas-editor-site";
+  docVersion: number;
+  content: EditorShellContent;
+  contentTypes: EditorShellBootstrap["contentTypes"];
+  library: BlockLibrary;
+  pageOrder: string[];
+  canvas: Pick<CanvasDocument, "theme" | "assets" | "variables" | "layout">;
+  published?: {
+    document: CanvasDocument;
+    content: EditorShellContent;
+    library: BlockLibrary;
+    publishedAt: string;
+    sourceDocVersion: number;
+  };
+  status: EditorShellBootstrap["status"];
+};
+
+export class CanvasSiteConflict extends Error {
+  readonly status = 409;
+
+  constructor(
+    readonly expectedDocVersion: number,
+    readonly actualDocVersion: number,
+  ) {
+    super(`Canvas site conflict: expected ${expectedDocVersion}, got ${actualDocVersion}`);
+    this.name = "CanvasSiteConflict";
+  }
+}
+
+export function emptyLibrary(): BlockLibrary {
+  return { categories: [], blocks: [], presets: [], sharedBlocks: [] };
+}
+
+/**
+ * Normalizes a host-supplied `seedLibrary` plugin config value into a
+ * `BlockLibrary`, filling any missing keys with empty arrays. Returns
+ * `undefined` when no seed was configured so callers can fall back to
+ * `emptyLibrary()`.
+ */
+export function normalizeLibrary(seed?: CanvasPluginConfig["seedLibrary"]): BlockLibrary | undefined {
+  if (!seed || typeof seed !== "object" || Array.isArray(seed)) return undefined;
+  return {
+    categories: Array.isArray(seed.categories) ? (seed.categories as BlockLibrary["categories"]) : [],
+    blocks: Array.isArray(seed.blocks) ? (seed.blocks as BlockLibrary["blocks"]) : [],
+    presets: Array.isArray(seed.presets) ? (seed.presets as BlockLibrary["presets"]) : [],
+    sharedBlocks: [],
+  };
+}
+
+export function defaultHomePage(_now = new Date()): CanvasPage {
+  return {
+    id: "home",
+    title: "Home",
+    path: "/",
+    parentId: null,
+    root: [],
+  };
+}
+
+export function defaultSiteDocument(now = new Date()): CanvasSiteDocument {
+  return {
+    kind: "canvas-editor-site",
+    docVersion: 1,
+    content: {
+      media: [],
+      routes: [{ id: "home", label: "Home", path: "/" }],
+      sharedBlocks: [],
+      siteMetadata: { title: "Strapi site" },
+      translations: {},
+    },
+    contentTypes: [],
+    library: emptyLibrary(),
+    pageOrder: ["home"],
+    canvas: {
+      theme: { tokens: BATTERY_THEME_DEFAULT_TOKENS },
+      assets: [],
+      variables: {},
+      layout: { pageOrder: ["home" as never] },
+    },
+    status: {
+      adapter: "strapi",
+      connected: true,
+      product: "Canvas",
+      runtimeModel: "strapi-admin-plugin",
+      source: "plugin::canvas.canvas-site",
+      version: "0.1.0",
+      lastSyncedAt: now.toISOString(),
+    },
+  };
+}
+
+export function createSiteStore(
+  strapi: any,
+  seedLibrary?: CanvasPluginConfig["seedLibrary"],
+  transaction?: ((tableName: string) => any),
+) {
+  const query = () => strapi.documents?.("plugin::canvas.canvas-site") ?? strapi.entityService;
+  const metadata = transaction ? strapi.db.metadata.get(CANVAS_SITE_UID) : undefined;
+  const tableName = metadata?.tableName;
+  const columns = metadata ? {
+    documentId: columnName(metadata, "documentId", "document_id"),
+    siteKey: columnName(metadata, "siteKey", "site_key"),
+    docVersion: columnName(metadata, "docVersion", "doc_version"),
+    document: columnName(metadata, "document", "document"),
+    createdAt: columnName(metadata, "createdAt", "created_at"),
+    updatedAt: columnName(metadata, "updatedAt", "updated_at"),
+  } : undefined;
+
+  function table() {
+    if (!transaction || !tableName) throw new Error("Canvas site aggregate writes require a Strapi transaction.");
+    return transaction(tableName);
+  }
+
+  async function transactionalRow() {
+    return table().where({ [columns!.siteKey]: DEFAULT_SITE_KEY }).first();
+  }
+
+  return {
+    async readOrCreate(): Promise<CanvasSiteDocument> {
+      if (transaction) {
+        const existing = await transactionalRow();
+        if (existing?.[columns!.document]) return normalizeSiteDocument(parseJson(existing[columns!.document]));
+        const document: CanvasSiteDocument = {
+          ...defaultSiteDocument(),
+          library: normalizeLibrary(seedLibrary) ?? emptyLibrary(),
+        };
+        const timestamp = new Date().toISOString();
+        await table().insert({
+          [columns!.documentId]: randomUUID(),
+          [columns!.siteKey]: DEFAULT_SITE_KEY,
+          [columns!.docVersion]: document.docVersion,
+          [columns!.document]: JSON.stringify(document),
+          [columns!.createdAt]: timestamp,
+          [columns!.updatedAt]: timestamp,
+        });
+        return document;
+      }
+      const rows = await strapi.entityService.findMany("plugin::canvas.canvas-site", {
+        filters: { siteKey: { $eq: DEFAULT_SITE_KEY } },
+        limit: 1,
+      });
+      const existing = rows[0];
+      if (existing?.document) return normalizeSiteDocument(existing.document);
+      const document: CanvasSiteDocument = {
+        ...defaultSiteDocument(),
+        library: normalizeLibrary(seedLibrary) ?? emptyLibrary(),
+      };
+      await query().create?.({
+        data: {
+          siteKey: DEFAULT_SITE_KEY,
+          docVersion: document.docVersion,
+          document,
+        },
+      });
+      return document;
+    },
+    async update(mutator: (document: CanvasSiteDocument) => CanvasSiteDocument): Promise<CanvasSiteDocument> {
+      const rows = await strapi.entityService.findMany("plugin::canvas.canvas-site", {
+        filters: { siteKey: { $eq: DEFAULT_SITE_KEY } },
+        limit: 1,
+      });
+      const existing = rows[0];
+      const next = mutator(normalizeSiteDocument(existing?.document));
+      if (existing?.documentId) {
+        await query().update?.({
+          documentId: existing.documentId,
+          data: { docVersion: next.docVersion, document: next },
+        });
+      }
+      return next;
+    },
+    async updateIfVersion(
+      expectedDocVersion: number,
+      mutator: (document: CanvasSiteDocument) => CanvasSiteDocument,
+    ): Promise<CanvasSiteDocument> {
+      const existing = await transactionalRow();
+      const current = normalizeSiteDocument(parseJson(existing?.[columns!.document]));
+      const actualDocVersion = Number(existing?.[columns!.docVersion] ?? current.docVersion);
+      if (!existing || actualDocVersion !== expectedDocVersion) {
+        throw new CanvasSiteConflict(expectedDocVersion, actualDocVersion);
+      }
+      const next = mutator(current);
+      if (next.docVersion !== expectedDocVersion + 1) {
+        throw new Error("Canvas site aggregate mutation must increment docVersion exactly once.");
+      }
+      const affected = await table()
+        .where({
+          [columns!.siteKey]: DEFAULT_SITE_KEY,
+          [columns!.docVersion]: expectedDocVersion,
+        })
+        .update({
+          [columns!.docVersion]: next.docVersion,
+          [columns!.document]: JSON.stringify(next),
+          [columns!.updatedAt]: new Date().toISOString(),
+        });
+      if (Number(affected) !== 1) {
+        const latest = await transactionalRow();
+        throw new CanvasSiteConflict(expectedDocVersion, Number(latest?.[columns!.docVersion] ?? actualDocVersion));
+      }
+      return next;
+    },
+  };
+}
+
+export function normalizeSiteDocument(document: unknown): CanvasSiteDocument {
+  if (!document || typeof document !== "object" || Array.isArray(document)) return defaultSiteDocument();
+  const candidate = document as Partial<CanvasSiteDocument>;
+  return {
+    ...defaultSiteDocument(),
+    ...candidate,
+    content: {
+      ...defaultSiteDocument().content,
+      ...(candidate.content ?? {}),
+    },
+    library: candidate.library ?? emptyLibrary(),
+    canvas: {
+      ...defaultSiteDocument().canvas,
+      ...(candidate.canvas ?? {}),
+    },
+    pageOrder: Array.isArray(candidate.pageOrder) ? candidate.pageOrder.filter(Boolean) : ["home"],
+    docVersion: Number.isInteger(candidate.docVersion) && candidate.docVersion! > 0 ? candidate.docVersion! : 1,
+  };
+}
+
+function columnName(metadata: any, attribute: string, fallback: string): string {
+  return metadata?.attributes?.[attribute]?.columnName ?? fallback;
+}
+
+function parseJson(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}