Server Utilities

import { Server } from "http";

/**
 * Abstract class providing graceful shutdown functionality for HTTP servers
 */
abstract class GracefulShutdownServer {
  /** Indicates if the server is currently shutting down */
  public isShuttingDown: boolean;
  
  /** Abstract method that must be implemented by concrete classes */
  public abstract shutdown(timeout?: number): Promise<void>;
  
  /**
   * Creates a graceful shutdown server from an existing HTTP server
   * @param originalServer - The HTTP server to enhance
   * @param waitingResponseTime - Time to wait between connection checks (default: 200ms)
   * @returns Enhanced server with graceful shutdown capabilities
   */
  public static create<T extends Server>(
    originalServer: T,
    waitingResponseTime?: number
  ): T & GracefulShutdownServer;
}

import { GracefulShutdownServer } from "medusa-core-utils";
import { createServer } from "http";
import express from "express";

// Create Express app and HTTP server
const app = express();
const httpServer = createServer(app);

// Enhance server with graceful shutdown
const server = GracefulShutdownServer.create(httpServer);

// Start server
server.listen(3000, () => {
  console.log("Server running on port 3000");
});

// Handle shutdown signals
const gracefulShutdown = async (signal: string) => {
  console.log(`Received ${signal}. Starting graceful shutdown...`);
  
  try {
    // Stop accepting new connections and wait for existing ones to finish
    await server.shutdown(30000); // 30 second timeout
    console.log("Server shut down gracefully");
    process.exit(0);
  } catch (error) {
    console.error("Error during shutdown:", error);
    process.exit(1);
  }
};

// Register signal handlers
process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
process.on("SIGINT", () => gracefulShutdown("SIGINT"));

// Check shutdown status
app.get("/health", (req, res) => {
  if (server.isShuttingDown) {
    res.status(503).json({ status: "shutting down" });
  } else {
    res.json({ status: "healthy" });
  }
});

// With custom waiting time for faster shutdown cycles
const fastShutdownServer = GracefulShutdownServer.create(httpServer, 50);

/**
 * Attempts to resolve and load a configuration file from a directory
 * @param rootDir - The directory to search for the config file
 * @param configName - The name of the config file (without extension)
 * @returns Object containing the loaded config, file path, and any errors
 */
function getConfigFile<TConfig = unknown>(
  rootDir: string,
  configName: string
): { 
  configModule: TConfig; 
  configFilePath: string; 
  error: any 
};

import { getConfigFile } from "medusa-core-utils";
import path from "path";

// Load application configuration
const { configModule, configFilePath, error } = getConfigFile(
  process.cwd(),
  "medusa-config"
);

if (error) {
  console.log("No config file found, using defaults");
  // Handle missing config gracefully
} else {
  console.log(`Loaded config from: ${configFilePath}`);
  console.log("Config:", configModule);
}

// Type-safe configuration loading
interface AppConfig {
  database: {
    host: string;
    port: number;
  };
  redis: {
    url: string;
  };
  server: {
    port: number;
  };
}

function loadAppConfig(): AppConfig {
  const { configModule, error } = getConfigFile<AppConfig>(
    process.cwd(),
    "app-config"
  );
  
  if (error || !configModule) {
    // Return default configuration
    return {
      database: {
        host: "localhost",
        port: 5432
      },
      redis: {
        url: "redis://localhost:6379"
      },
      server: {
        port: 3000
      }
    };
  }
  
  return configModule;
}

// Multi-environment config loading
function loadEnvironmentConfig(env: string = "development") {
  const configName = `config.${env}`;
  const { configModule, error } = getConfigFile(
    path.join(process.cwd(), "config"),
    configName
  );
  
  if (error) {
    console.warn(`Failed to load ${configName}, falling back to default config`);
    return getConfigFile(process.cwd(), "config").configModule;
  }
  
  return configModule;
}

// Plugin configuration loading
function loadPluginConfigs(pluginDir: string): Record<string, any> {
  const fs = require("fs");
  const plugins = {};
  
  try {
    const files = fs.readdirSync(pluginDir);
    
    for (const file of files) {
      if (file.endsWith("-config.js")) {
        const pluginName = file.replace("-config.js", "");
        const { configModule, error } = getConfigFile(pluginDir, file.replace(".js", ""));
        
        if (!error && configModule) {
          plugins[pluginName] = configModule;
        }
      }
    }
  } catch (error) {
    console.warn("Failed to load plugin configs:", error.message);
  }
  
  return plugins;
}

/**
 * Gets the version of the installed @medusajs/medusa package
 * @returns Version string or empty string if not found
 */
function getMedusaVersion(): string;

import { getMedusaVersion } from "medusa-core-utils";

// Get current Medusa version
const version = getMedusaVersion();

if (version) {
  console.log(`Medusa version: ${version}`);
} else {
  console.log("Medusa package not found");
}

// Version compatibility checking
function checkCompatibility() {
  const currentVersion = getMedusaVersion();
  
  if (!currentVersion) {
    throw new Error("Medusa package not installed");
  }
  
  const [major, minor] = currentVersion.split('.').map(Number);
  
  if (major < 1 || (major === 1 && minor < 2)) {
    throw new Error(`Unsupported Medusa version: ${currentVersion}. Minimum required: 1.2.0`);
  }
  
  return currentVersion;
}

// System information gathering
function getSystemInfo() {
  return {
    nodeVersion: process.version,
    medusaVersion: getMedusaVersion(),
    platform: process.platform,
    arch: process.arch,
    environment: process.env.NODE_ENV || "development"
  };
}

// Health check endpoint
app.get("/health", (req, res) => {
  const medusaVersion = getMedusaVersion();
  
  res.json({
    status: "healthy",
    timestamp: new Date().toISOString(),
    versions: {
      node: process.version,
      medusa: medusaVersion || "not-installed"
    }
  });
});

/**
 * Creates a require function from a specific file path
 * Polyfill for Node's Module.createRequire (added in Node v10.12.0)
 * @param filename - The file path to create require function for
 * @returns require function scoped to the given path
 */
function createRequireFromPath(filename: string): NodeRequire;

import { createRequireFromPath } from "medusa-core-utils";
import path from "path";

// Create require function for a specific directory
const pluginDir = path.join(process.cwd(), "plugins", "my-plugin");
const pluginRequire = createRequireFromPath(path.join(pluginDir, "index.js"));

// Use the scoped require to load modules relative to plugin directory
try {
  const pluginConfig = pluginRequire("./config.json");
  const pluginHelpers = pluginRequire("./helpers");
  
  console.log("Plugin loaded successfully");
} catch (error) {
  console.error("Failed to load plugin:", error);
}

// Dynamic module loading from different contexts
function loadModuleFromPath(modulePath: string, fromDirectory: string) {
  const requireFromPath = createRequireFromPath(
    path.join(fromDirectory, "package.json")
  );
  
  try {
    return requireFromPath(modulePath);
  } catch (error) {
    throw new Error(`Failed to load module ${modulePath} from ${fromDirectory}: ${error.message}`);
  }
}

// Plugin system implementation
class PluginLoader {
  private pluginDir: string;
  private pluginRequire: NodeRequire;
  
  constructor(pluginDirectory: string) {
    this.pluginDir = pluginDirectory;
    this.pluginRequire = createRequireFromPath(
      path.join(pluginDirectory, "index.js")
    );
  }
  
  loadPlugin(pluginName: string) {
    try {
      const pluginMain = this.pluginRequire(`./${pluginName}`);
      const pluginPackage = this.pluginRequire(`./${pluginName}/package.json`);
      
      return {
        name: pluginName,
        version: pluginPackage.version,
        main: pluginMain,
        path: path.join(this.pluginDir, pluginName)
      };
    } catch (error) {
      throw new Error(`Failed to load plugin ${pluginName}: ${error.message}`);
    }
  }
}

// Cross-Node.js version compatibility
function createRequire(filename: string) {
  // Use native createRequire if available (Node.js 12+)
  if (require.createRequire) {
    return require.createRequire(filename);
  }
  
  // Fallback to custom implementation for older Node.js
  return createRequireFromPath(filename);
}