refactor(lib): reduce lint complexity in path normalization

Author: skulidropek

packages/lib/src/core/command-builders.ts

@@ -114,41 +114,57 @@ type PathConfig = {
   readonly outDir: string
 }
 
+type DefaultPathConfig = {
+  readonly dockerGitPath: string
+  readonly authorizedKeysPath: string
+  readonly envGlobalPath: string
+  readonly envProjectPath: string
+  readonly codexAuthPath: string
+}
+
+const resolveNormalizedSecretsRoot = (value: string | undefined): string | undefined => {
+  const trimmed = value?.trim() ?? ""
+  return trimmed.length === 0 ? undefined : normalizeSecretsRoot(trimmed)
+}
+
+const buildDefaultPathConfig = (
+  normalizedSecretsRoot: string | undefined,
+  projectSlug: string
+): DefaultPathConfig =>
+  normalizedSecretsRoot === undefined
+    ? {
+      dockerGitPath: defaultTemplateConfig.dockerGitPath,
+      authorizedKeysPath: defaultTemplateConfig.authorizedKeysPath,
+      envGlobalPath: defaultTemplateConfig.envGlobalPath,
+      envProjectPath: defaultTemplateConfig.envProjectPath,
+      codexAuthPath: defaultTemplateConfig.codexAuthPath
+    }
+    : {
+      dockerGitPath: normalizedSecretsRoot,
+      authorizedKeysPath: `${normalizedSecretsRoot}/authorized_keys`,
+      envGlobalPath: `${normalizedSecretsRoot}/global.env`,
+      envProjectPath: `${normalizedSecretsRoot}/${projectSlug}.env`,
+      codexAuthPath: `${normalizedSecretsRoot}/codex`
+    }
+
 const resolvePaths = (
   raw: RawOptions,
   projectSlug: string,
   repoPath: string
 ): Either.Either<PathConfig, ParseError> =>
   Either.gen(function*(_) {
-    const secretsRoot = raw.secretsRoot?.trim()
-    const normalizedSecretsRoot = secretsRoot === undefined || secretsRoot.length === 0
-      ? undefined
-      : normalizeSecretsRoot(secretsRoot)
-    const defaultAuthorizedKeysPath = normalizedSecretsRoot === undefined
-      ? defaultTemplateConfig.authorizedKeysPath
-      : `${normalizedSecretsRoot}/authorized_keys`
-    const defaultDockerGitPath = normalizedSecretsRoot === undefined
-      ? defaultTemplateConfig.dockerGitPath
-      : normalizedSecretsRoot
-    const defaultEnvGlobalPath = normalizedSecretsRoot === undefined
-      ? defaultTemplateConfig.envGlobalPath
-      : `${normalizedSecretsRoot}/global.env`
-    const defaultEnvProjectPath = normalizedSecretsRoot === undefined
-      ? defaultTemplateConfig.envProjectPath
-      : `${normalizedSecretsRoot}/${projectSlug}.env`
-    const defaultCodexAuthPath = normalizedSecretsRoot === undefined
-      ? defaultTemplateConfig.codexAuthPath
-      : `${normalizedSecretsRoot}/codex`
-    const dockerGitPath = defaultDockerGitPath
+    const normalizedSecretsRoot = resolveNormalizedSecretsRoot(raw.secretsRoot)
+    const defaults = buildDefaultPathConfig(normalizedSecretsRoot, projectSlug)
+    const dockerGitPath = defaults.dockerGitPath
     const authorizedKeysPath = yield* _(
-      nonEmpty("--authorized-keys", raw.authorizedKeysPath, defaultAuthorizedKeysPath)
+      nonEmpty("--authorized-keys", raw.authorizedKeysPath, defaults.authorizedKeysPath)
     )
-    const envGlobalPath = yield* _(nonEmpty("--env-global", raw.envGlobalPath, defaultEnvGlobalPath))
+    const envGlobalPath = yield* _(nonEmpty("--env-global", raw.envGlobalPath, defaults.envGlobalPath))
     const envProjectPath = yield* _(
-      nonEmpty("--env-project", raw.envProjectPath, defaultEnvProjectPath)
+      nonEmpty("--env-project", raw.envProjectPath, defaults.envProjectPath)
     )
     const codexAuthPath = yield* _(
-      nonEmpty("--codex-auth", raw.codexAuthPath, defaultCodexAuthPath)
+      nonEmpty("--codex-auth", raw.codexAuthPath, defaults.codexAuthPath)
     )
     const codexSharedAuthPath = codexAuthPath
     const codexHome = yield* _(nonEmpty("--codex-home", raw.codexHome, defaultTemplateConfig.codexHome))

packages/lib/src/usecases/state-normalize.ts

@@ -21,20 +21,28 @@ const isLegacyDockerGitRelativePath = (value: string): boolean => {
 const shouldNormalizePath = (path: Path.Path, value: string): boolean =>
   path.isAbsolute(value) || isLegacyDockerGitRelativePath(value)
 
+const withFallback = (value: string, fallback: string): string =>
+  value.length > 0 ? value : fallback
+
+const pathFieldsForNormalization = (template: TemplateConfig): ReadonlyArray<string> => [
+  template.dockerGitPath,
+  template.authorizedKeysPath,
+  template.envGlobalPath,
+  template.envProjectPath,
+  template.codexAuthPath,
+  template.codexSharedAuthPath
+]
+
+const hasLegacyTemplatePaths = (path: Path.Path, template: TemplateConfig): boolean =>
+  pathFieldsForNormalization(template).some((value) => shouldNormalizePath(path, value))
+
 const normalizeTemplateConfig = (
   path: Path.Path,
   projectsRoot: string,
   projectDir: string,
   template: TemplateConfig
 ): TemplateConfig | null => {
-  const needs = shouldNormalizePath(path, template.dockerGitPath) ||
-    shouldNormalizePath(path, template.authorizedKeysPath) ||
-    shouldNormalizePath(path, template.envGlobalPath) ||
-    shouldNormalizePath(path, template.envProjectPath) ||
-    shouldNormalizePath(path, template.codexAuthPath) ||
-    shouldNormalizePath(path, template.codexSharedAuthPath)
-
-  if (!needs) {
+  if (!hasLegacyTemplatePaths(path, template)) {
     return null
   }
 
@@ -51,12 +59,12 @@ const normalizeTemplateConfig = (
 
   return {
     ...template,
-    dockerGitPath: dockerGitRel.length > 0 ? dockerGitRel : "./.docker-git",
-    authorizedKeysPath: authorizedKeysRel.length > 0 ? authorizedKeysRel : "./authorized_keys",
+    dockerGitPath: withFallback(dockerGitRel, "./.docker-git"),
+    authorizedKeysPath: withFallback(authorizedKeysRel, "./authorized_keys"),
     envGlobalPath,
     envProjectPath,
     codexAuthPath,
-    codexSharedAuthPath: codexSharedRel.length > 0 ? codexSharedRel : "./.orch/auth/codex"
+    codexSharedAuthPath: withFallback(codexSharedRel, "./.orch/auth/codex")
   }
 }