Class SchemaTypeOptions<T, EnforcedDocType>

Type Parameters

  • T

  • EnforcedDocType = any

Hierarchy

Indexable

[other: string]: any

Constructors

constructor

Properties

_id? alias? auto? cast? default? enum? excludeIndexes? expires? get? immutable? index? lowercase? match? max? maxlength? min? minlength? of? ref? refPath? required? select? set? sparse? subtype? text? transform? trim? type? unique? uppercase? validate?

Constructors

constructor

Properties

Optional _id

_id?: boolean

If set, overrides the child schema's _id option. Only allowed for subdocuments and subdocument arrays.

Optional alias

alias?: string | string[]

Defines a virtual with the given name that gets/sets this path.

Optional auto

auto?: boolean

If true, uses Mongoose's default _id settings. Only allowed for ObjectIds

Optional cast

cast?: string | boolean | ((value) => T) | [((value) => T), string] | [((value) => T), ((value, path, model, kind) => string)]

Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message.

Type declaration

    • (value): T

    • Parameters

      • value: any

      Returns T

Optional default

default?: DefaultType<T> | ((this, doc) => DefaultType<T>)

The default value for this path. If a function, Mongoose executes the function and uses the return value as the default.

Type declaration

Optional enum

enum?: (string | number)[] | readonly (string | number)[] | {
    message?: string;
    values: (string | number)[] | readonly (string | number)[];
} | {
    [path: string]: string | number | null;
}

array of allowed values for this path. Allowed for strings, numbers, and arrays of strings

Type declaration

  • Optional message?: string
  • values: (string | number)[] | readonly (string | number)[]

Type declaration

  • [path: string]: string | number | null

Optional excludeIndexes

excludeIndexes?: boolean

If true, Mongoose will skip gathering indexes on subpaths. Only allowed for subdocuments and subdocument arrays.

Optional expires

expires?: string | number

Defines a TTL index on this path. Only allowed for dates.

Optional get

get?: ((value, doc?) => T)

Type declaration

Optional immutable

immutable?: boolean | ((this, doc) => boolean)

If 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.

Type declaration

    • (this, doc): boolean

    • Parameters

      • this: any
      • doc: any

      Returns boolean

Optional index

index?: boolean | mongoose.IndexDirection | mongoose.IndexOptions

If truthy, Mongoose will build an index on this path when the model is compiled.

Optional lowercase

lowercase?: boolean

If truthy, Mongoose will add a custom setter that lowercases this string using JavaScript's built-in String#toLowerCase().

Optional match

match?: RegExp | [RegExp, string] | readonly [RegExp, string]

Attaches a validator that succeeds if the data string matches the given regular expression, and fails otherwise.

Optional max

max?: 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.

Optional maxlength

maxlength?: 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.

Optional min

min?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string]

The minimum value allowed for this path. Only allowed for numbers and dates.

Optional minlength

minlength?: number | [number, string] | readonly [number, string]

If set, Mongoose will add a custom validator that ensures the given string's length is at least the given number.

Optional of

of?: SchemaDefinitionProperty<any, any>

If set, specifies the type of this map's values. Mongoose will cast this map's values to the given type.

Optional ref

ref?: string | mongoose.Model<any, {}, {}, {}, any, any> | ((this, doc) => string | mongoose.Model<any, {}, {}, {}, any, any>)

The model that populate() should use if populating this path.

Type declaration

    • (this, doc): string | mongoose.Model<any, {}, {}, {}, any, any>

    • Parameters

      • this: any
      • doc: any

      Returns string | mongoose.Model<any, {}, {}, {}, any, any>

Optional refPath

refPath?: string | ((this, doc) => string)

The path in the document that populate() should use to find the model to use.

Type declaration

    • (this, doc): string

    • Parameters

      • this: any
      • doc: any

      Returns string

Optional required

required?: boolean | ((this) => boolean) | [boolean, string] | [((this) => boolean), 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.

Type declaration

    • (this): boolean

    • Parameters

      • this: EnforcedDocType

      Returns boolean

Optional select

select?: number | boolean

Whether to include or exclude this path by default when loading documents using find(), findOne(), etc.

Optional set

set?: ((value, priorVal?, doc?) => any)

Type declaration

    • (value, priorVal?, doc?): any

    • defines a custom setter for this property using Object.defineProperty().

      Parameters

      • value: any
      • Optional priorVal: T
        Optional
      • Optional doc: SchemaTypeOptions<T, EnforcedDocType>
        Optional

      Returns any

Optional sparse

sparse?: number | boolean

If truthy, Mongoose will build a sparse index on this path.

Optional subtype

subtype?: number

The default subtype associated with this buffer when it is stored in MongoDB. Only allowed for buffer paths

Optional text

text?: any

If truthy, Mongoose will build a text index on this path.

Optional transform

transform?: ((this, val) => any)

Type declaration

    • (this, val): any

    • Define a transform function for this individual schema type. Only called when calling toJSON() or toObject().

      Parameters

      • this: any
      • val: T

      Returns any

Optional trim

trim?: boolean

If truthy, Mongoose will add a custom setter that removes leading and trailing whitespace using JavaScript's built-in String#trim().

Optional type

type?: T extends string
    ? StringSchemaDefinition
    : T extends number
        ? NumberSchemaDefinition
        : T extends boolean
            ? BooleanSchemaDefinition
            : T extends NativeDate
                ? DateSchemaDefinition
                : T extends Map<any, any>
                    ? {
                        [species]?: SchemaDefinitionProperty<MapConstructor, any>;
                        prototype?: SchemaDefinitionProperty<Map<any, any>, any>;
                    }
                    : T extends Buffer
                        ? {
                            poolSize?: SchemaDefinitionProperty<number, any>;
                            alloc?: any;
                            allocUnsafe?: any;
                            allocUnsafeSlow?: any;
                            byteLength?: any;
                            compare?: any;
                            concat?: any;
                            from?: any;
                            isBuffer?: any;
                            isEncoding?: any;
                            of?: any;
                        }
                        : T extends mongoose.Types.ObjectId
                            ? ObjectIdSchemaDefinition
                            : T extends mongoose.Types.ObjectId[]
                                ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<mongoose.Schema.Types.ObjectId, EnforcedDocType>>
                                : T extends object[]
                                    ? AnyArray<Schema<any, any, any, {}, {}, {}, DefaultSchemaOptions, {}, mongoose.Document<unknown, {}, FlatRecord<{}>> & FlatRecord<{}> & Required<{
                                        _id: unknown;
                                    }>>> | AnyArray<SchemaDefinition<Unpacked<T>, any>> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>>
                                    : T extends string[]
                                        ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string, EnforcedDocType>>
                                        : T extends number[]
                                            ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number, EnforcedDocType>>
                                            : T extends boolean[]
                                                ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean, EnforcedDocType>>
                                                : T extends Function[]
                                                    ? AnyArray<string | Function> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>>
                                                    : Function | T | typeof SchemaType | Schema<any, any, any, {}, {}, {}, DefaultSchemaOptions, {}, mongoose.Document<unknown, {}, FlatRecord<{}>> & FlatRecord<{}> & Required<{
                                                        _id: unknown;
                                                    }>> | SchemaDefinition<T, any> | AnyArray<Function>

Optional unique

unique?: number | boolean

If truthy, Mongoose will build a unique index on this path when the model is compiled. The unique option is not a validator.

Optional uppercase

uppercase?: boolean

If truthy, Mongoose will add a custom setter that uppercases this string using JavaScript's built-in String#toUpperCase().

Optional validate

validate?: SchemaValidator<T> | AnyArray<SchemaValidator<T>>

Function or object describing how to validate this schematype. See validation docs.

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc