@seamapi/blueprint/lib/openapi/flatten-openapi-schema.js

Build tools for the Seam API using this blueprint.

export const flattenOpenapiSchema = (schema) => {
    if ('allOf' in schema && Array.isArray(schema.allOf)) {
        return flattenAllOfSchema(schema);
    }
    if ('oneOf' in schema && Array.isArray(schema.oneOf)) {
        return flattenOneOfSchema(schema);
    }
    if (schema.type === 'object' && schema.properties != null) {
        const flattenedProperties = {};
        for (const [propKey, propSchema] of Object.entries(schema.properties)) {
            flattenedProperties[propKey] = flattenOpenapiSchema(propSchema);
        }
        return { ...schema, properties: flattenedProperties };
    }
    if (schema.type === 'array' && schema.items != null) {
        return { ...schema, items: flattenOpenapiSchema(schema.items) };
    }
    return schema;
};
export const flattenAllOfSchema = (schema) => {
    const flattenedSchema = {
        type: 'object',
        properties: {},
        required: [],
        ...(schema?.description != null && { description: schema.description }),
        ...(schema['x-property-groups'] != null && {
            'x-property-groups': schema['x-property-groups'],
        }),
    };
    const flattenedSubschemas = schema.allOf.map(flattenOpenapiSchema);
    for (const flattenedSubschema of flattenedSubschemas) {
        if (flattenedSubschema.properties != null) {
            flattenedSchema.properties = {
                ...flattenedSchema.properties,
                ...flattenedSubschema.properties,
            };
        }
        if (flattenedSubschema.required != null &&
            Array.isArray(flattenedSubschema.required)) {
            flattenedSchema.required = Array.from(new Set([...flattenedSchema.required, ...flattenedSubschema.required]));
        }
    }
    for (const [propKey, propSchema] of Object.entries(flattenedSchema.properties)) {
        if ('enum' in propSchema && Array.isArray(propSchema.enum)) {
            const enumValues = new Set();
            for (const subschema of flattenedSubschemas) {
                const enumProp = subschema.properties?.[propKey];
                if (enumProp != null &&
                    'enum' in enumProp &&
                    Array.isArray(enumProp.enum)) {
                    enumProp.enum.forEach((val) => enumValues.add(val));
                }
            }
            flattenedSchema.properties[propKey] = {
                ...propSchema,
                enum: Array.from(enumValues),
            };
        }
    }
    return flattenedSchema;
};
export const flattenOneOfSchema = (schema) => {
    const baseFlattenedSchema = {
        ...(schema?.description != null && { description: schema.description }),
    };
    const flattenedSubschemas = schema.oneOf.map(flattenOpenapiSchema);
    if (flattenedSubschemas.every((s) => s.type === 'string' && Array.isArray(s.enum))) {
        const mergedEnums = Array.from(new Set(flattenedSubschemas.flatMap((s) => s.enum ?? [])));
        return {
            ...baseFlattenedSchema,
            type: 'string',
            enum: mergedEnums,
        };
    }
    else {
        let mergedProperties = {};
        const requiredFieldsLists = [];
        for (const flattenedSubschema of flattenedSubschemas) {
            if (flattenedSubschema.properties != null) {
                mergedProperties = {
                    ...mergedProperties,
                    ...flattenedSubschema.properties,
                };
            }
            if (flattenedSubschema.required != null &&
                Array.isArray(flattenedSubschema.required)) {
                requiredFieldsLists.push(flattenedSubschema.required);
            }
            else {
                requiredFieldsLists.push([]);
            }
        }
        for (const [propKey, propSchema] of Object.entries(mergedProperties)) {
            if ('enum' in propSchema && Array.isArray(propSchema.enum)) {
                const enumValues = new Set();
                for (const subschema of flattenedSubschemas) {
                    const enumProp = subschema.properties?.[propKey];
                    if (enumProp != null &&
                        'enum' in enumProp &&
                        Array.isArray(enumProp.enum)) {
                        enumProp.enum.forEach((val) => enumValues.add(val));
                    }
                }
                mergedProperties[propKey] = {
                    ...propSchema,
                    enum: Array.from(enumValues),
                };
            }
        }
        let commonRequiredFields = [];
        if (requiredFieldsLists.length > 0) {
            commonRequiredFields = requiredFieldsLists.reduce((commonRequired, currentRequiredFields) => commonRequired.filter((field) => currentRequiredFields.includes(field)));
        }
        return {
            ...baseFlattenedSchema,
            type: 'object',
            properties: mergedProperties,
            required: commonRequiredFields,
        };
    }
};
//# sourceMappingURL=flatten-openapi-schema.js.map