@bedrockio/model 0.18.3 → 0.18.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (16) hide show
  1. package/.prettierignore +1 -0
  2. package/CHANGELOG.md +5 -0
  3. package/README.md +8 -4
  4. package/dist/cjs/delete-hooks.js +9 -4
  5. package/dist/cjs/validation.js +4 -4
  6. package/package.json +2 -2
  7. package/src/delete-hooks.js +6 -3
  8. package/src/validation.js +5 -4
  9. package/types/delete-hooks.d.ts.map +1 -1
  10. package/types/schema.d.ts +1 -0
  11. package/types/schema.d.ts.map +1 -1
  12. package/types/search.d.ts +33 -42
  13. package/types/search.d.ts.map +1 -1
  14. package/types/validation-schemas.d.ts +70 -84
  15. package/types/validation-schemas.d.ts.map +1 -1
  16. package/types/validation.d.ts.map +1 -1
package/.prettierignore ADDED
@@ -0,0 +1 @@
1
+ README.md
package/CHANGELOG.md CHANGED
@@ -1,3 +1,8 @@
1
+ ## 0.18.4
2
+
3
+ - Bumped yada to fix JSON schema issues.
4
+ - Fixed `deletedRefs` being exposed.
5
+
1
6
  ## 0.18.3
2
7
 
3
8
  - Fixed issues with `getUpdateValidation` not allowing null for nested objects.
package/README.md CHANGED
@@ -461,7 +461,8 @@ validation which will:
461
461
  `Model.getUpdateValidation` to allow this constraint to trickle down to the
462
462
  API.
463
463
 
464
- > [!WARNING] Note that calling `Model.updateOne` will throw an error when a
464
+ > [!WARNING]
465
+ > Note that calling `Model.updateOne` will throw an error when a
465
466
  > unique field exists on any document **including the document being updated**.
466
467
  > This is an intentional constraint that allows `updateOne` better peformance by
467
468
  > not having to fetch the ids of the documents being updated in order to exclude
@@ -1066,7 +1067,8 @@ await Product.findById(id).include('shop.user.^name').
1066
1067
  }
1067
1068
  ```
1068
1069
 
1069
- > [!WARNING] Fields that are dynamically referenced using `refPath` are unable
1070
+ > [!WARNING]
1071
+ > Fields that are dynamically referenced using `refPath` are unable
1070
1072
  > to resolve the schemas beforehand (ie. before query execution), therefore they
1071
1073
  > can only be populated at the top level.
1072
1074
 
@@ -1613,7 +1615,8 @@ for (let shop of shops) {
1613
1615
  }
1614
1616
  ```
1615
1617
 
1616
- > [!WARNING] The ability to run an `$and` query with multiple paths is currently
1618
+ > [!WARNING]
1619
+ > The ability to run an `$and` query with multiple paths is currently
1617
1620
  > not implemented.
1618
1621
 
1619
1622
  #### Erroring on Delete
@@ -1643,7 +1646,8 @@ Models that have delete hooks defined on them will keep a reference of the
1643
1646
  documents that were deleted. Calling `.restore()` on the document will also
1644
1647
  restore these references.
1645
1648
 
1646
- > [!WARNING] Delete hooks are **only** run on a single document (`.delete` or
1649
+ > [!WARNING]
1650
+ > Delete hooks are **only** run on a single document (`.delete` or
1647
1651
  > `.restore`). They will not be run when using model methods like `deleteOne` or
1648
1652
  > `deleteMany`.
1649
1653
 
package/dist/cjs/delete-hooks.js CHANGED
@@ -20,10 +20,15 @@ function addDeletedFields(definition) {
20
20
  if (!deleteHooks) {
21
21
  return;
22
22
  }
23
- definition.attributes['deletedRefs'] = [{
24
- _id: 'ObjectId',
25
- ref: 'String'
26
- }];
23
+ definition.attributes['deletedRefs'] = {
24
+ type: 'Array',
25
+ readAccess: 'none',
26
+ writeAccess: 'none',
27
+ attributes: {
28
+ _id: 'ObjectId',
29
+ ref: 'String'
30
+ }
31
+ };
27
32
  }
28
33
  function applyDeleteHooks(schema, definition) {
29
34
  let {
package/dist/cjs/validation.js CHANGED
@@ -368,13 +368,13 @@ function getSchemaForType(type, options) {
368
368
  }
369
369
  function getSearchSchema(schema, type) {
370
370
  if (type === 'String') {
371
- return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.STRING_RANGE_SCHEMA).description('Allows searching by a string, array of strings, or a range.');
371
+ return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _validationSchemas.STRING_RANGE_SCHEMA).description('Allows searching by a string, array of strings, or a range.');
372
372
  } else if (type === 'Number') {
373
- return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.NUMBER_RANGE_SCHEMA).description('Allows searching by a value, array of values, or a range.');
373
+ return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _validationSchemas.NUMBER_RANGE_SCHEMA).description('Allows searching by a value, array of values, or a range.');
374
374
  } else if (type === 'Date') {
375
- return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.DATE_RANGE_SCHEMA).description('Allows searching by a date, array of dates, or a range.');
375
+ return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _validationSchemas.DATE_RANGE_SCHEMA).description('Allows searching by a date, array of dates, or a range.');
376
376
  } else if (type === 'ObjectId') {
377
- return _yada.default.allow(schema, _yada.default.array(schema));
377
+ return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)));
378
378
  } else {
379
379
  return schema;
380
380
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@bedrockio/model",
3
- "version": "0.18.3",
3
+ "version": "0.18.4",
4
4
  "description": "Bedrock utilities for model creation.",
5
5
  "type": "module",
6
6
  "scripts": {
@@ -39,7 +39,7 @@
39
39
  "@babel/preset-env": "^7.26.0",
40
40
  "@bedrockio/eslint-plugin": "^1.2.2",
41
41
  "@bedrockio/prettier-config": "^1.1.1",
42
- "@bedrockio/yada": "^1.9.0",
42
+ "@bedrockio/yada": "^1.10.0",
43
43
  "@shelf/jest-mongodb": "^5.2.2",
44
44
  "eslint": "^9.36.0",
45
45
  "jest": "^30.2.0",
package/src/delete-hooks.js CHANGED
@@ -13,12 +13,15 @@ export function addDeletedFields(definition) {
13
13
  return;
14
14
  }
15
15
 
16
- definition.attributes['deletedRefs'] = [
17
- {
16
+ definition.attributes['deletedRefs'] = {
17
+ type: 'Array',
18
+ readAccess: 'none',
19
+ writeAccess: 'none',
20
+ attributes: {
18
21
  _id: 'ObjectId',
19
22
  ref: 'String',
20
23
  },
21
- ];
24
+ };
22
25
  }
23
26
 
24
27
  export function applyDeleteHooks(schema, definition) {
package/src/validation.js CHANGED
@@ -270,6 +270,7 @@ function getArraySchema(arr, options) {
270
270
  } else {
271
271
  throw new Error('Array schema may not have more than 1 element.');
272
272
  }
273
+
273
274
  return schema;
274
275
  }
275
276
 
@@ -397,22 +398,22 @@ function getSchemaForType(type, options) {
397
398
  function getSearchSchema(schema, type) {
398
399
  if (type === 'String') {
399
400
  return yd
400
- .allow(schema, yd.array(schema), STRING_RANGE_SCHEMA)
401
+ .allow(schema, yd.array(schema.nullable(false)), STRING_RANGE_SCHEMA)
401
402
  .description(
402
403
  'Allows searching by a string, array of strings, or a range.',
403
404
  );
404
405
  } else if (type === 'Number') {
405
406
  return yd
406
- .allow(schema, yd.array(schema), NUMBER_RANGE_SCHEMA)
407
+ .allow(schema, yd.array(schema.nullable(false)), NUMBER_RANGE_SCHEMA)
407
408
  .description(
408
409
  'Allows searching by a value, array of values, or a range.',
409
410
  );
410
411
  } else if (type === 'Date') {
411
412
  return yd
412
- .allow(schema, yd.array(schema), DATE_RANGE_SCHEMA)
413
+ .allow(schema, yd.array(schema.nullable(false)), DATE_RANGE_SCHEMA)
413
414
  .description('Allows searching by a date, array of dates, or a range.');
414
415
  } else if (type === 'ObjectId') {
415
- return yd.allow(schema, yd.array(schema));
416
+ return yd.allow(schema, yd.array(schema.nullable(false)));
416
417
  } else {
417
418
  return schema;
418
419
  }
package/types/delete-hooks.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,wDAaC;AAED,qEAqCC"}
1
+ {"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,wDAgBC;AAED,qEAqCC"}
package/types/schema.d.ts CHANGED
@@ -19,6 +19,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
19
19
  };
20
20
  collation?: mongoose.mongo.CollationOptions;
21
21
  collectionOptions?: mongoose.mongo.CreateCollectionOptions;
22
+ lean?: boolean | mongoose.LeanOptions;
22
23
  timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
23
24
  expireAfterSeconds?: number;
24
25
  expires?: number | string;
package/types/schema.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA2C7B,CAAC;WAAa,CAAC;mBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;SAgIb,CAAC;gBAA4B,CAAA;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA3H5C;AAED,iEAcC;qBA9FoB,UAAU"}
1
+ {"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA2C7B,CAAC;WAAa,CAAC;mBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SAqIH,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAjItB;AAED,iEAcC;qBA9FoB,UAAU"}
package/types/search.d.ts CHANGED
@@ -7,7 +7,7 @@ export function searchValidation(options?: {}): {
7
7
  omit(...names?: string[]): /*elided*/ any;
8
8
  require(...fields: string[]): /*elided*/ any;
9
9
  requireAll(): /*elided*/ any;
10
- requireAllWithin(): /*elided*/ any;
10
+ transform(fn: Function, root?: boolean): /*elided*/ any;
11
11
  export(): any;
12
12
  append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
13
13
  options(options?: {
@@ -16,30 +16,30 @@ export function searchValidation(options?: {}): {
16
16
  allowFlatKeys?: boolean;
17
17
  expandFlatKeys?: boolean;
18
18
  }): /*elided*/ any;
19
+ toJsonSchema(options: any): any;
19
20
  format(name: any, fn: any): /*elided*/ any;
20
21
  toString(): any;
21
22
  assertions: any[];
22
23
  meta: {};
23
- required(): /*elided*/ any;
24
+ required(allow?: boolean): /*elided*/ any;
24
25
  default(arg: any): /*elided*/ any;
25
26
  custom(fn: Function): /*elided*/ any;
26
27
  missing(fn: Function): /*elided*/ any;
27
28
  strip(strip: any): /*elided*/ any;
28
29
  allow(...set: any[]): /*elided*/ any;
29
30
  reject(...set: any[]): /*elided*/ any;
30
- nullable(): /*elided*/ any;
31
+ nullable(allow?: boolean): /*elided*/ any;
31
32
  message(message: any): /*elided*/ any;
32
33
  tag(tags: any): /*elided*/ any;
33
34
  description(description: any): /*elided*/ any;
34
35
  validate(value: any, options?: {}): Promise<any>;
35
36
  clone(meta: any): /*elided*/ any;
36
- toJsonSchema(extra?: any): any;
37
- toOpenApi(...extra: any[]): any;
37
+ toOpenApi(options: any): any;
38
38
  toJSON(): any;
39
- getAnyType(): {
40
- type: string[];
39
+ getType(): {
40
+ type: any;
41
41
  };
42
- getFormat(): {
42
+ getFormat(options: any): {
43
43
  format: any;
44
44
  };
45
45
  getDefault(): {
@@ -47,23 +47,19 @@ export function searchValidation(options?: {}): {
47
47
  } | {
48
48
  default: any;
49
49
  };
50
- getNullable(): {
51
- nullable: boolean;
52
- };
53
- getEnum(): any;
54
- expandExtra(extra?: {}): {};
50
+ getEnum(options: any): any;
51
+ getTags(options?: {}): any;
55
52
  inspect(): string;
56
53
  assertEnum(set: any, allow: any): /*elided*/ any;
57
54
  assert(type: any, fn: any): /*elided*/ any;
58
55
  pushAssertion(assertion: any): void;
59
56
  canSkipAssertion(value: any, assertion: any, options: any): any;
60
- transform(fn: any): /*elided*/ any;
57
+ transformValue(fn: any): /*elided*/ any;
61
58
  getSortIndex(type: any): number;
62
59
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
63
60
  };
64
61
  export function exportValidation(options?: {}): {
65
62
  filename: {
66
- required(): /*elided*/ any;
67
63
  length(length: number): /*elided*/ any;
68
64
  min(length: number): /*elided*/ any;
69
65
  max(length: number): /*elided*/ any;
@@ -123,16 +119,18 @@ export function exportValidation(options?: {}): {
123
119
  calendar(): /*elided*/ any;
124
120
  time(): /*elided*/ any;
125
121
  format(name: any, fn: any): /*elided*/ any;
122
+ toJsonSchema(options: any): any;
126
123
  toString(): any;
127
124
  assertions: any[];
128
125
  meta: {};
126
+ required(allow?: boolean): /*elided*/ any;
129
127
  default(arg: any): /*elided*/ any;
130
128
  custom(fn: Function): /*elided*/ any;
131
129
  missing(fn: Function): /*elided*/ any;
132
130
  strip(strip: any): /*elided*/ any;
133
131
  allow(...set: any[]): /*elided*/ any;
134
132
  reject(...set: any[]): /*elided*/ any;
135
- nullable(): /*elided*/ any;
133
+ nullable(allow?: boolean): /*elided*/ any;
136
134
  message(message: any): /*elided*/ any;
137
135
  tag(tags: any): /*elided*/ any;
138
136
  description(description: any): /*elided*/ any;
@@ -140,13 +138,12 @@ export function exportValidation(options?: {}): {
140
138
  validate(value: any, options?: {}): Promise<any>;
141
139
  clone(meta: any): /*elided*/ any;
142
140
  append(schema: any): import("@bedrockio/yada/types/Schema").default;
143
- toJsonSchema(extra?: any): any;
144
- toOpenApi(...extra: any[]): any;
141
+ toOpenApi(options: any): any;
145
142
  toJSON(): any;
146
- getAnyType(): {
147
- type: string[];
143
+ getType(): {
144
+ type: any;
148
145
  };
149
- getFormat(): {
146
+ getFormat(options: any): {
150
147
  format: any;
151
148
  };
152
149
  getDefault(): {
@@ -154,24 +151,20 @@ export function exportValidation(options?: {}): {
154
151
  } | {
155
152
  default: any;
156
153
  };
157
- getNullable(): {
158
- nullable: boolean;
159
- };
160
- getEnum(): any;
161
- requireAllWithin(): /*elided*/ any;
162
- expandExtra(extra?: {}): {};
154
+ getEnum(options: any): any;
155
+ getTags(options?: {}): any;
156
+ transform(fn: Function, root: any): /*elided*/ any;
163
157
  inspect(): string;
164
158
  get(): void;
165
159
  assertEnum(set: any, allow: any): /*elided*/ any;
166
160
  assert(type: any, fn: any): /*elided*/ any;
167
161
  pushAssertion(assertion: any): void;
168
162
  canSkipAssertion(value: any, assertion: any, options: any): any;
169
- transform(fn: any): /*elided*/ any;
163
+ transformValue(fn: any): /*elided*/ any;
170
164
  getSortIndex(type: any): number;
171
165
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
172
166
  };
173
167
  format: {
174
- required(): /*elided*/ any;
175
168
  length(length: number): /*elided*/ any;
176
169
  min(length: number): /*elided*/ any;
177
170
  max(length: number): /*elided*/ any;
@@ -231,16 +224,18 @@ export function exportValidation(options?: {}): {
231
224
  calendar(): /*elided*/ any;
232
225
  time(): /*elided*/ any;
233
226
  format(name: any, fn: any): /*elided*/ any;
227
+ toJsonSchema(options: any): any;
234
228
  toString(): any;
235
229
  assertions: any[];
236
230
  meta: {};
231
+ required(allow?: boolean): /*elided*/ any;
237
232
  default(arg: any): /*elided*/ any;
238
233
  custom(fn: Function): /*elided*/ any;
239
234
  missing(fn: Function): /*elided*/ any;
240
235
  strip(strip: any): /*elided*/ any;
241
236
  allow(...set: any[]): /*elided*/ any;
242
237
  reject(...set: any[]): /*elided*/ any;
243
- nullable(): /*elided*/ any;
238
+ nullable(allow?: boolean): /*elided*/ any;
244
239
  message(message: any): /*elided*/ any;
245
240
  tag(tags: any): /*elided*/ any;
246
241
  description(description: any): /*elided*/ any;
@@ -248,13 +243,12 @@ export function exportValidation(options?: {}): {
248
243
  validate(value: any, options?: {}): Promise<any>;
249
244
  clone(meta: any): /*elided*/ any;
250
245
  append(schema: any): import("@bedrockio/yada/types/Schema").default;
251
- toJsonSchema(extra?: any): any;
252
- toOpenApi(...extra: any[]): any;
246
+ toOpenApi(options: any): any;
253
247
  toJSON(): any;
254
- getAnyType(): {
255
- type: string[];
248
+ getType(): {
249
+ type: any;
256
250
  };
257
- getFormat(): {
251
+ getFormat(options: any): {
258
252
  format: any;
259
253
  };
260
254
  getDefault(): {
@@ -262,19 +256,16 @@ export function exportValidation(options?: {}): {
262
256
  } | {
263
257
  default: any;
264
258
  };
265
- getNullable(): {
266
- nullable: boolean;
267
- };
268
- getEnum(): any;
269
- requireAllWithin(): /*elided*/ any;
270
- expandExtra(extra?: {}): {};
259
+ getEnum(options: any): any;
260
+ getTags(options?: {}): any;
261
+ transform(fn: Function, root: any): /*elided*/ any;
271
262
  inspect(): string;
272
263
  get(): void;
273
264
  assertEnum(set: any, allow: any): /*elided*/ any;
274
265
  assert(type: any, fn: any): /*elided*/ any;
275
266
  pushAssertion(assertion: any): void;
276
267
  canSkipAssertion(value: any, assertion: any, options: any): any;
277
- transform(fn: any): /*elided*/ any;
268
+ transformValue(fn: any): /*elided*/ any;
278
269
  getSortIndex(type: any): number;
279
270
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
280
271
  };
package/types/search.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBA8GU,CAAH;oBAEG,CAAR;qBAEU,CAAF;sBAEF,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAlDwB,CAAC;;;;;;;;;;;;;;;;;EAzC5B;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA7DzB,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;EA1B5B"}
1
+ {"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBAmHU,CAAC;oBAGD,CAAP;qBACoB,CAAC;sBAGlB,CAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA7B6B,CAAC;;;;;;;;;;;;;;EApElC;AAED;;;;;;;;;;;;;;;;mBA1BmD,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BAGZ,CAAH;0BACgB,CAAC;6BACZ,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAL8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5FgB,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BAGZ,CAAH;0BACgB,CAAC;6BACZ,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAL8B,CAAC;;;;;;;;;;;;;;;;;EArDlC"}
package/types/validation-schemas.d.ts CHANGED
@@ -10,14 +10,14 @@ export const DATE_SCHEMA: {
10
10
  unix(): /*elided*/ any;
11
11
  assertions: any[];
12
12
  meta: {};
13
- required(): /*elided*/ any;
13
+ required(allow?: boolean): /*elided*/ any;
14
14
  default(arg: any): /*elided*/ any;
15
15
  custom(fn: Function): /*elided*/ any;
16
16
  missing(fn: Function): /*elided*/ any;
17
17
  strip(strip: any): /*elided*/ any;
18
18
  allow(...set: any[]): /*elided*/ any;
19
19
  reject(...set: any[]): /*elided*/ any;
20
- nullable(): /*elided*/ any;
20
+ nullable(allow?: boolean): /*elided*/ any;
21
21
  message(message: any): /*elided*/ any;
22
22
  tag(tags: any): /*elided*/ any;
23
23
  description(description: any): /*elided*/ any;
@@ -25,13 +25,17 @@ export const DATE_SCHEMA: {
25
25
  validate(value: any, options?: {}): Promise<any>;
26
26
  clone(meta: any): /*elided*/ any;
27
27
  append(schema: any): import("@bedrockio/yada/types/Schema").default;
28
- toJsonSchema(extra?: any): any;
29
- toOpenApi(...extra: any[]): any;
28
+ toJsonSchema(options?: {
29
+ tag?: Function;
30
+ style?: "openai";
31
+ stripExtensions?: boolean;
32
+ }): any;
33
+ toOpenApi(options: any): any;
30
34
  toJSON(): any;
31
- getAnyType(): {
32
- type: string[];
35
+ getType(): {
36
+ type: any;
33
37
  };
34
- getFormat(): {
38
+ getFormat(options: any): {
35
39
  format: any;
36
40
  };
37
41
  getDefault(): {
@@ -39,24 +43,20 @@ export const DATE_SCHEMA: {
39
43
  } | {
40
44
  default: any;
41
45
  };
42
- getNullable(): {
43
- nullable: boolean;
44
- };
45
- getEnum(): any;
46
- requireAllWithin(): /*elided*/ any;
47
- expandExtra(extra?: {}): {};
46
+ getEnum(options: any): any;
47
+ getTags(options?: {}): any;
48
+ transform(fn: Function, root: any): /*elided*/ any;
48
49
  inspect(): string;
49
50
  get(): void;
50
51
  assertEnum(set: any, allow: any): /*elided*/ any;
51
52
  assert(type: any, fn: any): /*elided*/ any;
52
53
  pushAssertion(assertion: any): void;
53
54
  canSkipAssertion(value: any, assertion: any, options: any): any;
54
- transform(fn: any): /*elided*/ any;
55
+ transformValue(fn: any): /*elided*/ any;
55
56
  getSortIndex(type: any): number;
56
57
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
57
58
  };
58
59
  export const OBJECT_ID_SCHEMA: {
59
- required(): /*elided*/ any;
60
60
  length(length: number): /*elided*/ any;
61
61
  min(length: number): /*elided*/ any;
62
62
  max(length: number): /*elided*/ any;
@@ -116,16 +116,18 @@ export const OBJECT_ID_SCHEMA: {
116
116
  calendar(): /*elided*/ any;
117
117
  time(): /*elided*/ any;
118
118
  format(name: any, fn: any): /*elided*/ any;
119
+ toJsonSchema(options: any): any;
119
120
  toString(): any;
120
121
  assertions: any[];
121
122
  meta: {};
123
+ required(allow?: boolean): /*elided*/ any;
122
124
  default(arg: any): /*elided*/ any;
123
125
  custom(fn: Function): /*elided*/ any;
124
126
  missing(fn: Function): /*elided*/ any;
125
127
  strip(strip: any): /*elided*/ any;
126
128
  allow(...set: any[]): /*elided*/ any;
127
129
  reject(...set: any[]): /*elided*/ any;
128
- nullable(): /*elided*/ any;
130
+ nullable(allow?: boolean): /*elided*/ any;
129
131
  message(message: any): /*elided*/ any;
130
132
  tag(tags: any): /*elided*/ any;
131
133
  description(description: any): /*elided*/ any;
@@ -133,13 +135,12 @@ export const OBJECT_ID_SCHEMA: {
133
135
  validate(value: any, options?: {}): Promise<any>;
134
136
  clone(meta: any): /*elided*/ any;
135
137
  append(schema: any): import("@bedrockio/yada/types/Schema").default;
136
- toJsonSchema(extra?: any): any;
137
- toOpenApi(...extra: any[]): any;
138
+ toOpenApi(options: any): any;
138
139
  toJSON(): any;
139
- getAnyType(): {
140
- type: string[];
140
+ getType(): {
141
+ type: any;
141
142
  };
142
- getFormat(): {
143
+ getFormat(options: any): {
143
144
  format: any;
144
145
  };
145
146
  getDefault(): {
@@ -147,19 +148,16 @@ export const OBJECT_ID_SCHEMA: {
147
148
  } | {
148
149
  default: any;
149
150
  };
150
- getNullable(): {
151
- nullable: boolean;
152
- };
153
- getEnum(): any;
154
- requireAllWithin(): /*elided*/ any;
155
- expandExtra(extra?: {}): {};
151
+ getEnum(options: any): any;
152
+ getTags(options?: {}): any;
153
+ transform(fn: Function, root: any): /*elided*/ any;
156
154
  inspect(): string;
157
155
  get(): void;
158
156
  assertEnum(set: any, allow: any): /*elided*/ any;
159
157
  assert(type: any, fn: any): /*elided*/ any;
160
158
  pushAssertion(assertion: any): void;
161
159
  canSkipAssertion(value: any, assertion: any, options: any): any;
162
- transform(fn: any): /*elided*/ any;
160
+ transformValue(fn: any): /*elided*/ any;
163
161
  getSortIndex(type: any): number;
164
162
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
165
163
  };
@@ -171,7 +169,7 @@ export const NUMBER_RANGE_SCHEMA: {
171
169
  omit(...names?: string[]): /*elided*/ any;
172
170
  require(...fields: string[]): /*elided*/ any;
173
171
  requireAll(): /*elided*/ any;
174
- requireAllWithin(): /*elided*/ any;
172
+ transform(fn: Function, root?: boolean): /*elided*/ any;
175
173
  export(): any;
176
174
  append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
177
175
  options(options?: {
@@ -180,30 +178,30 @@ export const NUMBER_RANGE_SCHEMA: {
180
178
  allowFlatKeys?: boolean;
181
179
  expandFlatKeys?: boolean;
182
180
  }): /*elided*/ any;
181
+ toJsonSchema(options: any): any;
183
182
  format(name: any, fn: any): /*elided*/ any;
184
183
  toString(): any;
185
184
  assertions: any[];
186
185
  meta: {};
187
- required(): /*elided*/ any;
186
+ required(allow?: boolean): /*elided*/ any;
188
187
  default(arg: any): /*elided*/ any;
189
188
  custom(fn: Function): /*elided*/ any;
190
189
  missing(fn: Function): /*elided*/ any;
191
190
  strip(strip: any): /*elided*/ any;
192
191
  allow(...set: any[]): /*elided*/ any;
193
192
  reject(...set: any[]): /*elided*/ any;
194
- nullable(): /*elided*/ any;
193
+ nullable(allow?: boolean): /*elided*/ any;
195
194
  message(message: any): /*elided*/ any;
196
195
  tag(tags: any): /*elided*/ any;
197
196
  description(description: any): /*elided*/ any;
198
197
  validate(value: any, options?: {}): Promise<any>;
199
198
  clone(meta: any): /*elided*/ any;
200
- toJsonSchema(extra?: any): any;
201
- toOpenApi(...extra: any[]): any;
199
+ toOpenApi(options: any): any;
202
200
  toJSON(): any;
203
- getAnyType(): {
204
- type: string[];
201
+ getType(): {
202
+ type: any;
205
203
  };
206
- getFormat(): {
204
+ getFormat(options: any): {
207
205
  format: any;
208
206
  };
209
207
  getDefault(): {
@@ -211,17 +209,14 @@ export const NUMBER_RANGE_SCHEMA: {
211
209
  } | {
212
210
  default: any;
213
211
  };
214
- getNullable(): {
215
- nullable: boolean;
216
- };
217
- getEnum(): any;
218
- expandExtra(extra?: {}): {};
212
+ getEnum(options: any): any;
213
+ getTags(options?: {}): any;
219
214
  inspect(): string;
220
215
  assertEnum(set: any, allow: any): /*elided*/ any;
221
216
  assert(type: any, fn: any): /*elided*/ any;
222
217
  pushAssertion(assertion: any): void;
223
218
  canSkipAssertion(value: any, assertion: any, options: any): any;
224
- transform(fn: any): /*elided*/ any;
219
+ transformValue(fn: any): /*elided*/ any;
225
220
  getSortIndex(type: any): number;
226
221
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
227
222
  };
@@ -233,7 +228,7 @@ export const STRING_RANGE_SCHEMA: {
233
228
  omit(...names?: string[]): /*elided*/ any;
234
229
  require(...fields: string[]): /*elided*/ any;
235
230
  requireAll(): /*elided*/ any;
236
- requireAllWithin(): /*elided*/ any;
231
+ transform(fn: Function, root?: boolean): /*elided*/ any;
237
232
  export(): any;
238
233
  append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
239
234
  options(options?: {
@@ -242,30 +237,30 @@ export const STRING_RANGE_SCHEMA: {
242
237
  allowFlatKeys?: boolean;
243
238
  expandFlatKeys?: boolean;
244
239
  }): /*elided*/ any;
240
+ toJsonSchema(options: any): any;
245
241
  format(name: any, fn: any): /*elided*/ any;
246
242
  toString(): any;
247
243
  assertions: any[];
248
244
  meta: {};
249
- required(): /*elided*/ any;
245
+ required(allow?: boolean): /*elided*/ any;
250
246
  default(arg: any): /*elided*/ any;
251
247
  custom(fn: Function): /*elided*/ any;
252
248
  missing(fn: Function): /*elided*/ any;
253
249
  strip(strip: any): /*elided*/ any;
254
250
  allow(...set: any[]): /*elided*/ any;
255
251
  reject(...set: any[]): /*elided*/ any;
256
- nullable(): /*elided*/ any;
252
+ nullable(allow?: boolean): /*elided*/ any;
257
253
  message(message: any): /*elided*/ any;
258
254
  tag(tags: any): /*elided*/ any;
259
255
  description(description: any): /*elided*/ any;
260
256
  validate(value: any, options?: {}): Promise<any>;
261
257
  clone(meta: any): /*elided*/ any;
262
- toJsonSchema(extra?: any): any;
263
- toOpenApi(...extra: any[]): any;
258
+ toOpenApi(options: any): any;
264
259
  toJSON(): any;
265
- getAnyType(): {
266
- type: string[];
260
+ getType(): {
261
+ type: any;
267
262
  };
268
- getFormat(): {
263
+ getFormat(options: any): {
269
264
  format: any;
270
265
  };
271
266
  getDefault(): {
@@ -273,17 +268,14 @@ export const STRING_RANGE_SCHEMA: {
273
268
  } | {
274
269
  default: any;
275
270
  };
276
- getNullable(): {
277
- nullable: boolean;
278
- };
279
- getEnum(): any;
280
- expandExtra(extra?: {}): {};
271
+ getEnum(options: any): any;
272
+ getTags(options?: {}): any;
281
273
  inspect(): string;
282
274
  assertEnum(set: any, allow: any): /*elided*/ any;
283
275
  assert(type: any, fn: any): /*elided*/ any;
284
276
  pushAssertion(assertion: any): void;
285
277
  canSkipAssertion(value: any, assertion: any, options: any): any;
286
- transform(fn: any): /*elided*/ any;
278
+ transformValue(fn: any): /*elided*/ any;
287
279
  getSortIndex(type: any): number;
288
280
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
289
281
  };
@@ -295,7 +287,7 @@ export const DATE_RANGE_SCHEMA: {
295
287
  omit(...names?: string[]): /*elided*/ any;
296
288
  require(...fields: string[]): /*elided*/ any;
297
289
  requireAll(): /*elided*/ any;
298
- requireAllWithin(): /*elided*/ any;
290
+ transform(fn: Function, root?: boolean): /*elided*/ any;
299
291
  export(): any;
300
292
  append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
301
293
  options(options?: {
@@ -304,30 +296,30 @@ export const DATE_RANGE_SCHEMA: {
304
296
  allowFlatKeys?: boolean;
305
297
  expandFlatKeys?: boolean;
306
298
  }): /*elided*/ any;
299
+ toJsonSchema(options: any): any;
307
300
  format(name: any, fn: any): /*elided*/ any;
308
301
  toString(): any;
309
302
  assertions: any[];
310
303
  meta: {};
311
- required(): /*elided*/ any;
304
+ required(allow?: boolean): /*elided*/ any;
312
305
  default(arg: any): /*elided*/ any;
313
306
  custom(fn: Function): /*elided*/ any;
314
307
  missing(fn: Function): /*elided*/ any;
315
308
  strip(strip: any): /*elided*/ any;
316
309
  allow(...set: any[]): /*elided*/ any;
317
310
  reject(...set: any[]): /*elided*/ any;
318
- nullable(): /*elided*/ any;
311
+ nullable(allow?: boolean): /*elided*/ any;
319
312
  message(message: any): /*elided*/ any;
320
313
  tag(tags: any): /*elided*/ any;
321
314
  description(description: any): /*elided*/ any;
322
315
  validate(value: any, options?: {}): Promise<any>;
323
316
  clone(meta: any): /*elided*/ any;
324
- toJsonSchema(extra?: any): any;
325
- toOpenApi(...extra: any[]): any;
317
+ toOpenApi(options: any): any;
326
318
  toJSON(): any;
327
- getAnyType(): {
328
- type: string[];
319
+ getType(): {
320
+ type: any;
329
321
  };
330
- getFormat(): {
322
+ getFormat(options: any): {
331
323
  format: any;
332
324
  };
333
325
  getDefault(): {
@@ -335,17 +327,14 @@ export const DATE_RANGE_SCHEMA: {
335
327
  } | {
336
328
  default: any;
337
329
  };
338
- getNullable(): {
339
- nullable: boolean;
340
- };
341
- getEnum(): any;
342
- expandExtra(extra?: {}): {};
330
+ getEnum(options: any): any;
331
+ getTags(options?: {}): any;
343
332
  inspect(): string;
344
333
  assertEnum(set: any, allow: any): /*elided*/ any;
345
334
  assert(type: any, fn: any): /*elided*/ any;
346
335
  pushAssertion(assertion: any): void;
347
336
  canSkipAssertion(value: any, assertion: any, options: any): any;
348
- transform(fn: any): /*elided*/ any;
337
+ transformValue(fn: any): /*elided*/ any;
349
338
  getSortIndex(type: any): number;
350
339
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
351
340
  };
@@ -358,7 +347,7 @@ export const INCLUDE_FIELD_SCHEMA: {
358
347
  omit(...names?: string[]): /*elided*/ any;
359
348
  require(...fields: string[]): /*elided*/ any;
360
349
  requireAll(): /*elided*/ any;
361
- requireAllWithin(): /*elided*/ any;
350
+ transform(fn: Function, root?: boolean): /*elided*/ any;
362
351
  export(): any;
363
352
  append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
364
353
  options(options?: {
@@ -367,30 +356,30 @@ export const INCLUDE_FIELD_SCHEMA: {
367
356
  allowFlatKeys?: boolean;
368
357
  expandFlatKeys?: boolean;
369
358
  }): /*elided*/ any;
359
+ toJsonSchema(options: any): any;
370
360
  format(name: any, fn: any): /*elided*/ any;
371
361
  toString(): any;
372
362
  assertions: any[];
373
363
  meta: {};
374
- required(): /*elided*/ any;
364
+ required(allow?: boolean): /*elided*/ any;
375
365
  default(arg: any): /*elided*/ any;
376
366
  custom(fn: Function): /*elided*/ any;
377
367
  missing(fn: Function): /*elided*/ any;
378
368
  strip(strip: any): /*elided*/ any;
379
369
  allow(...set: any[]): /*elided*/ any;
380
370
  reject(...set: any[]): /*elided*/ any;
381
- nullable(): /*elided*/ any;
371
+ nullable(allow?: boolean): /*elided*/ any;
382
372
  message(message: any): /*elided*/ any;
383
373
  tag(tags: any): /*elided*/ any;
384
374
  description(description: any): /*elided*/ any;
385
375
  validate(value: any, options?: {}): Promise<any>;
386
376
  clone(meta: any): /*elided*/ any;
387
- toJsonSchema(extra?: any): any;
388
- toOpenApi(...extra: any[]): any;
377
+ toOpenApi(options: any): any;
389
378
  toJSON(): any;
390
- getAnyType(): {
391
- type: string[];
379
+ getType(): {
380
+ type: any;
392
381
  };
393
- getFormat(): {
382
+ getFormat(options: any): {
394
383
  format: any;
395
384
  };
396
385
  getDefault(): {
@@ -398,17 +387,14 @@ export const INCLUDE_FIELD_SCHEMA: {
398
387
  } | {
399
388
  default: any;
400
389
  };
401
- getNullable(): {
402
- nullable: boolean;
403
- };
404
- getEnum(): any;
405
- expandExtra(extra?: {}): {};
390
+ getEnum(options: any): any;
391
+ getTags(options?: {}): any;
406
392
  inspect(): string;
407
393
  assertEnum(set: any, allow: any): /*elided*/ any;
408
394
  assert(type: any, fn: any): /*elided*/ any;
409
395
  pushAssertion(assertion: any): void;
410
396
  canSkipAssertion(value: any, assertion: any, options: any): any;
411
- transform(fn: any): /*elided*/ any;
397
+ transformValue(fn: any): /*elided*/ any;
412
398
  getSortIndex(type: any): number;
413
399
  runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
414
400
  };
package/types/validation-schemas.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA0F4E,CAAC;;;;;;;;;;;;;;;;;;;EA1FnB;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAW0D,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ9N,CAAC;;;;;;;;;;;;;;;;;;;EAhFxE;AAEL;;;;;;;;;;;;kBA0Fmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApExE;AAEL;;;;;;;;;;;;kBA8Emb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAxDxE;AAEL;;;;;;;;;;;;kBAkEmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApBxE;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAW1E"}
1
+ {"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2FwE,CAAC;aACjE,CAAC;uBAGc,CAAC;;;;;;;;;;;eAO2H,CAAC;;;;;;;;;;;;;;;;EAtG1F;AAE1D;;;;;;;;;;;;;;;eAwBwB,CAAC;;;;;;;;;;;;iBAoBjB,CAAC;kBAEC,CAAC;kBAEH,CAAH;oBAA8B,CAAC;oBAEhC,CAAD;;;wBA4BW,CAAC;8BAEK,CAAA;oBAEd,CAAF;oBAEiB,CAAC;oCACjB,CAAC;uBAEF,CAAD;8BACkB,CAAC;uBAAkC,CAAC;iBAA4B,CAAC;;;mBAYjC,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA1F,CAAC;;;;;;;;;;;;;;;;EA5F/I;AAEL;;;;;;;;;;;;kBA0FghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EAhF/I;AAEL;;;;;;;;;;;;kBA8EghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EApE/I;AAEL;;;;;;;;;;;;kBAkEghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EAhC/I;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EADjJ"}
package/types/validation.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA6DA,kDAEC;AAED,oEA4FC;AAsBD,wEAiBC;AAkUD;;;EAEC;AAED;;;EAOC"}
1
+ {"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA6DA,kDAEC;AAED,oEA4FC;AAsBD,wEAiBC;AAmUD;;;EAEC;AAED;;;EAOC"}