@alova/wormhole
Version:
More modern openAPI generating solution for alova.js
126 lines (125 loc) • 3.97 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.filterApiDescriptor = filterApiDescriptor;
exports.apiFilter = apiFilter;
const logger_1 = require("../../helper/logger");
/**
* Tests if value matches the specified rule
*/
function isMatch(value, match) {
if (!match)
return true;
if (typeof match === 'string') {
return value.includes(match);
}
if (match instanceof RegExp) {
return match.test(value);
}
if (typeof match === 'function') {
try {
return match(value);
}
catch {
return false; // Return false on error to exclude the item
}
}
return false;
}
/**
* Extracts the corresponding property value from API descriptor based on scope
*/
function getApiProperty(apiDescriptor, scope) {
switch (scope) {
case 'url':
return apiDescriptor.url || '';
case 'tag':
// Assume tags exist in tags array, join with comma if multiple tags
return Array.isArray(apiDescriptor.tags) ? apiDescriptor.tags.join(',') : '';
default:
return '';
}
}
/**
* Applies filtering rules for a single configuration
* @param apiDescriptor API descriptor
* @param config Filter configuration
* @returns Whether it passes the filter (true means keep, false means filter out)
*/
function applyFilterRule(apiDescriptor, config) {
const scope = config.scope || 'url';
const value = getApiProperty(apiDescriptor, scope);
// Handle include and exclude logic
const includeMatch = config.include ? isMatch(value, config.include) : true;
const excludeMatch = config.exclude ? isMatch(value, config.exclude) : false;
// If both include and exclude are specified, exclude matching items from include
return includeMatch && !excludeMatch;
}
/**
* Handles union logic for multiple configurations
* @param apiDescriptor API descriptor
* @param configs Configuration array
* @returns Whether it passes the filter (true means keep, false means filter out)
*/
function combineFilterResults(apiDescriptor, configs) {
// If any configuration matches, keep the API (union logic)
return configs.some(config => applyFilterRule(apiDescriptor, config));
}
/**
* Main processing function for filtering API descriptors
* @param apiDescriptor API descriptor
* @param configs Configuration array
* @returns Filtered API descriptor, or null if filtered out
*/
function filterApiDescriptor(apiDescriptor, configs) {
if (!apiDescriptor)
return null;
// Use union logic to determine whether to keep the API
const shouldKeep = combineFilterResults(apiDescriptor, configs);
return shouldKeep ? apiDescriptor : null;
}
/**
* Creates a plugin for filtering APIs
*
* @param config Filter configuration, can be a single config or array of configs
* @returns API plugin instance
*
* @example
* ```ts
* // Only include URLs containing 'user'
* const userOnlyFilter = apiFilter({
* include: 'user'
* });
*
* // Exclude tags containing 'internal'
* const noInternalFilter = apiFilter({
* scope: 'tag',
* exclude: 'internal'
* });
*
* // Multi-condition filtering (union)
* const multiFilter = apiFilter([
* { include: 'user' },
* { include: 'admin' }
* ]);
* ```
*/
function apiFilter(config) {
const configs = Array.isArray(config) ? config : [config];
// Validate configuration
for (const conf of configs) {
if (!conf.include && !conf.exclude) {
throw logger_1.logger.throwError('at least one of `include` or `exclude` must be specified');
}
}
return {
name: 'filterApi',
extends: {
handleApi: (apiDescriptor) => {
if (!apiDescriptor)
return null;
return filterApiDescriptor(apiDescriptor, configs);
},
},
};
}
exports.default = apiFilter;