@vsaas/loopback-datasource-juggler 10.0.0

package/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) IBM Corp. 2011,2017. All Rights Reserved.
+Node module: loopback-datasource-juggler
+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/NOTICE

@@ -0,0 +1,23 @@
+This product includes software developed at https://github.com/1602/jugglingdb
+under the following MIT license.
+
+Copyright (C) 2011 by Anatoliy Chakkaev <mail [åt] anatoliy [døt] in>
+
+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,74 @@
+# @vsaas/loopback-datasource-juggler
+
+`@vsaas/loopback-datasource-juggler` is a fork of `loopback-datasource-juggler` focused on keeping LoopBack 3 style data access working while reducing maintenance overhead.
+
+The goal of this fork is practical compatibility for the common upstream use cases, not byte-for-byte preservation of the original package. The internals were intentionally simplified and modernized:
+
+- TypeScript source with build output in `dist/`
+- English-only messages
+- no i18n catalogs or `strong-globalize`
+- several legacy dependencies removed or replaced
+- modern tooling with `tsdown`, `vitest`, and `oxlint`
+- callback-compatible public APIs that continue to work with `Promise` and `async/await`
+
+## Installation
+
+```sh
+npm install @vsaas/loopback-datasource-juggler
+```
+
+If you are also using the related connector forks, pair it with packages such as `@vsaas/loopback-connector` and `@vsaas/loopback-connector-mongodb`.
+
+## Quick start
+
+```js
+const juggler = require('@vsaas/loopback-datasource-juggler');
+
+const ds = new juggler.DataSource('memory');
+
+const Product = ds.createModel('Product', {
+  name: String,
+  price: Number,
+});
+
+async function main() {
+  await Product.create({ name: 'Notebook', price: 20 });
+  const products = await Product.find();
+  console.log(products);
+}
+
+main().catch(console.error);
+```
+
+## Scope
+
+This package still provides the same main building blocks that existing juggler users expect:
+
+- datasource and connector abstraction
+- model definition and inheritance
+- relations and inclusion
+- scopes and query normalization
+- validations and hooks
+- transactions and id generation helpers
+
+If you are migrating an existing codebase, the intent is that the public API should feel familiar even though the implementation is leaner.
+
+## Notes for Fork Users
+
+- This is a maintained fork, not the upstream package.
+- Messages are English-only by design.
+- Legacy internals were removed where they were easy to replace without changing the public API.
+- The test entrypoint is `vitest`, while the large legacy suite still runs underneath for compatibility.
+
+## Development
+
+```bash
+npm run build
+npm run typecheck
+npm run lint
+npm test
+```
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/dist/_virtual/_rolldown/runtime.js

@@ -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.js

@@ -0,0 +1,26 @@
+"use strict";
+const require_lib_globalize = require("./lib/globalize.js");
+const require_lib_geo = require("./lib/geo.js");
+const require_lib_validations = require("./lib/validations.js");
+const require_lib_model = require("./lib/model.js");
+const require_lib_model_builder = require("./lib/model-builder.js");
+const require_lib_kvao_index = require("./lib/kvao/index.js");
+const require_lib_datasource = require("./lib/datasource.js");
+const require_package$1 = require("./package.js");
+//#region src/index.ts
+require_lib_globalize.SetRootDir(__dirname);
+exports.ModelBuilder = exports.LDL = require_lib_model_builder.ModelBuilder;
+exports.DataSource = exports.Schema = require_lib_datasource.DataSource;
+exports.ModelBaseClass = require_lib_model;
+exports.GeoPoint = require_lib_geo.GeoPoint;
+exports.ValidationError = require_lib_validations.ValidationError;
+Object.defineProperty(exports, "version", { get: function() {
+	return require_package$1.default.version;
+} });
+const commonTest = "../test/common_test";
+Object.defineProperty(exports, "test", { get: function() {
+	return require(commonTest);
+} });
+exports.Transaction = require("@vsaas/loopback-connector").Transaction;
+exports.KeyValueAccessObject = require_lib_kvao_index;
+//#endregion

package/dist/lib/browser.depd.js

@@ -0,0 +1,13 @@
+"use strict";
+//#region src/lib/browser.depd.ts
+module.exports = function depd(namespace) {
+	const warned = {};
+	return function deprecate(message) {
+		if (warned[message]) return;
+		warned[message] = true;
+		if (process.noDeprecation) return;
+		else if (process.traceDeprecation) console.trace(namespace, "deprecated", message);
+		else console.warn(namespace, "deprecated", message);
+	};
+};
+//#endregion

package/dist/lib/case-utils.js

@@ -0,0 +1,21 @@
+"use strict";
+//#region src/lib/case-utils.ts
+var require_case_utils = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	function splitWords(value) {
+		return String(value).replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+	}
+	function pascalCase(value) {
+		return splitWords(value).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+	}
+	function camelCase(value) {
+		const normalized = pascalCase(value);
+		if (!normalized) return "";
+		return normalized.charAt(0).toLowerCase() + normalized.slice(1);
+	}
+	module.exports = {
+		camelCase,
+		pascalCase
+	};
+}));
+//#endregion
+module.exports = require_case_utils();

package/dist/lib/connectors/kv-memory.js

@@ -0,0 +1,158 @@
+"use strict";
+//#region src/lib/connectors/kv-memory.ts
+const g = require("../globalize.js")();
+const Connector = require("@vsaas/loopback-connector").Connector;
+const debug = require("debug")("loopback:connector:kv-memory");
+const minimatch = require("minimatch");
+const util = require("util");
+exports.initialize = function initializeDataSource(dataSource, cb) {
+	const settings = dataSource.settings;
+	dataSource.connector = new KeyValueMemoryConnector(settings, dataSource);
+	if (cb) process.nextTick(cb);
+};
+function KeyValueMemoryConnector(settings, dataSource) {
+	Connector.call(this, "kv-memory", settings);
+	debug("Connector settings", settings);
+	this.dataSource = dataSource;
+	this.DataAccessObject = dataSource.juggler.KeyValueAccessObject;
+	this._store = Object.create(null);
+	this._setupRegularCleanup();
+}
+util.inherits(KeyValueMemoryConnector, Connector);
+KeyValueMemoryConnector.prototype._setupRegularCleanup = function() {
+	this._cleanupTimer = setInterval(() => {
+		if (this && this._removeExpiredItems) this._removeExpiredItems();
+		else clearInterval(this._cleanupTimer);
+	}, 1e3);
+	this._cleanupTimer.unref();
+};
+KeyValueMemoryConnector._removeExpiredItems = function() {
+	debug("Running scheduled cleanup of expired items.");
+	for (const modelName in this._store) {
+		const modelStore = this._store[modelName];
+		for (const key in modelStore) if (modelStore[key].isExpired()) {
+			debug("Removing expired key", key);
+			delete modelStore[key];
+		}
+	}
+};
+KeyValueMemoryConnector.prototype._getStoreForModel = function(modelName) {
+	if (!(modelName in this._store)) this._store[modelName] = Object.create(null);
+	return this._store[modelName];
+};
+KeyValueMemoryConnector.prototype._removeIfExpired = function(modelName, key) {
+	const store = this._getStoreForModel(modelName);
+	let item = store[key];
+	if (item && item.isExpired()) {
+		debug("Removing expired key", key);
+		delete store[key];
+		item = void 0;
+		return true;
+	}
+	return false;
+};
+KeyValueMemoryConnector.prototype.get = function(modelName, key, options, callback) {
+	this._removeIfExpired(modelName, key);
+	const item = this._getStoreForModel(modelName)[key];
+	let value = item ? item.value : null;
+	debug("GET %j %j -> %s", modelName, key, value);
+	if (typeof value === "string" && value.startsWith("buffer:")) value = Buffer.from(value.slice(7), "base64");
+	else if (typeof value === "string" && value.startsWith("date:")) value = new Date(value.slice(5));
+	else if (value != null) value = JSON.parse(value);
+	process.nextTick(function() {
+		callback(null, value);
+	});
+};
+KeyValueMemoryConnector.prototype.set = function(modelName, key, value, options, callback) {
+	const store = this._getStoreForModel(modelName);
+	if (Buffer.isBuffer(value)) value = "buffer:" + value.toString("base64");
+	else if (value instanceof Date) value = "date:" + value.toISOString();
+	else value = JSON.stringify(value);
+	debug("SET %j %j %s %j", modelName, key, value, options);
+	store[key] = new StoreItem(value, options && options.ttl);
+	process.nextTick(callback);
+};
+KeyValueMemoryConnector.prototype.expire = function(modelName, key, ttl, options, callback) {
+	this._removeIfExpired(modelName, key);
+	const store = this._getStoreForModel(modelName);
+	if (!(key in store)) return process.nextTick(function() {
+		const err = new Error(g.f("Cannot expire unknown key %j", key));
+		err.statusCode = 404;
+		callback(err);
+	});
+	debug("EXPIRE %j %j %s", modelName, key, ttl || "(never)");
+	store[key].setTtl(ttl);
+	process.nextTick(callback);
+};
+KeyValueMemoryConnector.prototype.ttl = function(modelName, key, options, callback) {
+	this._removeIfExpired(modelName, key);
+	const store = this._getStoreForModel(modelName);
+	if (!(key in store)) return process.nextTick(function() {
+		const err = new Error(g.f("Cannot get TTL for unknown key %j", key));
+		err.statusCode = 404;
+		callback(err);
+	});
+	const ttl = store[key].getTtl();
+	debug("TTL %j %j -> %s", modelName, key, ttl);
+	process.nextTick(function() {
+		callback(null, ttl);
+	});
+};
+KeyValueMemoryConnector.prototype.iterateKeys = function(modelName, filter, _options, _callback) {
+	const store = this._getStoreForModel(modelName);
+	const self = this;
+	const checkFilter = createMatcher(filter.match);
+	const keys = Object.keys(store).filter(function(key) {
+		return !self._removeIfExpired(modelName, key) && checkFilter(key);
+	});
+	debug("ITERATE KEYS %j -> %s keys", modelName, keys.length);
+	let ix = 0;
+	return { next: function(cb) {
+		const value = ix < keys.length ? keys[ix++] : void 0;
+		setImmediate(function() {
+			cb(null, value);
+		});
+	} };
+};
+function createMatcher(pattern) {
+	if (!pattern) return function matchAll() {
+		return true;
+	};
+	return minimatch.filter(pattern, {
+		nobrace: true,
+		noglobstar: true,
+		dot: true,
+		noext: true,
+		nocomment: true
+	});
+}
+KeyValueMemoryConnector.prototype.disconnect = function(callback) {
+	if (this._cleanupTimer) clearInterval(this._cleanupTimer);
+	this._cleanupTimer = null;
+	process.nextTick(callback);
+};
+KeyValueMemoryConnector.prototype.delete = function(modelName, key, options, callback) {
+	const store = this._getStoreForModel(modelName);
+	delete store[key];
+	callback();
+};
+KeyValueMemoryConnector.prototype.deleteAll = function(modelName, options, callback) {
+	const modelStore = this._getStoreForModel(modelName);
+	for (const key in modelStore) delete modelStore[key];
+	callback();
+};
+function StoreItem(value, ttl) {
+	this.value = value;
+	this.setTtl(ttl);
+}
+StoreItem.prototype.isExpired = function() {
+	return this.expires && this.expires <= Date.now();
+};
+StoreItem.prototype.setTtl = function(ttl) {
+	if (ttl) this.expires = Date.now() + ttl;
+	else this.expires = void 0;
+};
+StoreItem.prototype.getTtl = function() {
+	return !this.expires ? void 0 : this.expires - Date.now();
+};
+//#endregion