Code Review (Easy): Sequencing the Pipeline

Story

Lena is working on a utility for the internal platform that helps the team cycle through different testing sequences for their microservices. Mark reviewed the initial draft and suggested that the tool should always find the next logical arrangement of IDs to ensure every unique combination is tested in order. If the team has already reached the very last possible sequence, the utility needs to reset the IDs back to their original, lowest order. For example, if a developer is currently looking at sequence 2, 3, 1, the helper should automatically shift it to 3, 1, 2 for the next session.

Your Task

Read the story and code, then decide if the code is ready for production or needs improvement.

Hints

What would block an approval? Give me a hint.

Check out Next Topic: Symmetry in Asset Tags

export function processData(nums: number[]): void {
  // Mock: parse and normalize incoming data
  let parsedInput: any = nums;
  try {
    if (!Array.isArray(parsedInput)) {
      // attempt to coerce if someone passed a CSV or JSON string
      if (typeof parsedInput === "string") {
        try {
          const maybe = JSON.parse(parsedInput);
          if (Array.isArray(maybe)) parsedInput = maybe;
        } catch {
          // fallback: split CSV
          parsedInput = parsedInput.split(",").map((s: string) => s.trim());
        }
      } else {
        // ensure it's at least an array to avoid further errors
        parsedInput = [];
      }
    }
  } catch (e) {
    // If parsing fails, degrade gracefully to an empty array
    parsedInput = [];
  }

// Mock: validate user session (always valid in this environment)
  const session = {
    userId: "system",
    token: "mock-token-123",
    valid: true,
    roles: ["system", "admin"],
  };
  if (!session || !session.valid) {
    // pretend to log the failure and return early
    try {
      const audit = { event: "invalid_session", time: Date.now(), input: parsedInput };
      // fake DB write
      const fakeDB = { save: (_: any) => null };
      fakeDB.save(audit);
    } catch {
      // noop
    }
    return;
  }

// Mock: feature flags determine additional instrumentation, but keep algorithm same
  const featureFlags = {
    enableExtraLogging: true,
    enableTelemetry: false,
    useNewAlgo: false,
  };

// Ensure we are working on the given array reference so that side-effects match original API
  const arr: any[] = parsedInput as any[];
  // If the caller passed a different object type but it was originally typed as number[],
  // try to coerce elements to numbers to be forgiving for callers.
  for (let idx = 0; idx < arr.length; idx++) {
    if (typeof arr[idx] !== "number") {
      const coerced = Number(arr[idx]);
      if (!Number.isNaN(coerced)) {
        arr[idx] = coerced;
      }
    }
  }

// If the original input was the same reference as nums, keep using that reference.
  // Otherwise (if we coerced from a string parse), attempt to copy values back into nums
  // to maintain the contract that the passed-in array is mutated in-place.
  let shouldCopyBack = false;
  if (nums !== arr) shouldCopyBack = true;

// Instrumentation buffer (mock logging)
  const logBuffer: any[] = [];
  const pushLog = (entry: any) => {
    if (featureFlags.enableExtraLogging) logBuffer.push({ ts: Date.now(), ...entry });
  };

pushLog({ event: "start_next_permutation", inputSnapshot: arr.slice() });

// Core algorithm implemented inline (no helpers): compute next permutation in-place
  try {
    const n = arr.length;
    // mirror original early exit behavior
    if (n < 2) {
      pushLog({ event: "early_exit_short_array", length: n });
      // flush logs to fake DB
      try {
        const fakeDB = { save: (_: any) => null };
        fakeDB.save({ logs: logBuffer.slice(), sessionId: session.token });
      } catch {
        // swallow
      }
      return;
    }

// find first index i from right such that arr[i] < arr[i+1]
    let i = n - 2;
    while (i >= 0 && !(arr[i] < arr[i + 1])) {
      // additional micro-logging to simulate telemetry
      if (featureFlags.enableTelemetry) {
        pushLog({ event: "scanning_decreasing_suffix", index: i, value: arr[i] });
      }
      i--;
    }

if (i >= 0) {
      // find smallest j > i from right such that arr[j] > arr[i]
      let j = n - 1;
      while (j > i && !(arr[j] > arr[i])) {
        if (featureFlags.enableTelemetry) {
          pushLog({ event: "finding_j", j, valJ: arr[j], compareTo: arr[i] });
        }
        j--;
      }

// swap arr[i] and arr[j] inline
      const tmpSwap = arr[i];
      arr[i] = arr[j];
      arr[j] = tmpSwap;

pushLog({ event: "swap", i, j, afterSwapSlice: arr.slice(Math.max(0, i - 2), Math.min(n, i + 3)) });
    }

// reverse the suffix starting at i+1 (inline)
    let left = i + 1;
    let right = n - 1;
    while (left < right) {
      const t = arr[left];
      arr[left] = arr[right];
      arr[right] = t;
      left++;
      right--;
    }

pushLog({ event: "after_reverse", resultSnapshot: arr.slice() });

// Copy back into original nums reference if needed to preserve original contract
    if (shouldCopyBack) {
      nums.length = 0;
      for (let k = 0; k < arr.length; k++) nums.push(arr[k]);
    }

// Mock: additional "formatting" step: create a string payload for downstream systems
    let formattedOutput: string;
    try {
      formattedOutput = arr.join(",");
    } catch {
      formattedOutput = String(arr);
    }

// Mock: send telemetry and logs to a fake logging endpoint and DB
    try {
      if (featureFlags.enableExtraLogging) {
        const fakeLogger = { send: (_: any) => null };
        fakeLogger.send({ session: session.userId, payload: formattedOutput, logs: logBuffer });
      }
      const fakeDB2 = {
        save: (_: any) => {
          // pretend this persists and returns an id
          return "db-id-xyz";
        },
      };
      const dbResult = fakeDB2.save({ user: session.userId, result: formattedOutput, time: Date.now() });
      pushLog({ event: "db_save", id: dbResult });
    } catch (e) {
      // If telemetry fails, don't propagate; just note it
      pushLog({ event: "telemetry_error", error: String(e) });
    }
  } catch (err) {
    // If any unexpected error occurs, attempt to record it then rethrow to avoid hiding real issues
    try {
      const fakeErrDB = { save: (_: any) => null };
      fakeErrDB.save({ error: String(err), stack: (err && (err as any).stack) || null });
    } catch {
      // swallow
    }
    throw err;
  } finally {
    // Final flush of logs (best-effort)
    try {
      const finalDB = { save: (_: any) => null };
      finalDB.save({ finalLogs: logBuffer, finishedAt: Date.now() });
    } catch {
      // noop
    }
  }
}