@vsaas/loopback 10.0.0

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

@@ -0,0 +1,375 @@
+"use strict";
+//#region src/lib/connectors/mail-direct-transport.ts
+var require_mail_direct_transport = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const path = require("path");
+	const debug = require("debug")("loopback:connector:mail:direct");
+	const dns = require("dns");
+	const EventEmitter = require("events");
+	const net = require("net");
+	const os = require("os");
+	const SMTPConnection = require("nodemailer/lib/smtp-connection/index.js");
+	const packageData = require(path.join(__dirname, "..", "..", "..", "node_modules", "nodemailer", "package.json"));
+	function createDirectTransport(options) {
+		return new DirectTransport(options);
+	}
+	var MessageQueue = class {
+		_instantQueue;
+		_sortedQueue;
+		_shiftTimer;
+		_callbackQueue;
+		constructor() {
+			this._instantQueue = [];
+			this._sortedQueue = [];
+			this._shiftTimer = null;
+			this._callbackQueue = [];
+		}
+		get(callback) {
+			if (this._instantQueue.length) {
+				callback(this._instantQueue.pop());
+				return;
+			}
+			this._callbackQueue.unshift(callback);
+		}
+		insert(data, delay) {
+			if (typeof delay !== "number") {
+				this._instantQueue.unshift(data);
+				this._processInsert();
+				return true;
+			}
+			const container = {
+				data,
+				available: Date.now() + delay
+			};
+			let insertedIndex = -1;
+			for (let index = 0; index < this._sortedQueue.length; index++) if (this._sortedQueue[index].available >= container.available) {
+				this._sortedQueue.splice(index, 0, container);
+				insertedIndex = index;
+				break;
+			}
+			if (insertedIndex === -1) {
+				this._sortedQueue.push(container);
+				insertedIndex = 0;
+			}
+			if (insertedIndex === 0) this._updateShiftTimer();
+			return true;
+		}
+		_updateShiftTimer() {
+			clearTimeout(this._shiftTimer);
+			if (!this._sortedQueue.length) return;
+			const nextShift = this._sortedQueue[0].available;
+			if (nextShift <= Date.now()) {
+				this._shiftSorted();
+				return;
+			}
+			this._shiftTimer = setTimeout(this._shiftSorted.bind(this), nextShift - Date.now() + 15);
+			if (this._shiftTimer && typeof this._shiftTimer.unref === "function") this._shiftTimer.unref();
+		}
+		_shiftSorted() {
+			if (!this._sortedQueue.length) return;
+			if (this._sortedQueue[0].available <= Date.now()) {
+				const container = this._sortedQueue.shift();
+				this.insert(container.data);
+			}
+			this._updateShiftTimer();
+		}
+		_processInsert() {
+			if (this._instantQueue.length && this._callbackQueue.length) this._callbackQueue.pop()(this._instantQueue.pop());
+		}
+	};
+	var DirectTransport = class extends EventEmitter {
+		options;
+		_queue;
+		_started;
+		_lastId;
+		name;
+		version;
+		constructor(options) {
+			super();
+			this.options = options || {};
+			this._queue = new MessageQueue();
+			this._started = false;
+			this._lastId = 0;
+			if (typeof this.options.getSocket === "function") this.getSocket = this.options.getSocket;
+			const connection = new SMTPConnection({});
+			this.name = "SMTP (direct)";
+			this.version = packageData.version + "[client:" + connection.version + "]";
+		}
+		get length() {
+			return this._queue._instantQueue.length + this._queue._sortedQueue.length;
+		}
+		getSocket(options, callback) {
+			callback(null, false);
+		}
+		send(mail, callback) {
+			const envelope = mail.message.getEnvelope();
+			const domainEnvelopes = {};
+			if (!envelope.from) {
+				callback(/* @__PURE__ */ new Error("\"From\" address missing"));
+				return;
+			}
+			envelope.to = [].concat(envelope.to || []);
+			if (!envelope.to.length) {
+				callback("\"Recipients\" addresses missing");
+				return;
+			}
+			this._clearStreams(mail, (err) => {
+				if (err) {
+					callback(err);
+					return;
+				}
+				this._formatMessage(mail.message);
+				envelope.to.forEach(function(recipient) {
+					recipient = (recipient || "").toString();
+					const domain = (recipient.split("@").pop() || "").toLowerCase().trim();
+					if (!domainEnvelopes[domain]) domainEnvelopes[domain] = {
+						from: envelope.from,
+						to: [recipient]
+					};
+					else if (domainEnvelopes[domain].to.indexOf(recipient) === -1) domainEnvelopes[domain].to.push(recipient);
+				});
+				let returned = 0;
+				const domains = Object.keys(domainEnvelopes);
+				const combinedInfo = {
+					accepted: [],
+					rejected: [],
+					pending: [],
+					errors: [],
+					envelope: mail.message.getEnvelope()
+				};
+				domains.forEach((domain) => {
+					let called = false;
+					const id = ++this._lastId;
+					const item = {
+						envelope: domainEnvelopes[domain],
+						data: mail.data,
+						message: mail.message,
+						domain,
+						id,
+						callback: (err, info) => {
+							if (called) {
+								debug("Callback for #%s already called. Updated values: %o", id, err || info);
+								return;
+							}
+							called = true;
+							returned++;
+							if (err) {
+								combinedInfo.errors.push(err);
+								if (err.recipients) combinedInfo.rejected = combinedInfo.rejected.concat(err.recipients || []);
+							} else if (info) {
+								combinedInfo.accepted = combinedInfo.accepted.concat(info.accepted || []);
+								combinedInfo.rejected = combinedInfo.rejected.concat(info.rejected || []);
+								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);
+						}
+					};
+					this._queue.insert(item);
+				});
+				if (!this._started) {
+					this._started = true;
+					setImmediate(this._loop.bind(this));
+				}
+			});
+		}
+		_loop() {
+			this._queue.get((data) => {
+				debug("Retrieved message #%s from the queue, resolving %s", data.id, data.domain);
+				this._resolveMx(data.domain, (err, list) => {
+					if (err || !list || !list.length) {
+						data.callback(err || /* @__PURE__ */ new Error("Could not resolve MX for " + data.domain));
+						setImmediate(this._loop.bind(this));
+						return;
+					}
+					list.sort(function(a, b) {
+						return (a && a.priority || 0) - (b && b.priority || 0);
+					});
+					const exchanges = list.map(function(item) {
+						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 {
+								processErr.domain = data.domain;
+								processErr.exchange = exchanges[0];
+								processErr.recipients = data.envelope.to;
+								data.callback(processErr);
+							}
+						}
+						else data.callback(null, response);
+						setImmediate(this._loop.bind(this));
+					});
+				});
+			});
+		}
+		_process(exchanges, data, callback) {
+			const options = {
+				host: exchanges[0],
+				port: this.options.port || 25,
+				requireTLS: !data.ignoreTLS,
+				ignoreTLS: !!data.ignoreTLS,
+				tls: { rejectUnauthorized: false }
+			};
+			Object.keys(this.options).forEach((key) => {
+				options[key] = this.options[key];
+			});
+			this.getSocket(options, (err, socketOptions) => {
+				if (err) {
+					exchanges.shift();
+					if (!exchanges.length) {
+						callback(err);
+						return;
+					}
+					this._process(exchanges, data, callback);
+					return;
+				}
+				if (socketOptions && socketOptions.connection) Object.keys(socketOptions).forEach(function(key) {
+					options[key] = socketOptions[key];
+				});
+				const connection = new SMTPConnection(options);
+				let returned = false;
+				let connected = false;
+				connection.once("error", (error) => {
+					if (returned) return;
+					returned = true;
+					if (error.code === "ETLS") {
+						data.ignoreTLS = true;
+						this._process(exchanges, data, callback);
+						return;
+					}
+					if (!connected) {
+						exchanges.shift();
+						if (!exchanges.length) {
+							callback(error);
+							return;
+						}
+						this._process(exchanges, data, callback);
+						return;
+					}
+					callback(error);
+				});
+				const sendMessage = () => {
+					connection.send(data.envelope, data.message.createReadStream(), (sendErr, info) => {
+						if (returned) return;
+						returned = true;
+						connection.close();
+						if (sendErr) {
+							callback(sendErr);
+							return;
+						}
+						info.messageId = (data.message.getHeader("message-id") || "").replace(/[<>\s]/g, "");
+						callback(null, info);
+					});
+				};
+				connection.connect(() => {
+					connected = true;
+					if (returned) return;
+					sendMessage();
+				});
+			});
+		}
+		_formatMessage(message) {
+			const hostname = this._resolveHostname(this.options.name);
+			message._headers.unshift({
+				key: "Received",
+				value: "from localhost (127.0.0.1) by " + hostname + " with SMTP; " + Date()
+			});
+		}
+		_clearStreams(mail, callback) {
+			const streamNodes = [];
+			function walkNode(node) {
+				if (node.content && typeof node.content.pipe === "function") streamNodes.push(node);
+				if (node.childNodes && node.childNodes.length) node.childNodes.forEach(walkNode);
+			}
+			walkNode(mail.message);
+			const resolveNodes = () => {
+				if (!streamNodes.length) {
+					callback();
+					return;
+				}
+				const node = streamNodes.shift();
+				mail.resolveContent(node, "content", (err) => {
+					if (err) {
+						callback(err);
+						return;
+					}
+					setImmediate(resolveNodes);
+				});
+			};
+			resolveNodes();
+		}
+		_resolveMx(domain, callback) {
+			domain = domain.replace(/^\[(ipv6:)?|\]$/gi, "");
+			if (net.isIP(domain)) {
+				callback(null, [{
+					priority: 0,
+					exchange: domain
+				}]);
+				return;
+			}
+			dns.resolveMx(domain, function(err, list) {
+				if (err) {
+					if (err.code === "ENODATA" || err.code === "ENOTFOUND") {
+						dns.resolve4(domain, function(resolve4Err, ipv4List) {
+							if (resolve4Err) {
+								if (resolve4Err.code === "ENODATA" || resolve4Err.code === "ENOTFOUND") {
+									dns.resolve6(domain, function(resolve6Err, ipv6List) {
+										if (resolve6Err) {
+											callback(resolve6Err);
+											return;
+										}
+										callback(null, [].concat(ipv6List || []).map(function(entry) {
+											return {
+												priority: 0,
+												exchange: entry
+											};
+										}).slice(0, 1));
+									});
+									return;
+								}
+								callback(resolve4Err);
+								return;
+							}
+							callback(null, [].concat(ipv4List || []).map(function(entry) {
+								return {
+									priority: 0,
+									exchange: entry
+								};
+							}).slice(0, 1));
+						});
+						return;
+					}
+					callback(err);
+					return;
+				}
+				callback(null, list);
+			});
+		}
+		_resolveHostname(name) {
+			if (!name || net.isIP(name.replace(/[\[\]]/g, "").trim())) name = os.hostname && os.hostname() || "";
+			if (!name || net.isIP(name.replace(/[\[\]]/g, "").trim())) name = "localhost";
+			return name.toLowerCase();
+		}
+	};
+	module.exports = createDirectTransport;
+}));
+//#endregion
+module.exports = require_mail_direct_transport();

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

@@ -0,0 +1,86 @@
+"use strict";
+//#region src/lib/connectors/mail-stub-transport.ts
+var require_mail_stub_transport = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const EventEmitter = require("events");
+	const util = require("util");
+	const packageData = require("nodemailer/package.json");
+	function createStubTransport(options) {
+		return new StubTransport(options);
+	}
+	var StubTransport = class extends EventEmitter {
+		options;
+		name;
+		version;
+		constructor(options) {
+			super();
+			this.options = options || {};
+			this.name = "Stub";
+			this.version = packageData.version;
+		}
+		isIdle() {
+			return true;
+		}
+		verify(callback) {
+			setImmediate(() => {
+				if (this.options.error) return callback(asError(this.options.error));
+				return callback(null, true);
+			});
+		}
+		send(mail, callback) {
+			if (this.options.error) {
+				setImmediate(() => {
+					callback(asError(this.options.error));
+				});
+				return;
+			}
+			if (this.options.keepBcc) mail.message.keepBcc = true;
+			const message = mail.message.createReadStream();
+			const chunks = [];
+			let chunkLength = 0;
+			const envelope = mail.data.envelope || mail.message.getEnvelope();
+			this._log("info", "envelope", JSON.stringify(envelope));
+			this.emit("envelope", envelope);
+			message.on("error", (err) => {
+				setImmediate(() => {
+					callback(err);
+				});
+			});
+			message.on("data", (chunk) => {
+				chunks.push(chunk);
+				chunkLength += chunk.length;
+				this._log("verbose", "message", chunk.toString());
+				this.emit("data", chunk.toString());
+			});
+			message.on("end", () => {
+				setImmediate(() => {
+					const messageId = String(mail.message.getHeader("message-id") || "").replace(/[<>\s]/g, "");
+					const response = Buffer.concat(chunks, chunkLength);
+					const info = {
+						envelope: mail.data.envelope || mail.message.getEnvelope(),
+						messageId,
+						response
+					};
+					this._log("info", "end", "Processed <%s> (%sB)", messageId, response.length);
+					this.emit("end", info);
+					callback(null, info);
+				});
+			});
+		}
+		_log(level, type, ...args) {
+			const message = util.format.apply(util, args);
+			this.emit("log", {
+				name: "loopback-stub-transport",
+				version: this.version,
+				level: (level || "info").toUpperCase(),
+				type: type || "",
+				message
+			});
+		}
+	};
+	function asError(error) {
+		return error instanceof Error ? error : new Error(error);
+	}
+	module.exports = createStubTransport;
+}));
+//#endregion
+module.exports = require_mail_stub_transport();

package/dist/lib/connectors/mail.cjs

@@ -0,0 +1,128 @@
+"use strict";
+const require_runtime$1 = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("../globalize.cjs");
+const require_lib_runtime = require("../runtime.cjs");
+const require_lib_connectors_mail_direct_transport = require("./mail-direct-transport.cjs");
+const require_lib_connectors_mail_stub_transport = require("./mail-stub-transport.cjs");
+//#region src/lib/connectors/mail.ts
+/**
+* Dependencies.
+*/
+var require_mail = /* @__PURE__ */ require_runtime$1.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	const mailer = require("nodemailer");
+	const createDirectTransport = require_lib_connectors_mail_direct_transport;
+	const createStubTransport = require_lib_connectors_mail_stub_transport;
+	const assert = require("assert");
+	const debug = require("debug")("loopback:connector:mail");
+	const runtime = require_lib_runtime;
+	function MailConnector(settings) {
+		assert(typeof settings === "object", "cannot initialize MailConnector without a settings object");
+		let transports = settings.transports;
+		if (!transports && settings.transport) transports = [settings.transport];
+		if (!transports) transports = [];
+		this.transportsIndex = {};
+		this.transports = [];
+		if (runtime.isServer) transports.forEach(this.setupTransport.bind(this));
+	}
+	MailConnector.initialize = function(dataSource, callback) {
+		dataSource.connector = new MailConnector(dataSource.settings);
+		callback();
+	};
+	MailConnector.prototype.DataAccessObject = Mailer;
+	MailConnector.prototype.setupTransport = function(setting) {
+		const connector = this;
+		connector.transports = connector.transports || [];
+		connector.transportsIndex = connector.transportsIndex || {};
+		let transport;
+		const transportType = (setting.type || "STUB").toLowerCase();
+		if (transportType === "smtp") transport = mailer.createTransport(setting);
+		else if (transportType === "direct") transport = mailer.createTransport(createDirectTransport(setting));
+		else if (transportType === "stub") transport = mailer.createTransport(createStubTransport(setting));
+		else if (transportType === "ses" && supportsBuiltinSesTransport(setting)) transport = mailer.createTransport(createBuiltinSesTransportConfig(setting));
+		else {
+			const transportModuleName = "nodemailer-" + transportType + "-transport";
+			const transportModule = require(transportModuleName);
+			transport = mailer.createTransport(transportModule(setting));
+		}
+		connector.transportsIndex[setting.alias || setting.type] = transport;
+		connector.transports.push(transport);
+	};
+	function supportsBuiltinSesTransport(setting) {
+		return !!(setting.SES || setting.sesClient && setting.SendEmailCommand || hasLegacySesCredentials(setting));
+	}
+	function createBuiltinSesTransportConfig(setting) {
+		const transportConfig = Object.assign({}, setting);
+		delete transportConfig.alias;
+		delete transportConfig.type;
+		if (!transportConfig.SES) transportConfig.SES = createSesTransportOptions(transportConfig);
+		delete transportConfig.sesClient;
+		delete transportConfig.SendEmailCommand;
+		delete transportConfig.accessKeyId;
+		delete transportConfig.secretAccessKey;
+		delete transportConfig.sessionToken;
+		delete transportConfig.region;
+		return transportConfig;
+	}
+	function hasLegacySesCredentials(setting) {
+		return !!(setting && setting.accessKeyId && setting.secretAccessKey && setting.region);
+	}
+	function createSesTransportOptions(setting) {
+		if (setting.sesClient && setting.SendEmailCommand) return {
+			sesClient: setting.sesClient,
+			SendEmailCommand: setting.SendEmailCommand
+		};
+		if (!hasLegacySesCredentials(setting)) return setting.SES;
+		const ses = require("@aws-sdk/client-sesv2");
+		const clientConfig = { region: setting.region };
+		clientConfig.credentials = {
+			accessKeyId: setting.accessKeyId,
+			secretAccessKey: setting.secretAccessKey
+		};
+		if (setting.sessionToken) clientConfig.credentials.sessionToken = setting.sessionToken;
+		return {
+			sesClient: new ses.SESv2Client(clientConfig),
+			SendEmailCommand: ses.SendEmailCommand
+		};
+	}
+	function Mailer() {}
+	MailConnector.prototype.transportForName = function(name) {
+		return this.transportsIndex[name];
+	};
+	MailConnector.prototype.defaultTransport = function() {
+		return this.transports[0] || this.stubTransport;
+	};
+	Mailer.send = function(options, fn) {
+		const dataSource = this.dataSource;
+		const settings = dataSource && dataSource.settings;
+		const connector = dataSource.connector;
+		assert(connector, "Cannot send mail without a connector!");
+		let transport = connector.transportForName(options.transport);
+		if (!transport) transport = connector.defaultTransport();
+		if (debug.enabled || settings && settings.debug) {
+			g.log("Sending Mail:");
+			if (options.transport) console.log(g.f("	 TRANSPORT:%s", options.transport));
+			g.log("	 TO:%s", options.to);
+			g.log("	 FROM:%s", options.from);
+			g.log("	 SUBJECT:%s", options.subject);
+			g.log("	 TEXT:%s", options.text);
+			g.log("	 HTML:%s", options.html);
+		}
+		if (transport) {
+			assert(transport.sendMail, "You must supply an Email.settings.transports containing a valid transport");
+			transport.sendMail(options, fn);
+		} else {
+			g.warn("Warning: No email transport specified for sending email. Setup a transport to send mail messages.");
+			process.nextTick(function() {
+				fn(null, options);
+			});
+		}
+	};
+	Mailer.prototype.send = function(fn) {
+		this.constructor.send(this, fn);
+	};
+	MailConnector.mailer = MailConnector.prototype.mailer = Mailer.mailer = Mailer.prototype.mailer = mailer;
+	module.exports = MailConnector;
+}));
+//#endregion
+module.exports = require_mail();

package/dist/lib/connectors/memory.cjs

@@ -0,0 +1,19 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_connectors_base_connector = require("./base-connector.cjs");
+//#region src/lib/connectors/memory.ts
+/**
+* Expose `Memory`.
+*/
+var require_memory = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	require("debug")("memory");
+	const inherits = require("util").inherits;
+	const JdbMemory = require("@vsaas/loopback-datasource-juggler/connectors/memory");
+	const Connector = require_lib_connectors_base_connector;
+	function Memory() {}
+	inherits(Memory, Connector);
+	Memory.initialize = JdbMemory.initialize;
+	module.exports = Memory;
+}));
+//#endregion
+module.exports = require_memory();

package/dist/lib/current-context.cjs

@@ -0,0 +1,22 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("./globalize.cjs");
+//#region src/lib/current-context.ts
+var require_current_context = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	const juggler = require("@vsaas/loopback-datasource-juggler");
+	const remoting = require("@vsaas/remoting");
+	function currentContext(loopback) {
+		juggler.getCurrentContext = remoting.getCurrentContext = loopback.getCurrentContext = function() {
+			throw new Error(g.f("%s was removed in version 3.0. See %s for more details.", "loopback.getCurrentContext()", "http://loopback.io/doc/en/lb2/Using-current-context.html"));
+		};
+		loopback.runInContext = function(fn) {
+			throw new Error(g.f("%s was removed in version 3.0. See %s for more details.", "loopback.runInContext()", "http://loopback.io/doc/en/lb2/Using-current-context.html"));
+		};
+		loopback.createContext = function(scopeName) {
+			throw new Error(g.f("%s was removed in version 3.0. See %s for more details.", "loopback.createContext()", "http://loopback.io/doc/en/lb2/Using-current-context.html"));
+		};
+	}
+	module.exports = currentContext;
+}));
+//#endregion
+module.exports = require_current_context();

package/dist/lib/globalize.cjs

@@ -0,0 +1,29 @@
+//#region src/lib/globalize.ts
+var require_globalize = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const format = require("util").format;
+	function f(message) {
+		const args = Array.prototype.slice.call(arguments, 1);
+		return format.apply(null, [normalizeMessage(message)].concat(args));
+	}
+	function log(message) {
+		console.log(formatWithArgs.apply(null, arguments));
+	}
+	function warn(message) {
+		console.warn(formatWithArgs.apply(null, arguments));
+	}
+	function formatWithArgs(message) {
+		const args = Array.prototype.slice.call(arguments, 1);
+		return format.apply(null, [normalizeMessage(message)].concat(args));
+	}
+	function normalizeMessage(message) {
+		if (typeof message !== "string") return message;
+		return message.replace(/\{\{([^{}]+)\}\}/g, "$1");
+	}
+	module.exports = {
+		f,
+		log,
+		warn
+	};
+}));
+//#endregion
+module.exports = require_globalize();