@descryy/adapter-csharp 0.1.0

package/dist/client-base.js

@@ -0,0 +1,123 @@
+/**
+ * D-FIX-3's client-base extractor — DEC-164's contract, and the first adapter
+ * in this project to build it. `client.ts` already reads a call's own literal
+ * path; this is the separate, larger row that row's own header named as
+ * unaddressed: what the receiver's *base* is, so a bare-relative call
+ * (`client.GetAsync("Users/Me")`, no leading slash) composes against
+ * something real instead of being refused for want of one.
+ *
+ * ## Two shapes built, and why not more
+ *
+ * §7's original audit named `services.AddHttpClient<T>(c => c.BaseAddress =
+ * new Uri(...))` as *the* pattern to build, on the strength of "jellyfin and
+ * eShopOnWeb both confirmed to use exactly this shape." Read against the real
+ * source, that premise does not hold for either named repository: jellyfin's
+ * own `AddHttpClient(NamedClient.Default, ...)` registrations
+ * (`Jellyfin.Server/Startup.cs`) never set `BaseAddress` at all, and
+ * eShopOnWeb has no `AddHttpClient<T>(...)` call anywhere.
+ *
+ * **What every one of both corpora's real `USES_API` edges (and several
+ * previously-silent call sites) actually goes through** is
+ * `WebApplicationFactory<TEntryPoint>.CreateClient(...)` — ASP.NET's own
+ * integration-test client, whose documented default `BaseAddress` is the
+ * application under test itself. `derivesFromWebApplicationFactory` (in
+ * `extract.ts`, where the type graph lives) is the whole mechanism: does the
+ * receiver's own class (directly, or through one in-repo indirection —
+ * `CustomWebApplicationFactory<TProgram> : WebApplicationFactory<TProgram>`
+ * is `CleanArchitecture`'s own shape) carry `WebApplicationFactory<` in its
+ * written base list. Measured: **100% of jellyfin's and eShopOnWeb's existing
+ * 27 `USES_API` edges, plus every previously-silent or previously-refused
+ * bare-relative call this row newly reaches, go through exactly this
+ * receiver.**
+ *
+ * The named `AddHttpClient<T>(...)` shape is real, just not in the two
+ * repositories the audit cited — `dotnet/eShop` has it
+ * (`WebApp/Extensions.cs`, `WebhookClient/Extensions.cs`,
+ * `HybridApp/MauiProgram.cs`, 4 sites), and every one of those typed clients'
+ * own call sites builds its path by string interpolation
+ * (`$"{remoteServiceBaseUrl}items/{id}"`), already and separately refused by
+ * `client.ts`'s "not a bare string literal" rule — so resolving this base
+ * moves **zero** measured edges in any corpus this row has on disk.
+ * {@link typedClientBases} below reads it anyway, narrowly (a literal string
+ * argument to `new Uri(...)`/`new(...)` only — a field, a config read, or any
+ * other expression stays `unresolved`, never guessed): the mechanism is real
+ * corpus evidence, not invented for a fixture, and golden pattern 08a needs a
+ * *non-empty* composed path to prove `DEC-097`'s composition is real rather
+ * than coincidentally correct when the prefix is always empty. No other DI
+ * mechanism — `IHttpClientFactory.CreateClient(name)`'s named-client form
+ * included — is read here; every such call was invisible before this row and
+ * stays exactly as invisible after it, a disclosed, unaffected limit rather
+ * than a claim this file makes and cannot back.
+ *
+ * ## The state built but never produced by real corpus evidence
+ *
+ * DEC-164 names four states; three are real here. `unresolved` is reachable
+ * in code (a `AddHttpClient<T>` registration whose `BaseAddress` is a field
+ * or a config read rather than a literal) but has zero witnesses in any of
+ * the six corpora this row measured — kept rather than deleted, the same way
+ * `efcore.ts`'s rival-ORM exclusion rule stays written down at zero
+ * witnesses: a real rule with no corpus evidence yet, not a guess.
+ */
+/**
+ * DEC-097: only the origin — scheme, host, port — is stripped from an
+ * absolute URI; the path is kept. `undefined` when `uri` is not an absolute
+ * URI this reader can split (no `scheme://`); refused by the caller rather
+ * than guessed, same as every other shape in this file.
+ */
+function pathPrefixOf(uri) {
+    const match = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/]*(\/.*)?$/.exec(uri.trim());
+    if (match === null)
+        return undefined;
+    const path = match[1] ?? "";
+    return path === "/" ? "" : path.replace(/\/+$/, "");
+}
+/**
+ * `services.AddHttpClient<TClient>(o => o.BaseAddress = <expr>)` —
+ * `dotnet/eShop`'s own shape (`WebApp/Extensions.cs`,
+ * `WebhookClient/Extensions.cs`, `HybridApp/MauiProgram.cs`), read textually
+ * rather than through the AST (the same division of labour `aspnetcore.ts`
+ * and `efcore.ts` already keep for a fluent registration chain — see
+ * `extract.ts`'s own header for why). Keyed by `TClient`'s own written name
+ * (short, unqualified — matched the same way against the enclosing type's own
+ * simple name, a disclosed limit rather than a full type resolution this
+ * textual pass cannot do): DI hands the configured client straight to
+ * `TClient`'s own constructor, so a call inside `TClient` whose receiver
+ * resolves to a bare, otherwise-untraced `HttpClient` is exactly this base.
+ *
+ * The RHS is matched as `new(...)`/`new Uri(...)`'s own single argument —
+ * not "everything up to the next `;`", which real `eShop` source would get
+ * wrong: `AddHttpClient<CatalogService>(o => o.BaseAddress = new(...))` is
+ * followed by a fluent chain (`.AddApiVersion(2.0).AddAuthToken();`) whose
+ * terminating `;` is lines away and whose own parentheses would otherwise be
+ * swallowed into the "expression." Real corpus shapes have no nested parens
+ * inside the argument itself (a string literal, or a bare field reference),
+ * so matching up to the first `)` is exact for both, not an approximation.
+ * A bare string literal (`new Uri("https+http://catalog-api")`,
+ * `new("http://webhooks-api")`) resolves; anything else (`new(MobileBffHost)`
+ * — a static field, `eShop`'s own `HybridApp/MauiProgram.cs`) is `unresolved`
+ * with the argument's own text as `why`. Both are measured, not invented for
+ * this file.
+ */
+export function typedClientBases(files) {
+    const bases = new Map();
+    const pattern = /AddHttpClient\s*<\s*([A-Za-z_][A-Za-z0-9_.]*)\s*>\s*\(\s*[A-Za-z_][A-Za-z0-9_]*\s*=>[\s\S]{0,240}?\.BaseAddress\s*=\s*new(?:\s+Uri)?\s*\(\s*([^)]*)\)/g;
+    for (const { source } of files) {
+        for (const match of source.matchAll(pattern)) {
+            const clientType = match[1];
+            const argument = match[2]?.trim();
+            if (clientType === undefined || argument === undefined || bases.has(clientType))
+                continue;
+            const literal = /^"([^"]*)"$/.exec(argument);
+            if (literal === null) {
+                bases.set(clientType, { state: "unresolved", why: argument });
+                continue;
+            }
+            const path = pathPrefixOf(literal[1] ?? "");
+            if (path === undefined)
+                continue; // not an absolute URI this reader can split — leave untraced
+            bases.set(clientType, { state: "resolved", path });
+        }
+    }
+    return bases;
+}
+//# sourceMappingURL=client-base.js.map

package/dist/client-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-base.js","sourceRoot":"","sources":["../src/client-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAsCH;;;;;GAKG;AACH,SAAS,YAAY,CAAC,GAAW;IAC/B,MAAM,KAAK,GAAG,4CAA4C,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5E,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IACrC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC5B,OAAO,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA6C;IAC5E,MAAM,KAAK,GAAG,IAAI,GAAG,EAA4B,CAAC;IAClD,MAAM,OAAO,GACX,wJAAwJ,CAAC;IAC3J,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7C,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;YAClC,IAAI,UAAU,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC;gBAAE,SAAS;YAE1F,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7C,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;gBACrB,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAC9D,SAAS;YACX,CAAC;YACD,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5C,IAAI,IAAI,KAAK,SAAS;gBAAE,SAAS,CAAC,6DAA6D;YAC/F,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,168 @@
+/**
+ * D-FIX-3's C# half: a call through a known HTTP client is disclosed, never
+ * silent — even though this adapter extracts no `USES_API` edges in C# at
+ * all yet.
+ *
+ * ## Why disclosure without extraction is the right first producer here
+ *
+ * Java's `client.ts` extracts real edges for Spring's clients and files a
+ * ledger row for the shapes it cannot read. C# has no extraction path at
+ * all — `capabilities()` already declares no `USES_API` for this adapter
+ * (PROGRESS.md), so *every* call through a known client is unclaimed today.
+ * Building the extractor itself (reading `GetAsync("/orders/{id}")`'s literal
+ * path, the way `bench/client-call-census.mjs`'s C# census shows is
+ * structurally the same shape as Spring's `RestTemplate` — the URL is the
+ * call's own first argument, not a separately built request object) is a
+ * **separate, larger row**: it needs the DEC-129 counting-first admission
+ * this project requires before an extractor ships, a golden fixture change,
+ * and a capability declaration tested against pattern 08 the way DEC-195
+ * records for Java. That is not built here.
+ *
+ * What *is* in scope, and small: recognise the receiver's declared type and
+ * turn "nothing" into a disclosed refusal, so `0 USES_API edges` stops being
+ * indistinguishable from "no HTTP calls in this codebase" — the exact
+ * distinction DEC-113's ledger exists to carry, and the reason a `cf-worker`
+ * zero and a `sherpa-frontend` zero are different facts.
+ *
+ * ## The bounded population, measured before it was picked
+ *
+ * `bench/client-call-census.mjs csharp` names `HttpClient`, `IHttpClientFactory`,
+ * `HttpRequestMessage` and `RestClient` as candidates. Measured directly against
+ * this row: `RestClient` (RestSharp's type) has **zero** occurrences across all
+ * six C# reference corpora (`jellyfin`, `eShop`, `eShopOnWeb`, `Ocelot`,
+ * `CleanArchitecture`, `Dapper`) — counted, not assumed, the same way DEC-129
+ * counted before admitting a corpus. `IHttpClientFactory` produces an
+ * `HttpClient` from `CreateClient()`; the client census's 61 relative-path call
+ * sites are all through `HttpClient` variables and fields once the factory call
+ * has already returned. So the known-type set here is **just `HttpClient`** —
+ * narrower than the census's candidate list, on a measurement rather than a
+ * guess, and it can widen the day a corpus exercises `RestClient` for real.
+ *
+ * `HttpRequestMessage` is not a receiver in any of the census's call sites — it
+ * is the *argument* to `SendAsync`, never the thing a verb method is called on
+ * — so it does not belong in a receiver-type set at all; including it would
+ * have been the coarser-than-node-key mistake DEC-165/187 already paid for once.
+ *
+ * ## Origin check, added after DEC-260
+ *
+ * The first pass of this file filed every candidate as "no extractor," with no
+ * distinction between a call whose literal path stays inside this repository
+ * and one that names a different origin outright — a divergence from Java's
+ * `client.ts`, which has always told the two apart. DEC-260 §3 names the
+ * consequence directly: two adapters disagreeing on the same refusal shape
+ * corrupts `refusalClass` (DEC-242) the moment a consumer trusts it, because
+ * C# would systematically over-report `capability-gap` against Java's
+ * classifier on the same underlying population.
+ *
+ * **Not Java's exact predicate, on purpose — measured, not assumed.** A first
+ * attempt reused Java's "does not start with `/`" rule verbatim and ran it
+ * against the real admitted corpora before calling the row done, per this
+ * project's own discipline. It misfired: `jellyfin` and `eShopOnWeb` both pass
+ * a **bare relative path with no leading slash** (`"Users/New"`) to `HttpClient`
+ * calls resolved against `HttpClient.BaseAddress` at run time — a shape Java's
+ * own population never contains, so Java's rule was never tested against it.
+ * Every such call site found is an integration test through
+ * `_factory.CreateClient()`, ASP.NET's in-process test client pointed at the
+ * application under test — a same-repository call this reader was about to
+ * mislabel as "another origin." See {@link namesAnotherOrigin}'s own comment
+ * for the corrected, narrower rule. This origin check was later carried back
+ * into `adapter-java`'s own `relativePath` rule, which carried the identical
+ * latent defect (`adapter-java` `1bfd2ae`) — the two adapters now agree on
+ * this shape by construction, not by two independently-tuned rules.
+ *
+ * ## Extraction, built on the shape the origin check already separated out
+ *
+ * `DEC-241` §4 named this row: `HttpClient`'s verb methods take the path as
+ * their **own first argument** — `GetAsync("/orders/{id}")`, never a
+ * separately built request object the way `OkHttpClient`/`java.net.http.HttpClient`
+ * require — the same structurally-straightforward shape Java's `RestTemplate`
+ * already extracts from. `clientCalls` below mints a real `USES_API` edge for
+ * every call whose receiver is a known client type, whose method names a
+ * literal verb, and whose path is a repository-relative literal
+ * (`relativePath`, unchanged from the origin check's own reasoning) — and
+ * files a ledger row, never silently drops the call, for every other shape:
+ * an unrecognised verb (`SendAsync`, which takes a pre-built
+ * `HttpRequestMessage` — verb and path both live inside an object this reader
+ * does not open), a non-literal path, an origin outside this repository, or a
+ * bare relative path this reader genuinely cannot place (the same
+ * `BaseAddress`-resolved shape the origin check exists to disclose rather
+ * than guess).
+ */
+import { type IdentityScope, type IRNode } from "@descryy/ir";
+import type { CsRef } from "./parse.ts";
+import type { ClientBaseResult } from "./client-base.ts";
+export interface ClientCall {
+    /** The `FUNCTION` node making the call. */
+    readonly fromId: string;
+    readonly method: string;
+    readonly template: string;
+    readonly verb: string;
+    readonly line: number;
+    /** `test` when the enclosing method is a test case, else `production`. */
+    readonly callerKind: "test" | "production";
+    /** DEC-164's contract, resolved by `extract.ts`'s `client-base.ts` pass. See that file's own header. */
+    readonly clientBase: ClientBaseResult;
+}
+export interface ClientRefusal {
+    readonly fromId: string;
+    readonly raw: string;
+    readonly line: number;
+    readonly reason: string;
+    /** DEC-242's `attrs.blockedBy` — the literal blocking expression, or `null`. */
+    readonly blockedBy: string | null;
+    /** DEC-242's `attrs.refusalClass` — `undefined` means unclassified, never askable. */
+    readonly refusalClass: BaseRefusalClass | "out-of-scope" | undefined;
+    /**
+     * Diagnostic only, not part of DEC-242 — see `adapter-rust/src/client.ts`'s
+     * own doc for what this is and why it is not shipped as part of the
+     * contract. Present only on the generic fallthrough of `diagnoseArgument`.
+     */
+    readonly argumentKind?: "field" | "call" | "concatenation" | "other";
+    /**
+     * Present only when the refusal is DEC-164's own `unresolved` state — a
+     * base-setting mechanism was found but its value could not be read as a
+     * literal. Zero witnesses in this row's six corpora; see `client-base.ts`'s
+     * own header for why the mechanism that would produce this is not built.
+     */
+    readonly clientBase?: ClientBaseResult;
+}
+export type BaseRefusalClass = "value-unknown" | "varies-per-call" | "capability-gap";
+/**
+ * Every reference {@link clientCalls} will act on — an unbounded receiver
+ * type still makes it a true silence past this point, exactly as in Java. See
+ * `client.test.ts` for the reconciliation this makes checkable: every
+ * candidate whose type resolves lands in either `calls` or `refusals`, with
+ * nothing else.
+ */
+export declare function candidateClientRefs(refs: readonly CsRef[]): readonly (CsRef & {
+    readonly receiver: string;
+})[];
+/**
+ * Read one method's calls for outbound HTTP.
+ *
+ * `typeOfReceiver` is supplied by `extract.ts`, which already has the scope
+ * tables (`fn.scope.locals`, the enclosing type's members) a second copy of
+ * here would drift from — the same division of labour as Java's `client.ts`.
+ *
+ * `clientBaseOfReceiver` is DEC-164's contract (`client-base.ts`'s own
+ * header): a per-call determination of what base, if any, this reader traced
+ * for the receiver. Called only for refs that already passed the known-client-
+ * type gate below, matching `typeOfReceiver`'s own division of labour.
+ */
+export declare function clientCalls(refs: readonly CsRef[], fromId: string, typeOfReceiver: (ref: CsRef & {
+    readonly receiver: string;
+}) => string | undefined, isTest: boolean, parameterNames: ReadonlySet<string>, clientBaseOfReceiver: (ref: CsRef & {
+    readonly receiver: string;
+}) => ClientBaseResult): {
+    readonly calls: readonly ClientCall[];
+    readonly refusals: readonly ClientRefusal[];
+};
+/**
+ * The `API_ENDPOINT` a call joins to — minted identically to the route side.
+ *
+ * Shares `endpointQsp` with `extract.ts`'s `SERVES_API` block rather than
+ * recomputing the id, because the two must agree exactly and the failure when
+ * they do not is silent.
+ */
+export declare function endpointFor(scope: IdentityScope, call: ClientCall, producedBy: string, normalise: (template: string) => string): IRNode;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAEnF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,MAAM,WAAW,UAAU;IACzB,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;IAC3C,wGAAwG;IACxG,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;CACvC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,sFAAsF;IACtF,QAAQ,CAAC,YAAY,EAAE,gBAAgB,GAAG,cAAc,GAAG,SAAS,CAAC;IACrE;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,eAAe,GAAG,OAAO,CAAC;IACrE;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AAkBD,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AA8HtF;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,CAAC,KAAK,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAS9G;AAwBD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,GAAG,SAAS,EAClF,MAAM,EAAE,OAAO,EACf,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,oBAAoB,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,gBAAgB,GACrF;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,CAoIxF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GACtC,MAAM,CAaR"}