@bedrockio/model 0.1.3 → 0.1.5

package/dist/cjs/search.js

@@ -84,7 +84,7 @@ function searchValidation(definition, options = {}) {
     sort,
     ...rest
   } = options;
-  return {
+  return _yada.default.object({
     ids: _yada.default.array(_validation.OBJECT_ID_SCHEMA),
     keyword: _yada.default.string().description('A keyword to perform a text search against.'),
     include: _yada.default.string().description('Fields to be selected or populated.'),
@@ -92,7 +92,7 @@ function searchValidation(definition, options = {}) {
     sort: _yada.default.allow(SORT_SCHEMA, _yada.default.array(SORT_SCHEMA)).default(sort),
     limit: _yada.default.number().positive().default(limit).description('Limits the number of results.'),
     ...rest
-  };
+  });
 }
 function validateDefinition(definition) {
   if (Array.isArray(definition.search)) {

package/dist/cjs/validation.js

@@ -104,6 +104,7 @@ function applyValidation(schema, definition) {
     return getSchemaFromMongoose(schema, {
       allowSearch: true,
       skipRequired: true,
+      expandDotSyntax: true,
       unwindArrayFields: true,
       requireReadAccess: true,
       appendSchema: (0, _search.searchValidation)(definition, searchOptions),
@@ -135,8 +136,10 @@ function getValidationSchema(attributes, options = {}) {
   } = options;
   let schema = getObjectSchema(attributes, options);
   if (assertUniqueOptions) {
-    schema = _yada.default.custom(async obj => {
-      await (0, _softDelete.assertUnique)(obj, {
+    schema = schema.custom(async (obj, {
+      root
+    }) => {
+      await (0, _softDelete.assertUnique)(root, {
         model: options.model,
         ...assertUniqueOptions
       });
@@ -148,9 +151,6 @@ function getValidationSchema(attributes, options = {}) {
   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) {
@@ -158,6 +158,10 @@ function getObjectSchema(arg, options) {
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
+    const {
+      stripUnknown,
+      expandDotSyntax
+    } = options;
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
@@ -170,6 +174,11 @@ function getObjectSchema(arg, options) {
         stripUnknown: true
       });
     }
+    if (expandDotSyntax) {
+      schema = schema.options({
+        expandDotSyntax: true
+      });
+    }
     return schema;
   } else {
     return getSchemaForType(arg);
@@ -346,7 +355,9 @@ function getTupleValidator(types) {
   types = types.map(type => {
     return getSchemaForTypedef(type);
   });
-  return wrapSchemaAsValidator(_yada.default.tuple(types));
+  // Using "loose" here to allow empty arrays through,
+  // which mongoose defaults to for array fields.
+  return wrapSchemaAsValidator(_yada.default.tuple(types).loose());
 }
 
 // Returns an async function that will error on failure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -26,10 +26,10 @@
   },
   "dependencies": {
     "@bedrockio/logger": "^1.0.5",
-    "@bedrockio/yada": "^1.0.17",
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
+    "@bedrockio/yada": "^1.0.20",
     "mongoose": "^6.9.0"
   },
   "devDependencies": {
@@ -37,6 +37,7 @@
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
+    "@bedrockio/yada": "^1.0.20",
     "@shelf/jest-mongodb": "^4.1.6",
     "babel-plugin-import-replacement": "^1.0.1",
     "eslint": "^8.33.0",

package/src/search.js

@@ -85,7 +85,7 @@ export function searchValidation(definition, options = {}) {
 
   const { limit, sort, ...rest } = options;
 
-  return {
+  return yd.object({
     ids: yd.array(OBJECT_ID_SCHEMA),
     keyword: yd
       .string()
@@ -99,7 +99,7 @@ export function searchValidation(definition, options = {}) {
       .default(limit)
       .description('Limits the number of results.'),
     ...rest,
-  };
+  });
 }
 
 function validateDefinition(definition) {

package/src/validation.js

@@ -114,6 +114,7 @@ export function applyValidation(schema, definition) {
       return getSchemaFromMongoose(schema, {
         allowSearch: true,
         skipRequired: true,
+        expandDotSyntax: true,
         unwindArrayFields: true,
         requireReadAccess: true,
         appendSchema: searchValidation(definition, searchOptions),
@@ -142,8 +143,8 @@ export function getValidationSchema(attributes, options = {}) {
   const { appendSchema, assertUniqueOptions } = options;
   let schema = getObjectSchema(attributes, options);
   if (assertUniqueOptions) {
-    schema = yd.custom(async (obj) => {
-      await assertUnique(obj, {
+    schema = schema.custom(async (obj, { root }) => {
+      await assertUnique(root, {
         model: options.model,
         ...assertUniqueOptions,
       });
@@ -156,7 +157,6 @@ export function getValidationSchema(attributes, options = {}) {
 }
 
 function getObjectSchema(arg, options) {
-  const { stripUnknown } = options;
   if (isSchemaTypedef(arg)) {
     return getSchemaForTypedef(arg, options);
   } else if (arg instanceof mongoose.Schema) {
@@ -164,6 +164,7 @@ function getObjectSchema(arg, options) {
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
+    const { stripUnknown, expandDotSyntax } = options;
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
@@ -178,6 +179,11 @@ function getObjectSchema(arg, options) {
         stripUnknown: true,
       });
     }
+    if (expandDotSyntax) {
+      schema = schema.options({
+        expandDotSyntax: true,
+      });
+    }
 
     return schema;
   } else {
@@ -385,7 +391,9 @@ export function getTupleValidator(types) {
   types = types.map((type) => {
     return getSchemaForTypedef(type);
   });
-  return wrapSchemaAsValidator(yd.tuple(types));
+  // Using "loose" here to allow empty arrays through,
+  // which mongoose defaults to for array fields.
+  return wrapSchemaAsValidator(yd.tuple(types).loose());
 }
 
 // Returns an async function that will error on failure.

package/types/schema.d.ts

@@ -16,8 +16,8 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         max?: number;
         autoIndexId?: boolean;
     };
-    collation?: import("mongodb").CollationOptions;
-    timeseries?: import("mongodb").TimeSeriesCollectionOptions;
+    collation?: import("mongoose/node_modules/mongodb").CollationOptions;
+    timeseries?: import("mongoose/node_modules/mongodb").TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: string | number;
     collection?: string;
@@ -29,7 +29,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     optimisticConcurrency?: boolean;
     pluginTags?: string[];
     read?: string;
-    writeConcern?: import("mongodb").WriteConcern;
+    writeConcern?: import("mongoose/node_modules/mongodb").WriteConcern;
     safe?: boolean | {
         w?: string | number;
         wtimeout?: number;

package/types/search.d.ts

@@ -1,303 +1,39 @@
 export function applySearch(schema: any, definition: any): void;
 export function searchValidation(definition: any, options?: {}): {
-    ids: {
-        setup: any;
-        length(length: any): any;
-        min(length: any): any;
-        max(length: any): any;
-        latlng(): 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;
-        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;
-        };
-    };
-    keyword: {
-        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?: 2 | 1 | 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;
-        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;
-        };
-    };
-    include: {
-        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?: 2 | 1 | 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;
-        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;
-        };
-    };
-    skip: {
-        min(min: number, message?: string): any;
-        max(max: number, message?: string): any;
-        negative(): any;
-        positive(): any;
-        integer(): any;
-        multiple(multiple: any): 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;
-        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;
-        };
-    };
-    sort: import("@bedrockio/yada/types/Schema").default;
-    limit: {
-        min(min: number, message?: string): any;
-        max(max: number, message?: string): any;
-        negative(): any;
-        positive(): any;
-        integer(): any;
-        multiple(multiple: any): 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;
-        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;
-        };
+    setup: any;
+    getFields: any;
+    append(arg: import("@bedrockio/yada/types/Schema").default | import("@bedrockio/yada/types/object").SchemaMap): 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;
+    toOpenApi(extra: any): any;
+    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=search.d.ts.map

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAmBA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAmBA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBC"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA0DC;AAaD,wEAeC;AAgOD;;;EAEC;AAED;;;EAKC;AA7WD,8EAUK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA2DC;AAaD,wEAeC;AAqOD;;;EAEC;AAED;;;EAOC;AArXD,8EAUK"}