carrick 0.3.131 → 0.3.133

package/sidecar/dist/src/type-inferrer.js

@@ -32,6 +32,7 @@ import { attributedDeclaration, installedPackageOf } from './declaration-attribu
 import { endLineOf, startLineOf } from './line-index.js';
 import { elapsedMs, inferTiming, phaseClock, timedPhase } from './infer-timing.js';
 import { StatedParams } from './stated-params.js';
+import { bindingToleratesAbsence, handlerToleratesAbsentBody } from './absent-body.js';
 import { classifyStatusCodes, constituents, httpStatus, statesNoBody, statesNoShape, statusKeyCode, statusTableOf, successEntries, } from './capture/index.js';
 import { addedDiagnostics, applyInsertions, fileDiagnostics, literalInsertions, mapBack, mapForward, normalise, pathOf, } from './unwidened.js';
 import { expandTypeStructural, jsonWireType, } from './type-structural-expander.js';
@@ -883,7 +884,7 @@ export class TypeInferrer {
             case 'expression':
                 return this.inferExpression(sourceFile, request, extractionConfig);
             case 'request_body':
-                return this.inferRequestBody(sourceFile, request, extractionConfig);
+                return this.withAbsentBodyMark(sourceFile, request, this.inferRequestBody(sourceFile, request, extractionConfig));
             case 'signature_return':
                 return this.inferSignatureReturn(sourceFile, request);
             case 'function_param':
@@ -1168,7 +1169,51 @@ export class TypeInferrer {
         // scanner re-aims the explicit bundle at the root symbol instead of
         // pasting this string, so the alias's definition stays self-contained.
         const anchor = this.unwrapArrayLevels(this.unwrapPromiseType(paramType));
-        return this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(target.node), undefined, this.primaryTypeSymbol(anchor.element), anchor.depth, this.primaryTypeSymbolSource(anchor.element));
+        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(target.node), undefined, this.primaryTypeSymbol(anchor.element), anchor.depth, this.primaryTypeSymbolSource(anchor.element));
+        // carrick#2814: a subscriber that defaults its payload, or reads it only
+        // in ways `undefined` survives, still works when none is sent.
+        const binding = Node.isBindingElement(target.node) ? target.node : target.param;
+        if (bindingToleratesAbsence(binding)) {
+            inferred.absent_body_tolerated = true;
+        }
+        return inferred;
+    }
+    /**
+     * carrick#2814: mark a route's request body as one its handler tolerates
+     * going unsent, when the handler is in reach and every read of the body
+     * survives `undefined` (`absent-body.ts`). The check then lets a caller that
+     * may send nothing call a route whose body type has no required member.
+     *
+     * No mark where the handler cannot be found, where a validator the
+     * registration declares reads the body first (a schema, or another function
+     * handed in beside the handler), or where the handler reads no body it can
+     * see: the check keeps the reading it had.
+     */
+    withAbsentBodyMark(sourceFile, request, inferred) {
+        if (!inferred)
+            return inferred;
+        const atLine = this.registrationAtLine(sourceFile, request.line_number);
+        let registration = atLine?.registration;
+        let handler = atLine?.handler;
+        if (!handler) {
+            const located = this.resolveTargetNode(sourceFile, request);
+            handler = located ? this.registrationHandlerAt(located) : undefined;
+            registration = handler && located ? this.unwrapExpressionNode(located) : undefined;
+        }
+        handler ??= this.exportedFunctionOpeningOn(sourceFile, request.line_number);
+        if (!handler)
+            return inferred;
+        if (registration) {
+            if (this.routeSchemaContract(registration, 'body') ?? this.validatedBodyContract(registration)) {
+                return inferred;
+            }
+            if (this.statedParams.handsInAnotherFunction(registration, handler))
+                return inferred;
+        }
+        if (handlerToleratesAbsentBody(handler)) {
+            inferred.absent_body_tolerated = true;
+        }
+        return inferred;
     }
     /**
      * Resolve a `function_param` locator against a function's parameter list.

package/sidecar/dist/src/types.d.ts

@@ -1228,6 +1228,14 @@ export interface InferredType {
      * Absent when the body is not a raw-text read.
      */
     raw_text_read?: true;
+    /**
+     * carrick#2814, a route's request body or a subscriber's payload: the
+     * handler is in reach and works when nothing is sent, because it defaults
+     * the body or reads it only in ways `undefined` survives (`?.`, `?? {}`).
+     * Absent when the handler dereferences it, reads it through something not
+     * seen, or was not found.
+     */
+    absent_body_tolerated?: true;
     /**
      * carrick#2054, a response joined from two or more success bodies: the
      * request fields whose values pick among them (`reads`), and, for one