rfphub-validate 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import { Opportunity } from '@rfp-hub/standard';
+export { Opportunity, SPEC_VERSION } from '@rfp-hub/standard';
+import { ValidateFunction, ErrorObject } from 'ajv/dist/2020.js';
+import { ErrorObject as ErrorObject$1 } from 'ajv';
+
+/**
+ * The advisory tier.
+ *
+ * Schema errors and advisory warnings are deliberately different things. The schema stays
+ * permissive — open key→value eligibility, free-text deadline labels, an open programModel
+ * list — because a closed enum built from one publisher's vocabulary would force every other
+ * publisher into it. That permissiveness is what makes the registries load-bearing: nothing
+ * would ever notice drift if the only signal were pass/fail.
+ *
+ * So: a document that raises warnings is still CONFORMANT. Warnings are quality signal,
+ * reported separately, and only `--strict` turns them into a failing exit code.
+ */
+interface Warning {
+    /** Stable machine-readable identifier for the check that fired. */
+    code: string;
+    /** JSON-Pointer-ish path to the offending value, in the same shape ajv uses. */
+    instancePath: string;
+    /** One-line human-readable explanation, naming the offending value. */
+    message: string;
+}
+interface Check {
+    code: string;
+    /**
+     * Verb phrase completing "N of M entries …", for count-phrased text output.
+     * e.g. "use an unregistered eligibility key".
+     */
+    entryPhrase: string;
+    run(entry: Record<string, unknown>): Warning[];
+}
+
+/**
+ * The advisory checks, in report order. Each one covers something the schema deliberately
+ * leaves open — see ./types.ts for why the two tiers are separate.
+ */
+declare const checks: readonly Check[];
+/** Run every advisory check against one entry. Never throws; non-objects yield no warnings. */
+declare function runChecks(data: unknown): Warning[];
+/** The count-phrase for a code, for "N of M entries <phrase>" output. */
+declare function entryPhrase(code: string): string;
+
+interface ValidationResult {
+    /** Schema conformance. Advisory warnings never affect this. */
+    valid: boolean;
+    /** Hard schema violations. A document with any of these is not conformant. */
+    errors: ErrorObject[];
+    /**
+     * Advisory findings from the check tier — quality signal about things the schema
+     * deliberately leaves open (unregistered vocabulary values, cross-object rules JSON Schema
+     * cannot express). A conformant document may still carry warnings.
+     */
+    warnings: Warning[];
+}
+interface ValidateOptions {
+    /** Spec version to validate against. Only the bundled version is supported. */
+    spec?: string;
+    /** Inject a pre-compiled validator (e.g. to validate against a custom schema). */
+    validator?: ValidateFunction;
+    /** Run the advisory check tier. Default true. */
+    checks?: boolean;
+}
+/**
+ * Compile an ajv validator. Uses the SAME configuration the standard is authored
+ * against: draft 2020-12, strict mode, `strictRequired` off (so the conditional
+ * type-block pattern — `opportunity[opportunity.fundingType]` — is permitted).
+ */
+declare function createValidator(schema?: Record<string, unknown>): ValidateFunction;
+/** Validate arbitrary data against the RFP Hub Standard, plus the advisory check tier. */
+declare function validateOpportunity(data: unknown, opts?: ValidateOptions): ValidationResult;
+/** Assert that data is a valid Opportunity, narrowing its type. Throws otherwise. */
+declare function assertOpportunity(data: unknown, opts?: ValidateOptions): asserts data is Opportunity;
+
+/** Render a single ajv error as a concise, human-readable line naming the rule that failed. */
+declare function humanizeError(e: ErrorObject$1, data?: unknown): string;
+/**
+ * Render a list of ajv errors as human-readable lines.
+ *
+ * Pass the validated instance when you have it: it lets the one-block-per-fundingType rule name
+ * the block that should not be there, instead of ajv's bare "must NOT be valid".
+ */
+declare function humanizeErrors(errors: readonly ErrorObject$1[], data?: unknown): string[];
+
+export { type Check, type ValidateOptions, type ValidationResult, type Warning, assertOpportunity, checks, createValidator, entryPhrase, humanizeError, humanizeErrors, runChecks, validateOpportunity };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { SPEC_VERSION, assertOpportunity, checks, createValidator, entryPhrase, humanizeError, humanizeErrors, runChecks, validateOpportunity } from './chunk-QO7M2D7A.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "rfphub-validate",
+  "version": "0.1.0",
+  "description": "Validate funding opportunities against the RFP Hub Standard (CLI + typed library).",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "rfphub-validate": "./dist/cli.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "@the-rfp-hub/standard": "1.0.0"
+  },
+  "keywords": [
+    "rfp-hub",
+    "funding",
+    "grants",
+    "json-schema",
+    "validation",
+    "ethereum",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/The-RFP-Hub/the-rfp-hub",
+    "directory": "packages/validate"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}