te.js 2.2.0 → 2.2.1

package/database/mongodb.js

@@ -1,152 +0,0 @@
-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';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const logger = new TejLogger('MongoDBConnectionManager');
-
-async function checkMongooseInstallation() {
-  const packageJsonPath = path.join(__dirname, '..', 'package.json');
-  const nodeModulesPath = path.join(
-    __dirname,
-    '..',
-    'node_modules',
-    'mongoose',
-  );
-
-  try {
-    const packageJson = JSON.parse(
-      await fs.promises.readFile(packageJsonPath, 'utf8'),
-    );
-    const inPackageJson = !!packageJson.dependencies?.mongoose;
-
-    let inNodeModules = false;
-    try {
-      await fs.promises.access(nodeModulesPath);
-      inNodeModules = true;
-    } catch {
-      inNodeModules = false;
-    }
-
-    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 } = await checkMongooseInstallation();
-
-  if (needsInstall) {
-    const installed = installMongooseSync();
-    if (!installed) {
-      throw new TejError(500, 'Failed to install required mongoose package');
-    }
-  }
-
-  const { uri, options = {} } = config;
-
-  try {
-    const { default: mongoose } = await import('mongoose');
-    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

@@ -1,210 +0,0 @@
-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';
-
-const packageJsonPath = path.join(process.cwd(), 'package.json');
-const packagePath = `${process.cwd()}/node_modules/redis/dist/index.js`;
-
-const logger = new TejLogger('RedisConnectionManager');
-
-async function checkRedisInstallation() {
-  try {
-    const packageJson = JSON.parse(
-      await fs.promises.readFile(packageJsonPath, 'utf8'),
-    );
-    const inPackageJson = !!packageJson.dependencies?.redis;
-
-    let inNodeModules = false;
-    try {
-      await fs.promises.access(packagePath);
-      inNodeModules = true;
-    } catch {
-      inNodeModules = false;
-    }
-
-    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 } = await 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;
-
-    const {
-      promise: connectionPromise,
-      resolve: resolveConnection,
-      reject: rejectConnection,
-    } = Promise.withResolvers();
-
-    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);
-        client.quit().catch(() => {});
-        rejectConnection(
-          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');
-      resolveConnection(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,
-};