@descryy/adapter-python 0.1.0

package/dist/graphql.d.ts

@@ -0,0 +1,197 @@
+/**
+ * The GraphQL root-operation extractor for Python — strawberry and
+ * strawberry-django.
+ *
+ * ## The identity, and where it comes from
+ *
+ * `API_ROUTE`/`API_ENDPOINT` identity is `METHOD /path`, and a GraphQL field has
+ * neither a verb nor a URL. `DEC-NEXT-graphql-operation-identity` (descry-core)
+ * settles it by transposing the gRPC precedent
+ * (`DEC-NEXT-grpc-route-identity`), because deciding it here in isolation is how
+ * two producers of one operation end up with two conventions and no join:
+ *
+ * - **`method` is the literal sentinel `"GRAPHQL"`** — one per protocol, the
+ *   way gRPC has exactly one `"RPC"` rather than a sentinel per RPC kind. It is
+ *   not load-bearing for identity (the path alone is unique); it exists so a
+ *   human or a UI reading `attrs.method` knows not to expect `GET`.
+ * - **The path is `/<OperationType>/<field>`** — `/Query/circuit`,
+ *   `/Mutation/create_order`, `/Subscription/message_added`. GraphQL's root
+ *   operation type is the structural analogue of gRPC's Service and the field
+ *   name the analogue of its Method.
+ *
+ * ## The departure from the precedent, and how it is narrowed
+ *
+ * gRPC's decision leans on **"the path is read, not assembled"**: protoc writes
+ * `Service_Method_FullMethodName = "/pkg.Service/Method"` and the reader takes
+ * that literal verbatim. **strawberry writes no such artifact.** The schema is
+ * built at import time from the class structure, and the schema-facing field
+ * name is not always the Python name:
+ *
+ * | strawberry's own rule | consequence here |
+ * | --- | --- |
+ * | `NameConverter.auto_camel_case` defaults to **True** | `circuit_list` is served as `circuitList` |
+ * | an explicit `graphql_name` returns before `apply_naming_config` | `field(name="allCircuits")` is the name, verbatim |
+ * | `to_camel_case` is `s.split("_")`, rejoined | a name with **no** `_` is unchanged by it |
+ *
+ * So this reader admits a field **only when its schema-facing name can be read
+ * verbatim out of the source** — the three rows above give exactly three such
+ * cases, and `readFieldName` is the whole rule. Anything else is refused and
+ * disclosed. **The reader never computes a name.** Writing `circuitList` — a
+ * string that appears nowhere in the repository — because a library default
+ * says it should is precisely the DEC-055 shape both decisions exist to
+ * prevent: everything normalises, everything resolves, and the join is silently
+ * zero because the consumer half read the real wire name and this half invented
+ * a plausible one.
+ *
+ * The half that *is* still assembled is the `/Query/` prefix, and it is
+ * assembled out of the schema call's own slot keyword (`query=`/`mutation=`/
+ * `subscription=`) rather than out of any Python name. The three operation-type
+ * words are GraphQL's, fixed by the specification, and a client addresses an
+ * operation by its slot — never by the root class's name. That is why a class
+ * decorated `@strawberry.type(name="Query")` sitting in the `mutation=` slot
+ * yields `/Mutation/...` here, and why netbox's ten mixins all decorated
+ * `name="Query"` are read through the slot their root occupies rather than
+ * through a decorator that strawberry itself discards for a base class.
+ *
+ * ## The provenance rule, which does the precision work
+ *
+ * A field becomes an operation only when **a `strawberry.Schema(...)` call,
+ * whose callee resolves through the import table to strawberry's own module,
+ * puts its class in a root slot.** Not because a class is decorated
+ * `@strawberry.type` — netbox has 34 of those and 10 are root mixins — and
+ * never because an attribute is spelled like a field. This is `routes.ts`'s
+ * "the receiver must resolve to a router constructed from a web framework's own
+ * module" rule in a second spelling, and it is the same lesson: a node type
+ * comes from provenance or from nothing.
+ *
+ * The split with `extract.py` is this adapter's standing one — the Python side
+ * records syntactic form and names no framework, every decision about what a
+ * form *means* is taken here.
+ */
+import type { PyCall } from "./extract.ts";
+import type { PyAttribute } from "./orm.ts";
+/**
+ * The protocol sentinel. One per protocol, per `DEC-NEXT-grpc-route-identity`'s
+ * `"RPC"` — deliberately not split into QUERY/MUTATION/SUBSCRIPTION, because
+ * the operation type is carried in the path where gRPC carries the service.
+ */
+export declare const GRAPHQL_METHOD = "GRAPHQL";
+/** GraphQL's three root operation types, fixed by the specification. */
+export declare const OPERATION_SLOTS: readonly ["query", "mutation", "subscription"];
+export type OperationSlot = (typeof OPERATION_SLOTS)[number];
+/** The path segment each slot contributes — the specification's own spelling. */
+export declare const OPERATION_TYPE: Readonly<Record<OperationSlot, string>>;
+/**
+ * The modules a `Schema` must come from. The module check is the precision
+ * control: a local class called `Schema` is not strawberry's, and matching the
+ * bare name would admit it — the same trap `ROUTER_CONSTRUCTORS` guards against
+ * for `Blueprint`.
+ */
+export declare const SCHEMA_MODULES: ReadonlySet<string>;
+/** The modules a field constructor must come from, for the same reason. */
+export declare const FIELD_MODULES: ReadonlySet<string>;
+/**
+ * The field constructors read as declaring a root operation.
+ *
+ * Deliberately short. `field` is what netbox's 246 root operations are written
+ * with and is the only form with corpus evidence behind it; `mutation` is
+ * strawberry's equally unambiguous constructor for the mutation slot, admitted
+ * on the same provenance (a resolved import from strawberry) rather than on a
+ * name rule. Relay's `node`/`connection` are **not** here: no repository on
+ * hand writes them, and a constructor admitted from documentation rather than
+ * from a counted repository is a case that was imagined.
+ */
+export declare const FIELD_CONSTRUCTORS: ReadonlySet<string>;
+/** The class decorator that makes a class a GraphQL type at all. */
+export declare const TYPE_DECORATORS: ReadonlySet<string>;
+/**
+ * What this run could establish about how strawberry spells a field's name.
+ *
+ * `"unknown"` is a real and distinct third state, not a synonym for the
+ * default: two `StrawberryConfig` calls in one file, or a config passed as a
+ * variable, leave the disposition genuinely unresolved. It is kept apart from
+ * `"camel"` so the reason a field was refused stays truthful, even though both
+ * states refuse the same fields.
+ */
+export type FieldNaming = "verbatim" | "camel" | "unknown";
+/**
+ * The schema-facing name of a field, **read** — or `null` when stating it would
+ * mean computing it.
+ *
+ * This function is the whole of the departure-narrowing, and every branch
+ * corresponds to a line of strawberry's own `name_converter.py` /
+ * `str_converters.py`:
+ *
+ * - `get_graphql_name` returns `obj.graphql_name` *before* `apply_naming_config`
+ *   is ever called, so an explicit `name=` is the answer under every config.
+ * - with `auto_camel_case=False`, `apply_naming_config` is the identity.
+ * - `to_camel_case(s)` is `s.split("_")` rejoined, so for a name containing no
+ *   `_` it is the identity too — which is why an underscore-free field is
+ *   readable even when this run could not resolve the config at all.
+ *
+ * There is no fourth branch, and there must not be one: the only way to answer
+ * the remaining case is to run strawberry's transform, and the result would be
+ * a string that is not written anywhere in the repository.
+ */
+export declare function readFieldName(attributeName: string, explicitName: string | null, naming: FieldNaming): string | null;
+/** A `strawberry.Schema(...)` call, as the source states it. */
+export interface SchemaDecl {
+    readonly file: string;
+    readonly line: number;
+    /** Slot -> the root class's local name, where it was written as a bare name. */
+    readonly roots: ReadonlyMap<OperationSlot, string>;
+    /** Slots written as something other than a bare name — disclosed, never guessed. */
+    readonly opaqueSlots: readonly {
+        readonly slot: OperationSlot;
+        readonly written: string;
+    }[];
+    readonly naming: FieldNaming;
+}
+/**
+ * How this file spells its fields, resolved from the schema call's own `config`.
+ *
+ * **The tie is syntactic and it is required to be.** `keywordText.config` must
+ * literally read `StrawberryConfig(...)`, and the file must contain exactly one
+ * `StrawberryConfig` call — otherwise nothing says which config this schema
+ * got, and picking one is the guess this reader does not make. A config named
+ * by a variable, or one of two, yields `"unknown"`, which costs the snake_case
+ * fields and keeps the underscore-free ones (both dispositions agree on those).
+ */
+export declare function namingOf(calls: readonly PyCall[], schemaCall: PyCall): FieldNaming;
+/**
+ * Every `strawberry.Schema(...)` this file declares.
+ *
+ * `strawberry.federation.Schema` is included: federation changes what the
+ * gateway does with a subgraph, not how the subgraph names its own operations.
+ */
+export declare function schemaDeclsIn(file: string, calls: readonly PyCall[], moduleOf: (name: string) => string | undefined): readonly SchemaDecl[];
+/** One field on a root operation type, as far as this reader could read it. */
+export interface OperationField {
+    readonly attributeName: string;
+    /** The schema-facing name, read — or `null` when it would have to be computed. */
+    readonly name: string | null;
+    readonly file: string;
+    readonly line: number;
+}
+/**
+ * Is this class-body assignment a declared strawberry field?
+ *
+ * Provenance, not shape: the constructor's own module must resolve to
+ * strawberry or strawberry-django. `helper()` from an unrelated library and a
+ * plain `version = "1.0"` are class attributes, not operations.
+ */
+export declare function isFieldConstructor(callee: string | null, moduleOf: (name: string) => string | undefined): boolean;
+/** The literal `name=` on a field constructor, if one was written. */
+export declare function explicitNameOf(keywords: Readonly<Record<string, unknown>>): string | null;
+/** The fields a root operation class declares as class-body assignments. */
+export declare function fieldsFromAttributes(attributes: readonly PyAttribute[], file: string, naming: FieldNaming, moduleOf: (name: string) => string | undefined): readonly OperationField[];
+/**
+ * The same field written as a decorated method — `@strawberry.field def
+ * circuit_by_id(...)`, strawberry's other documented spelling for a resolver
+ * with arguments. `decoratorCalls` carries `@strawberry.field(name="x")`;
+ * the bare `@strawberry.field` arrives only in `decorators`, so both are read.
+ */
+export declare function fieldFromMethod(methodName: string, decorators: readonly (string | null)[], decoratorCalls: readonly PyCall[], file: string, line: number, naming: FieldNaming, moduleOf: (name: string) => string | undefined): OperationField | null;
+/** `Query` + `circuit` -> `/Query/circuit`. */
+export declare function operationPath(slot: OperationSlot, fieldName: string): string;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../src/graphql.ts"],"names":[],"mappings":"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"}

package/dist/graphql.js

@@ -0,0 +1,302 @@
+/**
+ * The GraphQL root-operation extractor for Python — strawberry and
+ * strawberry-django.
+ *
+ * ## The identity, and where it comes from
+ *
+ * `API_ROUTE`/`API_ENDPOINT` identity is `METHOD /path`, and a GraphQL field has
+ * neither a verb nor a URL. `DEC-NEXT-graphql-operation-identity` (descry-core)
+ * settles it by transposing the gRPC precedent
+ * (`DEC-NEXT-grpc-route-identity`), because deciding it here in isolation is how
+ * two producers of one operation end up with two conventions and no join:
+ *
+ * - **`method` is the literal sentinel `"GRAPHQL"`** — one per protocol, the
+ *   way gRPC has exactly one `"RPC"` rather than a sentinel per RPC kind. It is
+ *   not load-bearing for identity (the path alone is unique); it exists so a
+ *   human or a UI reading `attrs.method` knows not to expect `GET`.
+ * - **The path is `/<OperationType>/<field>`** — `/Query/circuit`,
+ *   `/Mutation/create_order`, `/Subscription/message_added`. GraphQL's root
+ *   operation type is the structural analogue of gRPC's Service and the field
+ *   name the analogue of its Method.
+ *
+ * ## The departure from the precedent, and how it is narrowed
+ *
+ * gRPC's decision leans on **"the path is read, not assembled"**: protoc writes
+ * `Service_Method_FullMethodName = "/pkg.Service/Method"` and the reader takes
+ * that literal verbatim. **strawberry writes no such artifact.** The schema is
+ * built at import time from the class structure, and the schema-facing field
+ * name is not always the Python name:
+ *
+ * | strawberry's own rule | consequence here |
+ * | --- | --- |
+ * | `NameConverter.auto_camel_case` defaults to **True** | `circuit_list` is served as `circuitList` |
+ * | an explicit `graphql_name` returns before `apply_naming_config` | `field(name="allCircuits")` is the name, verbatim |
+ * | `to_camel_case` is `s.split("_")`, rejoined | a name with **no** `_` is unchanged by it |
+ *
+ * So this reader admits a field **only when its schema-facing name can be read
+ * verbatim out of the source** — the three rows above give exactly three such
+ * cases, and `readFieldName` is the whole rule. Anything else is refused and
+ * disclosed. **The reader never computes a name.** Writing `circuitList` — a
+ * string that appears nowhere in the repository — because a library default
+ * says it should is precisely the DEC-055 shape both decisions exist to
+ * prevent: everything normalises, everything resolves, and the join is silently
+ * zero because the consumer half read the real wire name and this half invented
+ * a plausible one.
+ *
+ * The half that *is* still assembled is the `/Query/` prefix, and it is
+ * assembled out of the schema call's own slot keyword (`query=`/`mutation=`/
+ * `subscription=`) rather than out of any Python name. The three operation-type
+ * words are GraphQL's, fixed by the specification, and a client addresses an
+ * operation by its slot — never by the root class's name. That is why a class
+ * decorated `@strawberry.type(name="Query")` sitting in the `mutation=` slot
+ * yields `/Mutation/...` here, and why netbox's ten mixins all decorated
+ * `name="Query"` are read through the slot their root occupies rather than
+ * through a decorator that strawberry itself discards for a base class.
+ *
+ * ## The provenance rule, which does the precision work
+ *
+ * A field becomes an operation only when **a `strawberry.Schema(...)` call,
+ * whose callee resolves through the import table to strawberry's own module,
+ * puts its class in a root slot.** Not because a class is decorated
+ * `@strawberry.type` — netbox has 34 of those and 10 are root mixins — and
+ * never because an attribute is spelled like a field. This is `routes.ts`'s
+ * "the receiver must resolve to a router constructed from a web framework's own
+ * module" rule in a second spelling, and it is the same lesson: a node type
+ * comes from provenance or from nothing.
+ *
+ * The split with `extract.py` is this adapter's standing one — the Python side
+ * records syntactic form and names no framework, every decision about what a
+ * form *means* is taken here.
+ */
+/**
+ * The protocol sentinel. One per protocol, per `DEC-NEXT-grpc-route-identity`'s
+ * `"RPC"` — deliberately not split into QUERY/MUTATION/SUBSCRIPTION, because
+ * the operation type is carried in the path where gRPC carries the service.
+ */
+export const GRAPHQL_METHOD = "GRAPHQL";
+/** GraphQL's three root operation types, fixed by the specification. */
+export const OPERATION_SLOTS = ["query", "mutation", "subscription"];
+/** The path segment each slot contributes — the specification's own spelling. */
+export const OPERATION_TYPE = {
+    query: "Query",
+    mutation: "Mutation",
+    subscription: "Subscription",
+};
+/**
+ * The modules a `Schema` must come from. The module check is the precision
+ * control: a local class called `Schema` is not strawberry's, and matching the
+ * bare name would admit it — the same trap `ROUTER_CONSTRUCTORS` guards against
+ * for `Blueprint`.
+ */
+export const SCHEMA_MODULES = new Set([
+    "strawberry",
+    "strawberry.schema",
+    "strawberry.federation",
+    "strawberry.federation.schema",
+]);
+/** The modules a field constructor must come from, for the same reason. */
+export const FIELD_MODULES = new Set(["strawberry", "strawberry_django"]);
+/**
+ * The field constructors read as declaring a root operation.
+ *
+ * Deliberately short. `field` is what netbox's 246 root operations are written
+ * with and is the only form with corpus evidence behind it; `mutation` is
+ * strawberry's equally unambiguous constructor for the mutation slot, admitted
+ * on the same provenance (a resolved import from strawberry) rather than on a
+ * name rule. Relay's `node`/`connection` are **not** here: no repository on
+ * hand writes them, and a constructor admitted from documentation rather than
+ * from a counted repository is a case that was imagined.
+ */
+export const FIELD_CONSTRUCTORS = new Set(["field", "mutation"]);
+/** The class decorator that makes a class a GraphQL type at all. */
+export const TYPE_DECORATORS = new Set(["type", "interface", "input"]);
+/**
+ * The schema-facing name of a field, **read** — or `null` when stating it would
+ * mean computing it.
+ *
+ * This function is the whole of the departure-narrowing, and every branch
+ * corresponds to a line of strawberry's own `name_converter.py` /
+ * `str_converters.py`:
+ *
+ * - `get_graphql_name` returns `obj.graphql_name` *before* `apply_naming_config`
+ *   is ever called, so an explicit `name=` is the answer under every config.
+ * - with `auto_camel_case=False`, `apply_naming_config` is the identity.
+ * - `to_camel_case(s)` is `s.split("_")` rejoined, so for a name containing no
+ *   `_` it is the identity too — which is why an underscore-free field is
+ *   readable even when this run could not resolve the config at all.
+ *
+ * There is no fourth branch, and there must not be one: the only way to answer
+ * the remaining case is to run strawberry's transform, and the result would be
+ * a string that is not written anywhere in the repository.
+ */
+export function readFieldName(attributeName, explicitName, naming) {
+    if (explicitName !== null && explicitName !== "")
+        return explicitName;
+    if (naming === "verbatim")
+        return attributeName;
+    return attributeName.includes("_") ? null : attributeName;
+}
+/** The leading dotted segment of a callee — `strawberry` in `strawberry.Schema`. */
+function rootSegmentOf(callee) {
+    const dot = callee.indexOf(".");
+    return dot === -1 ? callee : callee.slice(0, dot);
+}
+/** The trailing segment — `Schema` in `strawberry.federation.Schema`. */
+function lastSegmentOf(callee) {
+    const dot = callee.lastIndexOf(".");
+    return dot === -1 ? callee : callee.slice(dot + 1);
+}
+/**
+ * Does a written callee resolve, through the file's import table, to a symbol
+ * in one of `modules`?
+ *
+ * Both spellings are accepted and both are checked: `from strawberry import
+ * Schema` binds the symbol directly, and `import strawberry` binds the module,
+ * in which case the dotted prefix in the source carries the rest of the path.
+ */
+function resolvesToModule(callee, wanted, modules, moduleOf) {
+    if (!wanted.has(lastSegmentOf(callee)))
+        return false;
+    const root = rootSegmentOf(callee);
+    const bound = moduleOf(root);
+    if (bound === undefined)
+        return false;
+    // `from strawberry import Schema` -> bound is `strawberry`, callee is `Schema`.
+    if (root === callee)
+        return modules.has(bound);
+    // `import strawberry` -> bound is `strawberry`, callee is `strawberry.Schema`;
+    // the dotted middle is part of the module path, so rebuild and check it.
+    const middle = callee.slice(root.length + 1, callee.length - lastSegmentOf(callee).length - 1);
+    const full = middle === "" ? bound : `${bound}.${middle}`;
+    return modules.has(full);
+}
+/**
+ * How this file spells its fields, resolved from the schema call's own `config`.
+ *
+ * **The tie is syntactic and it is required to be.** `keywordText.config` must
+ * literally read `StrawberryConfig(...)`, and the file must contain exactly one
+ * `StrawberryConfig` call — otherwise nothing says which config this schema
+ * got, and picking one is the guess this reader does not make. A config named
+ * by a variable, or one of two, yields `"unknown"`, which costs the snake_case
+ * fields and keeps the underscore-free ones (both dispositions agree on those).
+ */
+export function namingOf(calls, schemaCall) {
+    const written = schemaCall.keywordText["config"];
+    // No config keyword at all: strawberry's documented default, verified against
+    // `NameConverter.__init__` — `auto_camel_case` is True.
+    if (written === undefined)
+        return "camel";
+    if (!/^\s*(?:[A-Za-z_][\w.]*\.)?StrawberryConfig\s*\(/.test(written))
+        return "unknown";
+    const configs = calls.filter((c) => c.callee !== null && lastSegmentOf(c.callee) === "StrawberryConfig");
+    if (configs.length !== 1)
+        return "unknown";
+    const value = configs[0].keywords["auto_camel_case"];
+    if (value === true)
+        return "camel";
+    if (value === false)
+        return "verbatim";
+    // Written, but not as a literal — or not written, in which case the
+    // constructor default applies and that default is camel-casing.
+    return configs[0].opaqueKeywords.includes("auto_camel_case") ? "unknown" : "camel";
+}
+/**
+ * Every `strawberry.Schema(...)` this file declares.
+ *
+ * `strawberry.federation.Schema` is included: federation changes what the
+ * gateway does with a subgraph, not how the subgraph names its own operations.
+ */
+export function schemaDeclsIn(file, calls, moduleOf) {
+    const found = [];
+    for (const call of calls) {
+        if (call.callee === null)
+            continue;
+        if (!resolvesToModule(call.callee, new Set(["Schema"]), SCHEMA_MODULES, moduleOf))
+            continue;
+        const roots = new Map();
+        const opaqueSlots = [];
+        for (const slot of OPERATION_SLOTS) {
+            const bare = call.keywordNames[slot];
+            if (bare !== undefined) {
+                roots.set(slot, bare);
+                continue;
+            }
+            const written = call.keywordText[slot];
+            // A slot written as a call, a subscript or an attribute names a root this
+            // reader cannot follow. The operations under it are real and unreadable —
+            // the exact thing a ledger row is for.
+            if (written !== undefined)
+                opaqueSlots.push({ slot, written });
+        }
+        if (roots.size === 0 && opaqueSlots.length === 0)
+            continue;
+        found.push({ file, line: call.line, roots, opaqueSlots, naming: namingOf(calls, call) });
+    }
+    return found;
+}
+/**
+ * Is this class-body assignment a declared strawberry field?
+ *
+ * Provenance, not shape: the constructor's own module must resolve to
+ * strawberry or strawberry-django. `helper()` from an unrelated library and a
+ * plain `version = "1.0"` are class attributes, not operations.
+ */
+export function isFieldConstructor(callee, moduleOf) {
+    if (callee === null)
+        return false;
+    return resolvesToModule(callee, FIELD_CONSTRUCTORS, FIELD_MODULES, moduleOf);
+}
+/** The literal `name=` on a field constructor, if one was written. */
+export function explicitNameOf(keywords) {
+    const name = keywords["name"];
+    return typeof name === "string" ? name : null;
+}
+/** The fields a root operation class declares as class-body assignments. */
+export function fieldsFromAttributes(attributes, file, naming, moduleOf) {
+    const fields = [];
+    for (const attribute of attributes) {
+        if (!isFieldConstructor(attribute.callee, moduleOf))
+            continue;
+        const explicit = explicitNameOf(attribute.keywords);
+        fields.push({
+            attributeName: attribute.name,
+            name: readFieldName(attribute.name, explicit, naming),
+            file,
+            line: attribute.line,
+        });
+    }
+    return fields;
+}
+/**
+ * The same field written as a decorated method — `@strawberry.field def
+ * circuit_by_id(...)`, strawberry's other documented spelling for a resolver
+ * with arguments. `decoratorCalls` carries `@strawberry.field(name="x")`;
+ * the bare `@strawberry.field` arrives only in `decorators`, so both are read.
+ */
+export function fieldFromMethod(methodName, decorators, decoratorCalls, file, line, naming, moduleOf) {
+    let explicit = null;
+    let matched = false;
+    for (const decorator of decoratorCalls) {
+        if (!isFieldConstructor(decorator.callee, moduleOf))
+            continue;
+        matched = true;
+        explicit = explicitNameOf(decorator.keywords) ?? explicit;
+    }
+    if (!matched) {
+        for (const written of decorators) {
+            // `@strawberry.field(name="x")` is recorded here too, as source text.
+            // Strip any call so the bare and called forms take one path.
+            const bare = written === null ? null : written.replace(/\s*\(.*$/s, "");
+            if (bare !== null && isFieldConstructor(bare, moduleOf))
+                matched = true;
+        }
+    }
+    if (!matched)
+        return null;
+    return { attributeName: methodName, name: readFieldName(methodName, explicit, naming), file, line };
+}
+/** `Query` + `circuit` -> `/Query/circuit`. */
+export function operationPath(slot, fieldName) {
+    return `/${OPERATION_TYPE[slot]}/${fieldName}`;
+}
+//# sourceMappingURL=graphql.js.map

package/dist/graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../src/graphql.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@descryy/adapter-python` — the Python language adapter.
+ *
+ * Depends on `@descryy/ir` and `@descryy/adapter-common`, and on nothing else in
+ * the engine. Parsing is Python's own `ast`, in one subprocess (DEC-062).
+ */
+export { ADAPTER_ID, ADAPTER_VERSION, DEFAULT_PYTHON_GLOBS, LANGUAGE, createPythonAdapter, hashOf, } from "./adapter.ts";
+export type { PythonAdapter, PythonAdapterOptions } from "./adapter.ts";
+export { importRoots, modulePathOf, moduleNameOf, projectName, resolveImport, } from "./module.ts";
+export type { ImportRecord, ImportTarget, ResolveOptions } from "./module.ts";
+export { readPytestConfig, globToRegExp, PYTEST_DEFAULTS } from "./pytest-config.ts";
+export type { PytestConfig } from "./pytest-config.ts";
+export { DECLARATIVE_BASE_FACTORIES, ORM_BASE_MODULES, isColumnCall, isFrameworkBaseName, ormShapeOf, } from "./orm.ts";
+export type { OrmField, OrmFramework, OrmShape, PyAttribute } from "./orm.ts";
+export { GRAPHQL_METHOD, OPERATION_SLOTS, OPERATION_TYPE, namingOf, operationPath, readFieldName, schemaDeclsIn, } from "./graphql.ts";
+export type { FieldNaming, OperationField, OperationSlot, SchemaDecl } from "./graphql.ts";
+export { extract } from "./extract.ts";
+export type { ExtractInput, Extraction, PyResult } from "./extract.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,UAAU,EACV,eAAe,EACf,oBAAoB,EACpB,QAAQ,EACR,mBAAmB,EACnB,MAAM,GACP,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAExE,OAAO,EACL,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,GACd,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE9E,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrF,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,UAAU,GACX,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE9E,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,QAAQ,EACR,aAAa,EACb,aAAa,EACb,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * `@descryy/adapter-python` — the Python language adapter.
+ *
+ * Depends on `@descryy/ir` and `@descryy/adapter-common`, and on nothing else in
+ * the engine. Parsing is Python's own `ast`, in one subprocess (DEC-062).
+ */
+export { ADAPTER_ID, ADAPTER_VERSION, DEFAULT_PYTHON_GLOBS, LANGUAGE, createPythonAdapter, hashOf, } from "./adapter.js";
+export { importRoots, modulePathOf, moduleNameOf, projectName, resolveImport, } from "./module.js";
+export { readPytestConfig, globToRegExp, PYTEST_DEFAULTS } from "./pytest-config.js";
+export { DECLARATIVE_BASE_FACTORIES, ORM_BASE_MODULES, isColumnCall, isFrameworkBaseName, ormShapeOf, } from "./orm.js";
+export { GRAPHQL_METHOD, OPERATION_SLOTS, OPERATION_TYPE, namingOf, operationPath, readFieldName, schemaDeclsIn, } from "./graphql.js";
+export { extract } from "./extract.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,UAAU,EACV,eAAe,EACf,oBAAoB,EACpB,QAAQ,EACR,mBAAmB,EACnB,MAAM,GACP,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,GACd,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrF,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,UAAU,GACX,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,QAAQ,EACR,aAAa,EACb,aAAa,EACb,aAAa,GACd,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}