@fern-api/fdr-sdk 1.1.4-8eae8dde35 → 1.1.4-927605ea44

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

@@ -0,0 +1,831 @@
+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");
+/**
+ * Shared default constants used as fallback return values when migration fails or input is null.
+ */
+const DEFAULT_TYPE_REFERENCE = { type: "unknown", displayName: undefined };
+const DEFAULT_TYPE_SHAPE = { type: "alias", value: DEFAULT_TYPE_REFERENCE };
+const DEFAULT_WEBHOOK_PAYLOAD_SHAPE = { type: "alias", value: DEFAULT_TYPE_REFERENCE };
+const DEFAULT_WEBHOOK_PAYLOAD = { description: undefined, shape: DEFAULT_WEBHOOK_PAYLOAD_SHAPE };
+const DEFAULT_GRAPHQL_ARGUMENT = {
+    name: "",
+    description: undefined,
+    availability: undefined,
+    type: DEFAULT_TYPE_SHAPE,
+    defaultValue: undefined
+};
+/**
+ * Wraps a function with a try-catch that returns a default value on error.
+ */
+function withDefault(fn, defaultValue, label) {
+    return (...args) => {
+        try {
+            return fn(...args);
+        }
+        catch (e) {
+            const argsSummary = args.map((arg) => {
+                try {
+                    const str = JSON.stringify(arg);
+                    return str != null && str.length > 200 ? `${str.slice(0, 200)}...` : str;
+                }
+                catch {
+                    return String(arg);
+                }
+            });
+            console.error(`Error in ${label}:`, e, "args:", argsSummary);
+            return defaultValue;
+        }
+    };
+}
+/**
+ * Wraps a void callback in a try-catch that logs errors.
+ */
+function trySafe(fn, label) {
+    try {
+        fn();
+    }
+    catch (e) {
+        console.error(`Error in ${label}:`, e);
+    }
+}
+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]) => trySafe(() => {
+            if (type == null) {
+                return;
+            }
+            this.types[V2.TypeId(id)] = {
+                name: type?.name,
+                description: type?.description,
+                availability: type?.availability,
+                shape: this.migrateTypeShape(type?.shape),
+                displayName: type?.displayName
+            };
+        }, `migrate type ${id}`));
+        [this.v1.rootPackage, ...Object.values(this.v1.subpackages)].forEach((pkg) => trySafe(() => {
+            if (pkg == null) {
+                return;
+            }
+            const [subpackageId, namespace] = this.collectNamespace(pkg, this.v1.subpackages);
+            pkg?.endpoints?.forEach((endpoint) => trySafe(() => {
+                const id = endpoint?.protocol?.type === "grpc"
+                    ? ApiDefinitionV1ToLatest.createGrpcEndpointId(endpoint, subpackageId)
+                    : ApiDefinitionV1ToLatest.createEndpointId(endpoint, subpackageId);
+                this.endpoints[id] = this.migrateEndpoint(id, endpoint, namespace);
+            }, `migrate endpoint ${endpoint?.id}`));
+            pkg?.websockets?.forEach((webSocket) => trySafe(() => {
+                const id = ApiDefinitionV1ToLatest.createWebSocketId(webSocket, subpackageId);
+                this.websockets[id] = this.migrateWebSocket(id, webSocket, namespace);
+            }, `migrate webSocket ${webSocket?.id}`));
+            pkg?.webhooks?.forEach((webhook) => trySafe(() => {
+                const id = ApiDefinitionV1ToLatest.createWebhookId(webhook, subpackageId);
+                this.webhooks[id] = this.migrateWebhook(id, webhook, namespace);
+            }, `migrate webhook ${webhook?.id}`));
+            pkg?.graphqlOperations?.forEach((graphqlOp) => trySafe(() => {
+                const id = graphqlOp?.id;
+                this.graphqlOperations[id] = this.migrateGraphQlOperation(graphqlOp, namespace);
+            }, `migrate graphqlOp ${graphqlOp?.id}`));
+        }, "migrate package"));
+        Object.values(this.v1.subpackages)?.forEach((subpackage) => trySafe(() => {
+            if (subpackage == null) {
+                return;
+            }
+            this.subpackages[subpackage?.subpackageId] = this.migrateSubpackage(subpackage);
+        }, `migrate subpackage ${subpackage?.subpackageId}`));
+        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 (!pkg || !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
+            .filter((parameter) => parameter?.type != null)
+            .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
+            .filter((parameter) => parameter?.type != null)
+            .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 = withDefault((typeRef) => {
+        if (typeRef == null) {
+            return DEFAULT_TYPE_REFERENCE;
+        }
+        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
+            })
+        });
+    }, DEFAULT_TYPE_REFERENCE, "migrateTypeReference");
+    migrateTypeShape = withDefault((shape) => {
+        if (shape == null) {
+            return DEFAULT_TYPE_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 ?? [])
+                    .filter((variant) => variant?.type != null)
+                    .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
+                }))
+            })
+        });
+    }, DEFAULT_TYPE_SHAPE, "migrateTypeShape");
+    migrateObjectProperties = withDefault((properties) => {
+        if (properties == null) {
+            return [];
+        }
+        return properties
+            .filter((value) => value?.valueType != null)
+            .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
+        }));
+    }, [], "migrateObjectProperties");
+    migrateJsonShape = withDefault((shape) => {
+        if (shape == null) {
+            return DEFAULT_TYPE_SHAPE;
+        }
+        return visitDiscriminatedUnion(shape)._visit({
+            object: this.migrateTypeShape,
+            reference: (ref) => ({
+                type: "alias",
+                value: this.migrateTypeReference(ref?.value)
+            })
+        });
+    }, DEFAULT_TYPE_SHAPE, "migrateJsonShape");
+    migrateWebhookPayloadShape = withDefault((shape) => {
+        if (shape == null) {
+            return DEFAULT_WEBHOOK_PAYLOAD_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 ?? [])
+            })
+        });
+    }, DEFAULT_WEBHOOK_PAYLOAD_SHAPE, "migrateWebhookPayloadShape");
+    migrateWebhookPayload = withDefault((payload) => {
+        if (payload == null) {
+            return DEFAULT_WEBHOOK_PAYLOAD;
+        }
+        return {
+            description: payload?.description,
+            shape: this.migrateWebhookPayloadShape(payload?.type)
+        };
+    }, DEFAULT_WEBHOOK_PAYLOAD, "migrateWebhookPayload");
+    migrateChannelExamples = withDefault((examples, messages) => {
+        if (examples == null || 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)
+            }))
+        }));
+    }, undefined, "migrateChannelExamples");
+    migrateChannelMessages = withDefault((messages) => {
+        if (messages == null) {
+            return [];
+        }
+        return messages.map((message) => ({
+            type: message?.type,
+            displayName: message?.displayName,
+            origin: message?.origin,
+            body: this.migrateJsonShape(message?.body),
+            description: message?.description,
+            availability: message?.availability
+        }));
+    }, [], "migrateChannelMessages");
+    migrateHttpExamples = withDefault((examples, endpoint) => {
+        if (examples == null || 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;
+        });
+    }, undefined, "migrateHttpExamples");
+    migrateHttpErrors = withDefault((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)
+            };
+        });
+    }, undefined, "migrateHttpErrors");
+    migrateHttpResponse = withDefault((response) => {
+        if (response == null) {
+            return undefined;
+        }
+        if (response.type == 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)
+                })
+            })
+        };
+    }, undefined, "migrateHttpResponse");
+    migrateHttpRequest = withDefault((request) => {
+        if (request == null) {
+            return undefined;
+        }
+        if (request.type == 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 ?? [])
+                })
+            })
+        };
+    }, undefined, "migrateHttpRequest");
+    migrateFormDataProperties = withDefault((properties) => {
+        if (properties == null) {
+            return [];
+        }
+        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) => {
+                if (bodyProp?.valueType == null) {
+                    return undefined;
+                }
+                return {
+                    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
+                };
+            }
+        }))
+            .filter(isNonNullish);
+    }, [], "migrateFormDataProperties");
+    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) => {
+        if (v1 == null) {
+            return {
+                id: "",
+                operationType: "QUERY",
+                name: "",
+                displayName: undefined,
+                description: undefined,
+                availability: undefined,
+                namespace,
+                arguments: undefined,
+                returnType: DEFAULT_TYPE_SHAPE,
+                examples: [],
+                snippets: undefined
+            };
+        }
+        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 = withDefault((v1) => {
+        if (v1 == null) {
+            return DEFAULT_GRAPHQL_ARGUMENT;
+        }
+        return {
+            name: v1?.name,
+            description: v1?.description,
+            availability: v1?.availability,
+            type: {
+                type: "alias",
+                value: this.migrateTypeReference(v1?.type)
+            },
+            defaultValue: v1?.defaultValue
+        };
+    }, DEFAULT_GRAPHQL_ARGUMENT, "migrateGraphQlArgument");
+}
+//# sourceMappingURL=v1ToV2.js.map