clovie 0.1.33 → 0.1.37

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)

package/config/clovie.config.js

@@ -32,6 +32,19 @@ export default {
   watch: false,
   port: 3000,
   open: false,
+
+  // Extensibility — install custom engine services
+  // services: [MyService, AnotherService.configure({...})],
+
+  // Extensibility — custom wiring after services are installed
+  // setup(engine) {},
+
+  // Lifecycle — runs right before server.listen()
+  // beforeListen(opts) {},
+
+  // Lifecycle — runs right after server starts (attach WebSocket upgrades, etc.)
+  // afterListen(httpServer, opts) {},
+
   routes: [
     {
       name: 'Products',

package/lib/createClovie.js

@@ -0,0 +1,70 @@
+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';
+import { LiveReload } from './services/LiveReload.js';
+
+export const createClovie = async (config = {}) => {
+  return new Promise((resolve, reject) => {
+    try {
+      const clovie = Engine.create().install(
+        Configurator.configure({
+          optsPath: config.optsPath,
+          transform: transformConfig
+        }),
+      );
+  
+      clovie.configurator.onReady(async (opts) => {
+        // Always install core services
+        clovie.install(Compile)
+        clovie.install(Route)
+        clovie.install(Run)
+
+        if (opts.scripts) {
+          clovie.install(EsBuildCompiler.configure({
+            entryPoints: [`${opts.scripts}/**/*.js`],
+            outdir: opts.outputDir,
+            outbase: opts.scripts,
+            bundle: true,
+            format: 'iife',
+            target: 'es2015',
+            minify: opts.mode === 'production',
+            sourcemap: opts.mode === 'development',
+          }));
+        }
+
+        if (Array.isArray(opts.services)) {
+          for (const service of opts.services) {
+            if (service.configured) {
+              clovie.install(service);
+            } else {
+              clovie.install(service.configure(opts));
+            }
+          }
+        }
+
+        if (typeof opts.setup === 'function') {
+          await opts.setup(clovie);
+        }
+
+        if (opts.type === 'server' || opts.mode === 'development') {
+          clovie.install(Server);
+        }
+  
+        if (opts.mode === 'development') {
+          clovie.install(LiveReload);
+        }
+
+        // Don't auto-execute commands - let CLI decide
+        resolve(clovie);
+      });
+    } catch (error) {
+      reject({ error, code: 'CREATE_CLOVIE_ERROR' });
+    }
+  });
+}

package/lib/examples/kernel-adapters.js

@@ -0,0 +1,100 @@
+/**
+ * Example usage of Server with different adapters
+ */
+
+import { createClovie } from '../createClovie.js';
+import { ExpressAdapter } from '../adapters/express.js';
+
+// Example 1: Using built-in HTTP adapter (default)
+async function httpExample() {
+  const clovie = await createClovie();
+  
+  // Add routes using the new context-based API
+  clovie.server.add('GET', '/', (ctx) => {
+    return ctx.respond.json({ message: 'Hello from HTTP adapter!' });
+  });
+
+  clovie.server.add('GET', '/users/:id', (ctx) => {
+    return ctx.respond.json({ 
+      user: ctx.req.params.id,
+      query: ctx.req.query 
+    });
+  });
+
+  // Start server with HTTP adapter (default)
+  await clovie.server.listen(3000);
+  console.log('HTTP server running on port 3000');
+}
+
+// Example 2: Using Express adapter
+async function expressExample() {
+  const clovie = await createClovie();
+  
+  // Set Express adapter
+  clovie.server.useAdapter(new ExpressAdapter());
+  
+  // Add routes
+  clovie.server.add('GET', '/', (ctx) => {
+    return ctx.respond.json({ message: 'Hello from Express adapter!' });
+  });
+
+  clovie.server.add('POST', '/api/users', (ctx) => {
+    return ctx.respond.json({ 
+      created: true,
+      user: ctx.req.body 
+    }, 201);
+  });
+
+  // Configure hooks
+  clovie.server.hooks({
+    onRequest: async (ctx) => {
+      console.log(`${ctx.req.method} ${ctx.req.path}`);
+    },
+    onError: async (ctx, error) => {
+      console.error('Error:', error);
+      return ctx.respond.json({ error: 'Internal Server Error' }, 500);
+    }
+  });
+
+  // Start server
+  await clovie.server.listen({ port: 3001 });
+  console.log('Express server running on port 3001');
+}
+
+// Example 3: Advanced Express usage with middleware
+async function advancedExpressExample() {
+  const clovie = await createClovie();
+  
+  // Create Express adapter with custom Express instance
+  const express = await import('express');
+  const app = express.default();
+  
+  // Add custom middleware
+  app.use((req, res, next) => {
+    req.customProperty = 'Custom middleware value';
+    next();
+  });
+  
+  const adapter = new ExpressAdapter(app);
+  clovie.server.useAdapter(adapter);
+  
+  // Add routes that can access custom middleware
+  clovie.server.add('GET', '/middleware', (ctx) => {
+    return ctx.respond.json({ 
+      middleware: ctx.req.raw.req.customProperty 
+    });
+  });
+
+  await clovie.server.listen({ port: 3002 });
+  console.log('Advanced Express server running on port 3002');
+}
+
+// Run examples
+if (import.meta.url === `file://${process.argv[1]}`) {
+  console.log('Starting Server adapter examples...');
+  
+  // Uncomment to run specific examples:
+  // httpExample();
+  // expressExample();
+  // advancedExpressExample();
+}

package/lib/examples/kernel-usage.js

@@ -0,0 +1,177 @@
+/**
+ * Example usage of the new Server adapter system
+ */
+
+import { createClovie } from '../createClovie.js';
+import { ExpressAdapter } from '../adapters/express.js';
+
+// Example 1: Using built-in HTTP adapter (default)
+async function httpExample() {
+  console.log('🚀 Starting HTTP adapter example...');
+  
+  const clovie = await createClovie();
+  
+  // Add routes using the new context-based API
+  clovie.server.add('GET', '/', (ctx) => {
+    return ctx.respond.json({ 
+      message: 'Hello from HTTP adapter!',
+      adapter: 'http'
+    });
+  });
+
+  clovie.server.add('GET', '/users/:id', (ctx) => {
+    return ctx.respond.json({ 
+      userId: ctx.req.params.id,
+      query: ctx.req.query,
+      adapter: 'http'
+    });
+  });
+
+  // Configure hooks
+  clovie.server.hooks({
+    onRequest: async (ctx) => {
+      console.log(`📥 ${ctx.req.method} ${ctx.req.path}`);
+    },
+    onSend: async (ctx, response) => {
+      console.log(`📤 Sent ${response.type} response`);
+    }
+  });
+
+  // Start server with HTTP adapter (default)
+  const server = await clovie.server.listen({ port: 3000 });
+  console.log(`✅ HTTP server running on http://localhost:${server.address().port}`);
+  
+  // Keep server running for demo
+  console.log('Press Ctrl+C to stop...');
+  process.on('SIGINT', async () => {
+    await clovie.server.stop();
+    console.log('👋 Server stopped');
+    process.exit(0);
+  });
+}
+
+// Example 2: Using Express adapter
+async function expressExample() {
+  console.log('🚀 Starting Express adapter example...');
+  
+  const clovie = await createClovie();
+  
+  // Set Express adapter
+  clovie.server.useAdapter(new ExpressAdapter());
+  
+  // Add routes
+  clovie.server.add('GET', '/', (ctx) => {
+    return ctx.respond.json({ 
+      message: 'Hello from Express adapter!',
+      adapter: 'express'
+    });
+  });
+
+  clovie.server.add('POST', '/api/users', (ctx) => {
+    return ctx.respond.json({ 
+      created: true,
+      user: ctx.req.body,
+      adapter: 'express'
+    }, 201);
+  });
+
+  // Configure hooks
+  clovie.server.hooks({
+    onRequest: async (ctx) => {
+      console.log(`📥 ${ctx.req.method} ${ctx.req.path} (Express)`);
+    },
+    onError: async (ctx, error) => {
+      console.error('❌ Error:', error.message);
+      return ctx.respond.json({ error: 'Internal Server Error' }, 500);
+    }
+  });
+
+  // Start server
+  const server = await clovie.server.listen({ port: 3001 });
+  console.log(`✅ Express server running on http://localhost:${server.address().port}`);
+  
+  // Keep server running for demo
+  console.log('Press Ctrl+C to stop...');
+  process.on('SIGINT', async () => {
+    await clovie.server.stop();
+    console.log('👋 Server stopped');
+    process.exit(0);
+  });
+}
+
+// Example 3: Advanced usage with custom middleware
+async function advancedExample() {
+  console.log('🚀 Starting advanced example...');
+  
+  const clovie = await createClovie();
+  
+  // Create Express adapter with custom Express instance
+  try {
+    const express = await import('express');
+    const app = express.default();
+    
+    // Add custom middleware
+    app.use((req, res, next) => {
+      req.customProperty = 'Custom middleware value';
+      next();
+    });
+    
+    const adapter = new ExpressAdapter(app);
+    clovie.server.useAdapter(adapter);
+    
+    // Add routes that can access custom middleware
+    clovie.server.add('GET', '/middleware', (ctx) => {
+      return ctx.respond.json({ 
+        middleware: ctx.req.raw.req.customProperty,
+        adapter: 'express-with-middleware'
+      });
+    });
+
+    const server = await clovie.server.listen({ port: 3002 });
+    console.log(`✅ Advanced server running on http://localhost:${server.address().port}`);
+    
+    // Keep server running for demo
+    console.log('Press Ctrl+C to stop...');
+    process.on('SIGINT', async () => {
+      await clovie.server.stop();
+      console.log('👋 Server stopped');
+      process.exit(0);
+    });
+    
+  } catch (error) {
+    console.error('❌ Express not available. Install with: npm install express');
+    console.log('Falling back to HTTP adapter...');
+    
+    // Fallback to HTTP adapter
+    clovie.server.add('GET', '/fallback', (ctx) => {
+      return ctx.respond.json({ 
+        message: 'Fallback to HTTP adapter',
+        adapter: 'http-fallback'
+      });
+    });
+
+    const server = await clovie.server.listen({ port: 3002 });
+    console.log(`✅ Fallback server running on http://localhost:${server.address().port}`);
+  }
+}
+
+// Run examples based on command line argument
+const example = process.argv[2] || 'http';
+
+switch (example) {
+  case 'http':
+    httpExample();
+    break;
+  case 'express':
+    expressExample();
+    break;
+  case 'advanced':
+    advancedExample();
+    break;
+  default:
+    console.log('Usage: node kernel-usage.js [http|express|advanced]');
+    console.log('Examples:');
+    console.log('  node kernel-usage.js http      # HTTP adapter (default)');
+    console.log('  node kernel-usage.js express   # Express adapter');
+    console.log('  node kernel-usage.js advanced  # Advanced Express with middleware');
+}