@koalarx/nest 3.1.50 → 4.0.2

package/cli/commands/add/index.js

@@ -0,0 +1,97 @@
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import {
+  AddArgKind,
+  AuthStrategy,
+  ExtraFeature,
+  FEATURE_PROMPT_LABELS
+} from "../../constants/domain.js";
+import { addProjectFeatures } from "../../utils/add-project-features.js";
+import { assertNotCancel } from "../../utils/cancel.js";
+import {
+  assertKoalaProject,
+  dedupeAddArgs,
+  detectProjectState,
+  listAvailableAddOptions,
+  parseAddArgs
+} from "../../utils/detect-project-state.js";
+function formatResultSummary(results) {
+  if (results.length === 0) {
+    return color.dim("Nenhuma alteração necessária.");
+  }
+  return results.map((result) => {
+    if (result.installed) {
+      return `${color.green("✓")} ${result.label}`;
+    }
+    return `${color.yellow("○")} ${result.label} — ${result.reason ?? "já instalado"}`;
+  }).join(`
+`);
+}
+async function resolveAddArgsFromPrompt() {
+  const state = detectProjectState(".");
+  const available = listAvailableAddOptions(state);
+  const args = [];
+  if (available.authStrategies.length > 0) {
+    const authStrategies = assertNotCancel(await p.multiselect({
+      message: "Estratégias de autenticação para adicionar",
+      options: [
+        {
+          value: AuthStrategy.JWT,
+          label: "JWT",
+          hint: "RS256 + guards globais"
+        },
+        {
+          value: AuthStrategy.OAUTH2,
+          label: "OAuth2",
+          hint: "JWT + OAuth2 genérico"
+        }
+      ].filter((option) => available.authStrategies.includes(option.value)),
+      required: false
+    }));
+    if (authStrategies.length > 0) {
+      args.push({ kind: AddArgKind.AUTH, strategies: authStrategies });
+    }
+  }
+  if (available.features.length > 0) {
+    const features = assertNotCancel(await p.multiselect({
+      message: "Funcionalidades para adicionar",
+      options: available.features.map((feature) => ({
+        value: feature,
+        label: FEATURE_PROMPT_LABELS[feature]
+      })),
+      required: false
+    }));
+    for (const feature of features) {
+      args.push({ kind: AddArgKind.FEATURE, feature });
+    }
+  }
+  return dedupeAddArgs(args);
+}
+export async function runAdd(rawArgs = process.argv.slice(3)) {
+  p.intro(`${color.bgCyan(color.black(" koala-nest "))} ${color.dim("Adicionar funcionalidades")}`);
+  assertKoalaProject(".");
+  const state = detectProjectState(".");
+  const available = listAvailableAddOptions(state);
+  if (available.authStrategies.length === 0 && available.features.length === 0) {
+    p.outro(color.green("Este projeto já possui todas as funcionalidades disponíveis."));
+    return;
+  }
+  let args;
+  try {
+    args = rawArgs.length > 0 ? dedupeAddArgs(parseAddArgs(rawArgs)) : await resolveAddArgsFromPrompt();
+  } catch (error) {
+    p.cancel(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (args.length === 0) {
+    p.cancel("Nenhuma funcionalidade selecionada.");
+    process.exit(0);
+  }
+  const spinner = p.spinner();
+  spinner.start("Instalando funcionalidades...");
+  const results = await addProjectFeatures(".", args);
+  spinner.stop("Instalação concluída.");
+  p.note(formatResultSummary(results), "Resumo");
+  p.outro(color.green("Funcionalidades aplicadas.") + color.dim(`
+Revise o .env e reinicie a aplicação se necessário.`));
+}

package/cli/commands/help.js

@@ -0,0 +1,44 @@
+import color from "picocolors";
+import { CLI_VERSION } from "../constants/version.js";
+export function printHelp() {
+  console.log(`
+${color.bold("Koala Nest CLI")} ${color.dim(`v${CLI_VERSION}`)}
+
+${color.cyan("Uso:")}
+  kl-nest ${color.dim("<comando>")} ${color.dim("[opções]")}
+
+${color.cyan("Opções globais:")}
+  ${color.dim("--verbose")}   Exibe a saída dos comandos externos (npm, bun, nest, …)
+
+${color.cyan("New — opções:")}
+  ${color.dim("-y, --yes")}          Pula perguntas e cria com os argumentos informados
+  ${color.dim("<nome>")}              Nome do projeto (não pergunta de novo se já informado)
+  ${color.dim("--template, -t")}     ${color.dim("default")} ou ${color.dim("crud")}
+  ${color.dim("--pm")}                 ${color.dim("bun")}, ${color.dim("npm")} ou ${color.dim("pnpm")}
+  ${color.dim("--auth")}               ${color.dim("none")}, ${color.dim("jwt")} ou ${color.dim("oauth2")}
+  ${color.dim("--features")}           ${color.dim("cache,health,cron,events")} (vírgula)
+
+${color.cyan("Comandos:")}
+  ${color.green("new")}       Cria um novo projeto
+  ${color.green("add")}       Adiciona funcionalidades a um projeto existente
+  ${color.green("version")}   Exibe a versão da CLI
+  ${color.green("help")}      Exibe esta ajuda
+
+${color.cyan("Add — funcionalidades:")}
+  ${color.dim("auth jwt|oauth2")}   Autenticação
+  ${color.dim("cache")}             Cache Redis (+ exemplos no CRUD)
+  ${color.dim("health")}            GET /health
+  ${color.dim("cron")}              Jobs com expressão cron
+  ${color.dim("events")}            Jobs reativos a eventos
+
+${color.cyan("Exemplos:")}
+  kl-nest new example
+  kl-nest new my-api -y --template default --pm bun --auth none
+  kl-nest new my-api -y --template crud --pm bun --auth jwt
+  kl-nest new --verbose
+  kl-nest add cache
+  kl-nest add auth jwt health --verbose
+  kl-nest add cron events
+  kl-nest version
+`);
+}

package/cli/commands/new/configure-test-runner.js

@@ -0,0 +1,13 @@
+export function configureTestRunner(packageJson, packageManager) {
+  const scripts = packageJson.scripts;
+  const devDependencies = packageJson.devDependencies;
+  if (packageManager === "bun") {
+    scripts.test = "bun test";
+    scripts["test:watch"] = "bun test --watch";
+    return;
+  }
+  scripts.test = "vitest run";
+  scripts["test:watch"] = "vitest";
+  devDependencies.vitest = "^4.1.8";
+  devDependencies["vite-tsconfig-paths"] = "^5.1.4";
+}

package/cli/commands/new/create-ddd-structure.js

@@ -0,0 +1,52 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { DDD_LAYER_FOLDERS } from "../../constants/domain.js";
+import { patchGeneratedProjectConfig } from "../../utils/patch-generated-project.js";
+import { runCommand } from "../../utils/run-command.js";
+import { configureTestRunner } from "./configure-test-runner.js";
+export async function createDDDStructure(projectName, packageManager) {
+  const folders = [...DDD_LAYER_FOLDERS];
+  for (const folder of folders) {
+    mkdirSync(path.join(process.cwd(), projectName, folder), {
+      recursive: true
+    });
+  }
+  rmSync(path.join(process.cwd(), projectName, "test"), {
+    recursive: true,
+    force: true
+  });
+  rmSync(path.join(process.cwd(), projectName, "src/app.controller.spec.ts"), {
+    force: true
+  });
+  rmSync(path.join(process.cwd(), projectName, "src/app.controller.ts"), {
+    force: true
+  });
+  rmSync(path.join(process.cwd(), projectName, "src/app.module.ts"), {
+    force: true
+  });
+  rmSync(path.join(process.cwd(), projectName, "src/app.service.ts"), {
+    force: true
+  });
+  rmSync(path.join(process.cwd(), projectName, "src/main.ts"), { force: true });
+  const packageJson = JSON.parse(readFileSync(path.join(process.cwd(), projectName, "package.json"), "utf8"));
+  packageJson.packageManager = packageManager;
+  const migrationDatasource = "-d ./src/infra/database/migrations/migration-datasource.ts";
+  const typeormCli = "./node_modules/typeorm/cli.js";
+  const migrationRunner = packageManager === "bun" ? "bun" : "node --import ts-node/register/transpile-only";
+  packageJson.scripts["migration:generate"] = packageManager === "bun" ? "bun ./src/infra/database/migrations/generate-migration.ts" : "node --import ts-node/register/transpile-only ./src/infra/database/migrations/generate-migration.ts";
+  packageJson.scripts["migration:run"] = `${migrationRunner} ${typeormCli} migration:run ${migrationDatasource}`;
+  packageJson.scripts["migration:revert"] = `${migrationRunner} ${typeormCli} migration:revert ${migrationDatasource}`;
+  packageJson.devDependencies ??= {};
+  configureTestRunner(packageJson, packageManager);
+  delete packageJson.scripts["test:cov"];
+  delete packageJson.scripts["test:debug"];
+  delete packageJson.scripts["test:e2e"];
+  delete packageJson.jest;
+  delete packageJson.devDependencies["@types/jest"];
+  delete packageJson.devDependencies["@types/supertest"];
+  delete packageJson.devDependencies["ts-jest"];
+  delete packageJson.devDependencies["supertest"];
+  writeFileSync(path.join(process.cwd(), projectName, "package.json"), JSON.stringify(packageJson, null, 2));
+  patchGeneratedProjectConfig(path.join(process.cwd(), projectName));
+  await runCommand([packageManager, "install"], path.join(process.cwd(), projectName));
+}

package/cli/commands/new/create-empty-nest-project.js

@@ -0,0 +1,58 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { PackageManagerRunner } from "../../constants/package-manager.js";
+import { runCommand } from "../../utils/run-command.js";
+function updatePackageName(projectDir, projectName) {
+  const packageJsonPath = path.join(projectDir, "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  packageJson.name = projectName;
+  writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+}
+function copyScaffoldFromCache(scaffoldCache, projectName, cwd) {
+  const projectDir = path.join(cwd, projectName);
+  cpSync(scaffoldCache, projectDir, { recursive: true });
+  updatePackageName(projectDir, projectName);
+}
+function persistScaffoldCache(projectDir, scaffoldCache) {
+  rmSync(scaffoldCache, { recursive: true, force: true });
+  mkdirSync(scaffoldCache, { recursive: true });
+  cpSync(projectDir, scaffoldCache, { recursive: true });
+}
+export async function createEmptyNestProject(projectName, packageManager) {
+  const cwd = process.cwd();
+  const projectDir = path.join(cwd, projectName);
+  const scaffoldCache = process.env.KOALA_NEST_SCAFFOLD_CACHE;
+  if (scaffoldCache && packageManager === "bun" && existsSync(path.join(scaffoldCache, "node_modules"))) {
+    copyScaffoldFromCache(scaffoldCache, projectName, cwd);
+    return;
+  }
+  const command = PackageManagerRunner[packageManager];
+  await runCommand([
+    command,
+    "@nestjs/cli",
+    "new",
+    projectName,
+    "--package-manager",
+    "npm",
+    "--skip-git"
+  ]);
+  if (packageManager !== "npm") {
+    rmSync(path.join(cwd, projectName, "package-lock.json"));
+    rmSync(path.join(cwd, projectName, "node_modules"), {
+      recursive: true
+    });
+  }
+  await runCommand([packageManager, "install"], projectDir);
+  const scaffoldCacheBuild = process.env.KOALA_NEST_SCAFFOLD_CACHE_BUILD;
+  if (scaffoldCacheBuild && packageManager === "bun") {
+    persistScaffoldCache(projectDir, scaffoldCacheBuild);
+  }
+}

package/cli/commands/new/fix-lint-config.js

@@ -0,0 +1,24 @@
+import { cpSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { getSourceCodePath } from "../../utils/get-source-code-path.js";
+import { resolveProjectPath } from "../../utils/resolve-project-path.js";
+export function fixLintConfig(projectName) {
+  const projectPath = resolveProjectPath(projectName);
+  const tsconfigPath = path.join(projectPath, "tsconfig.json");
+  const tsconfigProjectContent = JSON.parse(readFileSync(tsconfigPath, "utf8"));
+  tsconfigProjectContent.compilerOptions ??= {};
+  tsconfigProjectContent.compilerOptions.baseUrl = "./";
+  tsconfigProjectContent.compilerOptions.paths = {
+    ...tsconfigProjectContent.compilerOptions.paths ?? {},
+    "@/*": ["./src/*"]
+  };
+  writeFileSync(tsconfigPath, `${JSON.stringify(tsconfigProjectContent, null, 2)}
+`);
+  const eslintKoalaNestConfig = path.join(getSourceCodePath(), "eslint.config.mjs");
+  const eslintProjectConfig = path.join(projectPath, "eslint.config.mjs");
+  cpSync(eslintKoalaNestConfig, eslintProjectConfig, { force: true });
+  const packageJsonProjectContent = JSON.parse(readFileSync(path.join(projectPath, "package.json"), "utf8"));
+  packageJsonProjectContent.scripts.lint = 'eslint "src/**/*.ts" --fix';
+  packageJsonProjectContent.scripts.format = 'prettier --write "src/**/*.ts"';
+  writeFileSync(path.join(projectPath, "package.json"), JSON.stringify(packageJsonProjectContent, null, 2));
+}

package/cli/commands/new/index.js

@@ -0,0 +1,202 @@
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import { assertNotCancel } from "../../utils/cancel.js";
+import { applyOptionalFeatures } from "../../utils/apply-optional-features.js";
+import {
+  buildNewProjectConfig,
+  parseNewArgs
+} from "../../utils/parse-new-args.js";
+import { createEmptyNestProject } from "./create-empty-nest-project.js";
+import { createDDDStructure } from "./create-ddd-structure.js";
+import {
+  AuthStrategy,
+  CRUD_BUNDLED_FEATURES,
+  DEFAULT_PACKAGE_MANAGER,
+  ExtraFeature,
+  FEATURE_LABELS,
+  FEATURE_PROMPT_LABELS,
+  formatAuthStrategies,
+  Template,
+  TEMPLATE_LABELS
+} from "../../constants/domain.js";
+import {
+  installModule,
+  Modules,
+  resolveNewProjectOptions,
+  resolveProjectFeatures
+} from "../../utils/install-module.js";
+import { fixLintConfig } from "./fix-lint-config.js";
+async function promptAuthStrategies(template) {
+  const isCrud = template === Template.CRUD_SAMPLE;
+  return assertNotCancel(await p.multiselect({
+    message: isCrud ? "Estratégias de autenticação (incluídas no exemplo CRUD)" : "Estratégias de autenticação",
+    options: [
+      {
+        value: AuthStrategy.JWT,
+        label: "JWT",
+        hint: "RS256 + guards globais"
+      },
+      {
+        value: AuthStrategy.OAUTH2,
+        label: "OAuth2",
+        hint: "JWT + OAuth2 genérico"
+      },
+      {
+        value: "api-key",
+        label: "API Key",
+        hint: "em breve",
+        disabled: true
+      }
+    ],
+    required: isCrud
+  }));
+}
+async function promptExtraFeatures(template) {
+  if (template === Template.CRUD_SAMPLE) {
+    const bundled = CRUD_BUNDLED_FEATURES.map((feature) => FEATURE_LABELS[feature]).join(", ");
+    p.note(`O exemplo CRUD já inclui: ${bundled} e autenticação.
+` + "Escolha abaixo apenas funcionalidades adicionais.", "Incluso no template");
+    return assertNotCancel(await p.multiselect({
+      message: "Funcionalidades extras adicionais",
+      options: [
+        {
+          value: ExtraFeature.HEALTH_CHECK,
+          label: FEATURE_PROMPT_LABELS[ExtraFeature.HEALTH_CHECK]
+        }
+      ],
+      required: false
+    }));
+  }
+  return assertNotCancel(await p.multiselect({
+    message: "Funcionalidades extras",
+    options: [
+      {
+        value: ExtraFeature.CACHE,
+        label: FEATURE_PROMPT_LABELS[ExtraFeature.CACHE],
+        hint: "ICacheService + ioredis"
+      },
+      {
+        value: ExtraFeature.HEALTH_CHECK,
+        label: FEATURE_PROMPT_LABELS[ExtraFeature.HEALTH_CHECK]
+      },
+      {
+        value: ExtraFeature.INTERNAL_CRON_JOBS,
+        label: FEATURE_PROMPT_LABELS[ExtraFeature.INTERNAL_CRON_JOBS],
+        hint: "cron-parser + bases"
+      },
+      {
+        value: ExtraFeature.INTERNAL_EVENT_JOBS,
+        label: FEATURE_PROMPT_LABELS[ExtraFeature.INTERNAL_EVENT_JOBS],
+        hint: "EventJob + bases"
+      }
+    ],
+    required: false
+  }));
+}
+async function promptProjectName() {
+  return assertNotCancel(await p.text({
+    message: "Nome do projeto",
+    placeholder: "my-api",
+    validate: (value) => value ? undefined : "Campo obrigatório"
+  }));
+}
+async function promptPackageManager() {
+  return assertNotCancel(await p.select({
+    message: "Gerenciador de pacotes",
+    options: [
+      { value: "bun", label: "Bun", hint: "recomendado" },
+      { value: "npm", label: "npm" },
+      { value: "pnpm", label: "pnpm" }
+    ]
+  }));
+}
+async function promptTemplate() {
+  return assertNotCancel(await p.select({
+    message: "Template",
+    options: [
+      {
+        value: Template.DEFAULT,
+        label: TEMPLATE_LABELS[Template.DEFAULT],
+        hint: "sem código de exemplo"
+      },
+      {
+        value: Template.CRUD_SAMPLE,
+        label: TEMPLATE_LABELS[Template.CRUD_SAMPLE],
+        hint: "Person + auth, cache e jobs"
+      }
+    ]
+  }));
+}
+async function resolveProjectInput(args) {
+  const parsed = parseNewArgs(args);
+  if (parsed.interactive) {
+    const name = parsed.projectName ?? await promptProjectName();
+    const packageManager = parsed.packageManager ?? await promptPackageManager();
+    const template = parsed.template ?? await promptTemplate();
+    const auth = parsed.auth ?? await promptAuthStrategies(template);
+    const features = parsed.features.length > 0 ? parsed.features : await promptExtraFeatures(template);
+    return buildNewProjectConfig(parsed, {
+      name,
+      packageManager,
+      template,
+      auth,
+      features
+    });
+  }
+  if (!parsed.projectName) {
+    throw new Error("Informe o nome do projeto com -y. Ex.: kl-nest new my-api -y --template default --pm bun --auth none");
+  }
+  return buildNewProjectConfig(parsed, {
+    name: parsed.projectName,
+    packageManager: DEFAULT_PACKAGE_MANAGER,
+    template: Template.DEFAULT,
+    auth: [],
+    features: []
+  });
+}
+export async function runNew(args = []) {
+  p.intro(`${color.bgCyan(color.black(" koala-nest "))} ${color.dim("Criar novo projeto")}`);
+  let project;
+  try {
+    project = await resolveProjectInput(args);
+  } catch (error) {
+    p.cancel(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  const { auth: authStrategies, features } = resolveNewProjectOptions(project.template, project.auth, project.features);
+  const spinner = p.spinner();
+  spinner.start("Criando projeto...");
+  await createEmptyNestProject(project.name, project.packageManager);
+  spinner.message("Definindo estrutura de pastas...");
+  await createDDDStructure(project.name, project.packageManager);
+  spinner.message("Aplicando configuração de lint...");
+  fixLintConfig(project.name);
+  spinner.message("Instalando módulo core...");
+  await installModule(Modules.CORE, project.template, project.name);
+  spinner.message("Instalando funcionalidades opcionais...");
+  await applyOptionalFeatures({
+    projectName: project.name,
+    template: project.template,
+    auth: authStrategies,
+    features
+  });
+  spinner.stop("Projeto criado com sucesso!");
+  const projectFeatures = resolveProjectFeatures(features, authStrategies);
+  const extrasSummary = [
+    project.template === Template.CRUD_SAMPLE ? color.dim("exemplo Person completo") : null,
+    projectFeatures.cacheWithRedis ? FEATURE_LABELS[ExtraFeature.CACHE] : null,
+    projectFeatures.cache && !projectFeatures.cacheWithRedis ? color.dim("cache em memória") : null,
+    projectFeatures.health ? FEATURE_LABELS[ExtraFeature.HEALTH_CHECK] : null,
+    projectFeatures.cronJobs ? FEATURE_LABELS[ExtraFeature.INTERNAL_CRON_JOBS] : null,
+    projectFeatures.eventJobs ? FEATURE_LABELS[ExtraFeature.INTERNAL_EVENT_JOBS] : null
+  ].filter(Boolean).join(", ");
+  p.note([
+    `${color.bold("Projeto:")} ${project.name}`,
+    `${color.bold("Template:")} ${TEMPLATE_LABELS[project.template]}`,
+    `${color.bold("Gerenciador:")} ${project.packageManager}`,
+    `${color.bold("Autenticação:")} ${formatAuthStrategies(authStrategies)}`,
+    `${color.bold("Extras:")} ${extrasSummary || color.dim("nenhum")}`,
+    `${color.dim("Depois:")} cd ${project.name} && kl-nest add <feature>`
+  ].join(`
+`), "Resumo");
+}

package/cli/commands/version.js

@@ -0,0 +1,5 @@
+import color from "picocolors";
+import { CLI_VERSION } from "../constants/version.js";
+export function runVersion() {
+  console.log(`${color.bold("kl-nest")} ${color.dim(`v${CLI_VERSION}`)}`);
+}

package/cli/constants/auth-strategy-artifacts.js

@@ -0,0 +1,56 @@
+export const JWT_ONLY_REMOVE_PATHS = [
+  "src/application/auth/oauth2",
+  "src/host/controllers/oauth2",
+  "src/host/decorators/scalar-token-endpoint.decorator.ts",
+  "src/domain/auth/dtos/oauth-user-info.dto.ts",
+  "src/domain/auth/dtos/auth-provider-config.dto.ts",
+  "src/infra/auth/oauth2-auth.service.ts",
+  "src/core/types/auth-provider-config-response.type.ts",
+  "src/core/auth/oauth-provider.registry.ts",
+  "src/core/auth/parse-oauth2-provider-env.ts",
+  "src/test/application/exchange-code.handler.spec.ts",
+  "src/test/application/scalar-oauth-token.handler.spec.ts",
+  "src/test/application/auth-link.handler.spec.ts",
+  "src/test/host/oauth-callback.controller.spec.ts",
+  "src/test/infra/oauth2-auth.service.spec.ts",
+  "src/test/core/oauth-provider.registry.spec.ts"
+];
+export const OAUTH2_INSTALL_PATHS = [
+  "src/application/auth/oauth2",
+  "src/host/controllers/oauth2",
+  "src/host/decorators/scalar-token-endpoint.decorator.ts",
+  "src/domain/auth/dtos/oauth-user-info.dto.ts",
+  "src/domain/auth/dtos/auth-provider-config.dto.ts",
+  "src/infra/auth/oauth2-auth.service.ts",
+  "src/core/types/auth-provider-config-response.type.ts",
+  "src/core/auth/oauth-provider.registry.ts",
+  "src/core/auth/parse-oauth2-provider-env.ts",
+  "src/test/application/exchange-code.handler.spec.ts",
+  "src/test/application/scalar-oauth-token.handler.spec.ts",
+  "src/test/application/auth-link.handler.spec.ts",
+  "src/test/host/oauth-callback.controller.spec.ts",
+  "src/test/infra/oauth2-auth.service.spec.ts",
+  "src/test/core/oauth-provider.registry.spec.ts",
+  "src/test/core/env.spec.ts"
+];
+export const OAUTH2_ONLY_REMOVE_PATHS = [
+  "src/application/auth/login",
+  "src/host/controllers/auth/login.controller.ts",
+  "src/test/application/login.handler.spec.ts"
+];
+export const JWT_ONLY_FORBIDDEN_CONTENT = [
+  "IOAuth2Service",
+  "OAuth2AuthService",
+  "OAuthProviderRegistry",
+  "OAuthUserInfoDto",
+  "AuthProviderConfigDto",
+  "parse-oauth2-provider-env",
+  "oauth-provider.registry",
+  "oauth2-auth.service",
+  "OAuthAuthLinkHandler",
+  "OAuthExchangeCodeController",
+  "ScalarOAuthTokenHandler",
+  "OAUTH2_PROVIDERS",
+  "OAUTH2_PROVIDER_ENV",
+  "parseOAuth2ProviderEnv"
+];