@bedrockio/model 0.1.9 → 0.1.11

package/dist/cjs/search.js

@@ -107,13 +107,15 @@ function validateDefinition(definition) {
   }
 }
 function resolveSort(sort, schema) {
-  if (!Array.isArray(sort)) {
+  if (!sort) {
+    sort = [];
+  } else if (!Array.isArray(sort)) {
     sort = [sort];
   }
   for (let {
     field
   } of sort) {
-    if (!schema.path(field)) {
+    if (!field || !schema.path(field)) {
       throw new Error(`Unknown sort field "${field}".`);
     }
   }

package/dist/cjs/validation.js

@@ -19,31 +19,33 @@ var _softDelete = require("./soft-delete");
 var _utils = require("./utils");
 var _include = require("./include");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const DATE_SCHEMA = _yada.default.date().iso().tag({
+const DATE_TAGS = {
   '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_SCHEMA = _yada.default.string().mongo().tag({
+  'x-schema': 'ObjectId',
+  'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
 });
-const OBJECT_ID_DESCRIPTION = `
+exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
+const REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.object({
+  id: OBJECT_ID_SCHEMA.required()
+}).custom(obj => {
+  return obj.id;
+})).tag({
+  'x-schema': 'Reference',
+  'x-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.
-`;
-const OBJECT_ID_SCHEMA = _yada.default.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()
+    `.trim()
 });
-exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
 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(),
+  objectId: OBJECT_ID_SCHEMA,
   ascii: _yada.default.string().ascii(),
   base64: _yada.default.string().base64(),
   btc: _yada.default.string().btc(),
@@ -77,6 +79,7 @@ function applyValidation(schema, definition) {
       allowIncludes: true,
       stripDeleted: true,
       stripTimestamps: true,
+      allowExpandedRefs: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -94,6 +97,7 @@ function applyValidation(schema, definition) {
       stripUnknown: true,
       stripDeleted: true,
       stripTimestamps: true,
+      allowExpandedRefs: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -213,7 +217,7 @@ function getObjectSchema(arg, options) {
     }
     return schema;
   } else {
-    return getSchemaForType(arg);
+    return getSchemaForType(arg, options);
   }
 }
 function getArraySchema(arr, options) {
@@ -247,11 +251,14 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else if (typeof type === 'object') {
     schema = getObjectSchema(type, options);
   } else {
-    schema = getSchemaForType(type);
+    schema = getSchemaForType(type, options);
   }
   if (isRequired(typedef, options)) {
     schema = schema.required();
   }
+  if (typedef.default) {
+    schema = schema.default(typedef.default);
+  }
   if (typedef.validate?.schema) {
     schema = schema.append(typedef.validate.schema);
   } else if (typeof typedef.validate === 'function') {
@@ -280,7 +287,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   }
   return schema;
 }
-function getSchemaForType(type) {
+function getSchemaForType(type, options) {
   switch (type) {
     case 'String':
       return _yada.default.string();
@@ -289,14 +296,18 @@ function getSchemaForType(type) {
     case 'Boolean':
       return _yada.default.boolean();
     case 'Date':
-      return DATE_SCHEMA;
+      return _yada.default.date().iso().tag(DATE_TAGS);
     case 'Mixed':
     case 'Object':
       return _yada.default.object();
     case 'Array':
       return _yada.default.array();
     case 'ObjectId':
-      return OBJECT_ID_SCHEMA;
+      if (options.allowExpandedRefs) {
+        return REFERENCE_SCHEMA;
+      } else {
+        return OBJECT_ID_SCHEMA;
+      }
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
@@ -315,19 +326,19 @@ function getSearchSchema(schema, type) {
   } else if (type === 'Date') {
     return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
       lt: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring before.'
       }),
       gt: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring after.'
       }),
       lte: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring on or before.'
       }),
       gte: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring on or after.'
       })
     }).tag({

package/package.json

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

package/src/search.js

@@ -119,11 +119,13 @@ function validateDefinition(definition) {
 }
 
 function resolveSort(sort, schema) {
-  if (!Array.isArray(sort)) {
+  if (!sort) {
+    sort = [];
+  } else if (!Array.isArray(sort)) {
     sort = [sort];
   }
   for (let { field } of sort) {
-    if (!schema.path(field)) {
+    if (!field || !schema.path(field)) {
       throw new Error(`Unknown sort field "${field}".`);
     }
   }

package/src/validation.js

@@ -10,27 +10,35 @@ import { hasUniqueConstraints, assertUnique } from './soft-delete';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
 import { INCLUDE_FIELD_SCHEMA } from './include';
 
-const DATE_SCHEMA = yd.date().iso().tag({
+const DATE_TAGS = {
   'x-schema': 'DateTime',
   'x-description':
     'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.',
+};
+
+export const OBJECT_ID_SCHEMA = yd.string().mongo().tag({
+  'x-schema': 'ObjectId',
+  'x-description':
+    'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).',
 });
 
-const OBJECT_ID_DESCRIPTION = `
+const REFERENCE_SCHEMA = yd
+  .allow(
+    OBJECT_ID_SCHEMA,
+    yd
+      .object({
+        id: OBJECT_ID_SCHEMA.required(),
+      })
+      .custom((obj) => {
+        return obj.id;
+      })
+  )
+  .tag({
+    'x-schema': 'Reference',
+    'x-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(),
+    `.trim(),
   });
 
 const namedSchemas = {
@@ -39,7 +47,7 @@ const namedSchemas = {
   email: yd.string().lowercase().email(),
   // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  objectId: yd.string().mongo(),
+  objectId: OBJECT_ID_SCHEMA,
 
   ascii: yd.string().ascii(),
   base64: yd.string().base64(),
@@ -79,6 +87,7 @@ export function applyValidation(schema, definition) {
         allowIncludes: true,
         stripDeleted: true,
         stripTimestamps: true,
+        allowExpandedRefs: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -100,6 +109,7 @@ export function applyValidation(schema, definition) {
         stripUnknown: true,
         stripDeleted: true,
         stripTimestamps: true,
+        allowExpandedRefs: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -216,7 +226,7 @@ function getObjectSchema(arg, options) {
 
     return schema;
   } else {
-    return getSchemaForType(arg);
+    return getSchemaForType(arg, options);
   }
 }
 
@@ -252,12 +262,15 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else if (typeof type === 'object') {
     schema = getObjectSchema(type, options);
   } else {
-    schema = getSchemaForType(type);
+    schema = getSchemaForType(type, options);
   }
 
   if (isRequired(typedef, options)) {
     schema = schema.required();
   }
+  if (typedef.default) {
+    schema = schema.default(typedef.default);
+  }
   if (typedef.validate?.schema) {
     schema = schema.append(typedef.validate.schema);
   } else if (typeof typedef.validate === 'function') {
@@ -288,7 +301,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   return schema;
 }
 
-function getSchemaForType(type) {
+function getSchemaForType(type, options) {
   switch (type) {
     case 'String':
       return yd.string();
@@ -297,14 +310,18 @@ function getSchemaForType(type) {
     case 'Boolean':
       return yd.boolean();
     case 'Date':
-      return DATE_SCHEMA;
+      return yd.date().iso().tag(DATE_TAGS);
     case 'Mixed':
     case 'Object':
       return yd.object();
     case 'Array':
       return yd.array();
     case 'ObjectId':
-      return OBJECT_ID_SCHEMA;
+      if (options.allowExpandedRefs) {
+        return REFERENCE_SCHEMA;
+      } else {
+        return OBJECT_ID_SCHEMA;
+      }
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
@@ -341,22 +358,34 @@ function getSearchSchema(schema, type) {
         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.',
-            }),
+            lt: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring before.',
+              }),
+            gt: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring after.',
+              }),
+            lte: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring on or before.',
+              }),
+            gte: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring on or after.',
+              }),
           })
           .tag({
             'x-schema': 'DateRange',

package/types/validation.d.ts

@@ -9,5 +9,95 @@ export function getTupleValidator(types: any): {
     (val: any): Promise<void>;
     schema: any;
 };
-export const OBJECT_ID_SCHEMA: import("@bedrockio/yada/types/Schema").default;
+export const OBJECT_ID_SCHEMA: {
+    length(length: number): any;
+    min(length: number): any;
+    max(length: number): any;
+    trim(): any;
+    lowercase(assert?: boolean): any;
+    uppercase(assert?: boolean): any;
+    match(reg: RegExp): any;
+    email(): any;
+    phone(): any;
+    hex(): any;
+    md5(): any;
+    sha1(): any;
+    ascii(): any;
+    base64(options?: {
+        urlSafe?: boolean;
+    }): any;
+    creditCard(): any;
+    ip(): any;
+    country(): any;
+    locale(): any;
+    jwt(): any;
+    slug(): any;
+    latlng(): any;
+    postalCode(locale?: string): any;
+    password(options?: {
+        minLength?: number;
+        minNumbers?: number;
+        minSymbols?: number;
+        minLowercase?: number;
+        minUppercase?: number;
+    }): any;
+    url(options?: {
+        require_protocol?: boolean;
+        require_valid_protocol?: boolean;
+        require_host?: boolean;
+        require_port?: boolean;
+        allow_protocol_relative_urls?: boolean;
+        allow_fragments?: boolean;
+        allow_query_components?: boolean;
+        validate_length?: boolean;
+        protocols?: string[];
+    }): any;
+    domain(options?: {
+        require_tld?: boolean;
+        allow_underscores?: boolean;
+        allow_trailing_dot?: boolean;
+        allow_numeric_tld?: boolean;
+        allow_wildcard?: boolean;
+        ignore_max_length?: boolean;
+    }): any;
+    uuid(version?: 1 | 2 | 5 | 3 | 4): any;
+    btc(): any;
+    eth(): any;
+    swift(): any;
+    mongo(): any;
+    format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): any;
+    default(value: any): any;
+    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+    strip(strip: any): any;
+    allow(...set: any[]): any;
+    reject(...set: any[]): any;
+    message(message: any): any;
+    tag(tags: any): any;
+    description(description: any): any;
+    options(options: any): any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): any;
+    append(schema: any): any;
+    toOpenApi(extra: any): any;
+    expandExtra(extra?: {}): {};
+    assertEnum(set: any, allow: any): any;
+    assert(type: any, fn: any): any;
+    pushAssertion(assertion: any): void;
+    transform(fn: any): any;
+    getSortIndex(type: any): number;
+    runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+    enumToOpenApi(): {
+        type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        enum: any;
+        oneOf?: undefined;
+    } | {
+        oneOf: any[];
+        type?: undefined;
+        enum?: undefined;
+    };
+};
 //# sourceMappingURL=validation.d.ts.map

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA4EC;AAsBD,wEAkBC;AA0PD;;;EAEC;AAED;;;EAOC;AAvaD,8EAUK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAyEA,kDAEC;AAED,oEA8EC;AAsBD,wEAkBC;AA6QD;;;EAEC;AAED;;;EAOC;AAzcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIG"}