@bedrockio/model 0.1.0

package/dist/cjs/soft-delete.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applySoftDelete = applySoftDelete;
+var _warn = _interopRequireDefault(require("./warn"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function applySoftDelete(schema) {
+  // Implementation
+
+  schema.pre(/^find|count|exists/, function (next) {
+    const filter = this.getFilter();
+    if (filter.deleted === undefined) {
+      // Search non-deleted docs by default
+      filter.deleted = false;
+    }
+    return next();
+  });
+
+  // Instance Methods
+
+  schema.method('delete', function () {
+    this.deleted = true;
+    this.deletedAt = new Date();
+    return this.save();
+  });
+  schema.method('restore', function restore() {
+    this.deleted = false;
+    this.deletedAt = undefined;
+    return this.save();
+  });
+  schema.method('destroy', function destroy(...args) {
+    const filter = {
+      _id: this._id
+    };
+    return this.constructor.destroyOne(filter, ...args);
+  });
+
+  // Static Methods
+
+  schema.static('deleteOne', async function deleteOne(filter, ...rest) {
+    const update = getDelete();
+    const res = await this.updateOne(filter, update, ...rest);
+    return {
+      acknowledged: res.acknowledged,
+      deletedCount: res.modifiedCount
+    };
+  });
+  schema.static('deleteMany', async function deleteMany(filter, ...rest) {
+    const update = getDelete();
+    const res = await this.updateMany(filter, update, ...rest);
+    return {
+      acknowledged: res.acknowledged,
+      deletedCount: res.modifiedCount
+    };
+  });
+  schema.static('findOneAndDelete', async function findOneAndDelete(filter, ...args) {
+    return await this.findOneAndUpdate(filter, getDelete(), ...args);
+  });
+  schema.static('restoreOne', async function restoreOne(filter, ...rest) {
+    const update = getRestore();
+    const res = await this.updateOne(filter, update, ...rest);
+    return {
+      acknowledged: res.acknowledged,
+      restoredCount: res.modifiedCount
+    };
+  });
+  schema.static('restoreMany', async function restoreMany(filter, ...rest) {
+    const update = getRestore();
+    const res = await this.updateMany(filter, update, ...rest);
+    return {
+      acknowledged: res.acknowledged,
+      restoredCount: res.modifiedCount
+    };
+  });
+  schema.static('destroyOne', async function destroyOne(...args) {
+    const res = await this.collection.deleteOne(...args);
+    return {
+      acknowledged: res.acknowledged,
+      destroyedCount: res.deletedCount
+    };
+  });
+  schema.static('destroyMany', async function destroyMany(...args) {
+    const res = await this.collection.deleteMany(...args);
+    return {
+      acknowledged: res.acknowledged,
+      destroyedCount: res.deletedCount
+    };
+  });
+  schema.static('findDeleted', function findDeleted(filter) {
+    return this.find({
+      ...filter,
+      deleted: true
+    });
+  });
+  schema.static('findOneDeleted', function findOneDeleted(filter) {
+    return this.findOne({
+      ...filter,
+      deleted: true
+    });
+  });
+  schema.static('findByIdDeleted', function findByIdDeleted(id) {
+    return this.findOne({
+      _id: id,
+      deleted: true
+    });
+  });
+  schema.static('existsDeleted', function existsDeleted() {
+    return this.exists({
+      deleted: true
+    });
+  });
+  schema.static('countDocumentsDeleted', function countDocumentsDeleted(filter) {
+    return this.countDocuments({
+      ...filter,
+      deleted: true
+    });
+  });
+  schema.static('findWithDeleted', function findWithDeleted(filter) {
+    return this.find({
+      ...filter,
+      ...getWithDeletedQuery()
+    });
+  });
+  schema.static('findOneWithDeleted', function findOneWithDeleted(filter) {
+    return this.findOne({
+      ...filter,
+      ...getWithDeletedQuery()
+    });
+  });
+  schema.static('findByIdWithDeleted', function findByIdWithDeleted(id) {
+    return this.findOne({
+      _id: id,
+      ...getWithDeletedQuery()
+    });
+  });
+  schema.static('existsWithDeleted', function existsWithDeleted() {
+    return this.exists({
+      ...getWithDeletedQuery()
+    });
+  });
+  schema.static('countDocumentsWithDeleted', function countDocumentsWithDeleted(filter) {
+    return this.countDocuments({
+      ...filter,
+      ...getWithDeletedQuery()
+    });
+  });
+  schema.method('remove', function () {
+    (0, _warn.default)('The "remove" method on documents is disallowed due to ambiguity.', 'To permanently delete a document use "destroy", otherwise "delete".');
+    throw new Error('Method not allowed.');
+  }, {
+    suppressWarning: true
+  });
+  schema.method('deleteOne', function () {
+    (0, _warn.default)('The "deleteOne" method on documents is disallowed due to ambiguity', 'Use either "delete" or "deleteOne" on the model.');
+    throw new Error('Method not allowed.');
+  });
+  schema.static('remove', function () {
+    (0, _warn.default)('The "remove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "destroyMany", otherwise "deleteMany".');
+    throw new Error('Method not allowed.');
+  });
+  schema.static('findOneAndRemove', function () {
+    (0, _warn.default)('The "findOneAndRemove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "findOneAndDestroy", otherwise "findOneAndDelete".');
+    throw new Error('Method not allowed.');
+  });
+  schema.static('findByIdAndRemove', function () {
+    (0, _warn.default)('The "findByIdAndRemove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "findByIdAndDestroy", otherwise "findByIdAndDelete".');
+    throw new Error('Method not allowed.');
+  });
+}
+function getDelete() {
+  return {
+    deleted: true,
+    deletedAt: new Date()
+  };
+}
+function getRestore() {
+  return {
+    deleted: false,
+    $unset: {
+      deletedAt: true
+    }
+  };
+}
+function getWithDeletedQuery() {
+  return {
+    deleted: {
+      $in: [true, false]
+    }
+  };
+}

package/dist/cjs/testing.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTestModel = createTestModel;
+exports.getTestModelName = getTestModelName;
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _schema = require("./schema");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let counter = 0;
+function createTestModel(...args) {
+  let modelName, attributes, schema;
+  if (typeof args[0] === 'string') {
+    modelName = args[0];
+    attributes = args[1];
+  } else {
+    attributes = args[0];
+  }
+  if ((0, _utils.isMongooseSchema)(attributes)) {
+    schema = attributes;
+  } else {
+    schema = (0, _schema.createSchema)({
+      attributes
+    });
+  }
+  modelName ||= getTestModelName();
+  return _mongoose.default.model(modelName, schema);
+}
+function getTestModelName() {
+  return `TestModel${counter++}`;
+}

package/dist/cjs/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDateField = isDateField;
+exports.isMongooseSchema = isMongooseSchema;
+exports.isNumberField = isNumberField;
+exports.isReferenceField = isReferenceField;
+exports.isSchemaTypedef = isSchemaTypedef;
+exports.resolveField = resolveField;
+exports.resolveInnerField = resolveInnerField;
+var _mongoose = _interopRequireDefault(require("mongoose"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isMongooseSchema(obj) {
+  return obj instanceof _mongoose.default.Schema;
+}
+function isReferenceField(obj, path) {
+  return isType(obj, path, 'ObjectId');
+}
+function isDateField(obj, path) {
+  return isType(obj, path, 'Date');
+}
+function isNumberField(obj, path) {
+  return isType(obj, path, 'Number');
+}
+function isType(obj, path, test) {
+  const {
+    type
+  } = resolveInnerField(obj, path);
+  return type === test || type === _mongoose.default.Schema.Types[test];
+}
+function isSchemaTypedef(arg) {
+  // Has a type defined and is not a literal type field.
+  return arg?.type && !arg.type?.type;
+}
+
+// Note: Resolved field may be an object or a function
+// from mongoose.Schema.Types that is resolved from the
+// shorthand: field: 'String'.
+function resolveField(obj, path) {
+  let typedef = obj;
+  for (let key of path.split('.')) {
+    typedef = resolveFieldForKey(typedef, key);
+  }
+  return typedef;
+}
+
+// The same as resolveField but gets the element
+// typedef in the case of arrays.
+function resolveInnerField(obj, path) {
+  let typedef = resolveField(obj, path);
+  if (Array.isArray(typedef.type)) {
+    typedef = typedef.type[0];
+  }
+  return typedef;
+}
+function resolveFieldForKey(obj, key) {
+  let typedef;
+  if (isSchemaTypedef(obj)) {
+    const {
+      type
+    } = obj;
+    if (Array.isArray(type)) {
+      typedef = type[0][key];
+    } else {
+      typedef = type[key];
+    }
+  } else {
+    typedef = obj[key];
+  }
+  return typedef || {};
+}

package/dist/cjs/validation.js

@@ -0,0 +1,313 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addValidators = addValidators;
+exports.applyValidation = applyValidation;
+exports.getNamedValidator = getNamedValidator;
+exports.getTupleValidator = getTupleValidator;
+exports.getValidationSchema = getValidationSchema;
+var _lowerFirst2 = _interopRequireDefault(require("lodash/lowerFirst"));
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+var _get2 = _interopRequireDefault(require("lodash/get"));
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _yada = _interopRequireDefault(require("@bedrockio/yada"));
+var _access = require("./access");
+var _search = require("./search");
+var _errors = require("./errors");
+var _utils = require("./utils");
+var _schema = require("./schema");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const namedSchemas = {
+  // Email is special as we are assuming that in
+  // all cases lowercase should be allowed but coerced.
+  email: _yada.default.string().lowercase().email(),
+  // Force "ObjectId" to have parity with refs.
+  // "mongo" is notably excluded here for this reason.
+  ObjectId: _yada.default.string().mongo(),
+  ascii: _yada.default.string().ascii(),
+  base64: _yada.default.string().base64(),
+  btc: _yada.default.string().btc(),
+  country: _yada.default.string().country(),
+  creditCard: _yada.default.string().creditCard(),
+  domain: _yada.default.string().domain(),
+  eth: _yada.default.string().eth(),
+  hex: _yada.default.string().hex(),
+  ip: _yada.default.string().ip(),
+  jwt: _yada.default.string().jwt(),
+  latlng: _yada.default.string().latlng(),
+  locale: _yada.default.string().locale(),
+  md5: _yada.default.string().md5(),
+  phone: _yada.default.string().phone(),
+  postalCode: _yada.default.string().postalCode(),
+  sha1: _yada.default.string().sha1(),
+  slug: _yada.default.string().slug(),
+  swift: _yada.default.string().swift(),
+  url: _yada.default.string().url(),
+  uuid: _yada.default.string().uuid()
+};
+function addValidators(schemas) {
+  Object.assign(namedSchemas, schemas);
+}
+function applyValidation(schema, definition) {
+  schema.static('getCreateValidation', function getCreateValidation(appendSchema) {
+    return getSchemaFromMongoose(schema, {
+      appendSchema,
+      stripReserved: true,
+      requireWriteAccess: true,
+      modelName: this.modelName
+    });
+  });
+  schema.static('getUpdateValidation', function getUpdateValidation(appendSchema) {
+    return getSchemaFromMongoose(schema, {
+      appendSchema,
+      skipRequired: true,
+      stripReserved: true,
+      stripUnknown: true,
+      requireWriteAccess: true,
+      modelName: this.modelName
+    });
+  });
+  schema.static('getSearchValidation', function getSearchValidation(searchOptions) {
+    return getSchemaFromMongoose(schema, {
+      allowRanges: true,
+      skipRequired: true,
+      allowMultiple: true,
+      unwindArrayFields: true,
+      requireReadAccess: true,
+      appendSchema: (0, _search.searchValidation)(definition, searchOptions),
+      modelName: this.modelName
+    });
+  });
+}
+
+// Yada schemas
+
+function getSchemaFromMongoose(schema, options) {
+  let {
+    obj
+  } = schema;
+  if (options.stripReserved) {
+    obj = (0, _omit2.default)(obj, _schema.RESERVED_FIELDS);
+  }
+  return getValidationSchema(obj, options);
+}
+
+// Exported for testing
+function getValidationSchema(attributes, options = {}) {
+  const {
+    appendSchema
+  } = options;
+  let schema = getObjectSchema(attributes, options);
+  if (appendSchema) {
+    schema = schema.append(appendSchema);
+  }
+  return schema;
+}
+function getObjectSchema(arg, options) {
+  const {
+    stripUnknown
+  } = options;
+  if ((0, _utils.isSchemaTypedef)(arg)) {
+    return getSchemaForTypedef(arg, options);
+  } else if (arg instanceof _mongoose.default.Schema) {
+    return getObjectSchema(arg.obj, options);
+  } else if (Array.isArray(arg)) {
+    return getArraySchema(arg, options);
+  } else if (typeof arg === 'object') {
+    const map = {};
+    for (let [key, field] of Object.entries(arg)) {
+      if (!isExcludedField(field, options)) {
+        map[key] = getObjectSchema(field, options);
+      }
+    }
+    let schema = _yada.default.object(map);
+    if (stripUnknown) {
+      schema = schema.options({
+        stripUnknown: true
+      });
+    }
+    return schema;
+  } else {
+    return getSchemaForType(arg);
+  }
+}
+function getArraySchema(obj, options) {
+  // Nested array fields may not skip required
+  // validations as they are a new context.
+  let schema = getObjectSchema(obj[0], {
+    ...options,
+    skipRequired: false
+  });
+  if (!options.unwindArrayFields) {
+    schema = _yada.default.array(schema);
+  }
+  return schema;
+}
+function getSchemaForTypedef(typedef, options = {}) {
+  let {
+    type
+  } = typedef;
+  let schema;
+  if ((0, _utils.isMongooseSchema)(type)) {
+    schema = getSchemaFromMongoose(type, options);
+  } else if (Array.isArray(type)) {
+    schema = getArraySchema(type, options);
+  } else if (typeof type === 'object') {
+    schema = getObjectSchema(type, options);
+  } else {
+    schema = getSchemaForType(type);
+  }
+  if (isRequired(typedef, options)) {
+    schema = schema.required();
+  }
+  if (typedef.validate?.schema) {
+    schema = schema.append(typedef.validate.schema);
+  }
+  if (typedef.enum) {
+    schema = schema.allow(...typedef.enum);
+  }
+  if (typedef.match) {
+    schema = schema.match(RegExp(typedef.match));
+  }
+  if (typedef.min != null || typedef.minLength != null) {
+    schema = schema.min(typedef.min ?? typedef.minLength);
+  }
+  if (typedef.max != null || typedef.maxLength != null) {
+    schema = schema.max(typedef.max ?? typedef.maxLength);
+  }
+  if (options.allowRanges) {
+    schema = getRangeSchema(schema, type);
+  }
+  if (options.allowMultiple) {
+    schema = _yada.default.allow(schema, _yada.default.array(schema));
+  }
+  if (typedef.readAccess && options.requireReadAccess) {
+    schema = validateReadAccess(schema, typedef.readAccess, options);
+  }
+  if (typedef.writeAccess && options.requireWriteAccess) {
+    schema = validateWriteAccess(schema, typedef.writeAccess, options);
+  }
+  return schema;
+}
+function getSchemaForType(type) {
+  switch (type) {
+    case 'String':
+      return _yada.default.string();
+    case 'Number':
+      return _yada.default.number();
+    case 'Boolean':
+      return _yada.default.boolean();
+    case 'Date':
+      return _yada.default.date().iso();
+    case 'Mixed':
+    case 'Object':
+      return _yada.default.object();
+    case 'Array':
+      return _yada.default.array();
+    case 'ObjectId':
+      return _yada.default.custom(async val => {
+        const id = String(val.id || val);
+        await namedSchemas['ObjectId'].validate(id);
+        return id;
+      });
+    default:
+      throw new TypeError(`Unknown schema type ${type}`);
+  }
+}
+function getRangeSchema(schema, type) {
+  if (type === 'Number') {
+    schema = _yada.default.allow(schema, _yada.default.object({
+      lt: _yada.default.number(),
+      gt: _yada.default.number(),
+      lte: _yada.default.number(),
+      gte: _yada.default.number()
+    }));
+  } else if (type === 'Date') {
+    return _yada.default.allow(schema, _yada.default.object({
+      lt: _yada.default.date().iso(),
+      gt: _yada.default.date().iso(),
+      lte: _yada.default.date().iso(),
+      gte: _yada.default.date().iso()
+    }));
+  }
+  return schema;
+}
+function isRequired(typedef, options) {
+  return typedef.required && !typedef.default && !options.skipRequired;
+}
+function isExcludedField(field, options) {
+  if ((0, _utils.isSchemaTypedef)(field)) {
+    const {
+      requireWriteAccess
+    } = options;
+    return requireWriteAccess && field.writeAccess === 'none';
+  } else {
+    return false;
+  }
+}
+function validateReadAccess(schema, allowed, options) {
+  return validateAccess('read', schema, allowed, options);
+}
+function validateWriteAccess(schema, allowed, options) {
+  return validateAccess('write', schema, allowed, options);
+}
+function validateAccess(type, schema, allowed, options) {
+  const {
+    modelName
+  } = options;
+  return schema.custom((val, options) => {
+    const document = options[(0, _lowerFirst2.default)(modelName)] || options['document'];
+    const isAllowed = (0, _access.hasAccess)(type, allowed, {
+      ...options,
+      document
+    });
+    if (!isAllowed) {
+      const currentValue = (0, _get2.default)(document, options.path);
+      if (val !== currentValue) {
+        throw new _errors.PermissionsError('requires write permissions.');
+      }
+    }
+  });
+}
+
+// Mongoose Validators
+
+function getNamedValidator(name) {
+  return wrapMongooseValidator(getNamedSchema(name));
+}
+function getTupleValidator(types) {
+  types = types.map(type => {
+    return getSchemaForTypedef(type);
+  });
+  return wrapMongooseValidator(_yada.default.array(types).length(types.length));
+}
+
+// Returns an async function that will error on failure.
+//
+// Note that mongoose validator functions will not be called
+// if the field is optional and not set or unset with undefined.
+// If the field is not optional the "required" field will also
+// perform valdation so no additional checks are necessary.
+//
+// Also note that throwing an error inside a validator and passing
+// the "message" field result in an identical error message. In this
+// case we want the schema error messages to trickle down so using
+// the first style here.
+//
+// https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-validate
+function wrapMongooseValidator(schema) {
+  const validator = async val => {
+    await schema.validate(val);
+  };
+  validator.schema = schema;
+  return validator;
+}
+function getNamedSchema(name) {
+  const schema = namedSchemas[name];
+  if (!schema) {
+    throw new Error(`Cannot find schema for "${name}".`);
+  }
+  return schema;
+}

package/dist/cjs/warn.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = warn;
+var _logger = _interopRequireDefault(require("@bedrockio/logger"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function warn(...lines) {
+  if (process.env.ENV_NAME !== 'test') {
+    _logger.default.warn(lines.join('\n'));
+  }
+}

package/jest-mongodb-config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  mongodbMemoryServerOptions: {
+    binary: {
+      version: '6.0.2',
+      skipMD5: true,
+    },
+    autoStart: false,
+    instance: {},
+  },
+};

package/jest.config.js

@@ -0,0 +1,8 @@
+process.env.ENV_NAME = 'test';
+
+export default {
+  preset: '@shelf/jest-mongodb',
+  setupFilesAfterEnv: ['<rootDir>/test/setup'],
+  // https://github.com/shelfio/jest-mongodb#6-jest-watch-mode-gotcha
+  watchPathIgnorePatterns: ['globalConfig'],
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@bedrockio/model",
+  "version": "0.1.0",
+  "description": "Bedrock utilities for model creation.",
+  "type": "module",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint",
+    "build": "scripts/build",
+    "prepublishOnly": "npm run build"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "src/index.js",
+  "contributors": [
+    {
+      "name": "Andrew Plummer",
+      "email": "andrew@rekall.ai"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bedrockio/model"
+  },
+  "dependencies": {
+    "@bedrockio/logger": "^1.0.3",
+    "@bedrockio/yada": "^1.0.9",
+    "lodash": "^4.17.21"
+  },
+  "peerDependencies": {
+    "mongoose": "^6.9.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.20.7",
+    "@babel/core": "^7.20.12",
+    "@babel/preset-env": "^7.20.2",
+    "@bedrockio/prettier-config": "^1.0.2",
+    "@shelf/jest-mongodb": "^4.1.6",
+    "babel-plugin-import-replacement": "^1.0.1",
+    "babel-plugin-lodash": "^3.3.4",
+    "eslint": "^8.33.0",
+    "eslint-plugin-bedrock": "^1.0.21",
+    "jest": "^29.4.1",
+    "jest-environment-node": "^29.4.1",
+    "mongodb": "4.13.0",
+    "mongoose": "^6.9.0",
+    "prettier-eslint": "^15.0.1"
+  },
+  "volta": {
+    "node": "18.14.0",
+    "yarn": "1.22.19"
+  }
+}