@brightsideoy/kama 0.1.0-alpha.1 → 0.1.0-alpha.101

package/bin/cli.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as readline from 'node:readline/promises';
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+async function main() {
+    console.log('\n🔥 --- KAMA SITE GENERATOR --- 🔥\n');
+
+    console.log('Select mode:');
+    console.log('  1) Kickstart new Kama Monorepo (CMS + Initial Site)');
+    console.log('  2) Add a new Astro Site to current workspace (sites/)');
+
+    const choice = await rl.question('\nChoice [1/2]: ');
+
+    if (choice.trim() === '2') {
+        await createNewSiteOnly();
+    } else {
+        await createFullWorkspace();
+    }
+
+    rl.close();
+}
+
+/**
+ * MODE 1: Kickstart full Monorepo Workspace
+ */
+async function createFullWorkspace() {
+    const projName = (await rl.question('Project folder name [kama-workspace]: ')) || 'kama-workspace';
+    const cmsDomain = (await rl.question('CMS Admin Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
+    const siteDomain = (await rl.question('First Website Domain (e.g., kama.t3cloud.eu): ')) || 'kama.t3cloud.eu';
+
+    const rootDir = join(process.cwd(), projName);
+
+    // 🎯 Derive dynamic worker, database, and bucket names from project folder name
+    const workerName = `${projName}-worker`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+    let dbName = `${projName}-db`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const bucketName = `${projName}-media-prod`.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+
+    console.log(`\n📁 Creating workspace folder at ./${projName}...`);
+    mkdirSync(rootDir, { recursive: true });
+
+    // 🎯 Scaffold schemas directory for project-level custom YAML definitions
+    mkdirSync(join(rootDir, 'schemas', 'nodes'), { recursive: true });
+    mkdirSync(join(rootDir, 'schemas', 'blocks'), { recursive: true });
+
+    // --- AUTO D1 CREATION MAGIC ---
+    let d1DatabaseId = 'REPLACE_WITH_YOUR_D1_ID';
+    let isAuthenticated = false;
+
+    console.log(`\n🔑 Checking Cloudflare authentication...`);
+    try {
+        execSync('npx wrangler whoami', { stdio: 'pipe' });
+        isAuthenticated = true;
+        console.log(`✅ Logged in to Cloudflare.`);
+    } catch (error) {
+        console.log(`⚠️ You are not logged in to Cloudflare.`);
+        console.log(`🌐 Launching browser for Cloudflare login...`);
+        try {
+            execSync('npx wrangler login', { stdio: 'inherit' });
+            isAuthenticated = true;
+            console.log(`✅ Successfully logged in!`);
+        } catch (loginError) {
+            console.log(`❌ Login failed or was cancelled.`);
+        }
+    }
+
+    if (isAuthenticated) {
+        try {
+            console.log(`\n🗄️ Checking existing Cloudflare D1 databases...`);
+            const listOutput = execSync(`npx wrangler d1 list --json`, { encoding: 'utf-8', stdio: 'pipe' });
+
+            const jsonStart = listOutput.indexOf('[');
+            const jsonEnd = listOutput.lastIndexOf(']') + 1;
+            let databases = [];
+
+            if (jsonStart !== -1 && jsonEnd !== -1) {
+                databases = JSON.parse(listOutput.substring(jsonStart, jsonEnd));
+            }
+
+            const existingDb = databases.find(db => db.name === dbName);
+
+            if (existingDb) {
+                console.log(`⚠️ Database '${dbName}' already exists on your account.`);
+                const useExisting = await rl.question(`Do you want to link this existing database? (y/n) [y]: `);
+
+                if (useExisting.toLowerCase() !== 'n') {
+                    d1DatabaseId = existingDb.uuid;
+                    console.log(`✅ Linked existing database ID: ${d1DatabaseId}`);
+                } else {
+                    dbName = (await rl.question(`Enter a new database name: `)).trim();
+                    console.log(`\n🗄️ Creating new database '${dbName}'...`);
+                    const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: 'pipe' });
+                    const match = d1Output.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+                    if (match) {
+                        d1DatabaseId = match[0];
+                        console.log(`✅ Success! Database ID bound: ${d1DatabaseId}`);
+                    }
+                }
+            } else {
+                console.log(`\n🗄️ Attempting to auto-create Cloudflare D1 Database '${dbName}'...`);
+                const d1Output = execSync(`npx wrangler d1 create ${dbName}`, { encoding: 'utf-8', stdio: 'pipe' });
+                const match = d1Output.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+                if (match) {
+                    d1DatabaseId = match[0];
+                    console.log(`✅ Success! Database ID bound: ${d1DatabaseId}`);
+                }
+            }
+        } catch (error) {
+            console.log(`⚠️ Database operation failed. We'll leave a placeholder.`);
+        }
+    } else {
+        console.log(`⚠️ Skipping database creation. We'll leave a placeholder in wrangler.json.`);
+    }
+    // ------------------------------
+
+    // 🎯 1. Root package.json
+    writeFileSync(
+        join(rootDir, 'package.json'),
+        JSON.stringify({
+            name: projName,
+            private: true,
+            type: 'module',
+            workspaces: ['cms-worker', 'sites/*'],
+            scripts: {
+                'bundle:schemas': 'node node_modules/@brightsideoy/kama/scripts/bundle-definitions.js',
+                'dev:cms': 'npm run bundle:schemas && npm run dev -w cms-worker',
+                'deploy:cms': 'npm run bundle:schemas && npm run deploy -w cms-worker',
+            },
+            dependencies: {
+                '@brightsideoy/kama': 'alpha',
+            }
+        }, null, 2)
+    );
+
+    // 🎯 2. Setup CMS Worker with Dynamic Names
+    console.log(`\n☁️ Configuring CMS Worker '${workerName}' (${cmsDomain})...`);
+    const cmsDir = join(rootDir, 'cms-worker');
+    mkdirSync(cmsDir, { recursive: true });
+
+    writeFileSync(
+        join(cmsDir, 'index.js'),
+        `export { default } from '@brightsideoy/kama';\n`
+    );
+
+    writeFileSync(
+        join(cmsDir, 'package.json'),
+        JSON.stringify({
+            name: workerName,
+            type: 'module',
+            version: '1.0.0',
+            scripts: {
+                "bundle:schemas": "node ../node_modules/@brightsideoy/kama/scripts/bundle-definitions.js",
+                "schema:local": `npm run bundle:schemas && wrangler d1 execute ${dbName} --local --file=../node_modules/@brightsideoy/kama/schema.sql`,
+                "schema:remote": `npm run bundle:schemas && wrangler d1 execute ${dbName} --remote --file=../node_modules/@brightsideoy/kama/schema.sql`,
+                "dev": "npm run schema:local && wrangler dev",
+                "deploy": "npm run schema:remote && wrangler deploy"
+            },
+            dependencies: {
+                '@brightsideoy/kama': 'alpha',
+            },
+            devDependencies: {
+                wrangler: '^4.127.1',
+                tsx: '^4.19.2',
+            },
+        }, null, 2)
+    );
+
+    // 🎯 Fixed CMS wrangler.json (Added PUBLIC_FRONTEND_URL & CLOUDFLARE_ZONE_ID to public vars)
+    writeFileSync(
+        join(cmsDir, 'wrangler.json'),
+        JSON.stringify({
+            $schema: '../node_modules/wrangler/config-schema.json',
+            name: workerName,
+            main: 'index.js',
+            compatibility_date: '2026-08-01',
+            compatibility_flags: ['nodejs_compat'],
+            assets: {
+                directory: '../node_modules/@brightsideoy/kama/dist',
+                binding: 'ASSETS'
+            },
+            images: {
+                binding: 'IMAGES'
+            },
+            routes: [{ pattern: cmsDomain, custom_domain: true }],
+            vars: {
+                CDN_DOMAIN: cmsDomain,
+                PUBLIC_FRONTEND_URL: `https://${siteDomain}`,
+                CLOUDFLARE_ZONE_ID: "REPLACE_WITH_YOUR_32_CHAR_ZONE_ID"
+            },
+            d1_databases: [{
+                binding: 'DB',
+                database_name: dbName,
+                database_id: d1DatabaseId,
+            }],
+            r2_buckets: [{
+                binding: 'MEDIA_BUCKET',
+                bucket_name: bucketName,
+            }],
+        }, null, 2)
+    );
+
+    // 🎯 Fixed .dev.vars (Only contains API token for local dev, not public Zone ID)
+    writeFileSync(
+        join(cmsDir, '.dev.vars'),
+        `# Cloudflare Edge Cache Purging Secrets\nCLOUDFLARE_API_TOKEN=cfut_YOUR_CUSTOM_PURGE_TOKEN\n`
+    );
+
+    // 🎯 3. Setup First Astro Site tied to target workerName
+    const siteFolderName = siteDomain.split('.')[0];
+    await generateAstroSite(rootDir, siteFolderName, siteDomain, cmsDomain, workerName);
+
+    console.log(`\n✨ Workspace ready! Next steps:`);
+    console.log(`  1. cd ${projName}`);
+    console.log(`  2. npm install`);
+    if (d1DatabaseId === 'REPLACE_WITH_YOUR_D1_ID') {
+        console.log(`  3. Run 'npx wrangler login' and create a D1 database.`);
+    }
+    console.log(`  4. Update CLOUDFLARE_ZONE_ID in cms-worker/wrangler.json with your actual Zone ID`);
+    console.log(`  5. Securely store your purge token: cd cms-worker && npx wrangler secret put CLOUDFLARE_API_TOKEN`);
+    console.log(`  6. Run 'npm run dev:cms' from the workspace root to start the backend.`);
+}
+
+/**
+ * MODE 2: Add Site to existing workspace
+ */
+async function createNewSiteOnly() {
+    const rootDir = process.cwd();
+
+    if (!existsSync(join(rootDir, 'package.json'))) {
+        console.error('❌ Error: Must run this command inside the root of your workspace.');
+        return;
+    }
+
+    let targetWorkerName = 'kama-worker';
+    const cmsWranglerPath = join(rootDir, 'cms-worker', 'wrangler.json');
+    if (existsSync(cmsWranglerPath)) {
+        try {
+            const cmsWrangler = JSON.parse(readFileSync(cmsWranglerPath, 'utf-8'));
+            if (cmsWrangler.name) targetWorkerName = cmsWrangler.name;
+        } catch (e) { }
+    }
+
+    const siteFolder = await rl.question('Site folder name (e.g., my-new-site): ');
+    const siteDomain = await rl.question('Website Domain (e.g., brand.com): ');
+    const cmsDomain = (await rl.question('CMS API Domain (e.g., admin.t3cloud.eu): ')) || 'admin.t3cloud.eu';
+
+    await generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain.replace(/^https?:\/\//, ''), targetWorkerName);
+
+    console.log(`\n✨ Site created in sites/${siteFolder}! Run 'npm install' at workspace root.`);
+}
+
+/**
+ * Helper: Scaffolds the Astro site with middleware, wrangler.json, & slug page
+ */
+async function generateAstroSite(rootDir, siteFolder, siteDomain, cmsDomain, workerName = 'kama-worker') {
+    console.log(`\n🚀 Scaffolding Astro site (${siteFolder}) mapped to ${siteDomain} (Service: ${workerName})...`);
+
+    const siteDir = join(rootDir, 'sites', siteFolder);
+    mkdirSync(join(siteDir, 'src/pages'), { recursive: true });
+    mkdirSync(join(siteDir, 'src/layouts'), { recursive: true });
+    mkdirSync(join(siteDir, 'src/components/blocks'), { recursive: true });
+    mkdirSync(join(siteDir, 'src/lib'), { recursive: true });
+
+    writeFileSync(
+        join(siteDir, 'package.json'),
+        JSON.stringify({
+            name: siteFolder,
+            type: 'module',
+            version: '0.0.1',
+            engines: { node: '>=22.12.0' },
+            scripts: {
+                dev: 'astro dev',
+                build: 'astro build',
+                preview: 'astro preview',
+                deploy: 'astro build && wrangler deploy',
+            },
+            dependencies: {
+                '@astrojs/cloudflare': '^14.2.5',
+                '@brightsideoy/kama': 'alpha',
+                astro: '^7.2.2',
+                wrangler: '^4.127.1',
+            },
+        }, null, 2)
+    );
+
+    // 🎯 Fixed Astro wrangler.json: Added `run_worker_first: true` to prevent media routing 404s on Edge
+    writeFileSync(
+        join(siteDir, 'wrangler.json'),
+        JSON.stringify({
+            $schema: 'node_modules/wrangler/config-schema.json',
+            name: siteFolder,
+            compatibility_date: '2026-08-01',
+            compatibility_flags: ['nodejs_compat'],
+            assets: {
+                directory: './dist/client',
+                binding: 'ASSETS',
+                html_handling: 'drop-trailing-slash',
+                not_found_handling: '404-page',
+                run_worker_first: true
+            },
+            services: [{ binding: 'CMS_WORKER', service: workerName }],
+            routes: [{ pattern: siteDomain, custom_domain: true }],
+            vars: {
+                PUBLIC_CMS_URL: `https://${cmsDomain}`,
+                PUBLIC_API_URL: `https://${cmsDomain}`,
+            },
+        }, null, 2)
+    );
+
+    const astroConfig = `import { defineConfig } from 'astro/config';
+import cloudflare from '@astrojs/cloudflare';
+
+export default defineConfig({
+  output: 'server',
+  trailingSlash: 'ignore',
+  image: {
+    remotePatterns: [
+      { protocol: 'http', hostname: 'localhost', port: '3000' },
+      { protocol: 'https', hostname: '${cmsDomain}' }
+    ]
+  },
+  build: {
+    inlineStylesheets: 'always',
+  },
+  adapter: cloudflare({
+    imageService: 'cloudflare',
+  })
+});`;
+    writeFileSync(join(siteDir, 'astro.config.mjs'), astroConfig);
+
+    writeFileSync(
+        join(siteDir, '.env'),
+        `PUBLIC_CMS_URL="https://${cmsDomain}"\nPUBLIC_API_URL="https://${cmsDomain}"\n`
+    );
+}
+
+main().catch(console.error);

package/definitions/_page.yaml

@@ -0,0 +1,52 @@
+id: _page
+label: Page Old
+inTree: true
+inVault: true
+hasCanvas: true
+
+layout:
+  columns: "10fr 4fr"
+  areas:
+    - ["header", "header"]
+    - ["main", "sidebar"]
+    - ["footer", "footer"]
+
+regions:
+  header:
+    label: Header
+    inherit: parent
+  main:
+    label: Content
+  sidebar:
+    label: Sidebar
+  footer:
+    label: Footer
+    inherit: parent
+
+allowedBlocks:
+  - header
+  - hero
+  - text
+  - image_card
+
+# 👉 TABS DEFINITION
+tabs:
+  settings:
+    label: "Page"
+    fields:
+      # Imports core fields: title, slug, isHidden
+      - fieldSet: page-base
+
+      # Overrides & custom properties
+      - menuTitle:
+          label: Menu Title
+          type: text
+          dbType: text
+          public: true
+          placeholder: "Short title for navigation menus"
+
+      # SEO / OpenGraph metadata
+      - fieldSet: meta
+
+      # Role permissions & access control
+      - fieldSet: access

package/definitions/editor/button.ts

@@ -0,0 +1,11 @@
+import StarterKit from "@tiptap/starter-kit";
+import type { RteProfile } from "../../utils/rteProfiles";
+
+export const profile: RteProfile = {
+    toolbar: [
+        "bold",
+        "italic",
+        "superscript",
+        "subscript",
+    ],
+};

package/definitions/editor/default.ts

@@ -0,0 +1,21 @@
+import StarterKit from "@tiptap/starter-kit";
+import type { RteProfile } from "../../utils/rteProfiles";
+import Link from "../../src/utils/CmsLink";
+
+export const profile: RteProfile = {
+  extensions: [StarterKit, Link.configure({ openOnClick: false })],
+  toolbar: [
+    "heading-1",
+    "heading-2",
+    "heading-3",
+    "heading-4",
+    "bold",
+    "italic",
+    "bullet-list",
+    "ordered-list",
+    "blockquote",
+    "link",
+    "superscript",
+    "subscript",
+  ],
+};

package/definitions/editor/header.ts

@@ -0,0 +1,36 @@
+// definitions/editor/header.ts
+import StarterKit from "@tiptap/starter-kit";
+import Document from "@tiptap/extension-document";
+import Subscript from "@tiptap/extension-subscript";
+import Superscript from "@tiptap/extension-superscript";
+import type { RteProfile } from "../../src/utils/rteProfiles";
+import Link from "../../src/utils/CmsLink";
+
+// Custom document node forcing default top-level block to be a heading (H2)
+const CustomDocument = Document.extend({
+  content: "heading block*",
+});
+
+export const profile: RteProfile = {
+  extensions: [
+    CustomDocument,
+    StarterKit.configure({
+      document: false, // Replaces TipTap's default Document with CustomDocument
+      heading: { levels: [1, 2, 3, 4] },
+    }),
+    Subscript.configure(),
+    Superscript.configure(),
+    Link.configure({ openOnClick: false }),
+  ],
+  toolbar: [
+    "heading-1",
+    "heading-2",
+    "heading-3",
+    "heading-4",
+    "bold",
+    "italic",
+    "superscript",
+    "subscript",
+    "link",
+  ],
+};

package/definitions/editor/minimal.ts

@@ -0,0 +1,15 @@
+import StarterKit from "@tiptap/starter-kit";
+import type { RteProfile } from "../../utils/rteProfiles";
+import Link from "../../src/utils/CmsLink";
+
+export const profile: RteProfile = {
+  extensions: [StarterKit, Link.configure({ openOnClick: false })],
+  toolbar: [
+    "bold",
+    "italic",
+    "bullet-list",
+    "ordered-list",
+    "superscript",
+    "subscript",
+  ],
+};

package/definitions/validators/iban.ts

@@ -0,0 +1,12 @@
+// definitions/validators/iban.ts
+
+export const iban = (value: any, ruleValue: any, field: any) => {
+  if (!value || !ruleValue) return "";
+  
+  const isValid = /^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(String(value).toUpperCase());
+  if (!isValid) {
+    return field.rules?.customMessage || "Invalid IBAN format.";
+  }
+  
+  return "";
+};

package/definitions/validators/magic-word.ts

@@ -0,0 +1,7 @@
+// definitions/validators/test.ts
+export const isMagicWord = (value: any, ruleValue: any, field: any) => {
+  if (value && value.toLowerCase() !== "magic") {
+    return field.rules?.customMessage || "You didn't say the magic word!";
+  }
+  return "";
+};