@koalarx/nest 3.1.50 → 4.0.2

package/cli/utils/cli-project-validation.js

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import {
+  appModuleMustContain,
+  appModuleMustNotContain,
+  buildProjectExpectation,
+  forbiddenPathsForExpectation,
+  healthControllerMustContain,
+  healthControllerMustNotContain,
+  infraModuleMustContain,
+  infraModuleMustNotContain,
+  requiredPackagesForExpectation,
+  requiredPathsForExpectation
+} from "../constants/cli-project-checklist.js";
+import { AuthStrategy, ExtraFeature, Template } from "../constants/domain.js";
+import { detectProjectState } from "./detect-project-state.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+import { assertAuthStrategyProject } from "./auth-strategy-validation.js";
+function readOptional(projectRoot, relativePath) {
+  const filePath = path.join(projectRoot, relativePath);
+  return existsSync(filePath) ? readFileSync(filePath, "utf8") : null;
+}
+function expectContains(violations, label, source, patterns) {
+  if (!source) {
+    if (patterns.length > 0) {
+      violations.push(`missing:${label}`);
+    }
+    return;
+  }
+  for (const pattern of patterns) {
+    if (!source.includes(pattern)) {
+      violations.push(`${label}: ausente "${pattern}"`);
+    }
+  }
+}
+function expectNotContains(violations, label, source, patterns) {
+  if (!source) {
+    return;
+  }
+  for (const pattern of patterns) {
+    if (source.includes(pattern)) {
+      violations.push(`${label}: inesperado "${pattern}"`);
+    }
+  }
+}
+function readInstalledPackages(projectRoot) {
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  return {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+}
+export function listCliProjectViolations(projectName = "", expectation) {
+  const projectRoot = resolveProjectPath(projectName);
+  const violations = [];
+  for (const relativePath of requiredPathsForExpectation(expectation)) {
+    if (!existsSync(path.join(projectRoot, relativePath))) {
+      violations.push(`path:obrigatório ausente ${relativePath}`);
+    }
+  }
+  for (const relativePath of forbiddenPathsForExpectation(expectation)) {
+    if (existsSync(path.join(projectRoot, relativePath))) {
+      violations.push(`path:proibido presente ${relativePath}`);
+    }
+  }
+  const appModule = readOptional(projectRoot, "src/host/app.module.ts");
+  const infraModule = readOptional(projectRoot, "src/infra/infra.module.ts");
+  const healthController = readOptional(projectRoot, "src/host/controllers/health-check/health-check.controller.ts");
+  expectContains(violations, "app.module", appModule, appModuleMustContain(expectation));
+  expectNotContains(violations, "app.module", appModule, appModuleMustNotContain(expectation));
+  expectContains(violations, "infra.module", infraModule, infraModuleMustContain(expectation));
+  expectNotContains(violations, "infra.module", infraModule, infraModuleMustNotContain(expectation));
+  expectContains(violations, "health-check.controller", healthController, healthControllerMustContain(expectation));
+  expectNotContains(violations, "health-check.controller", healthController, healthControllerMustNotContain(expectation));
+  if (expectation.template === Template.CRUD_SAMPLE) {
+    const deletePerson = readOptional(projectRoot, "src/host/controllers/person/delete-person.controller.ts");
+    expectContains(violations, "delete-person.controller", deletePerson, [
+      "RestrictionByProfile"
+    ]);
+  }
+  const nestCliPath = path.join(projectRoot, "nest-cli.json");
+  if (existsSync(nestCliPath)) {
+    const nestCli = JSON.parse(readFileSync(nestCliPath, "utf8"));
+    if (nestCli.entryFile !== "host/main") {
+      violations.push('nest-cli.json: entryFile deve ser "host/main"');
+    }
+  }
+  const packageJson = readOptional(projectRoot, "package.json");
+  if (packageJson?.includes('"start:prod": "node dist/host/main"') === false) {
+    violations.push("package.json: start:prod deve apontar para dist/host/main");
+  }
+  const installed = readInstalledPackages(projectRoot);
+  if (installed) {
+    for (const dependency of requiredPackagesForExpectation(expectation)) {
+      if (!installed[dependency]) {
+        violations.push(`package:obrigatório ausente ${dependency}`);
+      }
+    }
+    if (expectation.cache !== "redis" && installed.ioredis) {
+      violations.push("package:proibido presente ioredis");
+    }
+    if (!expectation.cronJobs && installed["cron-parser"]) {
+      violations.push("package:proibido presente cron-parser");
+    }
+    if (!expectation.health && installed["@nestjs/terminus"]) {
+      violations.push("package:proibido presente @nestjs/terminus");
+    }
+  }
+  try {
+    const detected = detectProjectState(projectName);
+    if (detected.template !== expectation.template) {
+      violations.push(`state:template esperado ${expectation.template}, detectado ${detected.template}`);
+    }
+    if (detected.cache !== expectation.cache) {
+      violations.push(`state:cache esperado ${String(expectation.cache)}, detectado ${String(detected.cache)}`);
+    }
+    if (detected.health !== expectation.health) {
+      violations.push(`state:health esperado ${expectation.health}, detectado ${detected.health}`);
+    }
+    if (detected.cronJobs !== expectation.cronJobs) {
+      violations.push(`state:cronJobs esperado ${expectation.cronJobs}, detectado ${detected.cronJobs}`);
+    }
+    if (detected.eventJobs !== expectation.eventJobs) {
+      violations.push(`state:eventJobs esperado ${expectation.eventJobs}, detectado ${detected.eventJobs}`);
+    }
+    const expectedAuth = expectation.auth === false ? false : [...expectation.auth].sort().join(",");
+    const detectedAuth = detected.auth === false ? false : [...detected.auth].sort().join(",");
+    if (expectedAuth !== detectedAuth) {
+      violations.push(`state:auth esperado ${String(expectedAuth)}, detectado ${String(detectedAuth)}`);
+    }
+  } catch (error) {
+    violations.push(`state:${error instanceof Error ? error.message : String(error)}`);
+  }
+  return [...new Set(violations)].sort();
+}
+export function assertCliProject(projectName = "", expectation) {
+  const violations = listCliProjectViolations(projectName, expectation);
+  if (violations.length > 0) {
+    throw new Error(`Checklist CLI falhou (${expectation.template}, auth=${expectation.auth === false ? "none" : expectation.auth.join("+")}):
+${violations.join(`
+`)}`);
+  }
+  if (expectation.auth !== false) {
+    assertAuthStrategyProject(projectName, expectation.auth);
+  } else {
+    assertAuthStrategyProject(projectName, false);
+  }
+}
+export function assertCliProjectFromSelection(projectName = "", template, auth, features) {
+  assertCliProject(projectName, buildProjectExpectation(template, auth, features));
+}
+
+export { buildProjectExpectation };

package/cli/utils/detect-project-state.js

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import {
+  AddArgKind,
+  ExtraFeature,
+  FEATURE_ALIASES,
+  isAuthStrategy,
+  listMissingAuthStrategies,
+  mergeAuthStrategies,
+  ProjectMarker,
+  resolveAuthStrategiesFromModule,
+  Template
+} from "../constants/domain.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+export function assertKoalaProject(projectName = "") {
+  const root = resolveProjectPath(projectName);
+  const envPath = path.join(root, "src/core/env.ts");
+  if (!existsSync(envPath)) {
+    throw new Error("Projeto Koala Nest não encontrado. Execute o comando na raiz do projeto (com src/core/env.ts).");
+  }
+  return root;
+}
+function readProjectFile(projectName, relativePath) {
+  return readFileSync(path.join(resolveProjectPath(projectName), relativePath), "utf8");
+}
+export function detectProjectState(projectName = "") {
+  assertKoalaProject(projectName);
+  const appModule = readProjectFile(projectName, "src/host/app.module.ts");
+  const authModulePath = path.join(resolveProjectPath(projectName), "src/host/controllers/auth/auth.module.ts");
+  const authModule = existsSync(authModulePath) ? readFileSync(authModulePath, "utf8") : "";
+  const hasPersonModule = appModule.includes(ProjectMarker.PERSON_MODULE) || existsSync(path.join(resolveProjectPath(projectName), "src/host/controllers/person/person.module.ts"));
+  let auth = false;
+  if (existsSync(authModulePath) && appModule.includes(ProjectMarker.SECURITY_MODULE)) {
+    auth = resolveAuthStrategiesFromModule(authModule);
+  }
+  let cache = false;
+  const infraModule = readProjectFile(projectName, "src/infra/infra.module.ts");
+  if (infraModule.includes(ProjectMarker.CACHE_SERVICE_PROVIDER)) {
+    const hasRedisFile = existsSync(path.join(resolveProjectPath(projectName), "src/infra/common/redis-cache.service.ts"));
+    cache = hasRedisFile ? "redis" : "memory";
+  }
+  return {
+    template: hasPersonModule ? Template.CRUD_SAMPLE : Template.DEFAULT,
+    auth,
+    cache,
+    health: appModule.includes(ProjectMarker.HEALTH_CHECK_MODULE),
+    cronJobs: existsSync(path.join(resolveProjectPath(projectName), "src/core/utils/cron-expression-to-boolean.ts")),
+    eventJobs: existsSync(path.join(resolveProjectPath(projectName), "src/core/background-services/event-service/event-handler.base.ts"))
+  };
+}
+export function listAvailableAddOptions(state) {
+  const features = [];
+  if (state.cache !== "redis") {
+    features.push(ExtraFeature.CACHE);
+  }
+  if (!state.health) {
+    features.push(ExtraFeature.HEALTH_CHECK);
+  }
+  if (!state.cronJobs) {
+    features.push(ExtraFeature.INTERNAL_CRON_JOBS);
+  }
+  if (!state.eventJobs) {
+    features.push(ExtraFeature.INTERNAL_EVENT_JOBS);
+  }
+  return {
+    authStrategies: listMissingAuthStrategies(state.auth),
+    features
+  };
+}
+export function parseAddArgs(args) {
+  const parsed = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index]?.toLowerCase();
+    if (!arg) {
+      continue;
+    }
+    if (arg === AddArgKind.AUTH) {
+      const strategies = [];
+      let cursor = index + 1;
+      while (cursor < args.length) {
+        const strategy = args[cursor]?.toLowerCase();
+        if (!strategy || !isAuthStrategy(strategy)) {
+          break;
+        }
+        strategies.push(strategy);
+        cursor += 1;
+      }
+      if (strategies.length === 0) {
+        throw new Error("Use: kl-nest add auth jwt  ou  kl-nest add auth oauth2  ou  kl-nest add auth jwt oauth2");
+      }
+      parsed.push({
+        kind: AddArgKind.AUTH,
+        strategies: Array.from(new Set(strategies))
+      });
+      index = cursor - 1;
+      continue;
+    }
+    const feature = FEATURE_ALIASES[arg];
+    if (!feature) {
+      throw new Error(`Opção desconhecida: "${args[index]}". Use: cache, auth, health, cron, events.`);
+    }
+    parsed.push({ kind: AddArgKind.FEATURE, feature });
+  }
+  return parsed;
+}
+export function dedupeAddArgs(args) {
+  const seenFeatures = new Set;
+  const authStrategies = new Set;
+  const result = [];
+  for (const arg of args) {
+    if (arg.kind === AddArgKind.AUTH) {
+      for (const strategy of arg.strategies) {
+        authStrategies.add(strategy);
+      }
+      continue;
+    }
+    if (!seenFeatures.has(arg.feature)) {
+      seenFeatures.add(arg.feature);
+      result.push(arg);
+    }
+  }
+  if (authStrategies.size > 0) {
+    result.unshift({
+      kind: AddArgKind.AUTH,
+      strategies: Array.from(authStrategies)
+    });
+  }
+  return result;
+}
+
+export { mergeAuthStrategies };

package/cli/utils/format-code.js

@@ -0,0 +1,9 @@
+import { getPackageManager } from "./get-package-manager.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+import { runCommand } from "./run-command.js";
+export async function formatCode(projectName) {
+  if (process.env.CI === "1" || process.env.KOALA_SKIP_FORMAT === "1") {
+    return;
+  }
+  await runCommand([getPackageManager(projectName), "run", "format"], resolveProjectPath(projectName));
+}

package/cli/utils/get-package-manager.js

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { resolveProjectPath } from "./resolve-project-path.js";
+export function getPackageManager(projectName) {
+  const packageJson = JSON.parse(readFileSync(path.join(resolveProjectPath(projectName), "package.json"), "utf8"));
+  const raw = packageJson.packageManager ?? "bun";
+  const manager = raw.split("@")[0];
+  if (manager === "npm" || manager === "pnpm" || manager === "bun") {
+    return manager;
+  }
+  return "bun";
+}

package/cli/utils/get-package-root.js

@@ -0,0 +1,19 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function isPackageRoot(dir) {
+  if (!existsSync(path.join(dir, "package.json"))) {
+    return false;
+  }
+  return existsSync(path.join(dir, "koala-nest")) || existsSync(path.join(dir, "libs", "koala-nest"));
+}
+export function getPackageRoot(fromUrl = import.meta.url) {
+  let dir = path.dirname(fileURLToPath(fromUrl));
+  while (dir !== path.dirname(dir)) {
+    if (isPackageRoot(dir)) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error("Não foi possível resolver a raiz do pacote koala-nest.");
+}

package/cli/utils/get-source-code-path.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { getPackageRoot } from "./get-package-root.js";
+export function getSourceCodePath() {
+  const root = getPackageRoot(import.meta.url);
+  const distTemplate = path.join(root, "dist", "koala-nest");
+  if (existsSync(distTemplate)) {
+    return distTemplate;
+  }
+  const publishedTemplate = path.join(root, "koala-nest");
+  if (existsSync(publishedTemplate)) {
+    return publishedTemplate;
+  }
+  return path.join(root, "libs", "koala-nest");
+}

package/cli/utils/install-module.js

@@ -0,0 +1,258 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import {
+  AUTH_DEV_PACKAGES,
+  AUTH_PACKAGES,
+  CACHE_PACKAGES,
+  CORE_PACKAGES,
+  CRON_PACKAGES,
+  devAddFlag,
+  HEALTH_PACKAGES
+} from "../constants/core-packages.js";
+import {
+  AuthChoice,
+  AuthStrategy,
+  ExtraFeature,
+  InstallModule as Modules,
+  Template
+} from "../constants/domain.js";
+import { getSourceCodePath } from "./get-source-code-path.js";
+import {
+  patchAppModuleForHealth,
+  patchHealthCheckWithoutRedis
+} from "./patch-health-module.js";
+import {
+  patchInfraModuleForAuth,
+  patchInfraModuleForCache,
+  stripInfraModuleCache
+} from "./patch-infra-module.js";
+import { patchAuthInstall } from "./patch-auth-install.js";
+import { patchMainForAuth, stripMainOptionalFeatures } from "./patch-main.js";
+import { restoreDefineDocumentationWithAuth } from "./patch-define-documentation.js";
+import { pruneCoreAuthForSlimTemplate } from "./prune-core-auth.js";
+import { removeSampleParts } from "./remove-sample-parts.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+import { runCommand } from "./run-command.js";
+import { getPackageManager } from "./get-package-manager.js";
+export {
+  AuthChoice,
+  AuthStrategy,
+  CRUD_BUNDLED_FEATURES,
+  ExtraFeature,
+  InstallModule as Modules,
+  mapExtraFeatureToModule,
+  mergeCrudSampleFeatures,
+  resolveNewProjectOptions,
+  Template
+} from "../constants/domain.js";
+function install(modulePath, projectName) {
+  const koalaNestPath = path.join(getSourceCodePath(), modulePath);
+  const projectPath = path.join(resolveProjectPath(projectName), modulePath);
+  mkdirSync(path.dirname(projectPath), { recursive: true });
+  cpSync(koalaNestPath, projectPath, { recursive: true, force: true });
+}
+async function installPackages(projectName, packages, devPackages = []) {
+  const packageManager = getPackageManager(projectName);
+  const projectPath = resolveProjectPath(projectName);
+  if (packages.length > 0) {
+    await runCommand([packageManager, "add", ...packages], projectPath);
+  }
+  if (devPackages.length > 0) {
+    await runCommand([packageManager, "add", devAddFlag(packageManager), ...devPackages], projectPath);
+  }
+}
+function patchInfraModuleFile(projectName, withCache) {
+  const infraModulePath = path.join(resolveProjectPath(projectName), "src/infra/infra.module.ts");
+  const content = readFileSync(infraModulePath, "utf8");
+  writeFileSync(infraModulePath, withCache ? patchInfraModuleForCache(content) : stripInfraModuleCache(content));
+}
+function patchInfraModuleAuthFile(projectName) {
+  const infraModulePath = path.join(resolveProjectPath(projectName), "src/infra/infra.module.ts");
+  writeFileSync(infraModulePath, patchInfraModuleForAuth(readFileSync(infraModulePath, "utf8")));
+}
+function patchAppModuleFile(projectName, replacer) {
+  const appModulePath = path.join(resolveProjectPath(projectName), "src/host/app.module.ts");
+  writeFileSync(appModulePath, replacer(readFileSync(appModulePath, "utf8")));
+}
+function patchMainFile(projectName, replacer) {
+  const mainPath = path.join(resolveProjectPath(projectName), "src/host/main.ts");
+  writeFileSync(mainPath, replacer(readFileSync(mainPath, "utf8")));
+}
+function installCacheInfrastructure(projectName, withRedis) {
+  install("src/domain/common/icache.service.ts", projectName);
+  install("src/domain/common/ired-lock.service.ts", projectName);
+  install("src/infra/common/in-memory-cache.service.ts", projectName);
+  install("src/infra/common/cache-service.provider.ts", projectName);
+  install("src/infra/common/red-lock.service.ts", projectName);
+  if (withRedis) {
+    install("src/infra/common/redis-cache.service.ts", projectName);
+  } else {
+    rmSync(path.join(resolveProjectPath(projectName), "src/infra/common/redis-cache.service.ts"), { force: true });
+    let provider = readFileSync(path.join(resolveProjectPath(projectName), "src/infra/common/cache-service.provider.ts"), "utf8");
+    provider = provider.replace(`import { RedisCacheService } from '@/infra/common/redis-cache.service';
+`, "").replace(/const redisUrl = env\.get\('REDIS_CONNECTION_STRING'\);\n\n {4}this\.delegate = redisUrl\n {6}\? new RedisCacheService\(redisUrl, this\.resolveKeyPrefix\(env\)\)\n {6}: new InMemoryCacheService\(\);/, "this.delegate = new InMemoryCacheService();");
+    writeFileSync(path.join(resolveProjectPath(projectName), "src/infra/common/cache-service.provider.ts"), provider);
+  }
+  patchInfraModuleFile(projectName, true);
+}
+export async function installModule(module, template, projectName = "", options = {}) {
+  switch (module) {
+    case Modules.CORE: {
+      install("src/application/common", projectName);
+      install("src/application/mapping/mapping.provider.ts", projectName);
+      install("src/core", projectName);
+      install("src/domain/common/ilogging.service.ts", projectName);
+      install("src/domain/dtos/pagination.dto.ts", projectName);
+      install("src/host/controllers/common", projectName);
+      install("src/host/decorators", projectName);
+      install("src/host/filters", projectName);
+      install("src/host/open-api", projectName);
+      install("src/host/jobs", projectName);
+      install("src/host/app.module.ts", projectName);
+      install("src/host/main.ts", projectName);
+      install("src/infra/common/env.service.ts", projectName);
+      install("src/infra/common/logging.service.ts", projectName);
+      install("src/infra/services", projectName);
+      install("src/infra/database/migrations/generate-migration.ts", projectName);
+      install("src/infra/database/migrations/migration-datasource.ts", projectName);
+      install("src/infra/database/data-source-factory.ts", projectName);
+      install("src/infra/database/database.module.ts", projectName);
+      install("src/infra/repositories/repository.base.ts", projectName);
+      install("src/infra/repositories/repository.module.ts", projectName);
+      install("src/infra/infra.module.ts", projectName);
+      install("src/test", projectName);
+      rmSync(path.join(resolveProjectPath(projectName), "src/core/background-services"), { recursive: true, force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/core/utils/cron-expression-to-boolean.ts"), { force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/core/utils/person-list-cache.ts"), { force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/core/utils/build-list-cache-key.ts"), { force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/host/bootstrap"), {
+        recursive: true,
+        force: true
+      });
+      rmSync(path.join(resolveProjectPath(projectName), "src/host/controllers/health-check"), { recursive: true, force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/infra/services/database.indicator.service.ts"), { force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/infra/services/redis.indicator.service.ts"), { force: true });
+      rmSync(path.join(resolveProjectPath(projectName), "src/infra/services/logged-user-info.service.ts"), { force: true });
+      pruneCoreAuthForSlimTemplate(projectName);
+      const projectPath = resolveProjectPath(projectName);
+      const packageManager = getPackageManager(projectName);
+      rmSync(path.join(projectPath, "src/test/cli"), {
+        recursive: true,
+        force: true
+      });
+      if (packageManager === "bun") {
+        cpSync(path.join(getSourceCodePath(), "bunfig.toml"), path.join(projectPath, "bunfig.toml"));
+      }
+      for (const configFile of ["tsconfig.build.json", ".env.example"]) {
+        cpSync(path.join(getSourceCodePath(), configFile), path.join(projectPath, configFile));
+      }
+      patchInfraModuleFile(projectName, false);
+      patchMainFile(projectName, stripMainOptionalFeatures);
+      if (!options.skipPackages) {
+        await installPackages(projectName, CORE_PACKAGES);
+      }
+      if (template === Template.DEFAULT) {
+        await removeSampleParts(projectName);
+      } else {
+        install("src/application/mapping", projectName);
+        install("src/application/person", projectName);
+        install("src/domain/entities", projectName);
+        install("src/domain/repositories", projectName);
+        install("src/domain/dtos", projectName);
+        install("src/host/controllers/person", projectName);
+        install("src/infra/repositories/person.repository.ts", projectName);
+        install("src/infra/database/migrations", projectName);
+      }
+      break;
+    }
+    case Modules.AUTH: {
+      install("src/application/auth", projectName);
+      install("src/domain/dtos/logged-user-info.dto.ts", projectName);
+      install("src/domain/services", projectName);
+      install("src/domain/auth", projectName);
+      install("src/domain/entities/user", projectName);
+      install("src/domain/repositories/iuser.repository.ts", projectName);
+      install("src/infra/auth", projectName);
+      install("src/infra/repositories/user.repository.ts", projectName);
+      install("src/infra/services/logged-user-info.service.ts", projectName);
+      install("src/core/utils/hash-password.ts", projectName);
+      install("src/core/utils/name-to-login.ts", projectName);
+      const initMigration = "src/infra/database/migrations/1781281330533-Init.ts";
+      if (!existsSync(path.join(resolveProjectPath(projectName), initMigration))) {
+        install(initMigration, projectName);
+      }
+      install("src/host/security", projectName);
+      install("src/host/controllers/auth", projectName);
+      install("src/host/controllers/oauth2", projectName);
+      install("src/core/auth", projectName);
+      install("src/core/types/auth-provider-config-response.type.ts", projectName);
+      install("src/host/decorators/scalar-token-endpoint.decorator.ts", projectName);
+      install("src/host/decorators/restriction-by-profile.decorator.ts", projectName);
+      restoreDefineDocumentationWithAuth(projectName);
+      if (!options.skipPackages) {
+        await installPackages(projectName, AUTH_PACKAGES, AUTH_DEV_PACKAGES);
+      }
+      patchMainFile(projectName, patchMainForAuth);
+      patchInfraModuleAuthFile(projectName);
+      await patchAuthInstall(projectName, options.authStrategies?.length ? options.authStrategies : [AuthStrategy.JWT]);
+      break;
+    }
+    case Modules.CACHE: {
+      installCacheInfrastructure(projectName, options.withRedis ?? false);
+      if (options.withRedis && !options.skipPackages) {
+        await installPackages(projectName, CACHE_PACKAGES);
+      }
+      if (template === Template.CRUD_SAMPLE) {
+        install("src/core/utils/person-list-cache.ts", projectName);
+        install("src/core/utils/build-list-cache-key.ts", projectName);
+      }
+      break;
+    }
+    case Modules.HEALTH: {
+      install("src/host/controllers/health-check", projectName);
+      install("src/infra/services/database.indicator.service.ts", projectName);
+      if (options.withRedisIndicator) {
+        install("src/infra/services/redis.indicator.service.ts", projectName);
+      } else {
+        patchHealthCheckWithoutRedis(projectName);
+      }
+      patchAppModuleFile(projectName, patchAppModuleForHealth);
+      if (!options.skipPackages) {
+        await installPackages(projectName, HEALTH_PACKAGES);
+      }
+      break;
+    }
+    case Modules.INTERNAL_CRON_JOBS: {
+      install("src/core/background-services/cron-service", projectName);
+      install("src/core/utils/cron-expression-to-boolean.ts", projectName);
+      if (!options.skipPackages) {
+        await installPackages(projectName, CRON_PACKAGES);
+      }
+      break;
+    }
+    case Modules.INTERNAL_EVENT_JOBS: {
+      install("src/core/background-services/event-service", projectName);
+      break;
+    }
+  }
+}
+export function resolveProjectFeatures(features, auth) {
+  const selected = new Set(features);
+  const cacheWithRedis = selected.has(ExtraFeature.CACHE);
+  const needsMemoryCache = cacheWithRedis || auth.length > 0 || selected.has(ExtraFeature.INTERNAL_CRON_JOBS);
+  return {
+    cache: needsMemoryCache,
+    cacheWithRedis,
+    cacheForCrud: cacheWithRedis,
+    health: selected.has(ExtraFeature.HEALTH_CHECK),
+    cronJobs: selected.has(ExtraFeature.INTERNAL_CRON_JOBS),
+    eventJobs: selected.has(ExtraFeature.INTERNAL_EVENT_JOBS)
+  };
+}

package/cli/utils/normalize-add-args.js

@@ -0,0 +1,25 @@
+import {
+  AddArgKind,
+  ExtraFeature,
+  FEATURE_INSTALL_ORDER
+} from "../constants/domain.js";
+export function normalizeAddArgs(args) {
+  const auth = args.find((item) => item.kind === AddArgKind.AUTH);
+  const selectedFeatures = new Set(args.filter((item) => item.kind === AddArgKind.FEATURE).map((item) => item.feature));
+  const ordered = [];
+  for (const feature of FEATURE_INSTALL_ORDER) {
+    if (selectedFeatures.has(feature)) {
+      ordered.push({ kind: AddArgKind.FEATURE, feature });
+    }
+  }
+  if (auth) {
+    const cacheIndex = ordered.findIndex((item) => item.kind === AddArgKind.FEATURE && item.feature === ExtraFeature.CACHE);
+    const authArg = auth;
+    if (cacheIndex >= 0) {
+      ordered.splice(cacheIndex + 1, 0, authArg);
+    } else {
+      ordered.unshift(authArg);
+    }
+  }
+  return ordered;
+}