@maroonedog/luq 2.3.0 → 2.3.1

package/dist/chain/create-chain-node.d.ts

@@ -9,6 +9,16 @@ export interface ChainBuildContext {
     readonly fieldPath: string;
     readonly declaredSiblingKeys: readonly string[];
     readonly config: ResolvedGlobalConfig;
+    /**
+     * True when something other than the slot already decides the runtime type.
+     *
+     * Set by the JSON Schema converter and nowhere else: there the DOCUMENT owns
+     * the type, its `type` keyword reports under the code `type`, and its
+     * vocabulary is wider than a slot's — `integer`, a list of types, and `null`
+     * as a type in its own right. A slot guard on that path would report a
+     * second issue for one bad value, under a code no schema asked for.
+     */
+    readonly typeDecidedElsewhere?: boolean;
 }
 /**
  * The parts a node cannot make for itself. `resolveArguments` is injected so

package/dist/chain/create-field-slots.js

@@ -5,6 +5,7 @@ exports.createFieldSlots = createFieldSlots;
 const type_erasure_1 = require("../core/type-erasure");
 const create_chain_node_1 = require("./create-chain-node");
 const collect_branch_rules_1 = require("./collect-branch-rules");
+const slot_type_guard_1 = require("./slot-type-guard");
 const SLOT_NAMES = Object.freeze([
     "string",
     "number",
@@ -25,9 +26,16 @@ function buildSlotSurface(bag, context) {
         resolveArguments: (plugin, declared) => (0, collect_branch_rules_1.resolvePluginArguments)(bag, context, buildSlotSurface, plugin, declared),
     };
     for (const slot of SLOT_NAMES) {
+        // The slot's own type check leads the chain, so it runs before any value
+        // rule. Those rules pass a wrong-typed value through on purpose; this is
+        // what reports it. See slot-type-guard.ts.
+        const guard = context.typeDecidedElsewhere === true
+            ? null
+            : (0, slot_type_guard_1.slotTypeGuard)(slot, context.config.defaultSeverity);
+        const seed = guard === null ? create_chain_node_1.EMPTY_RULES : Object.freeze([guard]);
         Object.defineProperty(surface, slot, {
             enumerable: true,
-            get: () => (0, create_chain_node_1.createChainNode)(wiring, slot, create_chain_node_1.EMPTY_RULES),
+            get: () => (0, create_chain_node_1.createChainNode)(wiring, slot, seed),
         });
     }
     return surface;

package/dist/chain/create-field-slots.mjs

@@ -1,6 +1,7 @@
 import { eraseChainSurface } from "../core/type-erasure.mjs";
 import { createChainNode, EMPTY_RULES, } from "./create-chain-node.mjs";
 import { resolvePluginArguments } from "./collect-branch-rules.mjs";
+import { slotTypeGuard } from "./slot-type-guard.mjs";
 const SLOT_NAMES = Object.freeze([
     "string",
     "number",
@@ -21,9 +22,16 @@ export function buildSlotSurface(bag, context) {
         resolveArguments: (plugin, declared) => resolvePluginArguments(bag, context, buildSlotSurface, plugin, declared),
     };
     for (const slot of SLOT_NAMES) {
+        // The slot's own type check leads the chain, so it runs before any value
+        // rule. Those rules pass a wrong-typed value through on purpose; this is
+        // what reports it. See slot-type-guard.ts.
+        const guard = context.typeDecidedElsewhere === true
+            ? null
+            : slotTypeGuard(slot, context.config.defaultSeverity);
+        const seed = guard === null ? EMPTY_RULES : Object.freeze([guard]);
         Object.defineProperty(surface, slot, {
             enumerable: true,
-            get: () => createChainNode(wiring, slot, EMPTY_RULES),
+            get: () => createChainNode(wiring, slot, seed),
         });
     }
     return surface;

package/dist/chain/slot-type-guard.d.ts

@@ -0,0 +1,10 @@
+import type { IssueSeverity, TypeName } from "../types";
+import type { Rule } from "../plugin-kit/compiled-rule";
+/**
+ * The rule `b.<slot>` starts its chain with, or null for a slot that claims
+ * nothing about the runtime type.
+ *
+ * The code is `<slot>Type` — `stringType`, `numberType` — which reads as the
+ * plugin name it would have had, matching every other code in the library.
+ */
+export declare function slotTypeGuard(slot: TypeName, severity: IssueSeverity): Rule | null;

package/dist/chain/slot-type-guard.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slotTypeGuard = slotTypeGuard;
+const types_1 = require("../types");
+const create_rule_1 = require("../plugin-kit/create-rule");
+const SLOT_TYPES = Object.freeze({
+    string: { accepts: types_1.isString, noun: "a string" },
+    number: { accepts: types_1.isNumber, noun: "a number" },
+    boolean: {
+        accepts: (value) => typeof value === "boolean",
+        noun: "a boolean",
+    },
+    date: { accepts: (value) => value instanceof Date, noun: "a Date" },
+    array: { accepts: types_1.isArray, noun: "an array" },
+    object: { accepts: types_1.isPlainObject, noun: "an object" },
+});
+/**
+ * The rule `b.<slot>` starts its chain with, or null for a slot that claims
+ * nothing about the runtime type.
+ *
+ * The code is `<slot>Type` — `stringType`, `numberType` — which reads as the
+ * plugin name it would have had, matching every other code in the library.
+ */
+function slotTypeGuard(slot, severity) {
+    const slotType = SLOT_TYPES[slot];
+    if (slotType === undefined)
+        return null;
+    return (0, create_rule_1.check)({
+        code: `${slot}Type`,
+        severity,
+        run: (value) => value === undefined || value === null || slotType.accepts(value)
+            ? types_1.PASS
+            : (0, types_1.fail)({ expected: slotType.noun, actual: value }),
+        describe: () => `Value must be ${slotType.noun}`,
+        buildMessageContext: () => ({}),
+    });
+}

package/dist/chain/slot-type-guard.mjs

@@ -0,0 +1,34 @@
+import { PASS, fail, isArray, isNumber, isPlainObject, isString, } from "../types/index.mjs";
+import { check } from "../plugin-kit/create-rule.mjs";
+const SLOT_TYPES = Object.freeze({
+    string: { accepts: isString, noun: "a string" },
+    number: { accepts: isNumber, noun: "a number" },
+    boolean: {
+        accepts: (value) => typeof value === "boolean",
+        noun: "a boolean",
+    },
+    date: { accepts: (value) => value instanceof Date, noun: "a Date" },
+    array: { accepts: isArray, noun: "an array" },
+    object: { accepts: isPlainObject, noun: "an object" },
+});
+/**
+ * The rule `b.<slot>` starts its chain with, or null for a slot that claims
+ * nothing about the runtime type.
+ *
+ * The code is `<slot>Type` — `stringType`, `numberType` — which reads as the
+ * plugin name it would have had, matching every other code in the library.
+ */
+export function slotTypeGuard(slot, severity) {
+    const slotType = SLOT_TYPES[slot];
+    if (slotType === undefined)
+        return null;
+    return check({
+        code: `${slot}Type`,
+        severity,
+        run: (value) => value === undefined || value === null || slotType.accepts(value)
+            ? PASS
+            : fail({ expected: slotType.noun, actual: value }),
+        describe: () => `Value must be ${slotType.noun}`,
+        buildMessageContext: () => ({}),
+    });
+}

package/dist/json-schema/create-structural-context.js

@@ -58,6 +58,9 @@ function createStructuralContext(seed, node, visitedRefs, scope = seed.scope) {
         fieldPath: seed.chain.fieldPath,
         declaredSiblingKeys: propertyKeysOf(node),
         config: seed.chain.config,
+        // The document owns the type here: `type` is a keyword with its own code
+        // and a wider vocabulary than a slot has. The slot must not add a second.
+        typeDecidedElsewhere: true,
     };
     /**
      * One descent: the node this schema really is, and the context inside it.

package/dist/json-schema/create-structural-context.mjs

@@ -54,6 +54,9 @@ export function createStructuralContext(seed, node, visitedRefs, scope = seed.sc
         fieldPath: seed.chain.fieldPath,
         declaredSiblingKeys: propertyKeysOf(node),
         config: seed.chain.config,
+        // The document owns the type here: `type` is a keyword with its own code
+        // and a wider vocabulary than a slot has. The slot must not add a second.
+        typeDecidedElsewhere: true,
     };
     /**
      * One descent: the node this schema really is, and the context inside it.

package/dist/plugins/object/object.d.ts

@@ -2,6 +2,12 @@ import type { Unchanged } from "../../plugin-kit/marker.types";
 export interface ObjectTypeContext {
     readonly actual: string;
 }
+/**
+ * @deprecated Entering `b.object` already checks this, under the code
+ * `objectType`. Drop the `.use(objectPlugin)` and the `.object()` call: the
+ * field goes on rejecting arrays, `null` and primitives, and only the issue's
+ * code and message change.
+ */
 export declare const objectPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"object", "object", readonly ["object"], {
     args: readonly [];
     out: Unchanged;

package/dist/plugins/object/object.js

@@ -4,14 +4,12 @@ exports.objectPlugin = void 0;
 const types_1 = require("../../types");
 const create_rule_1 = require("../../plugin-kit/create-rule");
 const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
-/** "array" is worth naming: it is the mistake this plugin exists to catch. */
-function describeType(value) {
-    if ((0, types_1.isArray)(value))
-        return "array";
-    if (value === null)
-        return "null";
-    return typeof value;
-}
+/**
+ * @deprecated Entering `b.object` already checks this, under the code
+ * `objectType`. Drop the `.use(objectPlugin)` and the `.object()` call: the
+ * field goes on rejecting arrays, `null` and primitives, and only the issue's
+ * code and message change.
+ */
 exports.objectPlugin = (0, plugin_definition_1.definePlugin)()({
     name: "object",
     method: "object",
@@ -20,9 +18,9 @@ exports.objectPlugin = (0, plugin_definition_1.definePlugin)()({
         code: ctx.code,
         messageFactory: ctx.messageFactory,
         severity: ctx.severity,
-        run: (value) => (0, types_1.isPlainObject)(value)
-            ? types_1.PASS
-            : (0, types_1.fail)({ expected: "object", actual: describeType(value) }),
+        run: () => types_1.PASS,
+        // Unreachable while run() never fails, and kept so the shape of the rule
+        // stays a rule rather than becoming a special case for the engine.
         describe: (detail) => `Value must be an object, but got ${String(detail.actual)}`,
         buildMessageContext: (detail) => ({ actual: String(detail.actual) }),
     }),

package/dist/plugins/object/object.mjs

@@ -1,14 +1,12 @@
-import { PASS, fail, isArray, isPlainObject } from "../../types/index.mjs";
+import { PASS } from "../../types/index.mjs";
 import { check } from "../../plugin-kit/create-rule.mjs";
 import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
-/** "array" is worth naming: it is the mistake this plugin exists to catch. */
-function describeType(value) {
-    if (isArray(value))
-        return "array";
-    if (value === null)
-        return "null";
-    return typeof value;
-}
+/**
+ * @deprecated Entering `b.object` already checks this, under the code
+ * `objectType`. Drop the `.use(objectPlugin)` and the `.object()` call: the
+ * field goes on rejecting arrays, `null` and primitives, and only the issue's
+ * code and message change.
+ */
 export const objectPlugin = /*#__PURE__*/ definePlugin()({
     name: "object",
     method: "object",
@@ -17,9 +15,9 @@ export const objectPlugin = /*#__PURE__*/ definePlugin()({
         code: ctx.code,
         messageFactory: ctx.messageFactory,
         severity: ctx.severity,
-        run: (value) => isPlainObject(value)
-            ? PASS
-            : fail({ expected: "object", actual: describeType(value) }),
+        run: () => PASS,
+        // Unreachable while run() never fails, and kept so the shape of the rule
+        // stays a rule rather than becoming a special case for the engine.
         describe: (detail) => `Value must be an object, but got ${String(detail.actual)}`,
         buildMessageContext: (detail) => ({ actual: String(detail.actual) }),
     }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",