@peasant-labs/schema 0.1.0-rc6

package/dist/testcase.js

@@ -0,0 +1,144 @@
+import { parseAllDocuments } from "yaml";
+// Classification and ProvenanceSource are generated from
+// testcase/testcase.go's AllClassifications/AllProvenanceSources (see
+// typescript/scripts/generate-contract-support.mjs's renderTestcaseModel) so
+// this meta-testing vocabulary can never silently drift from the Go source it
+// mirrors. Only the YAML-loading mechanics below are handwritten.
+import { Classification, AllClassifications, isClassification, ProvenanceSource, AllProvenanceSources, isProvenanceSource, } from "./internal/generated/testcase.gen.js";
+export { Classification, AllClassifications, isClassification, ProvenanceSource, AllProvenanceSources, isProvenanceSource };
+export function checkMin(corpus, minimum) {
+    if (!Number.isSafeInteger(minimum) || minimum < 0)
+        return new Error(`minimum must be a non-negative safe integer, got ${String(minimum)}`);
+    if (corpus.cases.length < minimum)
+        return new Error(`corpus has ${corpus.cases.length} case(s), want at least ${minimum}`);
+    return undefined;
+}
+export function validateCase(testCase) {
+    const path = `case ${JSON.stringify(testCase.name)}`;
+    if (testCase.name.trim() === "")
+        return new Error(`${path}: name is empty`);
+    if (!isClassification(testCase.classification))
+        return new Error(`${path}: classification ${JSON.stringify(testCase.classification)} is not one of ${AllClassifications.join("/")}`);
+    if (!isProvenanceSource(testCase.provenance.source))
+        return new Error(`${path}: provenance source ${JSON.stringify(testCase.provenance.source)} is not a known source`);
+    if (testCase.provenance.ref.trim() === "")
+        return new Error(`${path}: provenance ref is empty (a case must cite why it exists)`);
+    if (testCase.mutation.description.trim() === "")
+        return new Error(`${path}: mutation description is empty (a case must describe the change under test)`);
+    return undefined;
+}
+export function validateCorpus(corpus) {
+    const names = new Set();
+    for (const [index, testCase] of corpus.cases.entries()) {
+        if (names.has(testCase.name))
+            return new Error(`corpus case ${index}: duplicate case name ${JSON.stringify(testCase.name)}`);
+        names.add(testCase.name);
+        const error = validateCase(testCase);
+        if (error !== undefined)
+            return new Error(`corpus case ${index}: ${error.message}`, { cause: error });
+    }
+    return undefined;
+}
+export class CorpusError extends Error {
+    path;
+    constructor(path, message, options) {
+        super(`${path}: ${message}`, options);
+        this.name = "CorpusError";
+        this.path = path;
+    }
+}
+export function loadCorpus(source, decoders) {
+    let documents;
+    try {
+        documents = parseAllDocuments(source, { strict: true, uniqueKeys: true });
+    }
+    catch (error) {
+        throw new CorpusError("$", "YAML parsing failed", { cause: error });
+    }
+    if (documents.length !== 1) {
+        throw new CorpusError("$", `expected exactly one YAML document, got ${documents.length}`);
+    }
+    const document = documents[0];
+    if (document === undefined) {
+        throw new CorpusError("$", "YAML parser returned no document");
+    }
+    if (document.errors.length > 0) {
+        throw new CorpusError("$", `YAML parsing failed: ${document.errors.map((error) => error.message).join("; ")}`);
+    }
+    let value;
+    try {
+        value = document.toJS({ maxAliasCount: 0 });
+    }
+    catch (error) {
+        throw new CorpusError("$", "YAML conversion failed", { cause: error });
+    }
+    const root = requireRecord(value, "$", ["cases"]);
+    requireKeys(root, "$", ["cases"]);
+    if (!Array.isArray(root.cases)) {
+        throw new CorpusError("$.cases", "must be a sequence");
+    }
+    const cases = root.cases.map((candidate, index) => {
+        const path = `$.cases[${index}]`;
+        const row = requireRecord(candidate, path, ["name", "input", "expected", "classification", "provenance", "mutation"]);
+        requireKeys(row, path, ["name", "input", "expected", "classification", "provenance", "mutation"]);
+        const name = requireString(row.name, `${path}.name`);
+        const classification = row.classification;
+        if (!isClassification(classification)) {
+            throw new CorpusError(`${path}.classification`, `${JSON.stringify(classification)} is not one of must-pass/must-fail`);
+        }
+        const provenanceValue = requireRecord(row.provenance, `${path}.provenance`, ["source", "ref"]);
+        requireKeys(provenanceValue, `${path}.provenance`, ["source", "ref"]);
+        const sourceValue = provenanceValue.source;
+        if (!isProvenanceSource(sourceValue)) {
+            throw new CorpusError(`${path}.provenance.source`, `${JSON.stringify(sourceValue)} is not a known source`);
+        }
+        const provenance = {
+            source: sourceValue,
+            ref: requireString(provenanceValue.ref, `${path}.provenance.ref`),
+        };
+        const mutationValue = requireRecord(row.mutation, `${path}.mutation`, ["description"]);
+        requireKeys(mutationValue, `${path}.mutation`, ["description"]);
+        const mutation = {
+            description: requireString(mutationValue.description, `${path}.mutation.description`),
+        };
+        return {
+            name,
+            input: decoders.decodeInput(row.input, `${path}.input`),
+            expected: decoders.decodeExpected(row.expected, `${path}.expected`),
+            classification,
+            provenance,
+            mutation,
+        };
+    });
+    const corpus = { cases };
+    const err = validateCorpus(corpus);
+    if (err !== undefined) {
+        throw new CorpusError("$", err.message, { cause: err });
+    }
+    return corpus;
+}
+function requireRecord(value, path, allowedKeys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new CorpusError(path, "must be a mapping");
+    }
+    const record = Object.fromEntries(Object.entries(value));
+    for (const key of Object.keys(record)) {
+        if (!allowedKeys.includes(key)) {
+            throw new CorpusError(`${path}.${key}`, "unknown key");
+        }
+    }
+    return record;
+}
+function requireKeys(record, path, requiredKeys) {
+    for (const key of requiredKeys) {
+        if (!Object.hasOwn(record, key)) {
+            throw new CorpusError(`${path}.${key}`, "required key is missing");
+        }
+    }
+}
+function requireString(value, path) {
+    if (typeof value !== "string") {
+        throw new CorpusError(path, "must be a string");
+    }
+    return value;
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import canonical contract types from `@peasant-labs/schema`. */
+export * from "./index.js";

package/dist/types.js

@@ -0,0 +1,2 @@
+/** @deprecated Import canonical contract types from `@peasant-labs/schema`. */
+export * from "./index.js";

package/dist/village-api.d.ts

@@ -0,0 +1,4 @@
+import type { operations as GeneratedOperations, paths as GeneratedPaths } from "./internal/generated/village-api.js";
+export { VillageAPIVersion } from "./index.js";
+export type paths = GeneratedPaths;
+export type operations = GeneratedOperations;

package/dist/village-api.js

@@ -0,0 +1 @@
+export { VillageAPIVersion } from "./index.js";

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@peasant-labs/schema",
+  "version": "0.1.0-rc6",
+  "description": "Generated TypeScript contract bindings for the peasant-labs schema module",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./local-api": {
+      "types": "./dist/local-api.d.ts",
+      "default": "./dist/local-api.js"
+    },
+    "./village-api": {
+      "types": "./dist/village-api.d.ts",
+      "default": "./dist/village-api.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./testcase": {
+      "types": "./dist/testcase.d.ts",
+      "default": "./dist/testcase.js"
+    },
+    "./fixtures": {
+      "types": "./dist/fixtures.d.ts",
+      "default": "./dist/fixtures.js"
+    },
+    "./fixtures/quality": {
+      "types": "./dist/fixtures/quality.d.ts",
+      "default": "./dist/fixtures/quality.js"
+    },
+    "./fixtures/timeline": {
+      "types": "./dist/fixtures/timeline.d.ts",
+      "default": "./dist/fixtures/timeline.js"
+    }
+  },
+  "dependencies": {
+    "yaml": "2.9.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "0.99.0",
+    "@types/node": "24.13.3",
+    "openapi-typescript": "7.13.0",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate": "openapi-ts -f openapi-ts.config.mjs && node scripts/generate-contract-support.mjs",
+    "build": "node scripts/build.mjs",
+    "typecheck": "pnpm run build && tsc --noEmit -p tsconfig.test.json",
+    "test": "pnpm run build && node --test tests/*.test.mjs",
+    "package:audit": "pnpm run build && node scripts/package-audit.mjs",
+    "package:smoke": "pnpm run build && node scripts/package-smoke.mjs"
+  }
+}