react-native-config-ultimate 0.0.1

package/src/cli.spec.ts

@@ -0,0 +1,224 @@
+// 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/cli.ts

@@ -0,0 +1,166 @@
+import yargs from 'yargs';
+import * as path from 'path';
+import * as fs from 'fs';
+import { watch } from 'chokidar';
+import main from './main';
+import type { RC } from './resolve-env';
+
+/**
+ * Load the RC file fresh on every call (clears require cache so
+ * changes to .rncurc.js are picked up during --watch mode).
+ */
+function load_rc(rc_file: string): RC | undefined {
+  if (!fs.existsSync(rc_file)) return undefined;
+  delete require.cache[require.resolve(rc_file)];
+  // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
+  return require(rc_file) as RC;
+}
+
+function log(msg: string): void {
+  process.stdout.write(`[rncu] ${msg}\n`);
+}
+
+function log_err(msg: string): void {
+  process.stderr.write(`[rncu] ✗ ${msg}\n`);
+}
+
+export default async function cli(): Promise<void> {
+  const argv = await yargs(process.argv.slice(2))
+    .option('projectRoot', {
+      type: 'string',
+      default: process.cwd(),
+      description: 'Root directory of the React Native project',
+    })
+    .option('libRoot', {
+      type: 'string',
+      description:
+        'Root directory of react-native-config-ultimate ' +
+        '(defaults to <projectRoot>/node_modules/react-native-config-ultimate)',
+    })
+    .option('watch', {
+      alias: 'w',
+      type: 'boolean',
+      default: false,
+      description:
+        'Watch env file(s) for changes and regenerate automatically. ' +
+        'Note: changes to native vars (iOS xcconfig, Android BuildConfig) ' +
+        'still require a full native rebuild.',
+    })
+    .usage('Usage: $0 <env-file> [env-file2 ...] [options]')
+    .help()
+    .parseAsync();
+
+  const project_root = argv.projectRoot;
+
+  /**
+   * Resolve the library root directory.
+   *
+   * Priority:
+   * 1. --libRoot flag (explicit override)
+   * 2. Conventional path <projectRoot>/node_modules/react-native-config-ultimate
+   *    — used when the directory exists (standard install, or bin.spec.ts integration test).
+   * 3. require.resolve() — handles npm workspaces hoisting, pnpm, Yarn PnP,
+   *    and any layout where the package is hoisted above projectRoot.
+   * 4. Fall back to conventional path even if it doesn't exist yet
+   *    (write-env.ts will create the directories on first run).
+   */
+  const lib_root: string = (() => {
+    if (argv.libRoot) return argv.libRoot;
+
+    const conventional = path.join(
+      project_root,
+      'node_modules',
+      'react-native-config-ultimate'
+    );
+
+    // If the directory already exists at the conventional location, use it.
+    // This handles standard installs and the integration test temp-dir setup.
+    if (fs.existsSync(conventional)) return conventional;
+
+    // Otherwise, try require.resolve to handle hoisted workspaces.
+    try {
+      const pkg_json = require.resolve(
+        'react-native-config-ultimate/package.json',
+        { paths: [project_root] }
+      );
+      return path.dirname(pkg_json);
+    } catch {
+      // Last resort: return the conventional path and let write-env create it.
+      return conventional;
+    }
+  })();
+
+  // Accept one or more positional env file paths.
+  // Multiple files are merged left-to-right (last file wins for conflicting keys).
+  const env_files = argv._.map(String);
+
+  // Validate env files exist before running anything.
+  const missing_files = env_files.filter((f) => !fs.existsSync(f));
+  if (missing_files.length > 0) {
+    for (const f of missing_files) {
+      log_err(`env file not found: ${f}`);
+    }
+    process.exit(1);
+  }
+
+  const rc_file = path.resolve(project_root, '.rncurc.js');
+
+  // Helper: run the full pipeline once, returning duration in ms.
+  // Never throws — errors are caught and logged so watch mode stays alive.
+  async function run(changed_path?: string): Promise<void> {
+    if (changed_path) {
+      log(`${changed_path} changed → regenerating...`);
+    }
+    const start = Date.now();
+    try {
+      const rc = load_rc(rc_file);
+      await main(project_root, lib_root, env_files, rc);
+      if (changed_path) {
+        log(`✓ done in ${Date.now() - start}ms`);
+      }
+    } catch (err) {
+      log_err(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  // Initial run (always runs, throws on error in non-watch mode).
+  if (!argv.watch) {
+    const rc = load_rc(rc_file);
+    await main(project_root, lib_root, env_files, rc);
+    return;
+  }
+
+  // --watch mode ────────────────────────────────────────────────────────────
+  // Initial run (errors are caught — we still want to start watching).
+  await run();
+
+  // Files to watch: env files + RC file (if it exists).
+  const files_to_watch = [
+    ...env_files,
+    ...(fs.existsSync(rc_file) ? [rc_file] : []),
+  ];
+
+  const watcher = watch(files_to_watch, {
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  log(
+    `watching: ${files_to_watch.join(', ')}\n` +
+      `[rncu] ⚠  native vars (xcconfig/BuildConfig) require a full rebuild to take effect`
+  );
+
+  watcher.on('change', (p) => void run(p));
+  watcher.on('add', (p) => void run(p));
+
+  // Keep the process alive (chokidar persistent:true already does this,
+  // but stdin.resume makes it explicit and survives edge cases).
+  process.stdin.resume();
+
+  // Graceful shutdown on Ctrl+C.
+  process.on('SIGINT', () => {
+    process.stdout.write('\n');
+    log('stopping...');
+    void watcher.close().then(() => process.exit(0));
+  });
+}

package/src/flatten.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flatten;
+const assert_1 = __importDefault(require("assert"));
+const VALID_PLATFORMS = ['ios', 'android', 'web'];
+function flatten(config, platform) {
+    (0, assert_1.default)(config && typeof config === 'object', 'Config should be non-null object');
+    (0, assert_1.default)(VALID_PLATFORMS.includes(platform), '`platform` should one of: ' + VALID_PLATFORMS.join(', '));
+    const result = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (value && typeof value === 'object') {
+            result[key] = value[platform];
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/src/flatten.spec.ts

@@ -0,0 +1,16 @@
+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' });
+  });
+});

package/src/flatten.ts

@@ -0,0 +1,26 @@
+import assert from 'assert';
+
+type Platform = 'ios' | 'android' | 'web';
+export type ConfigValue = string | number | boolean;
+export type PerPlatformValue = Partial<Record<Platform, ConfigValue>>;
+export type EnvConfig = Record<string, ConfigValue | PerPlatformValue>;
+export type FlatConfig = Record<string, ConfigValue | undefined>;
+
+const VALID_PLATFORMS: Platform[] = ['ios', 'android', 'web'];
+
+export default function flatten(config: EnvConfig, platform: Platform): FlatConfig {
+  assert(config && typeof config === 'object', 'Config should be non-null object');
+  assert(
+    VALID_PLATFORMS.includes(platform),
+    '`platform` should one of: ' + VALID_PLATFORMS.join(', ')
+  );
+  const result: FlatConfig = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value && typeof value === 'object') {
+      result[key] = (value as PerPlatformValue)[platform];
+    } else {
+      result[key] = value as ConfigValue;
+    }
+  }
+  return result;
+}

package/src/load-env.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = load_env;
+const dotenv = __importStar(require("dotenv"));
+const dotenv_expand_1 = require("dotenv-expand");
+const yaml = __importStar(require("js-yaml"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function detect_format(config_path) {
+    const { ext } = path.parse(config_path);
+    return ext === '.yml' || ext === '.yaml' ? 'yaml' : 'dotenv';
+}
+function read_yaml(config_path) {
+    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}'`);
+    }
+    return data;
+}
+/**
+ * Load one or more env files and merge them (last file wins for conflicting keys).
+ *
+ * Dotenv files (.env, .env.staging, etc.):
+ *   - All files are merged first, then variable expansion runs once.
+ *   - This means cross-file `$VAR` references work:
+ *     .env.base:    BASE_URL=https://api.example.com
+ *     .env.staging: API_URL=$BASE_URL/v1  →  https://api.example.com/v1
+ *
+ * YAML files (.yml, .yaml):
+ *   - Each file is loaded and shallow-merged (last wins for top-level keys).
+ *   - No variable expansion is applied (use YAML anchors instead).
+ *
+ * @example
+ * // Single file (backward-compatible):
+ * load_env('.env')
+ *
+ * // Multi-file merge:
+ * load_env(['.env.base', '.env.staging'])
+ */
+function load_env(config_paths) {
+    var _a, _b;
+    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 ...]');
+    }
+    const formats = paths.map(detect_format);
+    const allDotenv = formats.every((f) => f === 'dotenv');
+    if (allDotenv) {
+        // Merge raw parsed content first, then expand once —
+        // so cross-file $VAR references resolve correctly.
+        const raw = {};
+        for (const p of paths) {
+            const content = fs.readFileSync(p, 'utf8');
+            Object.assign(raw, dotenv.parse(content));
+        }
+        const result = (0, dotenv_expand_1.expand)({ parsed: raw });
+        return ((_a = result.parsed) !== null && _a !== void 0 ? _a : raw);
+    }
+    // YAML or mixed: load each file individually and shallow-merge.
+    const merged = {};
+    for (let i = 0; i < paths.length; i++) {
+        const p = paths[i];
+        if (formats[i] === 'yaml') {
+            Object.assign(merged, read_yaml(p));
+        }
+        else {
+            const content = fs.readFileSync(p, 'utf8');
+            const parsed = dotenv.parse(content);
+            const expanded = (0, dotenv_expand_1.expand)({ parsed });
+            Object.assign(merged, (_b = expanded.parsed) !== null && _b !== void 0 ? _b : parsed);
+        }
+    }
+    return merged;
+}