@punks/backend-entity-manager 0.0.28 → 0.0.30

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-enable/index.d.ts

@@ -0,0 +1,9 @@
+import { AuthenticationServicesResolver } from "../../resolver";
+export interface UserEnableInput {
+    userId: string;
+}
+export declare class UserEnableHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserEnableInput): Promise<void>;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-login/index.d.ts

@@ -0,0 +1,22 @@
+import { PasswordHashingProvider } from "../../providers/password-hasher";
+import { AuthenticationServicesResolver } from "../../resolver";
+import { JwtProvider } from "../../providers/jwt";
+import { IUserContext } from "../../abstractions";
+export interface UserLoginInput<TUserContext extends IUserContext> {
+    userName: string;
+    password: string;
+    context?: TUserContext;
+}
+export interface UserLoginResult {
+    token?: string;
+    success: boolean;
+}
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-password-change/index.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticationServicesResolver } from "../../resolver";
+import { PasswordHashingProvider } from "../../providers/password-hasher";
+export interface UserPasswordChangeInput {
+    userId: string;
+    newPassword: string;
+    temporary: boolean;
+}
+export declare class UserPasswordChangeHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
+    execute(input: UserPasswordChangeInput): Promise<void>;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-password-reset-complete/index.d.ts

@@ -0,0 +1,18 @@
+import { AuthenticationServicesResolver } from "../../resolver";
+import { JwtProvider } from "../../providers/jwt";
+import { PasswordHashingProvider } from "../../providers/password-hasher";
+export interface UserPasswordResetCompleteInput {
+    token: string;
+    newPassword: string;
+    temporary?: boolean;
+}
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-password-reset-request/index.d.ts

@@ -0,0 +1,26 @@
+import { EmailService } from "../../../../services";
+import { IUserContext } from "../../abstractions";
+import { AuthenticationServicesResolver } from "../../resolver";
+import { JwtProvider } from "../../providers/jwt";
+export type CallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+export interface UserPasswordResetRequestInput<TUserContext extends IUserContext> {
+    email: string;
+    callback: CallbackTemplate;
+    context?: TUserContext;
+}
+export interface UserPasswordResetRequestResult {
+    success: boolean;
+}
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-register/index.d.ts

@@ -0,0 +1,42 @@
+import { IUserContext } from "../../abstractions";
+import { EmailService } from "../../../../services";
+import { AuthenticationServicesResolver } from "../../resolver";
+import { JwtProvider } from "../../providers/jwt";
+import { PasswordHashingProvider } from "../../providers/password-hasher";
+export type CallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+export interface UserRegistrationInput<TUserRegistrationInfo, TUserContext extends IUserContext> {
+    email: string;
+    password: string;
+    registrationInfo: TUserRegistrationInfo;
+    callback: CallbackTemplate;
+    context?: TUserContext;
+}
+export declare enum UserRegistrationError {
+    UserAlreadyExists = 0
+}
+export interface UserRegistrationResult {
+    success: boolean;
+    error?: UserRegistrationError;
+}
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-token-verify/index.d.ts

@@ -0,0 +1,15 @@
+import { JwtProvider } from "../../providers/jwt";
+import { IUserContext, IUserTokenData } from "../../abstractions";
+export interface UserTokenVerifyResult<TUserContext extends IUserContext> {
+    isValid: boolean;
+    data: IUserTokenData<TUserContext>;
+}
+export interface UserTokenVerifyInput {
+    token: string;
+}
+export declare class UserTokenVerifyHandler {
+    private readonly jwtProvider;
+    constructor(jwtProvider: JwtProvider);
+    execute<TUserContext extends IUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
+    private decodeUserJwtToken;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-verify-complete/index.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticationServicesResolver } from "../../resolver";
+import { JwtProvider } from "../../providers/jwt";
+export interface UserVerifyCompleteInput {
+    token: string;
+}
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/handlers/user-verify-request/index.d.ts

@@ -0,0 +1,26 @@
+import { IUserContext } from "../../abstractions";
+import { EmailService } from "../../../../services";
+import { JwtProvider } from "../../providers/jwt";
+import { AuthenticationServicesResolver } from "../../resolver";
+export type CallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+export interface UserVerifyRequestInput<TUserContext extends IUserContext> {
+    email: string;
+    callback: CallbackTemplate;
+    context?: TUserContext;
+}
+export interface UserVerifyResetRequestResult {
+    success: boolean;
+}
+export 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;
+}

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

@@ -1 +1,7 @@
+export * from "./abstractions";
+export * from "./decorators";
+export * from "./email";
+export * from "./errors";
+export * from "./services";
+export * from "./types";
 export { AuthenticationModule } from "./module";

package/dist/esm/types/platforms/nest/extensions/authentication/initializer/index.d.ts

@@ -0,0 +1,12 @@
+import { INestApplicationContext } from "@nestjs/common";
+import { IAppInitializer } from "../../../../../abstractions/app";
+import { CustomDiscoveryService } from "../../../ioc/discovery";
+import { AuthenticationServicesResolver } from "../resolver";
+export declare class AuthenticationInitializer implements IAppInitializer {
+    private readonly discover;
+    private readonly registry;
+    private readonly logger;
+    constructor(discover: CustomDiscoveryService, registry: AuthenticationServicesResolver);
+    initialize(app: INestApplicationContext): Promise<void>;
+    private discoverUserService;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/module.d.ts

@@ -1,2 +1,5 @@
+import { DynamicModule } from "@nestjs/common";
+import { AuthenticationModuleSettings } from "./types";
 export declare class AuthenticationModule {
+    static forRoot(input: AuthenticationModuleSettings): DynamicModule;
 }

package/dist/esm/types/platforms/nest/extensions/authentication/providers/index.d.ts

@@ -0,0 +1,3 @@
+import { JwtProvider } from "./jwt";
+import { PasswordHashingProvider } from "./password-hasher";
+export declare const AuthenticationProviders: (typeof JwtProvider | typeof PasswordHashingProvider)[];

package/dist/esm/types/platforms/nest/extensions/authentication/providers/jwt/index.d.ts

@@ -0,0 +1,8 @@
+import { JwtService } from "@nestjs/jwt";
+export 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>;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/providers/password-hasher/index.d.ts

@@ -0,0 +1,17 @@
+import { AppHashingService } from "../../../../services/hashing";
+export 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;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/resolver/index.d.ts

@@ -0,0 +1,6 @@
+import { IUser, IUserService } from "../abstractions";
+export declare class AuthenticationServicesResolver {
+    private usersService;
+    registerUsersService(usersService: IUserService<any, any, any>): void;
+    getUsersService<TUser extends IUser, TUserRegistrationInfo>(): IUserService<TUser, any, TUserRegistrationInfo>;
+}

package/dist/esm/types/platforms/nest/extensions/authentication/services/authentication/index.d.ts

@@ -1,3 +1,40 @@
-import { IAuthenticationService } from "../../abstractions";
+import { IAuthenticationService, IUserContext } from "../../abstractions";
+import { UserRegistrationInput, UserRegistrationHandler } from "../../handlers/user-register";
+import { UserDisableHandler, UserDisableInput } from "../../handlers/user-disable";
+import { UserEnableHandler, UserEnableInput } from "../../handlers/user-enable";
+import { UserLoginHandler, UserLoginInput } from "../../handlers/user-login";
+import { UserPasswordChangeHandler, UserPasswordChangeInput } from "../../handlers/user-password-change";
+import { UserPasswordResetCompleteHandler, UserPasswordResetCompleteInput } from "../../handlers/user-password-reset-complete";
+import { UserPasswordResetRequestHandler, UserPasswordResetRequestInput } from "../../handlers/user-password-reset-request";
+import { UserVerifyCompleteHandler, UserVerifyCompleteInput } from "../../handlers/user-verify-complete";
+import { UserTokenVerifyHandler, UserTokenVerifyInput } from "../../handlers/user-token-verify";
+import { UserVerifyRequestHandler, UserVerifyRequestInput } from "../../handlers/user-verify-request";
 export 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<import("../../handlers/user-login").UserLoginResult>;
+    userPasswordChange(input: UserPasswordChangeInput): Promise<void>;
+    userPasswordResetFinalize(input: UserPasswordResetCompleteInput): Promise<void>;
+    userPasswordResetRequest<TUserContext extends IUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<import("../../handlers/user-password-reset-request").UserPasswordResetRequestResult>;
+    userRegister<TUserRegistrationInfo, TUserContext extends IUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TUserContext>): Promise<{
+        success: boolean;
+        error: import("../../handlers/user-register").UserRegistrationError;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    userVerifyRequest<TUserContext extends IUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<import("../../handlers/user-verify-request").UserVerifyResetRequestResult>;
+    userVerifyComplete(input: UserVerifyCompleteInput): Promise<void>;
+    userTokenVerify<TUserContext extends IUserContext>(input: UserTokenVerifyInput): Promise<import("../../handlers/user-token-verify").UserTokenVerifyResult<TUserContext>>;
 }

package/dist/esm/types/platforms/nest/extensions/authentication/settings/index.d.ts

@@ -0,0 +1,3 @@
+import { AuthenticationModuleSettings } from "../types";
+export declare const setAuthSettings: (input: AuthenticationModuleSettings) => void;
+export declare const getAuthSettings: () => AuthenticationModuleSettings;

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

@@ -0,0 +1,14 @@
+export interface AuthenticationModuleSettings {
+    passwordSalt: string;
+    jwtSecret: string;
+}
+export type UserPasswordResetTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
+};
+export type EmailVerifyTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
+};

package/dist/esm/types/platforms/nest/ioc/discovery/index.d.ts

@@ -66,6 +66,7 @@ export 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

package/dist/esm/types/platforms/nest/processors/initializer/index.d.ts

@@ -17,11 +17,18 @@ export 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;
 }

package/dist/esm/types/platforms/nest/providers/email-templates/index.d.ts

@@ -0,0 +1,6 @@
+import { IEmailTemplate } from "../../../../abstractions";
+export declare class EmailTemplatesCollection {
+    private readonly _collection;
+    registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
+    getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
+}

package/dist/esm/types/platforms/nest/services/email/index.d.ts

@@ -0,0 +1,9 @@
+import { EntityManagerRegistry } from "../../ioc";
+import { HtmlEmailInput, TemplatedEmailInput } from "../../../../abstractions";
+export 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();
+}

package/dist/esm/types/platforms/nest/services/hashing/index.d.ts

@@ -0,0 +1,4 @@
+export declare class AppHashingService {
+    hash(value: string, salt: string): Promise<string>;
+    compare(hash: string, value: string, salt: string): Promise<boolean>;
+}

package/dist/esm/types/platforms/nest/services/index.d.ts

@@ -1 +1,4 @@
 export { AppSessionService } from "./session";
+export { AppHashingService } from "./hashing";
+export { EntityManagerService } from "./manager";
+export { EmailService } from "./email";

package/dist/esm/types/platforms/nest/services/manager/index.d.ts

@@ -0,0 +1,9 @@
+import { EntityManagerRegistry } from "../../ioc";
+import { IEntityManager } from "../../../../abstractions";
+export 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): import("../../../../abstractions").IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
+    getRepository<TEntity>(entityName: string): import("../../../../abstractions").IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
+}

package/dist/esm/types/platforms/nest/services/providers.d.ts

@@ -1,2 +1,5 @@
+import { EmailService } from "./email";
+import { AppHashingService } from "./hashing";
+import { EntityManagerService } from "./manager";
 import { AppSessionService } from "./session";
-export declare const Services: (typeof AppSessionService)[];
+export declare const Services: (typeof AppSessionService | typeof AppHashingService | typeof EntityManagerService | typeof EmailService)[];

package/dist/esm/types/providers/services.d.ts

@@ -1,4 +1,4 @@
-import { IAuthenticationContext, IAuthenticationContextProvider } from "../abstractions";
+import { IAuthenticationContext, IAuthenticationContextProvider, IEmailProvider, IEmailTemplatesCollection } from "../abstractions";
 import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
 import { IEntityAdapter } from "../abstractions/adapters";
 import { IEntityAuthorizationMiddleware } from "../abstractions/authorization";
@@ -53,6 +53,10 @@ export 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>;

package/dist/esm/types/symbols/ioc.d.ts

@@ -55,4 +55,8 @@ export declare const GlobalServices: {
     Authentication: {
         IAuthenticationContextProvider: string;
     };
+    Messaging: {
+        IEmailProvider: string;
+        IEmailTemplatesCollection: string;
+    };
 };