@vsaas/loopback 12.1.1 → 12.2.0

package/dist/lib/rate-limit/algorithms/common.cjs

@@ -0,0 +1,37 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+//#region src/lib/rate-limit/algorithms/common.ts
+function emptyRateLimitState() {
+	return {
+		failureCount: 0,
+		attemptCount: 0,
+		lockoutLevel: 0,
+		windowStartedAtMs: null,
+		lastAttemptAtMs: null,
+		lastFailureAtMs: null,
+		blockedUntilMs: null
+	};
+}
+function cloneRateLimitState(state) {
+	const empty = emptyRateLimitState();
+	if (!state) return empty;
+	for (const key of Object.keys(empty)) {
+		const value = state[key];
+		if (value !== void 0) empty[key] = value;
+	}
+	return empty;
+}
+function isBlocked(state, nowMs) {
+	return state.blockedUntilMs != null && state.blockedUntilMs > nowMs;
+}
+var init_common = require_runtime.__esmMin((() => {}));
+//#endregion
+init_common();
+exports.cloneRateLimitState = cloneRateLimitState;
+exports.emptyRateLimitState = emptyRateLimitState;
+Object.defineProperty(exports, "init_common", {
+	enumerable: true,
+	get: function() {
+		return init_common;
+	}
+});
+exports.isBlocked = isBlocked;

package/dist/lib/rate-limit/algorithms/failure-lockout.cjs

@@ -0,0 +1,70 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_common = require("./common.cjs");
+//#region src/lib/rate-limit/algorithms/failure-lockout.ts
+function normalizeFailureWindow(current, policy, nowMs) {
+	const state = require_common.cloneRateLimitState(current);
+	if (state.blockedUntilMs != null && state.blockedUntilMs <= nowMs) {
+		state.blockedUntilMs = null;
+		state.failureCount = 0;
+		state.windowStartedAtMs = null;
+	}
+	if (state.windowStartedAtMs != null && state.windowStartedAtMs + policy.observationWindowMs <= nowMs) {
+		state.failureCount = 0;
+		state.windowStartedAtMs = null;
+	}
+	if (state.lastFailureAtMs != null && state.lastFailureAtMs + policy.backoffResetAfterMs <= nowMs) state.lockoutLevel = 0;
+	return state;
+}
+function inspectFailureLockout(current, policy, nowMs) {
+	const state = normalizeFailureWindow(current, policy, nowMs);
+	return {
+		state,
+		allowed: !require_common.isBlocked(state, nowMs),
+		blockedUntilMs: require_common.isBlocked(state, nowMs) ? state.blockedUntilMs : null
+	};
+}
+function blockDuration(policy, lockoutLevel) {
+	if (policy.strategy === "fixed") return policy.blockDurationMs;
+	const exponent = Math.min(30, Math.max(0, lockoutLevel - 1));
+	return Math.min(policy.maxBlockDurationMs, policy.blockDurationMs * Math.pow(policy.multiplier, exponent));
+}
+function consumeFailureLockout(current, policy, cost, nowMs) {
+	const state = normalizeFailureWindow(current, policy, nowMs);
+	if (require_common.isBlocked(state, nowMs)) return {
+		state,
+		allowed: false,
+		blockedUntilMs: state.blockedUntilMs
+	};
+	if (state.windowStartedAtMs == null) state.windowStartedAtMs = nowMs;
+	state.lastFailureAtMs = nowMs;
+	state.failureCount = Math.min(policy.maxFailedAttempts, state.failureCount + cost);
+	if (state.failureCount >= policy.maxFailedAttempts) {
+		state.failureCount = 0;
+		state.windowStartedAtMs = null;
+		state.lockoutLevel += 1;
+		state.blockedUntilMs = nowMs + blockDuration(policy, state.lockoutLevel);
+		return {
+			state,
+			allowed: false,
+			blockedUntilMs: state.blockedUntilMs
+		};
+	}
+	return {
+		state,
+		allowed: true,
+		blockedUntilMs: null
+	};
+}
+var init_failure_lockout = require_runtime.__esmMin((() => {
+	require_common.init_common();
+}));
+//#endregion
+init_failure_lockout();
+exports.consumeFailureLockout = consumeFailureLockout;
+Object.defineProperty(exports, "init_failure_lockout", {
+	enumerable: true,
+	get: function() {
+		return init_failure_lockout;
+	}
+});
+exports.inspectFailureLockout = inspectFailureLockout;

package/dist/lib/rate-limit/algorithms/fixed-window.cjs

@@ -0,0 +1,61 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_common = require("./common.cjs");
+//#region src/lib/rate-limit/algorithms/fixed-window.ts
+function normalizeWindow(current, policy, nowMs) {
+	const state = require_common.cloneRateLimitState(current);
+	const blockExpired = state.blockedUntilMs != null && state.blockedUntilMs <= nowMs;
+	const windowExpired = state.windowStartedAtMs != null && state.windowStartedAtMs + policy.observationWindowMs <= nowMs;
+	if (blockExpired || windowExpired) {
+		state.attemptCount = 0;
+		state.windowStartedAtMs = null;
+		state.blockedUntilMs = null;
+	}
+	return state;
+}
+function inspectFixedWindow(current, policy, nowMs) {
+	const state = normalizeWindow(current, policy, nowMs);
+	return {
+		state,
+		allowed: !require_common.isBlocked(state, nowMs),
+		blockedUntilMs: require_common.isBlocked(state, nowMs) ? state.blockedUntilMs : null
+	};
+}
+function consumeFixedWindow(current, policy, cost, nowMs) {
+	const state = normalizeWindow(current, policy, nowMs);
+	if (require_common.isBlocked(state, nowMs)) return {
+		state,
+		allowed: false,
+		blockedUntilMs: state.blockedUntilMs
+	};
+	if (state.windowStartedAtMs == null) state.windowStartedAtMs = nowMs;
+	state.lastAttemptAtMs = nowMs;
+	if (cost > Math.max(0, policy.maxAttempts - state.attemptCount)) {
+		state.attemptCount = policy.maxAttempts;
+		state.blockedUntilMs = nowMs + policy.blockDurationMs;
+		return {
+			state,
+			allowed: false,
+			blockedUntilMs: state.blockedUntilMs
+		};
+	}
+	state.attemptCount += cost;
+	if (state.attemptCount === policy.maxAttempts) state.blockedUntilMs = nowMs + policy.blockDurationMs;
+	return {
+		state,
+		allowed: true,
+		blockedUntilMs: state.blockedUntilMs
+	};
+}
+var init_fixed_window = require_runtime.__esmMin((() => {
+	require_common.init_common();
+}));
+//#endregion
+init_fixed_window();
+exports.consumeFixedWindow = consumeFixedWindow;
+Object.defineProperty(exports, "init_fixed_window", {
+	enumerable: true,
+	get: function() {
+		return init_fixed_window;
+	}
+});
+exports.inspectFixedWindow = inspectFixedWindow;

package/dist/lib/rate-limit/algorithms/index.cjs

@@ -0,0 +1,55 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_common = require("./common.cjs");
+const require_failure_lockout = require("./failure-lockout.cjs");
+const require_fixed_window = require("./fixed-window.cjs");
+//#region src/lib/rate-limit/algorithms/index.ts
+var algorithms_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	cloneRateLimitState: () => require_common.cloneRateLimitState,
+	consumeFailureLockout: () => require_failure_lockout.consumeFailureLockout,
+	consumeFixedWindow: () => require_fixed_window.consumeFixedWindow,
+	consumeState: () => consumeState,
+	emptyRateLimitState: () => require_common.emptyRateLimitState,
+	inspectFailureLockout: () => require_failure_lockout.inspectFailureLockout,
+	inspectFixedWindow: () => require_fixed_window.inspectFixedWindow,
+	inspectState: () => inspectState,
+	isBlocked: () => require_common.isBlocked
+});
+function inspectState(state, policy, nowMs) {
+	if (policy.algorithm === "fixed-window") return require_fixed_window.inspectFixedWindow(state, policy, nowMs);
+	return require_failure_lockout.inspectFailureLockout(state, policy, nowMs);
+}
+function consumeState(state, policy, cost, nowMs) {
+	if (policy.algorithm === "fixed-window") return require_fixed_window.consumeFixedWindow(state, policy, cost, nowMs);
+	return require_failure_lockout.consumeFailureLockout(state, policy, cost, nowMs);
+}
+var init_algorithms = require_runtime.__esmMin((() => {
+	require_failure_lockout.init_failure_lockout();
+	require_fixed_window.init_fixed_window();
+	require_common.init_common();
+}));
+//#endregion
+require_common.init_common();
+require_failure_lockout.init_failure_lockout();
+require_fixed_window.init_fixed_window();
+init_algorithms();
+Object.defineProperty(exports, "algorithms_exports", {
+	enumerable: true,
+	get: function() {
+		return algorithms_exports;
+	}
+});
+exports.cloneRateLimitState = require_common.cloneRateLimitState;
+exports.consumeFailureLockout = require_failure_lockout.consumeFailureLockout;
+exports.consumeFixedWindow = require_fixed_window.consumeFixedWindow;
+exports.consumeState = consumeState;
+exports.emptyRateLimitState = require_common.emptyRateLimitState;
+Object.defineProperty(exports, "init_algorithms", {
+	enumerable: true,
+	get: function() {
+		return init_algorithms;
+	}
+});
+exports.inspectFailureLockout = require_failure_lockout.inspectFailureLockout;
+exports.inspectFixedWindow = require_fixed_window.inspectFixedWindow;
+exports.inspectState = inspectState;
+exports.isBlocked = require_common.isBlocked;

package/dist/lib/rate-limit/config.cjs

@@ -0,0 +1,107 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors.cjs");
+const require_subject = require("./subject.cjs");
+//#region src/lib/rate-limit/config.ts
+var config_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	canonicalJson: () => canonicalJson,
+	fingerprintPolicy: () => fingerprintPolicy,
+	normalizeFailureLockoutPolicy: () => normalizeFailureLockoutPolicy,
+	normalizeFixedWindowPolicy: () => normalizeFixedWindowPolicy,
+	validateRateLimitCost: () => validateRateLimitCost
+});
+function assertInteger(value, name, minimum = 1, maximum = MAX_INTEGER) {
+	if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw require_errors.rateLimitConfigurationError(`${name} must be an integer between ${minimum} and ${maximum}`);
+	return value;
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value && typeof value === "object") {
+		const output = {};
+		for (const key of Object.keys(value).sort()) {
+			const current = value[key];
+			if (current !== void 0) output[key] = canonicalize(current);
+		}
+		return output;
+	}
+	return value;
+}
+function canonicalJson(value) {
+	return JSON.stringify(canonicalize(value));
+}
+function fingerprintPolicy(policy) {
+	return crypto.createHash("sha256").update(canonicalJson(policy)).digest("hex");
+}
+function normalizeFixedWindowPolicy(input) {
+	require_subject.validateSafeIdentifier(input.policyId, "policyId");
+	require_subject.validateSafeIdentifier(input.policyVersion, "policyVersion");
+	const normalized = {
+		policyId: input.policyId,
+		policyVersion: input.policyVersion,
+		algorithm: "fixed-window",
+		maxAttempts: assertInteger(input.maxAttempts, "maxAttempts"),
+		observationWindowMs: assertInteger(input.observationWindowMs, "observationWindowMs", 1, MAX_DURATION_MS),
+		blockDurationMs: assertInteger(input.blockDurationMs, "blockDurationMs", 1, MAX_DURATION_MS),
+		stateTtlMs: assertInteger(input.stateTtlMs, "stateTtlMs", 1, MAX_DURATION_MS)
+	};
+	if (normalized.stateTtlMs < Math.max(normalized.observationWindowMs, normalized.blockDurationMs)) throw require_errors.rateLimitConfigurationError("stateTtlMs must cover observationWindowMs and blockDurationMs");
+	return {
+		...normalized,
+		policyFingerprint: fingerprintPolicy(normalized)
+	};
+}
+function normalizeFailureLockoutPolicy(input) {
+	require_subject.validateSafeIdentifier(input.policyId, "policyId");
+	require_subject.validateSafeIdentifier(input.policyVersion, "policyVersion");
+	const strategy = input.strategy || "fixed";
+	if (strategy !== "fixed" && strategy !== "exponential") throw require_errors.rateLimitConfigurationError("strategy must be fixed or exponential");
+	const blockDurationMs = assertInteger(input.blockDurationMs, "blockDurationMs", 1, MAX_DURATION_MS);
+	const maxBlockDurationMs = assertInteger(input.maxBlockDurationMs || blockDurationMs, "maxBlockDurationMs", blockDurationMs, MAX_DURATION_MS);
+	const normalized = {
+		policyId: input.policyId,
+		policyVersion: input.policyVersion,
+		algorithm: "failure-lockout",
+		maxFailedAttempts: assertInteger(input.maxFailedAttempts, "maxFailedAttempts"),
+		observationWindowMs: assertInteger(input.observationWindowMs, "observationWindowMs", 1, MAX_DURATION_MS),
+		blockDurationMs,
+		strategy,
+		multiplier: assertInteger(input.multiplier || 2, "multiplier", 1, 100),
+		maxBlockDurationMs,
+		backoffResetAfterMs: assertInteger(input.backoffResetAfterMs, "backoffResetAfterMs", 1, MAX_DURATION_MS),
+		stateTtlMs: assertInteger(input.stateTtlMs, "stateTtlMs", 1, MAX_DURATION_MS)
+	};
+	if (normalized.stateTtlMs < Math.max(normalized.observationWindowMs, normalized.maxBlockDurationMs, normalized.backoffResetAfterMs)) throw require_errors.rateLimitConfigurationError("stateTtlMs must cover window, maximum block and backoff reset");
+	return {
+		...normalized,
+		policyFingerprint: fingerprintPolicy(normalized)
+	};
+}
+function validateRateLimitCost(cost, maximum = 1e5) {
+	return assertInteger(cost, "cost", 1, maximum);
+}
+var crypto, MAX_INTEGER, MAX_DURATION_MS;
+var init_config = require_runtime.__esmMin((() => {
+	require_errors.init_errors();
+	require_subject.init_subject();
+	crypto = require("crypto");
+	MAX_INTEGER = 2147483647;
+	MAX_DURATION_MS = 31536e6;
+}));
+//#endregion
+init_config();
+exports.canonicalJson = canonicalJson;
+Object.defineProperty(exports, "config_exports", {
+	enumerable: true,
+	get: function() {
+		return config_exports;
+	}
+});
+exports.fingerprintPolicy = fingerprintPolicy;
+Object.defineProperty(exports, "init_config", {
+	enumerable: true,
+	get: function() {
+		return init_config;
+	}
+});
+exports.normalizeFailureLockoutPolicy = normalizeFailureLockoutPolicy;
+exports.normalizeFixedWindowPolicy = normalizeFixedWindowPolicy;
+exports.validateRateLimitCost = validateRateLimitCost;

package/dist/lib/rate-limit/errors.cjs

@@ -0,0 +1,58 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+//#region src/lib/rate-limit/errors.ts
+var errors_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	RateLimitError: () => RateLimitError,
+	rateLimitConfigurationError: () => rateLimitConfigurationError,
+	rateLimitUnavailableError: () => rateLimitUnavailableError,
+	rateLimitedError: () => rateLimitedError
+});
+function rateLimitedError(blockedUntilMs, nowMs = Date.now(), code = "RATE_LIMITED") {
+	const retryAfter = blockedUntilMs == null ? 1 : Math.max(1, Math.ceil((blockedUntilMs - nowMs) / 1e3));
+	return new RateLimitError(code, "Too many requests", 429, {
+		retryAfter,
+		details: { retryAfter }
+	});
+}
+function rateLimitUnavailableError(cause, code = "RATE_LIMIT_UNAVAILABLE") {
+	return new RateLimitError(code, "Rate limit service unavailable", 503, { cause });
+}
+function rateLimitConfigurationError(message) {
+	return new RateLimitError("RATE_LIMIT_CONFIGURATION_INVALID", message, 500);
+}
+var RateLimitError;
+var init_errors = require_runtime.__esmMin((() => {
+	RateLimitError = class extends Error {
+		code;
+		statusCode;
+		details;
+		retryAfter;
+		cause;
+		constructor(code, message, statusCode, options = {}) {
+			super(message);
+			this.name = "RateLimitError";
+			this.code = code;
+			this.statusCode = statusCode;
+			this.cause = options.cause;
+			this.details = options.details;
+			this.retryAfter = options.retryAfter;
+		}
+	};
+}));
+//#endregion
+init_errors();
+exports.RateLimitError = RateLimitError;
+Object.defineProperty(exports, "errors_exports", {
+	enumerable: true,
+	get: function() {
+		return errors_exports;
+	}
+});
+Object.defineProperty(exports, "init_errors", {
+	enumerable: true,
+	get: function() {
+		return init_errors;
+	}
+});
+exports.rateLimitConfigurationError = rateLimitConfigurationError;
+exports.rateLimitUnavailableError = rateLimitUnavailableError;
+exports.rateLimitedError = rateLimitedError;

package/dist/lib/rate-limit/index.cjs

@@ -0,0 +1,15 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors.cjs");
+const require_subject = require("./subject.cjs");
+const require_config = require("./config.cjs");
+const require_limiter = require("./limiter.cjs");
+const require_index = require("./algorithms/index.cjs");
+const require_persisted_model = require("./stores/persisted-model.cjs");
+const require_registry = require("./registry.cjs");
+const require_lib_rate_limit_remote = require("./remote.cjs");
+//#region src/lib/rate-limit/index.ts
+var require_rate_limit = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = Object.assign({}, (require_errors.init_errors(), require_runtime.__toCommonJS(require_errors.errors_exports)), (require_config.init_config(), require_runtime.__toCommonJS(require_config.config_exports)), (require_subject.init_subject(), require_runtime.__toCommonJS(require_subject.subject_exports)), (require_index.init_algorithms(), require_runtime.__toCommonJS(require_index.algorithms_exports)), (require_limiter.init_limiter(), require_runtime.__toCommonJS(require_limiter.limiter_exports)), (require_registry.init_registry(), require_runtime.__toCommonJS(require_registry.registry_exports)), (require_lib_rate_limit_remote.init_remote(), require_runtime.__toCommonJS(require_lib_rate_limit_remote.remote_exports)), (require_persisted_model.init_persisted_model(), require_runtime.__toCommonJS(require_persisted_model.persisted_model_exports)));
+}));
+//#endregion
+module.exports = require_rate_limit();

package/dist/lib/rate-limit/index.d.cts

@@ -0,0 +1 @@
+export {}

package/dist/lib/rate-limit/initializer.cjs

@@ -0,0 +1,92 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_limiter = require("./limiter.cjs");
+const require_registry = require("./registry.cjs");
+const require_lib_rate_limit_remote = require("./remote.cjs");
+//#region src/lib/rate-limit/initializer.ts
+var initializer_exports = /* @__PURE__ */ require_runtime.__exportAll({ installRateLimiting: () => installRateLimiting });
+function installRateLimiting(app) {
+	const registry = new require_registry.RateLimitRegistry(app);
+	const limiter = new require_limiter.RateLimiter(registry);
+	const registered = new require_limiter.RegisteredRateLimiter(limiter, registry);
+	let initialization = null;
+	require_lib_rate_limit_remote.installRemoteRateLimiting(app);
+	app.rateLimitRegistry = registry;
+	app.rateLimiter = registered;
+	app.rateLimit = {
+		limiter,
+		registry,
+		get ready() {
+			return app.rateLimitReadiness.ready;
+		}
+	};
+	app.rateLimitReadiness = {
+		ready: false,
+		error: null
+	};
+	app.registerRateLimitProvider = function(name, factory) {
+		registry.registerProvider(name, factory);
+		return app;
+	};
+	app.registerRateLimitStore = function(name, store) {
+		registry.registerStore(name, store);
+		return app;
+	};
+	app.registerRateLimitSubjectKeyring = function(name, keyring) {
+		registry.registerKeyring(name, keyring);
+		return app;
+	};
+	app.cleanupRateLimitStates = function(options = {}, callback) {
+		const promise = Promise.resolve().then(async () => {
+			const modelName = options.model || "RateLimitState";
+			const model = app.models && app.models[modelName];
+			if (!model) throw new Error(`Rate limit state model ${modelName} was not found`);
+			return model.destroyAll({ expiresAt: { lt: options.now || /* @__PURE__ */ new Date() } });
+		});
+		if (typeof callback === "function") {
+			promise.then((result) => callback(null, result), callback);
+			return;
+		}
+		return promise;
+	};
+	app.initializeRateLimiting = function(callback) {
+		if (!initialization) initialization = Promise.resolve().then(async () => {
+			const config = app.get("rateLimit") || {};
+			registered.configureLimits(config.limits || {});
+			registry.configure(config);
+			await Promise.all(Object.keys(config.stores || {}).map((name) => registry.resolveStore(name)));
+			await app.validateRemoteRateLimits();
+			registry.freeze();
+			app.installRemoteRateLimits();
+			app.rateLimitReadiness.ready = true;
+		}).catch((error) => {
+			app.rateLimitReadiness.error = error;
+			throw error;
+		});
+		if (typeof callback === "function") {
+			initialization.then(() => callback(null), callback);
+			return;
+		}
+		return initialization;
+	};
+}
+var init_initializer = require_runtime.__esmMin((() => {
+	require_limiter.init_limiter();
+	require_registry.init_registry();
+	require_lib_rate_limit_remote.init_remote();
+}));
+//#endregion
+init_initializer();
+Object.defineProperty(exports, "init_initializer", {
+	enumerable: true,
+	get: function() {
+		return init_initializer;
+	}
+});
+Object.defineProperty(exports, "initializer_exports", {
+	enumerable: true,
+	get: function() {
+		return initializer_exports;
+	}
+});
+exports.installRateLimiting = installRateLimiting;

package/dist/lib/rate-limit/initializer.d.cts

@@ -0,0 +1,4 @@
+//#region src/lib/rate-limit/initializer.d.ts
+declare function installRateLimiting(app: any): void;
+//#endregion
+export { installRateLimiting };