@ted-galago/wave-cli 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ted-galago/wave-cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "bin": {
     "wave": "dist/index.js"

package/scripts/verify-dev-api.mjs

@@ -41,9 +41,27 @@ function runWave(args, env) {
 }
 
 function firstId(parsed, field) {
-  const data = parsed?.data?.[field];
-  if (data?.data?.[0]?.id) return String(data.data[0].id);
-  if (data?.id) return String(data.id);
+  const root = parsed?.data;
+  if (!root || typeof root !== "object") {
+    return undefined;
+  }
+
+  const lookup = root;
+  const candidates = [];
+  if (field) {
+    candidates.push(field);
+  }
+  for (const key of Object.keys(lookup)) {
+    if (!candidates.includes(key)) {
+      candidates.push(key);
+    }
+  }
+
+  for (const key of candidates) {
+    const data = lookup[key];
+    if (data?.data?.[0]?.id) return String(data.data[0].id);
+    if (data?.id) return String(data.id);
+  }
   return undefined;
 }
 
@@ -61,7 +79,15 @@ function classify(result) {
   if (!result.parsed) {
     return { ok: false, reason: "non_json_output" };
   }
+  const embeddedError = findFirstEmbeddedErrors(result.parsed);
   if (result.parsed.ok === true) {
+    if (embeddedError) {
+      return {
+        ok: false,
+        reason: "embedded_errors",
+        details: { path: embeddedError.path, sample: embeddedError.sample }
+      };
+    }
     return { ok: true, reason: "ok" };
   }
 
@@ -91,12 +117,79 @@ function classify(result) {
   if (code === "invalid_args" && message.includes("Missing required create fields")) {
     return { ok: true, reason: "skipped_missing_parent_dependency" };
   }
+  if (result.parsed?.status === 422 && code === "VALIDATION_ERROR") {
+    return { ok: true, reason: "domain_validation_error" };
+  }
   if (code === "invalid_args") {
     return { ok: false, reason: code };
   }
   return { ok: true, reason: `reachable_${code}` };
 }
 
+function isNonEmptyErrorsValue(value) {
+  if (value === null || value === undefined) return false;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return false;
+    return value.some((entry) => {
+      if (entry === null || entry === undefined) return false;
+      if (typeof entry === "string") return entry.trim().length > 0;
+      if (typeof entry === "object") return Object.keys(entry).length > 0;
+      return true;
+    });
+  }
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+
+function summarizeValue(value) {
+  try {
+    if (typeof value === "string") return value.slice(0, 160);
+    const serialized = JSON.stringify(value);
+    if (typeof serialized !== "string") return String(value);
+    return serialized.slice(0, 300);
+  } catch {
+    return String(value);
+  }
+}
+
+function findFirstEmbeddedErrors(input) {
+  const queue = [{ value: input, path: "$", depth: 0 }];
+  const maxDepth = 12;
+  const maxNodes = 2000;
+  let visited = 0;
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    visited += 1;
+    if (visited > maxNodes) break;
+
+    const { value, path, depth } = current;
+    if (!value || typeof value !== "object") continue;
+
+    if (Array.isArray(value)) {
+      if (depth >= maxDepth) continue;
+      for (let i = 0; i < value.length; i += 1) {
+        queue.push({ value: value[i], path: `${path}[${i}]`, depth: depth + 1 });
+      }
+      continue;
+    }
+
+    for (const [key, nested] of Object.entries(value)) {
+      const nextPath = `${path}.${key}`;
+      if (key === "errors" && isNonEmptyErrorsValue(nested)) {
+        return { path: nextPath, sample: summarizeValue(nested) };
+      }
+      if (depth < maxDepth && nested && typeof nested === "object") {
+        queue.push({ value: nested, path: nextPath, depth: depth + 1 });
+      }
+    }
+  }
+
+  return null;
+}
+
 function payload(root, attrs) {
   return JSON.stringify({ [root]: attrs });
 }
@@ -151,6 +244,83 @@ function verifySubissueDeleteWithPolling(env, issueId, subIssueId) {
   return { ok: false, attempts, tries: 5 };
 }
 
+function isValidationErrorResult(result) {
+  return result?.parsed?.status === 422 && result?.parsed?.error?.code === "VALIDATION_ERROR";
+}
+
+function extractValidationMessages(result) {
+  const errors = result?.parsed?.error?.details?.errors?.data;
+  if (!Array.isArray(errors)) return [];
+  return errors
+    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+    .filter((entry) => entry.length > 0);
+}
+
+function startsWithArgs(args, prefix) {
+  if (!Array.isArray(args)) return false;
+  if (args.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i += 1) {
+    if (args[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+
+function findFirstResultByPrefix(results, prefix) {
+  return results.find((entry) => startsWithArgs(entry.args, prefix));
+}
+
+function cloneArgs(args) {
+  return Array.isArray(args) ? [...args] : [];
+}
+
+function parseDataJsonFromArgs(args) {
+  const idx = args.indexOf("--data-json");
+  if (idx < 0 || idx + 1 >= args.length) return null;
+  try {
+    const parsed = JSON.parse(String(args[idx + 1]));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function withUpdatedDataJson(args, nextPayload) {
+  const idx = args.indexOf("--data-json");
+  if (idx < 0 || idx + 1 >= args.length) return args;
+  const next = cloneArgs(args);
+  next[idx + 1] = JSON.stringify(nextPayload);
+  return next;
+}
+
+function getArgValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function isoDatePlusDays(isoDate, days) {
+  const date = new Date(`${isoDate}T00:00:00Z`);
+  if (Number.isNaN(date.getTime())) return null;
+  date.setUTCDate(date.getUTCDate() + days);
+  return date.toISOString().slice(0, 10);
+}
+
+function summarizeStatus(result) {
+  const status = result?.parsed?.status ?? "n/a";
+  const err = result?.parsed?.error?.code ?? "none";
+  return `status=${status},err=${err}`;
+}
+
+function resolveAnnualStrategicObjectiveId(result) {
+  return firstDefinedValue(result?.parsed, [
+    ["data", "annual_objective", "attributes", "strategicObjectiveId"],
+    ["data", "annual_objective", "attributes", "strategic_objective_id"],
+    ["data", "annual_objective", "strategicObjectiveId"],
+    ["data", "annual_objective", "strategic_objective_id"]
+  ]);
+}
+
 const root = process.cwd();
 const envFile = resolve(root, ".env");
 const dot = loadDotEnv(envFile);
@@ -412,6 +582,352 @@ for (const args of probes) {
   results.push(runWave(args, env));
 }
 
+const validationRemediationEntries = [];
+let validationRemediationFailures = 0;
+let feedbackQuarterExpected = feedbackQuarterVerify;
+
+function recordValidationRemediation(entry) {
+  validationRemediationEntries.push(entry);
+}
+
+function remediateStandupsCreateDuplicateDate() {
+  const operation = "stand-ups.create";
+  const initial = findFirstResultByPrefix(results, ["stand-ups", "create"]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.completed_date"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isDuplicateDateValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) => /completed date.*already been taken/i.test(msg));
+
+  if (!isDuplicateDateValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.completed_date"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const standUpBody =
+    initialPayload && typeof initialPayload.stand_up === "object" ? initialPayload.stand_up : null;
+  const baseDate =
+    standUpBody && typeof standUpBody.completed_date === "string"
+      ? standUpBody.completed_date
+      : "2026-04-06";
+
+  if (!standUpBody || typeof standUpBody.member_id !== "string") {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.member_id", "stand_up.completed_date"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_member_or_payload",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const attemptedDates = [];
+  let finalResult = initial;
+  let remediation = "retry_create_with_next_date";
+  for (let offset = 1; offset <= 7; offset += 1) {
+    const candidateDate = isoDatePlusDays(baseDate, offset);
+    if (!candidateDate) continue;
+    attemptedDates.push(candidateDate);
+    const nextPayload = {
+      stand_up: {
+        ...standUpBody,
+        completed_date: candidateDate
+      }
+    };
+    const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+    const retryResult = runWave(retryArgs, env);
+    results.push(retryResult);
+    finalResult = retryResult;
+    if (retryResult.parsed?.ok === true) {
+      remediation = `retry_create_with_next_date_success base=${baseDate} chosen=${candidateDate}`;
+      break;
+    }
+    const retryMessages = extractValidationMessages(retryResult);
+    const stillDuplicate = retryMessages.some((msg) =>
+      /completed date.*already been taken/i.test(msg)
+    );
+    if (!stillDuplicate) {
+      remediation = `retry_create_with_next_date_stopped_non_duplicate_error at=${candidateDate}`;
+      break;
+    }
+    remediation = `retry_create_with_next_date_exhausting base=${baseDate}`;
+  }
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["stand_up.completed_date"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation: `${remediation};attempted_dates=${attemptedDates.join(",")}`,
+    finalResult: summarizeStatus(finalResult)
+  });
+
+  if (finalResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  }
+}
+
+function remediateFeedbacksUpdateDuplicateName() {
+  const operation = "feedbacks.update";
+  const initial = findFirstResultByPrefix(results, ["feedbacks", "update"]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isDuplicateNameValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) => /name has already been taken/i.test(msg));
+
+  if (!isDuplicateNameValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const feedbackBody =
+    initialPayload && typeof initialPayload.feedback === "object" ? initialPayload.feedback : null;
+  const originalName =
+    feedbackBody && typeof feedbackBody.name === "string" ? feedbackBody.name : "feedback";
+
+  if (!feedbackBody) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_feedback_payload",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const feedbackId = getArgValue(initial.args, "--id");
+  if (!feedbackId) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name", "feedback.year"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_feedback_id",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const showArgs = ["feedbacks", "show", "--id", String(feedbackId)];
+  const showResult = runWave(showArgs, env);
+  results.push(showResult);
+
+  const currentName = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "name"],
+    ["data", "feedback", "name"]
+  ]);
+  const currentQuarter = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "quarter"],
+    ["data", "feedback", "quarter"]
+  ]);
+  const currentYear = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "year"],
+    ["data", "feedback", "year"]
+  ]);
+
+  if (!showResult.parsed?.ok || !currentName || !currentQuarter) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name", "feedback.year"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: `failed_feedback_show_lookup id=${feedbackId};lookup=${summarizeStatus(showResult)}`,
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const parsedYear = Number.parseInt(String(currentYear ?? ""), 10);
+  const remediatedYear = Number.isFinite(parsedYear) ? parsedYear + 1 : 2030;
+  const nextPayload = {
+    feedback: {
+      ...feedbackBody,
+      name: String(currentName),
+      quarter: String(currentQuarter),
+      year: String(remediatedYear)
+    }
+  };
+  const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+  const finalResult = runWave(retryArgs, env);
+  results.push(finalResult);
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["feedback.name", "feedback.year"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation:
+      `fallback_non_unique_field original_name=${originalName}` +
+      ` remediated_name=${String(currentName)}` +
+      ` remediated_quarter=${String(currentQuarter)}` +
+      ` remediated_year=${String(remediatedYear)}`,
+    finalResult: summarizeStatus(finalResult)
+  });
+
+  if (finalResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  } else {
+    feedbackQuarterExpected = String(currentQuarter);
+  }
+}
+
+function remediateQuarterlyObjectiveParentMismatch() {
+  const operation = "foundation.quarterly-objectives.create";
+  const initial = findFirstResultByPrefix(results, [
+    "foundation",
+    "quarterly-objectives",
+    "create"
+  ]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isParentMismatchValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) =>
+      /belongs to strategic_objective_id|matching strategic_objective_id/i.test(msg)
+    );
+
+  if (!isParentMismatchValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const quarterlyBody =
+    initialPayload && typeof initialPayload.quarterly_objective === "object"
+      ? initialPayload.quarterly_objective
+      : null;
+  const annualId =
+    quarterlyBody && typeof quarterlyBody.annual_objective_id === "string"
+      ? quarterlyBody.annual_objective_id
+      : "";
+
+  if (!quarterlyBody || annualId.length === 0) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_annual_objective_id",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const annualShowArgs = ["foundation", "annual-objectives", "show", "--id", annualId];
+  const annualShowResult = runWave(annualShowArgs, env);
+  results.push(annualShowResult);
+  const resolvedStrategicObjectiveId = resolveAnnualStrategicObjectiveId(annualShowResult);
+  if (!annualShowResult.parsed?.ok || !resolvedStrategicObjectiveId) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: `failed_parent_lookup annual_id=${annualId};lookup=${summarizeStatus(annualShowResult)}`,
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const nextPayload = {
+    quarterly_objective: {
+      ...quarterlyBody,
+      strategic_objective_id: String(resolvedStrategicObjectiveId),
+      annual_objective_id: annualId
+    }
+  };
+  const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+  const retryResult = runWave(retryArgs, env);
+  results.push(retryResult);
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation: `parent_match annual_id=${annualId} strategic_objective_id=${String(resolvedStrategicObjectiveId)}`,
+    finalResult: summarizeStatus(retryResult)
+  });
+
+  if (retryResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  }
+}
+
+remediateStandupsCreateDuplicateDate();
+remediateFeedbacksUpdateDuplicateName();
+remediateQuarterlyObjectiveParentMismatch();
+
 let deleteVerifyLine = "";
 let deleteVerifyFailure = 0;
 if (issueId) {
@@ -577,7 +1093,7 @@ verifyFieldWrite({
 verifyFieldWrite({
   label: "feedbacks.update verify quarter",
   showArgs: ["feedbacks", "show", "--id", feedbackId],
-  expectedValue: feedbackQuarterVerify,
+  expectedValue: feedbackQuarterExpected,
   requiredSuccessPrefix: ["feedbacks", "update"],
   candidatePaths: [["data", "feedback", "attributes", "quarter"]]
 });
@@ -597,7 +1113,10 @@ for (const res of results) {
   const cmd = res.args.join(" ");
   const status = res.parsed?.status ?? "n/a";
   const errCode = res.parsed?.error?.code ?? "none";
-  lines.push(`${verdict.ok ? "PASS" : "FAIL"} | status=${status} | err=${errCode} | ${cmd}`);
+  const reasonDetail = verdict.details ? ` (${JSON.stringify(verdict.details)})` : "";
+  lines.push(
+    `${verdict.ok ? "PASS" : "FAIL"} | status=${status} | err=${errCode} | reason=${verdict.reason}${reasonDetail} | ${cmd}`
+  );
   if (!verdict.ok) failures += 1;
 }
 
@@ -609,9 +1128,30 @@ if (postUpdateVerificationLines.length > 0) {
   lines.push(...postUpdateVerificationLines);
 }
 failures += postUpdateVerificationFailures;
+failures += validationRemediationFailures;
+
+if (validationRemediationEntries.length > 0) {
+  lines.push("VALIDATION_REMEDIATION_SUMMARY_START");
+  for (const entry of validationRemediationEntries) {
+    lines.push(
+      [
+        "VALIDATION_REMEDIATION",
+        `operation=${entry.operation}`,
+        `offending_fields=${entry.offendingFields.join(",") || "n/a"}`,
+        `backend_message=${JSON.stringify(entry.backendMessage ?? "")}`,
+        `initial_result=${entry.initialResult}`,
+        `remediation=${entry.remediation}`,
+        `final_result=${entry.finalResult}`
+      ].join(" | ")
+    );
+  }
+  lines.push("VALIDATION_REMEDIATION_SUMMARY_END");
+}
 
 console.log(lines.join("\n"));
 const extraChecksCount =
-  (deleteVerifyLine ? 1 : 0) + postUpdateVerificationLines.length;
+  (deleteVerifyLine ? 1 : 0) +
+  postUpdateVerificationLines.length +
+  validationRemediationEntries.length;
 console.log(`\nSUMMARY total=${results.length + extraChecksCount} failures=${failures}`);
 if (failures > 0) process.exit(1);