@mojaloop/inter-scheme-proxy-cache-lib
Version:
Common component, that provides scheme proxy caching mapping (ISPC)
221 lines (211 loc) • 7.12 kB
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 __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);
// src/validation.ts
var validation_exports = {};
__export(validation_exports, {
validateAlsRequestDetails: () => validateAlsRequestDetails,
validateDfspId: () => validateDfspId,
validateRedisClusterProxyCacheConfig: () => validateRedisClusterProxyCacheConfig,
validateRedisProxyCacheConfig: () => validateRedisProxyCacheConfig
});
module.exports = __toCommonJS(validation_exports);
var import_ajv = __toESM(require("ajv"));
// src/utils/index.ts
var import_contextLogger = require("@mojaloop/central-services-logger/src/contextLogger");
// src/config.ts
var import_convict = __toESM(require("convict"));
// src/types/utils.ts
var logLevelsMap = {
error: "error",
warn: "warn",
info: "info",
verbose: "verbose",
debug: "debug",
silly: "silly",
audit: "audit",
trace: "trace",
perf: "perf"
};
var logLevelValues = Object.values(logLevelsMap);
// src/config.ts
var config = (0, import_convict.default)({
logLevel: {
doc: "Log level for the library.",
format: logLevelValues,
default: logLevelsMap.warn,
env: "PROXY_CACHE_LOG_LEVEL"
},
defaultTtlSec: {
doc: "Default cache TTL for sendToProxiesList keys.",
format: Number,
default: 20,
env: "PROXY_CACHE_DEFAULT_TTL_SEC"
}
});
config.validate({ allowed: "strict" });
var config_default = config;
// src/utils/index.ts
var createLogger = (context) => {
const log = (0, import_contextLogger.loggerFactory)(context);
log.setLevel(config_default.get("logLevel"));
return log;
};
var logger = createLogger("ISPCL");
// src/constants.ts
var STORAGE_TYPES = {
redis: "redis",
redisCluster: "redis-cluster",
mysql: "mysql"
};
var storageTypeValues = Object.values(STORAGE_TYPES);
var ERROR_MESSAGES = {
unsupportedProxyCacheType: `Unsupported proxyCache type [possible values: ${storageTypeValues.join(", ")}]`,
invalidFormat: "Invalid format"
// add all needed error messages
};
// src/lib/errors.ts
var ProxyCacheError = class _ProxyCacheError extends Error {
constructor(message) {
super(message);
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
}
static unsupportedProxyCacheType() {
return new _ProxyCacheError(ERROR_MESSAGES.unsupportedProxyCacheType);
}
};
var ValidationError = class _ValidationError extends ProxyCacheError {
static invalidFormat(details) {
const erMessage = `${ERROR_MESSAGES.invalidFormat}${details ? ` - ${details}` : ""}`;
return new _ValidationError(erMessage);
}
};
// src/lib/storages/RedisProxyCache.ts
var import_ioredis = __toESM(require("ioredis"));
var PROCESS_NODE_STREAM_TIMEOUT_MS = 2 * 60 * 1e3;
// src/validation.ts
var ajv = new import_ajv.default();
var BasicConnectionSchema = {
type: "object",
properties: {
host: { type: "string", minLength: 1 },
port: { type: "integer" }
},
required: ["host", "port"],
additionalProperties: false
};
var RedisOptionsSchema = {
type: "object",
properties: {
username: { type: "string", nullable: true },
password: { type: "string", nullable: true },
lazyConnect: { type: "boolean", nullable: true },
db: { type: "number", nullable: true }
},
additionalProperties: true
};
var RedisProxyCacheConfigSchema = {
type: "object",
properties: {
...BasicConnectionSchema.properties,
...RedisOptionsSchema.properties
},
required: ["host", "port"],
additionalProperties: true
};
var redisProxyCacheConfigValidatingFn = ajv.compile(RedisProxyCacheConfigSchema);
var validateRedisProxyCacheConfig = (cacheConfig) => {
const isValid = redisProxyCacheConfigValidatingFn(cacheConfig);
if (!isValid) {
const errDetails = `redisProxyCacheConfig error: ${redisProxyCacheConfigValidatingFn.errors[0].message}`;
throw ValidationError.invalidFormat(errDetails);
}
return cacheConfig;
};
var RedisClusterProxyCacheConfigSchema = {
type: "object",
properties: {
cluster: { type: "array", items: BasicConnectionSchema, minItems: 1 },
...RedisOptionsSchema.properties
},
required: ["cluster"],
additionalProperties: true
};
var redisClusterProxyCacheConfigValidatingFn = ajv.compile(
RedisClusterProxyCacheConfigSchema
);
var validateRedisClusterProxyCacheConfig = (cacheConfig) => {
const isValid = redisClusterProxyCacheConfigValidatingFn(cacheConfig);
if (!isValid) {
const errDetails = `redisClusterProxyCacheConfig error: ${redisClusterProxyCacheConfigValidatingFn.errors[0].message}`;
throw ValidationError.invalidFormat(errDetails);
}
return cacheConfig;
};
var AlsRequestSchema = {
type: "object",
properties: {
sourceId: { type: "string" },
type: { type: "string" },
partyId: { type: "string" }
},
required: ["sourceId", "type", "partyId"],
additionalProperties: false
};
var alsRequestValidatingFn = ajv.compile(AlsRequestSchema);
var validateAlsRequestDetails = (data) => {
const isValid = alsRequestValidatingFn(data);
if (!isValid) {
const errDetails = `alsRequest: ${alsRequestValidatingFn.errors[0].message}`;
throw ValidationError.invalidFormat(errDetails);
}
return true;
};
var DfspIdSchema = {
type: "string",
minLength: 1,
maxLength: 32
};
var dfspIdValidatingFn = ajv.compile(DfspIdSchema);
var validateDfspId = (data) => {
const isValid = dfspIdValidatingFn(data);
if (!isValid) {
const errDetails = `dfspId: ${dfspIdValidatingFn.errors[0].message}`;
throw ValidationError.invalidFormat(errDetails);
}
return true;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
validateAlsRequestDetails,
validateDfspId,
validateRedisClusterProxyCacheConfig,
validateRedisProxyCacheConfig
});
//# sourceMappingURL=validation.js.map