@nestjs/mongoose

@nestjs/mongoose

Version 10.0.5
Published 3 days ago
54.3 kB
No dependencies
MIT license

Install

npm i @nestjs/mongoose

yarn add @nestjs/mongoose

pnpm add @nestjs/mongoose

Overview

Nest - modern, fast, powerful node.js web framework (@mongoose)

Functions

function getConnectionToken

getConnectionToken: (name?: string) => string;

function getModelToken

getModelToken: (model: string, connectionName?: string) => string;

function InjectConnection

InjectConnection: (
    name?: string
) => (
    target: object,
    key: string | symbol | undefined,
    index?: number | undefined
) => void;

function InjectModel

InjectModel: (
    model: string,
    connectionName?: string
) => (
    target: object,
    key: string | symbol | undefined,
    index?: number | undefined
) => void;

function Prop

Prop: (options?: PropOptions) => PropertyDecorator;

function raw

raw: (definition: Record<string, any>) => Record<string, any>;

function Schema

Schema: (options?: mongoose.SchemaOptions) => ClassDecorator;

Classes

class CannotDetermineTypeError

class CannotDetermineTypeError extends Error {}

constructor

constructor(hostClass: string, propertyKey: string);

class DefinitionsFactory

class DefinitionsFactory {}

method createForClass

static createForClass: (target: Type<unknown>) => mongoose.SchemaDefinition;

class MongooseModule

class MongooseModule {}

method forFeature

static forFeature: (
    models?: ModelDefinition[],
    connectionName?: string
) => DynamicModule;

method forFeatureAsync

static forFeatureAsync: (
    factories?: AsyncModelFactory[],
    connectionName?: string
) => DynamicModule;

method forRoot

static forRoot: (uri: string, options?: MongooseModuleOptions) => DynamicModule;

method forRootAsync

static forRootAsync: (options: MongooseModuleAsyncOptions) => DynamicModule;

class SchemaFactory

class SchemaFactory {}

method createForClass

static createForClass: <TClass = any>(
    target: Type<TClass>
) => mongoose.Schema<TClass>;

Interfaces

interface AsyncModelFactory

interface AsyncModelFactory
    extends Pick<ModuleMetadata, 'imports'>,
        Pick<ModelDefinition, 'name' | 'collection' | 'discriminators'> {}

property inject

inject?: any[];

property useFactory

useFactory: (
    ...args: any[]
) => ModelDefinition['schema'] | Promise<ModelDefinition['schema']>;

interface MongooseModuleAsyncOptions

interface MongooseModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {}

property connectionName

connectionName?: string;

property inject

inject?: any[];

property useClass

useClass?: Type<MongooseOptionsFactory>;

property useExisting

useExisting?: Type<MongooseOptionsFactory>;

property useFactory

useFactory?: (
    ...args: any[]
) => Promise<MongooseModuleFactoryOptions> | MongooseModuleFactoryOptions;

interface MongooseModuleOptions

interface MongooseModuleOptions extends ConnectOptions {}

property connectionErrorFactory

connectionErrorFactory?: (error: MongooseError) => MongooseError;

property connectionFactory

connectionFactory?: (connection: any, name: string) => any;

property connectionName

connectionName?: string;

property lazyConnection

lazyConnection?: boolean;

property retryAttempts

retryAttempts?: number;

property retryDelay

retryDelay?: number;

property uri

uri?: string;

interface MongooseOptionsFactory

interface MongooseOptionsFactory {}

method createMongooseOptions

createMongooseOptions: () =>
    | Promise<MongooseModuleOptions>
    | MongooseModuleOptions;

Type Aliases

type DiscriminatorOptions

type DiscriminatorOptions = {
    name: string;
    schema: Schema;
    value?: string;
};

type ModelDefinition

type ModelDefinition = {
    name: string;
    schema: any;
    collection?: string;
    discriminators?: DiscriminatorOptions[];
};

type MongooseModuleFactoryOptions

type MongooseModuleFactoryOptions = Omit<MongooseModuleOptions, 'connectionName'>;

type PropOptions

type PropOptions<T = any> =
    | Partial<mongoose.SchemaDefinitionProperty<T>>
    | mongoose.SchemaType;

type SchemaOptions

type SchemaOptions = mongoose.SchemaOptions;

Package Files (13)

Dependencies (0)

No dependencies.

Peer Dependencies (4)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@nestjs/mongoose.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@nestjs/mongoose)

HTML

<a href="https://www.jsdocs.io/package/@nestjs/mongoose"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated just now.
Package analyzed in 3076 ms.
Missing or incorrect documentation? Open an issue for this package.

@nestjs/mongoose

Install

Overview

Index

Functions

Classes

Interfaces

Type Aliases

Functions

function getConnectionToken

function getModelToken

function InjectConnection

function InjectModel

function Prop

function raw

function Schema

Classes

class CannotDetermineTypeError

constructor

class DefinitionsFactory

method createForClass

class MongooseModule

method forFeature

method forFeatureAsync

method forRoot

method forRootAsync

class SchemaFactory

method createForClass

Interfaces

interface AsyncModelFactory

property inject

property useFactory

interface MongooseModuleAsyncOptions

property connectionName

property inject

property useClass

property useExisting

property useFactory

interface MongooseModuleOptions

property connectionErrorFactory

property connectionFactory

property connectionName

property lazyConnection

property retryAttempts

property retryDelay

property uri

interface MongooseOptionsFactory

method createMongooseOptions

Type Aliases

type DiscriminatorOptions

type ModelDefinition

type MongooseModuleFactoryOptions

type PropOptions

type SchemaOptions

Package Files (13)

Dependencies (0)

Dev Dependencies (26)

Peer Dependencies (4)

Badge