@tstdl/base 0.81.35 → 0.82.0

package/authentication/models/authentication-session.model.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationSession = void 0;
+const schema_1 = require("../../schema");
+class AuthenticationSession {
+    subject;
+    begin;
+    end;
+    tokenId;
+    hashVersion;
+    refreshTokenSalt;
+    refreshTokenHash;
+}
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", String)
+], AuthenticationSession.prototype, "subject", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", Number)
+], AuthenticationSession.prototype, "begin", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", Number)
+], AuthenticationSession.prototype, "end", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", String)
+], AuthenticationSession.prototype, "tokenId", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", Number)
+], AuthenticationSession.prototype, "hashVersion", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", Uint8Array)
+], AuthenticationSession.prototype, "refreshTokenSalt", void 0);
+__decorate([
+    (0, schema_1.Property)(),
+    __metadata("design:type", Uint8Array)
+], AuthenticationSession.prototype, "refreshTokenHash", void 0);
+exports.AuthenticationSession = AuthenticationSession;
+//# sourceMappingURL=authentication-session.model.js.map

package/authentication/models/authentication-session.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication-session.model.js","sourceRoot":"","sources":["../../../source/authentication/models/authentication-session.model.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAoC;AAEpC,MAAa,qBAAqB;IAEhC,OAAO,CAAS;IAGhB,KAAK,CAAS;IAGd,GAAG,CAAS;IAGZ,OAAO,CAAS;IAGhB,WAAW,CAAS;IAGpB,gBAAgB,CAAa;IAG7B,gBAAgB,CAAa;CAC9B;AApBC;IAAC,IAAA,iBAAQ,GAAE;;sDACK;AAEhB;IAAC,IAAA,iBAAQ,GAAE;;oDACG;AAEd;IAAC,IAAA,iBAAQ,GAAE;;kDACC;AAEZ;IAAC,IAAA,iBAAQ,GAAE;;sDACK;AAEhB;IAAC,IAAA,iBAAQ,GAAE;;0DACS;AAEpB;IAAC,IAAA,iBAAQ,GAAE;8BACO,UAAU;+DAAC;AAE7B;IAAC,IAAA,iBAAQ,GAAE;8BACO,UAAU;+DAAC;AApB/B,sDAqBC"}

package/authentication/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './authentication-credentials.model';
+export * from './authentication-session.model';

package/authentication/models/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./authentication-credentials.model"), exports);
+__exportStar(require("./authentication-session.model"), exports);
+//# sourceMappingURL=index.js.map

package/authentication/models/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/authentication/models/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qEAAmD;AACnD,iEAA+C"}

package/authentication/tokens.d.ts

@@ -0,0 +1,2 @@
+import type { AuthenticationServiceOptions } from './authentication.service';
+export declare const AUTHENTICATION_SERVICE_OPTIONS: import("../container").InjectionToken<AuthenticationServiceOptions, any>;

package/authentication/tokens.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTHENTICATION_SERVICE_OPTIONS = void 0;
+const container_1 = require("../container");
+exports.AUTHENTICATION_SERVICE_OPTIONS = (0, container_1.injectionToken)('AUTHENTICATION_SERVICE_OPTIONS');
+//# sourceMappingURL=tokens.js.map

package/authentication/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../source/authentication/tokens.ts"],"names":[],"mappings":";;;AAAA,4CAA6C;AAGhC,QAAA,8BAA8B,GAAG,IAAA,0BAAc,EAA+B,gCAAgC,CAAC,CAAC"}

package/collections/keyed-set.d.ts

@@ -2,7 +2,7 @@ export declare enum KeyedSetMode {
     Keep = 0,
     Overwrite = 1
 }
-export declare type Selector<T> = (value: T) => any;
+export type Selector<T> = (value: T) => any;
 export declare class KeyedSet<T> implements Set<T> {
     private readonly selector;
     private readonly mode;

package/collections/observable/observable-collection.d.ts

@@ -1,6 +1,6 @@
 import type { Observable } from 'rxjs';
 import type { Collection } from '../collection';
-export declare type ObservableCollectionChangeEvent<T> = {
+export type ObservableCollectionChangeEvent<T> = {
     add?: T[];
     remove?: T[];
 };

package/collections/observable/observable-list.d.ts

@@ -2,11 +2,11 @@ import type { Observable } from 'rxjs';
 import type { List } from '../list';
 import type { SortedList } from '../sorted-list';
 import type { ObservableCollection } from './observable-collection';
-export declare type ObservableListIndexedEvent<T> = {
+export type ObservableListIndexedEvent<T> = {
     value: T;
     index: number;
 };
-export declare type ObservableListIndexedChangeEvent<T> = {
+export type ObservableListIndexedChangeEvent<T> = {
     add?: ObservableListIndexedEvent<T>[];
     remove?: ObservableListIndexedEvent<T>[];
 };

package/container/container.d.ts

@@ -10,8 +10,8 @@ export declare const injectMetadataSymbol: unique symbol;
  * singleton: each resolve will return the same instance
  * resolution: the same instance will be resolved for each resolution of this dependency during a single resolution chain
  */
-export declare type Lifecycle = 'transient' | 'singleton' | 'resolution';
-export declare type RegistrationOptions<T, A = unknown> = {
+export type Lifecycle = 'transient' | 'singleton' | 'resolution';
+export type RegistrationOptions<T, A = unknown> = {
     lifecycle?: Lifecycle;
     /** default resolve argument used when neither token nor explicit resolve argument is provided */
     defaultArgument?: InjectableArgument<T, A>;
@@ -32,7 +32,7 @@ export declare type RegistrationOptions<T, A = unknown> = {
     /** custom metadata */
     metadata?: Record;
 };
-export declare type Registration<T = any, A = any> = {
+export type Registration<T = any, A = any> = {
     token: InjectionToken<T, A>;
     provider: Provider<T, A>;
     options: RegistrationOptions<T, A>;

package/container/decorators.d.ts

@@ -4,14 +4,14 @@ import type { Lifecycle, RegistrationOptions } from './container';
 import type { Provider } from './provider';
 import type { InjectionToken } from './token';
 import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types';
-declare type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
-export declare type InjectableOptions<T, A> = RegistrationOptions<T> & {
+type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A> = RegistrationOptions<T> & {
     /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
     alias?: OneOrMany<InjectionToken>;
     /** custom provider. Useful for example if initialization is required */
     provider?: Provider<T, A>;
 };
-export declare type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
 /**
  * Helper decorator to replace a class definition with an other
  * can be used for example to type external classes with the {@link Injectable} interface

package/container/interfaces.d.ts

@@ -1,6 +1,6 @@
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
-export declare type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
+export type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
 export interface Injectable<T = unknown> {
     /**
      * type of resolve argument

package/container/provider.d.ts

@@ -2,15 +2,15 @@ import type { Constructor } from "../types";
 import type { InjectableArgument } from './interfaces';
 import type { InjectionToken } from './token';
 import type { ResolveContext } from './types';
-export declare type Factory<T, A = any> = (argument: InjectableArgument<T, A> | undefined, context: ResolveContext) => T | Promise<T>;
-export declare type Provider<T = any, A = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T, A> | FactoryProvider<T, A>;
-export declare type ClassProvider<T = any> = {
+export type Factory<T, A = any> = (argument: InjectableArgument<T, A> | undefined, context: ResolveContext) => T | Promise<T>;
+export type Provider<T = any, A = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T, A> | FactoryProvider<T, A>;
+export type ClassProvider<T = any> = {
     useClass: Constructor<T>;
 };
-export declare type ValueProvider<T = any> = {
+export type ValueProvider<T = any> = {
     useValue: T;
 };
-export declare type TokenProvider<T = any, A = any> = {
+export type TokenProvider<T = any, A = any> = {
     useToken: InjectionToken<T, A>;
     useTokenProvider?: undefined;
     argument?: InjectableArgument<T, A>;
@@ -21,7 +21,7 @@ export declare type TokenProvider<T = any, A = any> = {
     argument?: InjectableArgument<T, A>;
     argumentProvider?: () => InjectableArgument<T, A>;
 };
-export declare type FactoryProvider<T = any, A = unknown> = {
+export type FactoryProvider<T = any, A = unknown> = {
     useFactory: Factory<T, A>;
 };
 export declare function classProvider<T>(constructor: Constructor<T>): ClassProvider<T>;

package/container/resolve-chain.d.ts

@@ -1,9 +1,9 @@
 import type { AbstractConstructor } from "../types";
 import type { InjectionToken } from './token';
-export declare type ResolveChainNodeBase<Type extends string> = {
+export type ResolveChainNodeBase<Type extends string> = {
     type: Type;
 };
-export declare type ResolveChainNode = ResolveChainNodeBase<'token'> & {
+export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
     token: InjectionToken;
 } | ResolveChainNodeBase<'parameter'> & {
     constructor: AbstractConstructor;

package/container/token.d.ts

@@ -1,10 +1,10 @@
 import type { Constructor } from "../types";
 declare const parameter: unique symbol;
-export declare type ParameterizedInjectionToken<T, A> = SimpleInjectionToken<T> & {
+export type ParameterizedInjectionToken<T, A> = SimpleInjectionToken<T> & {
     [parameter]?: A;
 };
-export declare type SimpleInjectionToken<T> = Constructor<T> | Function | object | string | symbol;
-export declare type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ParameterizedInjectionToken<T, A>;
+export type SimpleInjectionToken<T> = Constructor<T> | Function | object | string | symbol;
+export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ParameterizedInjectionToken<T, A>;
 export declare function injectionToken<T, A = any>(token: InjectionToken<T, A>): InjectionToken<T, A>;
 export declare function getTokenName(token: InjectionToken | undefined): string;
 export {};

package/container/type-info.d.ts

@@ -1,6 +1,6 @@
 import type { InjectionToken } from './token';
 import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types';
-export declare type InjectMetadata = {
+export type InjectMetadata = {
     /** token overwrite by inject decorator */
     injectToken?: InjectionToken;
     /** if defined, resolve the ForwardRefToken using ForwardRef strategy instead resolving the token */

package/container/types.d.ts

@@ -1,8 +1,8 @@
 import type { Container } from './container';
 import type { InjectionToken } from './token';
-export declare type ResolveContext = Pick<Container, 'resolve' | 'resolveAsync'> & {
+export type ResolveContext = Pick<Container, 'resolve' | 'resolveAsync'> & {
     isAsync: boolean;
 };
-export declare type Mapper<T = any, U = unknown> = (value: T) => U | Promise<U>;
-export declare type ArgumentProvider<T = unknown> = (context: ResolveContext) => T | Promise<T>;
-export declare type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
+export type Mapper<T = any, U = unknown> = (value: T) => U | Promise<U>;
+export type ArgumentProvider<T = unknown> = (context: ResolveContext) => T | Promise<T>;
+export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);

package/core.d.ts

@@ -6,7 +6,7 @@ export declare const CORE_LOGGER: InjectionToken<Logger, any>;
 export declare const disposer: AsyncDisposer;
 export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;
 export declare function disposeInstances(): Promise<void>;
-export declare type CoreConfiguration = {
+export type CoreConfiguration = {
     coreLogPrefix?: string;
     logLevel?: LogLevel;
     loggerToken?: InjectionToken<Logger, LoggerArgument>;

package/data-structures/linked-list.d.ts

@@ -2,7 +2,7 @@ import type { TryDereference } from "../serializer/serializable";
 import { Serializable } from "../serializer/serializable";
 import type { Predicate } from "../utils/iterable-helpers/types";
 import { List } from './list';
-export declare type LinkedListNode<T> = {
+export type LinkedListNode<T> = {
     /** item of node */
     item: T;
     /** previous node. Warning: it is not safe to use this reference on a removed node */

package/data-structures/multi-key-map.d.ts

@@ -1,5 +1,5 @@
 import { Collection } from './collection';
-declare type Node = {
+type Node = {
     nodeKey: any;
     parentNode: Node | undefined;
     hasInnerMap: boolean;
@@ -7,7 +7,7 @@ declare type Node = {
     hasValue: boolean;
     value: any;
 };
-declare type NewMapProvider = () => Map<any, Node>;
+type NewMapProvider = () => Map<any, Node>;
 export declare class MultiKeyMap<K extends any[], T> extends Collection<[K, T], MultiKeyMap<K, T>> implements Map<K, T> {
     private readonly newMapProvider;
     private rootNode;

package/data-structures/sorted-array-list.d.ts

@@ -3,7 +3,7 @@ import { Serializable } from "../serializer";
 import type { Predicate } from "../utils/iterable-helpers/types";
 import { Comparator } from "../utils/sort";
 import { List } from './list';
-export declare type RangeType = 'inclusive' | 'exclusive';
+export type RangeType = 'inclusive' | 'exclusive';
 export declare class SortedArrayList<T extends TComparator, TComparator = T> extends List<T, SortedArrayList<T, TComparator>> implements Serializable<SortedArrayList<T, TComparator>, T[]> {
     private readonly comparator;
     private backingArray;

package/database/entity-repository.d.ts

@@ -1,10 +1,10 @@
 import type { Entity, MaybeNewEntity } from './entity';
 import type { Query, QueryOptions } from './query';
 export declare const repositoryType: unique symbol;
-export declare type UpdateOptions = {
+export type UpdateOptions = {
     upsert?: boolean;
 };
-export declare type EntityPatch<T extends Entity = Entity> = Partial<Omit<T, 'id'>>;
+export type EntityPatch<T extends Entity = Entity> = Partial<Omit<T, 'id'>>;
 export declare abstract class EntityRepository<T extends Entity = Entity> {
     readonly [repositoryType]: T;
     abstract load<U extends T = T>(id: string): Promise<U>;

package/database/entity.d.ts

@@ -1,7 +1,7 @@
-export declare type Entity<Id = string> = {
+export type Entity<Id = string> = {
     id: Id;
 };
-export declare type NewEntity<T extends Entity | MaybeNewEntity = Entity> = Omit<T, 'id'>;
-export declare type MaybeNewEntity<T extends Entity = Entity> = NewEntity<T> & {
+export type NewEntity<T extends Entity | MaybeNewEntity = Entity> = Omit<T, 'id'>;
+export type MaybeNewEntity<T extends Entity = Entity> = NewEntity<T> & {
     id?: T['id'];
 };

package/database/module.d.ts

@@ -1,4 +1,4 @@
-export declare type DatabaseModuleConfig = {
+export type DatabaseModuleConfig = {
     idLength: number;
     idAlphabet: string;
 };

package/database/mongo/classes.d.ts

@@ -4,13 +4,13 @@ import type { Entity } from "..";
 import { Collection as MongoCollection, Db, MongoClient as MongoMongoClient } from 'mongodb';
 import type { MongoDocument } from './model';
 import type { MongoConnection, MongoRepositoryConfig } from './types';
-export declare type MongoClientArgument = MongoConnection;
+export type MongoClientArgument = MongoConnection;
 /** database name */
-export declare type DatabaseArgument = string | {
+export type DatabaseArgument = string | {
     connection?: MongoConnection;
     database?: string;
 };
-export declare type CollectionArgument<T extends Entity<any> = Entity, TDb extends Entity<any> = T> = MongoRepositoryConfig<T, TDb>;
+export type CollectionArgument<T extends Entity<any> = Entity, TDb extends Entity<any> = T> = MongoRepositoryConfig<T, TDb>;
 export declare class MongoClient extends MongoMongoClient implements Injectable<MongoClientArgument> {
     readonly [resolveArgumentType]: MongoClientArgument;
 }

package/database/mongo/model/document.d.ts

@@ -2,13 +2,13 @@ import type { Entity, MaybeNewEntity, NewEntity } from "../..";
 import type { OptionalId, OptionalUnlessRequiredId, WithId } from 'mongodb';
 import type { ProjectedEntity, Projection } from '../mongo-base.repository';
 import { ProjectionMode } from '../mongo-base.repository';
-export declare type MongoDocument<T extends MaybeNewEntity> = OptionalUnlessRequiredId<Omit<T, 'id'> & {
+export type MongoDocument<T extends MaybeNewEntity> = OptionalUnlessRequiredId<Omit<T, 'id'> & {
     _id: T['id'];
 }>;
-export declare type MongoDocumentWithPartialId<T extends MaybeNewEntity> = OptionalId<Omit<T, 'id'> & {
+export type MongoDocumentWithPartialId<T extends MaybeNewEntity> = OptionalId<Omit<T, 'id'> & {
     _id?: T['id'];
 }>;
-export declare type MongoDocumentWithoutId<T extends MaybeNewEntity> = Omit<T, 'id'>;
+export type MongoDocumentWithoutId<T extends MaybeNewEntity> = Omit<T, 'id'>;
 export declare function toEntity<T extends Entity>(document: WithId<MongoDocument<T>> | MongoDocument<T>): T;
 export declare function toNewEntity<T extends MaybeNewEntity>(entity: T): NewEntity<T>;
 export declare function toProjectedEntity<T extends Entity, M extends ProjectionMode, P extends Projection<T, M>>(document: MongoDocument<T> | MongoDocumentWithPartialId<T>): ProjectedEntity<T, M, P>;

package/database/mongo/module.d.ts

@@ -1,5 +1,5 @@
 import type { MongoConnection } from './types';
-export declare type MongoModuleConfig = {
+export type MongoModuleConfig = {
     defaultConnection: MongoConnection;
     defaultDatabase: string | undefined;
     logPrefix: string;

package/database/mongo/mongo-base.repository.d.ts

@@ -8,41 +8,41 @@ export declare const enum ProjectionMode {
     Include = 0,
     Exclude = 1
 }
-export declare type Projection<T, M extends ProjectionMode> = {
+export type Projection<T, M extends ProjectionMode> = {
     [P in keyof T]?: M extends ProjectionMode.Include ? true : false;
 };
-export declare type ProjectedEntity<T, M extends ProjectionMode, P extends Projection<T, M>> = M extends ProjectionMode.Include ? {
+export type ProjectedEntity<T, M extends ProjectionMode, P extends Projection<T, M>> = M extends ProjectionMode.Include ? {
     [K in keyof T]: P[K] extends true ? T[K] : undefined;
 } : {
     [K in keyof T]: P[K] extends false ? undefined : T[K];
 };
-export declare type ReplaceOptions = {
+export type ReplaceOptions = {
     upsert?: boolean;
 };
-export declare type UpdateOptions = {
+export type UpdateOptions = {
     upsert?: boolean;
 };
-export declare type UpdateResult = {
+export type UpdateResult = {
     matchedCount: number;
     modifiedCount: number;
 };
-export declare type LoadOptions<T extends Entity> = {
+export type LoadOptions<T extends Entity> = {
     limit?: number;
     skip?: number;
     sort?: Sort<T>;
 };
-export declare type LoadAndDeleteOptions<T extends Entity> = LoadOptions<T>;
-export declare type LoadManyOptions<T extends Entity> = LoadOptions<T>;
-export declare type LoadAndUpdateOptions<T extends Entity> = LoadOptions<T> & {
+export type LoadAndDeleteOptions<T extends Entity> = LoadOptions<T>;
+export type LoadManyOptions<T extends Entity> = LoadOptions<T>;
+export type LoadAndUpdateOptions<T extends Entity> = LoadOptions<T> & {
     upsert?: boolean;
     returnDocument?: FindOneAndUpdateOptions['returnDocument'];
     sort?: Sort<T>;
 };
-export declare type CountOptions = {
+export type CountOptions = {
     limit?: number;
     skip?: number;
 };
-export declare type InsertIfNotExistsByFilterItem<T extends Entity> = {
+export type InsertIfNotExistsByFilterItem<T extends Entity> = {
     filter: Filter<T>;
     entity: MaybeNewEntity<T>;
 };

package/database/mongo/mongo-bulk.d.ts

@@ -3,7 +3,7 @@ import type { BulkWriteResult } from 'mongodb';
 import type { Collection } from './classes';
 import type { ReplaceOptions, UpdateOptions } from './mongo-base.repository';
 import type { Filter, UpdateFilter } from './types';
-export declare type BulkResult = {
+export type BulkResult = {
     insertedCount: number;
     matchedCount: number;
     modifiedCount: number;

package/database/mongo/mongo-entity-repository.d.ts

@@ -6,21 +6,21 @@ import type { Logger } from "../../logger";
 import type { Collection } from './classes';
 import { MongoBaseRepository } from './mongo-base.repository';
 import type { TypedIndexDescription } from './types';
-export declare type MongoEntityRepositoryOptions<T extends Entity<any>> = {
+export type MongoEntityRepositoryOptions<T extends Entity<any>> = {
     logger: Logger;
     indexes?: TypedIndexDescription<T>[];
 };
-export declare type MappingItemTransformer<T extends Entity<any> = any, TKey extends keyof T = any> = (value: T[TKey]) => any;
-export declare type MappingItem<T extends Entity<any>, TDb extends Entity<any>, TKey extends keyof T = keyof T, TDbKey extends keyof TDb = keyof TDb> = {
+export type MappingItemTransformer<T extends Entity<any> = any, TKey extends keyof T = any> = (value: T[TKey]) => any;
+export type MappingItem<T extends Entity<any>, TDb extends Entity<any>, TKey extends keyof T = keyof T, TDbKey extends keyof TDb = keyof TDb> = {
     key: TDbKey;
     transform: MappingItemTransformer<T, TKey>;
 };
 export declare function mapTo<T extends Entity<any>, TDb extends Entity<any>, TKey extends keyof T, TDbKey extends keyof TDb>(key: TDbKey, transform: (value: T[TKey]) => TDb[TDbKey]): MappingItem<T, TDb, TKey, TDbKey>;
-export declare type TransformerMapping<T extends Entity<any>, TDb extends Entity<any>> = {
+export type TransformerMapping<T extends Entity<any>, TDb extends Entity<any>> = {
     [P in keyof T]?: MappingItem<T, TDb, P>;
 };
-export declare type TransformerMappingMap<T extends Entity<any> = any, TDb extends Entity<any> = any> = Map<keyof T, MappingItem<T, TDb>>;
-export declare type EntityTransformer<T extends Entity<any>, TDb extends Entity<any>> = {
+export type TransformerMappingMap<T extends Entity<any> = any, TDb extends Entity<any> = any> = Map<keyof T, MappingItem<T, TDb>>;
+export type EntityTransformer<T extends Entity<any>, TDb extends Entity<any>> = {
     /**
      * function to transform the base entity to the mongo entity
      */
@@ -34,7 +34,7 @@ export declare type EntityTransformer<T extends Entity<any>, TDb extends Entity<
      */
     mapping?: TransformerMapping<T, TDb>;
 };
-export declare type InsertIfNotExistsByQueryItem<T extends Entity<any>> = {
+export type InsertIfNotExistsByQueryItem<T extends Entity<any>> = {
     query: Query<T>;
     entity: MaybeNewEntity<T>;
 };

package/database/mongo/types.d.ts

@@ -2,10 +2,10 @@ import type { Entity } from "..";
 import type { Paths, TypedOmit } from "../../types";
 import type * as Mongo from 'mongodb';
 import type { MongoDocument } from './model';
-export declare type MongoConnection = {
+export type MongoConnection = {
     url: string;
 } & Mongo.MongoClientOptions;
-export declare type MongoRepositoryConfig<T extends Entity, TDb extends Entity = T> = {
+export type MongoRepositoryConfig<T extends Entity, TDb extends Entity = T> = {
     connection?: MongoConnection;
     database?: string;
     collection: string;
@@ -14,34 +14,34 @@ export declare type MongoRepositoryConfig<T extends Entity, TDb extends Entity =
         database: TDb;
     };
 };
-export declare type Filter<T extends Entity = Entity> = Mongo.Filter<MongoDocument<T>>;
-export declare type UpdateFilter<T extends Entity = Entity> = Mongo.UpdateFilter<MongoDocument<T>>;
-export declare type BulkOperation<T extends Entity = Entity> = InsertOneOperation<T> | ReplaceOneOperation<T> | UpdateOneOperation<T> | UpdateManyOperation<T> | DeleteOneOperation<T> | DeleteManyOperation<T>;
-export declare type InsertOneOperation<T extends Entity = Entity> = {
+export type Filter<T extends Entity = Entity> = Mongo.Filter<MongoDocument<T>>;
+export type UpdateFilter<T extends Entity = Entity> = Mongo.UpdateFilter<MongoDocument<T>>;
+export type BulkOperation<T extends Entity = Entity> = InsertOneOperation<T> | ReplaceOneOperation<T> | UpdateOneOperation<T> | UpdateManyOperation<T> | DeleteOneOperation<T> | DeleteManyOperation<T>;
+export type InsertOneOperation<T extends Entity = Entity> = {
     insertOne: Mongo.InsertOneModel<MongoDocument<T>>;
 };
-export declare type ReplaceOneOperation<T extends Entity = Entity> = {
+export type ReplaceOneOperation<T extends Entity = Entity> = {
     replaceOne: Mongo.ReplaceOneModel<MongoDocument<T>>;
 };
-export declare type UpdateOneOperation<T extends Entity = Entity> = {
+export type UpdateOneOperation<T extends Entity = Entity> = {
     updateOne: Mongo.UpdateOneModel<MongoDocument<T>>;
 };
-export declare type UpdateManyOperation<T extends Entity = Entity> = {
+export type UpdateManyOperation<T extends Entity = Entity> = {
     updateMany: Mongo.UpdateManyModel<MongoDocument<T>>;
 };
-export declare type DeleteOneOperation<T extends Entity = Entity> = {
+export type DeleteOneOperation<T extends Entity = Entity> = {
     deleteOne: Mongo.DeleteOneModel<MongoDocument<T>>;
 };
-export declare type DeleteManyOperation<T extends Entity = Entity> = {
+export type DeleteManyOperation<T extends Entity = Entity> = {
     deleteMany: Mongo.DeleteManyModel<MongoDocument<T>>;
 };
-export declare type SortObject<T extends Entity = Entity> = {
+export type SortObject<T extends Entity = Entity> = {
     [P in keyof MongoDocument<T>]?: 1 | -1;
 };
-export declare type SortArrayItem<T extends Entity = Entity> = [keyof MongoDocument<T> & string, 1 | -1];
-export declare type SortArray<T extends Entity = Entity> = SortArrayItem<T>[];
-export declare type Sort<T extends Entity = Entity> = SortArray<T> | SortObject<T>;
-export declare type TypedIndexDescription<T extends Entity = Entity> = Omit<Mongo.IndexDescription, 'key' | 'partialFilterExpression'> & {
+export type SortArrayItem<T extends Entity = Entity> = [keyof MongoDocument<T> & string, 1 | -1];
+export type SortArray<T extends Entity = Entity> = SortArrayItem<T>[];
+export type Sort<T extends Entity = Entity> = SortArray<T> | SortObject<T>;
+export type TypedIndexDescription<T extends Entity = Entity> = Omit<Mongo.IndexDescription, 'key' | 'partialFilterExpression'> & {
     key: {
         [P in Paths<T>]?: Mongo.IndexDirection;
     };