te.js 1.3.1 → 2.0.0

package/database/mongodb.js

@@ -0,0 +1,146 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import TejLogger from 'tej-logger';
+import TejError from '../server/error.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const logger = new TejLogger('MongoDBConnectionManager');
+
+function checkMongooseInstallation() {
+  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+  const nodeModulesPath = path.join(
+    __dirname,
+    '..',
+    'node_modules',
+    'mongoose',
+  );
+
+  try {
+    // Check if mongoose exists in package.json
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const inPackageJson = !!packageJson.dependencies?.mongoose;
+
+    // Check if mongoose exists in node_modules
+    const inNodeModules = fs.existsSync(nodeModulesPath);
+
+    return {
+      needsInstall: !inPackageJson || !inNodeModules,
+      reason: !inPackageJson
+        ? 'not in package.json'
+        : !inNodeModules
+          ? 'not in node_modules'
+          : null,
+    };
+  } catch (error) {
+    return { needsInstall: true, reason: 'error checking installation' };
+  }
+}
+
+function installMongooseSync() {
+  const spinner = ['|', '/', '-', '\\'];
+  let current = 0;
+  let intervalId;
+
+  try {
+    const { needsInstall, reason } = checkMongooseInstallation();
+
+    if (!needsInstall) {
+      return true;
+    }
+
+    // Start the spinner
+    intervalId = setInterval(() => {
+      process.stdout.write(`\r${spinner[current]} Installing mongoose...`);
+      current = (current + 1) % spinner.length;
+    }, 100);
+
+    logger.info(`Tejas will install mongoose (${reason})...`);
+
+    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const result = spawn.sync(command, ['install', 'mongoose'], {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    process.stdout.write('\r');
+    clearInterval(intervalId);
+
+    if (result.status === 0) {
+      logger.info('Mongoose installed successfully');
+      return true;
+    } else {
+      logger.error('Mongoose installation failed');
+      return false;
+    }
+  } catch (error) {
+    if (intervalId) {
+      process.stdout.write('\r');
+      clearInterval(intervalId);
+    }
+    logger.error('Error installing mongoose:', error);
+    return false;
+  }
+}
+
+/**
+ * Create a new MongoDB connection
+ * @param {Object} config - MongoDB configuration
+ * @param {string} config.uri - MongoDB connection URI
+ * @param {Object} [config.options={}] - Additional Mongoose options
+ * @returns {Promise<mongoose.Connection>} Mongoose connection instance
+ */
+async function createConnection(config) {
+  const { needsInstall } = checkMongooseInstallation();
+
+  if (needsInstall) {
+    const installed = installMongooseSync();
+    if (!installed) {
+      throw new TejError(500, 'Failed to install required mongoose package');
+    }
+  }
+
+  const { uri, options = {} } = config;
+
+  try {
+    const mongoose = await import('mongoose').then((mod) => mod.default);
+    const connection = await mongoose.createConnection(uri, options);
+
+    connection.on('error', (err) =>
+      logger.error(`MongoDB connection error:`, err),
+    );
+    connection.on('connected', () => {
+      logger.info(`MongoDB connected to ${uri}`);
+    });
+    connection.on('disconnected', () => {
+      logger.info(`MongoDB disconnected from ${uri}`);
+    });
+
+    return connection;
+  } catch (error) {
+    logger.error(`Failed to create MongoDB connection:`, error);
+    throw new TejError(
+      500,
+      `Failed to create MongoDB connection: ${error.message}`,
+    );
+  }
+}
+
+/**
+ * Close a MongoDB connection
+ * @param {mongoose.Connection} connection - Mongoose connection to close
+ * @returns {Promise<void>}
+ */
+async function closeConnection(connection) {
+  if (connection) {
+    await connection.close();
+  }
+}
+
+export default {
+  createConnection,
+  closeConnection,
+};

package/database/redis.js

@@ -0,0 +1,201 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import TejError from '../server/error.js';
+import TejLogger from 'tej-logger';
+import { pathToFileURL } from 'node:url';
+
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+const packagePath = `${process.cwd()}/node_modules/redis/dist/index.js`;
+
+const logger = new TejLogger('RedisConnectionManager');
+
+function checkRedisInstallation() {
+  try {
+    // Check if redis exists in package.json
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const inPackageJson = !!packageJson.dependencies?.redis;
+
+    // Check if redis exists in node_modules
+    const inNodeModules = fs.existsSync(packagePath);
+
+    return {
+      needsInstall: !inPackageJson || !inNodeModules,
+      reason: !inPackageJson
+        ? 'not in package.json'
+        : !inNodeModules
+          ? 'not in node_modules'
+          : null,
+    };
+  } catch (error) {
+    logger.error(error, true);
+    return { needsInstall: true, reason: 'error checking installation' };
+  }
+}
+
+function installRedisSync() {
+  const spinner = ['|', '/', '-', '\\'];
+  let current = 0;
+  let intervalId;
+
+  try {
+    const { needsInstall, reason } = checkRedisInstallation();
+
+    if (!needsInstall) {
+      return true;
+    }
+
+    // Start the spinner
+    intervalId = setInterval(() => {
+      process.stdout.write(`\r${spinner[current]} Installing redis...`);
+      current = (current + 1) % spinner.length;
+    }, 100);
+
+    logger.info(`Tejas will install redis (${reason})...`);
+
+    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const result = spawnSync(command, ['install', 'redis'], {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    process.stdout.write('\r');
+    clearInterval(intervalId);
+
+    if (result.status === 0) {
+      logger.info('Redis installed successfully');
+      return true;
+    } else {
+      logger.error('Redis installation failed');
+      return false;
+    }
+  } catch (error) {
+    if (intervalId) {
+      process.stdout.write('\r');
+      clearInterval(intervalId);
+    }
+    logger.error(error, true);
+    return false;
+  }
+}
+
+/**
+ * Create a new Redis client or cluster
+ * @param {Object} config - Redis configuration
+ * @param {boolean} [config.isCluster=false] - Whether to use Redis Cluster
+ * @param {Object} [config.options={}] - Additional Redis options
+ * @returns {Promise<RedisClient|RedisCluster>} Redis client or cluster instance
+ */
+async function createConnection(config) {
+  const { needsInstall } = checkRedisInstallation();
+
+  if (needsInstall) {
+    const installed = installRedisSync();
+    if (!installed) {
+      throw new TejError(500, 'Failed to install required redis package');
+    }
+  }
+
+  const { isCluster = false, options = {} } = config;
+  let client;
+
+  try {
+    const { createClient, createCluster } = await import(
+      pathToFileURL(packagePath)
+    );
+
+    if (isCluster) {
+      client = createCluster({
+        ...options,
+      });
+    } else {
+      client = createClient({
+        ...options,
+      });
+    }
+
+    let connectionTimeout;
+    let hasConnected = false;
+    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++;
+      });
+
+      client.on('connect', () => {
+        hasConnected = true;
+        clearTimeout(connectionTimeout);
+        logger.info(
+          `Redis connected on ${client?.options?.url ?? client?.options?.socket?.host}`,
+        );
+      });
+
+      client.on('ready', () => {
+        logger.info('Redis ready');
+        resolve(client);
+      });
+
+      client.on('end', () => {
+        logger.info('Redis connection closed');
+      });
+    });
+
+    await client.connect();
+    await connectionPromise;
+
+    return client;
+  } catch (error) {
+    if (client) {
+      try {
+        await client.quit();
+      } catch (quitError) {
+        logger.error(
+          `Error while cleaning up Redis connection: ${quitError}`,
+          true,
+        );
+      }
+    }
+    logger.error(`Failed to create Redis connection: ${error}`, true);
+    throw new TejError(
+      500,
+      `Failed to create Redis connection: ${error.message}`,
+    );
+  }
+}
+
+/**
+ * Close a Redis connection
+ * @param {RedisClient|RedisCluster} client - Redis client to close
+ * @returns {Promise<void>}
+ */
+async function closeConnection(client) {
+  if (client) {
+    await client.quit();
+  }
+}
+
+export default {
+  createConnection,
+  closeConnection,
+};

package/docs/README.md

@@ -0,0 +1,36 @@
+# Tejas Documentation
+
+Welcome to the documentation for **Tejas** — a Node.js framework for building powerful backend services.
+
+## Table of Contents
+
+### Getting Started
+
+- [Introduction & Quick Start](./getting-started.md) — Install, create your first app, and core concepts
+- [Configuration](./configuration.md) — Config sources, all available options, and environment variables
+
+### Core Concepts
+
+- [Routing (Targets)](./routing.md) — Define routes, parameterized paths, and endpoint metadata
+- [Request & Response (Ammo)](./ammo.md) — Handle requests, send responses, and access request data
+- [Middleware](./middleware.md) — Global, target, and route-level middleware with Express compatibility
+- [Error Handling](./error-handling.md) — Zero-config error handling, TejError, and BodyParserError
+
+### Features
+
+- [Database Integration](./database.md) — Redis and MongoDB connections with auto-install
+- [Rate Limiting](./rate-limiting.md) — Three algorithms, two storage backends, custom headers
+- [File Uploads](./file-uploads.md) — Single and multiple file handling with validation
+
+### Tooling
+
+- [CLI Reference](./cli.md) — `tejas fly`, `tejas generate:docs`, and `tejas docs:on-push`
+- [Auto-Documentation](./auto-docs.md) — LLM-powered OpenAPI generation and Scalar API docs UI
+
+### Reference
+
+- [API Reference](./api-reference.md) — Complete API documentation for all classes and functions
+
+---
+
+This documentation is for Tejas v2.0.0.