@web-ts-toolkit/moo 0.1.0 → 0.3.0

package/LICENSE

@@ -1,4 +1,3 @@
-
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -187,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright © 2017, Province of British Columbia, Canada.
+   Copyright Junmin Ahn
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -14,9 +14,12 @@ This package includes:
 npm install mongoose @web-ts-toolkit/moo
 ```
 
-## Usage
+## Documentation
 
-### Schema helpers
+- Full package documentation lives in `website/docs/packages/moo.md`.
+- Use the Docusaurus site in `website` for the full examples.
+
+## Minimal Example
 
 ```ts
 import { Schema } from 'mongoose';
@@ -27,101 +30,3 @@ const userSchema = new Schema({
   username: uniqueEmptiableString('username'),
 });
 ```
-
-### ObjectId checks
-
-```ts
-import { isObjectId } from '@web-ts-toolkit/moo';
-
-if (!isObjectId(value)) {
-  throw new Error('expected a valid MongoDB ObjectId');
-}
-```
-
-### Model function plugin
-
-```ts
-import mongoose, { type Model } from 'mongoose';
-import {
-  type ModelDocument,
-  type ModelFunctionInstanceMethods,
-  type ModelFunctionStaticMethods,
-  modelFunctionPlugin,
-} from '@web-ts-toolkit/moo';
-
-type Cart = {
-  name: string;
-  price: number;
-};
-
-type CartDocument = ModelDocument<Cart, CartMethods>;
-
-type CartMethods = ModelFunctionInstanceMethods<'applyDiscount', [suffix: string, priceChange: number], CartDocument>;
-
-type CartModel = Model<Cart, {}, CartMethods> &
-  ModelFunctionStaticMethods<'applyDiscount', CartDocument, [suffix: string, priceChange: number], CartDocument>;
-
-const cartSchema = new mongoose.Schema<Cart, CartModel, CartMethods>({
-  name: { type: String, required: true },
-  price: { type: Number, required: true },
-});
-
-cartSchema.plugin(modelFunctionPlugin, {
-  fnName: 'applyDiscount',
-  fn: (cart: CartDocument, suffix: string, priceChange: number) => {
-    cart.name = `${cart.name}-${suffix}`;
-    cart.price += priceChange;
-    return cart;
-  },
-});
-```
-
-### Cascade delete plugin
-
-```ts
-import mongoose, { type Model, type Types } from 'mongoose';
-import {
-  type CascadeDeleteDependencyMap,
-  type CascadeDeleteDocumentMethods,
-  type CascadeDeleteModelStatics,
-  cascadeDeletePlugin,
-} from '@web-ts-toolkit/moo/plugins';
-
-const referenceModelName = 'Reference';
-
-type Reference = {
-  name: string;
-};
-
-type File = {
-  refs: Types.ObjectId[];
-};
-
-type FileMethods = CascadeDeleteDocumentMethods<typeof referenceModelName, Reference>;
-
-type FileModel = Model<File, {}, FileMethods> & CascadeDeleteModelStatics<typeof referenceModelName, Reference>;
-
-type FileDependents = CascadeDeleteDependencyMap<typeof referenceModelName, Reference>;
-
-const fileSchema = new mongoose.Schema<File, FileModel, FileMethods>({
-  refs: [{ type: mongoose.Schema.Types.ObjectId, ref: referenceModelName }],
-});
-
-fileSchema.plugin(cascadeDeletePlugin, {
-  model: referenceModelName,
-  localField: 'refs',
-  foreignField: '_id',
-});
-
-const File = mongoose.model<File, FileModel>('File', fileSchema);
-
-async function example(file: mongoose.HydratedDocument<File, FileMethods>) {
-  const dependents = (await file.findDependents()) as FileDependents;
-  const references = await file.findDependents(referenceModelName);
-  const orphans = await File.findOrphans(referenceModelName);
-
-  dependents.Reference;
-  references?.[0]?.name;
-  orphans?.[0]?.name;
-}
-```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-ts-toolkit/moo",
   "description": "Mongoose helpers for schema fields, ObjectId checks, and document plugins",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "keywords": [
     "mongoose",
     "mongodb",
@@ -30,6 +30,12 @@
       "require": "./schema.js",
       "default": "./schema.js"
     },
+    "./utils": {
+      "types": "./utils/index.d.ts",
+      "import": "./utils/index.mjs",
+      "require": "./utils/index.js",
+      "default": "./utils/index.js"
+    },
     "./plugins": {
       "types": "./plugins/index.d.ts",
       "import": "./plugins/index.mjs",
@@ -52,7 +58,10 @@
   "peerDependencies": {
     "mongoose": ">=8.0.0"
   },
-  "author": "Junmin Dev",
+  "dependencies": {
+    "@web-ts-toolkit/utils": "0.3.0"
+  },
+  "author": "Junmin Ahn",
   "bugs": {
     "url": "https://github.com/egose/web-ts-toolkit/issues"
   },

package/plugins/cascade-delete.js

@@ -32,22 +32,11 @@ __export(cascade_delete_exports, {
 });
 module.exports = __toCommonJS(cascade_delete_exports);
 var import_mongoose = __toESM(require("mongoose"));
-const deleteOneSupported = Number.parseInt(import_mongoose.default.version.split(".")[0] ?? "0", 10) >= 7;
-const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const isFunction = (value) => typeof value === "function";
-const getReferenceModel = (value) => {
-  if (Array.isArray(value)) {
-    return getReferenceModel(value[0]);
-  }
-  if (!isPlainObject(value) || typeof value.ref !== "string") {
-    return null;
-  }
-  return value.ref;
-};
-const isReference = (value, modelName) => getReferenceModel(value) === modelName;
+var import_utils = require("@web-ts-toolkit/utils");
+var import_utils2 = require("../utils");
 const resolveFilter = (value, document) => {
-  const result = isFunction(value) ? value(document) : value;
-  if (!isPlainObject(result)) {
+  const result = (0, import_utils.isFunction)(value) ? value(document) : value;
+  if (!(0, import_utils.isPlainObject)(result)) {
     return null;
   }
   return result;
@@ -68,8 +57,18 @@ const applyQueryOptions = (query, options) => {
   }
   return builder;
 };
-const supportsDeleteOne = (value) => isPlainObject(value) && typeof value.deleteOne === "function";
-const supportsRemove = (value) => isPlainObject(value) && typeof value.remove === "function";
+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 : {};
+  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) {
@@ -86,7 +85,7 @@ function cascadeDeletePlugin(schema, options) {
         ...extraFilter
       };
     }
-    if (!query || !isPlainObject(query)) {
+    if (!query || !(0, import_utils.isPlainObject)(query)) {
       return [];
     }
     return await applyQueryOptions(Target.find(query), queryOptions);
@@ -96,7 +95,7 @@ function cascadeDeletePlugin(schema, options) {
     const Target = import_mongoose.default.model(model);
     const schemaValue = Target.schema.obj[foreignField];
     if (!schemaValue) return null;
-    const isMyRef = isReference(schemaValue, this.modelName);
+    const isMyRef = (0, import_utils2.isReference)(schemaValue, this.modelName);
     if (!isMyRef) return null;
     const ids = await this.distinct("_id");
     const extraFilter = resolveFilter(extraForeignFilter) ?? {};
@@ -120,23 +119,9 @@ function cascadeDeletePlugin(schema, options) {
       })
     );
   };
-  if (deleteOneSupported) {
-    schema.post("deleteOne", { document: true, query: false }, async function() {
-      try {
-        await deleteDependents.call(this);
-      } catch (err) {
-        console.error(err);
-      }
-    });
-  } else {
-    schema.post("remove", async function() {
-      try {
-        await deleteDependents.call(this);
-      } catch (err) {
-        console.error(err);
-      }
-    });
-  }
+  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) {
@@ -147,10 +132,7 @@ function cascadeDeletePlugin(schema, options) {
       return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
     }
     const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
-    return {
-      ...isPlainObject(previousResults) ? previousResults : {},
-      [model]: await findDependents.call(this, {})
-    };
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
   });
   const staticFnName = "findOrphans";
   const prevStaticFn = schema.statics[staticFnName];
@@ -163,13 +145,7 @@ function cascadeDeletePlugin(schema, options) {
     }
     const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
     const currentResults = await findOrphans.call(this, {});
-    if (!currentResults) {
-      return isPlainObject(previousResults) ? previousResults : {};
-    }
-    return {
-      ...isPlainObject(previousResults) ? previousResults : {},
-      [model]: currentResults
-    };
+    return mergeResults(previousResults, model, currentResults);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/plugins/cascade-delete.mjs

@@ -1,17 +1,6 @@
 import mongoose from "mongoose";
-const deleteOneSupported = Number.parseInt(mongoose.version.split(".")[0] ?? "0", 10) >= 7;
-const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const isFunction = (value) => typeof value === "function";
-const getReferenceModel = (value) => {
-  if (Array.isArray(value)) {
-    return getReferenceModel(value[0]);
-  }
-  if (!isPlainObject(value) || typeof value.ref !== "string") {
-    return null;
-  }
-  return value.ref;
-};
-const isReference = (value, modelName) => getReferenceModel(value) === modelName;
+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)) {
@@ -35,8 +24,18 @@ const applyQueryOptions = (query, options) => {
   }
   return builder;
 };
-const supportsDeleteOne = (value) => isPlainObject(value) && typeof value.deleteOne === "function";
-const supportsRemove = (value) => isPlainObject(value) && typeof value.remove === "function";
+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 : {};
+  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) {
@@ -87,23 +86,9 @@ function cascadeDeletePlugin(schema, options) {
       })
     );
   };
-  if (deleteOneSupported) {
-    schema.post("deleteOne", { document: true, query: false }, async function() {
-      try {
-        await deleteDependents.call(this);
-      } catch (err) {
-        console.error(err);
-      }
-    });
-  } else {
-    schema.post("remove", async function() {
-      try {
-        await deleteDependents.call(this);
-      } catch (err) {
-        console.error(err);
-      }
-    });
-  }
+  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) {
@@ -114,10 +99,7 @@ function cascadeDeletePlugin(schema, options) {
       return prevMethodFn ? prevMethodFn.call(this, modelName) : null;
     }
     const previousResults = prevMethodFn ? await prevMethodFn.call(this) : {};
-    return {
-      ...isPlainObject(previousResults) ? previousResults : {},
-      [model]: await findDependents.call(this, {})
-    };
+    return mergeResults(previousResults, model, await findDependents.call(this, {}));
   });
   const staticFnName = "findOrphans";
   const prevStaticFn = schema.statics[staticFnName];
@@ -130,13 +112,7 @@ function cascadeDeletePlugin(schema, options) {
     }
     const previousResults = prevStaticFn ? await prevStaticFn.call(this) : {};
     const currentResults = await findOrphans.call(this, {});
-    if (!currentResults) {
-      return isPlainObject(previousResults) ? previousResults : {};
-    }
-    return {
-      ...isPlainObject(previousResults) ? previousResults : {},
-      [model]: currentResults
-    };
+    return mergeResults(previousResults, model, currentResults);
   });
 }
 export {

package/plugins/model-function.js

@@ -32,20 +32,23 @@ __export(model_function_exports, {
 });
 module.exports = __toCommonJS(model_function_exports);
 var import_mongoose = __toESM(require("mongoose"));
+const 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 fn.call(import_mongoose.default, doc, ...args);
+    return invokePluginFunction(fn, doc, args);
   });
   schema.method(fnName, function methodFn(...args) {
-    return fn.call(import_mongoose.default, this, ...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 fn.call(import_mongoose.default, model, ...args);
+      return invokePluginFunction(fn, model, args);
     }
   );
 }

package/plugins/model-function.mjs

@@ -1,18 +1,21 @@
 import mongoose from "mongoose";
+const 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 fn.call(mongoose, doc, ...args);
+    return invokePluginFunction(fn, doc, args);
   });
   schema.method(fnName, function methodFn(...args) {
-    return fn.call(mongoose, this, ...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 fn.call(mongoose, model, ...args);
+      return invokePluginFunction(fn, model, args);
     }
   );
 }

package/utils/index.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from 'mongoose';
+
+type ReferenceShape = {
+    ref?: unknown;
+    refPath?: unknown;
+    type?: unknown;
+};
+declare const isSchema: (value: unknown) => value is Schema;
+declare const isObjectIdType: (value: unknown) => boolean;
+declare const isReference: (value: unknown, ref?: string) => value is ReferenceShape;
+
+export { type ReferenceShape, isObjectIdType, isReference, isSchema };

package/utils/index.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'mongoose';
+
+type ReferenceShape = {
+    ref?: unknown;
+    refPath?: unknown;
+    type?: unknown;
+};
+declare const isSchema: (value: unknown) => value is Schema;
+declare const isObjectIdType: (value: unknown) => boolean;
+declare const isReference: (value: unknown, ref?: string) => value is ReferenceShape;
+
+export { type ReferenceShape, isObjectIdType, isReference, isSchema };

package/utils/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  isObjectIdType: () => isObjectIdType,
+  isReference: () => isReference,
+  isSchema: () => isSchema
+});
+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) => {
+  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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isObjectIdType,
+  isReference,
+  isSchema
+});

package/utils/index.mjs

@@ -0,0 +1,22 @@
+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) => {
+  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;
+};
+export {
+  isObjectIdType,
+  isReference,
+  isSchema
+};