carrick 0.3.112 → 0.3.113

package/sidecar/dist/src/type-inferrer.d.ts

@@ -944,6 +944,180 @@ export declare class TypeInferrer {
      * return statements are.
      */
     private recoverPayloadFromResponseExpressions;
+    /** How one payload node reads: its stated annotation, else its resolved type. */
+    private payloadCandidateOf;
+    /** A payload whose contract a type node in the source states. */
+    private statedPayloadCandidate;
+    /**
+     * Join the payloads of several response branches into one contract, as
+     * several return statements are joined: an empty object drops beside a
+     * branch with members, equal texts dedupe, and the rest is a union.
+     */
+    private joinPayloadCandidates;
+    /**
+     * True when a handler's awaited return, or a member of its union, is a
+     * serialised-body envelope: an object with a numeric `statusCode` or
+     * `status` member and a `body` member typed `string`. Either member may be
+     * optional, as a platform's result type declares them.
+     *
+     * HTTP vocabulary only, the class `RESPONSE_INIT_MEMBER_NAMES` is. A `body`
+     * typed as an object is not an envelope: a runtime that serialises the
+     * handler's return value sends that object as the payload, so the shape is
+     * ambiguous and keeps the ordinary reading.
+     */
+    private typeIsSerialisedBodyEnvelope;
+    /** A member's type with `undefined` and `null` removed, or `undefined` if absent. */
+    private envelopeMemberType;
+    /**
+     * True when a handler's return is a serialised-body envelope AND the source
+     * shows the body is serialised, so the envelope reading applies:
+     *  - a returned branch builds an envelope whose `body` is `JSON.stringify`
+     *    of a value, inline, through a `const`, or in a builder the reading can
+     *    follow (`branchShowsSerialisation`); or
+     *  - the envelope type is declared outside the repository (a platform's
+     *    result type) with every member optional. Nothing else returns such a
+     *    type, so a value of it returned as-is is still transport. The repo's
+     *    own all-optional types (`Partial<Article>`) engage only on evidence.
+     *
+     * A domain object that merely has `status` and `body` members (an article,
+     * a message) shows neither and keeps the ordinary reading.
+     */
+    private serialisedBodyEnvelopeEngages;
+    /**
+     * True when a returned branch builds an envelope from a serialised value:
+     * a literal whose `body` is `JSON.stringify(...)`, a call to a builder the
+     * reading can follow, or a call handing on one such envelope.
+     */
+    private branchShowsSerialisation;
+    /**
+     * The arguments a call could hand back as its result: every argument but
+     * an object literal, which is the call's input (`create({ body:
+     * JSON.stringify(doc) })` stores a document, it does not respond with it),
+     * and but a function, whose returns are read as the call's callbacks.
+     */
+    private handedOnArguments;
+    /**
+     * The returned branches of an envelope handler: each returned expression,
+     * conditional sides split. A returned call whose callbacks return values
+     * (`settle().then(ok, fail)`) is carried by those returns, plus every
+     * envelope it is handed directly (`withFallback(() => a, b)` can answer
+     * `b`); a call whose callbacks return nothing stays a branch of its own.
+     */
+    private envelopeBranches;
+    /**
+     * The `function_return` answer for a handler that returns a serialised-body
+     * envelope: the union of the values its success branches serialised.
+     *
+     * Each returned branch is read by `readEnvelopeBranch`. Error and redirect
+     * branches contribute nothing (carrick#1161). If any branch cannot be read,
+     * the answer is `unknown` with the decided reason `serialised_body_unread`
+     * and one sentence per cause: the branches that did read are part of the
+     * contract, and neither the envelope nor its `string` body is any of it.
+     */
+    private inferSerialisedBodyEnvelope;
+    /** An `unknown` answer the inferrer decided, carrying its reason at the root. */
+    private decidedAbstain;
+    /**
+     * What one returned branch of an envelope handler serialised:
+     *  - an envelope object literal: the argument of the `JSON.stringify` that
+     *    produced its `body`, inline or through a `const` in the same function;
+     *    its status member decides the branch;
+     *  - a call to a response builder this repository declares
+     *    (`envelopeBuilderOf`): the argument the builder serialises; the
+     *    argument or literal its status member takes decides the branch;
+     *  - any other call handing on exactly one envelope argument (never an
+     *    object literal, which is the call's input): that
+     *    envelope is read in its place. Its own stated status decides the
+     *    branch; only when it states none does a status the outer call's
+     *    arguments state decide (`log(ctx, 503, "code", prebuilt)`).
+     * Anything else, and a payload holding `any` or `unknown`, is unread, with
+     * its cause.
+     */
+    private readEnvelopeBranch;
+    /** The status a builder call sends: its status argument, or the builder's literal. */
+    private builderCallStatus;
+    /**
+     * The status an envelope expression states itself: a literal's status
+     * member, or what a followable builder call sends. `'undecided'` for
+     * anything else (a variable holding an envelope states nothing here).
+     */
+    private envelopeOwnStatus;
+    /** The status an envelope literal's `statusCode` or `status` member states. */
+    private envelopeLiteralStatus;
+    /** The status a value states, classified as a send's status argument is. */
+    private statusOfValue;
+    /**
+     * The value node an object literal gives a member: a property assignment's
+     * initializer, or a shorthand's own name.
+     */
+    private envelopeMemberValue;
+    /**
+     * The value an envelope literal's `body` serialises: the argument of a
+     * `JSON.stringify` written there, or written as the initializer of a
+     * `const` that `scope` declares and `body` names. `undefined` when `body`
+     * is built any other way.
+     */
+    private serialisedBodyArgument;
+    /**
+     * The initializer of the `const` an identifier (or a shorthand member's
+     * name) refers to, when `scope` itself declares it.
+     */
+    private constInitializerInScope;
+    /**
+     * The symbol of the value a node names: a shorthand member's value symbol
+     * (its own symbol is the property), else the identifier's symbol.
+     */
+    private valueSymbolOf;
+    /** The index of the `params` entry a node names, or `undefined`. */
+    private parameterIndexOf;
+    /**
+     * How a call's callee builds an envelope, when the callee is a function this
+     * repository declares (not lib, not an installed package) and every return
+     * it makes is an envelope literal:
+     *  - returns whose status member is a literal 4xx or 5xx are its failure
+     *    path and are ignored; a builder with nothing else is `'failure'`, so a
+     *    call to it is an error branch;
+     *  - every other return must serialise the same parameter into `body` and
+     *    take its status from the same parameter, or state the same literal
+     *    success or redirect status.
+     * `undefined` when the callee is anything else.
+     */
+    private envelopeBuilderOf;
+    /**
+     * The single function a callee symbol declares with a body: a function
+     * declaration, or a variable initialised with an arrow or function
+     * expression.
+     */
+    private builderFunctionOf;
+    /**
+     * The payload a builder call serialises. The source states it, and the
+     * answer is explicit, when the argument carries `satisfies`/`as`, when the
+     * builder's parameter is one of its type parameters and the call passes
+     * type arguments (`reply<AddNoteResult>(201, x)`), or when the parameter is
+     * declared with a type that says something. Otherwise the argument's own
+     * type is read.
+     */
+    private builderPayloadCandidate;
+    /**
+     * True when a declared parameter type does not say what is sent: a top
+     * type, the `object` keyword, an object type that names no member (`{}`,
+     * `Record<string, unknown>`), a union that admits both primitives and
+     * objects (a JSON-value type such as `string | number | Json[] | { [k:
+     * string]: Json }`), or a type that mentions a type parameter. A builder
+     * that takes "any value" states nothing about the payload a call hands it,
+     * so the argument's own type is read instead.
+     */
+    private typeNodeStatesNothing;
+    /** A serialised value's candidate, unread when it holds a top type. */
+    private envelopePayloadCandidate;
+    /**
+     * A payload candidate, or unread when its printed type is or holds `any`
+     * or `unknown` anywhere (`{ [x: string]: any }`, `{ data: any }`). A
+     * contract with a hole in it is not published on this path: the capture
+     * would refuse the text and re-read the line, which can publish the
+     * envelope.
+     */
+    private checkedEnvelopeCandidate;
     /**
      * The request field each member of a joined union answers
      * (`response-modes.ts`). Case texts are joined by the published union's