te.js 2.1.0 → 2.1.2

package/cli/fly-command.js

@@ -1,71 +1,71 @@
-/**
- * `tejas fly` — start the Tejas server by running the user's entry point.
- * Entry point is resolved in order: CLI arg → tejas.config.json "entry" → package.json "main" → index.js → app.js → server.js
- */
-
-import path from 'node:path';
-import fs from 'node:fs';
-import { spawn } from 'node:child_process';
-import { loadConfigFile } from '../utils/configuration.js';
-
-const CONVENTION_FILES = ['index.js', 'app.js', 'server.js'];
-
-function resolveEntryPoint(cliArg) {
-  const cwd = process.cwd();
-
-  if (cliArg) {
-    const candidate = path.isAbsolute(cliArg) ? cliArg : path.join(cwd, cliArg);
-    if (fs.existsSync(candidate)) return candidate;
-    throw new Error(`Entry file not found: ${cliArg}`);
-  }
-
-  const config = loadConfigFile();
-  if (config.entry) {
-    const candidate = path.join(cwd, config.entry);
-    if (fs.existsSync(candidate)) return candidate;
-    throw new Error(`Entry file from tejas.config.json not found: ${config.entry}`);
-  }
-
-  try {
-    const pkgPath = path.join(cwd, 'package.json');
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    if (pkg.main) {
-      const candidate = path.join(cwd, pkg.main);
-      if (fs.existsSync(candidate)) return candidate;
-      throw new Error(`Entry file from package.json "main" not found: ${pkg.main}`);
-    }
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      // no package.json, continue to convention
-    } else {
-      throw err;
-    }
-  }
-
-  for (const name of CONVENTION_FILES) {
-    const candidate = path.join(cwd, name);
-    if (fs.existsSync(candidate)) return candidate;
-  }
-
-  throw new Error(
-    `Could not resolve entry point. Set "entry" in tejas.config.json, "main" in package.json, pass a file (tejas fly <file>), or add index.js, app.js, or server.js in ${cwd}`,
-  );
-}
-
-/**
- * Resolves the entry point and spawns the server process. Exits with the child's exit code.
- */
-export function runFlyCommand() {
-  const cliArg = process.argv[3]; // tejas fly [file]
-  const entryFile = resolveEntryPoint(cliArg);
-
-  const child = spawn(process.execPath, [entryFile], {
-    stdio: 'inherit',
-    cwd: process.cwd(),
-    env: process.env,
-  });
-
-  child.on('exit', (code, signal) => {
-    process.exit(code ?? (signal ? 1 : 0));
-  });
-}
+/**
+ * `tejas fly` — start the Tejas server by running the user's entry point.
+ * Entry point is resolved in order: CLI arg → tejas.config.json "entry" → package.json "main" → index.js → app.js → server.js
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { loadConfigFile } from '../utils/configuration.js';
+
+const CONVENTION_FILES = ['index.js', 'app.js', 'server.js'];
+
+function resolveEntryPoint(cliArg) {
+  const cwd = process.cwd();
+
+  if (cliArg) {
+    const candidate = path.isAbsolute(cliArg) ? cliArg : path.join(cwd, cliArg);
+    if (fs.existsSync(candidate)) return candidate;
+    throw new Error(`Entry file not found: ${cliArg}`);
+  }
+
+  const config = loadConfigFile();
+  if (config.entry) {
+    const candidate = path.join(cwd, config.entry);
+    if (fs.existsSync(candidate)) return candidate;
+    throw new Error(`Entry file from tejas.config.json not found: ${config.entry}`);
+  }
+
+  try {
+    const pkgPath = path.join(cwd, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (pkg.main) {
+      const candidate = path.join(cwd, pkg.main);
+      if (fs.existsSync(candidate)) return candidate;
+      throw new Error(`Entry file from package.json "main" not found: ${pkg.main}`);
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      // no package.json, continue to convention
+    } else {
+      throw err;
+    }
+  }
+
+  for (const name of CONVENTION_FILES) {
+    const candidate = path.join(cwd, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  throw new Error(
+    `Could not resolve entry point. Set "entry" in tejas.config.json, "main" in package.json, pass a file (tejas fly <file>), or add index.js, app.js, or server.js in ${cwd}`,
+  );
+}
+
+/**
+ * Resolves the entry point and spawns the server process. Exits with the child's exit code.
+ */
+export function runFlyCommand() {
+  const cliArg = process.argv[3]; // tejas fly [file]
+  const entryFile = resolveEntryPoint(cliArg);
+
+  const child = spawn(process.execPath, [entryFile], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: process.env,
+  });
+
+  child.on('exit', (code, signal) => {
+    process.exit(code ?? (signal ? 1 : 0));
+  });
+}

package/cli/index.js

@@ -1,57 +1,57 @@
 #!/usr/bin/env node
-
-/**
- * CLI entry point for te.js (tejas).
- * Usage: tejas fly [file] | tejas generate:docs [--ci] | tejas docs:on-push
- */
-
-import { runDocsCommand, runDocsCommandCI, runDocsOnPush } from './docs-command.js';
-import { runFlyCommand } from './fly-command.js';
-
-const command = process.argv[2];
-const ciFlag = process.argv.includes('--ci');
-
-if (command === 'fly') {
-  try {
-    runFlyCommand();
-  } catch (err) {
-    console.error(err?.message ?? err);
-    process.exit(1);
-  }
-} else if (command === 'docs:on-push') {
-  runDocsOnPush().catch((err) => {
-    console.error(err?.message ?? err);
-    process.exit(1);
-  });
-} else if (command === 'generate:docs') {
-  if (ciFlag) {
-    runDocsCommandCI().catch((err) => {
-      console.error(err?.message ?? err);
-      process.exit(1);
-    });
-  } else {
-    runDocsCommand().catch((err) => {
-      console.error(err?.message ?? err);
-      process.exit(1);
-    });
-  }
-} else {
-  console.log(`
-tejas - te.js framework CLI
-
-Usage: tejas <command> [options]
-
-Commands:
-  fly [file]             Start the Tejas server
-  generate:docs [--ci]   OpenAPI documentation generator (interactive or CI mode)
-  docs:on-push           Generate docs when pushing to production branch (use in pre-push hook)
-
-Examples:
-  tejas fly
-  tejas fly index.js
-  tejas generate:docs
-  tejas generate:docs --ci
-  tejas docs:on-push
-`);
-  process.exit(command ? 1 : 0);
-}
+
+/**
+ * CLI entry point for te.js (tejas).
+ * Usage: tejas fly [file] | tejas generate:docs [--ci] | tejas docs:on-push
+ */
+
+import { runDocsCommand, runDocsCommandCI, runDocsOnPush } from './docs-command.js';
+import { runFlyCommand } from './fly-command.js';
+
+const command = process.argv[2];
+const ciFlag = process.argv.includes('--ci');
+
+if (command === 'fly') {
+  try {
+    runFlyCommand();
+  } catch (err) {
+    console.error(err?.message ?? err);
+    process.exit(1);
+  }
+} else if (command === 'docs:on-push') {
+  runDocsOnPush().catch((err) => {
+    console.error(err?.message ?? err);
+    process.exit(1);
+  });
+} else if (command === 'generate:docs') {
+  if (ciFlag) {
+    runDocsCommandCI().catch((err) => {
+      console.error(err?.message ?? err);
+      process.exit(1);
+    });
+  } else {
+    runDocsCommand().catch((err) => {
+      console.error(err?.message ?? err);
+      process.exit(1);
+    });
+  }
+} else {
+  console.log(`
+tejas - te.js framework CLI
+
+Usage: tejas <command> [options]
+
+Commands:
+  fly [file]             Start the Tejas server
+  generate:docs [--ci]   OpenAPI documentation generator (interactive or CI mode)
+  docs:on-push           Generate docs when pushing to production branch (use in pre-push hook)
+
+Examples:
+  tejas fly
+  tejas fly index.js
+  tejas generate:docs
+  tejas generate:docs --ci
+  tejas docs:on-push
+`);
+  process.exit(command ? 1 : 0);
+}

package/cors/index.js

@@ -0,0 +1,71 @@
+/**
+ * CORS middleware factory. Handles OPTIONS preflight with 204 and sets CORS response headers.
+ *
+ * @param {Object} config - CORS configuration
+ * @param {string|string[]|((origin: string) => boolean)} [config.origin='*'] - Allowed origin(s): '*' or array of origins or function
+ * @param {string[]} [config.methods=['GET','POST','PUT','DELETE','PATCH','HEAD','OPTIONS']] - Allowed methods for Access-Control-Allow-Methods
+ * @param {string[]} [config.allowedHeaders=['Content-Type','Authorization']] - Allowed request headers for Access-Control-Allow-Headers
+ * @param {boolean} [config.credentials=false] - Access-Control-Allow-Credentials (use with specific origin, not '*')
+ * @param {number} [config.maxAge] - Access-Control-Max-Age in seconds for preflight cache
+ * @returns {Function} Middleware (ammo, next)
+ */
+function corsMiddleware(config = {}) {
+  const {
+    origin = '*',
+    methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+    allowedHeaders = ['Content-Type', 'Authorization'],
+    credentials = false,
+    maxAge,
+  } = config;
+
+  const methodsList = Array.isArray(methods)
+    ? methods.map((m) => String(m).toUpperCase()).join(', ')
+    : String(methods);
+  const headersList = Array.isArray(allowedHeaders)
+    ? allowedHeaders.join(', ')
+    : String(allowedHeaders);
+
+  const resolveOrigin = (requestOrigin) => {
+    if (typeof origin === 'function') {
+      return origin(requestOrigin) ? requestOrigin || '*' : null;
+    }
+    if (origin === '*') {
+      return credentials ? (requestOrigin || '*') : '*';
+    }
+    if (Array.isArray(origin)) {
+      const normalized = (requestOrigin || '').toLowerCase();
+      const allowed = origin.some(
+        (o) => String(o).toLowerCase() === normalized,
+      );
+      return allowed ? requestOrigin : null;
+    }
+    return String(origin) === (requestOrigin || '') ? requestOrigin : null;
+  };
+
+  return async (ammo, next) => {
+    const requestOrigin = ammo.req.headers.origin;
+
+    const allowOrigin = resolveOrigin(requestOrigin);
+    if (allowOrigin != null) {
+      ammo.res.setHeader('Access-Control-Allow-Origin', allowOrigin);
+    }
+    ammo.res.setHeader('Access-Control-Allow-Methods', methodsList);
+    ammo.res.setHeader('Access-Control-Allow-Headers', headersList);
+    if (credentials) {
+      ammo.res.setHeader('Access-Control-Allow-Credentials', 'true');
+    }
+    if (maxAge != null && Number.isFinite(maxAge)) {
+      ammo.res.setHeader('Access-Control-Max-Age', String(maxAge));
+    }
+
+    if (ammo.req.method === 'OPTIONS') {
+      ammo.res.writeHead(204);
+      ammo.res.end();
+      return;
+    }
+
+    await next();
+  };
+}
+
+export default corsMiddleware;

package/database/index.js

@@ -1,165 +1,165 @@
-import redis from './redis.js';
-import mongodb from './mongodb.js';
-import TejError from '../server/error.js';
-import TejLogger from 'tej-logger';
-
-const logger = new TejLogger('DatabaseManager');
-
-class DatabaseManager {
-  static #instance = null;
-  static #isInitializing = false;
-
-  // Enhanced connection tracking with metadata
-  #connections = new Map();
-  #initializingConnections = new Map();
-
-  // Helper method for sleeping
-  async #sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  constructor() {
-    if (DatabaseManager.#instance) {
-      return DatabaseManager.#instance;
-    }
-
-    if (!DatabaseManager.#isInitializing) {
-      throw new TejError(
-        500,
-        'Use DatabaseManager.getInstance() to get the instance',
-      );
-    }
-
-    DatabaseManager.#isInitializing = false;
-    DatabaseManager.#instance = this;
-  }
-
-  static getInstance() {
-    if (!DatabaseManager.#instance) {
-      DatabaseManager.#isInitializing = true;
-      DatabaseManager.#instance = new DatabaseManager();
-    }
-    return DatabaseManager.#instance;
-  }
-
-  async initializeConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-
-    // If a connection already exists for this config, return it
-    if (this.#connections.has(key)) {
-      return this.#connections.get(key).client;
-    }
-
-    // Set initializing flag
-    this.#initializingConnections.set(key, true);
-
-    let client;
-    try {
-      switch (key) {
-        case 'redis':
-          client = await redis.createConnection({
-            isCluster: config.isCluster || false,
-            options: config || {},
-          });
-          break;
-        case 'mongodb':
-          client = await mongodb.createConnection(config);
-          break;
-        default:
-          throw new TejError(400, `Unsupported database type: ${dbType}`);
-      }
-
-      this.#connections.set(key, {
-        type: dbType,
-        client,
-        config,
-      });
-
-      // Clear initializing flag
-      this.#initializingConnections.delete(key);
-
-      return client;
-    } catch (error) {
-      // Clear initializing flag on error
-      this.#initializingConnections.delete(key);
-      logger.error(`Failed to initialize ${dbType} connection:`, error);
-      throw error;
-    }
-  }
-
-  getConnection(dbType) {
-    const key = dbType.toLowerCase();
-    const connection = this.#connections.get(key);
-    if (!connection) {
-      throw new TejError(
-        404,
-        `No connection found for ${dbType} with given config`,
-      );
-    }
-    return connection.client;
-  }
-
-  async closeConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-    if (!this.#connections.has(key)) {
-      return;
-    }
-
-    try {
-      const connection = this.#connections.get(key);
-      switch (key) {
-        case 'redis':
-          await redis.closeConnection(connection.client);
-          break;
-        case 'mongodb':
-          await mongodb.closeConnection(connection.client);
-          break;
-      }
-
-      this.#connections.delete(key);
-    } catch (error) {
-      logger.error(`Error closing ${dbType} connection:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Close all database connections
-   * @returns {Promise<void>}
-   */
-  async closeAllConnections() {
-    const closePromises = [];
-    for (const [key, connection] of this.#connections) {
-      closePromises.push(
-        this.closeConnection(connection.type, connection.config),
-      );
-    }
-    await Promise.all(closePromises);
-    this.#connections.clear();
-  }
-
-  /**
-   * Get all active connections
-   * @returns {Map<string, {type: string, client: any, config: Object}>}
-   */
-  getActiveConnections() {
-    return new Map(this.#connections);
-  }
-
-  /**
-   * Check if a connection exists or is being initialized
-   * @param {string} dbType - Type of database
-   * @param {Object} config - Database configuration
-   * @returns {{ exists: boolean, initializing: boolean }}
-   */
-  hasConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-    return {
-      exists: this.#connections.has(key),
-      initializing: this.#initializingConnections.has(key),
-    };
-  }
-}
-
-const dbManager = DatabaseManager.getInstance();
-export default dbManager;
+import redis from './redis.js';
+import mongodb from './mongodb.js';
+import TejError from '../server/error.js';
+import TejLogger from 'tej-logger';
+
+const logger = new TejLogger('DatabaseManager');
+
+class DatabaseManager {
+  static #instance = null;
+  static #isInitializing = false;
+
+  // Enhanced connection tracking with metadata
+  #connections = new Map();
+  #initializingConnections = new Map();
+
+  // Helper method for sleeping
+  async #sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  constructor() {
+    if (DatabaseManager.#instance) {
+      return DatabaseManager.#instance;
+    }
+
+    if (!DatabaseManager.#isInitializing) {
+      throw new TejError(
+        500,
+        'Use DatabaseManager.getInstance() to get the instance',
+      );
+    }
+
+    DatabaseManager.#isInitializing = false;
+    DatabaseManager.#instance = this;
+  }
+
+  static getInstance() {
+    if (!DatabaseManager.#instance) {
+      DatabaseManager.#isInitializing = true;
+      DatabaseManager.#instance = new DatabaseManager();
+    }
+    return DatabaseManager.#instance;
+  }
+
+  async initializeConnection(dbType, config) {
+    const key = dbType.toLowerCase();
+
+    // If a connection already exists for this config, return it
+    if (this.#connections.has(key)) {
+      return this.#connections.get(key).client;
+    }
+
+    // Set initializing flag
+    this.#initializingConnections.set(key, true);
+
+    let client;
+    try {
+      switch (key) {
+        case 'redis':
+          client = await redis.createConnection({
+            isCluster: config.isCluster || false,
+            options: config || {},
+          });
+          break;
+        case 'mongodb':
+          client = await mongodb.createConnection(config);
+          break;
+        default:
+          throw new TejError(400, `Unsupported database type: ${dbType}`);
+      }
+
+      this.#connections.set(key, {
+        type: dbType,
+        client,
+        config,
+      });
+
+      // Clear initializing flag
+      this.#initializingConnections.delete(key);
+
+      return client;
+    } catch (error) {
+      // Clear initializing flag on error
+      this.#initializingConnections.delete(key);
+      logger.error(`Failed to initialize ${dbType} connection:`, error);
+      throw error;
+    }
+  }
+
+  getConnection(dbType) {
+    const key = dbType.toLowerCase();
+    const connection = this.#connections.get(key);
+    if (!connection) {
+      throw new TejError(
+        404,
+        `No connection found for ${dbType} with given config`,
+      );
+    }
+    return connection.client;
+  }
+
+  async closeConnection(dbType, config) {
+    const key = dbType.toLowerCase();
+    if (!this.#connections.has(key)) {
+      return;
+    }
+
+    try {
+      const connection = this.#connections.get(key);
+      switch (key) {
+        case 'redis':
+          await redis.closeConnection(connection.client);
+          break;
+        case 'mongodb':
+          await mongodb.closeConnection(connection.client);
+          break;
+      }
+
+      this.#connections.delete(key);
+    } catch (error) {
+      logger.error(`Error closing ${dbType} connection:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Close all database connections
+   * @returns {Promise<void>}
+   */
+  async closeAllConnections() {
+    const closePromises = [];
+    for (const [key, connection] of this.#connections) {
+      closePromises.push(
+        this.closeConnection(connection.type, connection.config),
+      );
+    }
+    await Promise.all(closePromises);
+    this.#connections.clear();
+  }
+
+  /**
+   * Get all active connections
+   * @returns {Map<string, {type: string, client: any, config: Object}>}
+   */
+  getActiveConnections() {
+    return new Map(this.#connections);
+  }
+
+  /**
+   * Check if a connection exists or is being initialized
+   * @param {string} dbType - Type of database
+   * @param {Object} config - Database configuration
+   * @returns {{ exists: boolean, initializing: boolean }}
+   */
+  hasConnection(dbType, config) {
+    const key = dbType.toLowerCase();
+    return {
+      exists: this.#connections.has(key),
+      initializing: this.#initializingConnections.has(key),
+    };
+  }
+}
+
+const dbManager = DatabaseManager.getInstance();
+export default dbManager;