1539 lines
53 KiB
JavaScript
1539 lines
53 KiB
JavaScript
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 __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var __decorateClass = (decorators, target, key, kind) => {
|
|
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
|
|
for (var i = decorators.length - 1, decorator; i >= 0; i--)
|
|
if (decorator = decorators[i])
|
|
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
|
|
if (kind && result)
|
|
__defProp(target, key, result);
|
|
return result;
|
|
};
|
|
|
|
// node_modules/reflect-metadata/Reflect.js
|
|
var require_Reflect = __commonJS({
|
|
"node_modules/reflect-metadata/Reflect.js"() {
|
|
var Reflect2;
|
|
(function(Reflect3) {
|
|
(function(factory) {
|
|
var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
|
|
var exporter = makeExporter(Reflect3);
|
|
if (typeof root.Reflect !== "undefined") {
|
|
exporter = makeExporter(root.Reflect, exporter);
|
|
}
|
|
factory(exporter, root);
|
|
if (typeof root.Reflect === "undefined") {
|
|
root.Reflect = Reflect3;
|
|
}
|
|
function makeExporter(target, previous) {
|
|
return function(key, value) {
|
|
Object.defineProperty(target, key, { configurable: true, writable: true, value });
|
|
if (previous)
|
|
previous(key, value);
|
|
};
|
|
}
|
|
function functionThis() {
|
|
try {
|
|
return Function("return this;")();
|
|
} catch (_) {
|
|
}
|
|
}
|
|
function indirectEvalThis() {
|
|
try {
|
|
return (void 0, eval)("(function() { return this; })()");
|
|
} catch (_) {
|
|
}
|
|
}
|
|
function sloppyModeThis() {
|
|
return functionThis() || indirectEvalThis();
|
|
}
|
|
})(function(exporter, root) {
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var supportsSymbol = typeof Symbol === "function";
|
|
var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
|
|
var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
|
|
var supportsCreate = typeof Object.create === "function";
|
|
var supportsProto = { __proto__: [] } instanceof Array;
|
|
var downLevel = !supportsCreate && !supportsProto;
|
|
var HashMap = {
|
|
// create an object in dictionary mode (a.k.a. "slow" mode in v8)
|
|
create: supportsCreate ? function() {
|
|
return MakeDictionary(/* @__PURE__ */ Object.create(null));
|
|
} : supportsProto ? function() {
|
|
return MakeDictionary({ __proto__: null });
|
|
} : function() {
|
|
return MakeDictionary({});
|
|
},
|
|
has: downLevel ? function(map, key) {
|
|
return hasOwn.call(map, key);
|
|
} : function(map, key) {
|
|
return key in map;
|
|
},
|
|
get: downLevel ? function(map, key) {
|
|
return hasOwn.call(map, key) ? map[key] : void 0;
|
|
} : function(map, key) {
|
|
return map[key];
|
|
}
|
|
};
|
|
var functionPrototype = Object.getPrototypeOf(Function);
|
|
var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
|
|
var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
|
|
var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
|
|
var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
|
|
var metadataRegistry = GetOrCreateMetadataRegistry();
|
|
var metadataProvider = CreateMetadataProvider(metadataRegistry);
|
|
function decorate(decorators, target, propertyKey, attributes) {
|
|
if (!IsUndefined(propertyKey)) {
|
|
if (!IsArray(decorators))
|
|
throw new TypeError();
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
|
|
throw new TypeError();
|
|
if (IsNull(attributes))
|
|
attributes = void 0;
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return DecorateProperty(decorators, target, propertyKey, attributes);
|
|
} else {
|
|
if (!IsArray(decorators))
|
|
throw new TypeError();
|
|
if (!IsConstructor(target))
|
|
throw new TypeError();
|
|
return DecorateConstructor(decorators, target);
|
|
}
|
|
}
|
|
exporter("decorate", decorate);
|
|
function metadata(metadataKey, metadataValue) {
|
|
function decorator(target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
|
|
throw new TypeError();
|
|
OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
|
|
}
|
|
return decorator;
|
|
}
|
|
exporter("metadata", metadata);
|
|
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
|
|
}
|
|
exporter("defineMetadata", defineMetadata);
|
|
function hasMetadata(metadataKey, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryHasMetadata(metadataKey, target, propertyKey);
|
|
}
|
|
exporter("hasMetadata", hasMetadata);
|
|
function hasOwnMetadata(metadataKey, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
|
|
}
|
|
exporter("hasOwnMetadata", hasOwnMetadata);
|
|
function getMetadata(metadataKey, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryGetMetadata(metadataKey, target, propertyKey);
|
|
}
|
|
exporter("getMetadata", getMetadata);
|
|
function getOwnMetadata(metadataKey, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
|
|
}
|
|
exporter("getOwnMetadata", getOwnMetadata);
|
|
function getMetadataKeys(target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryMetadataKeys(target, propertyKey);
|
|
}
|
|
exporter("getMetadataKeys", getMetadataKeys);
|
|
function getOwnMetadataKeys(target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
return OrdinaryOwnMetadataKeys(target, propertyKey);
|
|
}
|
|
exporter("getOwnMetadataKeys", getOwnMetadataKeys);
|
|
function deleteMetadata(metadataKey, target, propertyKey) {
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
if (!IsObject(target))
|
|
throw new TypeError();
|
|
if (!IsUndefined(propertyKey))
|
|
propertyKey = ToPropertyKey(propertyKey);
|
|
var provider = GetMetadataProvider(
|
|
target,
|
|
propertyKey,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(provider))
|
|
return false;
|
|
return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
|
|
}
|
|
exporter("deleteMetadata", deleteMetadata);
|
|
function DecorateConstructor(decorators, target) {
|
|
for (var i = decorators.length - 1; i >= 0; --i) {
|
|
var decorator = decorators[i];
|
|
var decorated = decorator(target);
|
|
if (!IsUndefined(decorated) && !IsNull(decorated)) {
|
|
if (!IsConstructor(decorated))
|
|
throw new TypeError();
|
|
target = decorated;
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function DecorateProperty(decorators, target, propertyKey, descriptor) {
|
|
for (var i = decorators.length - 1; i >= 0; --i) {
|
|
var decorator = decorators[i];
|
|
var decorated = decorator(target, propertyKey, descriptor);
|
|
if (!IsUndefined(decorated) && !IsNull(decorated)) {
|
|
if (!IsObject(decorated))
|
|
throw new TypeError();
|
|
descriptor = decorated;
|
|
}
|
|
}
|
|
return descriptor;
|
|
}
|
|
function OrdinaryHasMetadata(MetadataKey, O, P) {
|
|
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
|
|
if (hasOwn2)
|
|
return true;
|
|
var parent = OrdinaryGetPrototypeOf(O);
|
|
if (!IsNull(parent))
|
|
return OrdinaryHasMetadata(MetadataKey, parent, P);
|
|
return false;
|
|
}
|
|
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
|
|
var provider = GetMetadataProvider(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(provider))
|
|
return false;
|
|
return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
|
|
}
|
|
function OrdinaryGetMetadata(MetadataKey, O, P) {
|
|
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
|
|
if (hasOwn2)
|
|
return OrdinaryGetOwnMetadata(MetadataKey, O, P);
|
|
var parent = OrdinaryGetPrototypeOf(O);
|
|
if (!IsNull(parent))
|
|
return OrdinaryGetMetadata(MetadataKey, parent, P);
|
|
return void 0;
|
|
}
|
|
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
|
|
var provider = GetMetadataProvider(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(provider))
|
|
return;
|
|
return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
|
|
}
|
|
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
|
|
var provider = GetMetadataProvider(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
true
|
|
);
|
|
provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
|
|
}
|
|
function OrdinaryMetadataKeys(O, P) {
|
|
var ownKeys = OrdinaryOwnMetadataKeys(O, P);
|
|
var parent = OrdinaryGetPrototypeOf(O);
|
|
if (parent === null)
|
|
return ownKeys;
|
|
var parentKeys = OrdinaryMetadataKeys(parent, P);
|
|
if (parentKeys.length <= 0)
|
|
return ownKeys;
|
|
if (ownKeys.length <= 0)
|
|
return parentKeys;
|
|
var set = new _Set();
|
|
var keys = [];
|
|
for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
|
|
var key = ownKeys_1[_i];
|
|
var hasKey = set.has(key);
|
|
if (!hasKey) {
|
|
set.add(key);
|
|
keys.push(key);
|
|
}
|
|
}
|
|
for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
|
|
var key = parentKeys_1[_a];
|
|
var hasKey = set.has(key);
|
|
if (!hasKey) {
|
|
set.add(key);
|
|
keys.push(key);
|
|
}
|
|
}
|
|
return keys;
|
|
}
|
|
function OrdinaryOwnMetadataKeys(O, P) {
|
|
var provider = GetMetadataProvider(
|
|
O,
|
|
P,
|
|
/*create*/
|
|
false
|
|
);
|
|
if (!provider) {
|
|
return [];
|
|
}
|
|
return provider.OrdinaryOwnMetadataKeys(O, P);
|
|
}
|
|
function Type(x) {
|
|
if (x === null)
|
|
return 1;
|
|
switch (typeof x) {
|
|
case "undefined":
|
|
return 0;
|
|
case "boolean":
|
|
return 2;
|
|
case "string":
|
|
return 3;
|
|
case "symbol":
|
|
return 4;
|
|
case "number":
|
|
return 5;
|
|
case "object":
|
|
return x === null ? 1 : 6;
|
|
default:
|
|
return 6;
|
|
}
|
|
}
|
|
function IsUndefined(x) {
|
|
return x === void 0;
|
|
}
|
|
function IsNull(x) {
|
|
return x === null;
|
|
}
|
|
function IsSymbol(x) {
|
|
return typeof x === "symbol";
|
|
}
|
|
function IsObject(x) {
|
|
return typeof x === "object" ? x !== null : typeof x === "function";
|
|
}
|
|
function ToPrimitive(input, PreferredType) {
|
|
switch (Type(input)) {
|
|
case 0:
|
|
return input;
|
|
case 1:
|
|
return input;
|
|
case 2:
|
|
return input;
|
|
case 3:
|
|
return input;
|
|
case 4:
|
|
return input;
|
|
case 5:
|
|
return input;
|
|
}
|
|
var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
|
|
var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
|
|
if (exoticToPrim !== void 0) {
|
|
var result = exoticToPrim.call(input, hint);
|
|
if (IsObject(result))
|
|
throw new TypeError();
|
|
return result;
|
|
}
|
|
return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
|
|
}
|
|
function OrdinaryToPrimitive(O, hint) {
|
|
if (hint === "string") {
|
|
var toString_1 = O.toString;
|
|
if (IsCallable(toString_1)) {
|
|
var result = toString_1.call(O);
|
|
if (!IsObject(result))
|
|
return result;
|
|
}
|
|
var valueOf = O.valueOf;
|
|
if (IsCallable(valueOf)) {
|
|
var result = valueOf.call(O);
|
|
if (!IsObject(result))
|
|
return result;
|
|
}
|
|
} else {
|
|
var valueOf = O.valueOf;
|
|
if (IsCallable(valueOf)) {
|
|
var result = valueOf.call(O);
|
|
if (!IsObject(result))
|
|
return result;
|
|
}
|
|
var toString_2 = O.toString;
|
|
if (IsCallable(toString_2)) {
|
|
var result = toString_2.call(O);
|
|
if (!IsObject(result))
|
|
return result;
|
|
}
|
|
}
|
|
throw new TypeError();
|
|
}
|
|
function ToBoolean(argument) {
|
|
return !!argument;
|
|
}
|
|
function ToString(argument) {
|
|
return "" + argument;
|
|
}
|
|
function ToPropertyKey(argument) {
|
|
var key = ToPrimitive(
|
|
argument,
|
|
3
|
|
/* String */
|
|
);
|
|
if (IsSymbol(key))
|
|
return key;
|
|
return ToString(key);
|
|
}
|
|
function IsArray(argument) {
|
|
return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
|
|
}
|
|
function IsCallable(argument) {
|
|
return typeof argument === "function";
|
|
}
|
|
function IsConstructor(argument) {
|
|
return typeof argument === "function";
|
|
}
|
|
function IsPropertyKey(argument) {
|
|
switch (Type(argument)) {
|
|
case 3:
|
|
return true;
|
|
case 4:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function SameValueZero(x, y) {
|
|
return x === y || x !== x && y !== y;
|
|
}
|
|
function GetMethod(V, P) {
|
|
var func = V[P];
|
|
if (func === void 0 || func === null)
|
|
return void 0;
|
|
if (!IsCallable(func))
|
|
throw new TypeError();
|
|
return func;
|
|
}
|
|
function GetIterator(obj) {
|
|
var method = GetMethod(obj, iteratorSymbol);
|
|
if (!IsCallable(method))
|
|
throw new TypeError();
|
|
var iterator = method.call(obj);
|
|
if (!IsObject(iterator))
|
|
throw new TypeError();
|
|
return iterator;
|
|
}
|
|
function IteratorValue(iterResult) {
|
|
return iterResult.value;
|
|
}
|
|
function IteratorStep(iterator) {
|
|
var result = iterator.next();
|
|
return result.done ? false : result;
|
|
}
|
|
function IteratorClose(iterator) {
|
|
var f = iterator["return"];
|
|
if (f)
|
|
f.call(iterator);
|
|
}
|
|
function OrdinaryGetPrototypeOf(O) {
|
|
var proto = Object.getPrototypeOf(O);
|
|
if (typeof O !== "function" || O === functionPrototype)
|
|
return proto;
|
|
if (proto !== functionPrototype)
|
|
return proto;
|
|
var prototype = O.prototype;
|
|
var prototypeProto = prototype && Object.getPrototypeOf(prototype);
|
|
if (prototypeProto == null || prototypeProto === Object.prototype)
|
|
return proto;
|
|
var constructor = prototypeProto.constructor;
|
|
if (typeof constructor !== "function")
|
|
return proto;
|
|
if (constructor === O)
|
|
return proto;
|
|
return constructor;
|
|
}
|
|
function CreateMetadataRegistry() {
|
|
var fallback;
|
|
if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
|
|
fallback = CreateFallbackProvider(root.Reflect);
|
|
}
|
|
var first;
|
|
var second;
|
|
var rest;
|
|
var targetProviderMap = new _WeakMap();
|
|
var registry = {
|
|
registerProvider,
|
|
getProvider,
|
|
setProvider
|
|
};
|
|
return registry;
|
|
function registerProvider(provider) {
|
|
if (!Object.isExtensible(registry)) {
|
|
throw new Error("Cannot add provider to a frozen registry.");
|
|
}
|
|
switch (true) {
|
|
case fallback === provider:
|
|
break;
|
|
case IsUndefined(first):
|
|
first = provider;
|
|
break;
|
|
case first === provider:
|
|
break;
|
|
case IsUndefined(second):
|
|
second = provider;
|
|
break;
|
|
case second === provider:
|
|
break;
|
|
default:
|
|
if (rest === void 0)
|
|
rest = new _Set();
|
|
rest.add(provider);
|
|
break;
|
|
}
|
|
}
|
|
function getProviderNoCache(O, P) {
|
|
if (!IsUndefined(first)) {
|
|
if (first.isProviderFor(O, P))
|
|
return first;
|
|
if (!IsUndefined(second)) {
|
|
if (second.isProviderFor(O, P))
|
|
return first;
|
|
if (!IsUndefined(rest)) {
|
|
var iterator = GetIterator(rest);
|
|
while (true) {
|
|
var next = IteratorStep(iterator);
|
|
if (!next) {
|
|
return void 0;
|
|
}
|
|
var provider = IteratorValue(next);
|
|
if (provider.isProviderFor(O, P)) {
|
|
IteratorClose(iterator);
|
|
return provider;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
|
|
return fallback;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getProvider(O, P) {
|
|
var providerMap = targetProviderMap.get(O);
|
|
var provider;
|
|
if (!IsUndefined(providerMap)) {
|
|
provider = providerMap.get(P);
|
|
}
|
|
if (!IsUndefined(provider)) {
|
|
return provider;
|
|
}
|
|
provider = getProviderNoCache(O, P);
|
|
if (!IsUndefined(provider)) {
|
|
if (IsUndefined(providerMap)) {
|
|
providerMap = new _Map();
|
|
targetProviderMap.set(O, providerMap);
|
|
}
|
|
providerMap.set(P, provider);
|
|
}
|
|
return provider;
|
|
}
|
|
function hasProvider(provider) {
|
|
if (IsUndefined(provider))
|
|
throw new TypeError();
|
|
return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
|
|
}
|
|
function setProvider(O, P, provider) {
|
|
if (!hasProvider(provider)) {
|
|
throw new Error("Metadata provider not registered.");
|
|
}
|
|
var existingProvider = getProvider(O, P);
|
|
if (existingProvider !== provider) {
|
|
if (!IsUndefined(existingProvider)) {
|
|
return false;
|
|
}
|
|
var providerMap = targetProviderMap.get(O);
|
|
if (IsUndefined(providerMap)) {
|
|
providerMap = new _Map();
|
|
targetProviderMap.set(O, providerMap);
|
|
}
|
|
providerMap.set(P, provider);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function GetOrCreateMetadataRegistry() {
|
|
var metadataRegistry2;
|
|
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
|
|
metadataRegistry2 = root.Reflect[registrySymbol];
|
|
}
|
|
if (IsUndefined(metadataRegistry2)) {
|
|
metadataRegistry2 = CreateMetadataRegistry();
|
|
}
|
|
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
|
|
Object.defineProperty(root.Reflect, registrySymbol, {
|
|
enumerable: false,
|
|
configurable: false,
|
|
writable: false,
|
|
value: metadataRegistry2
|
|
});
|
|
}
|
|
return metadataRegistry2;
|
|
}
|
|
function CreateMetadataProvider(registry) {
|
|
var metadata2 = new _WeakMap();
|
|
var provider = {
|
|
isProviderFor: function(O, P) {
|
|
var targetMetadata = metadata2.get(O);
|
|
if (IsUndefined(targetMetadata))
|
|
return false;
|
|
return targetMetadata.has(P);
|
|
},
|
|
OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
|
|
OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
|
|
OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
|
|
OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
|
|
OrdinaryDeleteMetadata
|
|
};
|
|
metadataRegistry.registerProvider(provider);
|
|
return provider;
|
|
function GetOrCreateMetadataMap(O, P, Create) {
|
|
var targetMetadata = metadata2.get(O);
|
|
var createdTargetMetadata = false;
|
|
if (IsUndefined(targetMetadata)) {
|
|
if (!Create)
|
|
return void 0;
|
|
targetMetadata = new _Map();
|
|
metadata2.set(O, targetMetadata);
|
|
createdTargetMetadata = true;
|
|
}
|
|
var metadataMap = targetMetadata.get(P);
|
|
if (IsUndefined(metadataMap)) {
|
|
if (!Create)
|
|
return void 0;
|
|
metadataMap = new _Map();
|
|
targetMetadata.set(P, metadataMap);
|
|
if (!registry.setProvider(O, P, provider)) {
|
|
targetMetadata.delete(P);
|
|
if (createdTargetMetadata) {
|
|
metadata2.delete(O);
|
|
}
|
|
throw new Error("Wrong provider for target.");
|
|
}
|
|
}
|
|
return metadataMap;
|
|
}
|
|
function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(metadataMap))
|
|
return false;
|
|
return ToBoolean(metadataMap.has(MetadataKey));
|
|
}
|
|
function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(metadataMap))
|
|
return void 0;
|
|
return metadataMap.get(MetadataKey);
|
|
}
|
|
function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
true
|
|
);
|
|
metadataMap.set(MetadataKey, MetadataValue);
|
|
}
|
|
function OrdinaryOwnMetadataKeys2(O, P) {
|
|
var keys = [];
|
|
var metadataMap = GetOrCreateMetadataMap(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(metadataMap))
|
|
return keys;
|
|
var keysObj = metadataMap.keys();
|
|
var iterator = GetIterator(keysObj);
|
|
var k = 0;
|
|
while (true) {
|
|
var next = IteratorStep(iterator);
|
|
if (!next) {
|
|
keys.length = k;
|
|
return keys;
|
|
}
|
|
var nextValue = IteratorValue(next);
|
|
try {
|
|
keys[k] = nextValue;
|
|
} catch (e) {
|
|
try {
|
|
IteratorClose(iterator);
|
|
} finally {
|
|
throw e;
|
|
}
|
|
}
|
|
k++;
|
|
}
|
|
}
|
|
function OrdinaryDeleteMetadata(MetadataKey, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(
|
|
O,
|
|
P,
|
|
/*Create*/
|
|
false
|
|
);
|
|
if (IsUndefined(metadataMap))
|
|
return false;
|
|
if (!metadataMap.delete(MetadataKey))
|
|
return false;
|
|
if (metadataMap.size === 0) {
|
|
var targetMetadata = metadata2.get(O);
|
|
if (!IsUndefined(targetMetadata)) {
|
|
targetMetadata.delete(P);
|
|
if (targetMetadata.size === 0) {
|
|
metadata2.delete(targetMetadata);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function CreateFallbackProvider(reflect) {
|
|
var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
|
|
var metadataOwner = new _WeakMap();
|
|
var provider = {
|
|
isProviderFor: function(O, P) {
|
|
var metadataPropertySet = metadataOwner.get(O);
|
|
if (!IsUndefined(metadataPropertySet)) {
|
|
return metadataPropertySet.has(P);
|
|
}
|
|
if (getOwnMetadataKeys2(O, P).length) {
|
|
if (IsUndefined(metadataPropertySet)) {
|
|
metadataPropertySet = new _Set();
|
|
metadataOwner.set(O, metadataPropertySet);
|
|
}
|
|
metadataPropertySet.add(P);
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
OrdinaryDefineOwnMetadata: defineMetadata2,
|
|
OrdinaryHasOwnMetadata: hasOwnMetadata2,
|
|
OrdinaryGetOwnMetadata: getOwnMetadata2,
|
|
OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
|
|
OrdinaryDeleteMetadata: deleteMetadata2
|
|
};
|
|
return provider;
|
|
}
|
|
function GetMetadataProvider(O, P, Create) {
|
|
var registeredProvider = metadataRegistry.getProvider(O, P);
|
|
if (!IsUndefined(registeredProvider)) {
|
|
return registeredProvider;
|
|
}
|
|
if (Create) {
|
|
if (metadataRegistry.setProvider(O, P, metadataProvider)) {
|
|
return metadataProvider;
|
|
}
|
|
throw new Error("Illegal state.");
|
|
}
|
|
return void 0;
|
|
}
|
|
function CreateMapPolyfill() {
|
|
var cacheSentinel = {};
|
|
var arraySentinel = [];
|
|
var MapIterator = (
|
|
/** @class */
|
|
function() {
|
|
function MapIterator2(keys, values, selector) {
|
|
this._index = 0;
|
|
this._keys = keys;
|
|
this._values = values;
|
|
this._selector = selector;
|
|
}
|
|
MapIterator2.prototype["@@iterator"] = function() {
|
|
return this;
|
|
};
|
|
MapIterator2.prototype[iteratorSymbol] = function() {
|
|
return this;
|
|
};
|
|
MapIterator2.prototype.next = function() {
|
|
var index2 = this._index;
|
|
if (index2 >= 0 && index2 < this._keys.length) {
|
|
var result = this._selector(this._keys[index2], this._values[index2]);
|
|
if (index2 + 1 >= this._keys.length) {
|
|
this._index = -1;
|
|
this._keys = arraySentinel;
|
|
this._values = arraySentinel;
|
|
} else {
|
|
this._index++;
|
|
}
|
|
return { value: result, done: false };
|
|
}
|
|
return { value: void 0, done: true };
|
|
};
|
|
MapIterator2.prototype.throw = function(error) {
|
|
if (this._index >= 0) {
|
|
this._index = -1;
|
|
this._keys = arraySentinel;
|
|
this._values = arraySentinel;
|
|
}
|
|
throw error;
|
|
};
|
|
MapIterator2.prototype.return = function(value) {
|
|
if (this._index >= 0) {
|
|
this._index = -1;
|
|
this._keys = arraySentinel;
|
|
this._values = arraySentinel;
|
|
}
|
|
return { value, done: true };
|
|
};
|
|
return MapIterator2;
|
|
}()
|
|
);
|
|
var Map2 = (
|
|
/** @class */
|
|
function() {
|
|
function Map3() {
|
|
this._keys = [];
|
|
this._values = [];
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
}
|
|
Object.defineProperty(Map3.prototype, "size", {
|
|
get: function() {
|
|
return this._keys.length;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Map3.prototype.has = function(key) {
|
|
return this._find(
|
|
key,
|
|
/*insert*/
|
|
false
|
|
) >= 0;
|
|
};
|
|
Map3.prototype.get = function(key) {
|
|
var index2 = this._find(
|
|
key,
|
|
/*insert*/
|
|
false
|
|
);
|
|
return index2 >= 0 ? this._values[index2] : void 0;
|
|
};
|
|
Map3.prototype.set = function(key, value) {
|
|
var index2 = this._find(
|
|
key,
|
|
/*insert*/
|
|
true
|
|
);
|
|
this._values[index2] = value;
|
|
return this;
|
|
};
|
|
Map3.prototype.delete = function(key) {
|
|
var index2 = this._find(
|
|
key,
|
|
/*insert*/
|
|
false
|
|
);
|
|
if (index2 >= 0) {
|
|
var size = this._keys.length;
|
|
for (var i = index2 + 1; i < size; i++) {
|
|
this._keys[i - 1] = this._keys[i];
|
|
this._values[i - 1] = this._values[i];
|
|
}
|
|
this._keys.length--;
|
|
this._values.length--;
|
|
if (SameValueZero(key, this._cacheKey)) {
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
Map3.prototype.clear = function() {
|
|
this._keys.length = 0;
|
|
this._values.length = 0;
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
};
|
|
Map3.prototype.keys = function() {
|
|
return new MapIterator(this._keys, this._values, getKey);
|
|
};
|
|
Map3.prototype.values = function() {
|
|
return new MapIterator(this._keys, this._values, getValue);
|
|
};
|
|
Map3.prototype.entries = function() {
|
|
return new MapIterator(this._keys, this._values, getEntry);
|
|
};
|
|
Map3.prototype["@@iterator"] = function() {
|
|
return this.entries();
|
|
};
|
|
Map3.prototype[iteratorSymbol] = function() {
|
|
return this.entries();
|
|
};
|
|
Map3.prototype._find = function(key, insert) {
|
|
if (!SameValueZero(this._cacheKey, key)) {
|
|
this._cacheIndex = -1;
|
|
for (var i = 0; i < this._keys.length; i++) {
|
|
if (SameValueZero(this._keys[i], key)) {
|
|
this._cacheIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (this._cacheIndex < 0 && insert) {
|
|
this._cacheIndex = this._keys.length;
|
|
this._keys.push(key);
|
|
this._values.push(void 0);
|
|
}
|
|
return this._cacheIndex;
|
|
};
|
|
return Map3;
|
|
}()
|
|
);
|
|
return Map2;
|
|
function getKey(key, _) {
|
|
return key;
|
|
}
|
|
function getValue(_, value) {
|
|
return value;
|
|
}
|
|
function getEntry(key, value) {
|
|
return [key, value];
|
|
}
|
|
}
|
|
function CreateSetPolyfill() {
|
|
var Set2 = (
|
|
/** @class */
|
|
function() {
|
|
function Set3() {
|
|
this._map = new _Map();
|
|
}
|
|
Object.defineProperty(Set3.prototype, "size", {
|
|
get: function() {
|
|
return this._map.size;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Set3.prototype.has = function(value) {
|
|
return this._map.has(value);
|
|
};
|
|
Set3.prototype.add = function(value) {
|
|
return this._map.set(value, value), this;
|
|
};
|
|
Set3.prototype.delete = function(value) {
|
|
return this._map.delete(value);
|
|
};
|
|
Set3.prototype.clear = function() {
|
|
this._map.clear();
|
|
};
|
|
Set3.prototype.keys = function() {
|
|
return this._map.keys();
|
|
};
|
|
Set3.prototype.values = function() {
|
|
return this._map.keys();
|
|
};
|
|
Set3.prototype.entries = function() {
|
|
return this._map.entries();
|
|
};
|
|
Set3.prototype["@@iterator"] = function() {
|
|
return this.keys();
|
|
};
|
|
Set3.prototype[iteratorSymbol] = function() {
|
|
return this.keys();
|
|
};
|
|
return Set3;
|
|
}()
|
|
);
|
|
return Set2;
|
|
}
|
|
function CreateWeakMapPolyfill() {
|
|
var UUID_SIZE = 16;
|
|
var keys = HashMap.create();
|
|
var rootKey = CreateUniqueKey();
|
|
return (
|
|
/** @class */
|
|
function() {
|
|
function WeakMap2() {
|
|
this._key = CreateUniqueKey();
|
|
}
|
|
WeakMap2.prototype.has = function(target) {
|
|
var table = GetOrCreateWeakMapTable(
|
|
target,
|
|
/*create*/
|
|
false
|
|
);
|
|
return table !== void 0 ? HashMap.has(table, this._key) : false;
|
|
};
|
|
WeakMap2.prototype.get = function(target) {
|
|
var table = GetOrCreateWeakMapTable(
|
|
target,
|
|
/*create*/
|
|
false
|
|
);
|
|
return table !== void 0 ? HashMap.get(table, this._key) : void 0;
|
|
};
|
|
WeakMap2.prototype.set = function(target, value) {
|
|
var table = GetOrCreateWeakMapTable(
|
|
target,
|
|
/*create*/
|
|
true
|
|
);
|
|
table[this._key] = value;
|
|
return this;
|
|
};
|
|
WeakMap2.prototype.delete = function(target) {
|
|
var table = GetOrCreateWeakMapTable(
|
|
target,
|
|
/*create*/
|
|
false
|
|
);
|
|
return table !== void 0 ? delete table[this._key] : false;
|
|
};
|
|
WeakMap2.prototype.clear = function() {
|
|
this._key = CreateUniqueKey();
|
|
};
|
|
return WeakMap2;
|
|
}()
|
|
);
|
|
function CreateUniqueKey() {
|
|
var key;
|
|
do
|
|
key = "@@WeakMap@@" + CreateUUID();
|
|
while (HashMap.has(keys, key));
|
|
keys[key] = true;
|
|
return key;
|
|
}
|
|
function GetOrCreateWeakMapTable(target, create) {
|
|
if (!hasOwn.call(target, rootKey)) {
|
|
if (!create)
|
|
return void 0;
|
|
Object.defineProperty(target, rootKey, { value: HashMap.create() });
|
|
}
|
|
return target[rootKey];
|
|
}
|
|
function FillRandomBytes(buffer, size) {
|
|
for (var i = 0; i < size; ++i)
|
|
buffer[i] = Math.random() * 255 | 0;
|
|
return buffer;
|
|
}
|
|
function GenRandomBytes(size) {
|
|
if (typeof Uint8Array === "function") {
|
|
if (typeof crypto !== "undefined")
|
|
return crypto.getRandomValues(new Uint8Array(size));
|
|
if (typeof msCrypto !== "undefined")
|
|
return msCrypto.getRandomValues(new Uint8Array(size));
|
|
return FillRandomBytes(new Uint8Array(size), size);
|
|
}
|
|
return FillRandomBytes(new Array(size), size);
|
|
}
|
|
function CreateUUID() {
|
|
var data = GenRandomBytes(UUID_SIZE);
|
|
data[6] = data[6] & 79 | 64;
|
|
data[8] = data[8] & 191 | 128;
|
|
var result = "";
|
|
for (var offset = 0; offset < UUID_SIZE; ++offset) {
|
|
var byte = data[offset];
|
|
if (offset === 4 || offset === 6 || offset === 8)
|
|
result += "-";
|
|
if (byte < 16)
|
|
result += "0";
|
|
result += byte.toString(16).toLowerCase();
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function MakeDictionary(obj) {
|
|
obj.__ = void 0;
|
|
delete obj.__;
|
|
return obj;
|
|
}
|
|
});
|
|
})(Reflect2 || (Reflect2 = {}));
|
|
}
|
|
});
|
|
|
|
// src/index.ts
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
BaseModule: () => BaseModule,
|
|
NoJsonClass: () => NoJsonClass,
|
|
UserLog: () => UserLog,
|
|
checkJson: () => checkJson,
|
|
dbconn: () => dbconn,
|
|
logger: () => logger,
|
|
noJson: () => noJson
|
|
});
|
|
module.exports = __toCommonJS(src_exports);
|
|
|
|
// src/decorators/dbconn.ts
|
|
var import_typegoose = require("@typegoose/typegoose");
|
|
function dbconn(name) {
|
|
return (target) => {
|
|
name = name || "main";
|
|
const dbName = ("db_" + name).toUpperCase();
|
|
const url = process.env[dbName];
|
|
target["db"] = import_typegoose.mongoose.createConnection(url, {});
|
|
};
|
|
}
|
|
|
|
// src/decorators/nojson.ts
|
|
var import_reflect_metadata = __toESM(require_Reflect(), 1);
|
|
|
|
// src/decorators/singleton.ts
|
|
var SINGLETON_KEY = Symbol();
|
|
var singleton = (classTarget) => new Proxy(classTarget, {
|
|
construct(target, argumentsList, newTarget) {
|
|
if (target.prototype !== newTarget.prototype) {
|
|
return Reflect.construct(target, argumentsList, newTarget);
|
|
}
|
|
if (!target[SINGLETON_KEY]) {
|
|
target[SINGLETON_KEY] = Reflect.construct(target, argumentsList, newTarget);
|
|
}
|
|
return target[SINGLETON_KEY];
|
|
}
|
|
});
|
|
|
|
// src/decorators/nojson.ts
|
|
var NoJsonClass = class {
|
|
noJsonPropSet = /* @__PURE__ */ new Set();
|
|
addKey(className, propertyKey) {
|
|
this.noJsonPropSet.add(className + "_" + propertyKey);
|
|
}
|
|
checkExist(className, propertyKey) {
|
|
return this.noJsonPropSet.has(className + "_" + propertyKey);
|
|
}
|
|
};
|
|
NoJsonClass = __decorateClass([
|
|
singleton
|
|
], NoJsonClass);
|
|
function noJson() {
|
|
return function(target, propertyKey) {
|
|
new NoJsonClass().addKey(target.constructor.name, propertyKey);
|
|
};
|
|
}
|
|
function checkJson(target, propertyKey) {
|
|
return !new NoJsonClass().checkExist(target.constructor.modelName, propertyKey);
|
|
}
|
|
|
|
// src/common/AsyncQueue.ts
|
|
function createAsyncQueue(opts = { dedupeConcurrent: false }) {
|
|
const { dedupeConcurrent } = opts;
|
|
let queue = [];
|
|
let running;
|
|
let nextPromise = new DeferredPromise();
|
|
const push = (task) => {
|
|
let taskPromise = new DeferredPromise();
|
|
if (dedupeConcurrent) {
|
|
queue = [];
|
|
if (nextPromise.started)
|
|
nextPromise = new DeferredPromise();
|
|
taskPromise = nextPromise;
|
|
}
|
|
queue.push(() => {
|
|
taskPromise.started = true;
|
|
task().then(taskPromise.resolve).catch(taskPromise.reject);
|
|
return taskPromise.promise;
|
|
});
|
|
if (!running)
|
|
running = start();
|
|
return taskPromise.promise;
|
|
};
|
|
const start = async () => {
|
|
while (queue.length) {
|
|
const task = queue.shift();
|
|
await task().catch(() => {
|
|
});
|
|
}
|
|
running = void 0;
|
|
};
|
|
return {
|
|
push,
|
|
flush: () => running || Promise.resolve(),
|
|
get size() {
|
|
return queue.length;
|
|
}
|
|
};
|
|
}
|
|
var DeferredPromise = class {
|
|
started = false;
|
|
resolve = () => {
|
|
};
|
|
reject = () => {
|
|
};
|
|
promise;
|
|
constructor() {
|
|
this.promise = new Promise((res, rej) => {
|
|
this.resolve = res;
|
|
this.reject = rej;
|
|
});
|
|
}
|
|
};
|
|
|
|
// src/models/UserLog.ts
|
|
var import_typegoose2 = require("@typegoose/typegoose");
|
|
var import_constants = require("@typegoose/typegoose/lib/internal/constants");
|
|
|
|
// src/models/Base.ts
|
|
var import_bson = require("bson");
|
|
var jsonExcludeKeys = ["updatedAt", "__v"];
|
|
var saveExcludeKeys = ["createdAt", "updatedAt", "__v", "_id"];
|
|
var isTrue = (obj) => {
|
|
return obj === "true" || obj === "TRUE" || obj === "True" || obj === "on" || obj === "ON" || obj === true || obj === 1 || obj === "1" || obj === "YES" || obj === "yes";
|
|
};
|
|
var BaseModule = class {
|
|
static db;
|
|
updateFromReq(data) {
|
|
for (let key in data) {
|
|
if (saveExcludeKeys.indexOf(key) == -1) {
|
|
this[key] = data[key];
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* 插入或更新
|
|
* @param condition
|
|
* @param data
|
|
*/
|
|
static insertOrUpdate(condition, data) {
|
|
return this.findOneAndUpdate(condition, data, { upsert: true, new: true, setDefaultsOnInsert: true });
|
|
}
|
|
/**
|
|
* 虚拟删除
|
|
* @param {string[]} ids
|
|
*/
|
|
static deleteVirtual(ids) {
|
|
return this.updateMany(
|
|
// @ts-ignore
|
|
{
|
|
_id: { $in: ids }
|
|
},
|
|
{
|
|
$set: {
|
|
deleted: true,
|
|
deleteTime: /* @__PURE__ */ new Date()
|
|
}
|
|
}
|
|
);
|
|
}
|
|
/**
|
|
* 自定义分页查询
|
|
* @param data
|
|
* @param {boolean} json
|
|
*/
|
|
static async pageQuery(data, json = false) {
|
|
let { start, limit, page } = data;
|
|
limit = +limit || 10;
|
|
start = +start || (+page - 1) * limit || 0;
|
|
let { opt, sort } = this.parseQueryParam(data);
|
|
let records = await this.find(opt).sort(sort).skip(start).limit(limit);
|
|
let total = await this.countDocuments(opt);
|
|
if (json) {
|
|
records.map((o) => o.toJson());
|
|
}
|
|
return { records, total, start, limit };
|
|
}
|
|
toJson() {
|
|
let result = {};
|
|
for (let key in this._doc) {
|
|
if (checkJson(this, key + "") && jsonExcludeKeys.indexOf(key) == -1) {
|
|
result[key] = this[key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* 通用的查询条件拼接方法
|
|
* @param {{}} params req.params
|
|
* @param options
|
|
* sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1}
|
|
* opt: 设置一些特殊的过滤条件, 比如{deleted: 0}
|
|
* timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置
|
|
* matchKey: 指定关键字查询的匹配字段, 可为string或[string]
|
|
*
|
|
* @return {{opt: any, sort: {_id: number}}}
|
|
*/
|
|
static parseQueryParam(params, options) {
|
|
const opt = { deleted: { $ne: true } };
|
|
let obj = this.schema.paths;
|
|
for (let key in params) {
|
|
if (key !== "sort" && obj.hasOwnProperty(key)) {
|
|
switch (obj[key].instance) {
|
|
case "String":
|
|
opt[key] = { $regex: params[key], $options: "i" };
|
|
break;
|
|
case "Number":
|
|
opt[key] = params[key];
|
|
break;
|
|
case "Array":
|
|
if (Array.isArray(params[key])) {
|
|
opt[key] = { $in: params[key] };
|
|
} else {
|
|
opt[key] = params[key];
|
|
}
|
|
break;
|
|
case "Date":
|
|
break;
|
|
case "Boolean":
|
|
opt[key] = isTrue(params[key]);
|
|
break;
|
|
case "ObjectID":
|
|
if (/^[0-9a-fA-F]{24}$/.test(params[key])) {
|
|
opt[key] = new import_bson.ObjectId(params[key]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (params.hasOwnProperty("key") && params["key"]) {
|
|
let orArr = [];
|
|
if (options?.matchKey) {
|
|
if (Array.isArray(options?.matchKey)) {
|
|
for (let key in options?.matchKey) {
|
|
let _tmp = {};
|
|
_tmp[key] = { $regex: params["key"], $options: "i" };
|
|
orArr.push(_tmp);
|
|
}
|
|
} else {
|
|
let _tmp = {};
|
|
_tmp[options.matchKey] = { $regex: params["key"], $options: "i" };
|
|
orArr.push(_tmp);
|
|
}
|
|
} else {
|
|
for (let key in obj) {
|
|
if (obj[key].instance === "String") {
|
|
let _tmp = {};
|
|
_tmp[key] = { $regex: params["key"], $options: "i" };
|
|
orArr.push(_tmp);
|
|
}
|
|
}
|
|
}
|
|
Object.assign(opt, { $or: orArr });
|
|
}
|
|
let timeKey = options?.timeKey ? options.timeKey : "createdAt";
|
|
if (params.hasOwnProperty("timeBegin") && !params.hasOwnProperty("timeEnd")) {
|
|
let timeBegin = params["timeBegin"];
|
|
if (!(timeBegin instanceof Date)) {
|
|
timeBegin = new Date(parseInt(timeBegin));
|
|
}
|
|
opt[timeKey] = { $gte: timeBegin };
|
|
} else if (params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) {
|
|
let timeBegin = params["timeBegin"];
|
|
if (!(timeBegin instanceof Date)) {
|
|
timeBegin = new Date(parseInt(timeBegin));
|
|
}
|
|
let timeEnd = params["timeEnd"];
|
|
if (!(timeEnd instanceof Date)) {
|
|
timeEnd = new Date(parseInt(timeEnd));
|
|
}
|
|
let tmpB = {};
|
|
tmpB[timeKey] = { $gte: timeBegin };
|
|
let tmpE = {};
|
|
tmpE[timeKey] = { $lte: timeEnd };
|
|
opt["$and"] = [tmpB, tmpE];
|
|
} else if (!params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) {
|
|
let timeEnd = params["timeEnd"];
|
|
if (!(timeEnd instanceof Date)) {
|
|
timeEnd = new Date(parseInt(timeEnd));
|
|
}
|
|
opt[timeKey] = { $lte: timeEnd };
|
|
}
|
|
if (options?.opt) {
|
|
Object.assign(opt, options.opt);
|
|
}
|
|
let sort = { _id: 1 };
|
|
if (params.hasOwnProperty("sort")) {
|
|
sort = params["sort"];
|
|
}
|
|
return { opt, sort };
|
|
}
|
|
getTimestampOfID() {
|
|
return this._id.getTimestamp();
|
|
}
|
|
};
|
|
|
|
// src/models/UserLog.ts
|
|
var UserLogClass = class extends BaseModule {
|
|
user;
|
|
name;
|
|
method;
|
|
path;
|
|
referer;
|
|
user_agent;
|
|
ip;
|
|
params;
|
|
};
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "user", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "name", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "method", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "path", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "referer", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "user_agent", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)()
|
|
], UserLogClass.prototype, "ip", 2);
|
|
__decorateClass([
|
|
(0, import_typegoose2.prop)({ type: import_typegoose2.mongoose.Schema.Types.Mixed })
|
|
], UserLogClass.prototype, "params", 2);
|
|
UserLogClass = __decorateClass([
|
|
dbconn(),
|
|
(0, import_typegoose2.index)({ user: 1 }, { unique: false }),
|
|
(0, import_typegoose2.index)({ name: 1 }, { unique: false }),
|
|
(0, import_typegoose2.modelOptions)({ schemaOptions: { collection: "user_log", timestamps: true }, options: { allowMixed: import_constants.Severity.ALLOW } })
|
|
], UserLogClass);
|
|
var UserLog = (0, import_typegoose2.getModelForClass)(UserLogClass, { existingConnection: UserLogClass["db"] });
|
|
|
|
// src/queue/logger.queue.ts
|
|
var LoggerQueue = class {
|
|
queue;
|
|
constructor() {
|
|
this.queue = createAsyncQueue();
|
|
}
|
|
addLog(name, req, logObj = {}) {
|
|
this.queue.push(async () => {
|
|
const user = req.user;
|
|
const ip = req.headers["x-forwarded-for"] || req.ip;
|
|
const path = req.url;
|
|
const params = req.method === "GET" ? req.query : req.body;
|
|
const dataObj = JSON.stringify(logObj) === "{}" ? params : logObj;
|
|
try {
|
|
const history = new UserLog({
|
|
user: user ? user.id : "",
|
|
path,
|
|
method: req.method,
|
|
params: dataObj,
|
|
referer: req.headers["referer"],
|
|
user_agent: req.headers["user-agent"],
|
|
ip,
|
|
name
|
|
});
|
|
await history.save();
|
|
} catch (err) {
|
|
logger.error("error add user log: ");
|
|
logger.error(err);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
LoggerQueue = __decorateClass([
|
|
singleton
|
|
], LoggerQueue);
|
|
|
|
// src/logger/logger.ts
|
|
var import_tracer = require("tracer");
|
|
var level = process.env.NODE_ENV === "production" ? "info" : "log";
|
|
var _logger = (0, import_tracer.colorConsole)({ dateformat: "yyyy-mm-dd HH:MM:ss.L", level });
|
|
Object.assign(_logger, {
|
|
db: (name, req, logObj) => {
|
|
logObj = logObj || {};
|
|
new LoggerQueue().addLog(name, req, logObj);
|
|
}
|
|
});
|
|
var logger = _logger;
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
BaseModule,
|
|
NoJsonClass,
|
|
UserLog,
|
|
checkJson,
|
|
dbconn,
|
|
logger,
|
|
noJson
|
|
});
|
|
/*! Bundled license information:
|
|
|
|
reflect-metadata/Reflect.js:
|
|
(*! *****************************************************************************
|
|
Copyright (C) Microsoft. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** *)
|
|
*/
|
|
//# sourceMappingURL=index.cjs.map
|