@koalarx/nest 3.1.50 → 4.0.1

package/cli/utils/patch-generated-project.js

@@ -0,0 +1,21 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+export function patchNestCliEntry(projectPath) {
+  const nestCliPath = path.join(projectPath, "nest-cli.json");
+  const nestCli = JSON.parse(readFileSync(nestCliPath, "utf8"));
+  nestCli.entryFile = "host/main";
+  writeFileSync(nestCliPath, `${JSON.stringify(nestCli, null, 2)}
+`);
+}
+export function patchStartProdScript(projectPath) {
+  const packageJsonPath = path.join(projectPath, "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  packageJson.scripts ??= {};
+  packageJson.scripts["start:prod"] = "node dist/host/main";
+  writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+}
+export function patchGeneratedProjectConfig(projectPath) {
+  patchNestCliEntry(projectPath);
+  patchStartProdScript(projectPath);
+}

package/cli/utils/patch-health-module.js

@@ -0,0 +1,80 @@
+import { cpSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { getSourceCodePath } from "./get-source-code-path.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+export function patchAppModuleForHealth(content) {
+  if (content.includes("HealthCheckModule")) {
+    return content;
+  }
+  return content.replace("import { Module } from '@nestjs/common';", `import { Module } from '@nestjs/common';
+import { HealthCheckModule } from './controllers/health-check/health-check.module';`).replace(/(ConfigModule\.forRoot\(\{[\s\S]*?\}\),)\n/, `$1
+    HealthCheckModule,
+`);
+}
+const healthCheckControllerWithoutRedis = `import { DatabaseIndicator } from '@/infra/services/database.indicator.service';
+import { IsPublic } from '@/host/decorators/is-public.decorator';
+import { Controller, Get } from '@nestjs/common';
+import { ApiExcludeEndpoint } from '@nestjs/swagger';
+import { HealthCheck, HealthCheckService } from '@nestjs/terminus';
+
+@Controller('health')
+export class HealthCheckController {
+  constructor(
+    private readonly health: HealthCheckService,
+    private readonly db: DatabaseIndicator,
+  ) {}
+
+  @ApiExcludeEndpoint()
+  @Get()
+  @IsPublic()
+  @HealthCheck()
+  healthCheck() {
+    return this.health.check([() => this.db.isHealthy()]);
+  }
+}
+`;
+const healthCheckModuleWithoutRedis = `import { DatabaseIndicator } from '@/infra/services/database.indicator.service';
+import { DatabaseModule } from '@/infra/database/database.module';
+import { HttpModule } from '@nestjs/axios';
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { ControllerModule } from '../common/controller.module.js';
+import { HealthCheckController } from './health-check.controller.js';
+
+@Module({
+  imports: [
+    ControllerModule,
+    DatabaseModule,
+    HttpModule,
+    TerminusModule.forRoot({
+      errorLogStyle: 'pretty',
+    }),
+  ],
+  providers: [DatabaseIndicator],
+  controllers: [HealthCheckController],
+})
+export class HealthCheckModule {}
+`;
+export function patchHealthCheckWithoutRedis(projectName) {
+  const projectRoot = resolveProjectPath(projectName);
+  writeFileSync(path.join(projectRoot, "src/host/controllers/health-check/health-check.controller.ts"), healthCheckControllerWithoutRedis, "utf8");
+  writeFileSync(path.join(projectRoot, "src/host/controllers/health-check/health-check.module.ts"), healthCheckModuleWithoutRedis, "utf8");
+}
+export function restoreRedisHealthCheck(projectName) {
+  const projectRoot = resolveProjectPath(projectName);
+  const sourceRoot = getSourceCodePath();
+  for (const relativePath of [
+    "src/infra/services/redis.indicator.service.ts",
+    "src/host/controllers/health-check/health-check.controller.ts",
+    "src/host/controllers/health-check/health-check.module.ts"
+  ]) {
+    cpSync(path.join(sourceRoot, relativePath), path.join(projectRoot, relativePath), { force: true });
+  }
+}
+export function projectHasRedisHealthCheck(projectName) {
+  const controllerPath = path.join(resolveProjectPath(projectName), "src/host/controllers/health-check/health-check.controller.ts");
+  if (!readFileSync(controllerPath, "utf8").includes("RedisIndicator")) {
+    return false;
+  }
+  return true;
+}

package/cli/utils/patch-infra-module.js

@@ -0,0 +1,62 @@
+export function patchInfraModuleForCache(content) {
+  if (content.includes("CacheServiceProvider")) {
+    return content;
+  }
+  const withAuth = content.includes("ILoggedUserInfoService");
+  let patched = content.replace("import { ILoggingService } from '@/domain/common/ilogging.service';", `import { ICacheService } from '@/domain/common/icache.service';
+import { ILoggingService } from '@/domain/common/ilogging.service';
+import { IRedLockService } from '@/domain/common/ired-lock.service';`).replace("import { LoggingService } from '@/infra/common/logging.service';", `import { CacheServiceProvider } from '@/infra/common/cache-service.provider';
+import { LoggingService } from '@/infra/common/logging.service';
+import { RedLockService } from '@/infra/common/red-lock.service';`).replace(`  providers: [
+    { provide: ILoggingService, useClass: LoggingService },`, `  providers: [
+    CacheServiceProvider,
+    { provide: ICacheService, useExisting: CacheServiceProvider },
+    { provide: ILoggingService, useClass: LoggingService },
+    { provide: IRedLockService, useClass: RedLockService },`);
+  if (withAuth) {
+    return patched.replace("  exports: [RepositoryModule, ILoggingService, ILoggedUserInfoService],", `  exports: [
+    RepositoryModule,
+    ICacheService,
+    ILoggingService,
+    IRedLockService,
+    ILoggedUserInfoService,
+  ],`);
+  }
+  return patched.replace("  exports: [RepositoryModule, ILoggingService],", `  exports: [
+    RepositoryModule,
+    ICacheService,
+    ILoggingService,
+    IRedLockService,
+  ],`);
+}
+export const SLIM_INFRA_MODULE = `import { ILoggingService } from '@/domain/common/ilogging.service';
+import { Module } from '@nestjs/common';
+import { LoggingService } from '@/infra/common/logging.service';
+import { RepositoryModule } from '@/infra/repositories/repository.module';
+
+@Module({
+  imports: [RepositoryModule],
+  providers: [{ provide: ILoggingService, useClass: LoggingService }],
+  exports: [RepositoryModule, ILoggingService],
+})
+export class InfraModule {}
+`;
+export function patchInfraModuleForAuth(content) {
+  if (content.includes("ILoggedUserInfoService")) {
+    return content;
+  }
+  let patched = content.replace("import { ILoggingService } from '@/domain/common/ilogging.service';", `import { ILoggingService } from '@/domain/common/ilogging.service';
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';`).replace("import { LoggingService } from '@/infra/common/logging.service';", `import { LoggingService } from '@/infra/common/logging.service';
+import { LoggedUserInfoService } from '@/infra/services/logged-user-info.service';`).replace("    { provide: ILoggingService, useClass: LoggingService },", `    { provide: ILoggingService, useClass: LoggingService },
+    { provide: ILoggedUserInfoService, useClass: LoggedUserInfoService },`);
+  if (patched.includes("IRedLockService,")) {
+    return patched.replace(`    IRedLockService,
+  ],`, `    IRedLockService,
+    ILoggedUserInfoService,
+  ],`);
+  }
+  return patched.replace("  exports: [RepositoryModule, ILoggingService],", "  exports: [RepositoryModule, ILoggingService, ILoggedUserInfoService],");
+}
+export function stripInfraModuleCache(_content) {
+  return SLIM_INFRA_MODULE;
+}

package/cli/utils/patch-jobs-module.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { removeImportLines } from "./project-files.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+const EXAMPLE_JOB_IMPORTS = {
+  InactivePersonHandler: "@/application/person/jobs/events/person/inactive-person/inactive-person.handler",
+  CreatePersonJob: "@/application/person/jobs/cron/create-person.job",
+  DeleteInactiveJob: "@/application/person/jobs/cron/delete-inactive.job"
+};
+const PERSON_MODULE_IMPORT = "import { PersonModule } from './controllers/person/person.module';";
+function appModulePath(projectName) {
+  return path.join(resolveProjectPath(projectName), "src/host/app.module.ts");
+}
+function hasPersonModule(projectName) {
+  return existsSync(path.join(resolveProjectPath(projectName), "src/host/controllers/person/person.module.ts"));
+}
+function hasExampleHandlers(options) {
+  return options.eventHandlers.length > 0 || options.cronJobs.length > 0;
+}
+export function buildJobsRegisterBlock(options) {
+  const eventHandlers = options.eventHandlers.length > 0 ? `[${options.eventHandlers.join(", ")}]` : "[]";
+  const cronJobs = options.cronJobs.length > 0 ? `[${options.cronJobs.join(", ")}]` : "[]";
+  const imports = hasExampleHandlers(options) ? `imports: [PersonModule],
+      ` : "";
+  return `JobsModule.register({
+      ${imports}eventHandlers: ${eventHandlers},
+      cronJobs: ${cronJobs},
+    })`;
+}
+export function ensureJobsModuleImport(content) {
+  if (/from ['"]\.\/jobs\/jobs\.module/.test(content)) {
+    return content;
+  }
+  return content.replace("import { Module } from '@nestjs/common';", `import { Module } from '@nestjs/common';
+import { JobsModule } from './jobs/jobs.module';`);
+}
+function ensurePersonModuleImport(content) {
+  if (/from ['"]\.\/controllers\/person\/person\.module/.test(content)) {
+    return content;
+  }
+  const jobsImportPattern = /import \{ JobsModule \} from ['"]\.\/jobs\/jobs\.module(?:\.js)?['"];/;
+  if (jobsImportPattern.test(content)) {
+    return content.replace(jobsImportPattern, (match) => `${match}
+${PERSON_MODULE_IMPORT}`);
+  }
+  return content.replace("import { Module } from '@nestjs/common';", `import { Module } from '@nestjs/common';
+${PERSON_MODULE_IMPORT}`);
+}
+function hasPersonModuleInAppImports(content) {
+  return /\n {4}PersonModule,\n/.test(content);
+}
+function ensurePersonModuleInAppImports(content) {
+  if (hasPersonModuleInAppImports(content)) {
+    return content;
+  }
+  return content.replace(/(JobsModule\.register\(\{[\s\S]*?\}\),)/, `$1
+    PersonModule,`);
+}
+function removePersonModuleFromAppImports(content) {
+  return content.replace(/\n {4}PersonModule,\n/g, `
+`);
+}
+export function patchAppModuleJobs(projectName, options) {
+  let content = readFileSync(appModulePath(projectName), "utf8");
+  content = removeImportLines(content, Object.values(EXAMPLE_JOB_IMPORTS));
+  content = ensureJobsModuleImport(content);
+  const exampleHandlers = hasExampleHandlers(options);
+  const crudWithPerson = hasPersonModule(projectName);
+  if (exampleHandlers) {
+    content = ensurePersonModuleImport(content);
+    content = removePersonModuleFromAppImports(content);
+  } else if (crudWithPerson) {
+    content = ensurePersonModuleImport(content);
+    content = ensurePersonModuleInAppImports(content);
+  } else {
+    content = removePersonModuleFromAppImports(content);
+  }
+  const importLines = [...options.eventHandlers, ...options.cronJobs].map((symbol) => {
+    const specifier = EXAMPLE_JOB_IMPORTS[symbol];
+    return specifier ? `import { ${symbol} } from '${specifier}';` : "";
+  }).filter(Boolean).join(`
+`);
+  if (importLines) {
+    const jobsImportPattern = /import \{ JobsModule \} from ['"]\.\/jobs\/jobs\.module(?:\.js)?['"];/;
+    if (jobsImportPattern.test(content)) {
+      content = content.replace(jobsImportPattern, (match) => `${match}
+${importLines}`);
+    }
+  }
+  if (content.includes("JobsModule.register(")) {
+    content = content.replace(/JobsModule\.register\(\{[\s\S]*?\}\)/, buildJobsRegisterBlock(options));
+  } else {
+    content = content.replace("ConfigModule.forRoot({", `${buildJobsRegisterBlock(options)},
+    ConfigModule.forRoot({`);
+  }
+  writeFileSync(appModulePath(projectName), content, "utf8");
+}
+export function patchAppModuleExampleJobs(projectName, options) {
+  patchAppModuleJobs(projectName, {
+    eventHandlers: options.eventJobs ? ["InactivePersonHandler"] : [],
+    cronJobs: options.cronJobs ? ["CreatePersonJob", "DeleteInactiveJob"] : []
+  });
+}

package/cli/utils/patch-main.js

@@ -0,0 +1,15 @@
+export function stripMainOptionalFeatures(content) {
+  return content.replace(/import cookieParser from 'cookie-parser';\n/, "").replace(/\n {2}app\.use\(cookieParser\(\)\);\n/, `
+`);
+}
+export function patchMainForAuth(content) {
+  if (content.includes("cookieParser()")) {
+    return content;
+  }
+  return content.replace("import { NestFactory } from '@nestjs/core';", `import { NestFactory } from '@nestjs/core';
+import cookieParser from 'cookie-parser';`).replace(`  const app = await NestFactory.create(AppModule);
+`, `  const app = await NestFactory.create(AppModule);
+
+  app.use(cookieParser());
+`);
+}

package/cli/utils/patch-person-features.js

@@ -0,0 +1,127 @@
+import { readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import { removeImportLines } from "./project-files.js";
+import { patchAppModuleExampleJobs } from "./patch-jobs-module.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+function projectFile(projectName, relativePath) {
+  return path.join(resolveProjectPath(projectName), relativePath);
+}
+function readProjectFile(projectName, relativePath) {
+  return readFileSync(projectFile(projectName, relativePath), "utf8");
+}
+function writeProjectFile(projectName, relativePath, content) {
+  writeFileSync(projectFile(projectName, relativePath), content);
+}
+const READ_MANY_WITHOUT_CACHE = `import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { AutoMapper } from '@/core/tools/mapping';
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Injectable } from '@nestjs/common';
+import { ReadManyPersonRequest } from './read-many-person.request.js';
+import {
+  ReadManyPersonResponse,
+  ReadManyPersonResponseItem,
+} from './read-many-person.response.js';
+import { ReadManyPersonValidator } from './read-many-person.validator.js';
+import { Person } from '@/domain/entities/person/person';
+
+@Injectable()
+export class ReadManyPersonHandler extends RequestHandlerBase<
+  ReadManyPersonRequest,
+  ReadManyPersonResponse
+> {
+  constructor(private readonly repository: IPersonRepository) {
+    super();
+  }
+
+  async handle(req: ReadManyPersonRequest): Promise<ReadManyPersonResponse> {
+    const query = AutoMapper.map(
+      new ReadManyPersonValidator(req).validate(),
+      ReadManyPersonRequest,
+      PersonQueryDto,
+    );
+
+    return ReadManyPersonResponse.from(
+      await this.repository.findMany(query).then((result) => ({
+        items: result.items.map((item) =>
+          AutoMapper.map(item, Person, ReadManyPersonResponseItem),
+        ),
+        count: result.count,
+      })),
+    );
+  }
+}
+`;
+export function stripPersonModuleCacheUsage(projectName) {
+  const handlers = [
+    "src/application/person/create/create-person.handler.ts",
+    "src/application/person/update/update-person.handler.ts",
+    "src/application/person/delete/delete-person.handler.ts",
+    "src/application/person/jobs/events/person/inactive-person/inactive-person.handler.ts"
+  ];
+  for (const handlerPath of handlers) {
+    let content = readProjectFile(projectName, handlerPath);
+    content = removeImportLines(content, [
+      "@/domain/common/icache.service",
+      "@/core/utils/person-list-cache"
+    ]);
+    content = content.replace(/,\n {4}private readonly cache: ICacheService/, "");
+    content = content.replace(/\n {4}await invalidatePersonListCache\(this\.cache\);\n/, `
+`);
+    writeProjectFile(projectName, handlerPath, content);
+  }
+  writeProjectFile(projectName, "src/application/person/read-many/read-many-person.handler.ts", READ_MANY_WITHOUT_CACHE);
+  for (const cacheUtil of [
+    "src/core/utils/person-list-cache.ts",
+    "src/core/utils/build-list-cache-key.ts"
+  ]) {
+    rmSync(projectFile(projectName, cacheUtil), { force: true });
+  }
+}
+export function stripPersonModuleCronJobs(projectName) {
+  rmSync(projectFile(projectName, "src/application/person/jobs/cron"), {
+    recursive: true,
+    force: true
+  });
+}
+export function stripPersonModuleEventJobs(projectName) {
+  rmSync(projectFile(projectName, "src/application/person/jobs/events"), {
+    recursive: true,
+    force: true
+  });
+}
+export function adjustCrudPersonModule(projectName, options) {
+  if (!options.cache) {
+    stripPersonModuleCacheUsage(projectName);
+  }
+  if (!options.cronJobs) {
+    stripPersonModuleCronJobs(projectName);
+  }
+  if (!options.eventJobs) {
+    stripPersonModuleEventJobs(projectName);
+  }
+  if (!options.auth) {
+    stripPersonAuthExample(projectName);
+  }
+  patchAppModuleExampleJobs(projectName, {
+    eventJobs: options.eventJobs,
+    cronJobs: options.cronJobs
+  });
+}
+export function stripPersonAuthExample(projectName) {
+  const controllerPath = "src/host/controllers/person/delete-person.controller.ts";
+  if (!existsSync(projectFile(projectName, controllerPath))) {
+    return;
+  }
+  let content = readProjectFile(projectName, controllerPath);
+  content = removeImportLines(content, [
+    "@/core/auth/auth-profile.enum",
+    "@/host/decorators/restriction-by-profile.decorator",
+    "@/host/decorators/api-exclude-endpoint-diff-develop.decorator"
+  ]);
+  content = content.replace(/\n {2}@RestrictionByProfile\(\[AuthProfile\.admin\]\)\n/, `
+`);
+  content = content.replace(/\n {2}@ApiExcludeEndpointDiffDevelop\(\)\n/, `
+`);
+  writeProjectFile(projectName, controllerPath, content);
+}

package/cli/utils/project-files.js

@@ -0,0 +1,11 @@
+export function removeImportLines(content, moduleSpecifiers) {
+  let result = content;
+  for (const specifier of moduleSpecifiers) {
+    const pattern = new RegExp(`^import\\s+(?:type\\s+)?(?:[^'";\\n]+|\\{[^}]*\\})\\s+from\\s+['"][^'"]*${escapeRegExp(specifier)}['"];?\\r?\\n`, "gm");
+    result = result.replace(pattern, "");
+  }
+  return result;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/cli/utils/prune-auth-strategies.js

@@ -0,0 +1,116 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import {
+  JWT_ONLY_REMOVE_PATHS,
+  OAUTH2_INSTALL_PATHS,
+  OAUTH2_ONLY_REMOVE_PATHS
+} from "../constants/auth-strategy-artifacts.js";
+import { AuthStrategy } from "../constants/domain.js";
+import { getSourceCodePath } from "./get-source-code-path.js";
+import { resolveProjectPath } from "./resolve-project-path.js";
+import { assertAuthStrategyProject } from "./auth-strategy-validation.js";
+function projectPath(projectName, relativePath) {
+  return path.join(resolveProjectPath(projectName), relativePath);
+}
+function sourcePath(relativePath) {
+  return path.join(getSourceCodePath(), relativePath);
+}
+function removePaths(projectName, paths) {
+  for (const relativePath of paths) {
+    rmSync(projectPath(projectName, relativePath), {
+      recursive: true,
+      force: true
+    });
+  }
+}
+function installPath(projectName, relativePath) {
+  const from = sourcePath(relativePath);
+  const to = projectPath(projectName, relativePath);
+  if (!existsSync(from)) {
+    return;
+  }
+  mkdirSync(path.dirname(to), { recursive: true });
+  cpSync(from, to, { recursive: true, force: true });
+}
+export function installAuthArtifactsForStrategies(projectName, strategies) {
+  const hasJwt = strategies.includes(AuthStrategy.JWT);
+  const hasOauth = strategies.includes(AuthStrategy.OAUTH2);
+  if (hasJwt) {
+    installPath(projectName, "src/application/auth/login");
+    installPath(projectName, "src/host/controllers/auth/login.controller.ts");
+    installPath(projectName, "src/test/application/login.handler.spec.ts");
+  }
+  if (hasOauth) {
+    for (const relativePath of OAUTH2_INSTALL_PATHS) {
+      installPath(projectName, relativePath);
+    }
+  }
+}
+export function pruneAuthArtifactsForStrategies(projectName, strategies) {
+  const hasJwt = strategies.includes(AuthStrategy.JWT);
+  const hasOauth = strategies.includes(AuthStrategy.OAUTH2);
+  if (hasJwt && !hasOauth) {
+    removePaths(projectName, JWT_ONLY_REMOVE_PATHS);
+  }
+  if (hasOauth && !hasJwt) {
+    removePaths(projectName, OAUTH2_ONLY_REMOVE_PATHS);
+  }
+}
+export { assertAuthStrategyProject, listAuthStrategyViolations } from "./auth-strategy-validation.js";
+export function assertAuthStrategyPaths(projectName, strategies) {
+  const hasJwt = strategies.includes(AuthStrategy.JWT);
+  const hasOauth = strategies.includes(AuthStrategy.OAUTH2);
+  const root = resolveProjectPath(projectName);
+  const expectations = [
+    {
+      path: "src/host/controllers/auth/login.controller.ts",
+      shouldExist: hasJwt
+    },
+    {
+      path: "src/host/controllers/oauth2/auth-link.controller.ts",
+      shouldExist: hasOauth
+    },
+    {
+      path: "src/application/auth/login/login.handler.ts",
+      shouldExist: hasJwt
+    },
+    {
+      path: "src/application/auth/oauth2/auth-link/auth-link.handler.ts",
+      shouldExist: hasOauth
+    },
+    {
+      path: "src/domain/auth/dtos/oauth-user-info.dto.ts",
+      shouldExist: hasOauth
+    },
+    {
+      path: "src/infra/auth/oauth2-auth.service.ts",
+      shouldExist: hasOauth
+    },
+    {
+      path: "src/core/auth/parse-oauth2-provider-env.ts",
+      shouldExist: hasOauth
+    },
+    {
+      path: "src/core/auth/oauth-provider.registry.ts",
+      shouldExist: hasOauth
+    }
+  ];
+  const iauthServicePath = path.join(root, "src/domain/auth/services/iauth.service.ts");
+  if (existsSync(iauthServicePath)) {
+    const iauthService = readFileSync(iauthServicePath, "utf8");
+    const hasOAuthInterface = iauthService.includes("IOAuth2Service");
+    const hasJwtInterface = iauthService.includes("IJwtTokenService");
+    if (hasJwt && !hasOauth && (hasOAuthInterface || !hasJwtInterface)) {
+      throw new Error("Esperado iauth.service.ts apenas com IJwtTokenService no modo JWT");
+    }
+    if (hasOauth && !hasOAuthInterface) {
+      throw new Error("Esperado iauth.service.ts conter IOAuth2Service quando OAuth2 está ativo");
+    }
+  }
+  for (const { path: relativePath, shouldExist } of expectations) {
+    const exists = existsSync(path.join(root, relativePath));
+    if (exists !== shouldExist) {
+      throw new Error(`Esperado ${shouldExist ? "existir" : "não existir"}: ${relativePath}`);
+    }
+  }
+}

package/cli/utils/prune-core-auth.js

@@ -0,0 +1,17 @@
+import { rmSync } from "node:fs";
+import path from "node:path";
+import { resolveProjectPath } from "./resolve-project-path.js";
+export function pruneCoreAuthForSlimTemplate(projectName) {
+  const projectRoot = resolveProjectPath(projectName);
+  rmSync(path.join(projectRoot, "src/core/auth"), {
+    recursive: true,
+    force: true
+  });
+  for (const relativePath of [
+    "src/core/utils/hash-password.ts",
+    "src/core/utils/name-to-login.ts",
+    "src/core/types/auth-provider-config-response.type.ts"
+  ]) {
+    rmSync(path.join(projectRoot, relativePath), { force: true });
+  }
+}