repo-contract 0.2.0 → 0.3.2

package/dist/index.js

@@ -74,6 +74,20 @@ var ParserDependencyMissingError = class extends RepoContractError {
     this.format = format;
   }
 };
+var StandardSchemaValidateThrewError = class extends RepoContractError {
+  /** Always `"REPO_CONTRACT_STANDARD_SCHEMA_VALIDATE_THREW"`. */
+  code = "REPO_CONTRACT_STANDARD_SCHEMA_VALIDATE_THREW";
+  /** The id of the check whose `output.schema` threw during validation. */
+  checkId;
+  constructor(checkId, cause) {
+    super(
+      `Check "${checkId}"'s output.schema["~standard"].validate() threw instead of returning a Result`,
+      { cause }
+    );
+    this.name = "StandardSchemaValidateThrewError";
+    this.checkId = checkId;
+  }
+};
 var PolicyThrewError = class extends RepoContractError {
   /** Always `"REPO_CONTRACT_POLICY_THREW"`. */
   code = "REPO_CONTRACT_POLICY_THREW";
@@ -358,13 +372,46 @@ function validateOutput(checkId, output) {
   if (output === null || typeof output !== "object") {
     throw new InvalidCheckConfigError(checkId, "output must be an object when provided.");
   }
-  const { format } = output;
+  const { format, schema } = output;
   if (typeof format !== "string" || !OUTPUT_FORMATS.includes(format)) {
     throw new InvalidCheckConfigError(
       checkId,
       `output.format must be one of ${OUTPUT_FORMATS.map((f) => `"${f}"`).join(", ")}.`
     );
   }
+  validateOutputSchema(checkId, schema);
+}
+function validateOutputSchema(checkId, schema) {
+  if (schema === void 0) return;
+  if (schema === null || typeof schema !== "object" && typeof schema !== "function") {
+    throw new InvalidCheckConfigError(
+      checkId,
+      "output.schema must be a Standard Schema-compliant object or function when provided (see https://standardschema.dev)."
+    );
+  }
+  const standard = schema["~standard"];
+  if (standard === null || typeof standard !== "object") {
+    throw new InvalidCheckConfigError(
+      checkId,
+      'output.schema must have a "~standard" property (see https://standardschema.dev).'
+    );
+  }
+  const { version, vendor, validate } = standard;
+  if (version !== 1) {
+    throw new InvalidCheckConfigError(checkId, 'output.schema["~standard"].version must be 1.');
+  }
+  if (typeof vendor !== "string") {
+    throw new InvalidCheckConfigError(
+      checkId,
+      'output.schema["~standard"].vendor must be a string.'
+    );
+  }
+  if (typeof validate !== "function") {
+    throw new InvalidCheckConfigError(
+      checkId,
+      'output.schema["~standard"].validate must be a function.'
+    );
+  }
 }
 function validatePolicy(checkId, policy) {
   if (typeof policy !== "function") {
@@ -405,6 +452,28 @@ function validateDependencyGraph(checks) {
   }
 }
 
+// src/parsing/format-schema-issues.ts
+function formatSchemaIssues(issues) {
+  return `Schema validation failed: ${issues.map(formatIssue).join("; ")}`;
+}
+function formatIssue(issue) {
+  const path = formatPath(issue.path);
+  return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function formatPath(path) {
+  if (path === void 0 || path.length === 0) return "";
+  return path.map(
+    (segment) => (
+      // eslint-disable-next-line secure-coding/no-improper-type-validation -- `segment` is declared `PropertyKey | StandardSchemaV1.PathSegment` (never `null` or an array), so `typeof segment === "object"` can only match the `PathSegment` object form here; the null/array-safe rewrite this rule suggests is flagged as an unreachable condition by @typescript-eslint/no-unnecessary-condition given that exact type, so satisfying both rules at once is impossible -- the type itself is the guarantee this check would otherwise add at runtime.
+      typeof segment === "object" ? segment.key : segment
+    )
+  ).map((key, index) => {
+    if (typeof key === "number") return `[${String(key)}]`;
+    const rendered = String(key);
+    return index === 0 ? rendered : `.${rendered}`;
+  }).join("");
+}
+
 // src/parsing/parse-json.ts
 function parseJson(stdout) {
   try {
@@ -443,7 +512,24 @@ async function parseYaml(stdout, checkId) {
 }
 
 // src/parsing/parse-output.ts
-async function parseOutput(format, stdout, checkId) {
+async function parseOutput(format, stdout, checkId, schema) {
+  const parsed = await dispatch(format, stdout, checkId);
+  if (!parsed.success || schema === void 0) return parsed;
+  let result;
+  try {
+    result = await schema["~standard"].validate(parsed.value);
+    if (typeof result !== "object" || result === null) {
+      throw new TypeError(`validate() returned ${String(result)} instead of a Result object`);
+    }
+  } catch (error) {
+    throw new StandardSchemaValidateThrewError(checkId, error);
+  }
+  if (result.issues === void 0) {
+    return { format, success: true, value: result.value };
+  }
+  return { format, success: false, error: formatSchemaIssues(result.issues) };
+}
+async function dispatch(format, stdout, checkId) {
   switch (format) {
     case "json":
       return parseJson(stdout);
@@ -461,7 +547,12 @@ async function buildEvidence(results, startedAt, completedAt) {
     results.map(async ([checkId, check, raw]) => {
       if (check.output === void 0) return [checkId, check, raw];
       try {
-        const output = await parseOutput(check.output.format, raw.stdout, checkId);
+        const output = await parseOutput(
+          check.output.format,
+          raw.stdout,
+          checkId,
+          check.output.schema
+        );
         return [checkId, check, { ...raw, output }];
       } catch (error) {
         thrown.push(error);
@@ -474,7 +565,10 @@ async function buildEvidence(results, startedAt, completedAt) {
     throw only;
   }
   if (thrown.length > 1) {
-    throw new AggregateError(thrown, `${String(thrown.length)} check output(s) failed to parse.`);
+    throw new AggregateError(
+      thrown,
+      `${String(thrown.length)} check output(s) failed during output processing.`
+    );
   }
   const evidence = {
     version: 1,
@@ -1066,6 +1160,6 @@ async function runRepoContractAfterValidation(config, options) {
   return { evidence, verdict };
 }
 
-export { DependencyDeclaredLaterError, InvalidCheckConfigError, InvalidRepoContractConfigError, ParserDependencyMissingError, PolicyReadFailedParseValueError, PolicyReadUnrequestedOutputError, PolicyThrewError, RepoContractError, UnknownCheckIdError, defineRepoContract, runRepoContract };
+export { DependencyDeclaredLaterError, InvalidCheckConfigError, InvalidRepoContractConfigError, ParserDependencyMissingError, PolicyReadFailedParseValueError, PolicyReadUnrequestedOutputError, PolicyThrewError, RepoContractError, StandardSchemaValidateThrewError, UnknownCheckIdError, defineRepoContract, runRepoContract };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map