-
Notifications
You must be signed in to change notification settings - Fork 30.1k
/
index.d.ts
3883 lines (3393 loc) · 151 KB
/
index.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Type definitions for Mongoose 5.10.9
// Project: http://mongoosejs.com/
// Definitions by: horiuchi <https://github.com/horiuchi>
// lukasz-zak <https://github.com/lukasz-zak>
// jendrikw <https://github.com/jendrikw>
// Ethan Resnick <https://github.com/ethanresnick>
// vologa <https://github.com/vologab>
// jussikinnula <https://github.com/jussikinnula>
// ondratra <https://github.com/ondratra>
// alfirin <https://github.com/alfirin>
// Idan Dardikman <https://github.com/idandrd>
// Dominik Heigl <https://github.com/various89>
// Fazendaaa <https://github.com/Fazendaaa>
// Norman Perrin <https://github.com/NormanPerrin>
// stablio <https://github.com/stablio>
// Emmanuel Gautier <https://github.com/emmanuelgautier>
// Frontend Monster <https://github.com/frontendmonster>
// Ming Chen <https://github.com/mingchen>
// Olga Isakova <https://github.com/penumbra1>
// HughKu <https://github.com/HughKu>
// Erik Lopez <https://github.com/niuware>
// Vlad Melnik <https://github.com/vladmel1234>
// Jarom Loveridge <https://github.com/jloveridge>
// Grimmer Kang <https://github.com/grimmer0125>
// Richard Davison <https://github.com/richarddd>
// Brian Chen <https://github.com/ToucheSir>
// Boris Figovsky <https://github.com/borfig>
// Simon Driscoll <https://github.com/dinodeSimon>
// Anton Kenikh <https://github.com/anthony-kenikh>
// Chathu Vishwajith <https://github.com/iamchathu>
// LKHO <https://github.com/lkho>
// Tom Yam <https://github.com/tomyam1>
// Thomas Pischulski <https://github.com/nephix>
// Sam Kim <https://github.com/rlaace423>
// Dongjun Lee <https://github.com/ChazEpps>
// Jan Nemcik <https://github.com/JanNemcik>
// Cl3dson <https://github.com/cl3dson>
// Richard Simko <https://github.com/richardsimko>
// Marek Tuchalski <https://github.com/ith>
// Jeremy Bensimon <https://github.com/jeremyben>
// Andrei Alecu <https://github.com/andreialecu>
// The Half Blood Prince <https://github.com/tHBp>
// Pirasis Leelatanon <https://github.com/1pete>
// Guillem Gelabert Sunyer <https://github.com/guillem-gelabert>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// Minimum TypeScript Version: 3.2
/// <reference types="mongodb" />
/// <reference types="node" />
/*
* Guidelines for maintaining these definitions:
* - If you spot an error here or there, please submit a PR.
* Give some examples/links to documentation if you can.
*
* For patches and minor releases:
* - Browse the changelog at https://github.com/Automattic/mongoose/blob/master/History.md
* and make necessary changes. Afterwards, update the version number at the top so we know
* which version we are on.
*
* For major releases:
* - Refer to the updated docs at https//mongoosejs.com/docs/api.html
* - On the left-hand side of the docs is a list of .js files. Reset and update the TODO list below
* then go through one-by-one, making any updates to params list, return type, etc. For documentation
* changes just copy/paste them into here.
* - Check the files off as you go. Some files below might not have anything in them. That's ok, this
* is just a simple heuristic to keep track of our progress.
*/
/*
For easier searching, add a header to each section like so:
To find a section, CTRL+F and type "section ___.js"
/*
* section filename.js
* http://mongoosejs.com/docs/api.html#filename-js
*/
declare module "mongoose" {
import events = require('events');
import mongodb = require('mongodb');
import stream = require('stream');
import mongoose = require('mongoose');
// We can use TypeScript Omit once minimum required TypeScript Version is above 3.5
type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
type NonFunctionPropertyNames<T> = {
[K in keyof T]: T[K] extends Function ? never : K;
}[keyof T];
type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
type IfEquals<X, Y, A, B> =
(<T>() => T extends X ? 1 : 2) extends
(<T>() => T extends Y ? 1 : 2) ? A : B;
type ReadonlyKeysOf<T> = {
[P in keyof T]: IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, never, P>
}[keyof T];
type OmitReadonly<T> = Omit<T, ReadonlyKeysOf<T>>;
type MongooseBuiltIns = mongodb.ObjectID | mongodb.Decimal128 | Date | number | boolean;
type ImplicitMongooseConversions<T> =
T extends MongooseBuiltIns
? T extends (boolean | mongodb.Decimal128 | Date) ? T | string | number // accept numbers for these
: T | string
: T;
type DeepCreateObjectTransformer<T> =
T extends MongooseBuiltIns
? T
: T extends object
? { [V in keyof NonFunctionProperties<OmitReadonly<T>>]: T[V] extends object | undefined
? ImplicitMongooseConversions<DeepCreateTransformer<NonNullable<T[V]>>>
: ImplicitMongooseConversions<T[V]> }
:
T;
// removes functions from schema from all levels
type DeepCreateTransformer<T> =
T extends Map<infer KM, infer KV>
// handle map values
// Maps are not scrubbed, replace below line with this once minimum TS version is 3.7:
// ? Map<KM, DeepNonFunctionProperties<KV>>
? { [key: string]: DeepCreateTransformer<KV> } | [KM, KV][] | Map<KM, KV>
:
T extends Array<infer U>
? Array<DeepCreateObjectTransformer<U>>
:
DeepCreateObjectTransformer<T>;
// mongoose allows Map<K, V> to be specified either as a Map or a Record<K, V>
type DeepMapAsObject<T> = T extends object | undefined
? {
[K in keyof T]: T[K] extends Map<infer KM, infer KV> | undefined
// if it's a map, transform it into Map | Record
// only string keys allowed
? KM extends string ? Map<KM, DeepMapAsObject<KV>> | Record<KM, DeepMapAsObject<KV>> | [KM, DeepMapAsObject<KV>][] : never
// otherwise if it's an object or undefined (for optional props), recursively go again
: T[K] extends object | undefined
? DeepMapAsObject<T[K]>
: T[K]
}
: T;
/* Helper type to extract a definition type from a Document type */
type DocumentDefinition<T> = Omit<T, Exclude<keyof Document, '_id'>>;
type ScrubCreateDefinition<T> = DeepMapAsObject<DeepCreateTransformer<T>>
type CreateDocumentDefinition<T> = ScrubCreateDefinition<DocumentDefinition<T>>;
/**
* Patched version of FilterQuery to also allow:
* - documents, ObjectId and strings for `_id`
* - strings for properties defined as ObjectId
*
* Uses `[]` tuple syntax around the `Extract` to avoid distributing on unions.
* See: https://devblogs.microsoft.com/typescript/announcing-typescript-2-8-2/#conditional-types
*
* Negates the condition with `never`, because the following condition:
* Extract<T[P], mongodb.ObjectId> extends mongodb.ObjectId
* Would result in `never extends mongodb.ObjectId` for non-ObjectId properties,
* which would result in a passing conditional, because `never` is included in all types.
*/
export type MongooseFilterQuery<T> = {
[P in keyof T]?: P extends '_id'
? [Extract<T[P], mongodb.ObjectId>] extends [never]
? mongodb.Condition<T[P]>
: mongodb.Condition<T[P] | string | { _id: mongodb.ObjectId }>
: [Extract<T[P], mongodb.ObjectId>] extends [never]
? mongodb.Condition<T[P]>
: mongodb.Condition<T[P] | string>;
} &
mongodb.RootQuerySelector<T>;
/* FilterQuery alias type for using as type for filter/conditions parameters */
export type FilterQuery<T> = MongooseFilterQuery<DocumentDefinition<T>>;
/**
* Patched version of UpdateQuery to also allow:
* - setting attributes directly in the root, without a `$set` wrapper
* - setting attributes via dot-notation
*/
export type MongooseUpdateQuery<S> = mongodb.UpdateQuery<S> & mongodb.MatchKeysAndValues<S>;
export type UpdateQuery<D> = MongooseUpdateQuery<DocumentDefinition<D>>;
// check whether a type consists just of {_id: T} and no other properties
type HasJustId<T> = keyof Omit<T, "_id"> extends never ? true : false;
// ensure that if an empty document type is passed, we allow any properties
// for backwards compatibility
export type CreateQuery<D> = HasJustId<CreateDocumentDefinition<D>> extends true
? { _id?: any } & Record<string, any>
: D extends { _id: infer TId }
? mongodb.OptionalId<CreateDocumentDefinition<D> & { _id: TId }>
: CreateDocumentDefinition<D>
/**
* Gets and optionally overwrites the function used to pluralize collection names
* @param fn function to use for pluralization of collection names
* @returns the current function used to pluralize collection names (defaults to the `mongoose-legacy-pluralize` module's function)
*/
export function pluralize(fn?: (str: string) => string): (str: string) => string;
/*
* Some mongoose classes have the same name as the native JS classes
* Keep references to native classes using a "Native" prefix
*/
class NativeBuffer extends global.Buffer { }
class NativeDate extends global.Date { }
class NativeError extends global.Error { }
/*
* section index.js
* http://mongoosejs.com/docs/api.html#index-js
*/
export var DocumentProvider: any;
// recursive constructor
export var Mongoose: new (...args: any[]) => typeof mongoose;
type Mongoose = typeof mongoose;
export var SchemaTypes: typeof Schema.Types;
/** Expose connection states for user-land */
export var STATES: typeof ConnectionStates;
/** The default connection of the mongoose module. */
export var connection: Connection;
/** An array containing all connections associated with this Mongoose instance. */
export var connections: Connection[];
/** Models registred on the default mongoose connection. */
export var models: { [index: string]: Model<any> };
/** The node-mongodb-native driver Mongoose uses. */
export var mongo: typeof mongodb;
/** The Mongoose version */
export var version: string;
/**
* Opens the default mongoose connection.
* Options passed take precedence over options included in connection strings.
* @returns pseudo-promise wrapper around this
*/
export function connect(uris: string, options: ConnectionOptions, callback: (err: mongodb.MongoError) => void): Promise<Mongoose>;
export function connect(uris: string, callback: (err: mongodb.MongoError) => void): Promise<Mongoose>;
export function connect(uris: string, options?: ConnectionOptions): Promise<Mongoose>;
/**
* Creates a Connection instance.
* Each connection instance maps to a single database. This method is helpful
* when mangaging multiple db connections.
* @param uri a mongodb:// URI
* @param options options to pass to the driver
* @returns the created Connection object
*/
export function createConnection(): Connection;
export function createConnection(uri: string,
options?: ConnectionOptions
): Connection & {
then: Promise<Connection>["then"];
catch: Promise<Connection>["catch"];
};
/**
* Disconnects all connections.
* @param fn called after all connection close.
*/
export function disconnect(fn: (error?: any) => void): void;
/** Disconnects all connections. */
export function disconnect(): Promise<void>;
/** Gets mongoose options */
export function get(key: string): any;
/**
* Tests whether Mongoose can cast a value to an ObjectId
* @param value value to be tested if it can be cast to an ObjectId
*/
export function isValidObjectId(value: any): boolean;
/**
* Defines a model or retrieves it.
* Models defined on the mongoose instance are available to all connection
* created by the same mongoose instance.
* @param name model name
* @param collection (optional, induced from model name)
* @param skipInit whether to skip initialization (defaults to false)
*/
export function model<T extends Document>(name: string, schema?: Schema, collection?: string,
skipInit?: boolean): Model<T>;
export function model<T extends Document, U extends Model<T>>(
name: string,
schema?: Schema,
collection?: string,
skipInit?: boolean
): U;
/**
* Removes the model named `name` from the default connection on this instance
* of Mongoose. You can use this function to clean up any models you created
* in your tests to prevent OverwriteModelErrors.
*/
export function deleteModel(name: string | RegExp): Connection;
/**
* Returns an array of model names created on the default connection for this
* instance of Mongoose. Does not include names of models created
* on additional connections that were created with `createConnection()`.
*/
export function modelNames(): string[];
/**
* Declares a global plugin executed on all Schemas.
* Equivalent to calling .plugin(fn) on each Schema you create.
* @param fn plugin callback
* @param opts optional options
*/
export function plugin(fn: Function): typeof mongoose;
export function plugin<T>(fn: Function, opts: T): typeof mongoose;
/** Sets mongoose options */
export function set(key: string, value: any): void;
export function startSession(options?: mongodb.SessionOptions, cb?: (err: any, session: mongodb.ClientSession) => void): Promise<mongodb.ClientSession>;
export type CastError = Error.CastError;
/*
* section connection.js
* http://mongoosejs.com/docs/api.html#connection-js
*
* The Connection class exposed by require('mongoose')
* is actually the driver's NativeConnection class.
* connection.js defines a base class that the native
* versions extend. See:
* http://mongoosejs.com/docs/api.html#drivers-node-mongodb-native-connection-js
*/
abstract class ConnectionBase extends events.EventEmitter {
/**
* For practical reasons, a Connection equals a Db.
* @param base a mongoose instance
* @event connecting Emitted when connection.{open,openSet}() is executed on this connection.
* @event connected Emitted when this connection successfully connects to the db. May be emitted multiple times in reconnected scenarios.
* @event open Emitted after we connected and onOpen is executed on all of this connections models.
* @event disconnecting Emitted when connection.close() was executed.
* @event disconnected Emitted after getting disconnected from the db.
* @event close Emitted after we disconnected and onClose executed on all of this connections models.
* @event reconnected Emitted after we connected and subsequently disconnected, followed by successfully another successfull connection.
* @event error Emitted when an error occurs on this connection.
* @event fullsetup Emitted in a replica-set scenario, when primary and at least one seconaries specified in the connection string are connected.
* @event all Emitted in a replica-set scenario, when all nodes specified in the connection string are connected.
*/
constructor(base: typeof mongoose);
/**
* Opens the connection to MongoDB.
* @param uri mongodb connection string
* @param options Mongoose forces the db option forceServerObjectId false and cannot be overridden.
* Mongoose defaults the server auto_reconnect options to true which can be overridden.
* See the node-mongodb-native driver instance for options that it understands.
* Options passed take precedence over options included in connection strings.
*/
openUri(uri: string, options?: ConnectionOptions): Promise<Connection>;
openUri(uri: string, callback: (err: any, conn?: Connection) => void): Connection;
openUri(
uri: string,
options: ConnectionOptions,
callback?: (err: any, conn?: Connection) => void
): Connection & {
then: Promise<Connection>["then"];
catch: Promise<Connection>["catch"];
};
/** Helper for dropDatabase() */
dropDatabase(callback?: (err: any) => void): Promise<any>;
/** Helper for creating a collection */
createCollection<T = any>(name: string, options?: mongodb.CollectionCreateOptions): Promise<mongodb.Collection<T>>;
createCollection<T = any>(name: string, cb: (err: any, collection: mongodb.Collection<T>) => void): Promise<void>;
createCollection<T = any>(name: string, options: mongodb.CollectionCreateOptions, cb?: (err: any, collection: mongodb.Collection) => void): Promise<mongodb.Collection<T>>;
/** Helper for dropCollection() */
dropCollection(name: string, callback?: (err: any) => void): Promise<void>;
/** Closes the connection */
close(callback?: (err: any) => void): Promise<void>;
/** Closes the connection */
close(force?: boolean, callback?: (err: any) => void): Promise<void>;
/**
* Retrieves a collection, creating it if not cached.
* Not typically needed by applications. Just talk to your collection through your model.
* @param name name of the collection
* @param options optional collection options
*/
collection(name: string, options?: any): Collection;
/**
* Defines or retrieves a model.
* When no collection argument is passed, Mongoose produces a collection name by passing
* the model name to the utils.toCollectionName method. This method pluralizes the name.
* If you don't like this behavior, either pass a collection name or set your schemas
* collection name option.
* @param name the model name
* @param schema a schema. necessary when defining a model
* @param collection name of mongodb collection (optional) if not given it will be induced from model name
* @returns The compiled model
*/
model<T extends Document>(name: string, schema?: Schema, collection?: string): Model<T>;
model<T extends Document, U extends Model<T>>(
name: string,
schema?: Schema,
collection?: string
): U;
/**
* Removes the model named `name` from this connection, if it exists. You can
* use this function to clean up any models you created in your tests to
* prevent OverwriteModelErrors.
*
* @param name if string, the name of the model to remove. If regexp, removes all models whose name matches the regexp.
* @returns this
*/
deleteModel(name: string | RegExp): Connection;
/** Returns an array of model names created on this connection. */
modelNames(): string[];
/** A hash of the global options that are associated with this connection */
config: Pick<ConnectionOptions, 'autoIndex' | 'autoCreate' | 'useCreateIndex' | 'useFindAndModify' | 'bufferCommands'>;
/** The mongodb.Db instance, set when the connection is opened */
db: mongodb.Db;
/** A hash of the collections associated with this connection */
collections: { [index: string]: Collection };
/** A hash of models registered with this connection */
models: { [index: string]: Model<any> };
/**
* Connection ready state
* 0 = disconnected
* 1 = connected
* 2 = connecting
* 3 = disconnecting
* Each state change emits its associated event name.
*/
readyState: number;
/** Connected database name */
name: string
/** Connected host */
host: string
/** Connected port number */
port: number
/** mapping of ready states */
states: typeof ConnectionStates;
}
/**
* Connection optional settings.
*
* see
* https://mongoosejs.com/docs/api.html#mongoose_Mongoose-connect
* and
* http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html
* for all available options.
*
*/
interface ConnectionOptions extends mongodb.MongoClientOptions {
/** mongoose-specific options */
/** See https://mongoosejs.com/docs/guide.html#bufferCommands */
bufferCommands?: boolean;
/** database Name for Mongodb Atlas Connection */
dbName?: string;
/** passed to the connection db instance */
db?: any;
config?: {
/**
* set to false to disable automatic index creation for all
* models associated with this connection.
*/
autoIndex?: boolean;
};
autoIndex?: boolean;
/** Before Mongoose builds indexes, it calls Model.createCollection()
* to create the underlying collection in MongoDB if autoCreate
* is set to true.(default: false) */
autoCreate?: boolean;
/** Configure csfle as especified in MongoDB official guide */
autoEncryption?: {
keyVaultNamespace: string,
kmsProviders: any,
schemaMap: any,
extraOptions?: any
}
/** Specify a journal write concern (default: false). */
journal?: boolean;
/** The current value of the parameter native_parser */
nativeParser?: boolean;
safe?: any;
slaveOk?: boolean;
/** username for authentication */
user?: string;
/** password for authentication */
pass?: string;
/** If true, this connection will use createIndex() instead of ensureIndex() for automatic index builds via Model.init(). */
useCreateIndex?: boolean;
/** See https://mongoosejs.com/docs/connections.html#use-mongo-client **/
useMongoClient?: boolean;
/** Flag for using new URL string parser instead of current (deprecated) one */
useNewUrlParser?: boolean;
/** Set to false to make findOneAndUpdate() and findOneAndRemove() use native findOneAndUpdate() rather than findAndModify(). */
useFindAndModify?: boolean;
/** Flag for using new Server Discovery and Monitoring engine instead of current (deprecated) one */
useUnifiedTopology?: boolean;
/**
* With useUnifiedTopology, the MongoDB driver will try to find a server to send any given operation to,
* and keep retrying for serverSelectionTimeoutMS milliseconds.
* If not set, the MongoDB driver defaults to using 30000 (30 seconds).
*/
serverSelectionTimeoutMS?: number;
/**
* With useUnifiedTopology, the MongoDB driver sends a heartbeat every heartbeatFrequencyMS to check on the status of the connection.
* A heartbeat is subject to serverSelectionTimeoutMS, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default.
* Mongoose only emits a 'disconnected' event after a heartbeat has failed,
* so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits 'disconnected'.
* We recommend you do not set this setting below 1000, too many heartbeats can lead to performance degradation.
*/
heartbeatFrequencyMS?: number;
// Legacy properties - passed to the connection server instance(s)
mongos?: any;
server?: any;
replset?: any;
}
interface ClientSession extends mongodb.ClientSession { }
/*
* section drivers/node-mongodb-native/collection.js
* http://mongoosejs.com/docs/api.html#drivers-node-mongodb-native-collection-js
*/
var Collection: Collection;
interface Collection extends CollectionBase {
/**
* Collection constructor
* @param name name of the collection
* @param conn A MongooseConnection instance
* @param opts optional collection options
*/
new(name: string, conn: Connection, opts?: any): Collection;
/** Formatter for debug print args */
$format(arg: any): string;
/** Debug print helper */
$print(name: any, i: any, args: any[]): void;
/** Retrieves information about this collections indexes. */
getIndexes(): any;
}
interface ConnectionUseDbOptions {
/**
* If true, cache results so calling `useDb()` multiple times with the same name only creates 1 connection object.
*/
useCache?: boolean;
}
/*
* section drivers/node-mongodb-native/connection.js
* http://mongoosejs.com/docs/api.html#drivers-node-mongodb-native-connection-js
*/
class Connection extends ConnectionBase {
/**
* Switches to a different database using the same connection pool.
* @param name The database name
* @param options Additional options
* @returns New Connection Object
*/
useDb(name: string, options?: ConnectionUseDbOptions): Connection;
startSession(options?: mongodb.SessionOptions, cb?: (err: any, session: mongodb.ClientSession) => void): Promise<mongodb.ClientSession>;
/** Expose the possible connection states. */
static STATES: typeof ConnectionStates;
}
export enum ConnectionStates {
disconnected = 0,
connected = 1,
connecting = 2,
disconnecting = 3,
uninitialized = 99,
}
/*
* section error.js
* http://mongoosejs.com/docs/api.html#error-js
*/
class Error extends global.Error {
// "MongooseError" for instances of the current class,
// an other string for instances of derived classes.
name: "MongooseError" | string;
/**
* MongooseError constructor
* @param msg Error message
*/
constructor(msg: string);
/**
* The default built-in validator error messages. These may be customized.
* As you might have noticed, error messages support basic templating
* {PATH} is replaced with the invalid document path
* {VALUE} is replaced with the invalid value
* {TYPE} is replaced with the validator type such as "regexp", "min", or "user defined"
* {MIN} is replaced with the declared min value for the Number.min validator
* {MAX} is replaced with the declared max value for the Number.max validator
*/
static messages: any;
/** For backwards compatibility. Same as mongoose.Error.messages */
static Messages: any;
}
module Error {
/**
* section error/notFound.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.DocumentNotFoundError
*
* An instance of this error class will be returned when `save()` fails
* because the underlying
* document was not found. The constructor takes one parameter, the
* conditions that mongoose passed to `update()` when trying to update
* the document.
*/
export class DocumentNotFoundError extends Error {
name: 'DocumentNotFoundError';
filter: any;
query: any;
constructor(filter: any);
}
/**
* section error/cast.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.CastError
*
* An instance of this error class will be returned when mongoose failed to
* cast a value.
*/
export class CastError extends Error {
name: 'CastError';
stringValue: string;
kind: string;
value: any;
path: string;
reason?: any;
model?: any;
constructor(type: string, value: any, path: string, reason?: NativeError);
setModel(model: any): void;
}
/**
* section error/validation.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.ValidationError
* An instance of this error class will be returned when [validation](/docs/validation.html) failed.
* The `errors` property contains an object whose keys are the paths that failed and whose values are
* instances of CastError or ValidationError.
*
*/
export class ValidationError extends Error {
name: 'ValidationError';
errors: {[path: string]: ValidatorError | CastError};
constructor(instance?: MongooseDocument);
/** Console.log helper */
toString(): string;
inspect(): object;
toJSON(): object;
addError(path: string, error: any): void;
}
/**
* section error/validator.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.ValidatorError
*
* A `ValidationError` has a hash of `errors` that contain individual `ValidatorError` instances
*/
export class ValidatorError extends Error {
name: 'ValidatorError';
properties: {message: string, type?: string, path?: string, value?: any, reason?: any};
kind: string;
path: string;
value: any;
reason: any;
constructor(properties: {message?: string, type?: string, path?: string, value?: any, reason?: any});
formatMessage(msg: string | Function, properties: any): string;
toString(): string;
}
/**
* section error/version.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.VersionError
*
* An instance of this error class will be returned when you call `save()` after
* the document in the database was changed in a potentially unsafe way. See
* the [`versionKey` option](http://mongoosejs.com/docs/guide.html#versionKey) for more information.
*/
export class VersionError extends Error {
name: 'VersionError';
version: any;
modifiedPaths: Array<any>;
constructor(doc: MongooseDocument, currentVersion: any, modifiedPaths: any);
}
/**
* section error/parallelSave.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.ParallelSaveError
*
* An instance of this error class will be returned when you call `save()` multiple
* times on the same document in parallel. See the [FAQ](http://mongoosejs.com/docs/faq.html) for more
* information.
*/
export class ParallelSaveError extends Error {
name: 'ParallelSaveError';
constructor(doc: MongooseDocument);
}
/**
* section error/overwriteModel.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.OverwriteModelError
*
* Thrown when a model with the given name was already registered on the connection.
* See [the FAQ about `OverwriteModelError`](http://mongoosejs.com/docs/faq.html#overwrite-model-error).
*/
export class OverwriteModelError extends Error {
name: 'OverwriteModelError';
constructor(name: string);
}
/**
* section error/missingSchema.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.MissingSchemaError
*
* Thrown when you try to access a model that has not been registered yet
*/
export class MissingSchemaError extends Error {
name: 'MissingSchemaError';
constructor(name: string);
}
/**
* section error/divergentArray.js
* https://mongoosejs.com/docs/api.html#mongooseerror_MongooseError.DivergentArrayError
*
* An instance of this error will be returned if you used an array projection
* and then modified the array in an unsafe way.
*/
export class DivergentArrayError extends Error {
name: 'DivergentArrayError';
constructor(paths: Array<any>);
}
}
interface EachAsyncOptions {
/** defaults to 1 */
parallel?: number;
}
/*
* section querycursor.js
* https://mongoosejs.com/docs/api.html#querycursor-js
*
* Callback signatures are from: https://mongodb.github.io/node-mongodb-native/2.1/api/Cursor.html#close
* QueryCursor can only be accessed by query#cursor(), we only
* expose its interface to enable type-checking.
*/
class QueryCursor<T extends Document> extends stream.Readable {
[Symbol.asyncIterator](): AsyncIterableIterator<T>;
/**
* A QueryCursor is a concurrency primitive for processing query results
* one document at a time. A QueryCursor fulfills the Node.js streams3 API,
* in addition to several other mechanisms for loading documents from MongoDB
* one at a time.
* Unless you're an advanced user, do not instantiate this class directly.
* Use Query#cursor() instead.
* @param options query options passed to .find()
* @event cursor Emitted when the cursor is created
* @event error Emitted when an error occurred
* @event data Emitted when the stream is flowing and the next doc is ready
* @event end Emitted when the stream is exhausted
*/
constructor(query: Query<T>, options: any);
/** Marks this cursor as closed. Will stop streaming and subsequent calls to next() will error. */
close(callback?: (error: any, result: any) => void): Promise<any>;
/**
* Execute fn for every document in the cursor. If fn returns a promise,
* will wait for the promise to resolve before iterating on to the next one.
* Returns a promise that resolves when done.
* @param fn Function to be executed for every document in the cursor
* @param callback Executed when all docs have been processed
*/
eachAsync(fn: (doc: T) => any, callback?: (err: any) => void): Promise<T>;
/**
* Execute fn for every document in the cursor. If fn returns a promise,
* will wait for the promise to resolve before iterating on to the next one.
* Returns a promise that resolves when done.
* @param fn Function to be executed for every document in the cursor
* @param options Async options (e. g. parallel function execution)
* @param callback Executed when all docs have been processed
*/
eachAsync(fn: (doc: T) => any, options: EachAsyncOptions, callback?: (err: any) => void): Promise<T>;
/**
* Registers a transform function which subsequently maps documents retrieved
* via the streams interface or .next()
*/
map(fn: (doc: T) => T): this;
/**
* Get the next document from this cursor. Will return null when there are
* no documents left.
*/
next(callback?: (err: any, doc?: T) => void): Promise<any>;
}
/*
* section virtualtype.js
* http://mongoosejs.com/docs/api.html#virtualtype-js
*/
class VirtualType {
/** This is what mongoose uses to define virtual attributes via Schema.prototype.virtual. */
constructor(options: any, name: string);
/** Applies getters to value using optional scope. */
applyGetters(value: any, scope: any): any;
/** Applies setters to value using optional scope. */
applySetters(value: any, scope: any): any;
/** Defines a getter. */
get(fn: Function): this;
/** Defines a setter. */
set(fn: Function): this;
}
interface HookOptions {
document?: boolean;
query?: boolean;
}
/*
* section schema.js
* http://mongoosejs.com/docs/api.html#schema-js
*/
class Schema<T = any> extends events.EventEmitter {
/**
* Schema constructor.
* When nesting schemas, (children in the example above), always declare
* the child schema first before passing it into its parent.
* @event init Emitted after the schema is compiled into a Model.
*/
constructor(definition?: SchemaDefinition, options?: SchemaOptions);
/** Adds key path / schema type pairs to this schema. */
add(obj: SchemaDefinition, prefix?: string): void;
/** Return a deep copy of this schema */
clone(): Schema;
/**
* Iterates the schemas paths similar to Array.forEach.
* @param fn callback function
* @returns this
*/
eachPath(fn: (path: string, type: SchemaType) => void): this;
/**
* Gets a schema option.
* @param key option name
*/
get(key: string): any;
/**
* Defines an index (most likely compound) for this schema.
* @param options Options to pass to MongoDB driver's createIndex() function
* @param options.expires Mongoose-specific syntactic sugar, uses ms to convert
* expires option into seconds for the expireAfterSeconds in the above link.
*/
index(fields: any, options?: {
expires?: string;
[other: string]: any;
}): this;
/** Compiles indexes from fields and schema-level indexes */
indexes(): any[];
/**
* Loads an ES6 class into a schema. Maps setters + getters, static methods, and
* instance methods to schema virtuals, statics, and methods.
*/
loadClass(model: Function): this;
/**
* Adds an instance method to documents constructed from Models compiled from this schema.
* If a hash of name/fn pairs is passed as the only argument, each name/fn pair will be added as methods.
*/
method<F extends keyof T>(method: F, fn: T[F]): this;
method(methodObj: {
[F in keyof T]: T[F]
}): this;
/**
* Gets/sets schema paths.
* Sets a path (if arity 2)
* Gets a path (if arity 1)
*/
path(path: string): SchemaType;
path(path: string, constructor: any): this;
/**
* Returns the pathType of path for this schema.
* @returns whether it is a real, virtual, nested, or ad-hoc/undefined path.
*/
pathType(path: string): string;
/**
* Registers a plugin for this schema.
* @param plugin callback
*/
plugin(plugin: (schema: Schema) => void): this;
plugin<T>(plugin: (schema: Schema, options: T) => void, opts: T): this;
/**
* Defines a post hook for the document
* Post hooks fire on the event emitted from document instances of Models compiled
* from this schema.
* @param method name of the method to hook
* @param fn callback
*/
post<T extends Document>(method: 'insertMany', fn: (
this: Model<Document>,
error: mongodb.MongoError, docs: T[], next: (err?: NativeError) => void
) => void): this;
post<T extends Document>(method: 'insertMany', fn: (
this: Model<Document>,
docs: T[], next: (err?: NativeError) => void
) => void): this;
post<T extends Document>(method: 'insertMany', fn: (
this: Model<Document>,
docs: T[], next: (err?: NativeError) => Promise<any>
) => void): this;
post<T extends Document>(method: 'remove' | 'deleteOne', { document, query }: HookOptions, fn: (
doc: T
) => void): this;
post<T extends Document>(method: string | RegExp, fn: (
doc: T, next: (err?: NativeError) => void
) => void): this;
post<T extends Document>(method: string | RegExp, fn: (
docs: T[], next: (err?: NativeError) => void
) => void): this;
post<T extends Document>(method: string | RegExp, fn: (
docs: T[], next: (err?: NativeError) => void
) => Promise<void>): this;