clovie 0.1.38 → 0.1.39

package/lib/createClovie.js

@@ -3,7 +3,6 @@ import { Engine } from '@jucie.io/engine';
 import { Compile } from './services/Compile.js';
 import { Run } from './services/Run.js';
 import { Configurator } from './services/Configurator.js';
-import { Route } from './services/Router.js';
 import { transformConfig } from './utils/transformConfig.js';
 import { Server } from '@jucie.io/engine-server';
 import { EsBuildCompiler } from '@jucie.io/engine-esbuild';
@@ -22,7 +21,6 @@ export const createClovie = async (config = {}) => {
       clovie.configurator.onReady(async (opts) => {
         // Always install core services
         clovie.install(Compile)
-        clovie.install(Route)
         clovie.install(Run)
 
         if (opts.scripts) {

package/lib/factories/api.js

@@ -0,0 +1 @@
+export{ defineRoutes as defineApi } from '@jucie.io/engine-server';

package/lib/factories/hooks.js

@@ -0,0 +1 @@
+export { defineHooks } from '@jucie.io/engine-server';

package/lib/factories/middleware.js

@@ -0,0 +1 @@
+export { defineMiddleware } from '@jucie.io/engine-server';

package/lib/factories/routes.js

@@ -0,0 +1 @@
+export { defineRoutes } from '@jucie.io/engine-server';

package/lib/main.js

@@ -0,0 +1,5 @@
+export { defineApi } from './factories/api.js';
+export { defineRoutes } from './factories/routes.js';
+export { defineHooks } from './factories/hooks.js';
+export { defineMiddleware } from './factories/middleware.js';
+export { createClovie } from './createClovie.js';

package/lib/services/Run.js

@@ -1,5 +1,9 @@
 import { ServiceProvider } from '@jucie.io/engine';
-import path from 'path';
+import { normalizeToFactories } from '../utils/normalizeToFactories.js';
+import { viewsToRoutes, pagesToRoutes } from '../utils/viewsToRoutes.js';
+import { defineRoutes } from '../factories/routes.js';
+import { defineHooks } from '../factories/hooks.js';
+import { defineMiddleware } from '../factories/middleware.js';
 
 export class Run extends ServiceProvider {
   static manifest = {
@@ -112,10 +116,22 @@ export class Run extends ServiceProvider {
   }
 
   async #serve (opts) {
-    const router = this.useContext('router');
-    await router.setHooks(opts);
-    await router.serveApi(opts);
-    await router.serveRoutes(opts);
+    const [server, file, liveReload] = this.useContext('server', 'file', 'liveReload');
+    const services = { file, liveReload };
+
+    const viewRoutes = viewsToRoutes(opts, services);
+    const pageRoutes = pagesToRoutes(opts.routes, opts, services);
+
+    const factories = [
+      ...normalizeToFactories(opts.hooks, defineHooks),
+      ...normalizeToFactories(opts.middleware, defineMiddleware),
+      ...normalizeToFactories(opts.api, defineRoutes),
+      ...normalizeToFactories([...viewRoutes, ...pageRoutes], defineRoutes),
+    ];
+
+    if (factories.length) {
+      server.use(...factories);
+    }
   }
 
   async #watch(opts) {

package/lib/utils/normalizeToFactories.js

@@ -0,0 +1,52 @@
+import { definitionType } from '@jucie.io/engine';
+
+/**
+ * Normalizes a config value into an array of engine-server factory definitions.
+ *
+ * Handles four input shapes:
+ *  - Raw data (plain array or object) → wrapped in factoryFn
+ *  - Single factory (created via createDefinition) → returned as-is
+ *  - Array of factories → returned as-is
+ *  - Intermixed (raw items + factories in the same array) → raw items
+ *    are batched and wrapped, factories are preserved
+ *
+ * @param {*} value - The config value (routes, middleware, hooks, api, etc.)
+ * @param {Function} factoryFn - The define* factory to wrap raw data with
+ * @returns {Array} Array of factory definitions ready for server.use()
+ */
+export function normalizeToFactories(value, factoryFn) {
+  if (!value) return [];
+
+  if (isFactory(value)) return [value];
+
+  if (!Array.isArray(value)) return [wrapRaw(factoryFn, value)];
+
+  const raw = [];
+  const factories = [];
+
+  for (const item of value) {
+    if (isFactory(item)) {
+      if (raw.length) {
+        factories.push(wrapRaw(factoryFn, [...raw]));
+        raw.length = 0;
+      }
+      factories.push(item);
+    } else {
+      raw.push(item);
+    }
+  }
+
+  if (raw.length) {
+    factories.push(wrapRaw(factoryFn, raw));
+  }
+
+  return factories;
+}
+
+function isFactory(value) {
+  return typeof value === 'function' && definitionType(value) !== undefined;
+}
+
+function wrapRaw(factoryFn, data) {
+  return factoryFn(() => data);
+}

package/lib/utils/transformConfig.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import fs from 'fs';
-import { loadRenderEngine, validateRenderEngine } from './loadRenderEngine.js';
+import { loadRenderEngine } from './loadRenderEngine.js';
 
 // Add this near the top of the file, after the imports
 const DATA_TYPES = {
@@ -195,40 +195,6 @@ export async function transformConfig(config, log = null) {
   if (discovered.data) {
     discovered.data = await resolveData(discovered.data);
   }
-
-  // Middleware processing and adapter selection
-  if (!discovered.adapter) {
-    // Auto-detect adapter based on middleware presence
-    if (discovered.middleware && discovered.middleware.length > 0) {
-      discovered.adapter = 'express'; // Use Express for middleware
-      logger.debug('Auto-selected Express adapter due to middleware configuration');
-    } else {
-      discovered.adapter = 'http'; // Default to HTTP adapter
-      logger.debug('Using default HTTP adapter');
-    }
-  }
-
-  // Validate middleware if provided
-  if (discovered.middleware) {
-    if (!Array.isArray(discovered.middleware)) {
-      throw new Error('middleware must be an array of functions');
-    }
-    
-    // Validate each middleware function
-    discovered.middleware.forEach((mw, index) => {
-      if (typeof mw !== 'function') {
-        throw new Error(`middleware[${index}] must be a function, got ${typeof mw}`);
-      }
-    });
-    
-    logger.debug(`Configured ${discovered.middleware.length} middleware functions`);
-    
-    // Ensure Express adapter is used when middleware is present
-    if (discovered.adapter !== 'express') {
-      logger.warn('Middleware detected but adapter is not "express". Switching to Express adapter.');
-      discovered.adapter = 'express';
-    }
-  }
   
   return discovered;
 }

package/lib/utils/viewsToRoutes.js

@@ -0,0 +1,109 @@
+import path from 'path';
+
+/**
+ * Scans the views directory and produces engine-server route definitions.
+ * Each template file becomes a GET route whose handler renders the template.
+ *
+ *   views/index.html     → GET /
+ *   views/about.html     → GET /about
+ *   views/blog/post.html → GET /blog/post
+ *
+ * @param {object} opts - Clovie config opts
+ * @param {object} services - Injected services { file, liveReload }
+ * @returns {Array} Array of engine-server route objects ({ method, path, handler })
+ */
+export function viewsToRoutes(opts, services) {
+  if (!opts.views) return [];
+
+  const filePaths = services.file.getFilePaths(opts.views);
+  if (!filePaths.length) return [];
+
+  return filePaths.map(filePath => ({
+    method: 'GET',
+    path: filePathToRoutePath(filePath, opts.views),
+    handler: createTemplateHandler(filePath, opts, services),
+    meta: { source: 'views', template: filePath },
+  }));
+}
+
+/**
+ * Wraps an array of Clovie page configs ({ path, template, data }) into
+ * engine-server route objects ({ method, path, handler }).
+ *
+ * @param {Array} pages - Clovie page/route configs
+ * @param {object} opts - Clovie config opts
+ * @param {object} services - Injected services { file, liveReload }
+ * @returns {Array} Engine-server route objects
+ */
+export function pagesToRoutes(pages, opts, services) {
+  if (!pages || !pages.length) return [];
+
+  return pages.map(page => ({
+    method: 'GET',
+    path: page.path,
+    handler: createTemplateHandler(
+      page.template,
+      opts,
+      services,
+      page.data ? (ctx) => page.data(ctx) : null,
+    ),
+    meta: page.meta || { source: 'routes', template: page.template },
+  }));
+}
+
+/**
+ * Creates a route handler that renders a template and returns HTML.
+ * Shared by both views-to-routes and explicit page route definitions.
+ *
+ * @param {string} templatePath - Path to the template file
+ * @param {object} opts - Clovie config opts (renderEngine, data, mode)
+ * @param {object} services - { file, liveReload }
+ * @param {Function|null} dataFn - Optional per-request data function (ctx) => data
+ */
+export function createTemplateHandler(templatePath, opts, services, dataFn) {
+  return async (ctx) => {
+    const template = services.file.read(templatePath);
+    if (!template) {
+      return ctx.respond.text('Not Found', 404);
+    }
+
+    const globalData = opts.data || {};
+    const routeData = dataFn ? await dataFn(ctx) : {};
+    const mergedData = { ...globalData, ...routeData };
+
+    let html = await opts.renderEngine.render(template, mergedData);
+
+    if (services.liveReload && opts.mode === 'development') {
+      html = await services.liveReload.injectLiveReloadScript(html, opts);
+    }
+
+    return ctx.respond.html(html);
+  };
+}
+
+/**
+ * Converts a template file path to a URL route path.
+ *   views/index.html       → /
+ *   views/about.html       → /about
+ *   views/blog/post.njk    → /blog/post
+ *   views/blog/index.html  → /blog
+ */
+function filePathToRoutePath(filePath, viewsDir) {
+  const absoluteViewsDir = toAbsolutePath(viewsDir);
+  const absoluteFilePath = toAbsolutePath(filePath);
+  const relativePath = path.relative(absoluteViewsDir, absoluteFilePath);
+  const withoutExt = relativePath.replace(path.extname(relativePath), '');
+
+  if (withoutExt === 'index') return '/';
+
+  const segments = withoutExt.split(path.sep);
+  if (segments[segments.length - 1] === 'index') {
+    segments.pop();
+  }
+
+  return '/' + segments.join('/');
+}
+
+function toAbsolutePath(inputPath) {
+  return path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clovie",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "Vintage web dev tooling with modern quality of life",
   "keywords": [
     "static-site-generator",
@@ -35,7 +35,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./lib/createClovie.js"
+      "import": "./lib/main.js",
+      "require": "./lib/main.js"
     },
     "./server": "./lib/Server/main.js",
     "./cli": "./bin/cli.js"
@@ -75,9 +76,9 @@
     "publish:info": "node scripts/publish.js info"
   },
   "dependencies": {
-    "@jucie.io/engine": "^1.1.67",
+    "@jucie.io/engine": "^1.1.68",
     "@jucie.io/engine-esbuild": "^1.0.2",
-    "@jucie.io/engine-server": "^1.0.22",
+    "@jucie.io/engine-server": "^1.0.23",
     "@jucie.io/reactive": "^1.0.26",
     "chalk": "^5.6.2",
     "chokidar": "^3.5.3",

package/lib/services/Router.js

@@ -1,189 +0,0 @@
-import { ServiceProvider } from '@jucie.io/engine';
-import path from 'path';
-
-export class Route extends ServiceProvider {
-  static manifest = {
-    name: 'Clovie Route',
-    namespace: 'router',
-    version: '1.0.0',
-  }
-  #staticCache = new Set();
-  #cache = new Map();
-  #cacheSize = 100;
-
-  initialize(useContext, config) {
-    this.#cacheSize = config.cacheSize || 100;
-  }
-
-  actions(useContext) {
-    return {
-      setHooks: (opts) => {
-        const server = this.useContext('server');
-        if (!opts) {
-          return;
-        }
-        if (opts.hooks) {
-          server.hooks(opts.hooks);
-        }
-        return this;
-      },
-      clearStaticCache: () => {
-        this.#staticCache.forEach(outputPath => {
-          file.delete(outputPath);
-        });
-        this.#staticCache.clear();
-      },
-      serveRoutes: async (opts) => {
-        const server = this.useContext('server');
-        if (!opts.routes) {
-          return;
-        }
-        for (const route of opts.routes) {
-          server.add('GET', route.path, async (context) => {
-            try {
-              const content = await this.#routeHandler(route, context, opts);
-              return context.respond.html(content);
-            } catch (error) {
-              console.error('Error rendering route', error);
-              return context.respond.text('Internal Server Error', 500);
-            } 
-          },
-          route.meta
-          );
-        }
-      },
-      serveApi: (opts) => {
-        const server = this.useContext('server');
-        if (!opts.api) {
-          return;
-        }
-        for (const api of opts.api) {
-          server.add(api.method, api.path, (context) => {
-            try {
-              return this.#apiHandler(api, context, opts);
-            } catch (error) {
-              console.error('Error rendering route', error);
-              return context.respond.text('Internal Server Error', 500);
-            }
-          },
-          api.meta
-        );
-        }
-        return;
-      }
-    }
-  }
-
-  #apiHandler(api, context) {
-    return api.handler(context);
-  }
-
-  async #routeHandler(route, context, opts) {
-    const [file, liveReload] = this.useContext('file', 'liveReload');
-    
-    // Create unique cache key from request
-    const cacheKey = this.#instancePath(context.req);
-
-    if (this.#cache.has(cacheKey)) {
-      return await this.#cache.get(cacheKey).compile();
-    }
-
-    try {
-      const instance = {
-        watcherCleanup: liveReload && opts.mode === 'development' ? file.watch(route.template, async () => {
-          instance.dirty = true;
-          if (liveReload) {
-            liveReload.notifyReload();
-          }
-        }) : null,
-        route,
-        outputPath: this.#formatOutputPath(opts.outputDir, context.req.path),
-        dirty: true,
-        data: async () => route.data ? await route.data(context) : {},
-        compile: async () => {
-          try {
-            if (!file.exists(instance.route.template)) {
-              throw new Error(`Template not found: ${instance.route.template}`);
-            }
-            instance.lastAccess = Date.now();
-            instance.expires = Date.now() + 1000 * 60 * 60 * 24 * 30;
-            const template = file.read(instance.route.template);
-            let renderedContent = await opts.renderEngine.render(template, {...(opts.data || {}), ...(await instance.data() || {})})
-            if (liveReload && opts.mode === 'development') {
-              renderedContent = await liveReload.injectLiveReloadScript(renderedContent, opts);
-            }
-            file.write(instance.outputPath, renderedContent);
-            instance.dirty = false;
-            return renderedContent;
-            // return file.read(instance.outputPath);
-          } catch (error) {
-            console.error('Error compiling route', error);
-          } finally {
-            instance.dirty = false;
-          }
-        }
-      }
-      this.#addInstanceCache(cacheKey, instance);
-      return instance.compile();
-    } catch (error) {
-      console.error('Error rendering route', error);
-    }
-  }
-
-  #addInstanceCache(path, instance) {
-    this.#cache.set(path, instance);
-    if (this.#cache.size > this.#cacheSize) {
-      this.#cache.delete(this.#cache.keys().next().value);
-    }
-    return instance;
-  }
-
-  /**
-   * Format output path to ensure proper .html extensions
-   * @private
-   */
-  #formatOutputPath(outputDir, reqPath) {
-    // Handle root path
-    if (reqPath === '/' || reqPath === '') {
-      return path.join(outputDir, 'index.html');
-    }
-
-    // If already has .html extension, use as-is
-    if (reqPath.endsWith('.html')) {
-      return path.join(outputDir, reqPath);
-    }
-
-    // Add .html extension
-    // For paths like /posts or /posts/my-slug, both become .html files
-    return path.join(outputDir, `${reqPath}.html`);
-  }
-
-  /**
-   * Create unique instance cache key from request
-   * Combines path, params, and query for unique identification
-   * @private
-   */
-  #instancePath(req) {
-    let key = req.path;
-    
-    // Add route params if present (e.g., /posts/:slug)
-    if (req.params && Object.keys(req.params).length > 0) {
-      const paramsStr = Object.entries(req.params)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `${k}=${v}`)
-        .join('&');
-      key += `?params:${paramsStr}`;
-    }
-    
-    // Add query params if present (e.g., ?page=1&sort=desc)
-    if (req.query && Object.keys(req.query).length > 0) {
-      const queryStr = Object.entries(req.query)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `${k}=${v}`)
-        .join('&');
-      key += `${req.params ? '&' : '?'}query:${queryStr}`;
-    }
-    
-    return key;
-  }
-}