typescript-express-starter 10.2.1 → 11.0.0

package/bin/db-map.js

@@ -0,0 +1,169 @@
+export const TEMPLATE_DB = {
+  default: null,
+  graphql: 'postgres',
+  knex: 'mysql',
+  mikroorm: 'mongo',
+  mongoose: 'mongo',
+  'node-postgres': 'postgres',
+  prisma: 'mysql',
+  sequelize: 'mysql',
+  typegoose: 'mongo',
+  typeorm: 'postgres',
+};
+
+const DB_SERVICES = {
+  postgres: `
+  pg:
+    container_name: pg
+    image: postgres:16-alpine
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_DB: \${POSTGRES_DB}
+      POSTGRES_USER: \${POSTGRES_USER}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD}
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    restart: always
+    networks:
+      - backend
+  `,
+  mysql: `
+  mysql:
+    container_name: mysql
+    image: mysql:8.0
+    ports:
+      - "3306:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: \${MYSQL_ROOT_PASSWORD}
+      MYSQL_DATABASE: \${MYSQL_DATABASE}
+      MYSQL_USER: \${MYSQL_USER}
+      MYSQL_PASSWORD: \${MYSQL_PASSWORD}
+    volumes:
+      - mysqldata:/var/lib/mysql
+    restart: always
+    networks:
+      - backend
+  `,
+  mongo: `
+  mongo:
+    container_name: mongo
+    image: mongo:7
+    ports:
+      - "27017:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: \${MONGO_ROOT_USERNAME}
+      MONGO_INITDB_ROOT_PASSWORD: \${MONGO_ROOT_PASSWORD}
+      MONGO_INITDB_DATABASE: \${MONGO_DATABASE}
+    volumes:
+      - mongodata:/data/db
+    restart: always
+    networks:
+      - backend
+  `,
+};
+
+// DB별 서비스명 맵핑
+const DB_SERVICE_NAMES = {
+  postgres: 'pg',
+  mysql: 'mysql',
+  mongo: 'mongo',
+};
+
+// 서비스 생성 헬퍼 함수
+const generateServices = (dbSnippet = '', dbType = null) => {
+  // depends_on 조건부 생성
+  const dependsOn =
+    dbType && DB_SERVICE_NAMES[dbType]
+      ? `    depends_on:
+      - ${DB_SERVICE_NAMES[dbType]}`
+      : '';
+
+  // 볼륨 설정 동적 생성
+  const volumes = dbType ? generateVolumes(dbType) : '';
+
+  return `version: '3.9'
+
+services:
+  proxy:
+    container_name: proxy
+    image: nginx:alpine
+    ports:
+      - '80:80'
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - server
+    restart: unless-stopped
+    networks:
+      - backend
+
+  server:
+    container_name: server
+    build:
+      context: ./
+      dockerfile: Dockerfile.dev
+    ports:
+      - '3000:3000'
+    volumes:
+      - ./:/app:cached
+      - /app/node_modules
+    env_file:
+      - .env.development.local
+${dependsOn}
+    restart: unless-stopped
+    networks:
+      - backend
+
+${dbSnippet.trim()}
+
+networks:
+  backend:
+    driver: bridge
+${volumes}`;
+};
+
+// 볼륨 생성 헬퍼 함수
+function generateVolumes(dbType) {
+  const volumeMap = {
+    postgres: `
+volumes:
+  pgdata:
+    driver: local`,
+    mysql: `
+volumes:
+  mysqldata:
+    driver: local`,
+    mongo: `
+volumes:
+  mongodata:
+    driver: local`,
+  };
+
+  return volumeMap[dbType] || '';
+}
+
+// 설정 검증 함수
+export function validateDbTemplate(template) {
+  if (!template || !TEMPLATE_DB.hasOwnProperty(template)) {
+    throw new Error(
+      `Invalid template: ${template}. Available templates: ${Object.keys(TEMPLATE_DB).join(', ')}`,
+    );
+  }
+  return TEMPLATE_DB[template];
+}
+
+// 완전한 docker-compose 생성 함수
+export function generateDockerCompose(template) {
+  const dbType = validateDbTemplate(template);
+  if (!dbType) {
+    return generateServices();
+  }
+
+  const dbSnippet = DB_SERVICES[dbType];
+  if (!dbSnippet) {
+    throw new Error(`Database service configuration not found for: ${dbType}`);
+  }
+
+  return generateServices(dbSnippet, dbType);
+}

package/bin/errors.js

@@ -0,0 +1,129 @@
+/**
+ * Custom error classes for better error handling
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Base CLI error class
+ */
+export class CLIError extends Error {
+  constructor(message, phase = null, suggestion = null, code = 1) {
+    super(message);
+    this.name = 'CLIError';
+    this.phase = phase;
+    this.suggestion = suggestion;
+    this.code = code;
+  }
+}
+
+/**
+ * Project generation specific error
+ */
+export class ProjectGenerationError extends CLIError {
+  constructor(message, phase, suggestion = null) {
+    super(message, phase, suggestion, 1);
+    this.name = 'ProjectGenerationError';
+  }
+}
+
+/**
+ * Validation error
+ */
+export class ValidationError extends CLIError {
+  constructor(message, field, suggestion = null) {
+    super(message, 'validation', suggestion, 2);
+    this.name = 'ValidationError';
+    this.field = field;
+  }
+}
+
+/**
+ * Network error
+ */
+export class NetworkError extends CLIError {
+  constructor(message, operation, suggestion = null) {
+    super(message, 'network', suggestion, 3);
+    this.name = 'NetworkError';
+    this.operation = operation;
+  }
+}
+
+/**
+ * File system error
+ */
+export class FileSystemError extends CLIError {
+  constructor(message, path, suggestion = null) {
+    super(message, 'filesystem', suggestion, 4);
+    this.name = 'FileSystemError';
+    this.path = path;
+  }
+}
+
+/**
+ * Enhanced error printing function
+ */
+export function printError(error, context = null) {
+  if (error instanceof CLIError) {
+    console.log(chalk.bgRed.white(` ${error.name.toUpperCase()} `), chalk.red(error.message));
+
+    if (error.phase) {
+      console.log(chalk.gray('Phase:'), chalk.cyan(error.phase));
+    }
+
+    if (error.suggestion) {
+      console.log(chalk.gray('Hint:'), chalk.cyan(error.suggestion));
+    }
+
+    if (context) {
+      console.log(chalk.gray('Context:'), chalk.yellow(context));
+    }
+  } else {
+    // Fallback for non-CLI errors
+    console.log(chalk.bgRed.white(' ERROR '), chalk.red(error.message || error));
+    if (context) {
+      console.log(chalk.gray('Context:'), chalk.yellow(context));
+    }
+  }
+}
+
+/**
+ * Error handler wrapper for async functions
+ */
+export function withErrorHandling(fn, errorMessage = 'Operation failed') {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+      throw new CLIError(errorMessage, null, error.message);
+    }
+  };
+}
+
+/**
+ * Retry mechanism with exponential backoff
+ */
+export async function withRetry(fn, maxRetries = 3, baseDelay = 1000) {
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      if (attempt === maxRetries) {
+        break;
+      }
+
+      const delay = baseDelay * Math.pow(2, attempt - 1);
+      console.log(chalk.yellow(`Attempt ${attempt} failed, retrying in ${delay}ms...`));
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  throw lastError;
+}

package/bin/performance.js

@@ -0,0 +1,203 @@
+/**
+ * Performance optimization utilities
+ */
+
+import { execa } from 'execa';
+import { NetworkError, withRetry } from './errors.js';
+import { CONFIG } from './config.js';
+
+/**
+ * Version cache for package lookups
+ */
+class VersionCache {
+  constructor() {
+    this.cache = new Map();
+    this.pendingRequests = new Map();
+  }
+
+  /**
+   * Get latest version with caching
+   */
+  async getLatestVersion(packageName) {
+    // Return cached result if available
+    if (this.cache.has(packageName)) {
+      return this.cache.get(packageName);
+    }
+
+    // Return pending promise if request is in progress
+    if (this.pendingRequests.has(packageName)) {
+      return this.pendingRequests.get(packageName);
+    }
+
+    // Create new request
+    const promise = this._fetchLatestVersion(packageName);
+    this.pendingRequests.set(packageName, promise);
+
+    try {
+      const version = await promise;
+      this.cache.set(packageName, version);
+      return version;
+    } finally {
+      this.pendingRequests.delete(packageName);
+    }
+  }
+
+  /**
+   * Fetch latest version from npm registry
+   */
+  async _fetchLatestVersion(packageName) {
+    return withRetry(
+      async () => {
+        try {
+          const { stdout } = await execa('npm', ['view', packageName, 'version'], {
+            timeout: CONFIG.timeout.versionCheck,
+          });
+          return stdout.trim();
+        } catch (error) {
+          throw new NetworkError(
+            `Failed to fetch version for ${packageName}`,
+            'version-check',
+            'Check your internet connection and try again',
+          );
+        }
+      },
+      3,
+      1000,
+    );
+  }
+
+  /**
+   * Prefetch versions for multiple packages in parallel
+   */
+  async prefetchVersions(packageNames) {
+    const promises = packageNames.map((name) => this.getLatestVersion(name));
+    const results = await Promise.allSettled(promises);
+
+    const successful = [];
+    const failed = [];
+
+    results.forEach((result, index) => {
+      if (result.status === 'fulfilled') {
+        successful.push({
+          package: packageNames[index],
+          version: result.value,
+        });
+      } else {
+        failed.push({
+          package: packageNames[index],
+          error: result.reason,
+        });
+      }
+    });
+
+    return { successful, failed };
+  }
+
+  /**
+   * Clear cache
+   */
+  clear() {
+    this.cache.clear();
+    this.pendingRequests.clear();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      cacheSize: this.cache.size,
+      pendingRequests: this.pendingRequests.size,
+      cachedPackages: Array.from(this.cache.keys()),
+    };
+  }
+}
+
+/**
+ * Global version cache instance
+ */
+export const versionCache = new VersionCache();
+
+/**
+ * Batch package operations
+ */
+export class PackageBatch {
+  constructor() {
+    this.packages = [];
+  }
+
+  /**
+   * Add package to batch
+   */
+  add(packageSpec) {
+    this.packages.push(packageSpec);
+    return this;
+  }
+
+  /**
+   * Add multiple packages to batch
+   */
+  addMany(packageSpecs) {
+    this.packages.push(...packageSpecs);
+    return this;
+  }
+
+  /**
+   * Resolve all packages with versions
+   */
+  async resolve() {
+    const resolved = await Promise.all(
+      this.packages.map(async (spec) => {
+        if (this._isExplicitSpecifier(spec)) {
+          return spec;
+        }
+
+        const { name, version } = this._splitNameAndVersion(spec);
+
+        if (version && version.length > 0) {
+          return `${name}@${version}`;
+        }
+
+        try {
+          const latest = await versionCache.getLatestVersion(name);
+          return latest ? `${name}@${latest}` : name;
+        } catch (error) {
+          console.warn(`Warning: Could not resolve version for ${name}, using latest`);
+          return name;
+        }
+      }),
+    );
+
+    return resolved;
+  }
+
+  /**
+   * Check if package specifier is explicit
+   */
+  _isExplicitSpecifier(spec) {
+    return (
+      spec.startsWith('http://') ||
+      spec.startsWith('https://') ||
+      spec.startsWith('git+') ||
+      spec.startsWith('file:') ||
+      spec.startsWith('link:') ||
+      spec.startsWith('workspace:') ||
+      spec.startsWith('npm:')
+    );
+  }
+
+  /**
+   * Split package name and version
+   */
+  _splitNameAndVersion(spec) {
+    if (spec.startsWith('@')) {
+      const idx = spec.indexOf('@', 1);
+      if (idx === -1) return { name: spec, version: null };
+      return { name: spec.slice(0, idx), version: spec.slice(idx + 1) };
+    } else {
+      const idx = spec.indexOf('@');
+      if (idx === -1) return { name: spec, version: null };
+      return { name: spec.slice(0, idx), version: spec.slice(idx + 1) };
+    }
+  }
+}