@bedrockio/model 0.3.0 → 0.3.1

package/dist/cjs/access.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.hasAccess = hasAccess;
 var _errors = require("./errors");
+var _utils = require("./utils");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
@@ -28,10 +29,10 @@ function hasAccess(allowed = 'all', options = {}) {
         return document.id == authUser.id;
       } else if (token === 'user') {
         assertOptions(token, options);
-        return document.user?.id == authUser.id;
+        return (0, _utils.isEqual)(document.user, authUser);
       } else if (token === 'owner') {
         assertOptions(token, options);
-        return document.owner?.id == authUser.id;
+        return (0, _utils.isEqual)(document.owner, authUser);
       } else {
         return scopes?.includes(token);
       }

package/dist/cjs/index.js

@@ -7,7 +7,8 @@ var _exportNames = {
   createSchema: true,
   loadModel: true,
   loadModelDir: true,
-  addValidators: true
+  addValidators: true,
+  isEqual: true
 };
 Object.defineProperty(exports, "addValidators", {
   enumerable: true,
@@ -21,6 +22,12 @@ Object.defineProperty(exports, "createSchema", {
     return _schema.createSchema;
   }
 });
+Object.defineProperty(exports, "isEqual", {
+  enumerable: true,
+  get: function () {
+    return _utils.isEqual;
+  }
+});
 Object.defineProperty(exports, "loadModel", {
   enumerable: true,
   get: function () {
@@ -36,6 +43,7 @@ Object.defineProperty(exports, "loadModelDir", {
 var _schema = require("./schema");
 var _load = require("./load");
 var _validation = require("./validation");
+var _utils = require("./utils");
 var _testing = require("./testing");
 Object.keys(_testing).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/dist/cjs/utils.js

@@ -6,12 +6,32 @@ Object.defineProperty(exports, "__esModule", {
 exports.getField = getField;
 exports.getInnerField = getInnerField;
 exports.isDateField = isDateField;
+exports.isEqual = isEqual;
 exports.isMongooseSchema = isMongooseSchema;
 exports.isNumberField = isNumberField;
 exports.isReferenceField = isReferenceField;
 exports.isSchemaTypedef = isSchemaTypedef;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Mongoose provides an "equals" method on both documents and
+// ObjectIds, however it does not provide a static method to
+// compare two unknown values that may be either, so provide
+// it here.
+function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  } else if (a instanceof _mongoose.default.Document) {
+    return a.equals(b);
+  } else if (b instanceof _mongoose.default.Document) {
+    return b.equals(a);
+  } else if (a instanceof _mongoose.default.Types.ObjectId) {
+    return a.equals(b);
+  } else if (b instanceof _mongoose.default.Types.ObjectId) {
+    return b.equals(a);
+  } else {
+    return false;
+  }
+}
 function isMongooseSchema(obj) {
   return obj instanceof _mongoose.default.Schema;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/access.js

@@ -1,4 +1,5 @@
 import { ImplementationError } from './errors';
+import { isEqual } from './utils';
 import warn from './warn';
 
 /**
@@ -20,10 +21,10 @@ export function hasAccess(allowed = 'all', options = {}) {
         return document.id == authUser.id;
       } else if (token === 'user') {
         assertOptions(token, options);
-        return document.user?.id == authUser.id;
+        return isEqual(document.user, authUser);
       } else if (token === 'owner') {
         assertOptions(token, options);
-        return document.owner?.id == authUser.id;
+        return isEqual(document.owner, authUser);
       } else {
         return scopes?.includes(token);
       }

package/src/index.js

@@ -1,5 +1,6 @@
 export { createSchema } from './schema';
 export { loadModel, loadModelDir } from './load';
 export { addValidators } from './validation';
+export { isEqual } from './utils';
 export * from './testing';
 export * from './errors';

package/src/utils.js

@@ -1,5 +1,25 @@
 import mongoose from 'mongoose';
 
+// Mongoose provides an "equals" method on both documents and
+// ObjectIds, however it does not provide a static method to
+// compare two unknown values that may be either, so provide
+// it here.
+export function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  } else if (a instanceof mongoose.Document) {
+    return a.equals(b);
+  } else if (b instanceof mongoose.Document) {
+    return b.equals(a);
+  } else if (a instanceof mongoose.Types.ObjectId) {
+    return a.equals(b);
+  } else if (b instanceof mongoose.Types.ObjectId) {
+    return b.equals(a);
+  } else {
+    return false;
+  }
+}
+
 export function isMongooseSchema(obj) {
   return obj instanceof mongoose.Schema;
 }

package/types/access.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,oCAFW,MAAM,GAAC,MAAM,EAAE,yBA2BzB"}
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,oCAFW,MAAM,GAAC,MAAM,EAAE,yBA2BzB"}

package/types/index.d.ts

@@ -1,5 +1,6 @@
 export { createSchema } from "./schema";
 export { addValidators } from "./validation";
+export { isEqual } from "./utils";
 export * from "./testing";
 export * from "./errors";
 export { loadModel, loadModelDir } from "./load";

package/types/load.d.ts

@@ -4,73 +4,7 @@
  * @param {string} name
  * @returns mongoose.Model
  */
-export function loadModel(definition: object, name: string): mongoose.Model<any, any, any, any, any, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
-    autoIndex?: boolean;
-    autoCreate?: boolean;
-    bufferCommands?: boolean;
-    bufferTimeoutMS?: number;
-    capped?: number | boolean | {
-        size?: number;
-        max?: number;
-        autoIndexId?: boolean;
-    };
-    collation?: mongoose.mongo.CollationOptions;
-    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
-    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
-    expireAfterSeconds?: number;
-    expires?: string | number;
-    collection?: string;
-    discriminatorKey?: string;
-    excludeIndexes?: boolean;
-    id?: boolean;
-    _id?: boolean;
-    minimize?: boolean;
-    optimisticConcurrency?: boolean;
-    pluginTags?: string[];
-    read?: string;
-    writeConcern?: mongoose.mongo.WriteConcern;
-    safe?: boolean | {
-        w?: string | number;
-        wtimeout?: number;
-        j?: boolean;
-    };
-    shardKey?: Record<string, unknown>;
-    strict?: boolean | "throw";
-    strictQuery?: boolean | "throw";
-    toJSON: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    toObject: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    typeKey?: string;
-    validateBeforeSave?: boolean;
-    validateModifiedOnly?: boolean;
-    versionKey?: string | boolean;
-    selectPopulatedPaths?: boolean;
-    skipVersioning?: {
-        [key: string]: boolean;
-    };
-    storeSubdocValidationError?: boolean;
-    timestamps: boolean | mongoose.SchemaTimestampsConfig;
-    suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
-    methods?: any;
-    query?: any;
-    castNonArrays?: boolean;
-    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
-    overwriteModels?: boolean;
-}, any, any>> & {
-    [x: string]: any;
-};
+export function loadModel(definition: object, name: string): any;
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.

package/types/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}

package/types/schema.d.ts

@@ -6,10 +6,9 @@
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, {
     autoIndex?: boolean;
+    autoSearchIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
     bufferTimeoutMS?: number;
@@ -62,10 +61,8 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
     suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
-    methods?: any;
+    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, {}, {}, {}, any, any>>;
+    methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}

package/types/utils.d.ts

@@ -1,3 +1,4 @@
+export function isEqual(a: any, b: any): boolean;
 export function isMongooseSchema(obj: any): boolean;
 export function isReferenceField(obj: any, path: any): boolean;
 export function isDateField(obj: any, path: any): boolean;

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAEA,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAOD,mDAGC;AAuBD,mDAYC;AAKD,wDAEC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAMA,iDAcC;AAED,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAOD,mDAGC;AAuBD,mDAYC;AAKD,wDAEC"}