@salesforcedevs/docs-components 1.29.0-alpha1 → 1.29.0

package/src/modules/docUtils/openApiParser/openApiParser.ts

@@ -1,187 +0,0 @@
-export type ParameterDefinition = {
-    name: string;
-    in: "path" | "query" | "header" | "cookie";
-    required: boolean;
-    description: string;
-    schema: any;
-    example?: any;
-};
-
-export type RequestBodyDefinition = {
-    description: string;
-    required: boolean;
-    content: Record<string, { schema: any }>;
-};
-
-export type OperationDefinition = {
-    operationId: string;
-    method: string;
-    path: string;
-    summary: string;
-    description: string;
-    parameters: ParameterDefinition[];
-    requestBody: RequestBodyDefinition | null;
-    responses: Record<string, any>;
-    tags: string[];
-};
-
-export function resolveRef(ref: string, spec: any): any {
-    if (!ref || !ref.startsWith("#/")) {
-        return ref;
-    }
-    const parts = ref.replace("#/", "").split("/");
-    let current = spec;
-    for (const part of parts) {
-        current = current?.[part];
-        if (current === undefined) {
-            return undefined;
-        }
-    }
-    return current;
-}
-
-export function generateSampleFromSchema(schema: any, spec: any): any {
-    if (!schema) {
-        return undefined;
-    }
-
-    if (schema.$ref) {
-        return generateSampleFromSchema(resolveRef(schema.$ref, spec), spec);
-    }
-
-    if (schema.example !== undefined) {
-        return schema.example;
-    }
-
-    if (schema.default !== undefined) {
-        return schema.default;
-    }
-
-    if (schema.enum && schema.enum.length > 0) {
-        return schema.enum[0];
-    }
-
-    switch (schema.type) {
-        case "string":
-            return schema.format === "date"
-                ? "2024-01-01"
-                : schema.format === "date-time"
-                  ? "2024-01-01T00:00:00Z"
-                  : schema.format === "email"
-                    ? "user@example.com"
-                    : schema.format === "uri"
-                      ? "https://example.com"
-                      : "string";
-        case "integer":
-            return schema.minimum ?? 0;
-        case "number":
-            return schema.minimum ?? 0.0;
-        case "boolean":
-            return false;
-        case "array":
-            if (schema.items) {
-                return [generateSampleFromSchema(schema.items, spec)];
-            }
-            return [];
-        case "object": {
-            const result: Record<string, any> = {};
-            if (schema.properties) {
-                for (const [key, propSchema] of Object.entries(
-                    schema.properties
-                )) {
-                    result[key] = generateSampleFromSchema(
-                        propSchema as any,
-                        spec
-                    );
-                }
-            }
-            return result;
-        }
-        default:
-            return null;
-    }
-}
-
-function resolveParameter(param: any, spec: any): ParameterDefinition {
-    const resolved = param.$ref ? resolveRef(param.$ref, spec) : param;
-    return {
-        name: resolved.name ?? "",
-        in: resolved.in ?? "query",
-        required: resolved.required ?? false,
-        description: resolved.description ?? "",
-        schema: resolved.schema ?? {},
-        example: resolved.example
-    };
-}
-
-export function parseOpenApiSpec(spec: any): OperationDefinition[] {
-    if (!spec?.paths) {
-        return [];
-    }
-
-    const operations: OperationDefinition[] = [];
-    const httpMethods = [
-        "get",
-        "post",
-        "put",
-        "delete",
-        "patch",
-        "options",
-        "head"
-    ];
-
-    for (const [path, pathItem] of Object.entries(spec.paths)) {
-        const pathObj = pathItem as any;
-        const pathLevelParams: any[] = pathObj.parameters ?? [];
-
-        for (const method of httpMethods) {
-            const operation = pathObj[method];
-            if (!operation) {
-                continue;
-            }
-
-            const operationParams = (operation.parameters ?? []).map(
-                (p: any) => resolveParameter(p, spec)
-            );
-            const pathParams = pathLevelParams
-                .map((p: any) => resolveParameter(p, spec))
-                .filter(
-                    (pp) =>
-                        !operationParams.some(
-                            (op: ParameterDefinition) => op.name === pp.name
-                        )
-                );
-
-            const mergedParams = [...pathParams, ...operationParams];
-
-            let requestBody: RequestBodyDefinition | null = null;
-            if (operation.requestBody) {
-                const rb = operation.requestBody.$ref
-                    ? resolveRef(operation.requestBody.$ref, spec)
-                    : operation.requestBody;
-                if (rb) {
-                    requestBody = {
-                        description: rb.description ?? "",
-                        required: rb.required ?? false,
-                        content: rb.content ?? {}
-                    };
-                }
-            }
-
-            operations.push({
-                operationId:
-                    operation.operationId ?? `${method}_${path.replace(/\//g, "_")}`,
-                method: method.toUpperCase(),
-                path,
-                summary: operation.summary ?? "",
-                description: operation.description ?? "",
-                parameters: mergedParams,
-                requestBody,
-                responses: operation.responses ?? {},
-                tags: operation.tags ?? []
-            });
-        }
-    }
-
-    return operations;
-}