| | | 1 | | import * as fs from 'node:fs/promises'; |
| | | 2 | | import * as dotenv from 'dotenv'; |
| | | 3 | | import { inject, injectable } from 'inversify'; |
| | | 4 | | import { |
| | | 5 | | DependencyMissingError, |
| | | 6 | | EnvironmentFileError, |
| | | 7 | | } from '../../domain/errors/DomainErrors.js'; |
| | | 8 | | import type { |
| | | 9 | | MapFileConfig, |
| | | 10 | | ParsedMapFile, |
| | | 11 | | } from '../../domain/MapFileConfig.js'; |
| | | 12 | | import type { ILogger } from '../../domain/ports/ILogger.js'; |
| | | 13 | | import type { IVariableStore } from '../../domain/ports/IVariableStore.js'; |
| | | 14 | | import { TYPES } from '../../types.js'; |
| | | 15 | | |
| | | 16 | | @injectable() |
| | 8 | 17 | | export class FileVariableStore implements IVariableStore { |
| | | 18 | | private logger: ILogger; |
| | | 19 | | |
| | | 20 | | constructor(@inject(TYPES.ILogger) logger: ILogger) { |
| | 46 | 21 | | if (!logger) { |
| | 1 | 22 | | throw new DependencyMissingError('Logger must be specified'); |
| | | 23 | | } |
| | 45 | 24 | | this.logger = logger; |
| | | 25 | | } |
| | | 26 | | |
| | | 27 | | async getMapping(source: string): Promise<Record<string, string>> { |
| | 9 | 28 | | const { mappings } = await this.getParsedMapping(source); |
| | 6 | 29 | | return mappings; |
| | | 30 | | } |
| | | 31 | | |
| | | 32 | | async getParsedMapping(source: string): Promise<ParsedMapFile> { |
| | 14 | 33 | | const raw = await this.readJsonFile(source); |
| | 11 | 34 | | const { $config, ...rest } = raw; |
| | | 35 | | const config: MapFileConfig = |
| | 11 | 36 | | $config && typeof $config === 'object' ? $config : {}; |
| | 14 | 37 | | const mappings: Record<string, string> = {}; |
| | 14 | 38 | | for (const [key, value] of Object.entries(rest)) { |
| | 21 | 39 | | if (!key.startsWith('$') && typeof value === 'string') { |
| | 16 | 40 | | mappings[key] = value; |
| | | 41 | | } |
| | | 42 | | } |
| | 11 | 43 | | return { config, mappings }; |
| | | 44 | | } |
| | | 45 | | |
| | | 46 | | private async readJsonFile(source: string): Promise<Record<string, unknown>> { |
| | 14 | 47 | | try { |
| | 14 | 48 | | const content = await fs.readFile(source, 'utf-8'); |
| | 12 | 49 | | try { |
| | 12 | 50 | | return JSON.parse(content); |
| | | 51 | | } catch (_err: unknown) { |
| | 1 | 52 | | this.logger.error(`Error parsing JSON from ${source}`); |
| | 1 | 53 | | throw new EnvironmentFileError( |
| | | 54 | | `Invalid JSON in parameter map file: ${source}`, |
| | | 55 | | ); |
| | | 56 | | } |
| | | 57 | | } catch (error) { |
| | 3 | 58 | | if (error instanceof EnvironmentFileError) { |
| | 1 | 59 | | throw error; |
| | | 60 | | } |
| | 2 | 61 | | throw new EnvironmentFileError(`Failed to read map file: ${source}`); |
| | | 62 | | } |
| | | 63 | | } |
| | | 64 | | |
| | | 65 | | async getEnvironment(source: string): Promise<Record<string, string>> { |
| | 8 | 66 | | const envVariables: Record<string, string> = {}; |
| | 8 | 67 | | try { |
| | 8 | 68 | | await fs.access(source); |
| | | 69 | | } catch { |
| | 4 | 70 | | return envVariables; |
| | | 71 | | } |
| | 4 | 72 | | const existingEnvContent = await fs.readFile(source, 'utf-8'); |
| | 2 | 73 | | const parsedEnv = dotenv.parse(existingEnvContent) || {}; |
| | 8 | 74 | | Object.assign(envVariables, parsedEnv); |
| | | 75 | | |
| | 8 | 76 | | return envVariables; |
| | | 77 | | } |
| | | 78 | | |
| | | 79 | | async saveEnvironment( |
| | | 80 | | destination: string, |
| | | 81 | | envVariables: Record<string, string>, |
| | | 82 | | ): Promise<void> { |
| | 10 | 83 | | const envContent = Object.entries(envVariables) |
| | 10 | 84 | | .map(([key, value]) => `${key}=${this.escapeEnvValue(value)}`) |
| | | 85 | | .join('\n'); |
| | | 86 | | |
| | 10 | 87 | | try { |
| | 10 | 88 | | await fs.writeFile(destination, envContent); |
| | | 89 | | } catch (error) { |
| | | 90 | | const errorMessage = |
| | 2 | 91 | | error instanceof Error ? error.message : String(error); |
| | 2 | 92 | | this.logger.error(`Failed to write environment file: ${errorMessage}`); |
| | 2 | 93 | | throw new EnvironmentFileError( |
| | | 94 | | `Failed to write environment file: ${errorMessage}`, |
| | | 95 | | ); |
| | | 96 | | } |
| | | 97 | | } |
| | | 98 | | |
| | | 99 | | private escapeEnvValue(value: string): string { |
| | | 100 | | // codeql[js/incomplete-sanitization] |
| | | 101 | | // CodeQL flags this as incomplete sanitization because we don't escape backslashes |
| | | 102 | | // before newlines. However, this is intentional: the dotenv library does NOT |
| | | 103 | | // interpret escape sequences (it treats \n literally as backslash+n, not as a newline). |
| | | 104 | | // Therefore, escaping backslashes would actually break the functionality by |
| | | 105 | | // doubling them when read back by dotenv. This is not a security issue in this context. |
| | 10 | 106 | | return value.replace(/(\r\n|\n|\r)/g, '\\n'); |
| | | 107 | | } |
| | | 108 | | } |
| | | 109 | | |
| | | 110 | | export async function readMapFileConfig( |
| | | 111 | | mapPath: string, |
| | | 112 | | ): Promise<MapFileConfig> { |
| | 4 | 113 | | try { |
| | 4 | 114 | | const content = await fs.readFile(mapPath, 'utf-8'); |
| | 3 | 115 | | try { |
| | 3 | 116 | | const raw = JSON.parse(content); |
| | 3 | 117 | | const config = raw.$config; |
| | 3 | 118 | | return config && typeof config === 'object' ? config : {}; |
| | | 119 | | } catch { |
| | 1 | 120 | | throw new EnvironmentFileError( |
| | | 121 | | `Invalid JSON in parameter map file: ${mapPath}`, |
| | | 122 | | ); |
| | | 123 | | } |
| | | 124 | | } catch (error) { |
| | 2 | 125 | | if (error instanceof EnvironmentFileError) { |
| | 1 | 126 | | throw error; |
| | | 127 | | } |
| | 1 | 128 | | throw new EnvironmentFileError(`Failed to read map file: ${mapPath}`); |
| | | 129 | | } |
| | | 130 | | } |