@abraca/nuxt 0.1.0

package/dist/runtime/server/runners/doc-tree-cache.js

@@ -0,0 +1,65 @@
+import { initDocCache, observeDoc, unobserveDoc } from "../utils/docCache.js";
+import { getServerPlugins } from "../utils/serverRunner.js";
+export const docTreeCacheRunner = {
+  name: "abracadabra:doc-tree-cache",
+  async start(ctx) {
+    const { rootDoc, rootProvider, storage } = ctx;
+    const treeMap = rootDoc.getMap("doc-tree");
+    const loadedDocs = /* @__PURE__ */ new Map();
+    const pendingDocs = /* @__PURE__ */ new Set();
+    const serverExts = getServerPlugins().flatMap((p) => p.serverExtensions?.() ?? []);
+    initDocCache(storage, serverExts);
+    async function trackDoc(docId) {
+      if (loadedDocs.has(docId) || pendingDocs.has(docId)) return;
+      pendingDocs.add(docId);
+      try {
+        const childProv = await rootProvider.loadChild(docId);
+        if (!childProv.isSynced) {
+          await new Promise((resolve) => {
+            const done = () => {
+              childProv.off("synced", done);
+              resolve();
+            };
+            const tid = setTimeout(() => {
+              childProv.off("synced", done);
+              resolve();
+            }, 6e3);
+            childProv.on("synced", () => {
+              clearTimeout(tid);
+              done();
+            });
+          });
+        }
+        loadedDocs.set(docId, childProv);
+        observeDoc(docId, childProv.document);
+        console.log(`[abracadabra:doc-tree-cache] Tracking: ${docId}`);
+      } catch (e) {
+        console.warn(`[abracadabra:doc-tree-cache] Failed to load ${docId}:`, e);
+      } finally {
+        pendingDocs.delete(docId);
+      }
+    }
+    treeMap.forEach((_val, docId) => {
+      trackDoc(docId);
+    });
+    const observer = (event) => {
+      event.keysChanged.forEach((docId) => {
+        if (treeMap.has(docId)) {
+          trackDoc(docId);
+        } else {
+          unobserveDoc(docId);
+          loadedDocs.delete(docId);
+          console.log(`[abracadabra:doc-tree-cache] Untracked: ${docId}`);
+        }
+      });
+    };
+    treeMap.observe(observer);
+    return () => {
+      treeMap.unobserve(observer);
+      for (const [docId] of loadedDocs) {
+        unobserveDoc(docId);
+      }
+      loadedDocs.clear();
+    };
+  }
+};

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/server/utils/docCache.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Server-side document cache for abracadabra-nuxt.
+ *
+ * Maintains a live Y.Doc → HTML + JSON render cache backed by Nitro storage.
+ * Updates are debounced 2s after the last Y.Doc change to avoid thrashing.
+ *
+ * Used by the built-in doc-tree-cache server runner and by the SSR render route.
+ */
+import type { DocCacheAPI } from '../../../runtime/types.js';
+/**
+ * Initialize the cache with a Nitro storage handle and optional extra extensions.
+ * Must be called before observeDoc().
+ */
+export declare function initDocCache(storage: any, extraExtensions?: any[]): void;
+export declare function getCachedHTML(docId: string): Promise<string | null>;
+export declare function getCachedJSON(docId: string): Promise<any | null>;
+export declare function invalidateDoc(docId: string, ydoc?: any): Promise<void>;
+/**
+ * Start observing a Y.Doc for changes with debounced re-rendering.
+ * Renders immediately on first observe.
+ */
+export declare function observeDoc(docId: string, ydoc: any): void;
+export declare function unobserveDoc(docId: string): void;
+/** Build the DocCacheAPI object for the ServerRunnerContext. */
+export declare function createDocCacheAPI(rootDoc: any): DocCacheAPI;

package/dist/runtime/server/utils/docCache.js

@@ -0,0 +1,131 @@
+let _extensions = [];
+let _storage = null;
+const _renderTimers = /* @__PURE__ */ new Map();
+const _observedDocs = /* @__PURE__ */ new Map();
+const RENDER_DEBOUNCE_MS = 2e3;
+export function initDocCache(storage, extraExtensions = []) {
+  _storage = storage;
+  _extensions = extraExtensions;
+}
+async function renderDocToHTML(ydoc) {
+  try {
+    const [{ generateHTML }, { yDocToProsemirrorJSON }, { default: StarterKit }] = await Promise.all([
+      import("@tiptap/core"),
+      import("@tiptap/y-tiptap"),
+      import("@tiptap/starter-kit")
+    ]);
+    const json = yDocToProsemirrorJSON(ydoc, "default");
+    return generateHTML(json, [StarterKit, ..._extensions]);
+  } catch (e) {
+    console.warn("[abracadabra:doc-cache] HTML render failed:", e);
+    return "";
+  }
+}
+async function renderDocToJSON(ydoc) {
+  try {
+    const Y = await import("yjs");
+    const result = {};
+    ydoc.share.forEach((type, key) => {
+      if (type instanceof Y.Map) {
+        result[key] = type.toJSON();
+      } else if (type instanceof Y.Array) {
+        result[key] = type.toJSON();
+      }
+    });
+    return result;
+  } catch (e) {
+    console.warn("[abracadabra:doc-cache] JSON render failed:", e);
+    return null;
+  }
+}
+function htmlKey(docId) {
+  return `doc-cache:html:${docId}`;
+}
+function jsonKey(docId) {
+  return `doc-cache:json:${docId}`;
+}
+export async function getCachedHTML(docId) {
+  if (!_storage) return null;
+  return await _storage.getItem(htmlKey(docId)) ?? null;
+}
+export async function getCachedJSON(docId) {
+  if (!_storage) return null;
+  return await _storage.getItem(jsonKey(docId)) ?? null;
+}
+export async function invalidateDoc(docId, ydoc) {
+  if (!_storage) return;
+  const doc = ydoc ?? _observedDocs.get(docId)?.doc;
+  if (!doc) return;
+  const [html, json] = await Promise.all([
+    renderDocToHTML(doc),
+    renderDocToJSON(doc)
+  ]);
+  await Promise.all([
+    _storage.setItem(htmlKey(docId), html),
+    _storage.setItem(jsonKey(docId), json)
+  ]);
+}
+export function observeDoc(docId, ydoc) {
+  if (_observedDocs.has(docId)) return;
+  const handler = () => {
+    clearTimeout(_renderTimers.get(docId));
+    _renderTimers.set(docId, setTimeout(async () => {
+      await invalidateDoc(docId, ydoc);
+      _renderTimers.delete(docId);
+    }, RENDER_DEBOUNCE_MS));
+  };
+  ydoc.on("update", handler);
+  invalidateDoc(docId, ydoc);
+  _observedDocs.set(docId, {
+    doc: ydoc,
+    cleanup: () => {
+      ydoc.off("update", handler);
+      clearTimeout(_renderTimers.get(docId));
+      _renderTimers.delete(docId);
+    }
+  });
+}
+export function unobserveDoc(docId) {
+  const entry = _observedDocs.get(docId);
+  if (entry) {
+    entry.cleanup();
+    _observedDocs.delete(docId);
+  }
+}
+export function createDocCacheAPI(rootDoc) {
+  return {
+    getHTML: getCachedHTML,
+    getJSON: getCachedJSON,
+    invalidate: (docId) => invalidateDoc(docId),
+    getTree: () => buildCachedTree(rootDoc)
+  };
+}
+async function buildCachedTree(rootDoc) {
+  const treeMap = rootDoc.getMap("doc-tree");
+  const entries = treeMap.toJSON();
+  const nodeMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const [id, entry] of Object.entries(entries)) {
+    const [html, data] = await Promise.all([
+      getCachedHTML(id),
+      getCachedJSON(id)
+    ]);
+    nodeMap.set(id, {
+      id,
+      label: entry.label ?? "",
+      type: entry.type ?? "doc",
+      html,
+      data,
+      children: []
+    });
+  }
+  for (const [id, entry] of Object.entries(entries)) {
+    const node = nodeMap.get(id);
+    if (entry.parentId && nodeMap.has(entry.parentId)) {
+      nodeMap.get(entry.parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}

package/dist/runtime/server/utils/serverRunner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Server-side plugin runner registry for abracadabra-nuxt.
+ *
+ * Manages AbracadabraPlugin instances that declare `serverRunners`.
+ * Called by the Nitro service plugin after the root document syncs.
+ *
+ * Usage in consuming app's server/plugins/my-plugin.ts:
+ *   import { registerServerPlugin } from '#imports'  // auto-imported by module
+ *   export default defineNitroPlugin((nitroApp) => {
+ *     nitroApp.hooks.hook('abracadabra:before-runners', () => {
+ *       registerServerPlugin(myPlugin)
+ *     })
+ *   })
+ */
+import type { AbracadabraPlugin, ServerRunnerContext } from '../../types.js';
+/**
+ * Register a plugin that may declare serverRunners.
+ * Must be called before bootRunners() (e.g. inside the 'abracadabra:before-runners' hook).
+ */
+export declare function registerServerPlugin(plugin: AbracadabraPlugin): void;
+/** Returns the list of currently registered server plugins. */
+export declare function getServerPlugins(): readonly AbracadabraPlugin[];
+/** Boot all runners from all registered plugins. Called once after auth + sync. */
+export declare function bootRunners(ctx: ServerRunnerContext): Promise<void>;
+/** Stop a single runner by name and remove it from the registry. */
+export declare function stopRunner(name: string): Promise<void>;
+/** Shutdown all runners gracefully. Called on server close. */
+export declare function shutdownAllRunners(): Promise<void>;

package/dist/runtime/server/utils/serverRunner.js

@@ -0,0 +1,58 @@
+const _plugins = [];
+const _runners = /* @__PURE__ */ new Map();
+let _serverCtx = null;
+export function registerServerPlugin(plugin) {
+  if (_plugins.some((p) => p.name === plugin.name)) {
+    console.warn(`[abracadabra-service] Plugin "${plugin.name}" already registered`);
+    return;
+  }
+  _plugins.push(plugin);
+}
+export function getServerPlugins() {
+  return _plugins;
+}
+export async function bootRunners(ctx) {
+  _serverCtx = ctx;
+  for (const plugin of _plugins) {
+    for (const def of plugin.serverRunners ?? []) {
+      await _startRunner(def);
+    }
+  }
+}
+async function _startRunner(def) {
+  if (_runners.has(def.name)) {
+    console.warn(`[abracadabra-service] Runner "${def.name}" already running`);
+    return;
+  }
+  if (!_serverCtx) {
+    throw new Error("[abracadabra-service] Server context not initialized");
+  }
+  const state = { definition: def, cleanup: void 0, running: false };
+  _runners.set(def.name, state);
+  try {
+    console.log(`[abracadabra-service] Starting runner: ${def.name}`);
+    state.cleanup = await def.start(_serverCtx);
+    state.running = true;
+  } catch (err) {
+    console.error(`[abracadabra-service] Runner "${def.name}" failed to start:`, err);
+    _runners.delete(def.name);
+  }
+}
+export async function stopRunner(name) {
+  const state = _runners.get(name);
+  if (!state) return;
+  try {
+    if (typeof state.cleanup === "function") await state.cleanup();
+  } catch (err) {
+    console.error(`[abracadabra-service] Runner "${name}" cleanup failed:`, err);
+  }
+  _runners.delete(name);
+  console.log(`[abracadabra-service] Stopped runner: ${name}`);
+}
+export async function shutdownAllRunners() {
+  for (const [name] of _runners) {
+    await stopRunner(name);
+  }
+  _plugins.length = 0;
+  _serverCtx = null;
+}