@brightsideoy/kama 0.1.0-alpha.36 → 0.1.0-alpha.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brightsideoy/kama",
-  "version": "0.1.0-alpha.36",
+  "version": "0.1.0-alpha.39",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,16 +17,18 @@
   "files": [
     "dist",
     "bin",
+    "scripts",
     "schema.sql"
   ],
   "scripts": {
     "dev": "concurrently \"vite\" \"tsx watch server/dev.ts\"",
-    "build:server": "vite build",
+    "bundle:definitions": "node scripts/bundle-definitions.js",
+    "build:schema": "tsx src/db/generate-schema.ts",
+    "build:server": "npm run bundle:definitions && vite build",
     "build:ui": "vite build --config vite.config.ui.ts",
-    "build": "npm run build:server && npm run build:ui",
+    "build": "npm run build:schema && npm run build:server && npm run build:ui",
     "build:cms": "npm run build",
-    "build:schema": "tsx src/db/generate-schema.ts",
-    "prepublishOnly": "npm run build:schema && npm run build",
+    "prepublishOnly": "npm run build",
     "db:seed": "npm run build:schema && tsx -e \"import Database from 'better-sqlite3'; import fs from 'node:fs'; const db = new Database('data/cms.db'); db.exec(fs.readFileSync('schema.sql', 'utf8')); console.log('✅ Database schema applied successfully!');\"",
     "d1:schema:remote": "npm run build:schema && npx wrangler d1 execute YOUR_D1_NAME --remote --file=./schema.sql",
     "serve": "tsx server/dev.ts"

package/schema.sql

@@ -1,6 +1,16 @@
 -- Kama Core System Schema 
 -- Auto-generated from server/db/dynamic-sync.ts
 
+CREATE TABLE IF NOT EXISTS "content_schemas" (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT UNIQUE NOT NULL,
+    schemaJson TEXT NOT NULL,
+    isSystem INTEGER DEFAULT 1,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP
+  );
+
 CREATE TABLE IF NOT EXISTS "users" (
     id TEXT PRIMARY KEY,
     email TEXT UNIQUE NOT NULL,
@@ -166,6 +176,7 @@ CREATE TABLE IF NOT EXISTS "node_assets" (
     FOREIGN KEY (assetId) REFERENCES assets(id) ON DELETE CASCADE
   );
 
+CREATE INDEX IF NOT EXISTS idx_content_schemas_type ON content_schemas(type);
 CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(userId);
 CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expiresAt);
 CREATE INDEX IF NOT EXISTS idx_channels_visibility ON channels(isHidden);
@@ -191,3 +202,14 @@ CREATE INDEX IF NOT EXISTS idx_assets_parent ON assets(parentAssetId);
 INSERT OR IGNORE INTO channels (id, key, label, channelType, defaultLanguage, isHidden, dataJson) VALUES (1, 'default-channel', 'Default Channel', 'website', 'en', 0, '{}');
 INSERT OR IGNORE INTO trees (id, key, label, treeType, channelId, isHidden, dataJson) VALUES (1, 'default-tree', 'Default Navigation', 'navigation', 1, 0, '{}');
 INSERT OR IGNORE INTO channel_trees (channelId, treeId, key) VALUES (1, 1, 'main');
+
+
+-- 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);
+
+-- JSON Custom Fields
+CREATE INDEX IF NOT EXISTS idx_content_nodes_articleDate ON content_nodes (json_extract(dataJson, '$.articleDate'));
+CREATE INDEX IF NOT EXISTS idx_content_nodes_startTime ON content_nodes (json_extract(dataJson, '$.startTime'));
+CREATE INDEX IF NOT EXISTS idx_content_nodes_endTime ON content_nodes (json_extract(dataJson, '$.endTime'));

package/scripts/bundle-definitions.js

@@ -0,0 +1,152 @@
+// scripts/bundle-definitions.js
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+
+// Look for definitions across package core folders
+function getDefinitionFiles(subDir) {
+    const fileMap = new Map();
+    const possibleDirs = [
+        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")
+                ) {
+                    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)};
+`;
+
+const outputDir = path.resolve(process.cwd(), 'server/db');
+if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+}
+
+const outputPath = path.resolve(outputDir, 'bundled-definitions.ts');
+fs.writeFileSync(outputPath, outputContent, 'utf-8');
+
+console.log(`✅ Definitions bundled successfully into Kama Core:
+  • Nodes: ${Object.keys(bundled.rawNodes).length} (${Object.keys(bundled.rawNodes).join(', ')})
+  • Blocks: ${Object.keys(bundled.rawBlocks).length}
+  • Channels: ${Object.keys(bundled.rawChannels).length}
+  ↳ Saved into ${outputPath}`);
+
+// ==========================================
+// AUTO-GENERATE SQL INDEXES FROM SCHEMA
+// ==========================================
+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');
+    console.log(`✅ Appended JSON auto-indexes directly to schema.sql`);
+}