@vsaas/loopback 12.1.1 → 12.2.0

package/dist/lib/authentication-security-initializer.cjs

@@ -0,0 +1,351 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_persisted_model = require("./rate-limit/stores/persisted-model.cjs");
+const require_lib_two_factor_config = require("./two-factor/config.cjs");
+const require_lib_two_factor_errors = require("./two-factor/errors.cjs");
+const require_lib_two_factor_rate_limit = require("./two-factor/rate-limit.cjs");
+const require_lib_two_factor_service = require("./two-factor/service.cjs");
+//#region src/lib/authentication-security-initializer.ts
+var authentication_security_initializer_exports = /* @__PURE__ */ require_runtime.__exportAll({ installAuthenticationSecurity: () => installAuthenticationSecurity });
+function isUserModel(model, baseUser) {
+	return model === baseUser || model?.prototype && baseUser?.prototype && model.prototype instanceof baseUser;
+}
+function requirePrivateModel(app, name) {
+	const model = app.models[name];
+	if (!model || !model.dataSource) throw new Error(`Authentication security model ${name} is not connected`);
+	if ((model.config || {}).public === true) throw new Error(`Authentication security model ${name} must be private`);
+	return model;
+}
+function resultCount(result) {
+	return typeof result === "number" ? result : Number(result?.count || 0);
+}
+function requireUniquePrincipalProviderIndex(model) {
+	const index = (model.settings?.indexes || model.definition?.settings?.indexes || {}).two_factor_principal_provider_unique;
+	if (!index || index.options?.unique !== true || Number(index.keys?.principalType) !== 1 || Number(index.keys?.principalId) !== 1 || Number(index.keys?.provider) !== 1) throw new Error("TwoFactorCredential requires a unique principalType/principalId/provider index");
+}
+function installAuthenticationSecurity(app) {
+	let initialization = null;
+	app.authenticationSecurityReadiness = {
+		ready: false,
+		error: null
+	};
+	const twoFactorMethods = [
+		"verifyTwoFactor",
+		"beginTwoFactorEnrollment",
+		"confirmTwoFactorEnrollment",
+		"regenerateTwoFactorRecoveryCodes",
+		"disableTwoFactor"
+	];
+	function disableUnconfiguredRemoteMethods() {
+		const BaseUser = app.registry.findModel("User");
+		if (!BaseUser) return;
+		for (const model of app.models().filter((candidate) => isUserModel(candidate, BaseUser))) if (model.settings.twoFactor == null) for (const method of twoFactorMethods) model.disableRemoteMethodByName(method);
+	}
+	app.on("modelRemoted", disableUnconfiguredRemoteMethods);
+	app.initializeAuthenticationSecurity = function(callback) {
+		if (!initialization) initialization = Promise.resolve().then(async () => {
+			const BaseUser = app.registry.findModel("User");
+			const userModels = BaseUser ? app.models().filter((model) => isUserModel(model, BaseUser)) : [];
+			disableUnconfiguredRemoteMethods();
+			const models = userModels.filter((model) => model.settings.twoFactor != null || model.settings.authenticationRateLimit?.enabled === true);
+			if (models.some((model) => model.settings.twoFactor != null)) {
+				requireUniquePrincipalProviderIndex(requirePrivateModel(app, "TwoFactorCredential"));
+				requirePrivateModel(app, "TwoFactorChallenge");
+				requirePrivateModel(app, "TwoFactorRecoveryCode");
+			}
+			const normalized = models.map((model) => ({
+				model,
+				twoFactor: require_lib_two_factor_config.normalizeTwoFactorConfig(model.settings.twoFactor),
+				rateLimit: require_lib_two_factor_config.normalizeAuthenticationRateLimitConfig(model.settings.authenticationRateLimit, model.modelName, app.get("rateLimit") || {})
+			}));
+			for (const item of normalized) {
+				if (item.twoFactor?.mode === "disabled") {
+					if (await app.models.TwoFactorCredential.count({
+						principalType: item.model.modelName,
+						status: "enabled"
+					}) !== 0) throw new Error(`Cannot disable two-factor authentication for ${item.model.modelName} with active credentials`);
+				}
+				if (!item.rateLimit) continue;
+				app.registerRateLimitSubjectKeyring(item.rateLimit.keyringName, item.model.settings.authenticationRateLimit.subjectHash);
+				if (item.rateLimit.usesApplicationStore) continue;
+				if (item.rateLimit.store.provider !== "persisted-model") throw new Error(`Rate limit provider ${item.rateLimit.store.provider} is not available`);
+				const stateModel = app.models[item.rateLimit.store.model || "RateLimitState"];
+				if (!stateModel || !stateModel.dataSource) throw new Error(`Rate limit state model ${item.rateLimit.store.model || "RateLimitState"} is not connected`);
+				const connectorName = stateModel.dataSource.connector?.name || stateModel.dataSource.settings?.connector;
+				const allowMemory = item.rateLimit.store.allowMemory === true;
+				if (connectorName === "memory" && !allowMemory) throw new Error("Memory rate limit store is allowed only when explicitly enabled");
+				app.registerRateLimitStore(item.rateLimit.storeName, new require_persisted_model.PersistedModelRateLimitStore({
+					model: stateModel,
+					allowMemory,
+					maxRetries: item.rateLimit.store.maxRetries
+				}));
+			}
+			await app.initializeRateLimiting();
+			for (const item of normalized) {
+				const limiter = item.rateLimit ? new require_lib_two_factor_rate_limit.AuthenticationRateLimiter(item.model.modelName, item.rateLimit, app.rateLimit.limiter) : null;
+				item.model._authenticationSecurity = new require_lib_two_factor_service.TwoFactorService(item.model, item.twoFactor, limiter, app);
+				item.model._authenticationSecurityReady = true;
+			}
+			app.authenticationSecurityReadiness.ready = true;
+		}).catch((error) => {
+			app.authenticationSecurityReadiness.error = error;
+			throw error;
+		});
+		if (typeof callback === "function") {
+			initialization.then(() => callback(null), callback);
+			return;
+		}
+		return initialization;
+	};
+	app.assertAuthenticationSecurityReady = function(UserModel) {
+		if ((UserModel.settings.twoFactor != null || UserModel.settings.authenticationRateLimit?.enabled === true) && !UserModel._authenticationSecurityReady) throw require_lib_two_factor_errors.authError("AUTHENTICATION_SECURITY_UNAVAILABLE", 503);
+	};
+	app.cleanupAuthenticationSecurity = function(options = {}, callback) {
+		const promise = Promise.resolve().then(async () => {
+			const now = options.now || /* @__PURE__ */ new Date();
+			const nowMs = now.getTime();
+			const terminalRetention = options.terminalRetentionMs ?? 6048e5;
+			const credentialRetention = options.disabledCredentialRetentionMs ?? 2592e6;
+			const consumingTimeout = options.consumingTimeoutMs ?? 6e5;
+			const Challenge = requirePrivateModel(app, "TwoFactorChallenge");
+			const Credential = requirePrivateModel(app, "TwoFactorCredential");
+			const RecoveryCode = requirePrivateModel(app, "TwoFactorRecoveryCode");
+			const result = {
+				expiredChallenges: 0,
+				recoveredVerifications: 0,
+				quarantinedConsumptions: 0,
+				reconciledTokens: 0,
+				releasedReservations: 0,
+				finalizedReservations: 0,
+				removedChallenges: 0,
+				expiredEnrollments: 0,
+				removedCredentials: 0,
+				removedRecoveryCodes: 0
+			};
+			const releaseReservations = async (ownerId) => {
+				const released = await RecoveryCode.updateAll({
+					status: "reserved",
+					reservationOwnerId: ownerId
+				}, {
+					status: "unused",
+					reservationId: null,
+					reservationExpiresAt: null,
+					reservationOwnerType: null,
+					reservationOwnerId: null
+				});
+				result.releasedReservations += resultCount(released);
+			};
+			const expiredChallenges = await Challenge.updateAll({
+				status: "pending",
+				expiresAt: { lte: now }
+			}, { status: "expired" });
+			result.expiredChallenges += resultCount(expiredChallenges);
+			const expiredLeases = await Challenge.find({ where: {
+				status: "verifying",
+				verificationLeaseExpiresAt: { lte: now }
+			} });
+			for (const challenge of expiredLeases) {
+				if (resultCount(await Challenge.updateAll({
+					id: challenge.id,
+					status: "verifying",
+					verificationLeaseId: challenge.verificationLeaseId
+				}, {
+					status: "reconciling_no_token",
+					verificationLeaseId: null,
+					verificationLeaseExpiresAt: null
+				})) !== 1) continue;
+				await releaseReservations(`challenge:${challenge.id}`);
+				await Challenge.updateAll({
+					id: challenge.id,
+					status: "reconciling_no_token"
+				}, { status: new Date(challenge.expiresAt).getTime() <= nowMs ? "expired" : "pending" });
+				result.recoveredVerifications++;
+			}
+			const stuckConsumptions = await Challenge.find({ where: {
+				status: "consuming",
+				claimedAt: { lte: new Date(nowMs - consumingTimeout) }
+			} });
+			for (const challenge of stuckConsumptions) {
+				const quarantined = await Challenge.updateAll({
+					id: challenge.id,
+					status: "consuming"
+				}, { status: "token_revocation_pending" });
+				result.quarantinedConsumptions += resultCount(quarantined);
+			}
+			const pendingRevocations = await Challenge.find({ where: {
+				status: "token_revocation_pending",
+				issuedTokenId: { neq: null }
+			} });
+			for (const challenge of pendingRevocations) {
+				const AccessToken = app.models[challenge.principalType]?.relations?.accessTokens?.modelTo;
+				if (!AccessToken || !challenge.issuedTokenId) continue;
+				try {
+					await AccessToken.destroyById(challenge.issuedTokenId);
+					if (await AccessToken.findById(challenge.issuedTokenId)) continue;
+				} catch {
+					continue;
+				}
+				if (resultCount(await Challenge.updateAll({
+					id: challenge.id,
+					status: "token_revocation_pending",
+					issuedTokenId: challenge.issuedTokenId
+				}, {
+					status: "token_failed",
+					issuedTokenId: null
+				})) !== 1) continue;
+				await releaseReservations(`challenge:${challenge.id}`);
+				result.reconciledTokens++;
+			}
+			const expiredReservations = await RecoveryCode.find({ where: {
+				status: "reserved",
+				reservationExpiresAt: { lte: now }
+			} });
+			for (const recoveryCode of expiredReservations) {
+				const ownerId = String(recoveryCode.reservationOwnerId || "");
+				if (!ownerId.startsWith("challenge:")) continue;
+				const challenge = await Challenge.findById(ownerId.slice(10));
+				if (!challenge) continue;
+				if (challenge.status === "consumed") {
+					const finalized = await RecoveryCode.updateAll({
+						id: recoveryCode.id,
+						status: "reserved",
+						reservationId: recoveryCode.reservationId,
+						reservationOwnerId: ownerId
+					}, {
+						status: "used",
+						usedAt: challenge.consumedAt || now,
+						reservationId: null,
+						reservationExpiresAt: null,
+						reservationOwnerType: null,
+						reservationOwnerId: null
+					});
+					result.finalizedReservations += resultCount(finalized);
+				} else if ([
+					"expired",
+					"locked",
+					"token_failed"
+				].includes(challenge.status)) await releaseReservations(ownerId);
+			}
+			const expiredEnrollments = await Credential.updateAll({
+				status: "pending",
+				pendingExpiresAt: { lte: now }
+			}, {
+				status: "disabled",
+				encryptedSecret: null,
+				secretKeyId: null,
+				enrollmentTokenDigest: null,
+				disabledAt: now,
+				updatedAt: now
+			});
+			result.expiredEnrollments += resultCount(expiredEnrollments);
+			const credentials = await Credential.find({});
+			const retainedCredentialIds = new Set(credentials.map((credential) => String(credential.id)));
+			for (const credential of credentials) {
+				const UserModel = app.models[credential.principalType];
+				const principalExists = UserModel && await UserModel.findById(credential.principalId, { fields: { id: true } });
+				const disabledExpired = credential.status === "disabled" && credential.disabledAt && new Date(credential.disabledAt).getTime() <= nowMs - credentialRetention;
+				if (!principalExists || disabledExpired) {
+					const removedCodes = await RecoveryCode.destroyAll({ credentialId: String(credential.id) });
+					const removedChallenges = await Challenge.destroyAll({ credentialId: String(credential.id) });
+					const removedCredential = await Credential.destroyAll({ id: credential.id });
+					result.removedRecoveryCodes += resultCount(removedCodes);
+					result.removedChallenges += resultCount(removedChallenges);
+					result.removedCredentials += resultCount(removedCredential);
+					retainedCredentialIds.delete(String(credential.id));
+					continue;
+				}
+				if (credential.activeRecoveryCodeSetId) {
+					const removedCodes = await RecoveryCode.destroyAll({
+						credentialId: String(credential.id),
+						setId: { neq: credential.activeRecoveryCodeSetId },
+						status: { neq: "reserved" }
+					});
+					result.removedRecoveryCodes += resultCount(removedCodes);
+				} else {
+					const removedCodes = await RecoveryCode.destroyAll({
+						credentialId: String(credential.id),
+						status: { neq: "reserved" }
+					});
+					result.removedRecoveryCodes += resultCount(removedCodes);
+				}
+			}
+			const recoveryCredentialIds = new Set((await RecoveryCode.find({ fields: { credentialId: true } })).map((recoveryCode) => String(recoveryCode.credentialId)));
+			const orphanedCredentialIds = Array.from(recoveryCredentialIds).filter((credentialId) => !retainedCredentialIds.has(credentialId));
+			if (orphanedCredentialIds.length) {
+				const removedCodes = await RecoveryCode.destroyAll({
+					credentialId: { inq: orphanedCredentialIds },
+					status: { neq: "reserved" }
+				});
+				result.removedRecoveryCodes += resultCount(removedCodes);
+			}
+			const terminalChallenges = await Challenge.find({
+				where: {
+					status: { inq: [
+						"expired",
+						"consumed",
+						"locked",
+						"token_failed"
+					] },
+					expiresAt: { lt: new Date(nowMs - terminalRetention) }
+				},
+				fields: { id: true }
+			});
+			for (const challenge of terminalChallenges) {
+				if (await RecoveryCode.count({
+					status: "reserved",
+					reservationOwnerId: `challenge:${challenge.id}`
+				}) !== 0) continue;
+				const removed = await Challenge.destroyAll({ id: challenge.id });
+				result.removedChallenges += resultCount(removed);
+			}
+			return result;
+		});
+		if (typeof callback === "function") {
+			promise.then((result) => callback(null, result), callback);
+			return;
+		}
+		return promise;
+	};
+	app.rotateAuthenticationSecurityEncryption = function(options = {}, callback) {
+		const promise = Promise.resolve().then(async () => {
+			if (!app.authenticationSecurityReadiness.ready) throw require_lib_two_factor_errors.authError("AUTHENTICATION_SECURITY_UNAVAILABLE", 503);
+			const BaseUser = app.registry.findModel("User");
+			const models = BaseUser ? app.models().filter((model) => isUserModel(model, BaseUser) && model.settings.twoFactor != null && model._authenticationSecurity) : [];
+			const perModel = {};
+			for (const model of models) perModel[model.modelName] = await model._authenticationSecurity.rotateEncryption(options);
+			return perModel;
+		});
+		if (typeof callback === "function") {
+			promise.then((result) => callback(null, result), callback);
+			return;
+		}
+		return promise;
+	};
+	app.once("booted", function() {
+		app.initializeAuthenticationSecurity().catch((error) => {
+			app.emit("authenticationSecurityError", error);
+		});
+	});
+}
+var init_authentication_security_initializer = require_runtime.__esmMin((() => {
+	require_persisted_model.init_persisted_model();
+	require_lib_two_factor_config.init_config();
+	require_lib_two_factor_rate_limit.init_rate_limit();
+	require_lib_two_factor_service.init_service();
+	require_lib_two_factor_errors.init_errors();
+}));
+//#endregion
+init_authentication_security_initializer();
+Object.defineProperty(exports, "authentication_security_initializer_exports", {
+	enumerable: true,
+	get: function() {
+		return authentication_security_initializer_exports;
+	}
+});
+Object.defineProperty(exports, "init_authentication_security_initializer", {
+	enumerable: true,
+	get: function() {
+		return init_authentication_security_initializer;
+	}
+});
+exports.installAuthenticationSecurity = installAuthenticationSecurity;

package/dist/lib/authentication-security-initializer.d.cts

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

package/dist/lib/builtin-models.cjs

@@ -10,6 +10,14 @@ const require_access_token$2 = require("../common/models/access-token2.cjs");
 const require_common_models_access_token = require("../common/models/access-token.cjs");
 const require_user$2 = require("../common/models/user2.cjs");
 const require_common_models_user = require("../common/models/user.cjs");
+const require_rate_limit_state$2 = require("../common/models/rate-limit-state2.cjs");
+const require_common_models_rate_limit_state = require("../common/models/rate-limit-state.cjs");
+const require_two_factor_credential$2 = require("../common/models/two-factor-credential2.cjs");
+const require_common_models_two_factor_credential = require("../common/models/two-factor-credential.cjs");
+const require_two_factor_challenge$2 = require("../common/models/two-factor-challenge2.cjs");
+const require_common_models_two_factor_challenge = require("../common/models/two-factor-challenge.cjs");
+const require_two_factor_recovery_code$2 = require("../common/models/two-factor-recovery-code2.cjs");
+const require_common_models_two_factor_recovery_code = require("../common/models/two-factor-recovery-code.cjs");
 const require_role_mapping$2 = require("../common/models/role-mapping2.cjs");
 const require_common_models_role_mapping = require("../common/models/role-mapping.cjs");
 const require_role$2 = require("../common/models/role2.cjs");
@@ -31,6 +39,10 @@ var require_builtin_models = /* @__PURE__ */ require_runtime.__commonJSMin(((exp
 		registry.Application = createModel(registry, require_application$2.default, require_common_models_application);
 		registry.AccessToken = createModel(registry, require_access_token$2.default, require_common_models_access_token);
 		registry.User = createModel(registry, require_user$2.default, require_common_models_user);
+		registry.RateLimitState = createModel(registry, require_rate_limit_state$2.default, require_common_models_rate_limit_state);
+		registry.TwoFactorCredential = createModel(registry, require_two_factor_credential$2.default, require_common_models_two_factor_credential);
+		registry.TwoFactorChallenge = createModel(registry, require_two_factor_challenge$2.default, require_common_models_two_factor_challenge);
+		registry.TwoFactorRecoveryCode = createModel(registry, require_two_factor_recovery_code$2.default, require_common_models_two_factor_recovery_code);
 		registry.RoleMapping = createModel(registry, require_role_mapping$2.default, require_common_models_role_mapping);
 		registry.Role = createModel(registry, require_role$2.default, require_common_models_role);
 		registry.ACL = createModel(registry, require_acl$2.default, require_common_models_acl);

package/dist/lib/builtin-models.d.cts

@@ -0,0 +1,3 @@
+//#region src/lib/builtin-models.d.ts
+declare function defineBuiltinModels(registry: any): void;
+export = defineBuiltinModels;

package/dist/lib/configure-shared-methods.cjs

@@ -24,11 +24,14 @@ var require_configure_shared_methods = /* @__PURE__ */ require_runtime.__commonJ
 		}) || [];
 		sharedMethods.forEach(function(sharedMethod) {
 			const methodName = sharedMethod.isStatic ? sharedMethod.name : "prototype." + sharedMethod.name;
-			if (Object.prototype.hasOwnProperty.call(settings, methodName)) if (settings[methodName] === false) sharedMethod.sharedClass.disableMethodByName(methodName);
-			else sharedMethod.shared = true;
-			else tests.forEach(function(glob) {
-				if (glob.regex.test(methodName)) if (glob.setting === false) sharedMethod.sharedClass.disableMethodByName(methodName);
+			if (Object.prototype.hasOwnProperty.call(settings, methodName)) {
+				if (settings[methodName] === false) sharedMethod.sharedClass.disableMethodByName(methodName);
 				else sharedMethod.shared = true;
+			} else tests.forEach(function(glob) {
+				if (glob.regex.test(methodName)) {
+					if (glob.setting === false) sharedMethod.sharedClass.disableMethodByName(methodName);
+					else sharedMethod.shared = true;
+				}
 			});
 		});
 	}

package/dist/lib/configure-shared-methods.d.cts

@@ -0,0 +1,3 @@
+//#region src/lib/configure-shared-methods.d.ts
+declare function configureSharedMethods(modelCtor: any, remotingConfig: any, modelConfig: any): void;
+export = configureSharedMethods;

package/dist/lib/connectors/base-connector.d.cts

@@ -0,0 +1,6 @@
+//#region src/lib/connectors/base-connector.d.ts
+declare function Connector(options: any): void;
+declare namespace Connector {
+  var _createJDBAdapter: (jdbModule: any) => void;
+}
+export = Connector;

package/dist/lib/connectors/mail-direct-transport.cjs

@@ -160,11 +160,13 @@ var require_mail_direct_transport = /* @__PURE__ */ require("../../_virtual/_rol
 								combinedInfo.pending = combinedInfo.pending.concat(info.pending || []);
 								combinedInfo.messageId = info.messageId;
 							}
-							if (returned >= domains.length) if (combinedInfo.errors.length === domains.length) {
-								const sendError = /* @__PURE__ */ new Error("Sending failed");
-								sendError.errors = combinedInfo.errors;
-								callback(sendError);
-							} else callback(null, combinedInfo);
+							if (returned >= domains.length) {
+								if (combinedInfo.errors.length === domains.length) {
+									const sendError = /* @__PURE__ */ new Error("Sending failed");
+									sendError.errors = combinedInfo.errors;
+									callback(sendError);
+								} else callback(null, combinedInfo);
+							}
 						}
 					};
 					this._queue.insert(item);
@@ -191,29 +193,30 @@ var require_mail_direct_transport = /* @__PURE__ */ require("../../_virtual/_rol
 						return item.exchange;
 					});
 					this._process([].concat(exchanges), data, (processErr, response) => {
-						if (processErr) if (processErr.responseCode && processErr.responseCode >= 500) {
-							processErr.domain = data.domain;
-							processErr.exchange = exchanges[0];
-							processErr.recipients = data.envelope.to;
-							data.callback(processErr);
-						} else {
-							data.replies = (data.replies || 0) + 1;
-							if (data.replies <= 5) {
-								this._queue.insert(data, this.options.retryDelay || data.replies * 15 * 60 * 1e3);
-								data.callback(null, { pending: {
-									domain: data.domain,
-									exchange: exchanges[0],
-									recipients: data.envelope.to,
-									response: processErr.response
-								} });
-							} else {
+						if (processErr) {
+							if (processErr.responseCode && processErr.responseCode >= 500) {
 								processErr.domain = data.domain;
 								processErr.exchange = exchanges[0];
 								processErr.recipients = data.envelope.to;
 								data.callback(processErr);
+							} else {
+								data.replies = (data.replies || 0) + 1;
+								if (data.replies <= 5) {
+									this._queue.insert(data, this.options.retryDelay || data.replies * 15 * 60 * 1e3);
+									data.callback(null, { pending: {
+										domain: data.domain,
+										exchange: exchanges[0],
+										recipients: data.envelope.to,
+										response: processErr.response
+									} });
+								} else {
+									processErr.domain = data.domain;
+									processErr.exchange = exchanges[0];
+									processErr.recipients = data.envelope.to;
+									data.callback(processErr);
+								}
 							}
-						}
-						else data.callback(null, response);
+						} else data.callback(null, response);
 						setImmediate(this._loop.bind(this));
 					});
 				});

package/dist/lib/connectors/mail-direct-transport.d.cts

@@ -0,0 +1,22 @@
+//#region src/lib/connectors/mail-direct-transport.d.ts
+declare const EventEmitter: any;
+declare function createDirectTransport(options: any): DirectTransport;
+declare class DirectTransport extends EventEmitter {
+  options: any;
+  _queue: any;
+  _started: any;
+  _lastId: any;
+  name: any;
+  version: any;
+  constructor(options: any);
+  get length(): any;
+  getSocket(options: any, callback: any): void;
+  send(mail: any, callback: any): void;
+  _loop(): void;
+  _process(exchanges: any, data: any, callback: any): void;
+  _formatMessage(message: any): void;
+  _clearStreams(mail: any, callback: any): void;
+  _resolveMx(domain: any, callback: any): void;
+  _resolveHostname(name: any): any;
+}
+export = createDirectTransport;

package/dist/lib/connectors/mail-stub-transport.d.cts

@@ -0,0 +1,14 @@
+//#region src/lib/connectors/mail-stub-transport.d.ts
+declare const EventEmitter: any;
+declare function createStubTransport(options: any): StubTransport;
+declare class StubTransport extends EventEmitter {
+  options: any;
+  name: any;
+  version: any;
+  constructor(options: any);
+  isIdle(): boolean;
+  verify(callback: any): void;
+  send(mail: any, callback: any): void;
+  _log(level: any, type: any, ...args: any[]): void;
+}
+export = createStubTransport;

package/dist/lib/connectors/mail.d.cts

@@ -0,0 +1,7 @@
+//#region src/lib/connectors/mail.d.ts
+declare function MailConnector(settings: any): void;
+declare namespace MailConnector {
+  var initialize: (dataSource: any, callback: any) => void;
+  var mailer: any;
+}
+export = MailConnector;

package/dist/lib/connectors/memory.d.cts

@@ -0,0 +1,6 @@
+//#region src/lib/connectors/memory.d.ts
+declare function Memory(): void;
+declare namespace Memory {
+  var initialize: any;
+}
+export = Memory;

package/dist/lib/current-context.d.cts

@@ -0,0 +1,3 @@
+//#region src/lib/current-context.d.ts
+declare function currentContext(loopback: any): void;
+export = currentContext;

package/dist/lib/globalize.d.cts

@@ -0,0 +1,10 @@
+//#region src/lib/globalize.d.ts
+declare function f(message: any): any;
+declare function log(message: any): void;
+declare function warn(message: any): void;
+declare const globalize: {
+  f: typeof f;
+  log: typeof log;
+  warn: typeof warn;
+};
+export = globalize;

package/dist/lib/loopback.cjs

@@ -5,6 +5,8 @@ const require_lib_runtime = require("./runtime.cjs");
 const require_lib_registry = require("./registry.cjs");
 const require_lib_application = require("./application.cjs");
 const require_lib_configure_shared_methods = require("./configure-shared-methods.cjs");
+const require_lib_rate_limit_initializer = require("./rate-limit/initializer.cjs");
+const require_lib_authentication_security_initializer = require("./authentication-security-initializer.cjs");
 const require_package$1 = require("../package.cjs");
 const require_lib_builtin_models = require("./builtin-models.cjs");
 const require_lib_current_context = require("./current-context.cjs");
@@ -24,6 +26,8 @@ var require_loopback = /* @__PURE__ */ require_runtime$1.__commonJSMin(((exports
 	const Registry = require_lib_registry;
 	const juggler = require("@vsaas/loopback-datasource-juggler");
 	const configureSharedMethods = require_lib_configure_shared_methods;
+	const installRateLimiting = (require_lib_rate_limit_initializer.init_initializer(), require_runtime$1.__toCommonJS(require_lib_rate_limit_initializer.initializer_exports)).installRateLimiting;
+	const installAuthenticationSecurity = (require_lib_authentication_security_initializer.init_authentication_security_initializer(), require_runtime$1.__toCommonJS(require_lib_authentication_security_initializer.authentication_security_initializer_exports)).installAuthenticationSecurity;
 	/**
 	* LoopBack core module. It provides static properties and
 	* methods to create models and data sources. The module itself is a function
@@ -73,6 +77,8 @@ var require_loopback = /* @__PURE__ */ require_runtime$1.__commonJSMin(((exports
 	function createApplication(options) {
 		const app = loopbackExpress();
 		Object.assign(app, proto);
+		installRateLimiting(app);
+		installAuthenticationSecurity(app);
 		app.loopback = loopback;
 		app.on("modelRemoted", function() {
 			app.models().forEach(function(Model) {

package/dist/lib/loopback.d.cts

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

package/dist/lib/model.d.cts

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

package/dist/lib/persisted-model.cjs

@@ -1389,9 +1389,7 @@ var require_persisted_model = /* @__PURE__ */ require_runtime$1.__commonJSMin(((
 							});
 						});
 						break;
-					case Change.DELETE:
-						updates.push(update);
-						break;
+					case Change.DELETE: updates.push(update);
 				}
 			});
 			Promise.all(tasks.map(function(task) {
@@ -1434,11 +1432,9 @@ var require_persisted_model = /* @__PURE__ */ require_runtime$1.__commonJSMin(((
 								applyCreate(Model, id, current, update.data, update.change, conflicts, options, cb);
 							});
 							break;
-						case Change.DELETE:
-							tasks.push(function(cb) {
-								applyDelete(Model, id, current, update.change, conflicts, options, cb);
-							});
-							break;
+						case Change.DELETE: tasks.push(function(cb) {
+							applyDelete(Model, id, current, update.change, conflicts, options, cb);
+						});
 					}
 				});
 				Promise.all(tasks.map(function(task) {
@@ -1554,7 +1550,8 @@ var require_persisted_model = /* @__PURE__ */ require_runtime$1.__commonJSMin(((
 		*/
 		PersistedModel.getChangeModel = function() {
 			const changeModel = this.Change;
-			assert(changeModel && changeModel.dataSource, "Cannot get a setup Change model for " + this.modelName);
+			const isSetup = changeModel && changeModel.dataSource;
+			assert(isSetup, "Cannot get a setup Change model for " + this.modelName);
 			return changeModel;
 		};
 		/**
@@ -1750,9 +1747,7 @@ var require_persisted_model = /* @__PURE__ */ require_runtime$1.__commonJSMin(((
 						if (ctx.isNewInstance === void 0) change.type = hasTarget ? "update" : "create";
 						else change.type = ctx.isNewInstance ? "create" : "update";
 						break;
-					case "delete":
-						change.type = "remove";
-						break;
+					case "delete": change.type = "remove";
 				}
 				return change;
 			}

package/dist/lib/persisted-model.d.cts

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