clovie 0.1.32 → 0.1.36

package/README.md

@@ -2,7 +2,7 @@
 
 > *"The Hollow Knight of Web Dev"* - Simple but deep, easy to start but room to grow.
 
-A powerful Node.js-based **static site generator** and **full-stack web framework** that bridges the gap between simple static sites and complex web applications. Built on the **@brickworks/engine** service architecture for maximum flexibility and maintainability.
+A powerful Node.js-based **static site generator** and **full-stack web framework** that bridges the gap between simple static sites and complex web applications. Built on the **@jucie.io/engine** service architecture for maximum flexibility and maintainability.
 
 ## 🚀 Quick Start
 
@@ -24,14 +24,13 @@ npm run dev
 - **🎨 Template Agnostic**: Handlebars, Nunjucks, Pug, Mustache, or custom engines
 - **📦 Asset Pipeline**: SCSS compilation, JavaScript bundling with esbuild
 - **🔄 Live Reload**: WebSocket-based live reload during development
-- **🗄️ Database Ready**: SQLite integration for server mode applications
 - **🛣️ Dynamic Routing**: Data-driven page generation and API endpoints
 - **🧩 App Orchestration**: Build and serve external Vite/Webpack/Rollup/esbuild apps via kernel handlers
 - **🔧 Service Architecture**: Modular, extensible service-oriented design
 
 ## 🏗️ Architecture Overview
 
-Clovie uses a **service-oriented architecture** built on `@brickworks/engine`. All functionality is provided by services that extend `ServiceProvider`, orchestrated through dependency injection with reactive state management.
+Clovie uses a **service-oriented architecture** built on `@jucie.io/engine`. All functionality is provided by services that extend `ServiceProvider`, orchestrated through dependency injection with reactive state management.
 
 ### Core Services
 
@@ -277,9 +276,6 @@ export default {
     }
   },
   
-  // Database configuration (optional)
-  dbPath: './data/app.db',
-  
   // Express middleware (auto-selects Express adapter)
   middleware: [
     express.json(),
@@ -433,28 +429,6 @@ export default {
 
 See [Apps Integration](docs/CONFIGURATION.md#apps-integration) for full examples covering Webpack, Rollup, and esbuild setups.
 
-### 📊 Database Integration (Server Mode)
-
-Clovie includes built-in SQLite database support for server applications:
-
-```javascript
-export default {
-  type: 'server',
-  dbPath: './data/app.db', // SQLite database path
-  
-  // Database is available in API actions and routes
-  api: [{
-    path: '/api/posts',
-    method: 'GET',
-    action: async (state, event) => {
-      // Access database through state.db
-      const posts = await state.db.query('SELECT * FROM posts ORDER BY created_at DESC');
-      return { posts };
-    }
-  }]
-};
-```
-
 ### 🔄 Async Data Loading
 
 Load data dynamically at build time or runtime:
@@ -628,7 +602,7 @@ my-site/
 - Validate input data in API actions
 - Use middleware for authentication and request parsing
 - Handle errors gracefully in API endpoints
-- Implement proper database migrations and seeding
+- Implement proper data migrations and seeding
 
 ### 🔧 Configuration Tips
 
@@ -715,11 +689,6 @@ clovie kill --check         # Check port status
 - Check that template files have correct extensions
 - Ensure partial files are in the `partials` directory
 
-**Database Connection Issues (Server Mode)**
-- Check that `dbPath` in config points to a writable directory
-- Ensure SQLite is properly installed 
-- Verify database initialization in your API actions
-
 **Live Reload Not Working**
 - Check that you're in development mode (`npm run dev`)
 - Verify WebSocket connection in browser dev tools

package/bin/cli.js

@@ -13,8 +13,7 @@ const packageJson = JSON.parse(readFileSync(path.join(__dirname, '../package.jso
 const CLOVIE_VERSION = packageJson.version;
 
 // Local - import from compiled dist for published package
-// import { createClovie } from "../lib/createClovie.js";
-import { createClovie } from "../dist/index.js";
+import { createClovie } from "../lib/createClovie.js";
 import { killPort, checkPorts, killCommonPorts } from "../scripts/killPort.js";
 
 // Check for kill command first (before any argument parsing)
@@ -361,16 +360,6 @@ function setupGracefulShutdown(clovie) {
     }, 5000); // 5 second timeout
     
     try {
-      // Close database if it exists and is initialized
-      const database = clovie.database;
-      if (database && database.isInitialized && database.isInitialized()) {
-        console.log('💾 Closing database...');
-        if (typeof database.checkpoint === 'function') {
-          await database.checkpoint();
-          console.log('✅ Database written successfully');
-        }
-      }
-      
       // Stop server if it's running
       const server = clovie.server;
       if (server && server.isRunning && server.isRunning()) {

package/lib/Apps.js

@@ -0,0 +1,66 @@
+import { ServiceProvider } from '@jucie.io/engine';
+import path from 'path';
+import fs from 'fs/promises';
+import { spawn } from 'child_process';
+import { pathToFileURL } from 'url';
+import { PageCache } from './Cache.js';
+import { File } from './File.js';
+import { createProgressTracker } from './utils/progress.js';
+
+export class Apps extends ServiceProvider {
+  static manifest = {
+    name: 'Clovie Apps',
+    namespace: 'apps',
+    version: '1.0.0',
+    dependencies: [PageCache, File],
+    defaults: {
+      apps: []
+    }
+  };
+
+  #progressTracker = null;
+  #buildProcesses = new Map();
+  #buildResults = new Map();
+  #handlers = new Map();
+  #apps = [];
+
+  actions(useContext) {
+    const log = useContext('log');
+  
+    
+    return {
+      build: async (opts = {}) => {
+        this.#apps = opts.apps || [];
+        try {
+
+          for (const app of this.#apps) {
+            const { default: config } = await import(app.config);
+            await this.createViteApp(opts, config);
+          }
+
+          return true
+          
+        } catch (error) {
+          console.error('Error building apps', error);
+        }
+        return true
+      }
+    };
+  }
+
+  async createViteApp(opts = {}, config = {}) {
+    const [server, log] = this.useContext('server', 'log');
+    const { createServer } = await import('vite');
+    const vite = await createServer({
+      httpServer: server.getHttpServer(),
+      root: opts.root,
+      configFile: opts.configFile
+    });
+    
+    // server.add('GET', '/vite', async (ctx) => {
+    //   const url = ctx.req.originalUrl;
+    //   const template = await vite.transformIndexHtml(url, fs.readFileSync(join(opts.root, 'index.html'), 'utf-8'));
+    //   return ctx.respond.html(template);
+    // })
+  }
+}

package/lib/Cache.js

@@ -0,0 +1,94 @@
+import { ServiceProvider } from '@jucie.io/engine';
+import crypto from 'crypto';
+
+export class PageCache extends ServiceProvider {
+  static manifest = {
+    name: 'Clovie Page Cache',
+    namespace: 'pageCache',
+    version: '1.0.0',
+  }
+
+  actions(useContext) {
+    const { cache } = useContext();
+    return {
+      /**
+       * Set cached content with hash for comparison
+       */
+      set: (filePath, content) => {
+        const hash = this.#createHash(content);
+        const cacheEntry = {
+          filePath,
+          hash,
+          timestamp: Date.now()
+        };
+        cache.set(['.cache', filePath], cacheEntry);
+        return hash;
+      },
+      
+      /**
+       * Get cached content
+       */
+      get: (filePath) => {
+        const entry = cache.get(['.cache', filePath]);
+        return entry ? entry.content : null;
+      },
+      
+      /**
+       * Check if content has changed by comparing hashes
+       */
+      hasChanged: (filePath, newContent) => {
+        return this.#hasChanged(filePath, newContent);
+      },
+      
+      /**
+       * Get hash of cached content
+       */
+      getHash: (filePath) => {
+        const entry = cache.get(['.cache', filePath]);
+        return entry ? entry.hash : null;
+      },
+      
+      /**
+       * Get cache entry metadata
+       */
+      getEntry: (filePath) => {
+        return cache.get(['.cache', filePath]);
+      },
+      
+      /**
+       * Clear cache entry
+       */
+      clear: (filePath) => {
+        cache.delete(['.cache', filePath]);
+      },
+      
+      /**
+       * Clear all cache
+       */
+      clearAll: () => {
+        cache.delete(['.cache']);
+      }
+    }
+  }
+
+  #hasChanged(filePath, newContent) {
+    const cache = this.useContext('cache');
+    const entry = cache.get(['.cache', filePath]);
+    
+    if (!entry) {
+      return true; // No cache entry means it's new/changed
+    }
+    
+    const newHash = this.#createHash(newContent);
+    return entry.hash !== newHash;
+  }
+  
+  /**
+   * Create consistent hash for content
+   */
+  #createHash(content) {
+    // Handle different content types
+    const contentString = typeof content === 'string' ? content : JSON.stringify(content);
+    return crypto.createHash('sha256').update(contentString).digest('hex');
+  }
+}

package/lib/Compile.js

@@ -0,0 +1,432 @@
+import { ServiceProvider } from '@jucie.io/engine';
+import path from 'path';
+import { PageCache } from './Cache.js';
+import { File } from './File.js';
+import { createProgressTracker } from './utils/progress.js';
+
+import { replaceRouteParams } from './Server/utils/routeMatch.js';
+import { formatOutputPath } from './utils/outputPath.js';
+
+export class Compile extends ServiceProvider {
+
+  static manifest = {
+    name: 'Clovie Compile',
+    namespace: 'compile',
+    version: '1.0.0',
+    dependencies: [PageCache, File]
+  };
+
+  #progressTracker = null;
+  #pathMap = new Map();
+
+  actions(useContext) {
+    const [file, log] = useContext('file', 'log');
+    
+    // Initialize progress tracker if not already done
+    if (!this.#progressTracker) {
+      this.#progressTracker = createProgressTracker(log);
+    }
+    
+    return {
+      assets: async (opts) => {
+        if (!opts.assets) {
+          log.debug('No assets directory to compile');
+          return [];
+        }
+        const filePaths = file.getFilePaths(opts.assets);
+        
+        if (filePaths.length === 0) {
+          log.debug('No assets to compile');
+          return [];
+        }
+
+        const progressId = this.#progressTracker.createProgressBar('Compiling Assets', filePaths.length, 'files');
+        const promises = [];
+
+        for (let i = 0; i < filePaths.length; i++) {
+          const filePath = filePaths[i];
+          promises.push(
+            this.#asset(filePath, opts).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: path.basename(filePath) 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Compiled ${filePaths.length} assets`);
+        
+        return promises;
+      },
+      scripts: async (opts) => {
+        if (!opts.scripts) {
+          log.debug('No scripts directory to compile');
+          return [];
+        }
+        const filePaths = file.getFilePaths(opts.scripts);
+        
+        if (filePaths.length === 0) {
+          log.debug('No scripts to compile');
+          return [];
+        }
+
+        const progressId = this.#progressTracker.createProgressBar('Compiling Scripts', filePaths.length, 'files');
+        const promises = [];
+
+        for (let i = 0; i < filePaths.length; i++) {
+          const filePath = filePaths[i];
+          promises.push(
+            this.#script(filePath, opts).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: path.basename(filePath) 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Compiled ${filePaths.length} scripts`);
+        
+        return promises;
+      },
+      styles: async (opts) => {
+        if (!opts.styles) {
+          log.debug('No styles directory to compile');
+          return [];
+        }
+        const filePaths = file.getFilePaths(opts.styles);
+        
+        if (filePaths.length === 0) {
+          log.debug('No styles to compile');
+          return [];
+        }
+
+        const progressId = this.#progressTracker.createProgressBar('Compiling Styles', filePaths.length, 'files');
+        const promises = [];
+
+        for (let i = 0; i < filePaths.length; i++) {
+          const filePath = filePaths[i];
+          promises.push(
+            this.#style(filePath, opts).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: path.basename(filePath) 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Compiled ${filePaths.length} styles`);
+        
+        return promises;
+      },
+      partials: async (opts) => {
+        if (!opts.partials) {
+          log.debug('No partials directory to compile');
+          return [];
+        }
+        const filePaths = file.getFilePaths(opts.partials);
+        
+        if (filePaths.length === 0) {
+          log.debug('No partials to load');
+          return [];
+        }
+
+        const progressId = this.#progressTracker.createProgressBar('Loading Partials', filePaths.length, 'files');
+        const promises = [];
+
+        for (let i = 0; i < filePaths.length; i++) {
+          const filePath = filePaths[i];
+          promises.push(
+            Promise.resolve(this.#loadPartial(filePath, opts)).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: path.basename(filePath) 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Loaded ${filePaths.length} partials`);
+        
+        return promises;
+      },
+      views: async (opts) => {
+        if (!opts.views) {
+          log.debug('No views directory to compile');
+          return [];
+        }
+        const filePaths = file.getFilePaths(opts.views);
+        
+        if (filePaths.length === 0) {
+          log.debug('No views to compile');
+          return [];
+        }
+
+        const progressId = this.#progressTracker.createProgressBar('Compiling Views', filePaths.length, 'files');
+        const promises = [];
+        
+        for (let i = 0; i < filePaths.length; i++) {
+          const filePath = filePaths[i];
+          console.log('filePath', filePath);
+          promises.push(
+            this.#view(filePath, opts).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: path.basename(filePath) 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Compiled ${filePaths.length} views`);
+        
+        return promises;
+      },
+
+      routes: async (opts) => {
+        if (!opts.routes || opts.routes.length === 0) {
+          log.debug('No routes to compile');
+          return [];
+        }
+        
+        const progressId = this.#progressTracker.createProgressBar('Compiling Routes', opts.routes.length, 'routes');
+        const promises = [];
+        const routesLength = opts.routes.length;
+
+        for (let i = 0; i < routesLength; i++) {
+          const route = opts.routes[i];
+          if (route.repeat) {
+            const data = route.repeat(opts.data);
+            const entries = Array.isArray(data) ? data.entries() : Object.entries(data);
+            for (const [key, value] of entries) {
+              promises.push(
+                this.#route(route, opts, value, key).then(() => {
+                  this.#progressTracker.updateProgress(progressId, i + 1, { 
+                    current: route.path || 'route' 
+                  });
+                })
+              );
+            }
+            continue;
+          }
+          promises.push(
+            this.#route(route, opts, null, null).then(() => {
+              this.#progressTracker.updateProgress(progressId, i + 1, { 
+                current: route.path || 'route' 
+              });
+            })
+          );
+        }
+
+        await Promise.all(promises);
+        this.#progressTracker.completeProgress(progressId, `✅ Compiled ${opts.routes.length} routes`);
+        
+        return promises;
+      },
+      
+      asset:    (path, opts) => this.#asset(path, opts),
+      script:   (path, opts) => this.#script(path, opts), 
+      style:    (path, opts) => this.#style(path, opts),
+      partial:  (path, opts) => this.#loadPartial(path, opts),
+      view: (path, opts) => this.#view(path, opts),
+      remove:   (path, opts) => this.#remove(path, opts),
+      route:    (route, opts, item, key) => this.#route(route, opts, item, key),
+    };
+  }
+
+  #remove(sourcePath) {
+    const file = this.useContext('file');
+    const outputPaths = this.#pathMap.get(sourcePath);
+    if (outputPaths) {
+      outputPaths.forEach(outputPath => {
+        file.delete(outputPath);
+      });
+    }
+  }
+
+  async #asset(filePath, opts) {
+    const [file, log] = this.useContext('file', 'log');
+    const content = file.read(filePath);
+
+    if (content) {
+      const assetsDir = opts.assets;
+      const absoluteAssetsDir = this.#toAbsolutePath(assetsDir);
+      const absoluteFilePath = this.#toAbsolutePath(filePath);
+      const relativePath = path.relative(absoluteAssetsDir, absoluteFilePath);
+      
+      log.debug(`Processing asset: ${filePath}`);
+      log.debug(`Asset processed: ${relativePath}`);
+      this.#registerOutputPath(filePath, relativePath, opts.outputDir);
+      return this.#write(relativePath, content, opts.outputDir);
+    }
+  }
+
+  async #script(filePath, opts) {
+    const [file, log] = this.useContext('file', 'log');
+    const content = file.read(filePath);
+
+    if (content && opts.scriptCompiler && typeof opts.scriptCompiler === 'function') {
+      const scriptsDir = opts.scripts;
+      const fileName = path.basename(filePath);
+      
+      // Ensure both paths are absolute for proper relative calculation
+      const absoluteScriptsDir = this.#toAbsolutePath(scriptsDir);
+      const absoluteFilePath = this.#toAbsolutePath(filePath);
+      const relativePath = path.relative(absoluteScriptsDir, absoluteFilePath);
+
+      try {
+        log.debug(`Using configured script compiler for: ${filePath}`);
+        const compiled = await opts.scriptCompiler(content, filePath);
+        log.debug(`Script compiled successfully: ${fileName}`);
+        this.#registerOutputPath(filePath, relativePath, opts.outputDir);
+        return this.#write(relativePath, compiled, opts.outputDir);
+      } catch (err) {
+        log.warn(`Script compilation failed for ${filePath}: ${err.message}`);  
+      }
+    }
+  }
+
+  async #style(filePath, opts) {
+    const [file, log] = this.useContext('file', 'log');
+    const content = file.read(filePath);
+
+    if (content && opts.styleCompiler && typeof opts.styleCompiler === 'function') {
+      const stylesDir = opts.styles;
+      
+      // Ensure both paths are absolute for proper relative calculation
+      const absoluteStylesDir = this.#toAbsolutePath(stylesDir);
+      const absoluteFilePath = this.#toAbsolutePath(filePath);
+      const relativePath = path.relative(absoluteStylesDir, absoluteFilePath).replace(/\.(scss|sass|less|styl)$/, '.css');
+      const fileName = path.basename(relativePath);
+
+      try {
+        log.debug(`Using configured style compiler for: ${filePath}`);
+        const compiled = await opts.styleCompiler(content, filePath);
+        log.debug(`Style compiled successfully: ${fileName}`);
+        this.#registerOutputPath(filePath, relativePath, opts.outputDir);
+        return this.#write(relativePath, compiled, opts.outputDir);
+      } catch (err) {
+        log.warn(`Style compilation failed for ${filePath}: ${err.message}`);
+      }
+    }
+  }
+
+  #loadPartial(filePath, opts) {
+    const [file, log] = this.useContext('file', 'log');
+
+    if (file.exists(filePath) && opts.renderEngine) {
+      try {
+        const partialsDir = opts.partials;
+        const relativePath = path.relative(partialsDir, filePath);
+        
+        // Get the partial name without extension (e.g., 'header.html' -> 'header')
+        const partialName = path.parse(relativePath).name;
+        
+        // Read the partial content
+        const content = file.read(filePath);
+        
+        log.debug(`Registering partial: ${partialName}`);
+        opts.renderEngine.register(partialName, content);
+        log.debug(`Registered partial: ${partialName}`);
+      } catch (err) {
+        log.warn('Could not register partials:', err.message);
+      }
+    }
+  }
+
+  async #view(filePath, opts) {
+    const [file, liveReload, log] = this.useContext('file', 'liveReload', 'log');
+
+    if (file.exists(filePath) && opts.renderEngine) {
+      const fileName = path.basename(filePath);
+      const viewsDir = opts.views;
+      
+      // Ensure both paths are absolute for proper relative calculation
+      const absoluteViewsDir = this.#toAbsolutePath(viewsDir);
+      const absoluteFilePath = this.#toAbsolutePath(filePath);
+      const relativePath = path.relative(absoluteViewsDir, absoluteFilePath);
+      const renderedContent = await this.#template(filePath, opts.data, opts);
+      this.#registerOutputPath(relativePath, relativePath, opts.outputDir);
+      return this.#write(relativePath, renderedContent, opts.outputDir);
+    }
+  }
+
+  async #route(route, opts, value, key) {
+    const [file, log] = this.useContext('file', 'log');
+    const data =  route.data(opts.data, value, key);
+    const relativePath = replaceRouteParams(route.path, data);
+    const outputPath = formatOutputPath(relativePath);
+            
+    if (file.exists(route.template) && opts.renderEngine) {
+      const renderedContent = await this.#template(route.template, data, opts);
+      this.#registerOutputPath(relativePath, outputPath, opts.outputDir);
+      return this.#write(outputPath, renderedContent, opts.outputDir);      
+    } else {
+      log.warn(`No template compiler configured for route: ${route.path}`);
+    }
+  }
+
+  async #template(templatePath, data, opts) {
+    const [file, log] = this.useContext('file', 'log');
+    try {
+      const template = file.read(templatePath);
+      let renderedContent = await opts.renderEngine.render(template, data);
+      renderedContent = await this.#injectLiveReloadScript(renderedContent, opts);
+      return renderedContent;
+    } catch (err) {
+      log.debug('Error compiling', err)
+    }
+  }
+
+  async #injectLiveReloadScript(renderedContent, opts) {
+    const [liveReload, log] = this.useContext('liveReload', 'log');
+    try {
+      if (liveReload && renderedContent.includes('</body>')) {
+          log.debug('Injecting live reload script');
+          renderedContent = await liveReload.injectLiveReloadScript(renderedContent, opts);
+      }
+      return renderedContent;
+    } catch (err) {
+      log.debug('Error injecting live reload script', err);
+      return renderedContent;
+    }
+  }
+
+  /**
+   * Convert a path to an absolute path
+   * @param {string} inputPath - The path to normalize
+   * @returns {string} - Absolute path
+   */
+  #toAbsolutePath(inputPath) {
+    return path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+  }
+
+  #registerOutputPath(sourcePath, relativePath, outputDir) {
+    const outputPath = path.join(outputDir, relativePath);
+    if (!this.#pathMap.has(sourcePath)) {
+      this.#pathMap.set(sourcePath, new Set());
+    }
+    this.#pathMap.get(sourcePath).add(outputPath);
+  }
+
+  #write(filePath, content, outputDir) {
+    const [file, pageCache, log, liveReload] = this.useContext('file', 'pageCache', 'log', 'liveReload');
+    const outputPath = path.join(outputDir, filePath);
+        
+    // Cache based on OUTPUT content (handles both template and data changes)
+    if (pageCache.hasChanged(outputPath, content)) {
+      file.write(outputPath, content);
+      pageCache.set(outputPath, content);
+      log.debug(`Written: ${filePath}`);
+      
+      if (liveReload) {
+        liveReload.notifyReload();
+      }
+      return outputPath;
+    } else {
+      log.debug(`Skipped (no changes): ${filePath}`);
+    }
+  }
+}