@web-ts-toolkit/moo 0.30.0 → 0.31.1

package/index.js

@@ -1,8 +1,14 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,16 +17,228 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  cascadeDeletePlugin: () => cascadeDeletePlugin,
+  isObjectId: () => isObjectId,
+  modelFunctionPlugin: () => modelFunctionPlugin,
+  uniqueEmptiableString: () => uniqueEmptiableString,
+  uniqueNullableString: () => uniqueNullableString
+});
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./plugins"), module.exports);
-__reExport(index_exports, require("./schema"), module.exports);
-__reExport(index_exports, require("./is"), module.exports);
+
+// src/plugins/model-function.ts
+var import_mongoose = __toESM(require("mongoose"));
+var invokePluginFunction = (fn, document, args) => {
+  return fn.call(import_mongoose.default, document, ...args);
+};
+function modelFunctionPlugin(schema, options) {
+  const { fnName, fn } = options;
+  schema.static(fnName, function staticFn(doc, ...args) {
+    return invokePluginFunction(fn, doc, args);
+  });
+  schema.method(fnName, function methodFn(...args) {
+    return invokePluginFunction(fn, this, args);
+  });
+  schema.static(
+    `${fnName}ById`,
+    async function staticByIdFn(docId, ...args) {
+      const model = await this.findById(docId);
+      if (!model) return null;
+      return invokePluginFunction(fn, model, args);
+    }
+  );
+}
+
+// src/plugins/cascade-delete.ts
+var import_mongoose3 = __toESM(require("mongoose"));
+var import_utils2 = require("@web-ts-toolkit/utils");
+
+// src/utils/index.ts
+var import_mongoose2 = require("mongoose");
+var import_utils = require("@web-ts-toolkit/utils");
+var isObjectIdType = (value) => value === "ObjectId" || value === import_mongoose2.Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => (0, import_utils.isString)(value.ref) || (0, import_utils.isFunction)(value.ref) || (0, import_utils.isString)(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!(0, import_utils.isPlainObject)(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = (0, import_utils2.isFunction)(value) ? value(document) : value;
+  if (!(0, import_utils2.isPlainObject)(result)) {
+    return null;
+  }
+  return result;
+};
+var applyQueryOptions = (query, options) => {
+  let builder = query;
+  if (options.select) {
+    builder = builder.select(options.select);
+  }
+  if (options.sort) {
+    builder = builder.sort(options.sort);
+  }
+  if (options.populate) {
+    builder = builder.populate(options.populate);
+  }
+  if (options.lean) {
+    builder = builder.lean();
+  }
+  return builder;
+};
+var supportsDeleteOne = (value) => (0, import_utils2.isObject)(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => (0, import_utils2.isObject)(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = (0, import_utils2.isPlainObject)(previousResults) ? previousResults : {};
+  if (currentResults === null) {
+    return resultMap;
+  }
+  return {
+    ...resultMap,
+    [modelName]: currentResults
+  };
+};
+function cascadeDeletePlugin(schema, options) {
+  const { model, localField, foreignField, foreignFilter, extraForeignFilter } = options ?? {};
+  const findDependents = async function(queryOptions) {
+    const Target = import_mongoose3.default.model(model);
+    let query = null;
+    const document = this.toObject({ virtuals: false });
+    if (foreignFilter) {
+      query = resolveFilter(foreignFilter, document);
+    } else if (localField && foreignField) {
+      const localValue = this.get(localField);
+      const extraFilter = resolveFilter(extraForeignFilter, document) ?? {};
+      query = {
+        [foreignField]: Array.isArray(localValue) ? { $in: localValue } : localValue,
+        ...extraFilter
+      };
+    }
+    if (!query || !(0, import_utils2.isPlainObject)(query)) {
+      return [];
+    }
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const findOrphans = async function(queryOptions) {
+    if (!localField || !foreignField) return null;
+    const Target = import_mongoose3.default.model(model);
+    const schemaValue = Target.schema.obj[foreignField];
+    if (!schemaValue) return null;
+    const isMyRef = isReference(schemaValue, this.modelName);
+    if (!isMyRef) return null;
+    const ids = await this.distinct("_id");
+    const extraFilter = resolveFilter(extraForeignFilter) ?? {};
+    const query = {
+      [foreignField]: { $not: { $in: ids } },
+      ...extraFilter
+    };
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const deleteDependents = async function() {
+    const documents = await findDependents.call(this, { select: "_id" });
+    await Promise.all(
+      documents.map((document) => {
+        if (supportsDeleteOne(document)) {
+          return document.deleteOne();
+        }
+        if (supportsRemove(document)) {
+          return document.remove();
+        }
+        return Promise.resolve();
+      })
+    );
+  };
+  schema.post("deleteOne", { document: true, query: false }, async function postDeleteOne() {
+    await deleteDependents.call(this);
+  });
+  const methodFnName = "findDependents";
+  const prevMethodFn = schema.methods[methodFnName];
+  schema.method(methodFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findDependents.call(this, {});
+      }
+      return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
+    }
+    const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
+  });
+  const staticFnName = "findOrphans";
+  const prevStaticFn = schema.statics[staticFnName];
+  schema.static(staticFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findOrphans.call(this, {});
+      }
+      return prevStaticFn ? prevStaticFn.call(this, modelName) : null;
+    }
+    const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
+    const currentResults = await findOrphans.call(this, {});
+    return mergeResults(previousResults, model, currentResults);
+  });
+}
+
+// src/schema.ts
+var uniqueNullableString = (field, options = {}) => ({
+  type: String,
+  index: { unique: true, partialFilterExpression: { [field]: { $type: "string" } } },
+  trim: true,
+  default: null,
+  ...options
+});
+var uniqueEmptiableString = (field, options = {}) => ({
+  type: String,
+  index: {
+    unique: true,
+    partialFilterExpression: { [field]: { $type: "string", $gt: "" } }
+  },
+  trim: true,
+  default: null,
+  ...options
+});
+
+// src/is.ts
+var import_mongoose4 = require("mongoose");
+var { ObjectId } = import_mongoose4.Types;
+function isObjectId(value) {
+  if (!ObjectId.isValid(value)) {
+    return false;
+  }
+  try {
+    const asString = String(value);
+    const asObjectId = new ObjectId(asString);
+    const asStringifiedObjectId = asObjectId.toString();
+    return asString === asStringifiedObjectId;
+  } catch {
+    return false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugins"),
-  ...require("./schema"),
-  ...require("./is")
+  cascadeDeletePlugin,
+  isObjectId,
+  modelFunctionPlugin,
+  uniqueEmptiableString,
+  uniqueNullableString
 });

package/index.mjs

@@ -1,3 +1,203 @@
-export * from "./plugins";
-export * from "./schema";
-export * from "./is";
+// src/plugins/model-function.ts
+import mongoose from "mongoose";
+var invokePluginFunction = (fn, document, args) => {
+  return fn.call(mongoose, document, ...args);
+};
+function modelFunctionPlugin(schema, options) {
+  const { fnName, fn } = options;
+  schema.static(fnName, function staticFn(doc, ...args) {
+    return invokePluginFunction(fn, doc, args);
+  });
+  schema.method(fnName, function methodFn(...args) {
+    return invokePluginFunction(fn, this, args);
+  });
+  schema.static(
+    `${fnName}ById`,
+    async function staticByIdFn(docId, ...args) {
+      const model = await this.findById(docId);
+      if (!model) return null;
+      return invokePluginFunction(fn, model, args);
+    }
+  );
+}
+
+// src/plugins/cascade-delete.ts
+import mongoose2 from "mongoose";
+import { isFunction as isFunction2, isObject, isPlainObject as isPlainObject2 } from "@web-ts-toolkit/utils";
+
+// src/utils/index.ts
+import { Schema } from "mongoose";
+import { isFunction, isPlainObject, isString } from "@web-ts-toolkit/utils";
+var isObjectIdType = (value) => value === "ObjectId" || value === Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => isString(value.ref) || isFunction(value.ref) || isString(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!isPlainObject(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = isFunction2(value) ? value(document) : value;
+  if (!isPlainObject2(result)) {
+    return null;
+  }
+  return result;
+};
+var applyQueryOptions = (query, options) => {
+  let builder = query;
+  if (options.select) {
+    builder = builder.select(options.select);
+  }
+  if (options.sort) {
+    builder = builder.sort(options.sort);
+  }
+  if (options.populate) {
+    builder = builder.populate(options.populate);
+  }
+  if (options.lean) {
+    builder = builder.lean();
+  }
+  return builder;
+};
+var supportsDeleteOne = (value) => isObject(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => isObject(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = isPlainObject2(previousResults) ? previousResults : {};
+  if (currentResults === null) {
+    return resultMap;
+  }
+  return {
+    ...resultMap,
+    [modelName]: currentResults
+  };
+};
+function cascadeDeletePlugin(schema, options) {
+  const { model, localField, foreignField, foreignFilter, extraForeignFilter } = options ?? {};
+  const findDependents = async function(queryOptions) {
+    const Target = mongoose2.model(model);
+    let query = null;
+    const document = this.toObject({ virtuals: false });
+    if (foreignFilter) {
+      query = resolveFilter(foreignFilter, document);
+    } else if (localField && foreignField) {
+      const localValue = this.get(localField);
+      const extraFilter = resolveFilter(extraForeignFilter, document) ?? {};
+      query = {
+        [foreignField]: Array.isArray(localValue) ? { $in: localValue } : localValue,
+        ...extraFilter
+      };
+    }
+    if (!query || !isPlainObject2(query)) {
+      return [];
+    }
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const findOrphans = async function(queryOptions) {
+    if (!localField || !foreignField) return null;
+    const Target = mongoose2.model(model);
+    const schemaValue = Target.schema.obj[foreignField];
+    if (!schemaValue) return null;
+    const isMyRef = isReference(schemaValue, this.modelName);
+    if (!isMyRef) return null;
+    const ids = await this.distinct("_id");
+    const extraFilter = resolveFilter(extraForeignFilter) ?? {};
+    const query = {
+      [foreignField]: { $not: { $in: ids } },
+      ...extraFilter
+    };
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const deleteDependents = async function() {
+    const documents = await findDependents.call(this, { select: "_id" });
+    await Promise.all(
+      documents.map((document) => {
+        if (supportsDeleteOne(document)) {
+          return document.deleteOne();
+        }
+        if (supportsRemove(document)) {
+          return document.remove();
+        }
+        return Promise.resolve();
+      })
+    );
+  };
+  schema.post("deleteOne", { document: true, query: false }, async function postDeleteOne() {
+    await deleteDependents.call(this);
+  });
+  const methodFnName = "findDependents";
+  const prevMethodFn = schema.methods[methodFnName];
+  schema.method(methodFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findDependents.call(this, {});
+      }
+      return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
+    }
+    const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
+  });
+  const staticFnName = "findOrphans";
+  const prevStaticFn = schema.statics[staticFnName];
+  schema.static(staticFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findOrphans.call(this, {});
+      }
+      return prevStaticFn ? prevStaticFn.call(this, modelName) : null;
+    }
+    const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
+    const currentResults = await findOrphans.call(this, {});
+    return mergeResults(previousResults, model, currentResults);
+  });
+}
+
+// src/schema.ts
+var uniqueNullableString = (field, options = {}) => ({
+  type: String,
+  index: { unique: true, partialFilterExpression: { [field]: { $type: "string" } } },
+  trim: true,
+  default: null,
+  ...options
+});
+var uniqueEmptiableString = (field, options = {}) => ({
+  type: String,
+  index: {
+    unique: true,
+    partialFilterExpression: { [field]: { $type: "string", $gt: "" } }
+  },
+  trim: true,
+  default: null,
+  ...options
+});
+
+// src/is.ts
+import { Types } from "mongoose";
+var { ObjectId } = Types;
+function isObjectId(value) {
+  if (!ObjectId.isValid(value)) {
+    return false;
+  }
+  try {
+    const asString = String(value);
+    const asObjectId = new ObjectId(asString);
+    const asStringifiedObjectId = asObjectId.toString();
+    return asString === asStringifiedObjectId;
+  } catch {
+    return false;
+  }
+}
+export {
+  cascadeDeletePlugin,
+  isObjectId,
+  modelFunctionPlugin,
+  uniqueEmptiableString,
+  uniqueNullableString
+};

package/is.js

@@ -16,13 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/is.ts
 var is_exports = {};
 __export(is_exports, {
   isObjectId: () => isObjectId
 });
 module.exports = __toCommonJS(is_exports);
 var import_mongoose = require("mongoose");
-const { ObjectId } = import_mongoose.Types;
+var { ObjectId } = import_mongoose.Types;
 function isObjectId(value) {
   if (!ObjectId.isValid(value)) {
     return false;

package/is.mjs

@@ -1,5 +1,6 @@
+// src/is.ts
 import { Types } from "mongoose";
-const { ObjectId } = Types;
+var { ObjectId } = Types;
 function isObjectId(value) {
   if (!ObjectId.isValid(value)) {
     return false;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@web-ts-toolkit/moo",
   "description": "Mongoose helpers for schema fields, ObjectId checks, and document plugins",
   "homepage": "https://web-ts-toolkit.pages.dev/docs/packages/moo",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "sideEffects": false,
   "keywords": [
     "mongoose",
@@ -65,7 +65,7 @@
     "mongoose": ">=8.0.0"
   },
   "dependencies": {
-    "@web-ts-toolkit/utils": "0.30.0"
+    "@web-ts-toolkit/utils": "0.31.1"
   },
   "files": [
     "**/*",

package/plugins/cascade-delete.js

@@ -26,22 +26,43 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/cascade-delete.ts
 var cascade_delete_exports = {};
 __export(cascade_delete_exports, {
   cascadeDeletePlugin: () => cascadeDeletePlugin
 });
 module.exports = __toCommonJS(cascade_delete_exports);
-var import_mongoose = __toESM(require("mongoose"));
+var import_mongoose2 = __toESM(require("mongoose"));
+var import_utils2 = require("@web-ts-toolkit/utils");
+
+// src/utils/index.ts
+var import_mongoose = require("mongoose");
 var import_utils = require("@web-ts-toolkit/utils");
-var import_utils2 = require("../utils");
-const resolveFilter = (value, document) => {
-  const result = (0, import_utils.isFunction)(value) ? value(document) : value;
-  if (!(0, import_utils.isPlainObject)(result)) {
+var isObjectIdType = (value) => value === "ObjectId" || value === import_mongoose.Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => (0, import_utils.isString)(value.ref) || (0, import_utils.isFunction)(value.ref) || (0, import_utils.isString)(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!(0, import_utils.isPlainObject)(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = (0, import_utils2.isFunction)(value) ? value(document) : value;
+  if (!(0, import_utils2.isPlainObject)(result)) {
     return null;
   }
   return result;
 };
-const applyQueryOptions = (query, options) => {
+var applyQueryOptions = (query, options) => {
   let builder = query;
   if (options.select) {
     builder = builder.select(options.select);
@@ -57,10 +78,10 @@ const applyQueryOptions = (query, options) => {
   }
   return builder;
 };
-const supportsDeleteOne = (value) => (0, import_utils.isObject)(value) && typeof value.deleteOne === "function";
-const supportsRemove = (value) => (0, import_utils.isObject)(value) && typeof value.remove === "function";
-const mergeResults = (previousResults, modelName, currentResults) => {
-  const resultMap = (0, import_utils.isPlainObject)(previousResults) ? previousResults : {};
+var supportsDeleteOne = (value) => (0, import_utils2.isObject)(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => (0, import_utils2.isObject)(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = (0, import_utils2.isPlainObject)(previousResults) ? previousResults : {};
   if (currentResults === null) {
     return resultMap;
   }
@@ -72,7 +93,7 @@ const mergeResults = (previousResults, modelName, currentResults) => {
 function cascadeDeletePlugin(schema, options) {
   const { model, localField, foreignField, foreignFilter, extraForeignFilter } = options ?? {};
   const findDependents = async function(queryOptions) {
-    const Target = import_mongoose.default.model(model);
+    const Target = import_mongoose2.default.model(model);
     let query = null;
     const document = this.toObject({ virtuals: false });
     if (foreignFilter) {
@@ -85,17 +106,17 @@ function cascadeDeletePlugin(schema, options) {
         ...extraFilter
       };
     }
-    if (!query || !(0, import_utils.isPlainObject)(query)) {
+    if (!query || !(0, import_utils2.isPlainObject)(query)) {
       return [];
     }
     return await applyQueryOptions(Target.find(query), queryOptions);
   };
   const findOrphans = async function(queryOptions) {
     if (!localField || !foreignField) return null;
-    const Target = import_mongoose.default.model(model);
+    const Target = import_mongoose2.default.model(model);
     const schemaValue = Target.schema.obj[foreignField];
     if (!schemaValue) return null;
-    const isMyRef = (0, import_utils2.isReference)(schemaValue, this.modelName);
+    const isMyRef = isReference(schemaValue, this.modelName);
     if (!isMyRef) return null;
     const ids = await this.distinct("_id");
     const extraFilter = resolveFilter(extraForeignFilter) ?? {};

package/plugins/cascade-delete.mjs

@@ -1,14 +1,34 @@
+// src/plugins/cascade-delete.ts
 import mongoose from "mongoose";
-import { isFunction, isObject, isPlainObject } from "@web-ts-toolkit/utils";
-import { isReference } from "../utils";
-const resolveFilter = (value, document) => {
-  const result = isFunction(value) ? value(document) : value;
-  if (!isPlainObject(result)) {
+import { isFunction as isFunction2, isObject, isPlainObject as isPlainObject2 } from "@web-ts-toolkit/utils";
+
+// src/utils/index.ts
+import { Schema } from "mongoose";
+import { isFunction, isPlainObject, isString } from "@web-ts-toolkit/utils";
+var isObjectIdType = (value) => value === "ObjectId" || value === Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => isString(value.ref) || isFunction(value.ref) || isString(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!isPlainObject(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = isFunction2(value) ? value(document) : value;
+  if (!isPlainObject2(result)) {
     return null;
   }
   return result;
 };
-const applyQueryOptions = (query, options) => {
+var applyQueryOptions = (query, options) => {
   let builder = query;
   if (options.select) {
     builder = builder.select(options.select);
@@ -24,10 +44,10 @@ const applyQueryOptions = (query, options) => {
   }
   return builder;
 };
-const supportsDeleteOne = (value) => isObject(value) && typeof value.deleteOne === "function";
-const supportsRemove = (value) => isObject(value) && typeof value.remove === "function";
-const mergeResults = (previousResults, modelName, currentResults) => {
-  const resultMap = isPlainObject(previousResults) ? previousResults : {};
+var supportsDeleteOne = (value) => isObject(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => isObject(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = isPlainObject2(previousResults) ? previousResults : {};
   if (currentResults === null) {
     return resultMap;
   }
@@ -52,7 +72,7 @@ function cascadeDeletePlugin(schema, options) {
         ...extraFilter
       };
     }
-    if (!query || !isPlainObject(query)) {
+    if (!query || !isPlainObject2(query)) {
       return [];
     }
     return await applyQueryOptions(Target.find(query), queryOptions);

package/plugins/index.js

@@ -1,8 +1,14 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,14 +17,186 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/index.ts
 var plugins_exports = {};
+__export(plugins_exports, {
+  cascadeDeletePlugin: () => cascadeDeletePlugin,
+  modelFunctionPlugin: () => modelFunctionPlugin
+});
 module.exports = __toCommonJS(plugins_exports);
-__reExport(plugins_exports, require("./model-function"), module.exports);
-__reExport(plugins_exports, require("./cascade-delete"), module.exports);
+
+// src/plugins/model-function.ts
+var import_mongoose = __toESM(require("mongoose"));
+var invokePluginFunction = (fn, document, args) => {
+  return fn.call(import_mongoose.default, document, ...args);
+};
+function modelFunctionPlugin(schema, options) {
+  const { fnName, fn } = options;
+  schema.static(fnName, function staticFn(doc, ...args) {
+    return invokePluginFunction(fn, doc, args);
+  });
+  schema.method(fnName, function methodFn(...args) {
+    return invokePluginFunction(fn, this, args);
+  });
+  schema.static(
+    `${fnName}ById`,
+    async function staticByIdFn(docId, ...args) {
+      const model = await this.findById(docId);
+      if (!model) return null;
+      return invokePluginFunction(fn, model, args);
+    }
+  );
+}
+
+// src/plugins/cascade-delete.ts
+var import_mongoose3 = __toESM(require("mongoose"));
+var import_utils2 = require("@web-ts-toolkit/utils");
+
+// src/utils/index.ts
+var import_mongoose2 = require("mongoose");
+var import_utils = require("@web-ts-toolkit/utils");
+var isObjectIdType = (value) => value === "ObjectId" || value === import_mongoose2.Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => (0, import_utils.isString)(value.ref) || (0, import_utils.isFunction)(value.ref) || (0, import_utils.isString)(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!(0, import_utils.isPlainObject)(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = (0, import_utils2.isFunction)(value) ? value(document) : value;
+  if (!(0, import_utils2.isPlainObject)(result)) {
+    return null;
+  }
+  return result;
+};
+var applyQueryOptions = (query, options) => {
+  let builder = query;
+  if (options.select) {
+    builder = builder.select(options.select);
+  }
+  if (options.sort) {
+    builder = builder.sort(options.sort);
+  }
+  if (options.populate) {
+    builder = builder.populate(options.populate);
+  }
+  if (options.lean) {
+    builder = builder.lean();
+  }
+  return builder;
+};
+var supportsDeleteOne = (value) => (0, import_utils2.isObject)(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => (0, import_utils2.isObject)(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = (0, import_utils2.isPlainObject)(previousResults) ? previousResults : {};
+  if (currentResults === null) {
+    return resultMap;
+  }
+  return {
+    ...resultMap,
+    [modelName]: currentResults
+  };
+};
+function cascadeDeletePlugin(schema, options) {
+  const { model, localField, foreignField, foreignFilter, extraForeignFilter } = options ?? {};
+  const findDependents = async function(queryOptions) {
+    const Target = import_mongoose3.default.model(model);
+    let query = null;
+    const document = this.toObject({ virtuals: false });
+    if (foreignFilter) {
+      query = resolveFilter(foreignFilter, document);
+    } else if (localField && foreignField) {
+      const localValue = this.get(localField);
+      const extraFilter = resolveFilter(extraForeignFilter, document) ?? {};
+      query = {
+        [foreignField]: Array.isArray(localValue) ? { $in: localValue } : localValue,
+        ...extraFilter
+      };
+    }
+    if (!query || !(0, import_utils2.isPlainObject)(query)) {
+      return [];
+    }
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const findOrphans = async function(queryOptions) {
+    if (!localField || !foreignField) return null;
+    const Target = import_mongoose3.default.model(model);
+    const schemaValue = Target.schema.obj[foreignField];
+    if (!schemaValue) return null;
+    const isMyRef = isReference(schemaValue, this.modelName);
+    if (!isMyRef) return null;
+    const ids = await this.distinct("_id");
+    const extraFilter = resolveFilter(extraForeignFilter) ?? {};
+    const query = {
+      [foreignField]: { $not: { $in: ids } },
+      ...extraFilter
+    };
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const deleteDependents = async function() {
+    const documents = await findDependents.call(this, { select: "_id" });
+    await Promise.all(
+      documents.map((document) => {
+        if (supportsDeleteOne(document)) {
+          return document.deleteOne();
+        }
+        if (supportsRemove(document)) {
+          return document.remove();
+        }
+        return Promise.resolve();
+      })
+    );
+  };
+  schema.post("deleteOne", { document: true, query: false }, async function postDeleteOne() {
+    await deleteDependents.call(this);
+  });
+  const methodFnName = "findDependents";
+  const prevMethodFn = schema.methods[methodFnName];
+  schema.method(methodFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findDependents.call(this, {});
+      }
+      return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
+    }
+    const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
+  });
+  const staticFnName = "findOrphans";
+  const prevStaticFn = schema.statics[staticFnName];
+  schema.static(staticFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findOrphans.call(this, {});
+      }
+      return prevStaticFn ? prevStaticFn.call(this, modelName) : null;
+    }
+    const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
+    const currentResults = await findOrphans.call(this, {});
+    return mergeResults(previousResults, model, currentResults);
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./model-function"),
-  ...require("./cascade-delete")
+  cascadeDeletePlugin,
+  modelFunctionPlugin
 });

package/plugins/index.mjs

@@ -1,2 +1,164 @@
-export * from "./model-function";
-export * from "./cascade-delete";
+// src/plugins/model-function.ts
+import mongoose from "mongoose";
+var invokePluginFunction = (fn, document, args) => {
+  return fn.call(mongoose, document, ...args);
+};
+function modelFunctionPlugin(schema, options) {
+  const { fnName, fn } = options;
+  schema.static(fnName, function staticFn(doc, ...args) {
+    return invokePluginFunction(fn, doc, args);
+  });
+  schema.method(fnName, function methodFn(...args) {
+    return invokePluginFunction(fn, this, args);
+  });
+  schema.static(
+    `${fnName}ById`,
+    async function staticByIdFn(docId, ...args) {
+      const model = await this.findById(docId);
+      if (!model) return null;
+      return invokePluginFunction(fn, model, args);
+    }
+  );
+}
+
+// src/plugins/cascade-delete.ts
+import mongoose2 from "mongoose";
+import { isFunction as isFunction2, isObject, isPlainObject as isPlainObject2 } from "@web-ts-toolkit/utils";
+
+// src/utils/index.ts
+import { Schema } from "mongoose";
+import { isFunction, isPlainObject, isString } from "@web-ts-toolkit/utils";
+var isObjectIdType = (value) => value === "ObjectId" || value === Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => isString(value.ref) || isFunction(value.ref) || isString(value.refPath);
+var isReference = (value, ref) => {
+  if (Array.isArray(value)) {
+    return value.length > 0 ? isReference(value[0], ref) : false;
+  }
+  if (!isPlainObject(value) || !isObjectIdType(value.type)) {
+    return false;
+  }
+  if (ref === void 0) {
+    return hasReferenceTarget(value);
+  }
+  return value.ref === ref;
+};
+
+// src/plugins/cascade-delete.ts
+var resolveFilter = (value, document) => {
+  const result = isFunction2(value) ? value(document) : value;
+  if (!isPlainObject2(result)) {
+    return null;
+  }
+  return result;
+};
+var applyQueryOptions = (query, options) => {
+  let builder = query;
+  if (options.select) {
+    builder = builder.select(options.select);
+  }
+  if (options.sort) {
+    builder = builder.sort(options.sort);
+  }
+  if (options.populate) {
+    builder = builder.populate(options.populate);
+  }
+  if (options.lean) {
+    builder = builder.lean();
+  }
+  return builder;
+};
+var supportsDeleteOne = (value) => isObject(value) && typeof value.deleteOne === "function";
+var supportsRemove = (value) => isObject(value) && typeof value.remove === "function";
+var mergeResults = (previousResults, modelName, currentResults) => {
+  const resultMap = isPlainObject2(previousResults) ? previousResults : {};
+  if (currentResults === null) {
+    return resultMap;
+  }
+  return {
+    ...resultMap,
+    [modelName]: currentResults
+  };
+};
+function cascadeDeletePlugin(schema, options) {
+  const { model, localField, foreignField, foreignFilter, extraForeignFilter } = options ?? {};
+  const findDependents = async function(queryOptions) {
+    const Target = mongoose2.model(model);
+    let query = null;
+    const document = this.toObject({ virtuals: false });
+    if (foreignFilter) {
+      query = resolveFilter(foreignFilter, document);
+    } else if (localField && foreignField) {
+      const localValue = this.get(localField);
+      const extraFilter = resolveFilter(extraForeignFilter, document) ?? {};
+      query = {
+        [foreignField]: Array.isArray(localValue) ? { $in: localValue } : localValue,
+        ...extraFilter
+      };
+    }
+    if (!query || !isPlainObject2(query)) {
+      return [];
+    }
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const findOrphans = async function(queryOptions) {
+    if (!localField || !foreignField) return null;
+    const Target = mongoose2.model(model);
+    const schemaValue = Target.schema.obj[foreignField];
+    if (!schemaValue) return null;
+    const isMyRef = isReference(schemaValue, this.modelName);
+    if (!isMyRef) return null;
+    const ids = await this.distinct("_id");
+    const extraFilter = resolveFilter(extraForeignFilter) ?? {};
+    const query = {
+      [foreignField]: { $not: { $in: ids } },
+      ...extraFilter
+    };
+    return await applyQueryOptions(Target.find(query), queryOptions);
+  };
+  const deleteDependents = async function() {
+    const documents = await findDependents.call(this, { select: "_id" });
+    await Promise.all(
+      documents.map((document) => {
+        if (supportsDeleteOne(document)) {
+          return document.deleteOne();
+        }
+        if (supportsRemove(document)) {
+          return document.remove();
+        }
+        return Promise.resolve();
+      })
+    );
+  };
+  schema.post("deleteOne", { document: true, query: false }, async function postDeleteOne() {
+    await deleteDependents.call(this);
+  });
+  const methodFnName = "findDependents";
+  const prevMethodFn = schema.methods[methodFnName];
+  schema.method(methodFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findDependents.call(this, {});
+      }
+      return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
+    }
+    const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
+  });
+  const staticFnName = "findOrphans";
+  const prevStaticFn = schema.statics[staticFnName];
+  schema.static(staticFnName, async function methodFn(modelName) {
+    if (modelName) {
+      if (modelName === model) {
+        return findOrphans.call(this, {});
+      }
+      return prevStaticFn ? prevStaticFn.call(this, modelName) : null;
+    }
+    const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
+    const currentResults = await findOrphans.call(this, {});
+    return mergeResults(previousResults, model, currentResults);
+  });
+}
+export {
+  cascadeDeletePlugin,
+  modelFunctionPlugin
+};

package/plugins/model-function.js

@@ -26,13 +26,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/model-function.ts
 var model_function_exports = {};
 __export(model_function_exports, {
   modelFunctionPlugin: () => modelFunctionPlugin
 });
 module.exports = __toCommonJS(model_function_exports);
 var import_mongoose = __toESM(require("mongoose"));
-const invokePluginFunction = (fn, document, args) => {
+var invokePluginFunction = (fn, document, args) => {
   return fn.call(import_mongoose.default, document, ...args);
 };
 function modelFunctionPlugin(schema, options) {

package/plugins/model-function.mjs

@@ -1,5 +1,6 @@
+// src/plugins/model-function.ts
 import mongoose from "mongoose";
-const invokePluginFunction = (fn, document, args) => {
+var invokePluginFunction = (fn, document, args) => {
   return fn.call(mongoose, document, ...args);
 };
 function modelFunctionPlugin(schema, options) {

package/schema.js

@@ -16,20 +16,22 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
   uniqueEmptiableString: () => uniqueEmptiableString,
   uniqueNullableString: () => uniqueNullableString
 });
 module.exports = __toCommonJS(schema_exports);
-const uniqueNullableString = (field, options = {}) => ({
+var uniqueNullableString = (field, options = {}) => ({
   type: String,
   index: { unique: true, partialFilterExpression: { [field]: { $type: "string" } } },
   trim: true,
   default: null,
   ...options
 });
-const uniqueEmptiableString = (field, options = {}) => ({
+var uniqueEmptiableString = (field, options = {}) => ({
   type: String,
   index: {
     unique: true,

package/schema.mjs

@@ -1,11 +1,12 @@
-const uniqueNullableString = (field, options = {}) => ({
+// src/schema.ts
+var uniqueNullableString = (field, options = {}) => ({
   type: String,
   index: { unique: true, partialFilterExpression: { [field]: { $type: "string" } } },
   trim: true,
   default: null,
   ...options
 });
-const uniqueEmptiableString = (field, options = {}) => ({
+var uniqueEmptiableString = (field, options = {}) => ({
   type: String,
   index: {
     unique: true,

package/utils/index.js

@@ -16,6 +16,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
   isObjectIdType: () => isObjectIdType,
@@ -25,10 +27,10 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var import_mongoose = require("mongoose");
 var import_utils = require("@web-ts-toolkit/utils");
-const isSchema = (value) => value instanceof import_mongoose.Schema;
-const isObjectIdType = (value) => value === "ObjectId" || value === import_mongoose.Schema.Types.ObjectId;
-const hasReferenceTarget = (value) => (0, import_utils.isString)(value.ref) || (0, import_utils.isFunction)(value.ref) || (0, import_utils.isString)(value.refPath);
-const isReference = (value, ref) => {
+var isSchema = (value) => value instanceof import_mongoose.Schema;
+var isObjectIdType = (value) => value === "ObjectId" || value === import_mongoose.Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => (0, import_utils.isString)(value.ref) || (0, import_utils.isFunction)(value.ref) || (0, import_utils.isString)(value.refPath);
+var isReference = (value, ref) => {
   if (Array.isArray(value)) {
     return value.length > 0 ? isReference(value[0], ref) : false;
   }

package/utils/index.mjs

@@ -1,9 +1,10 @@
+// src/utils/index.ts
 import { Schema } from "mongoose";
 import { isFunction, isPlainObject, isString } from "@web-ts-toolkit/utils";
-const isSchema = (value) => value instanceof Schema;
-const isObjectIdType = (value) => value === "ObjectId" || value === Schema.Types.ObjectId;
-const hasReferenceTarget = (value) => isString(value.ref) || isFunction(value.ref) || isString(value.refPath);
-const isReference = (value, ref) => {
+var isSchema = (value) => value instanceof Schema;
+var isObjectIdType = (value) => value === "ObjectId" || value === Schema.Types.ObjectId;
+var hasReferenceTarget = (value) => isString(value.ref) || isFunction(value.ref) || isString(value.refPath);
+var isReference = (value, ref) => {
   if (Array.isArray(value)) {
     return value.length > 0 ? isReference(value[0], ref) : false;
   }