@punks/backend-entity-manager 0.0.29 → 0.0.31

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="qs" />
 /// <reference types="express" />
-import { Type as Type$1, INestApplicationContext, ExceptionFilter, ArgumentsHost, NestMiddleware } from '@nestjs/common';
+import { Type as Type$1, INestApplicationContext, DynamicModule, ExceptionFilter, ArgumentsHost, NestMiddleware } from '@nestjs/common';
 import { Module } from '@nestjs/core/injector/module';
 import { ModulesContainer } from '@nestjs/core/injector/modules-container';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
+import { JwtService } from '@nestjs/jwt';
 import { ObjectLiteral, FindOneOptions, FindManyOptions, Repository, ObjectId, FindOptionsWhere, FindOptionsRelations } from 'typeorm';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { ModulesContainer as ModulesContainer$1 } from '@nestjs/core';
@@ -326,6 +327,10 @@ declare class EntitiesServiceLocator {
     getProvider(): ServiceLocator;
     resolveEventEmitter<TEventEmitter extends IEventEmitter>(): TEventEmitter;
     registerEventEmitter<TEventEmitter extends IEventEmitter>(instance: TEventEmitter): void;
+    resolveEmailProvider<TEmailProvider extends IEmailProvider>(): TEmailProvider;
+    registerEmailProvider<TEmailProvider extends IEmailProvider>(instance: TEmailProvider): void;
+    resolveEmailTemplatesCollection(): IEmailTemplatesCollection;
+    registerEmailTemplatesCollection(instance: IEmailTemplatesCollection): void;
     resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
     registerAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(instance: TAuthenticationContextProvider): void;
     resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
@@ -414,6 +419,37 @@ interface IEntityManagerServiceCollection<TEntity, TEntityId> {
     }): IEntityManagerServiceCollection<TEntity, TEntityId>;
 }
 
+interface IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload> {
+    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
+    getTemplateData(payload: TAugmentedPayload): Promise<TTemplateData>;
+}
+interface IEmailTemplatesCollection {
+    registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
+    getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
+}
+type TemplatedEmailInput<TPayload> = {
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject?: string;
+    templateId: string;
+    payload: TPayload;
+};
+interface HtmlEmailInput<TPayload> {
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject: string;
+    htmlTemplate: string;
+    payload: TPayload;
+}
+interface IEmailProvider {
+    sendTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
+    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
+}
+
 declare class EntityManagerException extends Error {
     constructor(message: string);
 }
@@ -442,6 +478,9 @@ declare class EntityNotFoundException<TEntityId> extends EntityManagerException
 declare class MultipleEntitiesFoundException extends EntityManagerException {
     constructor();
 }
+declare class EntityManagerConfigurationError extends EntityManagerException {
+    constructor(message: string);
+}
 
 type FilterExpression<TEntity> = (entity: TEntity) => boolean;
 
@@ -493,11 +532,18 @@ interface EntityConverterProps {
 }
 declare const WpEntityConverter: (entityName: string, props?: Omit<EntityConverterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
+interface EmailTemplateProps {
+    templateId: string;
+}
+declare const WpEmailTemplate: (templateId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
 interface EntityProps {
     name: string;
 }
 declare const WpEntity: (name: string, props?: Omit<EntityProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
+declare const WpAppInitializer: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
 interface EntityRepositoryProps {
     entityName: string;
 }
@@ -514,6 +560,7 @@ interface EntityQueryBuilderProps {
 declare const WpEntityQueryBuilder: (entityName: string, props?: Omit<EntityQueryBuilderProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
 declare const EntityManagerSymbols: {
+    AppInitializer: symbol;
     Entity: symbol;
     EntityActions: symbol;
     EntityAdapter: symbol;
@@ -523,6 +570,8 @@ declare const EntityManagerSymbols: {
     EntityConverter: symbol;
     EntityManager: symbol;
     EntityQueryBuilder: symbol;
+    EmailProvider: symbol;
+    EmailTemplate: symbol;
 };
 
 interface DiscoveredModule<T = object> {
@@ -577,6 +626,7 @@ declare class CustomDiscoveryService {
      * @param metaKey The metakey to scan for
      */
     providersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
+    providerWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T> | undefined>;
     /**
      * Discovers all controllers in a Nest App that match a filter
      * @param filter
@@ -642,7 +692,373 @@ declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData,
     get provider(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets>;
 }
 
+interface IAuthenticationService {
+}
+interface IUserProfile {
+    firstName: string;
+    lastName: string;
+}
+interface IUserOrganization {
+    id: string;
+    uid: string;
+    name: string;
+}
+interface IUser {
+    id: string;
+    passwordHash: string;
+    passwordUpdateTimestamp?: Date;
+    temporaryPassword: boolean;
+    userName: string;
+    email: string;
+    verified: boolean;
+    verifiedTimestamp?: Date;
+    disabled: boolean;
+    profile: IUserProfile;
+    organization?: IUserOrganization;
+}
+interface IUserContext {
+    organizationUid?: string;
+}
+interface IUserService<TUser extends IUser, TUserContext extends IUserContext, TUserRegistrationInfo> {
+    getById(id: string): Promise<TUser>;
+    getByEmail(email: string, context?: TUserContext): Promise<TUser>;
+    getByUserName(userName: string, context?: TUserContext): Promise<TUser>;
+    update(id: string, data: Partial<TUser>): Promise<void>;
+    delete(id: string): Promise<void>;
+    create(email: string, data: TUserRegistrationInfo, context?: TUserContext): Promise<TUser>;
+}
+interface IUserTokenData<TContext extends IUserContext> {
+    userId: string;
+    email: string;
+    context?: TContext;
+}
+
+declare const AuthenticationExtensionSymbols: {
+    UserService: symbol;
+};
+
+declare const WpUserService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const AuthenticationEmailTemplates: {
+    Registration: string;
+    PasswordReset: string;
+    EmailVerify: string;
+};
+type RegistrationEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
+};
+type EmailVerifyEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
+};
+type PasswordResetEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
+};
+
+declare class AuthenticationError extends Error {
+    constructor(message: string);
+}
+declare class InvalidCredentialsError extends AuthenticationError {
+    constructor(message: string);
+}
+declare class OperationTokenMismatchError extends AuthenticationError {
+    constructor(message: string);
+}
+
+interface UserTokenVerifyResult<TUserContext extends IUserContext> {
+    isValid: boolean;
+    data: IUserTokenData<TUserContext>;
+}
+interface UserTokenVerifyInput {
+    token: string;
+}
+
+interface UserVerifyRequestInput<TUserContext extends IUserContext> {
+    email: string;
+    callback: CallbackTemplate$2;
+    context?: TUserContext;
+}
+interface UserVerifyResetRequestResult {
+    success: boolean;
+}
+type CallbackTemplate$2 = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+
+type CallbackTemplate$1 = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+interface UserPasswordResetRequestInput<TUserContext extends IUserContext> {
+    email: string;
+    callback: CallbackTemplate$1;
+    context?: TUserContext;
+}
+interface UserPasswordResetRequestResult {
+    success: boolean;
+}
+
+interface UserLoginInput<TUserContext extends IUserContext> {
+    userName: string;
+    password: string;
+    context?: TUserContext;
+}
+interface UserLoginResult {
+    token?: string;
+    success: boolean;
+}
+
+declare class AppSessionService {
+    getValue<T>(key: string): T;
+    setValue<T>(key: string, value: T): void;
+    clearValue(key: string): void;
+    getRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+    private getSession;
+}
+
+declare class AppHashingService {
+    hash(value: string, salt: string): Promise<string>;
+    compare(hash: string, value: string, salt: string): Promise<boolean>;
+}
+
+declare class EntityManagerService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
+    getActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
+    getRepository<TEntity>(entityName: string): IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
+}
+
+declare class EmailService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    sendTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
+    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
+    private get provider();
+}
+
+declare class AuthenticationServicesResolver {
+    private usersService;
+    registerUsersService(usersService: IUserService<any, any, any>): void;
+    getUsersService<TUser extends IUser, TUserRegistrationInfo>(): IUserService<TUser, any, TUserRegistrationInfo>;
+}
+
+declare class JwtProvider {
+    private readonly jwtService;
+    constructor(jwtService: JwtService);
+    sign<T extends object>(payload: T): Promise<string>;
+    parse<T extends object>(token: string): Promise<T>;
+    verify<T extends object>(token: string): Promise<T>;
+}
+
+interface AuthenticationModuleSettings {
+    passwordSalt: string;
+    jwtSecret: string;
+}
+type UserPasswordResetTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
+};
+type EmailVerifyTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
+};
+declare enum UserRegistrationError {
+    UserAlreadyExists = 0
+}
+
+declare class PasswordHashingProvider {
+    private readonly hashing;
+    constructor(hashing: AppHashingService);
+    hashPassword(input: {
+        password: string;
+        userId: string;
+    }): Promise<string>;
+    verifyPassword(input: {
+        password: string;
+        userId: string;
+        hash: string;
+    }): Promise<{
+        isMatching: boolean;
+    }>;
+    private buildUserSalt;
+}
+
+type CallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+interface UserRegistrationInput<TUserRegistrationInfo, TUserContext extends IUserContext> {
+    email: string;
+    password: string;
+    registrationInfo: TUserRegistrationInfo;
+    callback: CallbackTemplate;
+    context?: TUserContext;
+}
+
+declare class UserRegistrationHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly emailService;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserRegistrationInfo, TContext extends IUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TContext>): Promise<{
+        success: boolean;
+        error: UserRegistrationError;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    private createPasswordHash;
+    private sendRegistrationEmail;
+    private generateEmailVerifyToken;
+    private createUser;
+    private resolveUser;
+}
+
+interface UserDisableInput {
+    userId: string;
+}
+
+declare class UserDisableHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserDisableInput): Promise<void>;
+}
+
+interface UserEnableInput {
+    userId: string;
+}
+
+declare class UserEnableHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserEnableInput): Promise<void>;
+}
+
+declare class UserLoginHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
+    execute<TUserContext extends IUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
+    private generateUserJwtToken;
+    private resolveUser;
+}
+
+interface UserPasswordChangeInput {
+    userId: string;
+    newPassword: string;
+    temporary: boolean;
+}
+
+declare class UserPasswordChangeHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
+    execute(input: UserPasswordChangeInput): Promise<void>;
+}
+
+interface UserPasswordResetCompleteInput {
+    token: string;
+    newPassword: string;
+    temporary?: boolean;
+}
+
+declare class UserPasswordResetCompleteHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
+    execute(input: UserPasswordResetCompleteInput): Promise<void>;
+    private decodeToken;
+    private validateUser;
+    private getUser;
+}
+
+declare class UserPasswordResetRequestHandler {
+    private readonly services;
+    private readonly emailService;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserContext extends IUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
+    private sendPasswordResetEmail;
+    private generatePasswordResetToken;
+    private resolveUser;
+}
+
+interface UserVerifyCompleteInput {
+    token: string;
+}
+
+declare class UserVerifyCompleteHandler {
+    private readonly services;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
+    execute(input: UserVerifyCompleteInput): Promise<void>;
+    private decodeToken;
+    private validateUser;
+    private getUser;
+}
+
+declare class UserTokenVerifyHandler {
+    private readonly jwtProvider;
+    constructor(jwtProvider: JwtProvider);
+    execute<TUserContext extends IUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
+    private decodeUserJwtToken;
+}
+
+declare class UserVerifyRequestHandler {
+    private readonly services;
+    private readonly emailService;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserContext extends IUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyResetRequestResult>;
+    private sendEmailVerifyEmail;
+    private generateEmailVerifyToken;
+    private resolveUser;
+}
+
+declare class AuthenticationService implements IAuthenticationService {
+    private readonly userDisableHandler;
+    private readonly userEnableHandler;
+    private readonly userLoginHandler;
+    private readonly userPasswordChangeHandler;
+    private readonly userPasswordResetFinalizeHandler;
+    private readonly userPasswordResetRequestHandler;
+    private readonly userRegistrationHandler;
+    private readonly userTokenVerifyHandler;
+    private readonly userVerifyRequestHandler;
+    private readonly userVerifyCompleteHandler;
+    constructor(userDisableHandler: UserDisableHandler, userEnableHandler: UserEnableHandler, userLoginHandler: UserLoginHandler, userPasswordChangeHandler: UserPasswordChangeHandler, userPasswordResetFinalizeHandler: UserPasswordResetCompleteHandler, userPasswordResetRequestHandler: UserPasswordResetRequestHandler, userRegistrationHandler: UserRegistrationHandler, userTokenVerifyHandler: UserTokenVerifyHandler, userVerifyRequestHandler: UserVerifyRequestHandler, userVerifyCompleteHandler: UserVerifyCompleteHandler);
+    userDisable(input: UserDisableInput): Promise<void>;
+    userEnable(input: UserEnableInput): Promise<void>;
+    userLogin<TUserContext extends IUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
+    userPasswordChange(input: UserPasswordChangeInput): Promise<void>;
+    userPasswordResetFinalize(input: UserPasswordResetCompleteInput): Promise<void>;
+    userPasswordResetRequest<TUserContext extends IUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
+    userRegister<TUserRegistrationInfo, TUserContext extends IUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TUserContext>): Promise<{
+        success: boolean;
+        error: UserRegistrationError;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    userVerifyRequest<TUserContext extends IUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyResetRequestResult>;
+    userVerifyComplete(input: UserVerifyCompleteInput): Promise<void>;
+    userTokenVerify<TUserContext extends IUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
+}
+
 declare class AuthenticationModule {
+    static forRoot(input: AuthenticationModuleSettings): DynamicModule;
 }
 
 declare class MultiTenancyModule {
@@ -735,30 +1151,29 @@ declare class EntityManagerInitializer {
     private readonly logger;
     constructor(discover: CustomDiscoveryService, registry: EntityManagerRegistry, eventEmitter: NestEventEmitter);
     initialize(app: INestApplicationContext, staticProviders: EntityManagerStaticProviders): Promise<void>;
+    private registerAuthentication;
+    private registerEntities;
+    private executeInitializers;
+    private registerEmailProviders;
+    private registerEmailTemplates;
     private initializeProviders;
-    private discoverEntities;
     private discoverRepositories;
     private discoverQueryBuilders;
     private discoverConverters;
     private discoverAdapters;
     private discoverAuthMiddlewares;
+    private discoverAppInitializers;
+    private discoverEmailTemplates;
+    private discoverEmailProviders;
 }
 
 declare class AppSessionMiddleware implements NestMiddleware {
     use(req: Request, res: Response, next: NextFunction): void;
 }
 
-declare class AppSessionService {
-    getValue<T>(key: string): T;
-    setValue<T>(key: string, value: T): void;
-    clearValue(key: string): void;
-    getRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
-    private getSession;
-}
-
 declare class EntityManagerModule {
 }
 
 declare const newUuid: () => string;
 
-export { AppExceptionsFilterBase, AppSessionMiddleware, AppSessionService, AuthenticationModule, EntityActionsProps, EntityAdapterProps, EntityAuthMiddlewareProps, EntityConnectorProps, EntityConverterProps, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityProps, EntityQueryBuilderProps, EntityRepositoryProps, FilterExpression, IAuthenticationContext, IAuthenticationContextProvider, IAuthorizationResult, IEntitiesQueryBuilder, IEntitiesSearchAction, IEntitiesSearchQuery, IEntitiesSearchResults, IEntitiesSearchResultsPaging, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateCommand, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityGetAction, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntityUpdateAction, IEntityUpdateCommand, IEntityUpsertAction, IEntityUpsertCommand, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmQueryBuilder, NestTypeOrmRepository, QueryBuilderBase, ReplicaConfiguration, ReplicaOptions, ReplicationMode, RuntimeErrorInformation, SortDirection, SortingType, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, newUuid };
+export { AppExceptionsFilterBase, AppHashingService, AppSessionMiddleware, AppSessionService, AuthenticationEmailTemplates, AuthenticationError, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationModuleSettings, AuthenticationService, EmailService, EmailTemplateProps, EmailVerifyEmailPayload, EmailVerifyTokenPayload, EntityActionsProps, EntityAdapterProps, EntityAuthMiddlewareProps, EntityConnectorProps, EntityConverterProps, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityProps, EntityQueryBuilderProps, EntityRepositoryProps, FilterExpression, HtmlEmailInput, IAuthenticationContext, IAuthenticationContextProvider, IAuthenticationService, IAuthorizationResult, IEmailProvider, IEmailTemplate, IEmailTemplatesCollection, IEntitiesQueryBuilder, IEntitiesSearchAction, IEntitiesSearchQuery, IEntitiesSearchResults, IEntitiesSearchResultsPaging, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateCommand, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityGetAction, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntityUpdateAction, IEntityUpdateCommand, IEntityUpsertAction, IEntityUpsertCommand, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, IUser, IUserContext, IUserOrganization, IUserProfile, IUserService, IUserTokenData, InvalidCredentialsError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmQueryBuilder, NestTypeOrmRepository, OperationTokenMismatchError, PasswordResetEmailPayload, QueryBuilderBase, RegistrationEmailPayload, ReplicaConfiguration, ReplicaOptions, ReplicationMode, RuntimeErrorInformation, SortDirection, SortingType, TemplatedEmailInput, UserPasswordResetTokenPayload, UserRegistrationError, WpAppInitializer, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpUserService, newUuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punks/backend-entity-manager",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -29,19 +29,23 @@
     "@nestjs/common": "^10.1.0",
     "@nestjs/core": "^10.1.0",
     "@nestjs/event-emitter": "^2.0.0",
+    "@nestjs/jwt": "^10.1.0",
     "@nestjs/platform-express": "^10.1.0",
     "@nestjs/swagger": "^7.1.2",
     "@nestjs/testing": "^10.1.0",
     "@nestjs/typeorm": "^10.0.0",
+    "@punks/backend-core": "^0.0.12",
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^13.0.6",
     "@rollup/plugin-typescript": "^11.0.0",
+    "@types/bcrypt": "^5.0.0",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.2",
     "@types/lodash": "^4.14.195",
     "@types/supertest": "^2.0.12",
     "async_hooks": "^1.0.0",
+    "bcrypt": "^5.1.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "express": "^4.18.2",
@@ -65,11 +69,13 @@
     "@nestjs/common": "^10.1.0",
     "@nestjs/core": "^10.1.0",
     "@nestjs/event-emitter": "^2.0.0",
+    "@nestjs/jwt": "^10.1.0",
     "@nestjs/platform-express": "^10.1.0",
     "@nestjs/swagger": "^7.1.2",
     "@nestjs/testing": "^10.1.0",
     "@nestjs/typeorm": "^10.0.0",
     "@punks/backend-core": "0.0.12",
+    "bcrypt": "^5.1.0",
     "typeorm": "^0.3.17"
   },
   "dependencies": {},

package/readme.md

@@ -11,7 +11,7 @@ npm install @punks/backend-entity-manager @punks/backend-core class-transformer
 ## Add authentication
 
 ```bash
-npm install express async_hooks @nestjs/platform-express
+npm install express async_hooks @nestjs/platform-express @nestjs/jwt
 ```
 
 ## Supported ORMs:

package/dist/cjs/types/platforms/nest/__test__/server/authentication/index.d.ts

@@ -1,13 +0,0 @@
-import { IAuthenticationContext, IAuthenticationContextProvider } from "../../../../../abstractions";
-export type AppUserContext = {
-    email: string;
-};
-export declare class AppAuthContext implements IAuthenticationContext<AppUserContext> {
-    isAuthenticated: boolean;
-    isAnonymous: boolean;
-    userId?: string;
-    userContext?: AppUserContext;
-}
-export declare class AppAuthContextProvider implements IAuthenticationContextProvider<AppUserContext> {
-    getContext(): Promise<IAuthenticationContext<AppUserContext>>;
-}

package/dist/esm/types/platforms/nest/__test__/server/authentication/index.d.ts

@@ -1,13 +0,0 @@
-import { IAuthenticationContext, IAuthenticationContextProvider } from "../../../../../abstractions";
-export type AppUserContext = {
-    email: string;
-};
-export declare class AppAuthContext implements IAuthenticationContext<AppUserContext> {
-    isAuthenticated: boolean;
-    isAnonymous: boolean;
-    userId?: string;
-    userContext?: AppUserContext;
-}
-export declare class AppAuthContextProvider implements IAuthenticationContextProvider<AppUserContext> {
-    getContext(): Promise<IAuthenticationContext<AppUserContext>>;
-}