@vsaas/loopback-connector-remote 10.0.0

package/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) IBM Corp. 2014,2018. All Rights Reserved.
+Node module: loopback-connector-remote
+This project is licensed under the MIT License, full text below.
+
+--------
+
+MIT license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# @vsaas/loopback-connector-remote
+
+`@vsaas/loopback-connector-remote` is a maintained fork of
+`loopback-connector-remote` for the Xompass LoopBack 3 stack.
+
+The goal of this fork is practical compatibility with existing LoopBack 3
+applications while simplifying the package and aligning it with the rest of the
+modernized `@vsaas/*` ecosystem.
+
+## What Changed In This Fork
+
+- Runtime migrated to TypeScript-backed sources and built to `dist/`
+- Tooling aligned with the other forks:
+  - `tsdown`
+  - `vitest`
+  - `oxlint`
+  - `oxfmt`
+- Legacy test/build infrastructure removed:
+  - `grunt`
+  - `mocha`
+  - old ESLint/JSHint config
+- Avoidable development dependencies removed
+- Package metadata and exports aligned with the scoped `@vsaas/*` packages
+
+This package is intended for the Xompass-maintained LoopBack 3 forks. It is not
+targeted at LoopBack 4.
+
+## Installation
+
+```bash
+npm install @vsaas/loopback-connector-remote
+```
+
+In practice this connector is usually installed alongside:
+
+- `@vsaas/loopback`
+- `@vsaas/loopback-datasource-juggler`
+- `@vsaas/remoting`
+
+## Usage
+
+Configure a datasource with the `remote` connector:
+
+```json
+{
+  "myRemoteDataSource": {
+    "name": "myRemoteDataSource",
+    "connector": "remote",
+    "url": "http://localhost:3000/api"
+  }
+}
+```
+
+Or in code:
+
+```js
+const loopback = require('@vsaas/loopback');
+
+const app = loopback();
+
+const ds = app.dataSource('remote', {
+  connector: require('@vsaas/loopback-connector-remote'),
+  url: 'http://localhost:3000/api',
+});
+```
+
+After attaching a compatible remote model, the connector proxies the remote
+methods through LoopBack models and preserves promise-based usage:
+
+```js
+const result = await app.dataSources.remote.models.MyModel.findById(1);
+```
+
+## Public Exports
+
+- `@vsaas/loopback-connector-remote`
+- `@vsaas/loopback-connector-remote/relations`
+
+## Development
+
+```bash
+npm run typecheck
+npm run lint
+npm test
+```
+
+## Notes
+
+- This fork keeps compatibility with common LoopBack 3 remote-model behavior.
+- Error messages and maintenance decisions in the Xompass forks are kept in
+  English only.
+- If you are using this package outside the Xompass forked stack, verify the
+  exact versions of `@vsaas/loopback`, `@vsaas/loopback-datasource-juggler`
+  and `@vsaas/remoting` you want to pair with it.

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,4 @@
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+//#endregion
+exports.__commonJSMin = __commonJSMin;

package/dist/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+const require_lib_relations = require("./lib/relations.cjs");
+const require_lib_remote_connector = require("./lib/remote-connector.cjs");
+//#region src/index.ts
+module.exports = require_lib_remote_connector;
+module.exports.RelationMixin = require_lib_relations;
+//#endregion

package/dist/lib/relations.cjs

@@ -0,0 +1,70 @@
+"use strict";
+//#region src/lib/relations.ts
+var require_relations = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const RelationDefinition = require("@vsaas/loopback-datasource-juggler/relation-definition").RelationDefinition;
+	module.exports = RelationMixin;
+	function RelationMixin() {}
+	RelationMixin.hasMany = function hasMany(modelTo, params) {
+		const def = RelationDefinition.hasMany(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.belongsTo = function belongsTo(modelTo, params) {
+		const def = RelationDefinition.belongsTo(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.hasAndBelongsToMany = function hasAndBelongsToMany(modelTo, params) {
+		const def = RelationDefinition.hasAndBelongsToMany(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.hasOne = function hasOne(modelTo, params) {
+		const def = RelationDefinition.hasOne(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.referencesMany = function referencesMany(modelTo, params) {
+		const def = RelationDefinition.referencesMany(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.embedsOne = function embedsOne(modelTo, params) {
+		const def = RelationDefinition.embedsOne(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	RelationMixin.embedsMany = function embedsMany(modelTo, params) {
+		const def = RelationDefinition.embedsMany(this, modelTo, params);
+		this.dataSource.adapter.resolve(this);
+		defineRelationProperty(this, def);
+	};
+	function defineRelationProperty(modelClass, def) {
+		Object.defineProperty(modelClass.prototype, def.name, { get() {
+			const scope = (...args) => {
+				const cachedEntities = this.__cachedRelations && this.__cachedRelations[def.name];
+				if (args.length || !cachedEntities) return this["__get__" + def.name].apply(this, args);
+				if (Array.isArray(cachedEntities)) return cachedEntities.map((data) => new def.modelTo(data));
+				return new def.modelTo(cachedEntities);
+			};
+			scope.count = (...args) => {
+				return this["__count__" + def.name].apply(this, args);
+			};
+			scope.create = (...args) => {
+				return this["__create__" + def.name].apply(this, args);
+			};
+			scope.deleteById = scope.destroyById = (...args) => {
+				return this["__destroyById__" + def.name].apply(this, args);
+			};
+			scope.exists = (...args) => {
+				return this["__exists__" + def.name].apply(this, args);
+			};
+			scope.findById = (...args) => {
+				return this["__findById__" + def.name].apply(this, args);
+			};
+			return scope;
+		} });
+	}
+}));
+//#endregion
+module.exports = require_relations();

package/dist/lib/remote-connector.cjs

@@ -0,0 +1,94 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_relations = require("./relations.cjs");
+//#region src/lib/remote-connector.ts
+var require_remote_connector = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const remoting = require("@vsaas/remoting");
+	const utils = require("@vsaas/loopback-datasource-juggler/utils");
+	const jutil = require("@vsaas/loopback-datasource-juggler/jutil");
+	const RelationMixin = require_lib_relations;
+	const InclusionMixin = require("@vsaas/loopback-datasource-juggler/include");
+	const findMethodNames = new Set(["findById", "findOne"]);
+	module.exports = RemoteConnector;
+	function RemoteConnector(settings) {
+		assert(typeof settings === "object", "cannot initialize RemoteConnector without a settings object");
+		this.client = settings.client;
+		this.adapter = settings.adapter || "rest";
+		this.protocol = settings.protocol || "http";
+		this.root = settings.root || "";
+		this.host = settings.host || "localhost";
+		this.port = settings.port || 3e3;
+		this.remotes = remoting.create(settings.options);
+		this.name = "remote-connector";
+		if (settings.url) this.url = settings.url;
+		else this.url = this.protocol + "://" + this.host + ":" + this.port + this.root;
+		this.DataAccessObject = function() {};
+	}
+	RemoteConnector.prototype.connect = function() {
+		this.remotes.connect(this.url, this.adapter);
+	};
+	RemoteConnector.initialize = function(dataSource, callback) {
+		(dataSource.connector = new RemoteConnector(dataSource.settings)).connect();
+		process.nextTick(callback);
+	};
+	RemoteConnector.prototype.define = function(definition) {
+		const Model = definition.model;
+		const remotes = this.remotes;
+		assert(Model.sharedClass, "cannot attach " + Model.modelName + " to a remote connector without a Model.sharedClass");
+		jutil.mixin(Model, RelationMixin);
+		jutil.mixin(Model, InclusionMixin);
+		remotes.addClass(Model.sharedClass);
+		this.resolve(Model);
+		this.setupRemotingTypeFor(Model);
+	};
+	RemoteConnector.prototype.resolve = function(Model) {
+		const remotes = this.remotes;
+		Model.sharedClass.methods().forEach(function(remoteMethod) {
+			if (remoteMethod.name !== "Change" && remoteMethod.name !== "Checkpoint") createProxyMethod(Model, remotes, remoteMethod);
+		});
+	};
+	RemoteConnector.prototype.setupRemotingTypeFor = function(Model) {
+		this.remotes.defineObjectType(Model.modelName, function(data) {
+			const model = new Model(data);
+			if (model.__cachedRelations) for (const relation in model.__cachedRelations) {
+				const relatedModel = model.__cachedRelations[relation];
+				model.__data[relation] = relatedModel;
+			}
+			return model;
+		});
+	};
+	function createProxyMethod(Model, remotes, remoteMethod) {
+		const scope = remoteMethod.isStatic ? Model : Model.prototype;
+		function remoteMethodProxy() {
+			const args = Array.prototype.slice.call(arguments);
+			const lastArgIsFunc = typeof args[args.length - 1] === "function";
+			let callback;
+			if (lastArgIsFunc) callback = args.pop();
+			else callback = utils.createPromiseCallback();
+			const callbackPromise = callback.promise;
+			const finalCallback = findMethodNames.has(remoteMethod.name) ? proxy404toNull(callback) : callback;
+			if (remoteMethod.isStatic) remotes.invoke(remoteMethod.stringName, args, finalCallback);
+			else {
+				const ctorArgs = [this.id];
+				remotes.invoke(remoteMethod.stringName, ctorArgs, args, finalCallback);
+			}
+			return callbackPromise;
+		}
+		scope[remoteMethod.name] = remoteMethodProxy;
+		remoteMethod.aliases.forEach(function(alias) {
+			scope[alias] = remoteMethodProxy;
+		});
+	}
+	function proxy404toNull(cb) {
+		return function(err, data) {
+			if (err && err.code === "MODEL_NOT_FOUND") {
+				cb(null, null);
+				return;
+			}
+			cb(err, data);
+		};
+	}
+}));
+//#endregion
+module.exports = require_remote_connector();

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@vsaas/loopback-connector-remote",
+  "version": "10.0.0",
+  "description": "Remote REST API connector for Loopback",
+  "keywords": [
+    "StrongLoop",
+    "rest",
+    "restful",
+    "web"
+  ],
+  "homepage": "https://github.com/xompass/loopback-connector-remote",
+  "bugs": {
+    "url": "https://github.com/xompass/loopback-connector-remote/issues"
+  },
+  "license": "MIT",
+  "author": "Xompass",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xompass/loopback-connector-remote"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "dist/index.cjs",
+  "exports": {
+    ".": "./dist/index.cjs",
+    "./relations": "./dist/lib/relations.cjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@vsaas/remoting": "^10.0.0",
+    "@vsaas/loopback-datasource-juggler": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "oxfmt": "0.42.0",
+    "oxlint": "1.57.0",
+    "tsdown": "0.21.5",
+    "typescript": "6.0.2",
+    "vitest": "4.1.1",
+    "@vsaas/error-handler": "^10.0.0",
+    "@vsaas/loopback": "^10.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "fmt": "oxfmt -c ../.oxfmtrc.json .",
+    "lint": "oxlint -c ../.oxlintrc.json .",
+    "lint:fix": "oxlint -c ../.oxlintrc.json . --fix",
+    "test:run": "vitest run",
+    "test:deps": "pnpm --filter @vsaas/error-handler --filter @vsaas/remoting --filter @vsaas/loopback-datasource-juggler --filter @vsaas/loopback-connector-remote --filter @vsaas/loopback build",
+    "test": "pnpm run test:deps && pnpm run build && vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}