@bedrockio/model 0.1.0 → 0.1.1

package/src/validation.js

@@ -6,16 +6,40 @@ import { get, omit, lowerFirst } from 'lodash';
 import { hasAccess } from './access';
 import { searchValidation } from './search';
 import { PermissionsError } from './errors';
+import { hasUniqueConstraints, assertUnique } from './soft-delete';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
 import { RESERVED_FIELDS } from './schema';
 
+const DATE_SCHEMA = yd.date().iso().tag({
+  'x-schema': 'DateTime',
+  'x-description':
+    'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.',
+});
+
+const OBJECT_ID_DESCRIPTION = `
+A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
+An object with an \`id\` field may also be passed, which will be converted into a string.
+`;
+
+export const OBJECT_ID_SCHEMA = yd
+  .custom(async (val) => {
+    const id = String(val.id || val);
+    await namedSchemas.objectId.validate(id);
+    return id;
+  })
+  .tag({
+    type: 'ObjectId',
+    'x-schema': 'ObjectId',
+    'x-description': OBJECT_ID_DESCRIPTION.trim(),
+  });
+
 const namedSchemas = {
   // Email is special as we are assuming that in
   // all cases lowercase should be allowed but coerced.
   email: yd.string().lowercase().email(),
-  // Force "ObjectId" to have parity with refs.
+  // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  ObjectId: yd.string().mongo(),
+  objectId: yd.string().mongo(),
 
   ascii: yd.string().ascii(),
   base64: yd.string().base64(),
@@ -44,14 +68,22 @@ export function addValidators(schemas) {
 }
 
 export function applyValidation(schema, definition) {
+  const hasUnique = hasUniqueConstraints(schema);
+
   schema.static(
     'getCreateValidation',
     function getCreateValidation(appendSchema) {
       return getSchemaFromMongoose(schema, {
+        model: this,
         appendSchema,
         stripReserved: true,
         requireWriteAccess: true,
-        modelName: this.modelName,
+        ...(hasUnique && {
+          assertUniqueOptions: {
+            schema,
+            operation: 'create',
+          },
+        }),
       });
     }
   );
@@ -60,12 +92,18 @@ export function applyValidation(schema, definition) {
     'getUpdateValidation',
     function getUpdateValidation(appendSchema) {
       return getSchemaFromMongoose(schema, {
+        model: this,
         appendSchema,
         skipRequired: true,
         stripReserved: true,
         stripUnknown: true,
         requireWriteAccess: true,
-        modelName: this.modelName,
+        ...(hasUnique && {
+          assertUniqueOptions: {
+            schema,
+            operation: 'update',
+          },
+        }),
       });
     }
   );
@@ -74,16 +112,19 @@ export function applyValidation(schema, definition) {
     'getSearchValidation',
     function getSearchValidation(searchOptions) {
       return getSchemaFromMongoose(schema, {
-        allowRanges: true,
+        allowSearch: true,
         skipRequired: true,
-        allowMultiple: true,
         unwindArrayFields: true,
         requireReadAccess: true,
         appendSchema: searchValidation(definition, searchOptions),
-        modelName: this.modelName,
+        model: this,
       });
     }
   );
+
+  schema.static('getBaseSchema', function getBaseSchema() {
+    return getSchemaFromMongoose(schema);
+  });
 }
 
 // Yada schemas
@@ -98,8 +139,16 @@ function getSchemaFromMongoose(schema, options) {
 
 // Exported for testing
 export function getValidationSchema(attributes, options = {}) {
-  const { appendSchema } = options;
+  const { appendSchema, assertUniqueOptions } = options;
   let schema = getObjectSchema(attributes, options);
+  if (assertUniqueOptions) {
+    schema = yd.custom(async (obj) => {
+      await assertUnique(obj, {
+        model: options.model,
+        ...assertUniqueOptions,
+      });
+    });
+  }
   if (appendSchema) {
     schema = schema.append(appendSchema);
   }
@@ -169,7 +218,10 @@ function getSchemaForTypedef(typedef, options = {}) {
   }
   if (typedef.validate?.schema) {
     schema = schema.append(typedef.validate.schema);
+  } else if (typeof typedef.validate === 'function') {
+    schema = schema.custom(wrapMongooseValidator(typedef.validate));
   }
+
   if (typedef.enum) {
     schema = schema.allow(...typedef.enum);
   }
@@ -182,11 +234,8 @@ function getSchemaForTypedef(typedef, options = {}) {
   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 = yd.allow(schema, yd.array(schema));
+  if (options.allowSearch) {
+    schema = getSearchSchema(schema, type);
   }
   if (typedef.readAccess && options.requireReadAccess) {
     schema = validateReadAccess(schema, typedef.readAccess, options);
@@ -206,46 +255,79 @@ function getSchemaForType(type) {
     case 'Boolean':
       return yd.boolean();
     case 'Date':
-      return yd.date().iso();
+      return DATE_SCHEMA;
     case 'Mixed':
     case 'Object':
       return yd.object();
     case 'Array':
       return yd.array();
     case 'ObjectId':
-      return yd.custom(async (val) => {
-        const id = String(val.id || val);
-        await namedSchemas['ObjectId'].validate(id);
-        return id;
-      });
+      return OBJECT_ID_SCHEMA;
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
 }
 
-function getRangeSchema(schema, type) {
+function getSearchSchema(schema, type) {
   if (type === 'Number') {
-    schema = yd.allow(
-      schema,
-      yd.object({
-        lt: yd.number(),
-        gt: yd.number(),
-        lte: yd.number(),
-        gte: yd.number(),
-      })
-    );
+    return yd
+      .allow(
+        schema,
+        yd.array(schema),
+        yd
+          .object({
+            lt: yd.number().description('Select values less than.'),
+            gt: yd.number().description('Select values greater than.'),
+            lte: yd.number().description('Select values less than or equal.'),
+            gte: yd
+              .number()
+              .description('Select values greater than or equal.'),
+          })
+          .tag({
+            'x-schema': 'NumberRange',
+            'x-description':
+              'An object representing numbers falling within a range.',
+          })
+      )
+      .description(
+        'Allows searching by a value, array of values, or a numeric range.'
+      );
   } else if (type === 'Date') {
-    return yd.allow(
-      schema,
-      yd.object({
-        lt: yd.date().iso(),
-        gt: yd.date().iso(),
-        lte: yd.date().iso(),
-        gte: yd.date().iso(),
-      })
-    );
+    return yd
+      .allow(
+        schema,
+        yd.array(schema),
+        yd
+          .object({
+            lt: yd.date().iso().tag({
+              'x-ref': 'DateTime',
+              description: 'Select dates occurring before.',
+            }),
+            gt: yd.date().iso().tag({
+              'x-ref': 'DateTime',
+              description: 'Select dates occurring after.',
+            }),
+            lte: yd.date().iso().tag({
+              'x-ref': 'DateTime',
+              description: 'Select dates occurring on or before.',
+            }),
+            gte: yd.date().iso().tag({
+              'x-ref': 'DateTime',
+              description: 'Select dates occurring on or after.',
+            }),
+          })
+          .tag({
+            'x-schema': 'DateRange',
+            'x-description':
+              'An object representing dates falling within a range.',
+          })
+      )
+      .description('Allows searching by a date, array of dates, or a range.');
+  } else if (type === 'String' || type === 'ObjectId') {
+    return yd.allow(schema, yd.array(schema));
+  } else {
+    return schema;
   }
-  return schema;
 }
 
 function isRequired(typedef, options) {
@@ -270,7 +352,7 @@ function validateWriteAccess(schema, allowed, options) {
 }
 
 function validateAccess(type, schema, allowed, options) {
-  const { modelName } = options;
+  const { modelName } = options.model;
   return schema.custom((val, options) => {
     const document = options[lowerFirst(modelName)] || options['document'];
     const isAllowed = hasAccess(type, allowed, {
@@ -289,14 +371,14 @@ function validateAccess(type, schema, allowed, options) {
 // Mongoose Validators
 
 export function getNamedValidator(name) {
-  return wrapMongooseValidator(getNamedSchema(name));
+  return wrapSchemaAsValidator(getNamedSchema(name));
 }
 
 export function getTupleValidator(types) {
   types = types.map((type) => {
     return getSchemaForTypedef(type);
   });
-  return wrapMongooseValidator(yd.array(types).length(types.length));
+  return wrapSchemaAsValidator(yd.array(types).length(types.length));
 }
 
 // Returns an async function that will error on failure.
@@ -312,7 +394,7 @@ export function getTupleValidator(types) {
 // the first style here.
 //
 // https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-validate
-function wrapMongooseValidator(schema) {
+function wrapSchemaAsValidator(schema) {
   const validator = async (val) => {
     await schema.validate(val);
   };
@@ -320,6 +402,15 @@ function wrapMongooseValidator(schema) {
   return validator;
 }
 
+function wrapMongooseValidator(validator) {
+  return async (val) => {
+    const result = await validator(val);
+    if (!result && result !== undefined) {
+      throw new Error('Validation failed.');
+    }
+  };
+}
+
 function getNamedSchema(name) {
   const schema = namedSchemas[name];
   if (!schema) {

package/types/access.d.ts

@@ -0,0 +1,7 @@
+export function hasReadAccess(allowed: any, options: any): boolean;
+export function hasWriteAccess(allowed: any, options: any): boolean;
+/**
+ * @param {string|string[]} allowed
+ */
+export function hasAccess(type: any, allowed?: string | string[], options?: {}): boolean;
+//# sourceMappingURL=access.d.ts.map

package/types/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.js"],"names":[],"mappings":"AAGA,mEAEC;AAED,oEAEC;AAED;;GAEG;AACH,+CAFW,MAAM,GAAC,MAAM,EAAE,yBA4BzB"}

package/types/assign.d.ts

@@ -0,0 +1,2 @@
+export function applyAssign(schema: any): void;
+//# sourceMappingURL=assign.d.ts.map

package/types/assign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assign.d.ts","sourceRoot":"","sources":["../src/assign.js"],"names":[],"mappings":"AAIA,+CAYC"}

package/types/const.d.ts

@@ -0,0 +1,9 @@
+export namespace SEARCH_DEFAULTS {
+    const limit: number;
+    namespace sort {
+        const field: string;
+        const order: string;
+    }
+}
+export const POPULATE_MAX_DEPTH: 5;
+//# sourceMappingURL=const.d.ts.map

package/types/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.js"],"names":[],"mappings":";;;;;;;AAQA,mCAAoC"}

package/types/disallowed.d.ts

@@ -0,0 +1,2 @@
+export function applyDisallowed(schema: any): void;
+//# sourceMappingURL=disallowed.d.ts.map

package/types/disallowed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disallowed.d.ts","sourceRoot":"","sources":["../src/disallowed.js"],"names":[],"mappings":"AAEA,mDA4DC"}

package/types/errors.d.ts

@@ -0,0 +1,9 @@
+export class PermissionsError extends Error {
+}
+export class ImplementationError extends Error {
+}
+export class ReferenceError extends Error {
+    constructor(message: any, references: any);
+    references: any;
+}
+//# sourceMappingURL=errors.d.ts.map

package/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAAA;CAA8C;AAC9C;CAAiD;AAEjD;IACE,2CAGC;IADC,gBAA4B;CAE/B"}

package/types/include.d.ts

@@ -0,0 +1,4 @@
+export function applyInclude(schema: any): void;
+export function checkSelects(doc: any, ret: any): void;
+export function getIncludes(modelName: any, arg: any): any;
+//# sourceMappingURL=include.d.ts.map

package/types/include.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAeA,gDAoCC;AAMD,uDA4BC;AAGD,2DAIC"}

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export { createSchema } from "./schema";
+export { addValidators } from "./validation";
+export * from "./testing";
+export * from "./errors";
+export { loadModel, loadModelDir } from "./load";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/types/load.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Loads a single model by definition and name.
+ * @param {object} definition
+ * @param {string} name
+ * @returns mongoose.Model
+ */
+export function loadModel(definition: object, name: string): any;
+/**
+ * Loads all model definitions in the given directory.
+ * Returns the full loaded model set.
+ * @param {string} dirPath
+ */
+export function loadModelDir(dirPath: string): mongoose.Models;
+import mongoose from "mongoose";
+//# sourceMappingURL=load.d.ts.map

package/types/load.d.ts.map

@@ -0,0 +1 @@
+{"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/references.d.ts

@@ -0,0 +1,2 @@
+export function applyReferences(schema: any): void;
+//# sourceMappingURL=references.d.ts.map

package/types/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../src/references.js"],"names":[],"mappings":"AAMA,mDAoDC"}

package/types/schema.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Creates a new Mongoose schema with Bedrock extensions
+ * applied. For more about syntax and functionality see
+ * [the documentation](https://github.com/bedrockio/model#schemas).
+ * @param {object} definition
+ * @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, {
+    autoIndex?: boolean;
+    autoCreate?: boolean;
+    bufferCommands?: boolean;
+    bufferTimeoutMS?: number;
+    capped?: number | boolean | {
+        size?: number;
+        max?: number;
+        autoIndexId?: boolean;
+    };
+    collation?: import("mongodb").CollationOptions;
+    timeseries?: import("mongodb").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?: import("mongodb").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;
+    toObject: {
+        getters: boolean;
+        versionKey: boolean;
+        transform: (doc: any, ret: any, options: any) => void;
+    } | mongoose.ToObjectOptions;
+    typeKey?: string;
+    validateBeforeSave?: boolean;
+    versionKey?: string | boolean;
+    selectPopulatedPaths?: boolean;
+    skipVersioning?: {
+        [key: string]: boolean;
+    };
+    storeSubdocValidationError?: boolean;
+    timestamps: boolean | mongoose.SchemaTimestampsConfig;
+    supressReservedKeysWarning?: boolean;
+    statics?: any;
+    methods?: any;
+    query?: any;
+    castNonArrays?: boolean;
+    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
+    overwriteModels?: boolean;
+}, any>;
+export function normalizeAttributes(arg: any, path?: any[]): any;
+export const RESERVED_FIELDS: string[];
+import mongoose from "mongoose";
+//# sourceMappingURL=schema.d.ts.map

package/types/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoChC;AAED,iEAuBC;AAzED,uCAKE"}