@alova/wormhole
Version:
More modern openAPI generating solution for alova.js
122 lines (121 loc) • 4.41 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.payloadModifier = payloadModifier;
const utils_1 = require("../utils");
const hepler_1 = require("./hepler");
// Apply modifications to object properties (for data/response scopes)
function modifySchemaProperties(schema, config) {
if (!schema || typeof schema !== 'object') {
return schema;
}
const targetSchema = { ...schema };
// union recursively
if (Array.isArray(targetSchema.oneOf)) {
targetSchema.oneOf = targetSchema.oneOf.map(item => modifySchemaProperties(item, config));
}
if (Array.isArray(targetSchema.anyOf)) {
targetSchema.anyOf = targetSchema.anyOf.map(item => modifySchemaProperties(item, config));
}
if (Array.isArray(targetSchema.allOf)) {
targetSchema.allOf = targetSchema.allOf.map(item => modifySchemaProperties(item, config));
}
// modify properties
if (targetSchema.properties) {
const props = { ...targetSchema.properties };
let required = Array.isArray(targetSchema.required) ? [...targetSchema.required] : [];
for (const key of Object.keys(props)) {
if (!(0, utils_1.isMatch)(key, config.match)) {
continue;
}
const { required: requiredOverride, value: valueSchema } = (0, hepler_1.applyModifierSchema)(props[key], config, { required: required.includes(key) });
required = required.filter(r => r !== key);
if (!valueSchema) {
delete props[key];
continue;
}
props[key] = valueSchema;
if (requiredOverride) {
required.push(key);
}
}
targetSchema.properties = props;
targetSchema.required = Array.from(new Set(required));
}
return targetSchema;
}
function modifyParameters(parameters, type, config) {
if (!parameters || !Array.isArray(parameters)) {
return parameters;
}
return parameters.map((param) => {
if (param.in === type) {
if (!(0, utils_1.isMatch)(param.name, config.match)) {
return param;
}
const { value: schema, required } = (0, hepler_1.applyModifierSchema)(param.schema, config, { required: !!param.required });
if (!schema) {
return null;
}
return {
...param,
schema,
required,
};
}
return param;
}).filter(item => item !== null);
}
function payloadModifierApiDescriptor(apiDescriptor, config) {
if (!apiDescriptor) {
return null;
}
const newDescriptor = { ...apiDescriptor };
const { scope } = config;
switch (scope) {
case 'params':
if (newDescriptor.parameters) {
newDescriptor.parameters = modifyParameters(newDescriptor.parameters, 'query', config);
}
break;
case 'pathParams':
if (newDescriptor.parameters) {
newDescriptor.parameters = modifyParameters(newDescriptor.parameters, 'path', config);
}
break;
case 'data':
if (newDescriptor.requestBody) {
newDescriptor.requestBody = modifySchemaProperties(newDescriptor.requestBody, config);
}
break;
case 'response':
if (newDescriptor.responses) {
newDescriptor.responses = modifySchemaProperties(newDescriptor.responses, config);
}
break;
default:
break;
}
return newDescriptor;
}
function payloadModifier(configs) {
return {
name: 'payloadModifier',
config(config) {
return (0, utils_1.extend)(config, {
handleApi: (apiDescriptor) => {
if (!apiDescriptor) {
return null;
}
// Apply each configuration in sequence
return configs.reduce((desc, conf) => {
if (!desc) {
return null;
}
return payloadModifierApiDescriptor(desc, conf);
}, apiDescriptor);
},
});
},
};
}
exports.default = payloadModifier;