@brightsideoy/kama 0.1.0-alpha.37 → 0.1.0-alpha.40

package/scripts/bundle-definitions.js

@@ -0,0 +1,176 @@
+// scripts/bundle-definitions.js
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 🎯 Package root is one directory up from scripts/
+const packageRootDir = path.resolve(__dirname, '..');
+
+// Look for definitions across package core AND consumer project overrides
+function getDefinitionFiles(subDir) {
+    const fileMap = new Map();
+
+    const possibleDirs = [
+        // 1. Core package defaults (from inside node_modules or package source)
+        path.resolve(packageRootDir, "defaults/definitions", subDir),
+        path.resolve(packageRootDir, "definitions", subDir),
+
+        // 2. Fallbacks relative to node_modules if running from workspace root
+        path.resolve(process.cwd(), "node_modules/@brightsideoy/kama/defaults/definitions", subDir),
+        path.resolve(process.cwd(), "node_modules/@brightsideoy/kama/definitions", subDir),
+
+        // 3. Consumer project local overrides (highest priority — overwrites defaults)
+        path.resolve(process.cwd(), "defaults/definitions", subDir),
+        path.resolve(process.cwd(), "definitions", subDir),
+        path.resolve(process.cwd(), "schemas", subDir),
+        path.resolve(process.cwd(), "server/schemas", subDir),
+    ];
+
+    for (const dirPath of possibleDirs) {
+        if (!fs.existsSync(dirPath)) continue;
+
+        const walkDir = (currentDir, relativePath = "") => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryRelPath = path.join(relativePath, entry.name);
+                const fullPath = path.join(currentDir, entry.name);
+
+                if (entry.isDirectory()) {
+                    walkDir(fullPath, entryRelPath);
+                } else if (
+                    entry.name.endsWith(".yaml") ||
+                    entry.name.endsWith(".yml") ||
+                    entry.name.endsWith(".json")
+                ) {
+                    // Overwrite earlier entries so local consumer files override package defaults
+                    fileMap.set(entryRelPath, fullPath);
+                }
+            }
+        };
+
+        walkDir(dirPath);
+    }
+
+    return Array.from(fileMap.entries()).map(([fileName, filePath]) => ({ fileName, filePath }));
+}
+
+function parseFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return filePath.endsWith('.json') ? JSON.parse(content) : YAML.parse(content);
+}
+
+function loadDir(...subDirs) {
+    const res = {};
+    for (const subDir of subDirs) {
+        const files = getDefinitionFiles(subDir);
+        for (const { fileName, filePath } of files) {
+            const key = path.basename(fileName, path.extname(fileName));
+            try {
+                res[key] = parseFile(filePath);
+            } catch (e) {
+                console.warn(`Failed to parse ${filePath}:`, e);
+            }
+        }
+    }
+    return res;
+}
+
+function loadSingle(subDirAndFile) {
+    const files = getDefinitionFiles(path.dirname(subDirAndFile));
+    const targetBase = path.basename(subDirAndFile);
+    const matched = files.find(
+        f => path.basename(f.fileName) === targetBase ||
+            path.basename(f.fileName) === targetBase.replace(/\.yaml$/, '.yml') ||
+            path.basename(f.fileName) === targetBase.replace(/\.yaml$/, '.json')
+    );
+    if (!matched) return null;
+    try {
+        return parseFile(matched.filePath);
+    } catch (e) {
+        return null;
+    }
+}
+
+// 🎯 MAP DEFINITIONS
+const rawBlocks = loadDir("blocks", "elements");
+const rawBlockLayouts = loadDir("block-layouts");
+const rawNodeLayouts = loadDir("node-layouts", "layouts");
+
+const bundled = {
+    rawNodes: loadDir("nodes"),
+    rawTrees: loadDir("trees"),
+    rawChannels: loadDir("channels"),
+    rawBlocks,
+    rawElements: rawBlocks,
+    rawBlockLayouts,
+    rawNodeLayouts,
+    rawLayouts: { ...rawNodeLayouts, ...rawBlockLayouts },
+    rawFieldSets: loadDir("field-sets"),
+    rawTemplates: loadDir("templates"),
+    nodeTemplate: loadSingle("templates/node.yaml") || { fields: {} },
+    treeTemplate: loadSingle("templates/tree.yaml") || { fields: {} },
+    channelTemplate: loadSingle("channels/channel.yaml") || loadSingle("templates/channel.yaml") || { fields: {} },
+    userTemplate: loadSingle("users/user.yaml") || loadSingle("templates/user.yaml") || { fields: {} },
+};
+
+const outputContent = `// Auto-generated pre-bundled definitions for Kama Core Engine
+export const BUNDLED_DEFINITIONS = ${JSON.stringify(bundled, null, 2)};
+`;
+
+// 🎯 Write to BOTH package dist/server locations so imports resolve cleanly
+const targetDirs = [
+    path.resolve(packageRootDir, 'server/db'),
+    path.resolve(process.cwd(), 'node_modules/@brightsideoy/kama/server/db'),
+    path.resolve(process.cwd(), 'node_modules/@brightsideoy/kama/dist'),
+    path.resolve(process.cwd(), 'server/db'),
+];
+
+for (const dir of targetDirs) {
+    if (fs.existsSync(dir)) {
+        const outputPath = path.resolve(dir, 'bundled-definitions.ts');
+        fs.writeFileSync(outputPath, outputContent, 'utf-8');
+        // Also write .js version for built packages
+        const jsOutputPath = path.resolve(dir, 'bundled-definitions.js');
+        fs.writeFileSync(jsOutputPath, `export const BUNDLED_DEFINITIONS = ${JSON.stringify(bundled, null, 2)};\n`, 'utf-8');
+    }
+}
+
+console.log(`✅ Definitions bundled successfully:
+  • Nodes: ${Object.keys(bundled.rawNodes).length} (${Object.keys(bundled.rawNodes).join(', ')})
+  • Blocks: ${Object.keys(bundled.rawBlocks).length} (${Object.keys(bundled.rawBlocks).join(', ')})
+  • Channels: ${Object.keys(bundled.rawChannels).length} (${Object.keys(bundled.rawChannels).join(', ')})
+  • Trees: ${Object.keys(bundled.rawTrees).length} (${Object.keys(bundled.rawTrees).join(', ')})`);
+
+// Auto-generate SQL Indexes
+const indexQueries = new Set([
+    "-- Native Columns",
+    "CREATE INDEX IF NOT EXISTS idx_content_nodes_slug ON content_nodes (slug);",
+    "CREATE INDEX IF NOT EXISTS idx_content_nodes_contentType ON content_nodes (contentType);",
+    "CREATE INDEX IF NOT EXISTS idx_content_nodes_updatedAt ON content_nodes (updatedAt);\n",
+    "-- JSON Custom Fields"
+]);
+
+function extractIndexes(obj) {
+    if (typeof obj !== 'object' || obj === null) return;
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'object' && value !== null) {
+            if (value.index === true && key !== "id" && key !== "slug" && key !== "contentType") {
+                indexQueries.add(`CREATE INDEX IF NOT EXISTS idx_content_nodes_${key} ON content_nodes (json_extract(dataJson, '$.${key}'));`);
+            }
+            extractIndexes(value);
+        }
+    }
+}
+
+extractIndexes(bundled.rawNodes);
+
+const sqlContent = Array.from(indexQueries).join('\n');
+const schemaSqlPath = path.resolve(process.cwd(), 'schema.sql');
+
+if (fs.existsSync(schemaSqlPath)) {
+    fs.appendFileSync(schemaSqlPath, '\n\n' + sqlContent + '\n', 'utf-8');
+}