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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brightsideoy/kama",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.100",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -10,23 +10,37 @@
       "import": "./dist/index.js"
     }
   },
+  "bin": {
+    "kama": "bin/cli.js",
+    "create-kama": "bin/cli.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "defaults",
+    "definitions",
+    "bin",
+    "scripts",
+    "schema.sql"
   ],
   "scripts": {
-    "dev": "concurrently \"vite\" \"tsx watch server/index.ts\"",
-    "build": "vite build",
-    "build:cms": "vue-tsc -p tsconfig.build.json || true && vite build",
-    "build:seed-sql": "tsx src/db/generate-sql.ts",
-    "db:seed": "npm run build:seed-sql && tsx -e \"import Database from 'better-sqlite3'; import fs from 'node:fs'; const db = new Database('data/cms.db'); db.exec(fs.readFileSync('seed.sql', 'utf8')); console.log('✅ Database seeded successfully!');\"",
-    "d1:seed:remote": "npm run build:seed-sql && npx wrangler d1 execute YOUR_D1_NAME --remote --file=./seed.sql",
-    "serve": "tsx server/index.ts",
-    "prepublishOnly": "npm run build:cms"
+    "predev": "npm run build:schema && npm run bundle:definitions",
+    "dev": "concurrently \"vite\" \"tsx watch server/dev.ts\"",
+    "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:schema && npm run build:server && npm run build:ui",
+    "build:cms": "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"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@brightsideoy/kama": "^0.1.0-alpha.47",
     "@heroicons/vue": "^2.2.0",
     "@hono/node-server": "^2.1.1",
     "@tiptap/core": "^3.30.0",
@@ -67,4 +81,4 @@
     "vite": "^8.2.1",
     "vue-tsc": "^2.2.0"
   }
-}
+}

package/schema.sql

@@ -0,0 +1,221 @@
+-- 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,
+    name TEXT NOT NULL,
+    globalRole TEXT DEFAULT 'editor',
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP
+  );
+
+CREATE TABLE IF NOT EXISTS "user_accounts" (
+    id TEXT PRIMARY KEY,
+    userId TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    providerAccountId TEXT NOT NULL,
+    passwordHash TEXT NOT NULL,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE,
+    UNIQUE(provider, providerAccountId)
+  );
+
+CREATE TABLE IF NOT EXISTS "sessions" (
+    id TEXT PRIMARY KEY,
+    userId TEXT NOT NULL,
+    expiresAt TEXT NOT NULL,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
+  );
+
+CREATE TABLE IF NOT EXISTS "channels" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    key TEXT UNIQUE NOT NULL,
+    label TEXT NOT NULL,
+    channelType TEXT,
+    domain TEXT,
+    baseUrl TEXT,
+    defaultLanguage TEXT DEFAULT 'en',
+    isHidden INTEGER NOT NULL DEFAULT 0,
+    dataJson TEXT,
+    createdById TEXT,
+    updatedById TEXT,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (createdById) REFERENCES users(id) ON DELETE SET NULL,
+    FOREIGN KEY (updatedById) REFERENCES users(id) ON DELETE SET NULL
+  );
+
+CREATE TABLE IF NOT EXISTS "trees" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    key TEXT UNIQUE NOT NULL,
+    label TEXT NOT NULL,
+    treeType TEXT,
+    channelId INTEGER,
+    isHidden INTEGER NOT NULL DEFAULT 0,
+    dataJson TEXT,
+    createdById TEXT,
+    updatedById TEXT,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (channelId) REFERENCES channels(id) ON DELETE SET NULL,
+    FOREIGN KEY (createdById) REFERENCES users(id) ON DELETE SET NULL,
+    FOREIGN KEY (updatedById) REFERENCES users(id) ON DELETE SET NULL
+  );
+
+CREATE TABLE IF NOT EXISTS "channel_trees" (
+    channelId INTEGER NOT NULL,
+    treeId INTEGER NOT NULL,
+    key TEXT NOT NULL DEFAULT 'main',
+    metaJson TEXT,
+    PRIMARY KEY (channelId, treeId, key),
+    FOREIGN KEY (channelId) REFERENCES channels(id) ON DELETE CASCADE,
+    FOREIGN KEY (treeId) REFERENCES trees(id) ON DELETE CASCADE
+  );
+
+CREATE TABLE IF NOT EXISTS "content_nodes" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    contentType TEXT NOT NULL,
+    title TEXT NOT NULL,
+    slug TEXT,
+    language TEXT DEFAULT 'en',
+    isHidden INTEGER NOT NULL DEFAULT 0,
+    status TEXT DEFAULT 'draft',
+    disabledRegionsJson TEXT DEFAULT '{}',
+    dataJson TEXT,
+    draftDataJson TEXT,
+    publishedDataJson TEXT,
+    publishedAt TEXT,
+    createdById TEXT,
+    updatedById TEXT,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    deletedAt TEXT,
+    FOREIGN KEY (createdById) REFERENCES users(id) ON DELETE SET NULL,
+    FOREIGN KEY (updatedById) REFERENCES users(id) ON DELETE SET NULL
+  );
+
+CREATE TABLE IF NOT EXISTS "node_channels" (
+    nodeId INTEGER NOT NULL,
+    channelId INTEGER NOT NULL,
+    PRIMARY KEY (nodeId, channelId),
+    FOREIGN KEY (nodeId) REFERENCES content_nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (channelId) REFERENCES channels(id) ON DELETE CASCADE
+  );
+
+CREATE TABLE IF NOT EXISTS "tree_nodes" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    treeId INTEGER NOT NULL,
+    contentId INTEGER NOT NULL,
+    parentId INTEGER,
+    sortOrder INTEGER DEFAULT 0,
+    FOREIGN KEY (treeId) REFERENCES trees(id) ON DELETE CASCADE,
+    FOREIGN KEY (contentId) REFERENCES content_nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (parentId) REFERENCES tree_nodes(id) ON DELETE CASCADE
+  );
+
+CREATE TABLE IF NOT EXISTS "content_blocks" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    contentId INTEGER NOT NULL,
+    region TEXT DEFAULT 'main',
+    elementType TEXT NOT NULL,
+    dataJson TEXT,
+    sortOrder INTEGER DEFAULT 0,
+    isDraft INTEGER NOT NULL DEFAULT 1,
+    FOREIGN KEY (contentId) REFERENCES content_nodes(id) ON DELETE CASCADE
+  );
+
+CREATE TABLE IF NOT EXISTS "node_revisions" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    nodeId INTEGER NOT NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    snapshotJson TEXT NOT NULL,
+    createdById TEXT,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (nodeId) REFERENCES content_nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (createdById) REFERENCES users(id) ON DELETE SET NULL
+  );
+
+CREATE TABLE IF NOT EXISTS "assets" (
+    id TEXT PRIMARY KEY,
+    filename TEXT NOT NULL,
+    mimeType TEXT NOT NULL,
+    sizeBytes INTEGER NOT NULL,
+    storageKeyPrivate TEXT,
+    cdnUrl TEXT,
+    parentAssetId TEXT,
+    cropCoordinatesJson TEXT,
+    isSystemVariant INTEGER DEFAULT 0,
+    dataJson TEXT DEFAULT '{}',
+    createdById TEXT,
+    createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
+    deletedAt TEXT,
+    FOREIGN KEY (parentAssetId) REFERENCES assets(id) ON DELETE SET NULL,
+    FOREIGN KEY (createdById) REFERENCES users(id) ON DELETE SET NULL
+  );
+
+CREATE TABLE IF NOT EXISTS "node_assets" (
+    nodeId INTEGER NOT NULL,
+    assetId TEXT NOT NULL,
+    fieldKey TEXT NOT NULL,
+    sortOrder INTEGER DEFAULT 0,
+    PRIMARY KEY (nodeId, assetId, fieldKey),
+    FOREIGN KEY (nodeId) REFERENCES content_nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (assetId) REFERENCES assets(id) ON DELETE CASCADE
+  );
+
+CREATE INDEX IF NOT EXISTS idx_tree_nodes_tree_parent ON tree_nodes(treeId, parentId);
+CREATE INDEX IF NOT EXISTS idx_tree_nodes_contentId ON tree_nodes(contentId);
+CREATE INDEX IF NOT EXISTS idx_content_nodes_slug_status ON content_nodes(slug, status);
+CREATE INDEX IF NOT EXISTS idx_content_blocks_node ON content_blocks(contentId, isDraft);
+CREATE INDEX IF NOT EXISTS idx_node_assets_nodeId ON node_assets(nodeId);
+CREATE INDEX IF NOT EXISTS idx_node_assets_assetId ON node_assets(assetId);
+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);
+CREATE INDEX IF NOT EXISTS idx_trees_visibility ON trees(isHidden);
+CREATE INDEX IF NOT EXISTS idx_content_nodes_visibility ON content_nodes(isHidden, status);
+CREATE INDEX IF NOT EXISTS idx_content_nodes_slug ON content_nodes(slug);
+CREATE INDEX IF NOT EXISTS idx_content_nodes_type ON content_nodes(contentType);
+CREATE INDEX IF NOT EXISTS idx_content_nodes_deleted_updated ON content_nodes(deletedAt, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_tree_nodes_hierarchy ON tree_nodes(treeId, parentId, sortOrder);
+CREATE INDEX IF NOT EXISTS idx_tree_nodes_content ON tree_nodes(contentId, treeId);
+CREATE INDEX IF NOT EXISTS idx_content_blocks_content ON content_blocks(contentId, isDraft, region, sortOrder);
+CREATE INDEX IF NOT EXISTS idx_node_channels_channel ON node_channels(channelId, nodeId);
+CREATE INDEX IF NOT EXISTS idx_node_channels_node ON node_channels(nodeId, channelId);
+CREATE INDEX IF NOT EXISTS idx_node_assets_node_asset ON node_assets(nodeId, assetId);
+CREATE INDEX IF NOT EXISTS idx_node_assets_asset_node ON node_assets(assetId, nodeId);
+CREATE INDEX IF NOT EXISTS idx_node_revisions_node ON node_revisions(nodeId, version);
+CREATE INDEX IF NOT EXISTS idx_assets_system_created ON assets(isSystemVariant, createdAt DESC);
+CREATE INDEX IF NOT EXISTS idx_assets_system_mime ON assets(isSystemVariant, mimeType);
+CREATE INDEX IF NOT EXISTS idx_assets_deleted ON assets(deletedAt);
+CREATE INDEX IF NOT EXISTS idx_assets_parent ON assets(parentAssetId);
+
+-- System Defaults
+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,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');
+}