@brightsideoy/kama 0.1.0-alpha.16 → 0.1.0-alpha.161

package/templates/astro-starter/src/utils/tiptap.ts

@@ -0,0 +1,113 @@
+// src/utils/tiptap.ts
+
+export interface TiptapNode {
+    type: string;
+    text?: string;
+    attrs?: Record<string, any>;
+    marks?: Array<{ type: string; attrs?: Record<string, any> }>;
+    content?: TiptapNode[];
+}
+
+/**
+ * Traverses a ProseMirror / Tiptap AST node and converts it into HTML.
+ */
+export function renderTiptapNode(node?: TiptapNode | null): string {
+    if (!node) return "";
+    if (typeof node === "string") return node;
+
+    // 1. Text Node Handling (with Marks)
+    if (node.type === "text") {
+        let text = escapeHtml(node.text || "");
+        if (node.marks && Array.isArray(node.marks)) {
+            node.marks.forEach((mark) => {
+                switch (mark.type) {
+                    case "bold":
+                    case "strong":
+                        text = `<strong>${text}</strong>`;
+                        break;
+                    case "italic":
+                    case "em":
+                        text = `<em>${text}</em>`;
+                        break;
+                    case "underline":
+                        text = `<u>${text}</u>`;
+                        break;
+                    case "strike":
+                        text = `<s>${text}</s>`;
+                        break;
+                    case "code":
+                        text = `<code>${text}</code>`;
+                        break;
+                    case "link": {
+                        const href = mark.attrs?.href ? escapeHtml(mark.attrs.href) : "#";
+                        const target = mark.attrs?.target ? ` target="${escapeHtml(mark.attrs.target)}"` : "";
+                        const rel = mark.attrs?.target === "_blank" ? ' rel="noopener noreferrer"' : "";
+                        text = `<a href="${href}"${target}${rel}>${text}</a>`;
+                        break;
+                    }
+                }
+            });
+        }
+        return text;
+    }
+
+    // 2. Traversal of Child Nodes
+    const childrenHtml = Array.isArray(node.content)
+        ? node.content.map(renderTiptapNode).join("")
+        : "";
+
+    // 3. Block Level Mapping
+    switch (node.type) {
+        case "doc":
+            return childrenHtml;
+        case "paragraph":
+            return childrenHtml.trim() ? `<p>${childrenHtml}</p>` : "";
+        case "heading": {
+            const level = Math.min(Math.max(node.attrs?.level || 2, 1), 6);
+            return `<h${level}>${childrenHtml}</h${level}>`;
+        }
+        case "bulletList":
+            return `<ul>${childrenHtml}</ul>`;
+        case "orderedList": {
+            const start = node.attrs?.start ? ` start="${node.attrs.start}"` : "";
+            return `<ol${start}>${childrenHtml}</ol>`;
+        }
+        case "listItem":
+            return `<li>${childrenHtml}</li>`;
+        case "blockquote":
+            return `<blockquote>${childrenHtml}</blockquote>`;
+        case "codeBlock": {
+            const lang = node.attrs?.language ? ` class="language-${escapeHtml(node.attrs.language)}"` : "";
+            return `<pre><code${lang}>${childrenHtml}</code></pre>`;
+        }
+        case "horizontalRule":
+            return "<hr />";
+        case "hardBreak":
+            return "<br />";
+        default:
+            return childrenHtml;
+    }
+}
+
+/**
+ * Universal helper that handles plain strings, legacy objects, and Tiptap ASTs safely.
+ */
+export function extractHtml(value: any): string {
+    if (!value) return "";
+    if (typeof value === "string") return value; // Already HTML/string
+    if (typeof value === "object") {
+        if (value.type === "doc") return renderTiptapNode(value);
+        if (value.html) return value.html;
+        if (value.markup) return value.markup;
+    }
+    return String(value);
+}
+
+function escapeHtml(str: string): string {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}

package/templates/kama-worker/index.js

@@ -0,0 +1,19 @@
+import kamaWorker from '@brightsideoy/kama';
+import * as localBundle from './bundled-definitions.js';
+
+export default {
+  async fetch(request, env, ctx) {
+    const schemas = localBundle.BUNDLED_DEFINITIONS || localBundle.default || localBundle;
+    const customEnv = { ...env, BUNDLED_DEFINITIONS: schemas, KAMA_RUNTIME: 'cloudflare' };
+
+    if (kamaWorker && typeof kamaWorker.fetch === 'function') {
+      return kamaWorker.fetch(request, customEnv, ctx);
+    }
+    
+    if (kamaWorker && kamaWorker.app && typeof kamaWorker.app.fetch === 'function') {
+      return kamaWorker.app.fetch(request, customEnv, ctx);
+    }
+    
+    return new Response('Kama Engine Worker Ready', { status: 200 });
+  }
+};

package/templates/kama-worker/server.js

@@ -0,0 +1,98 @@
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import kamaApp from '@brightsideoy/kama';
+import * as localBundle from './bundled-definitions.js';
+import dotenv from 'dotenv';
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+dotenv.config();
+
+const possiblePaths = [
+    './node_modules/@brightsideoy/kama/dist',
+    '../node_modules/@brightsideoy/kama/dist',
+    '../../node_modules/@brightsideoy/kama/dist'
+];
+const distPath = possiblePaths.find(p => existsSync(p));
+
+if (!distPath) {
+    console.warn('⚠️ Could not locate @brightsideoy/kama/dist folder. Admin UI will not load.');
+}
+
+const app = new Hono();
+
+let cachedSchemas = localBundle.BUNDLED_DEFINITIONS || localBundle.default || localBundle;
+let lastModified = 0;
+
+async function getCustomEnv(c) {
+    try {
+        const bundlePath = join(process.cwd(), 'bundled-definitions.js');
+        if (existsSync(bundlePath)) {
+            const mtime = statSync(bundlePath).mtimeMs;
+            if (mtime > lastModified) {
+                if (lastModified !== 0) console.log('🔄 Hot-reloading fresh schema definitions!');
+                const mod = await import(`${pathToFileURL(bundlePath).href}?t=${mtime}`);
+                cachedSchemas = mod.BUNDLED_DEFINITIONS || mod.default || mod;
+                lastModified = mtime;
+            }
+        }
+    } catch (err) { }
+
+    return {
+        ...process.env,
+        ...(c.env || {}),
+        BUNDLED_DEFINITIONS: cachedSchemas,
+        KAMA_RUNTIME: (c.env && c.env.DB) ? 'cloudflare' : 'node'
+    };
+}
+
+app.use('/media/*', serveStatic({ root: './' }));
+if (distPath) {
+    app.use('/assets/*', serveStatic({ root: distPath }));
+}
+
+function resolveExecutionContext(c) {
+    try {
+        if (c.executionCtx) return c.executionCtx;
+    } catch (e) { }
+    return {
+        waitUntil: (promise) => Promise.resolve(promise).catch(console.error),
+        passThroughOnException: () => { }
+    };
+}
+
+app.all('*', async (c) => {
+    const customEnv = await getCustomEnv(c);
+    const execCtx = resolveExecutionContext(c);
+
+    let response;
+    if (typeof kamaApp.fetch === 'function') {
+        response = await kamaApp.fetch(c.req.raw, customEnv, execCtx);
+    } else if (kamaApp.app && typeof kamaApp.app.fetch === 'function') {
+        response = await kamaApp.app.fetch(c.req.raw, customEnv, execCtx);
+    } else {
+        return c.text("Engine not configured correctly", 500);
+    }
+
+    if (response.status === 404 && distPath && !c.req.path.startsWith('/api')) {
+        const indexPath = join(distPath, 'index.html');
+        if (existsSync(indexPath)) {
+            return c.html(readFileSync(indexPath, 'utf-8'));
+        }
+    }
+
+    return response;
+});
+
+export default app;
+
+if (typeof process !== 'undefined' && process.argv && process.argv[1] && process.argv[1].endsWith('server.js')) {
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 8787;
+    serve({ fetch: app.fetch, port }, (info) => {
+        console.log(`\n🔥 KAMA CMS Node Server is running!`);
+        console.log(`┃ Local    http://localhost:${info.port}/`);
+        if (distPath) console.log(`┃ Admin UI Serving from: ${distPath}\n`);
+    });
+}

package/wrangler.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "kama",
+  "main": "server/index.ts",
+  "compatibility_date": "2024-09-23",
+  "compatibility_flags": [
+    "nodejs_compat"
+  ],
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "kama-db",
+      "database_id": "local-kama-db"
+    }
+  ],
+  "r2_buckets": [
+    {
+      "binding": "MEDIA_BUCKET",
+      "bucket_name": "kama-media"
+    }
+  ]
+}