te.js 2.1.6 → 2.2.0

package/cors/index.test.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Tests for CORS middleware.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import corsMiddleware from './index.js';
+
+function makeAmmo(method = 'GET', origin = 'https://example.com') {
+  const headers = {};
+  return {
+    req: { method, headers: { origin } },
+    res: {
+      _headers: {},
+      setHeader(name, value) {
+        this._headers[name.toLowerCase()] = value;
+      },
+      writeHead(code) {
+        this._status = code;
+      },
+      end() {
+        this._ended = true;
+      },
+    },
+  };
+}
+
+describe('corsMiddleware', () => {
+  it('should set Access-Control-Allow-Origin to * by default', async () => {
+    const mw = corsMiddleware();
+    const ammo = makeAmmo();
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._headers['access-control-allow-origin']).toBe('*');
+    expect(next).toHaveBeenCalled();
+  });
+
+  it('should respond 204 and not call next for OPTIONS preflight', async () => {
+    const mw = corsMiddleware();
+    const ammo = makeAmmo('OPTIONS');
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._status).toBe(204);
+    expect(ammo.res._ended).toBe(true);
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('should allow specific origin from array', async () => {
+    const mw = corsMiddleware({ origin: ['https://example.com'] });
+    const ammo = makeAmmo('GET', 'https://example.com');
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._headers['access-control-allow-origin']).toBe(
+      'https://example.com',
+    );
+  });
+
+  it('should block origins not in array', async () => {
+    const mw = corsMiddleware({ origin: ['https://example.com'] });
+    const ammo = makeAmmo('GET', 'https://evil.com');
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._headers['access-control-allow-origin']).toBeUndefined();
+  });
+
+  it('should set Access-Control-Max-Age when maxAge provided', async () => {
+    const mw = corsMiddleware({ maxAge: 86400 });
+    const ammo = makeAmmo();
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._headers['access-control-max-age']).toBe('86400');
+  });
+
+  it('should set Access-Control-Allow-Credentials when credentials=true', async () => {
+    const mw = corsMiddleware({
+      credentials: true,
+      origin: 'https://example.com',
+    });
+    const ammo = makeAmmo('GET', 'https://example.com');
+    const next = vi.fn();
+    await mw(ammo, next);
+    expect(ammo.res._headers['access-control-allow-credentials']).toBe('true');
+  });
+});

package/database/index.js

@@ -15,7 +15,9 @@ class DatabaseManager {
 
   // Helper method for sleeping
   async #sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    const { promise, resolve } = Promise.withResolvers();
+    setTimeout(resolve, ms);
+    return promise;
   }
 
   constructor() {

package/database/mongodb.js

@@ -1,7 +1,7 @@
-import { spawn } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import TejLogger from 'tej-logger';
 import TejError from '../server/error.js';
 
@@ -10,7 +10,7 @@ const __dirname = path.dirname(__filename);
 
 const logger = new TejLogger('MongoDBConnectionManager');
 
-function checkMongooseInstallation() {
+async function checkMongooseInstallation() {
   const packageJsonPath = path.join(__dirname, '..', 'package.json');
   const nodeModulesPath = path.join(
     __dirname,
@@ -20,12 +20,18 @@ function checkMongooseInstallation() {
   );
 
   try {
-    // Check if mongoose exists in package.json
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const packageJson = JSON.parse(
+      await fs.promises.readFile(packageJsonPath, 'utf8'),
+    );
     const inPackageJson = !!packageJson.dependencies?.mongoose;
 
-    // Check if mongoose exists in node_modules
-    const inNodeModules = fs.existsSync(nodeModulesPath);
+    let inNodeModules = false;
+    try {
+      await fs.promises.access(nodeModulesPath);
+      inNodeModules = true;
+    } catch {
+      inNodeModules = false;
+    }
 
     return {
       needsInstall: !inPackageJson || !inNodeModules,
@@ -94,7 +100,7 @@ function installMongooseSync() {
  * @returns {Promise<mongoose.Connection>} Mongoose connection instance
  */
 async function createConnection(config) {
-  const { needsInstall } = checkMongooseInstallation();
+  const { needsInstall } = await checkMongooseInstallation();
 
   if (needsInstall) {
     const installed = installMongooseSync();
@@ -106,7 +112,7 @@ async function createConnection(config) {
   const { uri, options = {} } = config;
 
   try {
-    const mongoose = await import('mongoose').then((mod) => mod.default);
+    const { default: mongoose } = await import('mongoose');
     const connection = await mongoose.createConnection(uri, options);
 
     connection.on('error', (err) =>

package/database/redis.js

@@ -1,6 +1,6 @@
-import { spawnSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import TejError from '../server/error.js';
 import TejLogger from 'tej-logger';
 import { pathToFileURL } from 'node:url';
@@ -10,14 +10,20 @@ const packagePath = `${process.cwd()}/node_modules/redis/dist/index.js`;
 
 const logger = new TejLogger('RedisConnectionManager');
 
-function checkRedisInstallation() {
+async function checkRedisInstallation() {
   try {
-    // Check if redis exists in package.json
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const packageJson = JSON.parse(
+      await fs.promises.readFile(packageJsonPath, 'utf8'),
+    );
     const inPackageJson = !!packageJson.dependencies?.redis;
 
-    // Check if redis exists in node_modules
-    const inNodeModules = fs.existsSync(packagePath);
+    let inNodeModules = false;
+    try {
+      await fs.promises.access(packagePath);
+      inNodeModules = true;
+    } catch {
+      inNodeModules = false;
+    }
 
     return {
       needsInstall: !inPackageJson || !inNodeModules,
@@ -87,7 +93,7 @@ function installRedisSync() {
  * @returns {Promise<RedisClient|RedisCluster>} Redis client or cluster instance
  */
 async function createConnection(config) {
-  const { needsInstall } = checkRedisInstallation();
+  const { needsInstall } = await checkRedisInstallation();
 
   if (needsInstall) {
     const installed = installRedisSync();
@@ -119,46 +125,49 @@ async function createConnection(config) {
     let connectionAttempts = 0;
     const maxRetries = options.maxRetries || 3;
 
-    // Create a promise that will resolve when connected or reject on fatal errors
-    const connectionPromise = new Promise((resolve, reject) => {
-      connectionTimeout = setTimeout(() => {
-        if (!hasConnected) {
-          client.quit().catch(() => {});
-          reject(new TejError(500, 'Redis connection timeout'));
-        }
-      }, options.connectTimeout || 10000);
-
-      client.on('error', (err) => {
-        logger.error(`Redis connection error: ${err}`, true);
-        if (!hasConnected && connectionAttempts >= maxRetries) {
-          clearTimeout(connectionTimeout);
-          client.quit().catch(() => {});
-          reject(
-            new TejError(
-              500,
-              `Redis connection failed after ${maxRetries} attempts: ${err.message}`,
-            ),
-          );
-        }
-        connectionAttempts++;
-      });
+    const {
+      promise: connectionPromise,
+      resolve: resolveConnection,
+      reject: rejectConnection,
+    } = Promise.withResolvers();
 
-      client.on('connect', () => {
-        hasConnected = true;
+    connectionTimeout = setTimeout(() => {
+      if (!hasConnected) {
+        client.quit().catch(() => {});
+        rejectConnection(new TejError(500, 'Redis connection timeout'));
+      }
+    }, options.connectTimeout || 10000);
+
+    client.on('error', (err) => {
+      logger.error(`Redis connection error: ${err}`, true);
+      if (!hasConnected && connectionAttempts >= maxRetries) {
         clearTimeout(connectionTimeout);
-        logger.info(
-          `Redis connected on ${client?.options?.url ?? client?.options?.socket?.host}`,
+        client.quit().catch(() => {});
+        rejectConnection(
+          new TejError(
+            500,
+            `Redis connection failed after ${maxRetries} attempts: ${err.message}`,
+          ),
         );
-      });
+      }
+      connectionAttempts++;
+    });
 
-      client.on('ready', () => {
-        logger.info('Redis ready');
-        resolve(client);
-      });
+    client.on('connect', () => {
+      hasConnected = true;
+      clearTimeout(connectionTimeout);
+      logger.info(
+        `Redis connected on ${client?.options?.url ?? client?.options?.socket?.host}`,
+      );
+    });
 
-      client.on('end', () => {
-        logger.info('Redis connection closed');
-      });
+    client.on('ready', () => {
+      logger.info('Redis ready');
+      resolveConnection(client);
+    });
+
+    client.on('end', () => {
+      logger.info('Redis connection closed');
     });
 
     await client.connect();

package/lib/llm/client.js

@@ -20,7 +20,7 @@ class LLMProvider {
       typeof options.timeout === 'number' && options.timeout > 0
         ? options.timeout
         : DEFAULT_TIMEOUT;
-    this.options = options;
+    this.options = Object.freeze({ ...options });
   }
 
   /**
@@ -30,6 +30,11 @@ class LLMProvider {
    * @returns {Promise<{ content: string, usage: { prompt_tokens: number, completion_tokens: number, total_tokens: number } }>}
    */
   async analyze(prompt) {
+    if (!prompt || typeof prompt !== 'string') {
+      throw new TypeError(
+        'LLMProvider.analyze: prompt must be a non-empty string',
+      );
+    }
     const url = `${this.baseURL}/chat/completions`;
     const headers = {
       'Content-Type': 'application/json',

package/lib/llm/index.js

@@ -3,5 +3,18 @@
  * Used by auto-docs, error-inference, and future LLM features.
  */
 
+/**
+ * OpenAI-compatible LLM client.
+ * @see {@link ./client.js}
+ */
 export { LLMProvider, createProvider } from './client.js';
-export { extractJSON, extractJSONArray, reconcileOrderedTags } from './parse.js';
+
+/**
+ * JSON parsing utilities for LLM responses.
+ * @see {@link ./parse.js}
+ */
+export {
+  extractJSON,
+  extractJSONArray,
+  reconcileOrderedTags,
+} from './parse.js';

package/lib/llm/parse.test.js

@@ -0,0 +1,60 @@
+/**
+ * Unit tests for lib/llm parse utilities (extractJSON, extractJSONArray, reconcileOrderedTags).
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  extractJSON,
+  extractJSONArray,
+  reconcileOrderedTags,
+} from './index.js';
+
+describe('llm/parse', () => {
+  describe('extractJSON', () => {
+    it('extracts object from plain JSON string', () => {
+      const str = '{"name":"Users","description":"CRUD"}';
+      expect(extractJSON(str)).toEqual({ name: 'Users', description: 'CRUD' });
+    });
+    it('extracts first object from text with markdown', () => {
+      const str = 'Here is the result:\n```json\n{"summary":"Get item"}\n```';
+      expect(extractJSON(str)).toEqual({ summary: 'Get item' });
+    });
+    it('returns null for empty or no object', () => {
+      expect(extractJSON('')).toBeNull();
+      expect(extractJSON('no brace here')).toBeNull();
+    });
+  });
+
+  describe('extractJSONArray', () => {
+    it('extracts array from string', () => {
+      const str = '["Users", "Auth", "Health"]';
+      expect(extractJSONArray(str)).toEqual(['Users', 'Auth', 'Health']);
+    });
+    it('returns null when no array', () => {
+      expect(extractJSONArray('')).toBeNull();
+      expect(extractJSONArray('nothing')).toBeNull();
+    });
+  });
+
+  describe('reconcileOrderedTags', () => {
+    it('reorders tags by orderedTagNames', () => {
+      const tags = [
+        { name: 'Health', description: '...' },
+        { name: 'Users', description: '...' },
+        { name: 'Auth', description: '...' },
+      ];
+      const ordered = reconcileOrderedTags(['Users', 'Auth', 'Health'], tags);
+      expect(ordered.map((t) => t.name)).toEqual(['Users', 'Auth', 'Health']);
+    });
+    it('appends tags not in orderedTagNames', () => {
+      const tags = [{ name: 'Users' }, { name: 'Other' }];
+      const ordered = reconcileOrderedTags(['Users'], tags);
+      expect(ordered.map((t) => t.name)).toEqual(['Users', 'Other']);
+    });
+    it('returns copy of tags when orderedTagNames empty', () => {
+      const tags = [{ name: 'A' }];
+      const ordered = reconcileOrderedTags([], tags);
+      expect(ordered).toEqual([{ name: 'A' }]);
+      expect(ordered).not.toBe(tags);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "te.js",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "description": "AI Native Node.js Framework",
   "type": "module",
   "main": "te.js",
@@ -18,6 +18,7 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "^20.12.5",
+    "@vitest/coverage-v8": "^4.0.18",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
     "prettier": "3.2.5",
@@ -31,6 +32,7 @@
     "te.js",
     "cli",
     "cors",
+    "radar",
     "server",
     "database",
     "rate-limit",