openapi-ts-mock-generator
Version:
typescript mock data generator based openapi
605 lines • 22.1 kB
JavaScript
;
function _array_like_to_array(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
return arr2;
}
function _array_with_holes(arr) {
if (Array.isArray(arr)) return arr;
}
function _array_without_holes(arr) {
if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _iterable_to_array_limit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally{
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally{
if (_d) throw _e;
}
}
return _arr;
}
function _non_iterable_rest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _non_iterable_spread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) {
symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
}
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = function(fn, res) {
return function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
};
var __export = function(target, all) {
for(var name in all)__defProp(target, name, {
get: all[name],
enumerable: true
});
};
var __copyProps = function(to, from, except, desc) {
if (from && typeof from === "object" || typeof from === "function") {
var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
try {
var _loop = function() {
var key = _step.value;
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
get: function() {
return from[key];
},
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
};
for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally{
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
return to;
};
var __toESM = function(mod, isNodeMode, target) {
return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod);
};
var __toCommonJS = function(mod) {
return __copyProps(__defProp({}, "__esModule", {
value: true
}), mod);
};
// src/core/types.ts
var HttpMethods, isNotNullish;
var init_types = __esm({
"src/core/types.ts": function() {
"use strict";
HttpMethods = /* @__PURE__ */ function(HttpMethods2) {
HttpMethods2["GET"] = "get";
HttpMethods2["PUT"] = "put";
HttpMethods2["POST"] = "post";
HttpMethods2["DELETE"] = "delete";
HttpMethods2["OPTIONS"] = "options";
HttpMethods2["HEAD"] = "head";
HttpMethods2["PATCH"] = "patch";
HttpMethods2["TRACE"] = "trace";
return HttpMethods2;
}(HttpMethods || {});
isNotNullish = function(value) {
return value !== null && value !== void 0;
};
}
});
// src/core/config.ts
var import_faker, defaultOptions, ARRAY_MIN_LENGTH, ARRAY_MAX_LENGTH, MIN_STRING_LENGTH, MAX_STRING_LENGTH, MIN_INTEGER, MAX_INTEGER, MIN_NUMBER, MAX_NUMBER, MIN_WORD_LENGTH, MAX_WORD_LENGTH, FAKER_SEED, faker, GEN_COMMENT;
var init_config = __esm({
"src/core/config.ts": function() {
"use strict";
import_faker = require("@faker-js/faker");
defaultOptions = {
path: "",
arrayMinLength: 1,
arrayMaxLength: 3,
includeCodes: void 0,
baseDir: "./",
specialPath: void 0,
handlerUrl: "*",
fakerLocale: "ko",
generateTarget: "api,schema",
clear: false,
// TypeScriptCodeOptions
isStatic: false,
isOptional: false
};
ARRAY_MIN_LENGTH = 1;
ARRAY_MAX_LENGTH = 3;
MIN_STRING_LENGTH = 3;
MAX_STRING_LENGTH = 20;
MIN_INTEGER = 1;
MAX_INTEGER = 1e5;
MIN_NUMBER = 0;
MAX_NUMBER = 100;
MIN_WORD_LENGTH = 0;
MAX_WORD_LENGTH = 3;
FAKER_SEED = 1;
faker = new import_faker.Faker({
locale: [
import_faker.ko
]
});
faker.seed(FAKER_SEED);
GEN_COMMENT = "/* Do not edit this file. */\n/* This file generated by openapi-ts-mock-generator. */\n\n";
}
});
// src/core/options.ts
var mergeOptions, transformCliOptions, validateOptions;
var init_options = __esm({
"src/core/options.ts": function() {
"use strict";
init_config();
mergeOptions = function(userOptions) {
return _object_spread({}, defaultOptions, userOptions);
};
transformCliOptions = function(rawOptions) {
return {
path: rawOptions.path || defaultOptions.path,
baseDir: rawOptions.baseDir || defaultOptions.baseDir,
arrayMinLength: parseInt(rawOptions.arrayMinLength) || defaultOptions.arrayMinLength,
arrayMaxLength: parseInt(rawOptions.arrayMaxLength) || defaultOptions.arrayMaxLength,
handlerUrl: rawOptions.handlerUrl || defaultOptions.handlerUrl,
fakerLocale: rawOptions.locales || defaultOptions.fakerLocale,
generateTarget: rawOptions.generateTarget || defaultOptions.generateTarget,
specialPath: rawOptions.specialPath || defaultOptions.specialPath,
clear: rawOptions.clear || defaultOptions.clear,
includeCodes: rawOptions.includeCodes ? rawOptions.includeCodes.toString().split(",").map(function(code) {
return parseInt(code);
}) : void 0,
// TypeScriptCodeOptions
isStatic: rawOptions.static || defaultOptions.isStatic,
isOptional: rawOptions.optional || defaultOptions.isOptional
};
};
validateOptions = function(options) {
var errors = [];
if (!options.path) {
errors.push("path is required");
}
if (options.arrayMinLength && options.arrayMaxLength && options.arrayMinLength > options.arrayMaxLength) {
errors.push("arrayMinLength should not be greater than arrayMaxLength");
}
if (options.generateTarget && !options.generateTarget.split(",").every(function(target) {
return [
"api",
"schema"
].includes(target.trim());
})) {
errors.push("generateTarget should contain only 'api' and/or 'schema'");
}
return errors;
};
}
});
// src/core/index.ts
var core_exports = {};
__export(core_exports, {
ARRAY_MAX_LENGTH: function() {
return ARRAY_MAX_LENGTH;
},
ARRAY_MIN_LENGTH: function() {
return ARRAY_MIN_LENGTH;
},
GEN_COMMENT: function() {
return GEN_COMMENT;
},
HttpMethods: function() {
return HttpMethods;
},
MAX_INTEGER: function() {
return MAX_INTEGER;
},
MAX_NUMBER: function() {
return MAX_NUMBER;
},
MAX_STRING_LENGTH: function() {
return MAX_STRING_LENGTH;
},
MAX_WORD_LENGTH: function() {
return MAX_WORD_LENGTH;
},
MIN_INTEGER: function() {
return MIN_INTEGER;
},
MIN_NUMBER: function() {
return MIN_NUMBER;
},
MIN_STRING_LENGTH: function() {
return MIN_STRING_LENGTH;
},
MIN_WORD_LENGTH: function() {
return MIN_WORD_LENGTH;
},
defaultOptions: function() {
return defaultOptions;
},
faker: function() {
return faker;
},
isNotNullish: function() {
return isNotNullish;
},
mergeOptions: function() {
return mergeOptions;
},
transformCliOptions: function() {
return transformCliOptions;
},
validateOptions: function() {
return validateOptions;
}
});
var init_core = __esm({
"src/core/index.ts": function() {
"use strict";
init_types();
init_config();
init_options();
}
});
// src/generators/faker-generator.ts
var faker_generator_exports = {};
__export(faker_generator_exports, {
generateCustomFakerConfig: function() {
return generateCustomFakerConfig;
},
generateDefaultFakerTemplate: function() {
return generateDefaultFakerTemplate;
},
generateFaker: function() {
return generateFaker;
},
generateSchemaFile: function() {
return generateSchemaFile;
},
getLocaleSpecificModules: function() {
return getLocaleSpecificModules;
},
validateFakerConfig: function() {
return validateFakerConfig;
}
});
module.exports = __toCommonJS(faker_generator_exports);
init_core();
// src/utils/code-utils.ts
var toTypeScriptCode = function(param, options) {
var _options_depth = options.depth, depth = _options_depth === void 0 ? 0 : _options_depth, isStatic = options.isStatic;
var prefixSpace = " ".repeat(depth * 2);
if (param === null) {
return "null";
}
if (Array.isArray(param)) {
var results = param.map(function(elem) {
return toTypeScriptCode(elem, _object_spread_props(_object_spread({}, options), {
depth: depth + 1
}));
}).join(",\n" + prefixSpace);
return [
"[",
results,
"]"
].join("\n" + prefixSpace);
}
if (typeof param === "object") {
var results1 = Object.entries(param).map(function(param) {
var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
return generateObjectProperty(key, value, options, prefixSpace);
}).join("\n" + prefixSpace);
return [
"{",
"".concat(results1),
"}"
].join("\n" + prefixSpace);
}
if (typeof param === "string") {
if (isStatic === false && (param.startsWith("faker") || param.startsWith("Buffer.from(faker"))) {
return param;
}
if (param.endsWith(" as const")) {
return '"'.concat(param.slice(0, -" as const".length), '" as const');
}
}
return JSON.stringify(param);
};
var shouldApplyNullableExtension = function(value, isOptional) {
if (!isOptional) return false;
if (value === null) return true;
if (typeof value === "string" && value.includes(",null")) {
return true;
}
return false;
};
var generateObjectProperty = function(key, value, options, prefixSpace) {
var isOptional = options.isOptional, _options_depth = options.depth, depth = _options_depth === void 0 ? 0 : _options_depth;
var shouldApplyNullable = shouldApplyNullableExtension(value, isOptional);
var nullableTypeExtensionStart = shouldApplyNullable ? "...(faker.datatype.boolean() ? {\n".concat(prefixSpace) : "";
var nullableTypeExtensionEnd = shouldApplyNullable ? "\n".concat(prefixSpace, "} : {})") : "";
var propertyValue = toTypeScriptCode(value, _object_spread_props(_object_spread({}, options), {
depth: depth + 1
}));
return "".concat(nullableTypeExtensionStart).concat(prefixSpace).concat(key, ": ").concat(propertyValue).concat(nullableTypeExtensionEnd, ",");
};
// src/utils/array-utils.ts
init_core();
// src/utils/file-utils.ts
var import_fs = require("fs");
var path = __toESM(require("path"));
var ensureDir = function(dirPath) {
if (!(0, import_fs.existsSync)(dirPath)) {
(0, import_fs.mkdirSync)(dirPath, {
recursive: true
});
}
};
var safeWriteFile = function(filePath, content) {
var dir = path.dirname(filePath);
ensureDir(dir);
(0, import_fs.writeFileSync)(filePath, content);
};
// src/generators/faker-generator.ts
var path2 = __toESM(require("path"));
var generateFaker = function(options) {
var _options_baseDir;
var directory = path2.join((_options_baseDir = options.baseDir) !== null && _options_baseDir !== void 0 ? _options_baseDir : "");
ensureDir(directory);
var content = generateFakerFileContent(options);
var _options_baseDir1;
var outputFileName = path2.join((_options_baseDir1 = options.baseDir) !== null && _options_baseDir1 !== void 0 ? _options_baseDir1 : "", "fakers.ts");
safeWriteFile(outputFileName, content);
console.log("Generated fakers ".concat(outputFileName));
};
var generateFakerFileContent = function(options) {
var _ref = (init_core(), __toCommonJS(core_exports)), GEN_COMMENT2 = _ref.GEN_COMMENT;
var localeOption = options.fakerLocale.replace(",", ", ");
var importFaker = "import { Faker, ".concat(localeOption, ' } from "@faker-js/faker"\n\n');
var fakerDeclare = [
"export const faker = new Faker({",
" locale: [".concat(localeOption, "]"),
"})"
].join("\n");
return GEN_COMMENT2 + importFaker + fakerDeclare;
};
var generateSchemaFile = function(schemas, options) {
var generatedVars = Object.entries(schemas).map(function(param) {
var _param = _sliced_to_array(param, 2), varName = _param[0], varValue = _param[1];
return "export const ".concat(varName, "Mock = ").concat(toTypeScriptCode(varValue, _object_spread({
depth: 0
}, options)));
}).join("\n\n");
var importFaker = options.isStatic ? "" : 'import { faker } from "./fakers"\n\n';
var content = GEN_COMMENT + importFaker + generatedVars;
var _options_baseDir;
var outputFileName = path2.join((_options_baseDir = options.baseDir) !== null && _options_baseDir !== void 0 ? _options_baseDir : "", "schemas.ts");
safeWriteFile(outputFileName, content);
console.log("Generated schema ".concat(outputFileName));
};
var generateCustomFakerConfig = function(titleConfig, descriptionConfig, options) {
if (!options.specialPath) return;
var _options_baseDir;
var specialDir = path2.join((_options_baseDir = options.baseDir) !== null && _options_baseDir !== void 0 ? _options_baseDir : "", options.specialPath);
ensureDir(specialDir);
var titlesPath = path2.join(specialDir, "titles.json");
safeWriteFile(titlesPath, JSON.stringify(titleConfig, null, 2));
console.log("Generated custom faker titles config: ".concat(titlesPath));
var descriptionsPath = path2.join(specialDir, "descriptions.json");
safeWriteFile(descriptionsPath, JSON.stringify(descriptionConfig, null, 2));
console.log("Generated custom faker descriptions config: ".concat(descriptionsPath));
};
var validateFakerConfig = function(config) {
var errors = [];
Object.entries(config).forEach(function(param) {
var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
if (typeof value !== "object") {
errors.push('Config for "'.concat(key, '" must be an object'));
return;
}
if ("module" in value && "type" in value) {
if (typeof value.module !== "string") {
errors.push('Module for "'.concat(key, '" must be a string'));
}
if (typeof value.type !== "string") {
errors.push('Type for "'.concat(key, '" must be a string'));
}
} else if (!("value" in value)) {
errors.push('Config for "'.concat(key, '" must have either "value" or "module"+"type"'));
}
});
return {
isValid: errors.length === 0,
errors: errors
};
};
var generateDefaultFakerTemplate = function() {
return {
titles: {
"User ID": {
module: "string",
type: "uuid"
},
Email: {
module: "internet",
type: "email"
},
Name: {
module: "person",
type: "fullName"
}
},
descriptions: {
"\uC0AC\uC6A9\uC790 \uC774\uBA54\uC77C": {
module: "internet",
type: "email"
},
"\uC0AC\uC6A9\uC790 \uC774\uB984": {
module: "person",
type: "fullName",
options: {
locale: "ko"
}
},
전화번호: {
module: "phone",
type: "number"
}
}
};
};
var getLocaleSpecificModules = function(locale) {
var commonModules = [
"datatype",
"date",
"finance",
"git",
"hacker",
"helpers",
"image",
"internet",
"lorem",
"music",
"person",
"phone",
"random",
"system",
"vehicle"
];
var localeModules = {
ko: [
"person",
"phone",
"address"
],
en: [
"person",
"phone",
"address",
"company"
],
ja: [
"person",
"phone",
"address"
]
};
return _to_consumable_array(commonModules).concat(_to_consumable_array(localeModules[locale] || []));
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
generateCustomFakerConfig: generateCustomFakerConfig,
generateDefaultFakerTemplate: generateDefaultFakerTemplate,
generateFaker: generateFaker,
generateSchemaFile: generateSchemaFile,
getLocaleSpecificModules: getLocaleSpecificModules,
validateFakerConfig: validateFakerConfig
});
//# sourceMappingURL=faker-generator.js.map