@fern-api/fdr-sdk 1.0.4-92b8658c63 → 1.0.4-cab13ddd2d

package/dist/api-definition/migrators/v1ToV2.js

@@ -0,0 +1,710 @@
+import { isNonNullish } from "@fern-api/ui-core-utils";
+import titleCase from "@fern-api/ui-core-utils/titleCase";
+import visitDiscriminatedUnion from "@fern-api/ui-core-utils/visitDiscriminatedUnion";
+import { mapValues } from "es-toolkit/object";
+import { ROOT_PACKAGE_ID } from "../../navigation/consts";
+import { SupportedLanguage } from "../../orpc-client/shared.js";
+import { LOOP_TOLERANCE } from "../const";
+import { cleanLanguage } from "../lang";
+import * as V2 from "../latest";
+import { convertToCurl } from "../snippets/curl";
+import { toSnippetHttpRequest } from "../snippets/SnippetHttpRequest";
+import { sortKeysByShape } from "../sort-keys";
+import { getMessageForStatus } from "../status-message";
+function isSubpackage(package_) {
+    return typeof package_.subpackageId === "string";
+}
+const AUTH_SCHEME_ID = V2.AuthSchemeId("default");
+export class ApiDefinitionV1ToLatest {
+    v1;
+    static from(v1) {
+        return new ApiDefinitionV1ToLatest(v1);
+    }
+    auth;
+    constructor(v1) {
+        this.v1 = v1;
+        this.auth = v1.auth ?? undefined;
+    }
+    static createEndpointId(endpoint, subpackageId = ROOT_PACKAGE_ID) {
+        return V2.EndpointId(endpoint.originalEndpointId ?? `${subpackageId}.${endpoint.id}`);
+    }
+    static createWebSocketId(webSocket, subpackageId = ROOT_PACKAGE_ID) {
+        return V2.WebSocketId(`${subpackageId}.${webSocket.id}`);
+    }
+    static createWebhookId(webhook, subpackageId = ROOT_PACKAGE_ID) {
+        return V2.WebhookId(`${subpackageId}.${webhook.id}`);
+    }
+    static createGrpcEndpointId(grpc, subpackageId = ROOT_PACKAGE_ID) {
+        return V2.EndpointId(`${subpackageId}.${grpc.id}`);
+    }
+    endpoints = {};
+    websockets = {};
+    webhooks = {};
+    graphqlOperations = {};
+    subpackages = {};
+    types = {};
+    migrate = () => {
+        Object.entries(this.v1.types).forEach(([id, type]) => {
+            this.types[V2.TypeId(id)] = {
+                name: type.name,
+                description: type.description,
+                availability: type.availability,
+                shape: this.migrateTypeShape(type.shape),
+                displayName: type.displayName
+            };
+        });
+        [this.v1.rootPackage, ...Object.values(this.v1.subpackages)].forEach((pkg) => {
+            const [subpackageId, namespace] = this.collectNamespace(pkg, this.v1.subpackages);
+            pkg.endpoints.forEach((endpoint) => {
+                const id = endpoint.protocol?.type === "grpc"
+                    ? ApiDefinitionV1ToLatest.createGrpcEndpointId(endpoint, subpackageId)
+                    : ApiDefinitionV1ToLatest.createEndpointId(endpoint, subpackageId);
+                this.endpoints[id] = this.migrateEndpoint(id, endpoint, namespace);
+            });
+            pkg.websockets.forEach((webSocket) => {
+                const id = ApiDefinitionV1ToLatest.createWebSocketId(webSocket, subpackageId);
+                this.websockets[id] = this.migrateWebSocket(id, webSocket, namespace);
+            });
+            pkg.webhooks.forEach((webhook) => {
+                const id = ApiDefinitionV1ToLatest.createWebhookId(webhook, subpackageId);
+                this.webhooks[id] = this.migrateWebhook(id, webhook, namespace);
+            });
+            pkg.graphqlOperations?.forEach((graphqlOp) => {
+                const id = graphqlOp.id;
+                this.graphqlOperations[id] = this.migrateGraphQlOperation(graphqlOp, namespace);
+            });
+        });
+        Object.values(this.v1.subpackages).forEach((subpackage) => {
+            this.subpackages[subpackage.subpackageId] = this.migrateSubpackage(subpackage);
+        });
+        return {
+            id: this.v1.id,
+            apiName: this.v1.apiName,
+            endpoints: this.endpoints,
+            websockets: this.websockets,
+            webhooks: this.webhooks,
+            graphqlOperations: this.graphqlOperations,
+            types: this.types,
+            subpackages: this.subpackages,
+            auths: this.v1.authSchemes ? this.v1.authSchemes : this.v1.auth ? { [AUTH_SCHEME_ID]: this.v1.auth } : {},
+            globalHeaders: this.migrateParameters(this.v1.globalHeaders ?? undefined),
+            snippetsConfiguration: this.v1.snippetsConfiguration
+        };
+    };
+    collectNamespace = (pkg, subpackages) => {
+        if (!isSubpackage(pkg)) {
+            return [ROOT_PACKAGE_ID, []];
+        }
+        const namespace = [pkg.subpackageId];
+        let subpackage = pkg;
+        let loop = 0;
+        while (subpackage.parent != null) {
+            if (loop > LOOP_TOLERANCE) {
+                throw new Error("Circular subpackage reference detected");
+            }
+            const next = subpackages[subpackage.parent];
+            if (next == null) {
+                break;
+            }
+            namespace.unshift(subpackage.parent);
+            subpackage = next;
+            loop++;
+        }
+        return [pkg.subpackageId, namespace];
+    };
+    migrateEndpoint = (id, v1, namespace) => {
+        const toRet = {
+            id,
+            namespace,
+            displayName: v1.name,
+            operationId: v1.urlSlug.split("/").pop(),
+            description: v1.description,
+            availability: v1.availability,
+            method: v1.method,
+            path: v1.path.parts.filter((part) => part.value !== ""),
+            auth: v1.authV2 ? v1.authV2 : v1.authed ? [AUTH_SCHEME_ID] : undefined,
+            multiAuth: v1.multiAuth,
+            defaultEnvironment: v1.defaultEnvironment,
+            environments: v1.environments,
+            pathParameters: this.migratePathOrQueryParameters(v1.path.pathParameters),
+            queryParameters: this.migratePathOrQueryParameters(v1.queryParameters),
+            requestHeaders: this.migrateParameters(v1.headers),
+            responseHeaders: this.migrateParameters(v1.responseHeaders ?? undefined),
+            requests: (() => {
+                const requests = (v1.requestsV2?.requests ?? undefined)
+                    ?.map((request) => this.migrateHttpRequest(request))
+                    ?.filter(isNonNullish);
+                if (requests != null && requests.length > 0) {
+                    return requests;
+                }
+                return [this.migrateHttpRequest(v1.request ?? undefined)].filter(isNonNullish);
+            })(),
+            responses: (() => {
+                const responses = (v1.responsesV2?.responses ?? undefined)
+                    ?.map((response) => this.migrateHttpResponse(response))
+                    ?.filter(isNonNullish);
+                if (responses != null && responses.length > 0) {
+                    return responses;
+                }
+                return [this.migrateHttpResponse(v1.response ?? undefined)].filter(isNonNullish);
+            })(),
+            errors: this.migrateHttpErrors(v1.errorsV2 ?? undefined),
+            examples: undefined,
+            snippetTemplates: v1.snippetTemplates,
+            protocol: v1.protocol,
+            includeInApiExplorer: v1.includeInApiExplorer ?? true
+        };
+        toRet.examples = this.migrateHttpExamples(v1.examples, toRet);
+        return toRet;
+    };
+    migrateWebSocket = (id, v1, namespace) => {
+        const messages = this.migrateChannelMessages(v1.messages);
+        return {
+            id,
+            namespace,
+            displayName: v1.name,
+            operationId: v1.urlSlug.split("/").pop(),
+            description: v1.description,
+            availability: v1.availability,
+            path: v1.path.parts.filter((part) => part.value !== ""),
+            messages,
+            auth: v1.auth ? [AUTH_SCHEME_ID] : undefined,
+            defaultEnvironment: v1.defaultEnvironment,
+            environments: v1.environments,
+            pathParameters: this.migratePathOrQueryParameters(v1.path.pathParameters),
+            queryParameters: this.migratePathOrQueryParameters(v1.queryParameters),
+            requestHeaders: this.migrateParameters(v1.headers),
+            examples: this.migrateChannelExamples(v1.examples, messages)
+        };
+    };
+    migrateWebhook = (id, v1, namespace) => {
+        const payload = this.migrateWebhookPayload(v1.payload);
+        return {
+            id,
+            namespace,
+            displayName: v1.name,
+            operationId: v1.urlSlug.split("/").pop(),
+            description: v1.description,
+            availability: v1.availability,
+            method: v1.method,
+            path: v1.path,
+            headers: this.migrateParameters(v1.headers),
+            payloads: [payload],
+            responses: v1.responses?.map(this.migrateHttpResponse)?.filter(isNonNullish),
+            examples: v1.examples.map((example) => ({
+                ...example,
+                payload: sortKeysByShape(example.payload, payload.shape, this.types)
+            }))
+        };
+    };
+    migrateSubpackage = (subpackage) => {
+        return {
+            id: subpackage.subpackageId,
+            name: subpackage.name,
+            displayName: subpackage.displayName
+        };
+    };
+    migrateParameters = (v1) => {
+        if (v1 == null || v1.length === 0) {
+            return undefined;
+        }
+        return v1.map((parameter) => ({
+            key: V2.PropertyKey(parameter.key),
+            valueShape: {
+                type: "alias",
+                value: this.migrateTypeReference(parameter.type)
+            },
+            propertyAccess: undefined,
+            description: parameter.description ?? undefined,
+            availability: parameter.availability ?? undefined
+        }));
+    };
+    migratePathOrQueryParameters = (v1) => {
+        if (v1 == null || v1.length === 0) {
+            return undefined;
+        }
+        return v1.map((parameter) => ({
+            key: V2.PropertyKey(parameter.key),
+            valueShape: {
+                type: "alias",
+                value: this.migrateTypeReference(parameter.type)
+            },
+            propertyAccess: undefined,
+            description: parameter.description ?? undefined,
+            availability: parameter.availability ?? undefined,
+            explode: parameter.explode ?? undefined
+        }));
+    };
+    migrateTypeReference = (typeRef) => {
+        return visitDiscriminatedUnion(typeRef)._visit({
+            map: (value) => ({
+                type: "map",
+                keyShape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.keyType)
+                },
+                valueShape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.valueType)
+                },
+                minProperties: value.minProperties ?? undefined,
+                maxProperties: value.maxProperties ?? undefined
+            }),
+            id: (value) => ({
+                type: "id",
+                id: value.value,
+                default: value.default ?? undefined
+            }),
+            primitive: (value) => value,
+            nullable: (value) => ({
+                type: "nullable",
+                shape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.itemType)
+                }
+            }),
+            optional: (value) => ({
+                type: "optional",
+                shape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.itemType)
+                },
+                default: value.defaultValue
+            }),
+            list: (value) => ({
+                type: "list",
+                itemShape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.itemType)
+                },
+                minItems: value.minItems ?? undefined,
+                maxItems: value.maxItems ?? undefined
+            }),
+            set: (value) => ({
+                type: "set",
+                itemShape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(value.itemType)
+                },
+                minItems: value.minItems ?? undefined,
+                maxItems: value.maxItems ?? undefined
+            }),
+            literal: (value) => value,
+            unknown: () => ({
+                type: "unknown",
+                displayName: undefined
+            })
+        });
+    };
+    migrateTypeShape = (shape) => {
+        return visitDiscriminatedUnion(shape)._visit({
+            object: (value) => ({
+                type: "object",
+                extends: value.extends,
+                properties: this.migrateObjectProperties(value.properties),
+                extraProperties: value.extraProperties != null ? this.migrateTypeReference(value.extraProperties) : undefined
+            }),
+            alias: (value) => ({
+                type: "alias",
+                value: this.migrateTypeReference(value.value)
+            }),
+            enum: (value) => value,
+            undiscriminatedUnion: (value) => ({
+                type: "undiscriminatedUnion",
+                variants: value.variants.map((variant) => ({
+                    displayName: variant.displayName ?? undefined,
+                    shape: {
+                        type: "alias",
+                        value: this.migrateTypeReference(variant.type)
+                    },
+                    description: variant.description ?? undefined,
+                    availability: variant.availability ?? undefined
+                }))
+            }),
+            discriminatedUnion: (value) => ({
+                type: "discriminatedUnion",
+                discriminant: V2.PropertyKey(value.discriminant),
+                variants: value.variants.map((variant) => ({
+                    discriminantValue: variant.discriminantValue,
+                    displayName: variant.displayName ?? undefined,
+                    description: variant.description ?? undefined,
+                    availability: variant.availability ?? undefined,
+                    extends: variant.additionalProperties.extends,
+                    properties: this.migrateObjectProperties(variant.additionalProperties.properties),
+                    extraProperties: undefined
+                }))
+            })
+        });
+    };
+    migrateObjectProperties = (properties) => {
+        return properties.map((value) => ({
+            key: V2.PropertyKey(value.key),
+            valueShape: {
+                type: "alias",
+                value: this.migrateTypeReference(value.valueType)
+            },
+            propertyAccess: value.propertyAccess ?? undefined,
+            description: value.description ?? undefined,
+            availability: value.availability ?? undefined
+        }));
+    };
+    migrateJsonShape = (shape) => {
+        return visitDiscriminatedUnion(shape)._visit({
+            object: this.migrateTypeShape,
+            reference: (ref) => ({
+                type: "alias",
+                value: this.migrateTypeReference(ref.value)
+            })
+        });
+    };
+    migrateWebhookPayloadShape = (shape) => {
+        return visitDiscriminatedUnion(shape)._visit({
+            object: (obj) => ({
+                type: "object",
+                extends: obj.extends,
+                properties: this.migrateObjectProperties(obj.properties),
+                extraProperties: undefined
+            }),
+            reference: (ref) => ({
+                type: "alias",
+                value: this.migrateTypeReference(ref.value)
+            }),
+            formData: (formData) => ({
+                type: "formData",
+                description: formData.description,
+                availability: formData.availability,
+                fields: this.migrateFormDataProperties(formData.properties)
+            })
+        });
+    };
+    migrateWebhookPayload = (payload) => {
+        return {
+            description: payload.description,
+            shape: this.migrateWebhookPayloadShape(payload.type)
+        };
+    };
+    migrateChannelExamples = (examples, messages) => {
+        if (examples.length === 0) {
+            return undefined;
+        }
+        return examples.map((example) => ({
+            description: example.description,
+            path: example.path,
+            name: example.name,
+            pathParameters: example.pathParameters,
+            queryParameters: example.queryParameters,
+            requestHeaders: example.headers,
+            messages: example.messages.map((example) => ({
+                ...example,
+                body: sortKeysByShape(example.body, messages.find((message) => message.type === example.type)?.body, this.types)
+            }))
+        }));
+    };
+    migrateChannelMessages = (messages) => {
+        return messages.map((message) => ({
+            type: message.type,
+            displayName: message.displayName,
+            origin: message.origin,
+            body: this.migrateJsonShape(message.body),
+            description: message.description,
+            availability: message.availability
+        }));
+    };
+    migrateHttpExamples = (examples, endpoint) => {
+        if (examples.length === 0) {
+            return undefined;
+        }
+        return examples.map((example) => {
+            const toRet = {
+                path: example.path,
+                responseStatusCode: example.responseStatusCode,
+                name: example.name,
+                description: example.description,
+                pathParameters: example.pathParameters,
+                queryParameters: example.queryParameters,
+                headers: example.headers,
+                requestBody: example.requestBodyV3,
+                responseBody: example.responseBodyV3,
+                snippets: undefined
+            };
+            if (example.requestBodyV3) {
+                toRet.requestBody = visitDiscriminatedUnion(example.requestBodyV3)._visit({
+                    bytes: (value) => value,
+                    json: (value) => ({
+                        type: "json",
+                        value: sortKeysByShape(value.value, endpoint.requests?.[0]?.body, this.types)
+                    }),
+                    form: (value) => ({
+                        type: "form",
+                        value: mapValues(value.value, (formValue, key) => {
+                            const typedFormValue = formValue;
+                            if (typedFormValue.type === "json") {
+                                const shape = endpoint.requests?.[0]?.body.type === "formData"
+                                    ? endpoint.requests?.[0]?.body.fields.find((field) => field.key === key && field.type === "property")?.valueShape
+                                    : undefined;
+                                return {
+                                    type: "json",
+                                    value: sortKeysByShape(typedFormValue.value, shape, this.types)
+                                };
+                            }
+                            else {
+                                return typedFormValue;
+                            }
+                        })
+                    })
+                });
+            }
+            if (toRet.responseBody) {
+                toRet.responseBody.value = sortKeysByShape(toRet.responseBody.value, endpoint.responses?.[0]?.body, this.types);
+            }
+            toRet.snippets = this.migrateEndpointSnippets(endpoint, toRet, example.codeSamples, example.codeExamples);
+            return toRet;
+        });
+    };
+    migrateHttpErrors = (errors) => {
+        if (errors == null || errors.length === 0) {
+            return undefined;
+        }
+        return errors.map((value) => {
+            const shape = value.type != null ? this.migrateTypeShape(value.type) : undefined;
+            return {
+                isWildcard: value.isWildcard,
+                description: value.description,
+                availability: value.availability,
+                name: (value.name != null ? titleCase(value.name) : undefined) ?? getMessageForStatus(value.statusCode),
+                statusCode: value.statusCode,
+                shape,
+                examples: value.examples?.map((example) => ({
+                    description: example.description,
+                    name: example.name,
+                    responseBody: {
+                        type: "json",
+                        value: sortKeysByShape(example.responseBody.value, shape, this.types)
+                    }
+                })),
+                headers: this.migrateParameters(value.headers ?? undefined)
+            };
+        });
+    };
+    migrateHttpResponse = (response) => {
+        if (response == null) {
+            return undefined;
+        }
+        return {
+            description: response.description,
+            statusCode: response.statusCode ?? 200,
+            isWildcard: response.isWildcard,
+            body: visitDiscriminatedUnion(response.type)._visit({
+                object: (value) => ({
+                    type: "object",
+                    extends: value.extends,
+                    properties: this.migrateObjectProperties(value.properties),
+                    extraProperties: undefined
+                }),
+                reference: (value) => ({
+                    type: "alias",
+                    value: this.migrateTypeReference(value.value)
+                }),
+                fileDownload: (value) => value,
+                streamingText: (value) => value,
+                stream: (value) => ({
+                    type: "stream",
+                    terminator: value.terminator,
+                    shape: this.migrateJsonShape(value.shape)
+                }),
+                // Careful! we're dropping non-streaming response shape in the following migration:
+                streamCondition: (value) => ({
+                    type: "stream",
+                    terminator: undefined,
+                    shape: this.migrateJsonShape(value.streamResponse.shape)
+                })
+            })
+        };
+    };
+    migrateHttpRequest = (request) => {
+        if (request == null) {
+            return undefined;
+        }
+        return {
+            description: request.description,
+            contentType: request.contentType,
+            body: visitDiscriminatedUnion(request.type)._visit({
+                object: (value) => ({
+                    type: "object",
+                    extends: value.extends,
+                    properties: this.migrateObjectProperties(value.properties),
+                    extraProperties: undefined
+                }),
+                reference: (value) => ({
+                    type: "alias",
+                    value: this.migrateTypeReference(value.value)
+                }),
+                bytes: (value) => ({
+                    type: "bytes",
+                    isOptional: value.isOptional,
+                    contentType: value.contentType
+                }),
+                formData: (value) => ({
+                    type: "formData",
+                    description: value.description,
+                    availability: value.availability,
+                    fields: this.migrateFormDataProperties(value.properties)
+                }),
+                fileUpload: (value) => ({
+                    type: "formData",
+                    description: value.value?.description,
+                    availability: value.value?.availability,
+                    fields: this.migrateFormDataProperties(value.value?.properties ?? [])
+                })
+            })
+        };
+    };
+    migrateFormDataProperties = (properties) => {
+        return properties.map((prop) => visitDiscriminatedUnion(prop)._visit({
+            file: (file) => visitDiscriminatedUnion(file.value)._visit({
+                file: (single) => ({
+                    type: "file",
+                    key: single.key,
+                    isOptional: single.isOptional,
+                    contentType: single.contentType ?? undefined,
+                    description: single.description ?? undefined,
+                    availability: single.availability ?? undefined
+                }),
+                fileArray: (multiple) => ({
+                    type: "files",
+                    key: multiple.key,
+                    isOptional: multiple.isOptional,
+                    contentType: multiple.contentType ?? undefined,
+                    description: multiple.description ?? undefined,
+                    availability: multiple.availability ?? undefined
+                })
+            }),
+            bodyProperty: (bodyProp) => ({
+                type: "property",
+                key: bodyProp.key,
+                contentType: bodyProp.contentType ?? undefined,
+                description: bodyProp.description ?? undefined,
+                availability: bodyProp.availability ?? undefined,
+                exploded: bodyProp.exploded ?? undefined,
+                valueShape: {
+                    type: "alias",
+                    value: this.migrateTypeReference(bodyProp.valueType)
+                },
+                propertyAccess: bodyProp.propertyAccess ?? undefined
+            })
+        }));
+    };
+    migrateEndpointSnippets(endpoint, example, codeSamples, codeExamples) {
+        const toRet = {};
+        function push(language, snippet) {
+            (toRet[language] ??= []).push(snippet);
+        }
+        const userProvidedLanguages = new Set();
+        // Add user-provided code snippets
+        codeSamples.forEach((codeSample) => {
+            const language = cleanLanguage(codeSample.language);
+            userProvidedLanguages.add(language);
+            push(language, {
+                name: codeSample.name,
+                language,
+                install: codeSample.install,
+                code: codeSample.code,
+                generated: false,
+                description: codeSample.description
+            });
+        });
+        if (!userProvidedLanguages.has(SupportedLanguage.Curl)) {
+            const code = convertToCurl(toSnippetHttpRequest(endpoint, example, this.auth));
+            push(SupportedLanguage.Curl, {
+                language: SupportedLanguage.Curl,
+                code,
+                name: undefined,
+                install: undefined,
+                generated: true,
+                description: undefined
+            });
+        }
+        if (!userProvidedLanguages.has(SupportedLanguage.Python) && codeExamples.pythonSdk != null) {
+            push(SupportedLanguage.Python, {
+                name: undefined,
+                language: SupportedLanguage.Python,
+                install: codeExamples.pythonSdk.install,
+                code: codeExamples.pythonSdk.sync_client,
+                generated: true,
+                description: undefined
+            });
+        }
+        if (!userProvidedLanguages.has(SupportedLanguage.Typescript) && codeExamples.typescriptSdk != null) {
+            push(SupportedLanguage.Typescript, {
+                name: undefined,
+                language: SupportedLanguage.Typescript,
+                install: codeExamples.typescriptSdk.install,
+                code: codeExamples.typescriptSdk.client,
+                generated: true,
+                description: undefined
+            });
+        }
+        if (!userProvidedLanguages.has(SupportedLanguage.Go) && codeExamples.goSdk != null) {
+            push(SupportedLanguage.Go, {
+                name: undefined,
+                language: SupportedLanguage.Go,
+                install: codeExamples.goSdk.install,
+                code: codeExamples.goSdk.client,
+                generated: true,
+                description: undefined
+            });
+        }
+        if (!userProvidedLanguages.has(SupportedLanguage.Ruby) && codeExamples.rubySdk != null) {
+            push(SupportedLanguage.Ruby, {
+                name: undefined,
+                language: SupportedLanguage.Ruby,
+                install: codeExamples.rubySdk.install,
+                code: codeExamples.rubySdk.client,
+                generated: true,
+                description: undefined
+            });
+        }
+        if (!userProvidedLanguages.has(SupportedLanguage.Csharp) && codeExamples.csharpSdk != null) {
+            push(SupportedLanguage.Csharp, {
+                name: undefined,
+                language: SupportedLanguage.Csharp,
+                install: codeExamples.csharpSdk.install,
+                code: codeExamples.csharpSdk.client,
+                generated: true,
+                description: undefined
+            });
+        }
+        return toRet;
+    }
+    migrateGraphQlOperation = (v1, namespace) => {
+        return {
+            id: v1.id,
+            operationType: v1.operationType,
+            name: v1.name,
+            displayName: v1.displayName,
+            description: v1.description,
+            availability: v1.availability,
+            namespace,
+            arguments: v1.arguments?.map((arg) => this.migrateGraphQlArgument(arg)),
+            returnType: {
+                type: "alias",
+                value: this.migrateTypeReference(v1.returnType)
+            },
+            examples: v1.examples,
+            snippets: v1.snippets
+        };
+    };
+    migrateGraphQlArgument = (v1) => {
+        return {
+            name: v1.name,
+            description: v1.description,
+            availability: v1.availability,
+            type: {
+                type: "alias",
+                value: this.migrateTypeReference(v1.type)
+            },
+            defaultValue: v1.defaultValue
+        };
+    };
+}
+//# sourceMappingURL=v1ToV2.js.map