@vsaas/loopback-softdelete-mixin4 10.0.0

package/README.md

@@ -0,0 +1,88 @@
+# `@vsaas/loopback-softdelete-mixin4`
+
+Fork of `loopback-softdelete-mixin4` for `@xompass` LoopBack 3 projects.
+
+This fork keeps the public mixin behavior compatible for existing apps, but trims the old Babel/Gulp toolchain and modernizes the package around:
+
+- TypeScript source in `src/`
+- `tsdown` builds to `dist/`
+- `vitest` tests
+- English-only runtime and docs
+
+## Install
+
+```bash
+npm install @vsaas/loopback-softdelete-mixin4
+```
+
+## Server Configuration
+
+Add the package directory to `mixins` in your `server/model-config.json`:
+
+```json
+{
+  "_meta": {
+    "mixins": ["../node_modules/@vsaas/loopback-softdelete-mixin4"]
+  }
+}
+```
+
+`@vsaas/loopback-boot` resolves this mixin from the package manifest, so no root wrapper file is required.
+
+## Model Configuration
+
+```json
+{
+  "name": "Widget",
+  "properties": {
+    "name": {
+      "type": "string"
+    }
+  },
+  "mixins": {
+    "SoftDelete": true
+  }
+}
+```
+
+## Options
+
+```json
+{
+  "mixins": {
+    "SoftDelete": {
+      "deletedAt": "deletedAt",
+      "scrub": true,
+      "index": true,
+      "deletedById": true,
+      "deleteOp": true
+    }
+  }
+}
+```
+
+Supported options:
+
+- `deletedAt`: rename the timestamp field used for soft deletes
+- `scrub`: set deleted model fields to `null`; use `true` for all non-key fields or an array for a subset
+- `index`: adds `deleteIndex` so soft-deleted rows can coexist with uniqueness constraints
+- `deletedById`: adds a `deletedById` field
+- `deleteOp`: adds a `deleteOp` field
+
+## Query Behavior
+
+By default, queries exclude soft-deleted rows. To include them, pass:
+
+```js
+{
+  deleted: true;
+}
+```
+
+at the same level as `where`, `include`, or `order`.
+
+## Notes
+
+- This package overrides `destroy`, `destroyById`, and `destroyAll` to perform soft deletes.
+- `count`, `find`, `findOrCreate`, `update`, and `updateAll` are scoped to non-deleted rows unless you explicitly opt into deleted results where supported.
+- The `index` option only adds the `deleteIndex` property. It does not create the database index for you.

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/debug.cjs

@@ -0,0 +1,30 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_util = require("node:util");
+//#region src/debug.ts
+var require_debug = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	function isEnabled(namespace) {
+		const debug = process.env.DEBUG;
+		if (!debug) return false;
+		return debug.split(",").map((part) => part.trim()).filter(Boolean).some((pattern) => matchesPattern(pattern, namespace));
+	}
+	function matchesPattern(pattern, value) {
+		if (pattern === "*" || pattern === value) return true;
+		if (!pattern.endsWith("*")) return false;
+		return value.startsWith(pattern.slice(0, -1));
+	}
+	function createDebug(name = "soft-delete") {
+		const namespace = `loopback:mixins:${name}`;
+		if (!isEnabled(namespace)) return () => {};
+		return (...args) => {
+			console.error(`${namespace} ${(0, node_util.format)(...args)}`);
+		};
+	}
+	module.exports = createDebug;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_debug();
+	}
+});

package/dist/index.cjs

@@ -0,0 +1,7 @@
+//#region src/index.ts
+const softDelete = require("./soft-delete.cjs");
+function registerSoftDeleteMixin(app) {
+	app.loopback.modelBuilder.mixins.define("SoftDelete", softDelete);
+}
+module.exports = registerSoftDeleteMixin;
+//#endregion

package/dist/soft-delete.cjs

@@ -0,0 +1,139 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_debug$1 = require("./debug.cjs");
+let node_crypto = require("node:crypto");
+//#region src/soft-delete.ts
+var require_soft_delete = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const debug = require_debug$1.default();
+	function withOptionalCallback(promise, callback) {
+		if (typeof callback !== "function") return promise;
+		promise.then((result) => callback(null, result), (error) => callback(error));
+		return promise;
+	}
+	function buildWhere(where, deletedAt) {
+		const queryNonDeleted = { [deletedAt]: null };
+		if (!where || Object.keys(where).length === 0) return queryNonDeleted;
+		return { and: [where, queryNonDeleted] };
+	}
+	function createDeletePayload(scrubbed, deletedAt, index) {
+		const payload = {
+			...scrubbed,
+			[deletedAt]: /* @__PURE__ */ new Date()
+		};
+		if (index) payload.deleteIndex = generateDeleteIndex();
+		return payload;
+	}
+	function softDeleteMixin(Model, { deletedAt = "deletedAt", scrub = false, index = false, deletedById = false, deleteOp = false } = {}) {
+		debug("SoftDelete mixin for Model %s", Model.modelName);
+		debug("options %j", {
+			deletedAt,
+			scrub,
+			index,
+			deletedById,
+			deleteOp
+		});
+		const properties = Model.definition.properties;
+		const idName = Model.dataSource.idName(Model.modelName);
+		let scrubbed = {};
+		if (scrub !== false) {
+			let propertiesToScrub = scrub;
+			if (!Array.isArray(propertiesToScrub)) propertiesToScrub = Object.keys(properties).filter((propertyName) => {
+				return !(properties[propertyName] ?? {}).id && propertyName !== idName && propertyName !== deletedAt;
+			});
+			scrubbed = propertiesToScrub.reduce((accumulator, propertyName) => {
+				accumulator[propertyName] = null;
+				return accumulator;
+			}, {});
+		}
+		Model.defineProperty(deletedAt, {
+			type: Date,
+			required: false,
+			default: null
+		});
+		if (index) Model.defineProperty("deleteIndex", {
+			type: String,
+			required: true,
+			default: "null"
+		});
+		if (deletedById) Model.defineProperty("deletedById", {
+			type: Number,
+			required: false,
+			default: null
+		});
+		if (deleteOp) Model.defineProperty("deleteOp", {
+			type: String,
+			required: false,
+			default: null
+		});
+		Model.destroyAll = function softDestroyAll(where, callback) {
+			return withOptionalCallback(Model.updateAll(where, createDeletePayload(scrubbed, deletedAt, index)), callback);
+		};
+		Model.remove = Model.destroyAll;
+		Model.deleteAll = Model.destroyAll;
+		Model.destroyById = function softDestroyById(id, callback) {
+			return withOptionalCallback(Model.updateAll({ [idName]: id }, createDeletePayload(scrubbed, deletedAt, index)), callback);
+		};
+		Model.removeById = Model.destroyById;
+		Model.deleteById = Model.destroyById;
+		Model.prototype.destroy = function softDestroy(options, callback) {
+			const normalizedCallback = typeof options === "function" ? options : callback;
+			const normalizedOptions = typeof options === "function" || options == null ? {} : { ...options };
+			const payload = createDeletePayload(scrubbed, deletedAt, index);
+			normalizedOptions.delete = true;
+			if (deletedById && normalizedOptions.deletedById) payload.deletedById = normalizedOptions.deletedById;
+			if (deleteOp && normalizedOptions.deletedById) payload.deleteOp = "user";
+			return withOptionalCallback(this.updateAttributes(payload, normalizedOptions), normalizedCallback);
+		};
+		Model.prototype.remove = Model.prototype.destroy;
+		Model.prototype.delete = Model.prototype.destroy;
+		const originalFindOrCreate = Model.findOrCreate;
+		Model.findOrCreate = function findOrCreateDeleted(query = {}, ...rest) {
+			if (!query.deleted) query.where = buildWhere(query.where, deletedAt);
+			return originalFindOrCreate.call(Model, query, ...rest);
+		};
+		const originalFind = Model.find;
+		Model.find = function findDeleted(query = {}, ...rest) {
+			if (!query.deleted) query.where = buildWhere(query.where, deletedAt);
+			return originalFind.call(Model, query, ...rest);
+		};
+		const originalCount = Model.count;
+		Model.count = function countDeleted(where = {}, ...rest) {
+			return originalCount.call(Model, buildWhere(where, deletedAt), ...rest);
+		};
+		const originalUpdate = Model.update;
+		Model.update = Model.updateAll = function updateDeleted(where = {}, ...rest) {
+			return originalUpdate.call(Model, buildWhere(where, deletedAt), ...rest);
+		};
+		if (Model.settings.remoting && Model.settings.remoting.sharedMethods.deleteById !== false && (deletedById || deleteOp)) {
+			Model.disableRemoteMethodByName("deleteById");
+			Model.remoteMethod("deleteById", {
+				accessType: "WRITE",
+				isStatic: false,
+				accepts: [{
+					arg: "options",
+					type: "object",
+					http: "optionsFromRequest"
+				}],
+				returns: {
+					arg: "data",
+					type: "object",
+					root: true
+				},
+				http: {
+					verb: "delete",
+					path: "/"
+				}
+			});
+			Model.prototype.deleteById = function deleteByIdWithMetadata(options = {}) {
+				if (deletedById) options.deletedById = options.accessToken ? options.accessToken.userId : null;
+				if (deleteOp && options.deletedById) options.deleteOp = "user";
+				return this.destroy(options).then(() => ({ count: 1 }));
+			};
+		}
+	}
+	function generateDeleteIndex() {
+		return (0, node_crypto.randomBytes)(4).toString("hex");
+	}
+	module.exports = softDeleteMixin;
+}));
+//#endregion
+module.exports = require_soft_delete();

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@vsaas/loopback-softdelete-mixin4",
+  "version": "10.0.0",
+  "description": "Fork of loopback-softdelete-mixin4 for @xompass LoopBack 3 projects",
+  "keywords": [
+    "delete",
+    "loopback",
+    "mixin",
+    "soft",
+    "strongloop"
+  ],
+  "homepage": "https://github.com/xompass/loopback-softdelete-mixin4",
+  "bugs": {
+    "url": "https://github.com/xompass/loopback-softdelete-mixin4/issues"
+  },
+  "author": "Xompass",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xompass/loopback-softdelete-mixin4"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/index.cjs",
+  "exports": {
+    ".": "./dist/index.cjs",
+    "./soft-delete": "./dist/soft-delete.cjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "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",
+    "@vsaas/remoting": "^10.0.0",
+    "@vsaas/loopback-datasource-juggler": "^10.0.0"
+  },
+  "peerDependencies": {
+    "@vsaas/loopback-datasource-juggler": "^10.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "loopback": {
+    "mixins": {
+      "SoftDelete": "./dist/soft-delete.cjs"
+    }
+  },
+  "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": "pnpm run build && vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}