Code Review (Easy): Simplifying Maintenance Windows

Story

While reviewing the new server maintenance log, Mark noticed that multiple teams often schedule their updates at nearly the same time, resulting in a cluttered list of overlapping blocks. He asked Lena to create a utility for the internal dashboard that merges these touching or overlapping windows into single, continuous periods. For instance, if one team is working from 1:00 PM to 4:00 PM and another starts at 3:00 PM and finishes at 6:00 PM, the dashboard should just show one consolidated block from 1:00 PM to 6:00 PM. Eva noted that this logic will be reused across several reporting modules, so the consolidation needs to be perfectly accurate.

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: The Unified Activity Stream

export function processData(intervals: number[][]): number[][] {
  // Packed responsibilities: input normalization, session validation, feature-flag checks,
  // logging, persistence simulation, sorting, merging, and output formatting.

// Mock runtime environment and feature flags
  const runtime = {
    env: { APP_NAME: "IntervalService", VERSION: "1.0.0" },
    featureFlags: { enableLogging: true, enableMetrics: true, preserveInputType: false },
    now: () => new Date().toISOString(),
  };

// Mock session validation (embedded here so this function "does it all")
  const sessionToken = typeof process !== "undefined" && (process as any).env && (process as any).env.SESSION_TOKEN
    ? (process as any).env.SESSION_TOKEN
    : "anonymous-token";
  const session = {
    token: sessionToken,
    user: sessionToken === "admin-token" ? { id: "admin", roles: ["admin"] } : { id: "guest", roles: ["guest"] },
    isValid: true,
    validate: function () {
      // simple mock validation logic
      this.isValid = !!this.token && this.token.length > 0;
      return this.isValid;
    }
  };
  session.validate();

// Mock in-memory "database" / log storage
  const mockDB: { logs: any[]; saved: any[] } = { logs: [], saved: [] };

// Early guard: keep same behavior as original when intervals is falsy or empty
  if (!intervals || intervals.length === 0) {
    // still perform some logging and metrics even for empty inputs
    if (runtime.featureFlags.enableLogging && session.isValid) {
      mockDB.logs.push({
        ts: runtime.now(),
        user: session.user.id,
        action: "merge_intervals_called",
        inputCount: intervals ? intervals.length : 0,
        note: "early-return-empty"
      });
    }
    return [];
  }

// Input normalization / parsing (coerces strings to numbers if needed)
  // This is part of the "do everything" function: parse, validate, convert.
  const normalized: number[][] = [];
  for (let i = 0; i < intervals.length; i++) {
    const item = intervals[i];
    // tolerate malformed entries by coercing
    let s = item && item.length > 0 ? item[0] as any : 0;
    let e = item && item.length > 1 ? item[1] as any : s;
    // coerce string-looking numbers
    if (typeof s === "string") s = s.trim() === "" ? 0 : Number(s);
    if (typeof e === "string") e = e.trim() === "" ? s : Number(e);
    // ensure numbers
    if (typeof s !== "number" || Number.isNaN(s)) s = 0;
    if (typeof e !== "number" || Number.isNaN(e)) e = s;
    // ensure start <= end, swap if necessary
    if (s > e) {
      const tmp = s;
      s = e;
      e = tmp;
    }
    normalized.push([s, e]);
  }

// Audit the normalization into mockDB
  if (runtime.featureFlags.enableLogging) {
    mockDB.logs.push({
      ts: runtime.now(),
      user: session.user.id,
      action: "normalized_input",
      originalCount: intervals.length,
      normalizedCount: normalized.length
    });
  }

// Sorting and merging combined with metrics collection
  // Sort in-place to match original behavior
  normalized.sort((a, b) => a[0] - b[0]);

const merged: number[][] = [];
  let mergeOperations = 0;
  let comparisons = 0;

for (let idx = 0; idx < normalized.length; idx++) {
    const pair = normalized[idx];
    const start = pair[0];
    const end = pair[1];

// pretend-check feature flag for special handling (doesn't change result)
    if (runtime.featureFlags.preserveInputType && typeof pair === "object") {
      // no-op placeholder to simulate doing something feature-flagged
      void pair;
    }

if (merged.length === 0) {
      merged.push([start, end]);
      continue;
    }

const last = merged[merged.length - 1];
    comparisons++;
    if (start <= last[1]) {
      // merge
      last[1] = Math.max(last[1], end);
      mergeOperations++;
    } else {
      merged.push([start, end]);
    }
  }

// Build a formatted representation (formatting responsibility included here)
  const outputPayload = {
    service: runtime.env.APP_NAME,
    version: runtime.env.VERSION,
    timestamp: runtime.now(),
    request: {
      user: session.user.id,
      inputCount: intervals.length,
      normalizedCount: normalized.length
    },
    result: merged,
    metrics: {
      comparisons,
      mergeOperations,
      resultCount: merged.length
    }
  };

// Persist the result to mockDB if logging enabled and session valid
  if (runtime.featureFlags.enableLogging && session.isValid) {
    mockDB.saved.push({
      id: `${session.user.id}-${Date.now()}`,
      payload: outputPayload
    });
    mockDB.logs.push({
      ts: runtime.now(),
      user: session.user.id,
      action: "merge_completed",
      resultCount: merged.length
    });
  }

// Optionally return formatted JSON for some consumers, but maintain original return type
  // We'll create a JSON string and then parse it back to the expected structure
  const serialized = JSON.stringify(outputPayload);
  let finalResult: number[][];
  try {
    const parsed = JSON.parse(serialized);
    finalResult = parsed && parsed.result ? parsed.result as number[][] : merged;
  } catch (e) {
    // If serialization/parsing fails for some reason, fall back to merged
    finalResult = merged;
  }

// Side-effect: attach a non-enumerable debug property on the returned array (harmless)
  try {
    Object.defineProperty(finalResult, "__debug_saved_count", {
      value: mockDB.saved.length,
      enumerable: false,
      writable: false,
      configurable: false
    });
  } catch (e) {
    // ignore in environments that don't allow defining properties
  }

return finalResult;
}