carrick 0.3.127 → 0.3.129

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

@@ -200,6 +200,31 @@ export interface InferRequest extends BaseRequest {
      * how each relates to what it read (`InferredType.model_symbol_relation`).
      */
     model_symbols?: ModelSymbol[];
+    /**
+     * carrick#2674: the service's settled server-framework claims. Each is
+     * verified again in the service's program, and the members the verified
+     * ones name are what a route handler's own parameters are read through:
+     * the reply a `send` op's payload slot states, and the request body a
+     * receive op's `request.body` path names. Absent or empty, nothing is read.
+     */
+    server_claims?: ServerClaims;
+}
+/** The server-framework claims an `infer` request reads handler parameters through (carrick#2674). */
+export interface ServerClaims {
+    /** The service root module resolution starts from, as on `verify_library_claims`. */
+    from_dir: string;
+    scan_root?: string;
+    /**
+     * As the client sends them: each is read through the library-check schema
+     * on its own, and a refused one is dropped (`settledServerChecks`).
+     */
+    checks: unknown[];
+    /**
+     * Per package specifier, the type-only packages the store says its surface
+     * re-exports (the store's `type_packages`): a reply member declared in one
+     * of them is the package's own.
+     */
+    type_packages?: Record<string, string[]>;
 }
 /** A type the model named for the row `alias` is for (carrick#2111). */
 export interface ModelSymbol {
@@ -423,10 +448,21 @@ export interface ClaimSlot {
 }
 /**
  * A name the call does not carry: the one the maker's `name` slot bound to
- * the instance (`maker`), or the one the scope member bound (`scope`).
+ * the instance (`maker`), the one the scope member bound (`scope`), or the
+ * key path the op's value sits under in a `collects` object (`key`, #2474
+ * R6a).
  */
 export interface BoundName {
-    bound: 'maker' | 'scope';
+    bound: 'maker' | 'scope' | 'key';
+}
+/**
+ * Where a router member takes its procedures (#2474 R6a, contract amendment
+ * 3 on carrick#2434): an object at argument `arg` (or its property `key`)
+ * whose property values are procedures or nested collections, each named by
+ * its key; nested keys join with `join`.
+ */
+export interface Collects extends ClaimSlot {
+    join: string;
 }
 /**
  * The function or client a call runs (label structure v2, carrick#2434): a
@@ -459,6 +495,8 @@ export interface RequestAt {
     path?: string[];
     url?: string[];
     method?: string[];
+    /** The member that holds the request's body (carrick#2674). */
+    body?: string[];
 }
 /** The closed role list; the role alone picks the checks a claim needs. */
 export type LibraryRole = 'http_client' | 'graphql_client' | 'broker' | 'in_process_bus' | 'socket' | 'server_framework' | 'none';
@@ -509,7 +547,8 @@ export type LibraryClaim = {
     /** A member that returns a receiver bound to a name (a channel, room or queue). */
     kind: 'scope';
     member: string;
-    name: ClaimSlot;
+    /** Exactly one of `name` and `collects` (#2474 R6a). */
+    name?: ClaimSlot;
     path?: string[];
     on?: ClaimOn;
     of?: string;
@@ -525,6 +564,8 @@ export type LibraryClaim = {
     yields?: Yields;
     /** Route fields (#2474 R0): the instance handed here is served under `name`. */
     mounts?: ClaimSlot;
+    /** Procedure routers (#2474 R6a): the member collects procedures by key and returns the collection. */
+    collects?: Collects;
 } | {
     kind: 'op';
     op: LibraryOp;
@@ -967,8 +1008,40 @@ export interface SurfaceMember {
     name: string;
     /** Declared by the receiver's home packages (not only inherited from another package). */
     own: boolean;
+    /**
+     * The members the parameters of a function this member takes declare
+     * (carrick#2674): what a receive op's `request` field names its member
+     * paths in. Under a cap of their own, apart from the main one.
+     */
+    handlers?: SurfaceHandler[];
     signatures: SurfaceSignature[];
 }
+/**
+ * A function a member takes at argument `arg`, or at `key` of the options
+ * object there, and the parameters of it that declare members. A handler the
+ * member's overloads state alike is listed once, from the first overload.
+ */
+export interface SurfaceHandler {
+    arg: number;
+    key?: string;
+    params: SurfaceHandlerParam[];
+}
+/** One parameter of a handler, with the members its type declares (none: not listed). */
+export interface SurfaceHandlerParam {
+    param: number;
+    name: string;
+    /** The parameter's type as the declarations print it, truncated. */
+    type: string;
+    members: SurfaceHandlerMember[];
+}
+/** A member of a handler's parameter, by path from the parameter, to two levels. */
+export interface SurfaceHandlerMember {
+    path: string[];
+    type: string;
+    optional: boolean;
+    /** Callable (a method or a function-typed property). */
+    function: boolean;
+}
 /** One receiver the verifier can read claims on, in its receiver grammar, with what it declares. */
 export interface SurfaceReceiver {
     receiver: string;

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

@@ -1,5 +1,6 @@
 /**
- * The unwidened reading of a producer's response (carrick#1516).
+ * The unwidened reading of a producer's response (carrick#1516), and of a
+ * consumer's request body (carrick#2011).
  *
  * A handler that returns `{ scope: row.parentId ? 'specific' : 'all' }` sends
  * one of two strings, but its inferred return type says `scope: string`:
@@ -78,8 +79,16 @@ export declare function pathOf(read: Node): Node[];
 /**
  * The insertions that mark every literal inside `fn` whose widening the
  * reading drops. Positions are original-file positions.
+ *
+ * `sent` is given for a request body a consumer sends (carrick#2011), and is
+ * the expression the inference read. A literal handed to any other call is
+ * then left alone: keeping `useState('open')` narrow narrows the state's
+ * setter too, and code elsewhere that calls the setter with another value
+ * sits in a file the reading's guard never checks. A response's reading
+ * passes no `sent`: what the handler hands its callees is part of what it
+ * returns.
  */
-export declare function literalInsertions(fn: Node): Insertion[];
+export declare function literalInsertions(fn: Node, sent?: Node): Insertion[];
 /** Deduplicated, in text order (a closer before an opener at one position). */
 export declare function normalise(insertions: Insertion[]): Insertion[];
 export declare function applyInsertions(text: string, insertions: Insertion[]): string;

package/sidecar/dist/src/unwidened.js

@@ -1,5 +1,6 @@
 /**
- * The unwidened reading of a producer's response (carrick#1516).
+ * The unwidened reading of a producer's response (carrick#1516), and of a
+ * consumer's request body (carrick#2011).
  *
  * A handler that returns `{ scope: row.parentId ? 'specific' : 'all' }` sends
  * one of two strings, but its inferred return type says `scope: string`:
@@ -111,15 +112,23 @@ function hasDeclaredReturn(node) {
 /**
  * The insertions that mark every literal inside `fn` whose widening the
  * reading drops. Positions are original-file positions.
+ *
+ * `sent` is given for a request body a consumer sends (carrick#2011), and is
+ * the expression the inference read. A literal handed to any other call is
+ * then left alone: keeping `useState('open')` narrow narrows the state's
+ * setter too, and code elsewhere that calls the setter with another value
+ * sits in a file the reading's guard never checks. A response's reading
+ * passes no `sent`: what the handler hands its callees is part of what it
+ * returns.
  */
-export function literalInsertions(fn) {
+export function literalInsertions(fn, sent) {
     const out = [];
     const visit = (node) => {
         // A type states no value, and a parameter's default decides what its
         // callers may pass, not what the function returns.
         if (Node.isTypeNode(node) || Node.isParameterDeclaration(node))
             return;
-        if (isMarkableLiteral(node)) {
+        if (isMarkableLiteral(node) && (sent === undefined || !handedToAnotherCall(node, sent))) {
             out.push({ pos: node.getStart(), text: OPEN, closes: false });
             out.push({ pos: node.getEnd(), text: CLOSE, closes: true });
             return;
@@ -129,6 +138,44 @@ export function literalInsertions(fn) {
     visit(fn);
     return out;
 }
+/**
+ * Whether `literal` is an argument, at any depth, of a call that is not the
+ * send: walking up, a call or `new` holds it as an argument before the walk
+ * reaches `sent` (the expression the request inference read) or the send
+ * call `sent` is.
+ *
+ * A literal that initialises a `const` reaches a call through the const's
+ * name (`const initial = 'open'; useState(initial)`), so the walk follows
+ * every identifier of that name in the const's scope, and a name it cannot
+ * follow (a destructuring pattern) counts as handed on. Matching by name, not
+ * by symbol, can only skip more literals.
+ */
+function handedToAnotherCall(literal, sent, depth = 0) {
+    if (depth > MAX_FOLLOW_DEPTH)
+        return true;
+    let current = literal;
+    for (let parent = current.getParent(); parent; parent = current.getParent()) {
+        if (current === sent)
+            return false;
+        if ((Node.isCallExpression(parent) || Node.isNewExpression(parent)) &&
+            parent.getArguments().includes(current)) {
+            return parent !== sent;
+        }
+        if (Node.isVariableDeclaration(parent) && parent.getInitializer() === current) {
+            const name = parent.getNameNode();
+            if (!Node.isIdentifier(name))
+                return true;
+            const scope = parent.getFirstAncestor(isFunctionWithBody) ?? parent.getSourceFile();
+            return scope
+                .getDescendantsOfKind(SyntaxKind.Identifier)
+                .some((use) => use !== name &&
+                use.getText() === name.getText() &&
+                handedToAnotherCall(use, sent, depth + 1));
+        }
+        current = parent;
+    }
+    return false;
+}
 /** Whether `node` is a literal value the reading marks `as const`. */
 function isMarkableLiteral(node) {
     const kind = node.getKind();