react-native-config-ultimate 0.0.1

package/src/write-env.spec.ts

@@ -0,0 +1,105 @@
+// Mocks must be declared before the module is required.
+const mockWriteFileSync = jest.fn();
+const mockRenameSync = jest.fn();
+const mockUnlinkSync = jest.fn();
+const mockCopyFileSync = jest.fn();
+const mockMkdirSync = jest.fn(); // needed since write-env creates dest dirs
+
+jest.mock('fs', () => ({
+  writeFileSync: (...args: unknown[]) => mockWriteFileSync(...args),
+  renameSync: (...args: unknown[]) => mockRenameSync(...args),
+  unlinkSync: (...args: unknown[]) => mockUnlinkSync(...args),
+  copyFileSync: (...args: unknown[]) => mockCopyFileSync(...args),
+  mkdirSync: (...args: unknown[]) => mockMkdirSync(...args),
+}));
+
+jest.mock('os', () => ({ tmpdir: () => '/tmp' }));
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const write_env: (env: Record<string, string>) => void = require('./write-env').default;
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+/** Returns the temp file path used for a given destination. */
+function tmp_for(dest: string): string {
+  const rename_call = mockRenameSync.mock.calls.find(
+    ([, d]: [string, string]) => d === dest
+  );
+  return rename_call?.[0] as string;
+}
+
+// ─── tests ───────────────────────────────────────────────────────────────────
+
+describe('write-env', () => {
+  beforeEach(() => {
+    mockWriteFileSync.mockReset();
+    mockRenameSync.mockReset();
+    mockUnlinkSync.mockReset();
+    mockCopyFileSync.mockReset();
+    mockMkdirSync.mockReset();
+  });
+
+  it('writes content to a temp file then renames to destination (atomic write)', () => {
+    write_env({ hello: 'world' });
+
+    // Phase 1: content written to a temp path under /tmp
+    expect(mockWriteFileSync).toHaveBeenCalledTimes(1);
+    const [tmp_path, content, encoding] = mockWriteFileSync.mock.calls[0] as [string, string, string];
+    expect(tmp_path).toMatch(/^\/tmp\/rncu_/);
+    expect(content).toBe('world');
+    expect(encoding).toBe('utf8');
+
+    // Phase 2: temp renamed to final destination (atomic)
+    expect(mockRenameSync).toHaveBeenCalledWith(tmp_path, 'hello');
+  });
+
+  it('writes multiple files atomically', () => {
+    write_env({ hello: 'world', hey: 'you' });
+
+    expect(mockWriteFileSync).toHaveBeenCalledTimes(2);
+    expect(mockRenameSync).toHaveBeenCalledTimes(2);
+
+    // Each dest should have been renamed from a unique temp path
+    const tmp_hello = tmp_for('hello');
+    const tmp_hey = tmp_for('hey');
+    expect(tmp_hello).toBeDefined();
+    expect(tmp_hey).toBeDefined();
+    expect(tmp_hello).not.toBe(tmp_hey);
+  });
+
+  it('falls back to copyFileSync + unlinkSync when renameSync fails (cross-device)', () => {
+    // Simulate cross-device rename error (e.g. /tmp on different device)
+    mockRenameSync.mockImplementation(() => { throw new Error('EXDEV'); });
+
+    write_env({ hello: 'world' });
+
+    expect(mockCopyFileSync).toHaveBeenCalledWith(expect.stringMatching(/^\/tmp\/rncu_/), 'hello');
+    expect(mockUnlinkSync).toHaveBeenCalled();
+  });
+
+  it('throws a descriptive error if copyFileSync also fails', () => {
+    mockRenameSync.mockImplementation(() => { throw new Error('EXDEV'); });
+    mockCopyFileSync.mockImplementation(() => { throw new Error('EACCES: permission denied'); });
+
+    expect(() => write_env({ hello: 'world' })).toThrow(
+      /Failed to write output files/
+    );
+    expect(() => write_env({ hello: 'world' })).toThrow('hello');
+  });
+
+  it('cleans up temp files when Phase 1 write fails', () => {
+    // First write succeeds, second fails mid-write
+    mockWriteFileSync
+      .mockImplementationOnce(() => { /* success */ })
+      .mockImplementationOnce(() => { throw new Error('ENOSPC: no space left'); });
+
+    expect(() => write_env({ hello: 'world', hey: 'you' })).toThrow(
+      /Failed to prepare output files/
+    );
+
+    // The first temp file should have been cleaned up
+    expect(mockUnlinkSync).toHaveBeenCalledTimes(1);
+    // No renames should have happened (no real files touched)
+    expect(mockRenameSync).not.toHaveBeenCalled();
+  });
+});

package/src/write-env.ts

@@ -0,0 +1,67 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export type FileMap = Record<string, string>;
+
+/**
+ * Atomically write all generated files.
+ *
+ * Strategy: write each file to a temp path first, then rename (atomic on POSIX).
+ * If any write fails, we abort before committing any renames so the project
+ * is never left in a partially-written state.
+ *
+ * On Windows, `fs.renameSync` across drives may fail — in that case we fall
+ * back to a direct `writeFileSync` (best-effort, still better than nothing).
+ */
+export default function write_env(files: FileMap): void {
+  const tmp_dir = os.tmpdir();
+  // Phase 1: write all content to temp files — if anything fails, no real files are touched.
+  const pending: Array<{ tmp: string; dest: string }> = [];
+
+  try {
+    for (const dest of Object.keys(files)) {
+      // Ensure the destination directory exists (handles first-run and hoisted workspaces).
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      const tmp = path.join(tmp_dir, `rncu_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+      fs.writeFileSync(tmp, files[dest], 'utf8');
+      pending.push({ tmp, dest });
+    }
+  } catch (err) {
+    // Clean up any temp files we already created.
+    for (const { tmp } of pending) {
+      try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+    }
+    throw new Error(
+      `[rncu] Failed to prepare output files: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+
+  // Phase 2: atomically rename temp → dest.
+  // We collect errors and rethrow at the end so the caller gets a clear message.
+  const rename_errors: string[] = [];
+
+  for (const { tmp, dest } of pending) {
+    try {
+      fs.renameSync(tmp, dest);
+    } catch {
+      // Cross-device rename (e.g. Windows different drives) — fall back to copy+delete.
+      try {
+        fs.copyFileSync(tmp, dest);
+        fs.unlinkSync(tmp);
+      } catch (copy_err) {
+        rename_errors.push(
+          `${dest}: ${copy_err instanceof Error ? copy_err.message : String(copy_err)}`
+        );
+        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')
+    );
+  }
+}