@treatwell/moleculer-essentials 1.0.0

package/dist/mixins/database.mixin.d.cts

@@ -0,0 +1,958 @@
+import { Document, WithoutId, InferIdType, ObjectId, Filter, WithId, OptionalId, FindOptions, CountDocumentsOptions, FindOneAndUpdateOptions, BulkWriteOptions, UpdateOptions, FindOneAndReplaceOptions, FindOneAndDeleteOptions, DeleteOptions, CollationOptions, CreateCollectionOptions, MongoClient, CollectionOptions, Collection, UpdateFilter, FindCursor, UpdateResult } from 'mongodb';
+import { ActionVisibility, BaseValidator, Errors, Context } from 'moleculer';
+import { ZodType, ZodObject } from 'zod/v4';
+import { V as ValidationSchema, J as JSONSchemaType, C as CustomActionSchema, a as CustomServiceSchema } from '../context-factory-BWO3xPWE.cjs';
+import { Readable } from 'stream';
+import 'bson';
+import 'ajv/dist/2019.js';
+
+declare enum QueryOp {
+    GT = "$gt",
+    GTE = "$gte",
+    LT = "$lt",
+    LTE = "$lte",
+    IN = "$in",
+    EQ = "$eq",
+    NE = "$ne"
+}
+type ActionGetParamsOptions = {
+    allowFields?: boolean;
+};
+type ActionCountParamsOptions = {
+    queryType: 'object' | 'stringified';
+};
+type ActionListParamsOptions = {
+    queryType: 'object' | 'stringified';
+    maxPageSize?: number;
+};
+type ActionCreateParamsOptions = {
+    allowClientId?: boolean;
+};
+type ActionSchemaFactoryOptions<S, TSchema extends Document> = {
+    schemaName?: string;
+    schema?: S;
+    timestamps: boolean;
+    softDelete: boolean;
+    tenantField: KeyString<TSchema> | false;
+};
+interface ActionSchemaFactory<S extends ValidationSchema | ZodType = ValidationSchema | ZodType> {
+    hasIdField(): boolean;
+    hasTenantIdField(): boolean;
+    /**
+     * Function that make auto generated fields mandatory.
+     */
+    createSchemaWithDbFields(): S;
+    /**
+     * Create the params for the find action.
+     */
+    createFindParams(): S;
+    /**
+     * Create get AND getInternal action params.
+     */
+    createGetParams(params: ActionGetParamsOptions): S;
+    /**
+     * Create count AND countInternal action params.
+     */
+    createCountParams(params: ActionCountParamsOptions): S;
+    /**
+     * Create list action params.
+     */
+    createListParams(params: ActionListParamsOptions): S;
+    /**
+     * Create list action result JSON schema.
+     */
+    createListResponse(): S;
+    /**
+     * Create 'create' action params.
+     */
+    createCreateParams(params: ActionCreateParamsOptions): S;
+    /**
+     * Create 'update' action params.
+     */
+    createUpdateParams(): S;
+    /**
+     * Create 'remove' action params.
+     */
+    createRemoveParams(): S;
+}
+
+/**
+ * Utility type to extract the string keys of a type.
+ */
+type KeyString<T> = Extract<keyof T, string>;
+type TenantParams<TSchema extends Document, TenantField extends KeyString<TSchema> | false> = (TenantField extends KeyString<TSchema> ? Pick<TSchema, TenantField> : null) | null;
+type DatabaseMethodsOptions<TSchema extends Document, TenantField extends KeyString<TSchema> | false> = {
+    /**
+     * Name of the field that will be required to be present in all documents.
+     * This will be used in read queries as a filter to ensure that the user
+     * can only access documents that belong to the same tenant.
+     *
+     * This field can only be top-level and should probably be indexed.
+     */
+    tenantField: TenantField;
+    /**
+     * Enable soft-delete for the model.
+     * The remove method will only set the deletedAt field to NOW.
+     * And a new `scope` field will be read to be able to read deleted documents.
+     *
+     * Note that if schema has a deletedAt field, you are required to set this option to true.
+     */
+    softDelete: TSchema extends {
+        deletedAt?: Date;
+    } ? true : false;
+    /**
+     * Enable timestamps for the model.
+     * Will automatically set the createdAt and updatedAt fields on write operations.
+     *
+     * Note that if schema has both createdAt and updatedAt field, you are required to set this option to true.
+     */
+    timestamps: TSchema extends {
+        createdAt?: Date;
+    } ? TSchema extends {
+        updatedAt?: Date;
+    } ? true : false : false;
+    /**
+     * Note that this function will be applied ONLY on insert operations.
+     */
+    idGenerator?: (doc: WithoutId<TSchema>) => InferIdType<TSchema>;
+    /**
+     * Prefix used for events.
+     * If not specified, will disable events.
+     *
+     * Here is the list of events:
+     * - `${eventPrefix}.created`: Sent on insertOne and insertMany
+     * - `${eventPrefix}.updated`: Sent on updateOne and replaceOne
+     * - `${eventPrefix}.deleted`: Sent on deleteOne
+     */
+    eventPrefix?: string;
+    /**
+     * The sQuerySchema variable is an optional parameter used for validation.
+     * This is used to parse the sQuery parameter on list and count actions.
+     * If omitted, sQuery will be silently discarded.
+     * It uses the same validator than on actions.
+     * The schema will not be published on the openAPI.
+     * See addQueryOps for easy support of some mongo operators.
+     */
+    sQuerySchema?: ValidationSchema | ZodType;
+    /**
+     * Create the actions for the database mixin.
+     * Read operations:
+     * - find (max public)
+     * - findStream (max public)
+     * - getInternal (max public)
+     * - get
+     * - countInternal (max public)
+     * - count
+     * - list
+     *
+     * Write operations:
+     * - create
+     * - update
+     * - remove
+     *
+     * If some actions are not provided here, it probably means that they are not necessary.
+     * For example, there is no `findAllStream` or `updateMany` actions. This is because they are not used
+     * often and is quite specific to the related service.
+     */
+    actions?: DatabaseActionOptions<TSchema>;
+};
+type DatabaseActionVisibility<T extends DatabaseActionNames> = T extends DatabaseActionInternalNames ? Exclude<ActionVisibility, 'published'> : ActionVisibility;
+type DatabaseActionOptions<TSchema extends Document & {
+    _id?: ObjectId | string;
+}> = {
+    [key in DatabaseActionNames]?: {
+        visibility: DatabaseActionVisibility<key>;
+    } & (key extends 'list' ? {
+        maxPageSize?: number;
+        defaultPageSize?: number;
+        defaultSort?: string[];
+    } : NonNullable<unknown>) & (key extends 'create' ? {
+        allowClientId?: boolean;
+    } : NonNullable<unknown>);
+} & {
+    schema?: JSONSchemaType<TSchema> | ZodObject;
+    schemaFactory?: ActionSchemaFactory;
+    schemaName?: string;
+};
+type DatabaseActionInternalNames = 'find' | 'findStream' | 'getInternal' | 'countInternal';
+type DatabaseActionPublishedNames = 'count' | 'list' | 'get' | 'create' | 'update' | 'remove';
+type DatabaseActionNames = DatabaseActionInternalNames | DatabaseActionPublishedNames;
+
+/**
+ * Create the actions for the database mixin.
+ * Read operations:
+ * - find (max public)
+ * - findStream (max public)
+ * - getInternal (max public)
+ * - get
+ * - countInternal (max public)
+ * - count
+ * - list
+ *
+ * Write operations:
+ * - create
+ * - update
+ * - remove
+ *
+ * If some actions are not provided here, it probably means that they are not necessary.
+ * For example, there is no `findAllStream` or `updateMany` actions. This is because they are not used
+ * often and is quite specific to the related service.
+ */
+declare function createActions<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false>(opts: DatabaseMethodsOptions<TSchema, TenantField>): Partial<Record<DatabaseActionNames, CustomActionSchema>>;
+
+declare class AjvActionSchemaFactory<TSchema extends Document> implements ActionSchemaFactory<ValidationSchema> {
+    private opts;
+    private readonly tenantFieldType;
+    private readonly _idFieldType;
+    constructor(opts: ActionSchemaFactoryOptions<JSONSchemaType<TSchema>, TSchema>);
+    hasIdField(): boolean;
+    hasTenantIdField(): boolean;
+    createSchemaWithDbFields(): ValidationSchema;
+    createFindParams(): ValidationSchema;
+    createGetParams(params: ActionGetParamsOptions): ValidationSchema;
+    createCountParams(params: ActionCountParamsOptions): ValidationSchema;
+    createListParams(params: ActionListParamsOptions): ValidationSchema;
+    createListResponse(): ValidationSchema;
+    createCreateParams(params: ActionCreateParamsOptions): ValidationSchema;
+    createUpdateParams(): ValidationSchema;
+    createRemoveParams(): ValidationSchema;
+}
+declare function addQueryOps<T>(schema: JSONSchemaType<T>, queryOps: QueryOp[]): JSONSchemaType<unknown>;
+
+declare function parseStringifiedQuery<TSchema extends Document>(sQuery?: string): Filter<TSchema>;
+declare function parseAndValidateQuery<TSchema extends Document>(validator: BaseValidator, schema: ValidationSchema | ZodType | undefined, sQuery: string | undefined): Filter<TSchema>;
+
+type DatabaseSoftDeleteScope = 'include-deleted' | 'only-deleted' | 'no-deleted';
+/**
+ * Options used on read only operations on the database mixin.
+ * Wrapper around mongodb's FindOptions that is easier for us to use.
+ */
+type DatabaseFindOptions = Omit<FindOptions, 'projection' | 'sort'> & {
+    fields?: string[];
+    sort?: string[];
+    scope?: DatabaseSoftDeleteScope;
+    strictTenantFilter?: boolean;
+};
+/**
+ * Options used on count operations on the database mixin.
+ */
+type DatabaseCountOptions = CountDocumentsOptions & {
+    scope?: DatabaseSoftDeleteScope;
+    strictTenantFilter?: boolean;
+};
+/**
+ * Options used on insertOne operations.
+ * Wrapper around findOneAndUpdate options as we don't use insertOne directly but findOneAndUpdate with upsert.
+ */
+type DatabaseInsertOneOptions = Omit<FindOneAndUpdateOptions, 'upsert' | 'returnDocument' | 'sort' | 'hint' | 'projection' | 'arrayFilters'> & {
+    fields?: string[];
+    skipCreateEvent?: boolean;
+};
+/**
+ * Options used on insertMany operations.
+ */
+type DatabaseInsertManyOptions = BulkWriteOptions & {
+    skipCreateEvent?: boolean;
+};
+/**
+ * Options used on updateOne operations.
+ */
+type DatabaseUpdateOneOptions = Omit<FindOneAndUpdateOptions, 'sort' | 'projection'> & {
+    fields?: string[];
+    sort?: string[];
+    strictTenantFilter?: boolean;
+    skipUpdateEvent?: boolean;
+};
+/**
+ * Options used on updateMany operations.
+ */
+type DatabaseUpdateManyOptions = UpdateOptions & {
+    strictTenantFilter?: boolean;
+};
+/**
+ * Options used on deleteOne operations.
+ * If soft delete is enabled, the document will be updated with a deletedAt field.
+ */
+type DatabaseReplaceOneOptions = Omit<FindOneAndReplaceOptions, 'projection' | 'sort'> & {
+    fields?: string[];
+    sort?: string[];
+    strictTenantFilter?: boolean;
+    skipUpdateEvent?: boolean;
+};
+/**
+ * Options used on deleteOne operations.
+ * If soft delete is enabled, the document will be updated with a deletedAt field.
+ */
+type DatabaseDeleteOneOptions = Omit<FindOneAndDeleteOptions, 'projection' | 'sort'> & {
+    fields?: string[];
+    sort?: string[];
+    strictTenantFilter?: boolean;
+    skipDeleteEvent?: boolean;
+};
+/**
+ * Options used on deleteMany operations.
+ * If soft delete is enabled, the document will be updated with a deletedAt field.
+ */
+type DatabaseDeleteManyOptions = DeleteOptions & {
+    strictTenantFilter?: boolean;
+};
+/**
+ * Type of the event sent by the database mixin on insert.
+ * For insertMany, it will be sent once per document.
+ */
+type DatabaseEventInsert<TSchema extends Document> = {
+    type: 'insert';
+    document: WithDbFields<TSchema>;
+};
+/**
+ * Type of the event sent by the database mixin on update.
+ * No event is sent on updateMany.
+ */
+type DatabaseEventUpdate<TSchema extends Document> = {
+    type: 'update' | 'replace';
+    document: WithDbFields<TSchema>;
+};
+/**
+ * Type of the event sent by the database mixin on update.
+ * No event is sent on deleteMany.
+ */
+type DatabaseEventDelete<TSchema extends Document> = {
+    type: 'delete';
+    document: WithDbFields<TSchema>;
+};
+/**
+ * Helper function that gives the type of document returned from the database.
+ * It will add _id, createdAt and updatedAt fields if they are not already present.
+ */
+type WithDbFields<TSchema extends Document> = TSchema & WithId<TSchema> & (TSchema extends {
+    createdAt?: Date;
+} ? TSchema extends {
+    updatedAt?: Date;
+} ? {
+    createdAt: Date;
+    updatedAt: Date;
+} : NonNullable<unknown> : NonNullable<unknown>);
+type WithOptionalId<T> = OptionalId<T>;
+
+type DatabaseActionFindParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    query?: Filter<TSchema>;
+    fields?: string[];
+    sort?: string[];
+    limit?: number;
+    offset?: number;
+    collation?: CollationOptions;
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionFindResult<TSchema extends Document> = Array<WithDbFields<TSchema>>;
+type DatabaseActionGetInternalParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    _id: InferIdType<TSchema>;
+    fields?: string[];
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionEntityResult<TSchema extends Document> = WithDbFields<TSchema>;
+type DatabaseActionGetParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    _id: InferIdType<TSchema>;
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionCountInternalParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    query?: Filter<TSchema>;
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionCountParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    sQuery?: string;
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionListParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    sQuery?: string;
+    sort?: string[];
+    page?: number;
+    pageSize?: number;
+    collation?: CollationOptions;
+} & (TSchema extends {
+    deletedAt?: Date;
+} ? {
+    scope?: DatabaseSoftDeleteScope;
+} : NonNullable<unknown>) & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionListResult<TSchema extends Document> = {
+    rows: Array<TSchema>;
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+};
+type DatabaseActionCreateParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}> = WithOptionalId<TSchema>;
+type DatabaseActionUpdateParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = Partial<TSchema> & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+type DatabaseActionRemoveParams<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false> = {
+    _id: InferIdType<TSchema>;
+} & (TenantField extends KeyString<TSchema> ? {
+    [key in TenantField]: TSchema[TenantField];
+} : NonNullable<unknown>);
+
+declare class ZodActionSchemaFactory<TSchema extends Document> implements ActionSchemaFactory<ZodType> {
+    private opts;
+    private readonly tenantFieldType;
+    private readonly _idFieldType;
+    private schemaWithDbFields;
+    constructor(opts: ActionSchemaFactoryOptions<ZodType, TSchema>);
+    hasIdField(): boolean;
+    hasTenantIdField(): boolean;
+    createSchemaWithDbFields(): ZodType;
+    createFindParams(): ZodType;
+    createGetParams(params: ActionGetParamsOptions): ZodType;
+    createCountParams(params: ActionCountParamsOptions): ZodType;
+    createListParams(params: ActionListParamsOptions): ZodType;
+    createListResponse(): ZodType;
+    createCreateParams(params: ActionCreateParamsOptions): ZodType;
+    createUpdateParams(): ZodType;
+    createRemoveParams(): ZodType;
+}
+declare function addZodQueryOps(fieldValue: ZodType, queryOps: QueryOp[]): ZodType;
+
+declare global {
+    var __MONGO_URI__: string | undefined;
+    var __MONGO_DB_NAME__: string | undefined;
+}
+type DatabaseConnectionOptions = {
+    /**
+     * Name of the database to use.
+     * If not specified, will use the default one (inferred from uri).
+     *
+     * OVERRIDDEN by globalThis.__MONGO_DB_NAME__ if set, which is useful for tests.
+     */
+    databaseName?: string;
+    /**
+     * Name of the collection in the DB.
+     */
+    collectionName: string;
+    /**
+     * Collection creation options.
+     * If not specified, will use the default one.
+     * Note that it shouldn't be changed without being sure of what you are doing.
+     */
+    createCollectionOptions?: CreateCollectionOptions;
+    /**
+     * URI of the MongoDB server.
+     * If not specified, will try to use one from environment:
+     * - process.env.MONGO_URL
+     * - process.env.MONGODB_URL
+     * - 'mongodb://localhost:27017' (default)
+     *
+     * OVERRIDDEN by globalThis.__MONGO_URI__ if set, which is useful for tests.
+     */
+    uri?: string;
+};
+declare function DatabaseConnectionMixin<TSchema extends Record<string, unknown> = never>(opts: DatabaseConnectionOptions): Partial<CustomServiceSchema<unknown, {
+    getMongoClient(): MongoClient;
+    getCollection(options?: CollectionOptions): Collection<TSchema>;
+}, Partial<CustomServiceSchema<unknown, {
+    getStore(storeName: string): Map<string, {
+        services: Set<unknown>;
+        client: MongoClient;
+        onClose: () => Promise<void> | void;
+    }>;
+    getFromStore(storeName: string, key: string): MongoClient | null;
+    removeServiceFromStore(storeName: string, key: string): Promise<boolean>;
+    setClientToStore(storeName: string, key: string, client: MongoClient, onClose: () => Promise<void> | void): void;
+}, unknown, unknown>>[], unknown>>;
+
+declare const MoleculerClientError: typeof Errors.MoleculerClientError;
+declare class EntityNotFoundError extends MoleculerClientError {
+    constructor(id: string | string[]);
+}
+
+type MongoIndex = {
+    key: Record<string, 1 | -1>;
+    name?: string;
+    expireAfterSeconds?: number;
+    partialFilterExpression?: Record<string, unknown>;
+    sparse?: boolean;
+    unique?: boolean;
+    collation?: CollationOptions;
+};
+type IndexTuple = [MongoIndex['key'], Omit<MongoIndex, 'key'>?];
+type SearchIndexCharFilter = {
+    type: 'htmlStrip';
+    ignoredTags?: string[];
+} | {
+    type: 'icuNormalize';
+} | {
+    type: 'mapping';
+    mappings: Record<string, string>;
+} | {
+    type: 'persian';
+};
+type SearchIndexTokenizer = {
+    type: 'edgeGram';
+    minGram: number;
+    maxGram: number;
+} | {
+    type: 'keyword';
+} | {
+    type: 'nGram';
+    minGram: number;
+    maxGram: number;
+} | {
+    type: 'regexCaptureGroup';
+    pattern: string;
+    group: number;
+} | {
+    type: 'regexSplit';
+    pattern: string;
+} | {
+    type: 'standard';
+    maxTokenLength?: number;
+} | {
+    type: 'uaxUrlEmail';
+    maxTokenLength?: number;
+} | {
+    type: 'whitespace';
+    maxTokenLength?: number;
+};
+type SearchIndexTokenFilter = {
+    type: 'asciiFolding';
+    originalTokens?: 'include' | 'omit';
+} | {
+    type: 'daitchMokotoffSoundex';
+    originalTokens?: 'include' | 'omit';
+} | {
+    type: 'edgeGram';
+    minGram: number;
+    maxGram: number;
+    termNotInBounds?: 'include' | 'omit';
+} | {
+    type: 'englishPossessive';
+} | {
+    type: 'flattenGraph';
+} | {
+    type: 'icuFolding';
+} | {
+    type: 'icuNormalizer';
+    normalizationForm?: 'nfd' | 'nfc' | 'nfkd' | 'nfkc';
+} | {
+    type: 'kStemming';
+} | {
+    type: 'length';
+    min?: number;
+    max?: number;
+} | {
+    type: 'lowercase';
+} | {
+    type: 'nGram';
+    minGram: number;
+    maxGram: number;
+    termNotInBounds?: 'include' | 'omit';
+} | {
+    type: 'porterStemming';
+} | {
+    type: 'regex';
+    pattern: string;
+    replacement: string;
+    matches: 'all' | 'first';
+} | {
+    type: 'reverse';
+} | {
+    type: 'shingle';
+    minShingleSize: number;
+    maxShingleSize: number;
+} | {
+    type: 'snowballStemming';
+    stemmerName: string;
+} | {
+    type: 'spanishPluralStemming';
+} | {
+    type: 'stempel';
+} | {
+    type: 'stopword';
+    tokens: string[];
+    ignoreCase?: boolean;
+} | {
+    type: 'trim';
+} | {
+    type: 'wordDelimiterGraph';
+    delimiterOptions?: {
+        generateWordParts?: boolean;
+        generateNumberParts?: boolean;
+        concatenateWords?: boolean;
+        concatenateNumbers?: boolean;
+        concatenateAll?: boolean;
+        preserveOriginal?: boolean;
+        splitOnCaseChange?: boolean;
+        splitOnNumerics?: boolean;
+        stemEnglishPossessive?: boolean;
+        ignoreKeywords?: boolean;
+    };
+    protectedWords?: {
+        words: string[];
+        ignoreCase?: boolean;
+    };
+};
+/**
+ * Definition of a custom atlas search analyzer.
+ * See https://www.mongodb.com/docs/atlas/atlas-search/analyzers/custom/#std-label-custom-analyzers
+ */
+type SearchIndexCustomAnalyzers = {
+    name: string;
+    charFilters?: Array<SearchIndexCharFilter>;
+    tokenizer: SearchIndexTokenizer;
+    tokenFilters?: Array<SearchIndexTokenFilter>;
+};
+type SearchIndexFieldString = {
+    type: 'string';
+    analyzer?: string;
+    searchAnalyzer?: string;
+    indexOptions?: 'docs' | 'freqs' | 'positions' | 'offsets';
+    store?: boolean;
+    ignoreAbove?: number;
+    multi?: Record<string, SearchIndexFieldString>;
+    norms?: 'include' | 'omit';
+};
+/**
+ * Definition of a field in a search index.
+ * See https://www.mongodb.com/docs/atlas/atlas-search/define-field-mappings/
+ */
+type SearchIndexField = {
+    type: 'autocomplete';
+    analyzer?: string;
+    maxGrams?: number;
+    minGrams?: number;
+    tokenization?: 'edgeGram' | 'rightEdgeGram' | 'nGram';
+    foldDiacritics?: boolean;
+} | {
+    type: 'boolean';
+} | {
+    type: 'date';
+} | {
+    type: 'dateFacet';
+} | {
+    type: 'document';
+    dynamic?: boolean;
+    fields?: Record<string, SearchIndexField | SearchIndexField[]>;
+} | {
+    type: 'embeddedDocuments';
+    dynamic?: boolean;
+    fields?: Record<string, SearchIndexField | SearchIndexField[]>;
+} | {
+    type: 'geo';
+    indexShapes?: boolean;
+} | {
+    type: 'number';
+    representation?: 'double' | 'int64';
+    indexIntegers?: boolean;
+    indexDoubles?: boolean;
+} | {
+    type: 'numberFacet';
+    representation?: 'double' | 'int64';
+    indexIntegers?: boolean;
+    indexDoubles?: boolean;
+} | {
+    type: 'objectId';
+} | SearchIndexFieldString | {
+    type: 'stringFacet';
+} | {
+    type: 'token';
+    normalizer?: 'lowercase' | 'none';
+};
+type SearchIndexDefinition = {
+    analyzer?: string;
+    searchAnalyzer?: string;
+    mappings?: {
+        dynamic?: boolean;
+        fields?: Record<string, SearchIndexField | SearchIndexField[]>;
+    };
+    analyzers?: Array<SearchIndexCustomAnalyzers>;
+    storedSource?: boolean | {
+        include: string[];
+    } | {
+        exclude: string[];
+    };
+    synonyms?: Array<{
+        analyzer: string;
+        name: string;
+        source: {
+            collection: string;
+        };
+    }>;
+};
+/**
+ * Type of what is returned by listSearchIndexes.
+ * See https://www.mongodb.com/docs/manual/reference/operator/aggregation/listSearchIndexes/#output
+ */
+type ListSearchIndex = {
+    id: string;
+    name: string;
+    status: 'BUILDING' | 'FAILED' | 'PENDING' | 'READY' | 'STALE';
+    queryable: boolean;
+    latestDefinitionVersion: {
+        version: number;
+        createdAt: Date;
+    };
+    latestDefinition: SearchIndexDefinition;
+    statusDetail: Array<{
+        hostname: string;
+        status: string;
+        queryable: boolean;
+        mainIndex: Document;
+        stagedIndex: Document;
+    }>;
+    synonymMappingStatus: 'BUILDING' | 'FAILED' | 'READY';
+    synonymMappingStatusDetail: Array<{
+        status: string;
+        queryable: boolean;
+    }>;
+    message: string;
+};
+declare enum IndexStatus {
+    OK = "OK",
+    MISSING = "MISSING",
+    OUTDATED = "OUTDATED",
+    NOT_DECLARED = "NOT_DECLARED"
+}
+type IndexState = {
+    type: 'index';
+    status: IndexStatus.OK | IndexStatus.OUTDATED;
+    index: MongoIndex;
+    declaredIndex: IndexTuple;
+} | {
+    type: 'index';
+    status: IndexStatus.MISSING;
+    declaredIndex: IndexTuple;
+} | {
+    type: 'index';
+    status: IndexStatus.NOT_DECLARED;
+    index: MongoIndex;
+} | {
+    type: 'searchIndex';
+    status: IndexStatus.OK | IndexStatus.OUTDATED;
+    name: string;
+    searchIndex: SearchIndexDefinition;
+    declaredSearchIndex: SearchIndexDefinition;
+} | {
+    type: 'searchIndex';
+    status: IndexStatus.MISSING;
+    name: string;
+    declaredSearchIndex: SearchIndexDefinition;
+} | {
+    type: 'searchIndex';
+    status: IndexStatus.NOT_DECLARED;
+    name: string;
+    searchIndex: SearchIndexDefinition;
+};
+
+type DatabaseIndexesOptions = {
+    indexes?: IndexTuple[];
+    searchIndexes?: Record<string, SearchIndexDefinition>;
+};
+type SyncIndexesOptions = {
+    createIndexes: boolean;
+    dropIndexes: boolean;
+};
+declare const DATABASE_INDEXES_MIXIN_SYNC_EVENT = "database-indexes-mixin.sync";
+declare function DatabaseIndexesMixin(opts: DatabaseIndexesOptions): Partial<CustomServiceSchema<unknown, {
+    _syncIndexes({ dropIndexes, createIndexes, }: SyncIndexesOptions): Promise<void>;
+    _createIndexFromState(col: Collection, state: IndexState): Promise<void>;
+}, unknown, unknown>>;
+
+declare function getDefaultIndexName(key: Record<string, 1 | -1>): string;
+declare function isIndexNameEqual(dbIdx: MongoIndex, idx: IndexTuple): boolean;
+declare function isIndexEqual(dbIdx: MongoIndex, idx: IndexTuple): boolean;
+declare function isOnAtlas(): boolean;
+/**
+ * Rule for auto synchronise indexes is, in that order to not be hosted in MongoDB Atlas
+ * 1. check for specific operation env variable
+ * 2. check for force operation env variable
+ * 3. check if we're hosted on MongoDB Atlas
+ * or to force sync with the SYNC_MONGO_INDEX = 'yes'.
+ */
+declare function shouldAutoCreateIndexes(): boolean;
+declare function shouldAutoDropIndexes(): boolean;
+declare function getIndexesDifference({ collection, declaredIdxs, }: {
+    collection: Collection<any>;
+    declaredIdxs: IndexTuple[];
+}): Promise<{
+    idxsToCreate: MongoIndex[];
+    idxsToUpdate: MongoIndex[];
+    idxsToDelete: Required<MongoIndex>[];
+    synced: boolean;
+}>;
+
+declare function removeMongoId<T>(schema: JSONSchemaType<WithId<T>>, refName?: string): JSONSchemaType<Omit<T, '_id'>>;
+declare function optionalMongoId<T>(schema: JSONSchemaType<WithId<T>>, refName?: string): JSONSchemaType<WithOptionalId<T>>;
+/**
+ * Optimize query index usage for $or queries.
+ * This is particularly useful in case of partial indexes.
+ * This distributes the original condition in all $or conditions.
+ * @param query the query to optimize
+ */
+declare function optimizeQuery<T extends Record<string, unknown>>(query: Filter<T>): Filter<T>;
+
+declare function DatabaseMethodsMixin<TSchema extends Document & {
+    _id: ObjectId | string;
+}, TenantField extends KeyString<TSchema> | false = false>(opts: DatabaseMethodsOptions<TSchema, TenantField>): Partial<CustomServiceSchema<unknown, {
+    /**
+     * Helper function that clean an update aggregation pipeline from createdAt changes.
+     * Note: This method mutate the array.
+     */
+    _removeCreatedAtFromUpdateAggregationPipeline(changes: UpdateFilter<TSchema>): void;
+    /**
+     * This method will automatically set the needed operators for our features (timestamps).
+     *
+     * Limitations of this method:
+     * - Dates are generated on the mongo server, except for `update` type with upsert.
+     * - It doesn't support $replaceWith/$replaceRoot in an aggregation pipeline except when using type `replace`.
+     * - Replaces (`replace` type) can only be done with an aggregation pipeline with a single $replaceWith stage.
+     * - Update aggregation pipelines will be modified to let the createdAt field stay the same.
+     */
+    _prepareUpdateFilter(changes: UpdateFilter<TSchema>, type: "create" | "update" | "replace"): UpdateFilter<TSchema>;
+    /**
+     * Will get the tenant filter from params.
+     * This filter should be used in all read queries to ensure that the user
+     * can only access documents that belong to the same tenant.
+     */
+    _getTenantFilter(params: TenantParams<TSchema, TenantField>, strict?: boolean): Filter<TSchema>;
+    /**
+     * Will get the soft delete filter from params.
+     * This filter should be used in all read queries.
+     *
+     * Indexes should also index the deleted field to ensure optimal performance.
+     * Note that in order to support partial indexes, a non deleted field is checked
+     * for `false` and `null` values.
+     */
+    _getSoftDeleteFilter(scope?: DatabaseSoftDeleteScope): Filter<TSchema>;
+    /**
+     * Get a query filter optimized ($or problem) with additional filters applied:
+     * - Tenant filter
+     * - Soft delete filter
+     */
+    _getQueryFilter(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, scope?: DatabaseSoftDeleteScope, strictTenantFilter?: boolean): Filter<TSchema>;
+    /**
+     * INTERNAL, DO NOT USE.
+     * Simple wrapper around the DatabaseConnectionMixin.getCollection method to have typed collection.
+     */
+    _getDatabaseMixinCollection(options?: CollectionOptions): Collection<TSchema>;
+    /**
+     * Create a find cursor with database mixin options applied.
+     */
+    _createFindCursor(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseFindOptions): FindCursor<WithDbFields<TSchema>>;
+    _findOne(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: Omit<DatabaseFindOptions, "limit" | "batchSize">): Promise<WithDbFields<TSchema> | null>;
+    _find(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseFindOptions): Promise<WithDbFields<TSchema>[]>;
+    _findStream(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseFindOptions): Readable;
+    _countDocuments(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseCountOptions): Promise<number>;
+    /**
+     * Insert one document and return it.
+     *
+     * It differs from the driver's insertOne as it returns the inserted document and
+     * send an event with the new document.
+     */
+    _insertOne(ctx: Context, doc: OptionalId<TSchema>, options?: DatabaseInsertOneOptions): Promise<WithDbFields<TSchema>>;
+    /**
+     * Insert many documents and return the list of inserted ids in the same order.
+     */
+    _insertMany(ctx: Context, docs: OptionalId<TSchema>[], options?: DatabaseInsertManyOptions): Promise<TSchema["_id"][]>;
+    /**
+     * Update one document and return the after version by default.
+     * To have the before version, use the `returnDocument` option.
+     *
+     * WARNING: Only send an event if returnDocument is 'after'.If returnDocument is 'before',
+     * you MUST pass skipUpdateEvent: true and optionally send the event yourself.
+     */
+    _updateOne(ctx: Context, query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, changes: UpdateFilter<TSchema>, options?: DatabaseUpdateOneOptions): Promise<WithDbFields<TSchema> | null>;
+    /**
+     * Update many documents and return the number of updated documents.
+     *
+     * WARNING: Do not send any events. You'll have to send an event yourself.
+     */
+    _updateMany(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, changes: UpdateFilter<TSchema>, options?: DatabaseUpdateManyOptions): Promise<UpdateResult<TSchema>>;
+    /**
+     * Replace one document and return the after version by default.
+     * To have the before version, use the `returnDocument` option.
+     *
+     * WARNING: Only send an event if returnDocument is 'after'.If returnDocument is 'before',
+     * you MUST pass skipUpdateEvent: true and optionally send the event yourself.
+     */
+    _replaceOne(ctx: Context, query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, doc: TSchema, options?: DatabaseReplaceOneOptions): Promise<WithDbFields<TSchema> | null>;
+    /**
+     * Delete one document and return it.
+     * If soft delete is enabled, it will only set the deleted field to true (hiding it from future requests).
+     */
+    _deleteOne(ctx: Context, query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseDeleteOneOptions): Promise<WithDbFields<TSchema> | null>;
+    /**
+     * Delete many documents and return the number of deleted documents.
+     * If soft delete is enabled, it will only set the deleted field to true (hiding it from future requests).
+     *
+     * WARNING: Do not send any events. You'll have to send an event yourself.
+     */
+    _deleteMany(query: Filter<TSchema>, params: TenantParams<TSchema, TenantField>, options?: DatabaseDeleteManyOptions): Promise<number>;
+}, unknown, unknown>>;
+
+/**
+ * This function is here to prevent accessing private (secure) fields.
+ *
+ * It removes any unauthorized fields from the query if it is an
+ * "allowed list" mode. In "deny list" mode or if no list,
+ * it adds secure fields to the list.
+ *
+ * If a query is a mixed of both mode, it throws an error.
+ */
+declare function filterFields(fields: string[] | undefined, secureFields: string[] | undefined): string[] | undefined;
+/**
+ * Filter an objects following a fields array.
+ * A simpler version of mongo projection logic.
+ */
+declare function filterObjectFields<T extends Record<string, unknown>>(obj: Record<string, unknown>, fields?: string[]): T;
+/**
+ * Return an object with each list item as key and 1/0/-1 as value
+ * to be used in mongo projection or sort.
+ */
+declare function getQueryFromList<T extends 'sort' | 'projection', NotOp extends T extends 'sort' ? -1 : 0>(type: T, list?: string[]): Record<string, 1 | NotOp> | undefined;
+
+export { AjvActionSchemaFactory, DATABASE_INDEXES_MIXIN_SYNC_EVENT, DatabaseConnectionMixin, DatabaseIndexesMixin, DatabaseMethodsMixin, EntityNotFoundError, IndexStatus, QueryOp, ZodActionSchemaFactory, addQueryOps, addZodQueryOps, createActions, filterFields, filterObjectFields, getDefaultIndexName, getIndexesDifference, getQueryFromList, isIndexEqual, isIndexNameEqual, isOnAtlas, optimizeQuery, optionalMongoId, parseAndValidateQuery, parseStringifiedQuery, removeMongoId, shouldAutoCreateIndexes, shouldAutoDropIndexes };
+export type { ActionCountParamsOptions, ActionCreateParamsOptions, ActionGetParamsOptions, ActionListParamsOptions, ActionSchemaFactory, ActionSchemaFactoryOptions, DatabaseActionCountInternalParams, DatabaseActionCountParams, DatabaseActionCreateParams, DatabaseActionEntityResult, DatabaseActionFindParams, DatabaseActionFindResult, DatabaseActionGetInternalParams, DatabaseActionGetParams, DatabaseActionInternalNames, DatabaseActionListParams, DatabaseActionListResult, DatabaseActionNames, DatabaseActionOptions, DatabaseActionPublishedNames, DatabaseActionRemoveParams, DatabaseActionUpdateParams, DatabaseConnectionOptions, DatabaseCountOptions, DatabaseDeleteManyOptions, DatabaseDeleteOneOptions, DatabaseEventDelete, DatabaseEventInsert, DatabaseEventUpdate, DatabaseFindOptions, DatabaseIndexesOptions, DatabaseInsertManyOptions, DatabaseInsertOneOptions, DatabaseMethodsOptions, DatabaseReplaceOneOptions, DatabaseSoftDeleteScope, DatabaseUpdateManyOptions, DatabaseUpdateOneOptions, IndexState, IndexTuple, KeyString, ListSearchIndex, MongoIndex, SearchIndexCustomAnalyzers, SearchIndexDefinition, SearchIndexField, SearchIndexFieldString, SyncIndexesOptions, TenantParams, WithDbFields, WithOptionalId };