@valentine-efagene/qshelter-common 1.0.1 → 1.0.3

package/entities/transaction.entity.ts

@@ -1,56 +0,0 @@
-import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
-import { Provider, TransactionType } from '../types/transaction.type';
-import { Wallet } from './wallet.entity';
-import { User } from './user.entity';
-
-@Entity({ name: 'prod_transactions' })
-export class Transaction {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({
-    type: 'enum',
-    enum: TransactionType
-  })
-  type: TransactionType
-
-  @ManyToOne(() => Wallet, wallet => wallet.transactions, {
-    onDelete: 'CASCADE',
-    onUpdate: 'CASCADE',
-  })
-  @JoinColumn({ name: 'wallet_id' })
-  wallet: Wallet;
-
-  @Column()
-  walletId: number
-
-  @ManyToOne(() => User, (user) => user.transactions)
-  @JoinColumn({ name: 'user_id' })
-  user: User;
-
-  @Column()
-  userId: number
-
-  @Column({
-    type: 'enum',
-    enum: Provider
-  })
-  provider: Provider
-
-  @Column()
-  ref: string
-
-  @Column({
-    type: 'text'
-  })
-  metadata: string
-
-  @Column({ type: 'decimal', precision: 65, scale: 2, nullable: true })
-  amount: number;
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

package/entities/user.entity.ts

@@ -1,89 +0,0 @@
-import { Column, Entity, JoinTable, ManyToMany, OneToMany } from 'typeorm';
-import { TenantAwareBaseEntity } from './BaseEntity';
-import { UserStatus } from '../types/user.enums';
-import { Role } from './role.entity';
-import { RefreshToken } from './refresh_token.entity';
-import { Property } from './property.entity';
-import { Transaction } from './transaction.entity';
-import { Wallet } from './wallet.entity';
-
-@Entity({ name: 'users' })
-export class User extends TenantAwareBaseEntity {
-  @Column({ nullable: true })
-  firstName?: string;
-
-  @Column({ nullable: true })
-  lastName?: string;
-
-  @Column({ nullable: true })
-  phone?: string;
-
-  @Column({ nullable: true, type: 'text' })
-  bio?: string;
-
-  @Column({ nullable: true })
-  address?: string;
-
-  @Column({ nullable: true })
-  email: string;
-
-  @Column({ nullable: true })
-  password: string;
-
-  @Column({ type: 'text', nullable: true })
-  avatar?: string;
-
-  @Column({ nullable: true })
-  gender: string;
-
-  @ManyToMany(() => Role, (role) => role.users, {
-    onDelete: 'CASCADE',
-    eager: true
-  })
-  @JoinTable()
-  roles?: Role[]
-
-  @OneToMany(
-    () => RefreshToken,
-    (refreshToken) =>
-      refreshToken.user,
-    { eager: true },
-  )
-  refreshTokens: RefreshToken[];
-
-  @OneToMany(
-    () => Wallet,
-    (wallet) =>
-      wallet.user,
-    { eager: true },
-  )
-  wallets: Wallet[];
-
-  @OneToMany(
-    () => Transaction,
-    (transaction) =>
-      transaction.user,
-    { eager: true },
-  )
-  transactions: Transaction[];
-
-  @OneToMany(
-    () => Property,
-    (property) =>
-      property.user,
-  )
-  properties: Property[];
-
-  @Column({
-    type: 'enum',
-    enum: UserStatus,
-    default: UserStatus.PENDING
-  })
-  status: UserStatus
-
-  @Column({ default: false })
-  isEmailVerified?: boolean;
-
-  @Column({ nullable: true })
-  emailVerificationToken: string | null
-}

package/entities/user_suspensions.entity.ts

@@ -1,24 +0,0 @@
-import { Column, Entity, JoinColumn, OneToOne } from 'typeorm';
-import { BaseEntity } from './BaseEntity';
-import { User } from './user.entity';
-
-@Entity({ name: 'user_suspension' })
-export class UserSuspension extends BaseEntity {
-  @OneToOne(() => User, {
-    //eager: true,
-    onDelete: 'CASCADE',
-    onUpdate: 'CASCADE',
-  })
-  @JoinColumn({ name: 'user_id' })
-  user: User;
-
-  @Column({
-    nullable: false
-  })
-  userId: number
-
-  @Column({
-    nullable: false
-  })
-  reason: string
-}

package/entities/wallet.entity.ts

@@ -1,54 +0,0 @@
-import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
-import { Transaction } from './transaction.entity';
-import { User } from './user.entity';
-import { Currency } from '../types/social.enums';
-
-@Entity({ name: 'wallets' })
-export class Wallet {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @ManyToOne(() => User, (user) => user.wallets)
-  @JoinColumn({ name: 'user_id' })
-  user: User;
-
-  @Column()
-  userId: number
-
-  @Column({
-    type: 'enum',
-    enum: Currency
-  })
-  currency: number
-
-  @Column({
-  })
-  customerId: string
-
-  @Column({
-  })
-  bankName: string
-
-  @Column({
-  })
-  accountNumber: string
-
-  @Column({
-  })
-  accountName: string
-
-  @Column({ type: 'decimal', precision: 65, scale: 2, nullable: true })
-  balance: number;
-
-  @Column()
-  enabled: boolean
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-
-  @OneToMany(() => Transaction, transaction => transaction.wallet)
-  transactions: Transaction[]
-}

package/guard/permission.guard.ts

@@ -1,42 +0,0 @@
-import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { RequirePermission } from '../decorator/permission.decorator';
-import { Observable } from 'rxjs';
-import { User } from '../../user/user.entity';
-
-@Injectable()
-export class PermissionGuard implements CanActivate {
-  constructor(private reflector: Reflector) { }
-
-  canActivate(
-    context: ExecutionContext,
-  ): boolean | Promise<boolean> | Observable<boolean> {
-    const permission = this.reflector.get(RequirePermission, context.getHandler());
-
-    if (!permission) {
-      return true;
-    }
-
-    const request = context.switchToHttp().getRequest();
-
-    const user: User = request.user;
-
-    if (!user) {
-      return false
-    }
-
-    return this.matchPermission(permission, user);
-  }
-
-  matchPermission(permission: string, user: User) {
-    const roles = user.roles
-
-    if (!roles || roles.length < 1) {
-      return false
-    }
-
-    const permissions = roles.map(role => role.permissions).reduce((acc, curr) => [...acc, ...curr]) ?? []
-    const permissionNames = permissions?.map(permission => permission.name)
-    return permissionNames.includes(permission)
-  }
-}

package/guard/swagger-auth.guard.ts

@@ -1,9 +0,0 @@
-import { applyDecorators, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth } from '@nestjs/swagger';
-
-export function SwaggerAuth() {
-    return applyDecorators(
-        // UseGuards(AuthGuard),
-        ApiBearerAuth()
-    );
-}

package/helpers/ArrayHelper.ts

@@ -1 +0,0 @@
-export default class ArrayHelper {}

package/helpers/CustomNamingStrategy.ts

@@ -1,27 +0,0 @@
-import { DefaultNamingStrategy, NamingStrategyInterface } from 'typeorm';
-
-export class CustomNamingStrategy
-  extends DefaultNamingStrategy
-  implements NamingStrategyInterface {
-  tableName(className: string, customName: string): string {
-    return customName ? customName : this.snakeCase(className);
-  }
-
-  columnName(
-    propertyName: string,
-    customName: string,
-    //embeddedPrefixes: string[],
-  ): string {
-    return customName ? customName : this.snakeCase(propertyName);
-  }
-
-  relationName(propertyName: string): string {
-    return this.snakeCase(propertyName);
-  }
-
-  private snakeCase(name: string): string {
-    return name
-      .replace(/([A-Z])/g, (match) => `_${match.toLowerCase()}`)
-      .replace(/^_/, '');
-  }
-}

package/helpers/DateHelper.ts

@@ -1,21 +0,0 @@
-import { BadRequestException } from '@nestjs/common';
-
-export default class DateHelper {
-  public static formatDateToYYYYMMDD(dateString: string) {
-    try {
-      const date = new Date(dateString);
-
-      // Ensure the input is a valid Date object
-      if (!(date instanceof Date)) {
-        throw new BadRequestException('Invalid date');
-      }
-
-      // Format the date using the formatter
-      const formattedDate = date.toISOString().split('T')[0];
-
-      return formattedDate;
-    } catch (error) {
-      throw new BadRequestException('Invalid date');
-    }
-  }
-}

package/helpers/EmailHelper.ts

@@ -1,38 +0,0 @@
-
-import * as Handlebars from 'handlebars';
-import { FileSystemHelper } from "./FileSystemHelper";
-
-export default class EmailHelper {
-    public static async compileStringTemplate(rawTemplate: string, variables: Record<string, any>): Promise<string> {
-        try {
-            // Compile it with Handlebars
-            const compiled = Handlebars.compile(rawTemplate);
-
-            const html = compiled(variables);
-
-            return html;
-        } catch (error) {
-            throw new Error(`Failed to generate HTML: ${error.message}`);
-        }
-    }
-
-    public static async compileTemplate(templatePath: string, variables: Record<string, any>): Promise<string> {
-        try {
-            // Load the raw template
-            const rawTemplate = FileSystemHelper.loadFile(templatePath);
-
-            // Compile it with Handlebars
-            const compiled = Handlebars.compile(rawTemplate);
-
-            if (templatePath.includes('layout')) {
-                console.log({ compiled, variables })
-            }
-
-            const html = compiled(variables);
-
-            return html;
-        } catch (error) {
-            throw new Error(`Failed to generate HTML: ${error.message}`);
-        }
-    }
-}

package/helpers/FileSystemHelper.ts

@@ -1,101 +0,0 @@
-import { readFileSync, readdirSync, statSync, promises, constants } from 'fs';
-import * as path from 'path';
-
-export class FileSystemHelper {
-    private static root: string = path.join(__dirname, '../../mail/templates/');
-
-    public static async getFilePath(fileName: string): Promise<string> {
-        const filePath = path.join(this.root, fileName);
-        return filePath
-    }
-
-    public static async checkFileExists(fileName: string): Promise<boolean> {
-        const filePath = path.join(this.root, fileName);
-
-        try {
-            await promises.access(`${filePath}`, constants.F_OK)
-            console.log({ filePath, found: true })
-            return true
-        } catch (error) {
-            console.log({ filePath, found: false })
-            return false
-        }
-    }
-
-    public static loadFileWithFullPath(path: string): string {
-        const fileContent = readFileSync(path, 'utf-8');
-        return fileContent;
-    }
-
-    public static loadFile(fileName: string): string {
-        const filePath = path.join(this.root, fileName);
-
-        const fileContent = readFileSync(filePath, 'utf-8');
-        return fileContent;
-    }
-
-    public static async splitFilePath(filePath: string) {
-        // Normalize the file path to handle both Windows and Unix formats
-        let normalizedPath = path.normalize(filePath)
-        normalizedPath = normalizedPath.replaceAll('\\', '/')
-
-        // Get the file name (last part of the path)
-        const fileName = path.basename(normalizedPath);
-
-        // Get the directory path
-        const directoryPath = path.dirname(normalizedPath);
-        const extension = path.extname(fileName)
-
-        // Split the directory path into an array of folders
-        const folderArray = directoryPath.split('/');
-
-        // Reassemble the folder path as a string (optional, if you need it in this format)
-        const folderPath = folderArray.join('/');
-
-        return {
-            folderArray,
-            folderPath,
-            fileName,
-            extension
-        };
-    }
-
-    public static loadTemplate(fileName: string): string {
-        const filePath = path.join(this.root, `${fileName}`);
-
-        const fileContent = readFileSync(filePath, 'utf-8');
-        return fileContent;
-    }
-
-    // Method to list all .html files from the templates directory
-    public static listHtmlFilesInTemplates(): string[] {
-        const htmlFiles: string[] = [];
-
-        const getFilesRecursively = (dir: string) => {
-            try {
-                const files = readdirSync(dir);
-
-                files.forEach(file => {
-                    const fullPath = path.join(dir, file);
-                    const relativePath = path.relative(this.root, fullPath);
-
-                    if (statSync(fullPath).isDirectory()) {
-                        // If it's a directory, go deeper
-                        getFilesRecursively(fullPath);
-                    } else if (file.endsWith('.html')) {
-                        // If it's an HTML file, add to the list
-                        htmlFiles.push(relativePath);
-                    }
-                });
-            } catch (error) {
-                console.log(error)
-                throw error
-            }
-        };
-
-        // Start the recursion from the templates folder
-        getFilesRecursively(this.root);
-
-        return htmlFiles;
-    }
-}

package/index.ts

@@ -1,9 +0,0 @@
-// Pagination
-export * from './pagination';
-
-// Types
-export * from './standard-response';
-
-// Entities
-export * from './entities';
-

package/middleware/AccessLoggerMiddleware.ts

@@ -1,58 +0,0 @@
-import { Injectable, NestMiddleware, Logger } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-
-@Injectable()
-export class AccessLoggerMiddleware implements NestMiddleware {
-  private readonly logger = new Logger('HTTP');
-
-  use = (request: Request, response: Response, next: NextFunction): void => {
-    const { ip, method, originalUrl: url } = request;
-    const userAgent = request.get('user-agent') || '';
-    const startTime = Date.now();
-
-    // 👇 capture body but don’t log yet
-    const originalSend = response.send;
-    let responseBody: any;
-
-    response.send = function (body?: any): Response {
-      responseBody = body;
-      return originalSend.call(this, body);
-    };
-
-    response.on('finish', () => {
-      const { statusCode } = response;
-      const contentLength = response.get('content-length');
-      const responseTime = Date.now() - startTime;
-
-      const message = {
-        method,
-        url,
-        statusCode,
-        contentLength,
-        responseTime: `${responseTime}ms`,
-        userAgent,
-        ip,
-        timestamp: new Date().toISOString(),
-      };
-
-      if (statusCode >= 500) {
-        this.logger.error(JSON.stringify(message));
-
-        // 👇 only log the response body here
-        try {
-          if (typeof responseBody === 'object') {
-            console.log('Response body:', JSON.stringify(responseBody, null, 2));
-          } else {
-            console.log('Response body:', responseBody);
-          }
-        } catch (err) {
-          console.log('Response body (unserializable):', responseBody);
-        }
-      } else {
-        this.logger.log(JSON.stringify(message));
-      }
-    });
-
-    next();
-  };
-}

package/middleware/AuthenticationMiddleware.ts

@@ -1,13 +0,0 @@
-import { Injectable, NestMiddleware } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-
-@Injectable()
-export default class AuthenticationMiddleware implements NestMiddleware {
-    use(req: Request, _res: Response, next: NextFunction) {
-        // No-op authentication middleware for now. Consumers should attach
-        // a real implementation or use a guard. This prevents build-time errors
-        // where the middleware is referenced.
-        // It preserves any existing req.user if already set by upstream middleware.
-        return next();
-    }
-}

package/middleware/TenantMiddleware.ts

@@ -1,52 +0,0 @@
-import { Injectable, NestMiddleware } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-
-// Extend Express Request to include tenantId
-declare global {
-    namespace Express {
-        interface Request {
-            tenantId?: number;
-        }
-    }
-}
-
-@Injectable()
-export class TenantMiddleware implements NestMiddleware {
-    async use(req: Request, _res: Response, next: NextFunction) {
-        // Prefer explicit header `x-tenant-id`
-        const tenantIdHeader = (req.headers['x-tenant-id'] as string) || (req.headers['X-Tenant-Id'] as string);
-        if (tenantIdHeader) {
-            const id = parseInt(tenantIdHeader, 10);
-            if (!isNaN(id)) {
-                req.tenantId = id;
-                return next();
-            }
-        }
-
-        // Fall back to subdomain extraction (subdomain.domain.tld)
-        const host = (req.hostname || req.headers.host || '').toString();
-        const subdomain = this.extractSubdomain(host);
-        if (subdomain) {
-            // If subdomain is numeric, treat as tenantId; otherwise leave undefined
-            const id = parseInt(subdomain, 10);
-            if (!isNaN(id)) {
-                req.tenantId = id;
-            }
-        }
-
-        next();
-    }
-
-    private extractSubdomain(host: string): string | null {
-        if (!host) return null;
-        const hostname = host.split(':')[0];
-        const parts = hostname.split('.');
-        if (hostname === 'localhost' || /^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
-            return null;
-        }
-        if (parts.length >= 3) return parts[0];
-        return null;
-    }
-}
-
-export default TenantMiddleware;

package/pagination/index.ts

@@ -1,2 +0,0 @@
-export * from './pagination.types';
-export * from './pagination.helper';

package/pagination/pagination.helper.ts

@@ -1,57 +0,0 @@
-import { PaginatedResponse, PaginationQuery } from './pagination.types';
-
-export class PaginationHelper {
-    /**
-     * Creates a paginated response object
-     */
-    static paginate<T>(
-        items: T[],
-        total: number,
-        query: PaginationQuery
-    ): PaginatedResponse<T> {
-        const page = Math.max(1, query.page || 1);
-        const limit = this.getLimit(query.limit);
-        const totalPages = Math.ceil(total / limit);
-
-        return {
-            data: items,
-            meta: {
-                total,
-                page,
-                limit,
-                totalPages,
-                hasNext: page < totalPages,
-                hasPrev: page > 1,
-            },
-        };
-    }
-
-    /**
-     * Calculate the number of records to skip for pagination
-     */
-    static getSkip(page?: number, limit?: number): number {
-        const actualPage = Math.max(1, page || 1);
-        const actualLimit = this.getLimit(limit);
-        return (actualPage - 1) * actualLimit;
-    }
-
-    /**
-     * Get validated limit (min: 1, max: 100, default: 10)
-     */
-    static getLimit(limit?: number): number {
-        return Math.min(100, Math.max(1, limit || 10));
-    }
-
-    /**
-     * Parse and validate pagination query parameters
-     */
-    static parseQuery(query: any): PaginationQuery {
-        return {
-            page: query.page ? parseInt(query.page, 10) : 1,
-            limit: query.limit ? parseInt(query.limit, 10) : 10,
-            sortBy: query.sortBy || 'id',
-            sortOrder: query.sortOrder?.toUpperCase() === 'ASC' ? 'ASC' : 'DESC',
-            search: query.search || undefined,
-        };
-    }
-}

package/pagination/pagination.types.ts

@@ -1,21 +0,0 @@
-export interface PaginationQuery {
-    page?: number;
-    limit?: number;
-    sortBy?: string;
-    sortOrder?: 'ASC' | 'DESC';
-    search?: string;
-}
-
-export interface PaginationMeta {
-    total: number;
-    page: number;
-    limit: number;
-    totalPages: number;
-    hasNext: boolean;
-    hasPrev: boolean;
-}
-
-export interface PaginatedResponse<T> {
-    data: T[];
-    meta: PaginationMeta;
-}