@skmtc/core 0.0.984 → 0.16.1

package/script/gql/field/toFieldSchema.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFieldSchema = void 0;
+const graphql_1 = require("graphql");
+const Array_js_1 = require("../../oas/array/Array.js");
+const unwrapType_js_1 = require("../_helpers/unwrapType.js");
+const toScalarType_js_1 = require("../scalar/toScalarType.js");
+const toEnumType_js_1 = require("../enum/toEnumType.js");
+const Unknown_js_1 = require("../../oas/unknown/Unknown.js");
+const Union_js_1 = require("../../oas/union/Union.js");
+/**
+ * Converts a GraphQL field type into an `OasSchema | OasRef<'schema'>`
+ * suitable for use inside an `OasObject.properties` slot or as the
+ * `returnType` / argument type of a {@link GqlOperation}.
+ *
+ * Named composite types (objects, inputs, interfaces, unions) become
+ * refs into the registry so cross-type references resolve through the
+ * registry's internal mirror. Scalars and enums are emitted inline
+ * because they don't need to be referenced from anywhere else (their
+ * type info is fully self-contained).
+ *
+ * The function also encodes the GraphQL list-nullability matrix:
+ * `[T]`, `[T!]`, `[T]!`, `[T!]!` each produce different combinations of
+ * `OasArray.nullable` and the inner schema's nullability.
+ */
+const toFieldSchema = ({ type, context, stackTrail }) => {
+    const { named, isList, outerNullable, itemNullable, nestedList } = (0, unwrapType_js_1.unwrapType)(type);
+    if (nestedList) {
+        // Nested lists (`[[T]]`) aren't representable as a single OasArray of
+        // items; fall back to OasUnknown to avoid producing a wrong type.
+        // Generators that care can later be extended; this is a v1 limitation.
+        context.logIssueNoKey({
+            level: 'warning',
+            stackTrail,
+            parent: type,
+            message: `Nested list type collapsed to 'unknown' — v1 limitation`,
+            type: 'NESTED_LIST_LOSSY'
+        });
+        return context.withStackTrail(stackTrail, () => new Unknown_js_1.OasUnknown({ nullable: outerNullable }, context));
+    }
+    // Resolve the inner schema (the part inside the optional list wrapper).
+    const innerSchema = (() => {
+        const innerNullable = isList ? itemNullable : outerNullable;
+        if ((0, graphql_1.isScalarType)(named)) {
+            return (0, toScalarType_js_1.toScalarType)({ scalar: named, nullable: innerNullable, context, stackTrail });
+        }
+        if ((0, graphql_1.isEnumType)(named)) {
+            return (0, toEnumType_js_1.toEnumType)({ enumType: named, nullable: innerNullable, context, stackTrail });
+        }
+        if ((0, graphql_1.isObjectType)(named) ||
+            (0, graphql_1.isInputObjectType)(named) ||
+            (0, graphql_1.isInterfaceType)(named) ||
+            (0, graphql_1.isUnionType)(named)) {
+            // Composite types live in the registry; the field gets a ref.
+            // Register the consumer location so `removeErroredItems` can
+            // prune this field if `named.name`'s type fails to parse.
+            context.registerRef(stackTrail.clone(), named.name);
+            // OasRef has no nullable flag, so when the field is nullable we wrap
+            // the ref in a single-member OasUnion that carries the flag instead.
+            const ref = context.registry.createRef(named.name, context);
+            return innerNullable
+                ? context.withStackTrail(stackTrail, () => new Union_js_1.OasUnion({ members: [ref], nullable: true }, context))
+                : ref;
+        }
+        // Unknown kind — defensive fallback. Shouldn't fire under
+        // graphql-js's type system, but if it does we want a loud signal.
+        // `named` is `never` here per exhaustiveness so we coerce to read
+        // `.name` for the diagnostic without leaking the cast elsewhere.
+        const unrecognized = named;
+        context.logIssueNoKey({
+            level: 'error',
+            stackTrail,
+            parent: type,
+            message: `Unknown GraphQL type kind for '${unrecognized.name ?? '<anon>'}' — fell back to 'unknown'`,
+            type: 'UNKNOWN_TYPE_KIND'
+        });
+        return context.withStackTrail(stackTrail, () => new Unknown_js_1.OasUnknown({ nullable: innerNullable }, context));
+    })();
+    if (!isList) {
+        return innerSchema;
+    }
+    return context.withStackTrail(stackTrail, () => new Array_js_1.OasArray({
+        items: innerSchema,
+        nullable: outerNullable
+    }, context));
+};
+exports.toFieldSchema = toFieldSchema;

package/script/gql/input/toInputType.d.ts

@@ -0,0 +1,28 @@
+import type { GraphQLInputObjectType } from 'graphql';
+import { OasObject } from '../../oas/object/Object.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToInputTypeArgs = {
+    inputType: GraphQLInputObjectType;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a GraphQL input object type into an `OasObject`.
+ *
+ * Input objects are structurally identical to objects from a parsing
+ * perspective, but they live in a separate names namespace at the
+ * GraphQL level (`UserInput` is distinct from `User`). The parser
+ * registers them under their own name, and downstream generators are
+ * free to emit them as separate TypeScript types.
+ *
+ * One semantic note: an input field marked `required` (non-null) without
+ * a default value must be supplied by the caller; one with a default
+ * value can be omitted. The `required` list here reflects the
+ * non-null-ness alone — generators that want the "effectively optional
+ * because of default" interpretation should consult `defaultValue` on
+ * the field as well, which is preserved on the inner schema's
+ * `default` slot when present.
+ */
+export declare const toInputType: ({ inputType, context, stackTrail }: ToInputTypeArgs) => OasObject;
+//# sourceMappingURL=toInputType.d.ts.map

package/script/gql/input/toInputType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toInputType.d.ts","sourceRoot":"","sources":["../../../src/gql/input/toInputType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAKtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,oCAIzB,eAAe,KAAG,SAiCpB,CAAA"}

package/script/gql/input/toInputType.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInputType = void 0;
+const graphql_1 = require("graphql");
+const Object_js_1 = require("../../oas/object/Object.js");
+const toFieldSchema_js_1 = require("../field/toFieldSchema.js");
+const recordAppliedDirectives_js_1 = require("../_helpers/recordAppliedDirectives.js");
+/**
+ * Converts a GraphQL input object type into an `OasObject`.
+ *
+ * Input objects are structurally identical to objects from a parsing
+ * perspective, but they live in a separate names namespace at the
+ * GraphQL level (`UserInput` is distinct from `User`). The parser
+ * registers them under their own name, and downstream generators are
+ * free to emit them as separate TypeScript types.
+ *
+ * One semantic note: an input field marked `required` (non-null) without
+ * a default value must be supplied by the caller; one with a default
+ * value can be omitted. The `required` list here reflects the
+ * non-null-ness alone — generators that want the "effectively optional
+ * because of default" interpretation should consult `defaultValue` on
+ * the field as well, which is preserved on the inner schema's
+ * `default` slot when present.
+ */
+const toInputType = ({ inputType, context, stackTrail }) => {
+    (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: inputType.astNode, stackTrail, context });
+    const fields = inputType.getFields();
+    const properties = {};
+    const required = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+        stackTrail.trace(fieldName, fieldStack => {
+            (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: field.astNode, stackTrail: fieldStack, context });
+            properties[fieldName] = (0, toFieldSchema_js_1.toFieldSchema)({
+                type: field.type,
+                context,
+                stackTrail: fieldStack
+            });
+            if ((0, graphql_1.isNonNullType)(field.type)) {
+                required.push(fieldName);
+            }
+        });
+    }
+    return context.withStackTrail(stackTrail, () => new Object_js_1.OasObject({
+        title: inputType.name,
+        description: inputType.description ?? undefined,
+        properties,
+        required: required.length > 0 ? required : undefined
+    }, context));
+};
+exports.toInputType = toInputType;

package/script/gql/interface/toInterfaceUnion.d.ts

@@ -0,0 +1,28 @@
+import type { GraphQLInterfaceType } from 'graphql';
+import { OasUnion } from '../../oas/union/Union.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToInterfaceUnionArgs = {
+    interfaceType: GraphQLInterfaceType;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Builds an `OasUnion` over the implementers of a GraphQL interface.
+ *
+ * The interface itself is registered separately as an `OasObject` (via
+ * {@link toObjectType}) so generators that want to emit a base type/
+ * interface can. The union returned here is a sibling registry entry
+ * holding the discriminated union of concrete implementers — the
+ * representation closer to what a typed client cares about at a usage
+ * site.
+ *
+ * Each implementer ref records its consumer location via `registerRef`
+ * so if an implementer type fails to parse the union's reference to it
+ * can be pruned at the end of parsing.
+ *
+ * Per the v1 design decision, the parser emits both forms by default;
+ * generators select whichever they prefer.
+ */
+export declare const toInterfaceUnion: ({ interfaceType, context, stackTrail }: ToInterfaceUnionArgs) => OasUnion;
+//# sourceMappingURL=toInterfaceUnion.d.ts.map

package/script/gql/interface/toInterfaceUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toInterfaceUnion.d.ts","sourceRoot":"","sources":["../../../src/gql/interface/toInterfaceUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAKnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,oBAAoB,CAAA;IACnC,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,GAAI,wCAI9B,oBAAoB,KAAG,QAyBzB,CAAA"}

package/script/gql/interface/toInterfaceUnion.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInterfaceUnion = void 0;
+const Union_js_1 = require("../../oas/union/Union.js");
+const Discriminator_js_1 = require("../../oas/discriminator/Discriminator.js");
+const recordAppliedDirectives_js_1 = require("../_helpers/recordAppliedDirectives.js");
+/**
+ * Builds an `OasUnion` over the implementers of a GraphQL interface.
+ *
+ * The interface itself is registered separately as an `OasObject` (via
+ * {@link toObjectType}) so generators that want to emit a base type/
+ * interface can. The union returned here is a sibling registry entry
+ * holding the discriminated union of concrete implementers — the
+ * representation closer to what a typed client cares about at a usage
+ * site.
+ *
+ * Each implementer ref records its consumer location via `registerRef`
+ * so if an implementer type fails to parse the union's reference to it
+ * can be pruned at the end of parsing.
+ *
+ * Per the v1 design decision, the parser emits both forms by default;
+ * generators select whichever they prefer.
+ */
+const toInterfaceUnion = ({ interfaceType, context, stackTrail }) => {
+    (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: interfaceType.astNode, stackTrail, context });
+    const implementers = context.schema.getImplementations(interfaceType).objects;
+    const members = stackTrail.trace('members', membersStack => implementers.map((impl, index) => membersStack.trace(String(index), memberStack => {
+        context.registerRef(memberStack.clone(), impl.name);
+        return context.registry.createRef(impl.name, context);
+    })));
+    return context.withStackTrail(stackTrail, () => new Union_js_1.OasUnion({
+        title: `${interfaceType.name}Union`,
+        description: interfaceType.description ?? undefined,
+        members,
+        discriminator: new Discriminator_js_1.OasDiscriminator({ propertyName: '__typename' })
+    }, context));
+};
+exports.toInterfaceUnion = toInterfaceUnion;

package/script/gql/object/toObjectType.d.ts

@@ -0,0 +1,23 @@
+import type { GraphQLObjectType, GraphQLInterfaceType } from 'graphql';
+import { OasObject } from '../../oas/object/Object.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToObjectTypeArgs = {
+    objectType: GraphQLObjectType | GraphQLInterfaceType;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a GraphQL object or interface type into an `OasObject`.
+ *
+ * Interfaces and object types share the same field-set shape, so a single
+ * converter handles both. Object property types come from
+ * {@link toFieldSchema}; the GraphQL non-null indicator on each field
+ * lifts into the parent's `required` list (OAS convention).
+ *
+ * Records skipped-feature warnings via `context` for non-root fields
+ * that carry arguments — those args aren't represented in the OAS
+ * model so the user would otherwise have no signal that they exist.
+ */
+export declare const toObjectType: ({ objectType, context, stackTrail }: ToObjectTypeArgs) => OasObject;
+//# sourceMappingURL=toObjectType.d.ts.map

package/script/gql/object/toObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toObjectType.d.ts","sourceRoot":"","sources":["../../../src/gql/object/toObjectType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEtE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAKtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,iBAAiB,GAAG,oBAAoB,CAAA;IACpD,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,qCAI1B,gBAAgB,KAAG,SAwDrB,CAAA"}

package/script/gql/object/toObjectType.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObjectType = void 0;
+const graphql_1 = require("graphql");
+const Object_js_1 = require("../../oas/object/Object.js");
+const toFieldSchema_js_1 = require("../field/toFieldSchema.js");
+const recordAppliedDirectives_js_1 = require("../_helpers/recordAppliedDirectives.js");
+/**
+ * Converts a GraphQL object or interface type into an `OasObject`.
+ *
+ * Interfaces and object types share the same field-set shape, so a single
+ * converter handles both. Object property types come from
+ * {@link toFieldSchema}; the GraphQL non-null indicator on each field
+ * lifts into the parent's `required` list (OAS convention).
+ *
+ * Records skipped-feature warnings via `context` for non-root fields
+ * that carry arguments — those args aren't represented in the OAS
+ * model so the user would otherwise have no signal that they exist.
+ */
+const toObjectType = ({ objectType, context, stackTrail }) => {
+    // Type-level directives (`type User @entity { ... }`).
+    (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: objectType.astNode, stackTrail, context });
+    const fields = objectType.getFields();
+    const properties = {};
+    const required = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+        stackTrail.trace(fieldName, fieldStack => {
+            // Field-level directives (`name: String @auth(role: "admin")`).
+            (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: field.astNode, stackTrail: fieldStack, context });
+            properties[fieldName] = (0, toFieldSchema_js_1.toFieldSchema)({
+                type: field.type,
+                context,
+                stackTrail: fieldStack
+            });
+            // GraphQL non-null at the outer position means the parent guarantees
+            // this field will be present — encode as `required` in the parent.
+            if ((0, graphql_1.isNonNullType)(field.type)) {
+                required.push(fieldName);
+            }
+            // Non-root object/interface fields can carry their own arguments
+            // (e.g. `posts(limit: Int): [Post!]!`). Our schema-driven model
+            // doesn't represent those — log them as skipped so the user knows
+            // they exist on the GraphQL side.
+            if (field.args.length > 0) {
+                const skipped = {};
+                for (const arg of field.args) {
+                    skipped[arg.name] = arg.defaultValue;
+                }
+                context.logSkippedFields({
+                    skipped,
+                    stackTrail: fieldStack,
+                    parent: field,
+                    parentType: 'objectField',
+                    type: 'SKIPPED_FIELD_ARGUMENTS'
+                });
+            }
+        });
+    }
+    return context.withStackTrail(stackTrail, () => new Object_js_1.OasObject({
+        title: objectType.name,
+        description: objectType.description ?? undefined,
+        properties,
+        required: required.length > 0 ? required : undefined
+    }, context));
+};
+exports.toObjectType = toObjectType;

package/script/gql/operation/GqlOperation.d.ts

@@ -0,0 +1,63 @@
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import type { OasRef } from '../../oas/ref/Ref.js';
+import type { GqlArgument } from '../argument/GqlArgument.js';
+import { OasBase } from '../../types/OasBase.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+/**
+ * GraphQL root operation kind. Maps directly onto the schema's root type
+ * pointers (Query / Mutation / Subscription).
+ */
+export type GqlRootKind = 'query' | 'mutation' | 'subscription';
+/**
+ * Fields used to construct a {@link GqlOperation}.
+ */
+export type GqlOperationFields = {
+    rootKind: GqlRootKind;
+    fieldName: string;
+    arguments: GqlArgument[];
+    returnType: OasSchema | OasRef<'schema'>;
+    /**
+     * The original GraphQL return-type string (e.g. `'User'`,
+     * `'[Post!]!'`). Captured at parse time so generators don't have
+     * to reverse-engineer it from the OAS form when emitting SDL
+     * fragments. Optional in construction with `''` fallback so test
+     * fixtures don't have to fabricate one.
+     */
+    returnTypeString?: string;
+    description?: string;
+    deprecated?: boolean;
+    deprecationReason?: string;
+};
+/**
+ * GraphQL counterpart to `OasOperation`.
+ *
+ * Each instance represents a single root-level field exposed by the schema
+ * (e.g. `Query.user`, `Mutation.createPost`). Operation generators marked
+ * `protocol: 'gql'` receive these via the same `transform({ context, operation, acc })`
+ * shape as their HTTP siblings, but with this class instead of
+ * `OasOperation`.
+ *
+ * Field arguments are kept structured (a list of `GqlArgument`) rather
+ * than synthesized into an `OasObject` upfront — generators that want an
+ * args object can build one at emit time, while generators that just need
+ * the per-argument metadata don't pay for the synthesis.
+ */
+export declare class GqlOperation extends OasBase {
+    readonly oasType: "gqlOperation";
+    readonly rootKind: GqlRootKind;
+    readonly fieldName: string;
+    readonly arguments: GqlArgument[];
+    readonly returnType: OasSchema | OasRef<'schema'>;
+    readonly returnTypeString: string;
+    readonly description: string | undefined;
+    readonly deprecated: boolean;
+    readonly deprecationReason: string | undefined;
+    constructor(fields: GqlOperationFields, context?: ParseContextType);
+    /**
+     * Stable identifier for this operation, suitable for file naming and
+     * cache keying. Concatenates the root kind and field name with an
+     * underscore: `query_getUser`, `mutation_createPost`.
+     */
+    get identifier(): string;
+}
+//# sourceMappingURL=GqlOperation.d.ts.map

package/script/gql/operation/GqlOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlOperation.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/GqlOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAA;AAE/D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,WAAW,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,UAAU,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACxC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC,QAAQ,CAAC,OAAO,EAAG,cAAc,CAAS;IAC1C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACjD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAA;gBAElC,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAYlE;;;;OAIG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF"}

package/script/gql/operation/GqlOperation.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GqlOperation = void 0;
+const OasBase_js_1 = require("../../types/OasBase.js");
+/**
+ * GraphQL counterpart to `OasOperation`.
+ *
+ * Each instance represents a single root-level field exposed by the schema
+ * (e.g. `Query.user`, `Mutation.createPost`). Operation generators marked
+ * `protocol: 'gql'` receive these via the same `transform({ context, operation, acc })`
+ * shape as their HTTP siblings, but with this class instead of
+ * `OasOperation`.
+ *
+ * Field arguments are kept structured (a list of `GqlArgument`) rather
+ * than synthesized into an `OasObject` upfront — generators that want an
+ * args object can build one at emit time, while generators that just need
+ * the per-argument metadata don't pay for the synthesis.
+ */
+class GqlOperation extends OasBase_js_1.OasBase {
+    constructor(fields, context) {
+        super(context);
+        Object.defineProperty(this, "oasType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gqlOperation'
+        });
+        Object.defineProperty(this, "rootKind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "arguments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnTypeString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deprecationReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rootKind = fields.rootKind;
+        this.fieldName = fields.fieldName;
+        this.arguments = fields.arguments;
+        this.returnType = fields.returnType;
+        this.returnTypeString = fields.returnTypeString ?? '';
+        this.description = fields.description;
+        this.deprecated = fields.deprecated ?? false;
+        this.deprecationReason = fields.deprecationReason;
+    }
+    /**
+     * Stable identifier for this operation, suitable for file naming and
+     * cache keying. Concatenates the root kind and field name with an
+     * underscore: `query_getUser`, `mutation_createPost`.
+     */
+    get identifier() {
+        return `${this.rootKind}_${this.fieldName}`;
+    }
+}
+exports.GqlOperation = GqlOperation;

package/script/gql/operation/synthesizeArgsObject.d.ts

@@ -0,0 +1,22 @@
+import type { GqlOperation } from './GqlOperation.js';
+import { OasObject } from '../../oas/object/Object.js';
+/**
+ * Builds an `OasObject` representing the arguments tuple of a GraphQL
+ * operation.
+ *
+ * Each argument becomes a property; required arguments without default
+ * values go on the parent's `required` list (OAS convention). An
+ * argument with both `required: true` and a non-undefined `defaultValue`
+ * is *not* listed as required, because the caller can omit it and the
+ * server fills in the default — surfacing it as required would be
+ * misleading at the consumer side.
+ *
+ * Returns `undefined` when the operation takes no arguments. Callers can
+ * use that to skip emitting an args type entirely.
+ *
+ * Lives in core (not in gen-graphql-operation) because it is generic
+ * enough to be reused by any GraphQL operation generator and has no
+ * generator-specific output assumptions.
+ */
+export declare const synthesizeArgsObject: (operation: GqlOperation) => OasObject | undefined;
+//# sourceMappingURL=synthesizeArgsObject.d.ts.map

package/script/gql/operation/synthesizeArgsObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesizeArgsObject.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/synthesizeArgsObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAItD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,YAAY,KAAG,SAAS,GAAG,SAoB1E,CAAA"}

package/script/gql/operation/synthesizeArgsObject.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeArgsObject = void 0;
+const Object_js_1 = require("../../oas/object/Object.js");
+/**
+ * Builds an `OasObject` representing the arguments tuple of a GraphQL
+ * operation.
+ *
+ * Each argument becomes a property; required arguments without default
+ * values go on the parent's `required` list (OAS convention). An
+ * argument with both `required: true` and a non-undefined `defaultValue`
+ * is *not* listed as required, because the caller can omit it and the
+ * server fills in the default — surfacing it as required would be
+ * misleading at the consumer side.
+ *
+ * Returns `undefined` when the operation takes no arguments. Callers can
+ * use that to skip emitting an args type entirely.
+ *
+ * Lives in core (not in gen-graphql-operation) because it is generic
+ * enough to be reused by any GraphQL operation generator and has no
+ * generator-specific output assumptions.
+ */
+const synthesizeArgsObject = (operation) => {
+    if (operation.arguments.length === 0) {
+        return undefined;
+    }
+    const properties = {};
+    const required = [];
+    for (const arg of operation.arguments) {
+        properties[arg.name] = arg.schema;
+        if (arg.required && arg.defaultValue === undefined) {
+            required.push(arg.name);
+        }
+    }
+    return new Object_js_1.OasObject({
+        title: `${operation.fieldName} arguments`,
+        properties,
+        required: required.length > 0 ? required : undefined
+    });
+};
+exports.synthesizeArgsObject = synthesizeArgsObject;

package/script/gql/operation/toRootField.d.ts

@@ -0,0 +1,26 @@
+import type { GraphQLField } from 'graphql';
+import { GqlOperation, type GqlRootKind } from './GqlOperation.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToRootFieldArgs = {
+    rootKind: GqlRootKind;
+    field: GraphQLField<unknown, unknown>;
+    context: ParseContextType;
+    /**
+     * Stack trail for the root field. Typical shape is `[<RootType>,
+     * <fieldName>]` (e.g. `[Query, getUser]`); the function descends
+     * into `args:<argName>` and `return` traces for child parses, so
+     * `removeErroredItems` can prune individual args or the entire
+     * operation depending on which target type errored.
+     */
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a single root-level GraphQL field into a {@link GqlOperation}.
+ *
+ * Used for each field on the Query / Mutation / Subscription root types.
+ * Field arguments become {@link GqlArgument} instances; the return type
+ * runs through {@link toFieldSchema} like any other field type.
+ */
+export declare const toRootField: ({ rootKind, field, context, stackTrail }: ToRootFieldArgs) => GqlOperation;
+//# sourceMappingURL=toRootField.d.ts.map

package/script/gql/operation/toRootField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toRootField.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/toRootField.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,SAAS,CAAA;AAE5D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAIlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,WAAW,CAAA;IACrB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IACrC,OAAO,EAAE,gBAAgB,CAAA;IACzB;;;;;;OAMG;IACH,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,0CAKzB,eAAe,KAAG,YAyDpB,CAAA"}

package/script/gql/operation/toRootField.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRootField = void 0;
+const graphql_1 = require("graphql");
+const GqlOperation_js_1 = require("./GqlOperation.js");
+const GqlArgument_js_1 = require("../argument/GqlArgument.js");
+const toFieldSchema_js_1 = require("../field/toFieldSchema.js");
+const recordAppliedDirectives_js_1 = require("../_helpers/recordAppliedDirectives.js");
+/**
+ * Converts a single root-level GraphQL field into a {@link GqlOperation}.
+ *
+ * Used for each field on the Query / Mutation / Subscription root types.
+ * Field arguments become {@link GqlArgument} instances; the return type
+ * runs through {@link toFieldSchema} like any other field type.
+ */
+const toRootField = ({ rootKind, field, context, stackTrail }) => {
+    // Field-level directives on the root field itself (`me: User @auth`).
+    (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: field.astNode, stackTrail, context });
+    const args = field.args.map((arg) => stackTrail.trace(`args:${arg.name}`, argStack => {
+        const schema = (0, toFieldSchema_js_1.toFieldSchema)({
+            type: arg.type,
+            context,
+            stackTrail: argStack
+        });
+        return context.withStackTrail(argStack, () => new GqlArgument_js_1.GqlArgument({
+            name: arg.name,
+            schema,
+            required: (0, graphql_1.isNonNullType)(arg.type),
+            // graphql-js's `GraphQLType.toString()` produces SDL syntax
+            // (`'ID!'`, `'[String!]'`). Stash it for downstream generators
+            // that need to reconstruct an SDL fragment.
+            gqlType: arg.type.toString(),
+            defaultValue: arg.defaultValue,
+            description: arg.description ?? undefined,
+            deprecated: arg.deprecationReason !== null && arg.deprecationReason !== undefined,
+            deprecationReason: arg.deprecationReason ?? undefined
+        }, context));
+    }));
+    const returnType = stackTrail.trace('return', returnStack => (0, toFieldSchema_js_1.toFieldSchema)({
+        type: field.type,
+        context,
+        stackTrail: returnStack
+    }));
+    return context.withStackTrail(stackTrail, () => new GqlOperation_js_1.GqlOperation({
+        rootKind,
+        fieldName: field.name,
+        arguments: args,
+        returnType,
+        returnTypeString: field.type.toString(),
+        description: field.description ?? undefined,
+        deprecated: field.deprecationReason !== null && field.deprecationReason !== undefined,
+        deprecationReason: field.deprecationReason ?? undefined
+    }, context));
+};
+exports.toRootField = toRootField;