react-native-config-ultimate 0.0.1 → 0.0.5

package/src/load-env.ts

@@ -16,9 +16,7 @@ function detect_format(config_path: string): FileFormat {
 function read_yaml(config_path: string): EnvData {
   const data = yaml.load(fs.readFileSync(config_path).toString());
   if (typeof data === 'undefined' || data === null || typeof data !== 'object') {
-    throw new Error(
-      `Expected to read object from ${config_path}, but got '${data}'`
-    );
+    throw new Error(`Expected to read object from ${config_path}, but got '${data}'`);
   }
   return data as EnvData;
 }
@@ -47,9 +45,7 @@ export default function load_env(config_paths: string | string[]): EnvData {
   const paths = Array.isArray(config_paths) ? config_paths : [config_paths];
 
   if (paths.length === 0) {
-    throw new Error(
-      'No env file specified. Usage: rncu <env-file> [env-file2 ...]'
-    );
+    throw new Error('No env file specified. Usage: rncu <env-file> [env-file2 ...]');
   }
 
   const formats = paths.map(detect_format);

package/src/render-env.js

@@ -54,7 +54,11 @@ function is_boolean(value) {
 }
 function escape(value) {
     if (is_string(value)) {
-        return value.replace(/"/gm, '\\"');
+        return value
+            .replace(/\\/gm, '\\\\')
+            .replace(/"/gm, '\\"')
+            .replace(/\n/gm, '\\n')
+            .replace(/\r/gm, '\\r');
     }
     return value;
 }
@@ -98,8 +102,7 @@ function render_env(project_root, lib_root, env, rc) {
     // Only write xcconfig if the project has an ios folder.
     // All RN apps have it; some react-native-web apps may not.
     if (fs.existsSync(path.join(project_root, 'ios'))) {
-        map[path.join(project_root, 'ios', `${config_file_name}.xcconfig`)] =
-            render_template('rncu.xcconfig', ios);
+        map[path.join(project_root, 'ios', `${config_file_name}.xcconfig`)] = render_template('rncu.xcconfig', ios);
     }
     const js_override = rc && typeof rc.js_override === 'boolean' && rc.js_override;
     map[path.join(lib_root, 'override.js')] = render_template('override.js', {

package/src/render-env.ts

@@ -25,7 +25,11 @@ function is_boolean(value: unknown): boolean {
 
 function escape(value: unknown): unknown {
   if (is_string(value)) {
-    return (value as string).replace(/"/gm, '\\"');
+    return (value as string)
+      .replace(/\\/gm, '\\\\')
+      .replace(/"/gm, '\\"')
+      .replace(/\n/gm, '\\n')
+      .replace(/\r/gm, '\\r');
   }
   return value;
 }
@@ -56,11 +60,7 @@ function get_compiled_template(template_name: string): HandlebarsTemplateDelegat
   const cached = template_cache.get(template_name);
   if (cached) return cached;
 
-  const template_path = path.join(
-    __dirname,
-    'templates',
-    `${template_name}.handlebars`
-  );
+  const template_path = path.join(__dirname, 'templates', `${template_name}.handlebars`);
   const compiled = handlebars.compile(fs.readFileSync(template_path, 'utf8'));
   template_cache.set(template_name, compiled);
   return compiled;
@@ -88,21 +88,17 @@ export default function render_env(
   const map: FileMap = {
     [path.join(lib_root, 'index.d.ts')]: render_template('index.d.ts', ios),
     [path.join(lib_root, 'index.web.js')]: render_template('index.web.js', web),
-    [path.join(lib_root, 'ios', `${code_file_name}.h`)]: render_template(
-      'ConfigValues.h',
-      ios
-    ),
-    [path.join(lib_root, 'android', 'rncu.yaml')]: render_template(
-      'rncu.yaml',
-      android
-    ),
+    [path.join(lib_root, 'ios', `${code_file_name}.h`)]: render_template('ConfigValues.h', ios),
+    [path.join(lib_root, 'android', 'rncu.yaml')]: render_template('rncu.yaml', android),
   };
 
   // Only write xcconfig if the project has an ios folder.
   // All RN apps have it; some react-native-web apps may not.
   if (fs.existsSync(path.join(project_root, 'ios'))) {
-    map[path.join(project_root, 'ios', `${config_file_name}.xcconfig`)] =
-      render_template('rncu.xcconfig', ios);
+    map[path.join(project_root, 'ios', `${config_file_name}.xcconfig`)] = render_template(
+      'rncu.xcconfig',
+      ios
+    );
   }
 
   const js_override = rc && typeof rc.js_override === 'boolean' && rc.js_override;

package/src/validate-env.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate_env = validate_env;
+const VALID_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * Validate env data against a schema defined in `.rncurc.js`.
  * Called after `on_env` so the hook can add/transform vars before validation.
@@ -10,6 +11,12 @@ exports.validate_env = validate_env;
  */
 function validate_env(env, schema) {
     const errors = [];
+    // Validate all env key names are valid identifiers
+    for (const key of Object.keys(env)) {
+        if (!VALID_KEY_PATTERN.test(key)) {
+            errors.push(`Invalid env key name: "${key}". Keys must start with a letter or underscore and contain only letters, numbers, and underscores.`);
+        }
+    }
     // Pre-compile all regex patterns once, before iterating over env values.
     // This avoids re-compiling the same pattern for every validated key.
     const compiled_patterns = new Map();
@@ -36,8 +43,7 @@ function validate_env(env, schema) {
         if (field.type === 'number' && isNaN(Number(value))) {
             errors.push(`${key} must be a number, got "${value}"`);
         }
-        if (field.type === 'boolean' &&
-            !['true', 'false', '1', '0'].includes(value.toLowerCase())) {
+        if (field.type === 'boolean' && !['true', 'false', '1', '0'].includes(value.toLowerCase())) {
             errors.push(`${key} must be a boolean (true/false/1/0), got "${value}"`);
         }
         const pattern = compiled_patterns.get(key);

package/src/validate-env.ts

@@ -1,5 +1,7 @@
 import type { EnvData, Schema } from './resolve-env';
 
+const VALID_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
 /**
  * Validate env data against a schema defined in `.rncurc.js`.
  * Called after `on_env` so the hook can add/transform vars before validation.
@@ -10,6 +12,15 @@ import type { EnvData, Schema } from './resolve-env';
 export function validate_env(env: EnvData, schema: Schema): void {
   const errors: string[] = [];
 
+  // Validate all env key names are valid identifiers
+  for (const key of Object.keys(env)) {
+    if (!VALID_KEY_PATTERN.test(key)) {
+      errors.push(
+        `Invalid env key name: "${key}". Keys must start with a letter or underscore and contain only letters, numbers, and underscores.`
+      );
+    }
+  }
+
   // Pre-compile all regex patterns once, before iterating over env values.
   // This avoids re-compiling the same pattern for every validated key.
   const compiled_patterns = new Map<string, RegExp>();
@@ -25,8 +36,7 @@ export function validate_env(env: EnvData, schema: Schema): void {
 
   for (const [key, field] of Object.entries(schema)) {
     const raw = env[key];
-    const missing =
-      raw === undefined || raw === null || String(raw).trim() === '';
+    const missing = raw === undefined || raw === null || String(raw).trim() === '';
 
     if (field.required && missing) {
       errors.push(`Missing required env var: ${key}`);
@@ -41,20 +51,13 @@ export function validate_env(env: EnvData, schema: Schema): void {
       errors.push(`${key} must be a number, got "${value}"`);
     }
 
-    if (
-      field.type === 'boolean' &&
-      !['true', 'false', '1', '0'].includes(value.toLowerCase())
-    ) {
-      errors.push(
-        `${key} must be a boolean (true/false/1/0), got "${value}"`
-      );
+    if (field.type === 'boolean' && !['true', 'false', '1', '0'].includes(value.toLowerCase())) {
+      errors.push(`${key} must be a boolean (true/false/1/0), got "${value}"`);
     }
 
     const pattern = compiled_patterns.get(key);
     if (pattern && !pattern.test(value)) {
-      errors.push(
-        `${key} does not match pattern /${field.pattern}/, got "${value}"`
-      );
+      errors.push(`${key} does not match pattern /${field.pattern}/, got "${value}"`);
     }
   }
 

package/src/write-env.js

@@ -66,7 +66,9 @@ function write_env(files) {
             try {
                 fs.unlinkSync(tmp);
             }
-            catch ( /* ignore */_a) { /* ignore */ }
+            catch (_a) {
+                /* ignore */
+            }
         }
         throw new Error(`[rncu] Failed to prepare output files: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -88,12 +90,13 @@ function write_env(files) {
                 try {
                     fs.unlinkSync(tmp);
                 }
-                catch ( /* ignore */_c) { /* ignore */ }
+                catch (_c) {
+                    /* ignore */
+                }
             }
         }
     }
     if (rename_errors.length > 0) {
-        throw new Error(`[rncu] Failed to write output files:\n` +
-            rename_errors.map((e) => `  • ${e}`).join('\n'));
+        throw new Error(`[rncu] Failed to write output files:\n` + rename_errors.map((e) => `  • ${e}`).join('\n'));
     }
 }

package/src/write-env.ts

@@ -30,7 +30,11 @@ export default function write_env(files: FileMap): void {
   } catch (err) {
     // Clean up any temp files we already created.
     for (const { tmp } of pending) {
-      try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+      try {
+        fs.unlinkSync(tmp);
+      } catch {
+        /* ignore */
+      }
     }
     throw new Error(
       `[rncu] Failed to prepare output files: ${err instanceof Error ? err.message : String(err)}`
@@ -53,15 +57,18 @@ export default function write_env(files: FileMap): void {
         rename_errors.push(
           `${dest}: ${copy_err instanceof Error ? copy_err.message : String(copy_err)}`
         );
-        try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+        try {
+          fs.unlinkSync(tmp);
+        } catch {
+          /* ignore */
+        }
       }
     }
   }
 
   if (rename_errors.length > 0) {
     throw new Error(
-      `[rncu] Failed to write output files:\n` +
-        rename_errors.map((e) => `  • ${e}`).join('\n')
+      `[rncu] Failed to write output files:\n` + rename_errors.map((e) => `  • ${e}`).join('\n')
     );
   }
 }

package/src/bin.spec.ts

@@ -1,36 +0,0 @@
-import cp from 'child_process';
-import fs from 'fs';
-import path from 'path';
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const { files_to_assert } = require('./main.spec') as { files_to_assert: string[] };
-
-describe.each`
-  extension  | env_test_content
-  ${''}      | ${'hello=world'}
-  ${'.yaml'} | ${'hello: world'}
-  ${'.yml'}  | ${'hello: world'}
-`('test codegen', ({ extension, env_test_content }: { extension: string; env_test_content: string }) => {
-  let project_root: string;
-  beforeAll(() => {
-    project_root = path.join(process.cwd(), fs.mkdtempSync('rncu-jest'));
-    for (const file_path of files_to_assert) {
-      const { dir } = path.parse(file_path);
-      const folder = path.join(project_root, dir);
-      fs.mkdirSync(folder, { recursive: true });
-    }
-  });
-  afterAll(() => {
-    fs.rmSync(project_root, { recursive: true, force: true });
-  });
-  it.each(files_to_assert.map((k) => [k]))(
-    'creates file at path %s',
-    (file_path) => {
-      const env_file_path = path.join(project_root, `.env${extension}`);
-      fs.writeFileSync(env_file_path, env_test_content);
-      cp.execFileSync(path.join(process.cwd(), 'bin.js'), [env_file_path], {
-        cwd: project_root,
-      });
-      expect(fs.existsSync(path.join(project_root, file_path as string))).toEqual(true);
-    }
-  );
-});

package/src/cli.spec.ts

@@ -1,224 +0,0 @@
-// All mocks must be declared before the module is required.
-const mock_main = jest.fn();
-jest.doMock('./main', () => ({ __esModule: true, default: mock_main }));
-
-const mock_exists_sync = jest.fn();
-jest.doMock('fs', () => ({
-  existsSync: mock_exists_sync,
-}));
-
-// Mock watcher returned by chokidar.watch()
-const mock_watcher_on = jest.fn();
-const mock_watcher_close = jest.fn().mockResolvedValue(undefined);
-const mock_watcher = {
-  on: mock_watcher_on.mockReturnThis(),
-  close: mock_watcher_close,
-};
-const mock_chokidar_watch = jest.fn().mockReturnValue(mock_watcher);
-jest.doMock('chokidar', () => ({ watch: mock_chokidar_watch }));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const cli: () => Promise<void> = require('./cli').default;
-
-// ─── helpers ────────────────────────────────────────────────────────────────
-
-function set_argv(...args: string[]): void {
-  process.argv = ['node', 'rncu', ...args];
-}
-
-/** Grab the handler registered for a given chokidar event. */
-function get_watcher_handler(
-  event: string
-): ((p: string) => Promise<void>) | undefined {
-  const call = (mock_watcher_on.mock.calls as [string, unknown][]).find(
-    ([ev]) => ev === event
-  );
-  return call?.[1] as ((p: string) => Promise<void>) | undefined;
-}
-
-// ─── test suite ──────────────────────────────────────────────────────────────
-
-describe('cli', () => {
-  const original_argv = process.argv;
-  const stdin_resume_spy = jest
-    .spyOn(process.stdin, 'resume')
-    .mockImplementation(() => process.stdin);
-  const process_on_spy = jest
-    .spyOn(process, 'on')
-    .mockImplementation(() => process);
-
-  beforeEach(() => {
-    mock_main.mockReset().mockResolvedValue(undefined);
-    // Default: env files exist, RC file does NOT exist.
-    // This mimics the real-world baseline: user passes a valid .env file,
-    // but hasn't created a .rncurc.js config yet.
-    mock_exists_sync.mockReset().mockImplementation((p: string) => !p.endsWith('.rncurc.js'));
-    mock_chokidar_watch.mockReset().mockReturnValue(mock_watcher);
-    mock_watcher_on.mockReset().mockReturnThis();
-    mock_watcher_close.mockReset().mockResolvedValue(undefined);
-    stdin_resume_spy.mockClear();
-    process_on_spy.mockClear();
-  });
-
-  afterAll(() => {
-    process.argv = original_argv;
-    stdin_resume_spy.mockRestore();
-    process_on_spy.mockRestore();
-  });
-
-  // ── normal (non-watch) mode ─────────────────────────────────────────────
-
-  describe('normal mode', () => {
-    it('runs main once with the env file and exits', async () => {
-      set_argv('.env');
-      await cli();
-      expect(mock_main).toHaveBeenCalledTimes(1);
-      expect(mock_main).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.any(String),
-        ['.env'],
-        undefined
-      );
-      expect(mock_chokidar_watch).not.toHaveBeenCalled();
-    });
-
-    it('passes multiple env files to main', async () => {
-      set_argv('.env.base', '.env.staging');
-      await cli();
-      expect(mock_main).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.any(String),
-        ['.env.base', '.env.staging'],
-        undefined
-      );
-    });
-
-    it('loads and passes RC file when it exists', async () => {
-      set_argv('.env');
-      // All files exist (env file + RC file). The RC file can't actually be
-      // resolved via require() in test env, so cli() is expected to throw.
-      mock_exists_sync.mockReturnValue(true);
-      await expect(cli()).rejects.toThrow();
-    });
-
-    it('propagates errors from main in non-watch mode', async () => {
-      set_argv('.env');
-      mock_main.mockRejectedValueOnce(new Error('missing var'));
-      await expect(cli()).rejects.toThrow('missing var');
-    });
-  });
-
-  // ── watch mode ──────────────────────────────────────────────────────────
-
-  describe('--watch mode', () => {
-    it('starts chokidar watcher on the env files', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      expect(mock_chokidar_watch).toHaveBeenCalledWith(
-        ['.env'],
-        expect.objectContaining({ ignoreInitial: true, persistent: true })
-      );
-    });
-
-    it('also watches .rncurc.js when it exists', async () => {
-      set_argv('.env', '--watch');
-      // All files exist (env + RC). We suppress the require() error below
-      // so the test can verify that .rncurc.js is added to the watcher list.
-      mock_exists_sync.mockReturnValue(true);
-      // Suppress require() failure for missing rc file in initial run
-      mock_main.mockResolvedValue(undefined);
-      try {
-        await cli();
-      } catch {
-        // ignore require error for non-existent RC in test env
-      }
-      const watched_files = mock_chokidar_watch.mock.calls[0]?.[0] as string[];
-      expect(watched_files.some((f) => f.endsWith('.rncurc.js'))).toBe(true);
-    });
-
-    it('runs main once immediately on start', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      expect(mock_main).toHaveBeenCalledTimes(1);
-    });
-
-    it('registers change and add event handlers', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      const events = (mock_watcher_on.mock.calls as [string, unknown][]).map(
-        ([ev]) => ev
-      );
-      expect(events).toContain('change');
-      expect(events).toContain('add');
-    });
-
-    it('re-runs main when a file changes', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      expect(mock_main).toHaveBeenCalledTimes(1);
-
-      const on_change = get_watcher_handler('change');
-      expect(on_change).toBeDefined();
-
-      await on_change?.('.env');
-      expect(mock_main).toHaveBeenCalledTimes(2);
-    });
-
-    it('re-runs main when a file is added', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-
-      const on_add = get_watcher_handler('add');
-      await on_add?.('.env.local');
-      expect(mock_main).toHaveBeenCalledTimes(2);
-    });
-
-    it('catches errors on re-run and keeps watching (does not throw)', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-
-      mock_main.mockRejectedValueOnce(new Error('validation failed'));
-      const on_change = get_watcher_handler('change');
-      expect(on_change).toBeDefined();
-
-      // The handler uses `void run(p)` so it returns undefined synchronously
-      // and swallows errors inside run()'s try/catch. We trigger it and then
-      // drain the microtask queue to let the async error handling complete.
-      expect(() => on_change!('.env')).not.toThrow();
-      await new Promise<void>((resolve) => setImmediate(resolve));
-
-      // main was called twice: initial run + change handler
-      expect(mock_main).toHaveBeenCalledTimes(2);
-    });
-
-    it('catches initial run errors and still starts the watcher', async () => {
-      set_argv('.env', '--watch');
-      mock_main.mockRejectedValueOnce(new Error('initial run failed'));
-
-      // Should not throw even though initial run fails
-      await expect(cli()).resolves.toBeUndefined();
-      expect(mock_chokidar_watch).toHaveBeenCalled();
-    });
-
-    it('keeps process alive via process.stdin.resume()', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      expect(stdin_resume_spy).toHaveBeenCalled();
-    });
-
-    it('registers a SIGINT handler for graceful shutdown', async () => {
-      set_argv('.env', '--watch');
-      await cli();
-      const sigint_call = (
-        process_on_spy.mock.calls as [string, unknown][]
-      ).find(([event]) => event === 'SIGINT');
-      expect(sigint_call).toBeDefined();
-    });
-
-    it('uses -w as alias for --watch', async () => {
-      set_argv('.env', '-w');
-      await cli();
-      expect(mock_chokidar_watch).toHaveBeenCalled();
-    });
-  });
-});

package/src/flatten.spec.ts

@@ -1,16 +0,0 @@
-import flatten from './flatten';
-
-describe('flatten', () => {
-  it('flattens config per platform', () => {
-    const config = {
-      value1: 'abc',
-      value2: { ios: 'def', android: 'xyz', web: '123' },
-    };
-    const flat_ios = flatten(config, 'ios');
-    expect(flat_ios).toEqual({ value1: 'abc', value2: 'def' });
-    const flat_android = flatten(config, 'android');
-    expect(flat_android).toEqual({ value1: 'abc', value2: 'xyz' });
-    const flat_web = flatten(config, 'web');
-    expect(flat_web).toEqual({ value1: 'abc', value2: '123' });
-  });
-});