johankit-runtime 0.0.2 → 0.4.3

package/dist/tests/dispatch.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)('dispatchEvent', () => {
+    let dispatchEvent;
+    let packageModule;
+    let decoratorModule;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetModules();
+        vitest_1.vi.clearAllMocks();
+        packageModule = require('../src/core/package');
+        decoratorModule = require('../src/core/register/decorators');
+        vitest_1.vi.spyOn(packageModule, 'getPackages');
+        vitest_1.vi.spyOn(decoratorModule, 'registerHooks');
+        ({ dispatchEvent } = require('../src/core/event/dispatch'));
+    });
+    (0, vitest_1.it)('processa hooks de todos os packages e retorna o resultado final', async () => {
+        packageModule.getPackages.mockResolvedValue([
+            { folder: 'pkg1' },
+            { folder: 'pkg2' },
+        ]);
+        const hook1 = vitest_1.vi.fn(async (d) => ({ ...d, p1: true }));
+        const hook2 = vitest_1.vi.fn(async (d) => ({ ...d, p2: true }));
+        decoratorModule.registerHooks.mockImplementation(async (folder) => {
+            if (folder === 'pkg1')
+                return [{ event: 'test', call: hook1 }];
+            if (folder === 'pkg2')
+                return [{ event: 'test', call: hook2 }];
+            return [];
+        });
+        const result = await dispatchEvent('test', { base: true });
+        (0, vitest_1.expect)(result).toEqual({
+            base: true,
+            p1: true,
+            p2: true,
+        });
+    });
+    (0, vitest_1.it)('continua execução se um package falhar ao registrar hooks', async () => {
+        packageModule.getPackages.mockResolvedValue([
+            { folder: 'fail' },
+            { folder: 'ok' },
+        ]);
+        decoratorModule.registerHooks.mockImplementation(async (folder) => {
+            if (folder === 'fail')
+                throw new Error('Load error');
+            return [
+                {
+                    event: 'test',
+                    call: async (d) => ({ ...d, ok: true }),
+                },
+            ];
+        });
+        const result = await dispatchEvent('test', {});
+        (0, vitest_1.expect)(result).toEqual({ ok: true });
+    });
+    (0, vitest_1.it)('ignora hooks de outros eventos', async () => {
+        packageModule.getPackages.mockResolvedValue([{ folder: 'pkg' }]);
+        decoratorModule.registerHooks.mockResolvedValue([
+            { event: 'other', call: vitest_1.vi.fn() },
+            { event: 'test', call: async (d) => ({ ...d, hit: true }) },
+        ]);
+        const result = await dispatchEvent('test', {});
+        (0, vitest_1.expect)(result).toEqual({ hit: true });
+    });
+    (0, vitest_1.it)('ignora retorno null ou undefined do hook', async () => {
+        packageModule.getPackages.mockResolvedValue([{ folder: 'pkg' }]);
+        decoratorModule.registerHooks.mockResolvedValue([
+            { event: 'test', call: async () => null },
+        ]);
+        const result = await dispatchEvent('test', { base: true });
+        (0, vitest_1.expect)(result).toEqual({ base: true });
+    });
+});

package/dist/tests/hooks.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const { parseHook } = require('../src/core/parse/hooks');
+(0, vitest_1.describe)('parseHook', () => {
+    (0, vitest_1.it)('should return null if input is not a function', () => {
+        (0, vitest_1.expect)(parseHook('not a function')).toBeNull();
+    });
+    (0, vitest_1.it)('should parse a valid hook with conditions', () => {
+        const testHook = () => {
+            /**
+             * @register_hook user_login
+             * @only web
+             * @never mobile
+             * @when authenticated
+             */
+            return true;
+        };
+        const result = parseHook(testHook);
+        (0, vitest_1.expect)(result.event).toBe('user_login');
+        (0, vitest_1.expect)(result.condition.only).toContain('web');
+        (0, vitest_1.expect)(result.condition.never).toContain('mobile');
+        (0, vitest_1.expect)(result.condition.when).toContain('authenticated');
+    });
+    (0, vitest_1.it)('should return null if no register_hook decorator is found', () => {
+        const noHook = () => {
+            /** @description just a comment */
+        };
+        (0, vitest_1.expect)(parseHook(noHook)).toBeNull();
+    });
+});

package/dist/tests/middleware.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const { parseMiddleware } = require('../src/core/parse/middleware');
+(0, vitest_1.describe)('parseMiddleware', () => {
+    (0, vitest_1.it)('should parse middleware inside function body', () => {
+        const myMiddleware = () => {
+            /**
+             * @register_middleware checkLog
+             * @predicate is_admin
+             * @predicate is_owner
+             */
+        };
+        const result = parseMiddleware(myMiddleware);
+        (0, vitest_1.expect)(result.name).toBe('checkLog');
+        (0, vitest_1.expect)(result.predicates).toContain('is_admin');
+        (0, vitest_1.expect)(result.predicates).toContain('is_owner');
+    });
+});

package/dist/tests/predicates.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const { parsePredicate } = require('../src/core/parse/predicates');
+(0, vitest_1.describe)('parsePredicate', () => {
+    (0, vitest_1.it)('should parse predicate with custom name', () => {
+        const isAuth = () => {
+            /** @register_predicate auth_check */
+        };
+        const result = parsePredicate(isAuth);
+        (0, vitest_1.expect)(result.name).toBe('auth_check');
+    });
+    (0, vitest_1.it)('should use function name if decorator name is missing', () => {
+        function isAdmin() {
+            /** @register_predicate */
+        }
+        const result = parsePredicate(isAdmin);
+        (0, vitest_1.expect)(result.name).toBe('isAdmin');
+    });
+});

package/dist/tests/routes.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const { parseRouter } = require('../src/core/parse/routes');
+(0, vitest_1.describe)('parseRouter', () => {
+    (0, vitest_1.it)('should parse valid route decorators', () => {
+        const handler = () => {
+            /**
+             * @register_router /test
+             * @method POST
+             */
+        };
+        const result = parseRouter(handler);
+        (0, vitest_1.expect)(result.path).toBe('/test');
+        (0, vitest_1.expect)(result.method).toBe('post');
+    });
+    (0, vitest_1.it)('should default method to get', () => {
+        const handler = () => {
+            /**
+             * @register_router /simple
+             */
+        };
+        const result = parseRouter(handler);
+        (0, vitest_1.expect)(result.method).toBe('get');
+    });
+});

package/dist/tests/tools.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const { parseTool } = require('../src/core/parse/tools');
+(0, vitest_1.describe)('parseTool', () => {
+    (0, vitest_1.it)('should parse tool parameters and descriptions', () => {
+        function calculate(args) {
+            /**
+             * @register_tool calc
+             * @description useful tool
+             * @param {number} x - first number
+             * @param {number?} y - second optional number
+             */
+        }
+        const result = parseTool(calculate);
+        (0, vitest_1.expect)(result.name).toBe('calc');
+        (0, vitest_1.expect)(result.description).toBe('useful tool');
+        (0, vitest_1.expect)(result.parameters).toHaveLength(2);
+        (0, vitest_1.expect)(result.parameters[0].name).toBe('x');
+        (0, vitest_1.expect)(result.parameters[0].required).toBe(true);
+        (0, vitest_1.expect)(result.parameters[1].name).toBe('y');
+        (0, vitest_1.expect)(result.parameters[1].required).toBe(false);
+    });
+    (0, vitest_1.it)('should parse complex nested object parameters', () => {
+        const tool = () => {
+            /**
+             * @register_tool complex
+             * @param {string} user.name - name
+             * @param {number} user.age - age
+             */
+        };
+        const result = parseTool(tool);
+        const userParam = result.parameters.find(p => p.name === 'user');
+        (0, vitest_1.expect)(userParam).toBeDefined();
+        (0, vitest_1.expect)(userParam.type).toBe('object');
+        (0, vitest_1.expect)(result.parameters).toHaveLength(3);
+    });
+});

package/package.json

@@ -1,29 +1,30 @@
 {
   "name": "johankit-runtime",
-  "version": "0.0.2",
+  "version": "0.4.3",
   "description": "A pluggable runtime for any back-end",
-  "main": "src/index.js",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage"
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "dependencies": {
-    "express": "^5.2.1",
-    "js-yaml": "^4.1.0"
+    "@sveltejs/kit": "^2.49.4",
+    "express": "^4.22.1",
+    "js-yaml": "^4.1.0",
+    "mdsvex": "^0.12.6"
   },
   "devDependencies": {
-    "vitest": "latest",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "latest",
     "typescript": "^5.4.0",
-    "@types/node": "^20.0.0",
-    "@types/express": "^4.17.21"
-  },
-  "peerDependencies": {
-    "express": "^4.x"
+    "vitest": "latest"
   }
-}
+}

package/src/app.ts

@@ -1,18 +0,0 @@
-import express, { Application } from 'express'
-import { registerPackages } from './core/register'
-
-type JohankitApp = Application & {
-  setup: () => Promise<void>
-}
-
-const app = express() as Application
-
-;(app as JohankitApp).setup = async () => {
-  try {
-    await registerPackages(app)
-  } catch (error: any) {
-    console.log(`Error registering packages: ${error.message}`, 'error')
-  }
-}
-
-export default app as JohankitApp

package/src/core/event/dispatch.js

@@ -1,31 +0,0 @@
-const { registerHooks } = require('../register/decorators');
-const { getPackages } = require('../package');
-
-async function dispatchEvent(eventName, payload) {
-    const packages = await getPackages();
-    let finalResult = payload;
-
-    for (const pkg of packages) {
-        try {
-            const hooks = await registerHooks(pkg.folder);
-            const relevant = hooks.filter(h => h.event === eventName);
-
-            for (const hook of relevant) {
-                try {
-                    const result = await hook.call(finalResult);
-                    if (result !== undefined && result !== null) {
-                        finalResult = result;
-                    }
-                } catch (err) {
-                    console.warn(`[Hook Error] Package ${pkg.folder} failed on event ${eventName}:`, err.message);
-                }
-            }
-        } catch (err) {
-            continue;
-        }
-    }
-
-    return finalResult;
-}
-
-module.exports = { dispatchEvent };

package/src/core/mcp/http-server.js

@@ -1,52 +0,0 @@
-const express = require('express');
-const bodyParser = require('body-parser');
-const { bootstrapMcp } = require('./tools-mcp');
-
-async function createMcpHttpServer(options = {}) {
-  const app = express();
-  const port = options.port || 3333;
-  const workspace = options.workspace || process.env.PACKAGES_PATH;
-
-  if (!workspace) {
-    throw new Error('PACKAGES_PATH or workspace option is required');
-  }
-
-  const mcp = await bootstrapMcp(workspace);
-
-  app.use(bodyParser.json());
-
-  app.get('/mcp', (req, res) => {
-    res.json({ protocol: mcp.protocol, version: mcp.version });
-  });
-
-  app.get('/mcp/tools', (req, res) => {
-    try {
-      res.json(mcp.listTools());
-    } catch (err) {
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  app.post('/mcp/call', async (req, res) => {
-    const { name, args } = req.body || {};
-
-    if (!name) {
-      return res.status(400).json({ error: 'Tool name is required' });
-    }
-
-    try {
-      const result = await mcp.callTool(name, args || {});
-      res.json({ result });
-    } catch (err) {
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  const server = app.listen(port, () => {
-    console.log(`MCP HTTP server running on port ${port}`);
-  });
-
-  return { app, server, mcp };
-}
-
-module.exports = { createMcpHttpServer };

package/src/core/mcp/tools-mcp.js

@@ -1,50 +0,0 @@
-const { registerTools } = require('../register/decorators');
-
-function toolToMcp(tool) {
-  return {
-    name: tool.name,
-    description: tool.description || '',
-    inputSchema: tool.parameters || { type: 'object', properties: {} },
-    handler: async (args) => {
-      return await tool.call(args);
-    },
-    condition: tool.condition || null
-  };
-}
-
-async function loadMcpTools(agentFolder) {
-  const tools = await registerTools(agentFolder);
-  return tools.map(toolToMcp);
-}
-
-function createMcpServer(tools) {
-  return {
-    protocol: 'mcp',
-    version: '1.0.0',
-    listTools() {
-      return tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema
-      }));
-    },
-    async callTool(name, args) {
-      const tool = tools.find(t => t.name === name);
-      if (!tool) {
-        throw new Error(`Tool not found: ${name}`);
-      }
-      return await tool.handler(args);
-    }
-  };
-}
-
-async function bootstrapMcp(agentFolder) {
-  const tools = await loadMcpTools(agentFolder);
-  return createMcpServer(tools);
-}
-
-module.exports = {
-  loadMcpTools,
-  createMcpServer,
-  bootstrapMcp
-};

package/src/core/package.js

@@ -1,79 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const { log } = console;
-
-async function getPackage(folderName) {
-  try {
-    const pluginsPath = process.env.PACKAGES_PATH || path.join(__dirname, '..', 'packages');
-    const manifestPath = path.join(pluginsPath, folderName, 'package.json');
-    
-    let manifest = {};
-    
-    try {
-      if (fs.existsSync(manifestPath)) {
-        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-      }
-    } catch (error) {
-      console.error(`Manifest not found in ${folderName}:`, error);
-      throw new Error(`Manifest not found in folder ${folderName}`);
-    }
-
-    return {
-      ...manifest,
-      folder: folderName,
-    };
-  } catch (error) {
-    throw error;
-  }
-}
-
-async function getPackages() {
-  try {
-    const pluginsPath = process.env.PACKAGES_PATH || path.join(__dirname, '..', 'packages');
-    const pluginFolders = fs.readdirSync(pluginsPath).filter(f => fs.statSync(path.join(pluginsPath, f)).isDirectory());
-
-    const folderPackages = await Promise.all(pluginFolders.map(async folderName => {
-      return await getPackage(folderName);
-    }));
-
-    return folderPackages;
-  } catch (error) {
-    throw error;
-  }
-}
-
-const registerPackage = async (app, pkg) => {
-  const basePackagesPath = process.env.PACKAGES_PATH || path.join(__dirname, '..', 'packages');
-  const packageDir = path.join(basePackagesPath, pkg.folder);
-  const manifestPath = path.join(packageDir, 'package.json');
-  pkg.dir = packageDir;
-
-  try {
-      if (!fs.existsSync(manifestPath)) {
-          return;
-      }
-
-      if (!fs.existsSync(path.join(packageDir, 'routes.js'))) {
-          return;
-      }
-
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-      const usePackage = manifest.entry ? require(path.join(packageDir, manifest.entry)) : () => { };
-
-      if (typeof usePackage !== 'function') {
-          log(`${pkg.name} invalid entry point. Expected a function.`, 'error');
-          return;
-      }
-
-      const packg = usePackage(app) ?? usePackage;
-      packg?.setup && packg.setup();
-
-      log(`${pkg.name} ${pkg.version ? `version ${pkg.version}` : ''} is running.\n`);
-  } catch (error) {
-      log(`Error with package ${pkg.name}: ${error.message}`, 'error');
-      log(`${pkg.name} ${pkg.version ? `version ${pkg.version}` : ''} isn't running.\n`);
-  }
-};
-
-module.exports = { getPackage, getPackages, registerPackage };

package/src/core/parse/hooks.js

@@ -1,37 +0,0 @@
-function parseHook(fn) {
-  if (typeof fn !== 'function') return null;
-
-  const fnStr = fn.toString();
-  const docMatch = fnStr.match(/\/\*\*([\s\S]*?)\*\//);
-  if (!docMatch) return null;
-
-  const doc = docMatch[1];
-
-  const hookMatch = doc.match(/@register_hook\s+([^\s]+)/);
-  if (!hookMatch) return null;
-
-  const event = hookMatch[1].trim();
-
-  const condition = { only: [], never: [], when: [] };
-
-  const onlyMatches = [...doc.matchAll(/@only\s+([^\s]+)/g)];
-  onlyMatches.forEach(m => condition.only.push(m[1]));
-
-  const neverMatches = [...doc.matchAll(/@never\s+([^\s]+)/g)];
-  neverMatches.forEach(m => condition.never.push(m[1]));
-
-  const whenMatches = [...doc.matchAll(/@when\s+([^\s]+)/g)];
-  whenMatches.forEach(m => condition.when.push(m[1]));
-
-  Object.keys(condition).forEach(k => {
-    if (condition[k].length === 0) delete condition[k];
-  });
-
-  return {
-    event,
-    call: fn,
-    condition
-  };
-}
-
-module.exports = { parseHook };

package/src/core/parse/tools.js

@@ -1,82 +0,0 @@
-function parseTool(fn) {
-  const meta = {
-    name: fn.name || null,
-    description: null,
-    parameters: [],
-    call: fn,
-    condition: { only: [], never: [], when: [] }
-  };
-
-  const fnString = fn.toString();
-  const jsdocMatch = fnString.match(/\/\*\*([\s\S]*?)\*\//);
-  if (!jsdocMatch) return null;
-
-  const lines = jsdocMatch[1].split('\n').map(l => l.trim().replace(/^\*\s?/, ''));
-
-  const registerLine = lines.find(l => l.startsWith('@register_tool'));
-  if (!registerLine) return null;
-
-  const registerMatch = registerLine.match(/@register_tool\s*(\S+)?/);
-  if (registerMatch && registerMatch[1]) {
-    meta.name = registerMatch[1];
-  } else if (!meta.name) {
-    meta.name = 'anonymousTool';
-  }
-
-  const paramMap = {};
-
-  const descriptionLine = lines.find(l => l.startsWith('@description'));
-  if (descriptionLine) meta.description = descriptionLine.replace('@description', '').trim();
-
-  lines.forEach(line => {
-    if (line.startsWith('@param')) {
-      const match = line.match(/@param {([\w\[\]\?]+)} (\S+) - (.+)/);
-      if (!match) return;
-
-      let [_, type, name, description] = match;
-      let required = !type.endsWith('?');
-      if (!required) type = type.slice(0, -1);
-
-      const cleanName = name.replace(/\[\]/g, '');
-      const isArray = name.includes('[]');
-      const isNested = cleanName.includes('.');
-
-      if (isNested) {
-        const parentName = cleanName.split('.')[0];
-        if (!paramMap[parentName]) {
-          const parent = {
-            name: parentName,
-            type: isArray ? 'array' : 'object',
-            description: `${parentName} object`,
-            required
-          };
-          meta.parameters.push(parent);
-          paramMap[parentName] = parent;
-        } else if (required) {
-          paramMap[parentName].required = true;
-        }
-      }
-
-      const param = { name, type, description, required };
-      meta.parameters.push(param);
-      paramMap[name] = param;
-    }
-
-    const onlyMatch = line.match(/@only\s+([^\s]+)/);
-    if (onlyMatch) meta.condition.only.push(onlyMatch[1]);
-
-    const neverMatch = line.match(/@never\s+([^\s]+)/);
-    if (neverMatch) meta.condition.never.push(neverMatch[1]);
-
-    const whenMatch = line.match(/@when\s+([^\s]+)/);
-    if (whenMatch) meta.condition.when.push(whenMatch[1]);
-  });
-
-  Object.keys(meta.condition).forEach(k => {
-    if (meta.condition[k].length === 0) delete meta.condition[k];
-  });
-
-  return meta;
-}
-
-module.exports = { parseTool };