478 lines
19 KiB
TypeScript
478 lines
19 KiB
TypeScript
declare module 'mongoose' {
|
|
|
|
/** The Mongoose Date [SchemaType](/docs/schematypes.html). */
|
|
type Date = Schema.Types.Date;
|
|
|
|
/**
|
|
* The Mongoose Decimal128 [SchemaType](/docs/schematypes.html). Used for
|
|
* declaring paths in your schema that should be
|
|
* [128-bit decimal floating points](http://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-decimal.html).
|
|
* Do not use this to create a new Decimal128 instance, use `mongoose.Types.Decimal128`
|
|
* instead.
|
|
*/
|
|
type Decimal128 = Schema.Types.Decimal128;
|
|
|
|
/**
|
|
* The Mongoose Mixed [SchemaType](/docs/schematypes.html). Used for
|
|
* declaring paths in your schema that Mongoose's change tracking, casting,
|
|
* and validation should ignore.
|
|
*/
|
|
type Mixed = Schema.Types.Mixed;
|
|
|
|
/**
|
|
* The Mongoose Number [SchemaType](/docs/schematypes.html). Used for
|
|
* declaring paths in your schema that Mongoose should cast to numbers.
|
|
*/
|
|
type Number = Schema.Types.Number;
|
|
|
|
/**
|
|
* The Mongoose ObjectId [SchemaType](/docs/schematypes.html). Used for
|
|
* declaring paths in your schema that should be
|
|
* [MongoDB ObjectIds](https://www.mongodb.com/docs/manual/reference/method/ObjectId/).
|
|
* Do not use this to create a new ObjectId instance, use `mongoose.Types.ObjectId`
|
|
* instead.
|
|
*/
|
|
type ObjectId = Schema.Types.ObjectId;
|
|
|
|
/** The various Mongoose SchemaTypes. */
|
|
const SchemaTypes: typeof Schema.Types;
|
|
|
|
type DefaultType<T> = T extends Schema.Types.Mixed ? any : Partial<ExtractMongooseArray<T>>;
|
|
|
|
class SchemaTypeOptions<T> {
|
|
type?:
|
|
T extends string ? StringSchemaDefinition :
|
|
T extends number ? NumberSchemaDefinition :
|
|
T extends boolean ? BooleanSchemaDefinition :
|
|
T extends NativeDate ? DateSchemaDefinition :
|
|
T extends Map<any, any> ? SchemaDefinition<typeof Map> :
|
|
T extends Buffer ? SchemaDefinition<typeof Buffer> :
|
|
T extends Types.ObjectId ? ObjectIdSchemaDefinition :
|
|
T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId>> :
|
|
T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>>>) :
|
|
T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string>> :
|
|
T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number>> :
|
|
T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean>> :
|
|
T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>>> :
|
|
T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T> | Function | AnyArray<Function>;
|
|
|
|
/** Defines a virtual with the given name that gets/sets this path. */
|
|
alias?: string | string[];
|
|
|
|
/** Function or object describing how to validate this schematype. See [validation docs](https://mongoosejs.com/docs/validation.html). */
|
|
validate?: SchemaValidator<T> | AnyArray<SchemaValidator<T>>;
|
|
|
|
/** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
|
|
cast?: string;
|
|
|
|
/**
|
|
* If true, attach a required validator to this path, which ensures this path
|
|
* path cannot be set to a nullish value. If a function, Mongoose calls the
|
|
* function and only checks for nullish values if the function returns a truthy value.
|
|
*/
|
|
required?: boolean | (() => boolean) | [boolean, string] | [() => boolean, string];
|
|
|
|
/**
|
|
* The default value for this path. If a function, Mongoose executes the function
|
|
* and uses the return value as the default.
|
|
*/
|
|
default?: DefaultType<T> | ((this: any, doc: any) => DefaultType<T>) | null;
|
|
|
|
/**
|
|
* The model that `populate()` should use if populating this path.
|
|
*/
|
|
ref?: string | Model<any> | ((this: any, doc: any) => string | Model<any>);
|
|
|
|
/**
|
|
* The path in the document that `populate()` should use to find the model
|
|
* to use.
|
|
*/
|
|
|
|
refPath?: string | ((this: any, doc: any) => string);
|
|
|
|
/**
|
|
* Whether to include or exclude this path by default when loading documents
|
|
* using `find()`, `findOne()`, etc.
|
|
*/
|
|
select?: boolean | number;
|
|
|
|
/**
|
|
* If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
|
|
* build an index on this path when the model is compiled.
|
|
*/
|
|
index?: boolean | IndexDirection | IndexOptions;
|
|
|
|
/**
|
|
* If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
|
|
* will build a unique index on this path when the
|
|
* model is compiled. [The `unique` option is **not** a validator](/docs/validation.html#the-unique-option-is-not-a-validator).
|
|
*/
|
|
unique?: boolean | number;
|
|
|
|
/**
|
|
* If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
|
|
* disallow changes to this path once the document is saved to the database for the first time. Read more
|
|
* about [immutability in Mongoose here](http://thecodebarbarian.com/whats-new-in-mongoose-5-6-immutable-properties.html).
|
|
*/
|
|
immutable?: boolean | ((this: any, doc: any) => boolean);
|
|
|
|
/**
|
|
* If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
|
|
* build a sparse index on this path.
|
|
*/
|
|
sparse?: boolean | number;
|
|
|
|
/**
|
|
* If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
|
|
* will build a text index on this path.
|
|
*/
|
|
text?: boolean | number | any;
|
|
|
|
/**
|
|
* Define a transform function for this individual schema type.
|
|
* Only called when calling `toJSON()` or `toObject()`.
|
|
*/
|
|
transform?: (this: any, val: T) => any;
|
|
|
|
/** defines a custom getter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
|
|
get?: (value: any, doc?: this) => T | undefined;
|
|
|
|
/** defines a custom setter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
|
|
set?: (value: any, priorVal?: T, doc?: this) => any;
|
|
|
|
/** array of allowed values for this path. Allowed for strings, numbers, and arrays of strings */
|
|
enum?: Array<string | number | null> | ReadonlyArray<string | number | null> | { values: Array<string | number | null> | ReadonlyArray<string | number | null>, message?: string } | { [path: string]: string | number | null };
|
|
|
|
/** The default [subtype](http://bsonspec.org/spec.html) associated with this buffer when it is stored in MongoDB. Only allowed for buffer paths */
|
|
subtype?: number;
|
|
|
|
/** The minimum value allowed for this path. Only allowed for numbers and dates. */
|
|
min?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string];
|
|
|
|
/** The maximum value allowed for this path. Only allowed for numbers and dates. */
|
|
max?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string];
|
|
|
|
/** Defines a TTL index on this path. Only allowed for dates. */
|
|
expires?: string | number;
|
|
|
|
/** If `true`, Mongoose will skip gathering indexes on subpaths. Only allowed for subdocuments and subdocument arrays. */
|
|
excludeIndexes?: boolean;
|
|
|
|
/** If set, overrides the child schema's `_id` option. Only allowed for subdocuments and subdocument arrays. */
|
|
_id?: boolean;
|
|
|
|
/** If set, specifies the type of this map's values. Mongoose will cast this map's values to the given type. */
|
|
of?: Function | SchemaDefinitionProperty<any>;
|
|
|
|
/** If true, uses Mongoose's default `_id` settings. Only allowed for ObjectIds */
|
|
auto?: boolean;
|
|
|
|
/** Attaches a validator that succeeds if the data string matches the given regular expression, and fails otherwise. */
|
|
match?: RegExp | [RegExp, string] | readonly [RegExp, string];
|
|
|
|
/** If truthy, Mongoose will add a custom setter that lowercases this string using JavaScript's built-in `String#toLowerCase()`. */
|
|
lowercase?: boolean;
|
|
|
|
/** If truthy, Mongoose will add a custom setter that removes leading and trailing whitespace using JavaScript's built-in `String#trim()`. */
|
|
trim?: boolean;
|
|
|
|
/** If truthy, Mongoose will add a custom setter that uppercases this string using JavaScript's built-in `String#toUpperCase()`. */
|
|
uppercase?: boolean;
|
|
|
|
/** If set, Mongoose will add a custom validator that ensures the given string's `length` is at least the given number. */
|
|
minlength?: number | [number, string] | readonly [number, string];
|
|
|
|
/** If set, Mongoose will add a custom validator that ensures the given string's `length` is at most the given number. */
|
|
maxlength?: number | [number, string] | readonly [number, string];
|
|
|
|
[other: string]: any;
|
|
}
|
|
|
|
interface Validator {
|
|
message?: string; type?: string; validator?: Function
|
|
}
|
|
|
|
class SchemaType<T = any, DocType = any> {
|
|
/** SchemaType constructor */
|
|
constructor(path: string, options?: AnyObject, instance?: string);
|
|
|
|
/** Get/set the function used to cast arbitrary values to this type. */
|
|
static cast(caster?: Function | boolean): Function;
|
|
|
|
static checkRequired(checkRequired?: (v: any) => boolean): (v: any) => boolean;
|
|
|
|
/** Sets a default option for this schema type. */
|
|
static set(option: string, value: any): void;
|
|
|
|
/** Attaches a getter for all instances of this schema type. */
|
|
static get(getter: (value: any) => any): void;
|
|
|
|
/** The class that Mongoose uses internally to instantiate this SchemaType's `options` property. */
|
|
OptionsConstructor: SchemaTypeOptions<T>;
|
|
|
|
/** Cast `val` to this schema type. Each class that inherits from schema type should implement this function. */
|
|
cast(val: any, doc: Document<any>, init: boolean, prev?: any, options?: any): any;
|
|
|
|
/** Sets a default value for this SchemaType. */
|
|
default(val: any): any;
|
|
|
|
/** Adds a getter to this schematype. */
|
|
get(fn: Function): this;
|
|
|
|
/**
|
|
* Defines this path as immutable. Mongoose prevents you from changing
|
|
* immutable paths unless the parent document has [`isNew: true`](/docs/api/document.html#document_Document-isNew).
|
|
*/
|
|
immutable(bool: boolean): this;
|
|
|
|
/** Declares the index options for this schematype. */
|
|
index(options: any): this;
|
|
|
|
/** String representation of what type this is, like 'ObjectID' or 'Number' */
|
|
instance: string;
|
|
|
|
/** True if this SchemaType has a required validator. False otherwise. */
|
|
isRequired?: boolean;
|
|
|
|
/** The options this SchemaType was instantiated with */
|
|
options: AnyObject;
|
|
|
|
/** The path to this SchemaType in a Schema. */
|
|
path: string;
|
|
|
|
/**
|
|
* Set the model that this path refers to. This is the option that [populate](https://mongoosejs.com/docs/populate.html)
|
|
* looks at to determine the foreign collection it should query.
|
|
*/
|
|
ref(ref: string | boolean | Model<any>): this;
|
|
|
|
/**
|
|
* Adds a required validator to this SchemaType. The validator gets added
|
|
* to the front of this SchemaType's validators array using unshift().
|
|
*/
|
|
required(required: boolean, message?: string): this;
|
|
|
|
/** The schema this SchemaType instance is part of */
|
|
schema: Schema<any>;
|
|
|
|
/** Sets default select() behavior for this path. */
|
|
select(val: boolean): this;
|
|
|
|
/** Adds a setter to this schematype. */
|
|
set(fn: Function): this;
|
|
|
|
/** Declares a sparse index. */
|
|
sparse(bool: boolean): this;
|
|
|
|
/** Declares a full text index. */
|
|
text(bool: boolean): this;
|
|
|
|
/** Defines a custom function for transforming this path when converting a document to JSON. */
|
|
transform(fn: (value: any) => any): this;
|
|
|
|
/** Declares an unique index. */
|
|
unique(bool: boolean): this;
|
|
|
|
/** The validators that Mongoose should run to validate properties at this SchemaType's path. */
|
|
validators: Validator[];
|
|
|
|
/** Adds validator(s) for this document path. */
|
|
validate(obj: RegExp | ((this: DocType, value: any, validatorProperties?: Validator) => any), errorMsg?: string, type?: string): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions?: Record<string, any>;
|
|
}
|
|
|
|
namespace Schema {
|
|
namespace Types {
|
|
class Array extends SchemaType implements AcceptsDiscriminator {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Array';
|
|
|
|
static options: { castNonArrays: boolean; };
|
|
|
|
discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
|
|
discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
|
|
|
|
/** The schematype embedded in this array */
|
|
caster?: SchemaType;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
|
|
/**
|
|
* Adds an enum validator if this is an array of strings or numbers. Equivalent to
|
|
* `SchemaString.prototype.enum()` or `SchemaNumber.prototype.enum()`
|
|
*/
|
|
enum(vals: string[] | number[]): this;
|
|
}
|
|
|
|
class Boolean extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Boolean';
|
|
|
|
/** Configure which values get casted to `true`. */
|
|
static convertToTrue: Set<any>;
|
|
|
|
/** Configure which values get casted to `false`. */
|
|
static convertToFalse: Set<any>;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Buffer extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Buffer';
|
|
|
|
/**
|
|
* Sets the default [subtype](https://studio3t.com/whats-new/best-practices-uuid-mongodb/)
|
|
* for this buffer. You can find a [list of allowed subtypes here](http://api.mongodb.com/python/current/api/bson/binary.html).
|
|
*/
|
|
subtype(subtype: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 128): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Date extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Date';
|
|
|
|
/** Declares a TTL index (rounded to the nearest second) for _Date_ types only. */
|
|
expires(when: number | string): this;
|
|
|
|
/** Sets a maximum date validator. */
|
|
max(value: NativeDate, message: string): this;
|
|
|
|
/** Sets a minimum date validator. */
|
|
min(value: NativeDate, message: string): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Decimal128 extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Decimal128';
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class DocumentArray extends SchemaType implements AcceptsDiscriminator {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'DocumentArray';
|
|
|
|
static options: { castNonArrays: boolean; };
|
|
|
|
discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
|
|
discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
|
|
|
|
/** The schema used for documents in this array */
|
|
schema: Schema;
|
|
|
|
/** The constructor used for subdocuments in this array */
|
|
caster?: typeof Types.Subdocument;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Map extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Map';
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Mixed extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Mixed';
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Number extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'Number';
|
|
|
|
/** Sets a enum validator */
|
|
enum(vals: number[]): this;
|
|
|
|
/** Sets a maximum number validator. */
|
|
max(value: number, message: string): this;
|
|
|
|
/** Sets a minimum number validator. */
|
|
min(value: number, message: string): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class ObjectId extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'ObjectId';
|
|
|
|
/** Adds an auto-generated ObjectId default if turnOn is true. */
|
|
auto(turnOn: boolean): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class Subdocument extends SchemaType implements AcceptsDiscriminator {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: string;
|
|
|
|
/** The document's schema */
|
|
schema: Schema;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
|
|
discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
|
|
discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
|
|
}
|
|
|
|
class String extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'String';
|
|
|
|
/** Adds an enum validator */
|
|
enum(vals: string[] | any): this;
|
|
|
|
/** Adds a lowercase [setter](http://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-set). */
|
|
lowercase(shouldApply?: boolean): this;
|
|
|
|
/** Sets a regexp validator. */
|
|
match(value: RegExp, message: string): this;
|
|
|
|
/** Sets a maximum length validator. */
|
|
maxlength(value: number, message: string): this;
|
|
|
|
/** Sets a minimum length validator. */
|
|
minlength(value: number, message: string): this;
|
|
|
|
/** Adds a trim [setter](http://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-set). */
|
|
trim(shouldTrim?: boolean): this;
|
|
|
|
/** Adds an uppercase [setter](http://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-set). */
|
|
uppercase(shouldApply?: boolean): this;
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
|
|
class UUID extends SchemaType {
|
|
/** This schema type's name, to defend against minifiers that mangle function names. */
|
|
static schemaName: 'UUID';
|
|
|
|
/** Default options for this SchemaType */
|
|
defaultOptions: Record<string, any>;
|
|
}
|
|
}
|
|
}
|
|
}
|