@pagefront/lint-commerce 0.10.0 → 0.12.0

package/dist/validate-and-lint.d.ts

@@ -5,9 +5,7 @@
  * boundary: callers see `SchemaError`, never Ajv's own error type.
  */
 import type { LintOptions, Report } from "@pagefront/lint-core";
-import type { SheetLine, SheetType } from "./sheet-type.js";
-/** The Layer 1 validator for a sheet type on a line. */
-export declare function validatorFor(sheetType: SheetType, line: SheetLine): import("ajv").ValidateFunction<unknown>;
+import type { SheetType } from "./sheet-type.js";
 /**
  * One Layer 1 (JSON Schema) validation failure, in a shape this
  * package owns. `instancePath` is a JSON Pointer to the offending
@@ -27,25 +25,34 @@ export type ValidateAndLintResult = {
     report: Report;
 };
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * product JSON Schema (Layer 1), and — only if it passes — lint it
- * against the commerce rule catalogue (Layer 2). The engine assumes a
- * schema-valid Sheet, so a failing document never reaches the
- * catalogue; Layer 1 success is also what makes the internal cast to
- * `Sheet` sound (the schema requires the envelope fields).
+ * Layer 1 for one document: validate it against the frozen schema the
+ * release it declares resolves to (see schema-registry.ts); a legacy
+ * sheet is validated against the schema its `$schema` names. Returns
+ * the errors, empty when the document is valid. A `release` the
+ * manifest does not list is a Layer 1 failure of its own, reported at
+ * `/release` with the keyword `release`; a legacy `$schema` naming no
+ * bundled schema is reported at `/$schema`. In neither case is the
+ * document validated against some other version.
+ */
+export declare function schemaErrorsFor(input: unknown, sheetType?: SheetType): SchemaError[];
+/**
+ * Validate a parsed-but-unvalidated document against a bundled JSON
+ * Schema (Layer 1), and — only if it passes — lint it against the
+ * commerce rule catalogue (Layer 2). The engine assumes a schema-valid
+ * Sheet, so a failing document never reaches the catalogue; Layer 1
+ * success is also what makes the internal cast to `Sheet` sound (the
+ * schema requires the envelope fields).
  *
- * Two lines are validated (see sheet-type.ts): a sheet carrying
- * `release` validates against the current sheet-spec schema for its
- * type, and a legacy sheet carrying `format_version` validates against
- * the frozen legacy schema (format 0.9). A legacy sheet declaring some
- * other `format_version` failing Layer 1 is the intended behavior:
- * there is no separate "unsupported version" outcome.
+ * The package bundles every schema ever published, on both lines: the
+ * sheet-spec versions of each release, and the legacy draft line's
+ * format 0.9 schemas. A sheet is judged by the release it declares: the
+ * schema is the one that release bundles for the sheet's type, and a
+ * `$schema` that names another one is a Layer 2 finding (PDP-E-002,
+ * ORG-E-003). A release the manifest does not list fails Layer 1 with a
+ * single error saying so.
  *
- * Dispatches by page type (see sheet-type.ts): product sheets validate
- * against the product schema and lint with the product catalogue;
- * Commerce Organization Sheets validate against the organization
- * schema and lint with the organization catalogue. Detection reads the
- * envelope `$schema` first, falling back to data-block shape, so a
- * document of either type routes to its own schema's errors.
+ * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
+ * lint with the product catalogue, Commerce Organization Sheets with
+ * the organization catalogue.
  */
 export declare function validateAndLint(input: unknown, options?: LintOptions): ValidateAndLintResult;

package/dist/validate-and-lint.js

@@ -1,49 +1,73 @@
 import { lintSheet } from "./lint-sheet.js";
-import { detectSheetLine, detectSheetType } from "./sheet-type.js";
-import { validateProduct, validateOrganization, validateLegacyProduct, validateLegacyOrganization, } from "./schema-validators.js";
-/** The Layer 1 validator for a sheet type on a line. */
-export function validatorFor(sheetType, line) {
-    if (line === "legacy") {
-        return sheetType === "organization" ? validateLegacyOrganization : validateLegacyProduct;
-    }
-    return sheetType === "organization" ? validateOrganization : validateProduct;
-}
+import { resolveSchema } from "./schema-registry.js";
+import { VALIDATORS } from "./schema-validators.js";
 // The validators are compiled ahead of time (see schema-validators.d.ts):
 // nothing here generates code at load time, so the pipeline runs where
 // eval is unavailable, and consumers calling it in a loop pay no
 // compilation cost.
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * product JSON Schema (Layer 1), and — only if it passes — lint it
- * against the commerce rule catalogue (Layer 2). The engine assumes a
- * schema-valid Sheet, so a failing document never reaches the
- * catalogue; Layer 1 success is also what makes the internal cast to
- * `Sheet` sound (the schema requires the envelope fields).
+ * Layer 1 for one document: validate it against the frozen schema the
+ * release it declares resolves to (see schema-registry.ts); a legacy
+ * sheet is validated against the schema its `$schema` names. Returns
+ * the errors, empty when the document is valid. A `release` the
+ * manifest does not list is a Layer 1 failure of its own, reported at
+ * `/release` with the keyword `release`; a legacy `$schema` naming no
+ * bundled schema is reported at `/$schema`. In neither case is the
+ * document validated against some other version.
+ */
+export function schemaErrorsFor(input, sheetType) {
+    const envelope = (typeof input === "object" && input !== null ? input : {});
+    const resolution = resolveSchema(envelope, sheetType);
+    if (resolution.kind === "unknown-release") {
+        return [
+            {
+                instancePath: "/release",
+                message: `names no release this linter knows: ${resolution.declared}`,
+                keyword: "release",
+            },
+        ];
+    }
+    if (resolution.kind === "unknown-schema") {
+        return [
+            {
+                instancePath: "/$schema",
+                message: `names no schema this linter bundles: ${resolution.declared}`,
+                keyword: "$schema",
+            },
+        ];
+    }
+    const validate = VALIDATORS[resolution.id];
+    if (validate(input))
+        return [];
+    return (validate.errors ?? []).map((error) => ({
+        instancePath: error.instancePath,
+        message: error.message ?? "invalid",
+        keyword: error.keyword,
+    }));
+}
+/**
+ * Validate a parsed-but-unvalidated document against a bundled JSON
+ * Schema (Layer 1), and — only if it passes — lint it against the
+ * commerce rule catalogue (Layer 2). The engine assumes a schema-valid
+ * Sheet, so a failing document never reaches the catalogue; Layer 1
+ * success is also what makes the internal cast to `Sheet` sound (the
+ * schema requires the envelope fields).
  *
- * Two lines are validated (see sheet-type.ts): a sheet carrying
- * `release` validates against the current sheet-spec schema for its
- * type, and a legacy sheet carrying `format_version` validates against
- * the frozen legacy schema (format 0.9). A legacy sheet declaring some
- * other `format_version` failing Layer 1 is the intended behavior:
- * there is no separate "unsupported version" outcome.
+ * The package bundles every schema ever published, on both lines: the
+ * sheet-spec versions of each release, and the legacy draft line's
+ * format 0.9 schemas. A sheet is judged by the release it declares: the
+ * schema is the one that release bundles for the sheet's type, and a
+ * `$schema` that names another one is a Layer 2 finding (PDP-E-002,
+ * ORG-E-003). A release the manifest does not list fails Layer 1 with a
+ * single error saying so.
  *
- * Dispatches by page type (see sheet-type.ts): product sheets validate
- * against the product schema and lint with the product catalogue;
- * Commerce Organization Sheets validate against the organization
- * schema and lint with the organization catalogue. Detection reads the
- * envelope `$schema` first, falling back to data-block shape, so a
- * document of either type routes to its own schema's errors.
+ * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
+ * lint with the product catalogue, Commerce Organization Sheets with
+ * the organization catalogue.
  */
 export function validateAndLint(input, options) {
-    const envelope = (typeof input === "object" && input !== null ? input : {});
-    const validate = validatorFor(detectSheetType(envelope), detectSheetLine(envelope));
-    if (!validate(input)) {
-        const schemaErrors = (validate.errors ?? []).map((error) => ({
-            instancePath: error.instancePath,
-            message: error.message ?? "invalid",
-            keyword: error.keyword,
-        }));
+    const schemaErrors = schemaErrorsFor(input);
+    if (schemaErrors.length > 0)
         return { layer: 1, schemaErrors };
-    }
     return { layer: 2, report: lintSheet(input, options) };
 }

package/dist/validate-organization.d.ts

@@ -18,10 +18,10 @@ export type ValidateOrganizationResult = {
     schemaErrors: SchemaError[];
 };
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * Commerce Organization Sheet JSON Schema for its line: the current
- * sheet-spec schema for a sheet carrying `release`, the frozen legacy
- * schema for one carrying `format_version`, exactly as in the product
- * pipeline.
+ * Validate a parsed-but-unvalidated document against a bundled
+ * Commerce Organization Sheet JSON Schema: the one its `$schema` names,
+ * or, when it declares none, the organization schema for its line (the
+ * sheet-spec version its `release` bundles, or the legacy format 0.9
+ * schema for a sheet carrying `format_version`).
  */
 export declare function validateOrganizationSheet(input: unknown): ValidateOrganizationResult;

package/dist/validate-organization.js

@@ -1,22 +1,12 @@
-import { detectSheetLine } from "./sheet-type.js";
-import { validatorFor } from "./validate-and-lint.js";
+import { schemaErrorsFor } from "./validate-and-lint.js";
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * Commerce Organization Sheet JSON Schema for its line: the current
- * sheet-spec schema for a sheet carrying `release`, the frozen legacy
- * schema for one carrying `format_version`, exactly as in the product
- * pipeline.
+ * Validate a parsed-but-unvalidated document against a bundled
+ * Commerce Organization Sheet JSON Schema: the one its `$schema` names,
+ * or, when it declares none, the organization schema for its line (the
+ * sheet-spec version its `release` bundles, or the legacy format 0.9
+ * schema for a sheet carrying `format_version`).
  */
 export function validateOrganizationSheet(input) {
-    const envelope = (typeof input === "object" && input !== null ? input : {});
-    const validate = validatorFor("organization", detectSheetLine(envelope));
-    if (!validate(input)) {
-        const schemaErrors = (validate.errors ?? []).map((error) => ({
-            instancePath: error.instancePath,
-            message: error.message ?? "invalid",
-            keyword: error.keyword,
-        }));
-        return { valid: false, schemaErrors };
-    }
-    return { valid: true };
+    const schemaErrors = schemaErrorsFor(input, "organization");
+    return schemaErrors.length > 0 ? { valid: false, schemaErrors } : { valid: true };
 }

package/dist/version.d.ts

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export declare const PACKAGE_VERSION = "0.10.0";
+export declare const PACKAGE_VERSION = "0.12.0";

package/dist/version.js

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export const PACKAGE_VERSION = "0.10.0";
+export const PACKAGE_VERSION = "0.12.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagefront/lint-commerce",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Pagefront commerce linter: the commerce rule catalogue and CLI, on the @pagefront/lint-core engine.",
   "license": "Apache-2.0",
   "repository": {
@@ -34,12 +34,12 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc && node scripts/compile-validators.mjs",
+    "build": "node scripts/bundle-schemas.mjs && tsc && node scripts/compile-validators.mjs",
     "test": "npm run build && node --test test/*.test.mjs",
     "prepublishOnly": "npm test"
   },
   "dependencies": {
-    "@pagefront/lint-core": "^0.2.0",
+    "@pagefront/lint-core": "^0.3.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },

package/dist/legacy-schemas.d.ts

@@ -1,9 +0,0 @@
-/**
- * The legacy draft line's JSON Schemas (commerce/spec/legacy/*.v0.9.json),
- * bundled verbatim so sheets carrying `format_version` keep validating
- * against the schemas their `$schema` URLs name. The files are frozen:
- * the schema drift test (test/schema.test.mjs) fails if a bundled copy
- * and its source diverge.
- */
-export declare const LEGACY_PRODUCT_SCHEMA: Record<string, unknown>;
-export declare const LEGACY_ORGANIZATION_SCHEMA: Record<string, unknown>;