@sidekick-coder/zenith-kit 0.3.6 → 0.3.8

package/src/server/services/DriveService.ts

@@ -0,0 +1,255 @@
+import fs from 'fs'
+import DriveEntry from '#shared/entities/DriveEntryEntity.ts'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import type { DriveUrlOptions } from '#server/contracts/DriveContract.ts'
+import { storagePath } from '#server/utils/basePath.ts'
+import BaseDrive from '#server/gateways/DriveBaseGateway.ts'
+import DriveS3 from '#server/gateways/DriveS3Gateway.ts'
+import DriveConfig from '#server/entities/DriveConfigEntity.ts'
+import type LoggerService from '#shared/services/LoggerService.ts'
+import logger from '#server/facades/logger.ts'
+import DriveFS from '#server/gateways/DriveFSGateway.ts'
+import config from '#server/facades/config.ts'
+
+interface ValidateUploadOptions {
+    mime_types: string
+    maxSize?: number
+}
+
+export default class DriveService {
+    public static __container_entry_key = 'DriveService'
+
+
+    public gateways: Map<string, typeof BaseDrive>
+    public drives: Map<string, BaseDrive> = new Map()
+    public selected?: string
+    public defaultDrive?: string
+    public debug = false
+    public logger: LoggerService
+
+    public get current() {
+        if (!this.selected) return undefined 
+        
+        const drive = this.drives.get(this.selected)
+        
+        if (!drive) return undefined
+
+        return drive
+    }
+
+    constructor(data: Partial<DriveService> = {}) {        
+        this.selected = data.selected || this.selected
+        this.debug = data.debug || this.debug
+        this.drives = data.drives || this.drives
+        this.logger = data.logger || logger.child({ label: 'drive' })
+        this.gateways = new Map<string, typeof BaseDrive>()
+
+        this.gateways.set('s3', DriveS3)
+        this.gateways.set('fs', DriveFS)
+    }
+
+    public listDrives() {
+        return Array.from(this.drives.values()).map(drive => ({
+            ...drive,
+            default: drive.id === this.defaultDrive
+        }))
+    }
+    
+    public get(name?: string) {
+        if (!name || !this.drives.has(name || '')) {
+            throw new BaseException('Drive not found')
+        }
+
+        const drive = this.drives.get(name)
+
+        if (!drive) {
+            throw new BaseException('Drive not found')
+        }
+
+        return drive
+    }
+
+    public use(name?: string) {
+        if (!this.drives.has(name || '')) {
+            throw new BaseException('Drive not found')
+        }
+        
+        return new DriveService({ 
+            selected: name,
+            drives: this.drives,
+            debug: this.debug 
+        })
+    }
+    
+
+    public list(folder?: string): Promise<DriveEntry[]> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.list(folder)
+    }
+
+    public find(filename: string): Promise<DriveEntry> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.find(filename)
+    }
+
+    public exists(filename: string): Promise<boolean> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.exists(filename)
+    }
+
+    public read(filename: string): Promise<Uint8Array> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.read(filename)
+    }
+
+    public readStream(filename: string) {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.readStream(filename)
+    }
+
+    public async readAsText(filename: string): Promise<string> {
+        const data = await this.read(filename)
+
+        return new TextDecoder().decode(data)
+    }
+
+    public write(filename: string, payload: Uint8Array | string | Record<string, unknown> ): Promise<void> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        let data: any = payload
+        
+        if (typeof payload === 'object' && !(payload instanceof Uint8Array)) {
+            data = JSON.stringify(payload, null, 4)
+        }
+
+        if (typeof data === 'string') {
+            data = new TextEncoder().encode(data)
+        }
+
+        return this.current.write(filename, data)
+    }
+
+    public writeStream(filename: string, stream: NodeJS.ReadableStream): Promise<void> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.writeStream(filename, stream)
+    }
+
+    /**
+     * Retrieve a URL for a file in the drive.
+     * @param payload  File instance, File ID, DriveEntry instance or filename string
+     * @param options 
+     * @returns string
+     */
+    public async url(filename: string, options: DriveUrlOptions = {}): Promise<string> {        
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.url(filename, options)
+    }
+
+    public async uploadUrl(filename: string, options: DriveUrlOptions = {}): Promise<string> {        
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.uploadUrl(filename, options)
+    }
+
+    /**
+     * Upload a file from the local filesystem to the drive.
+     * @param source filename in local filesystem
+     * @param destination 
+     * @returns 
+     */
+    public async upload(source: string, destination: string): Promise<void> {
+        const buffer = await fs.promises.readFile(source)
+
+        const uint8 = new Uint8Array(buffer)
+
+        return this.write(destination, uint8)
+    }
+
+    /**
+     * Download a file from the drive to the local filesystem.
+     * @param filename filename in the drive
+     * @param destination 
+     * @returns 
+     */
+    public async download(filename: string, destination: string): Promise<void> {
+        const data = await this.read(filename)
+        
+        await fs.promises.writeFile(destination, data)
+    }
+
+    public delete(filename: string): Promise<void> {
+        if (!this.current) throw new BaseException('No drive selected')
+
+        return this.current.delete(filename)
+    }
+
+    public async load(){
+        this.drives.clear()
+
+        const configs = await DriveConfig.list()
+
+        for (const c of configs) {
+            const gatewayClass = this.gateways.get(c.type)
+
+            if (!gatewayClass) {
+                this.logger.warn(`Drive gateway for type "${c.type}" not found`)
+                continue
+            }
+
+            const gateway = new gatewayClass(c)
+
+            this.drives.set(c.id, gateway)
+
+            if (this.debug) {
+                this.logger.debug(`drive loaded ${c.id} (${c.type})`)
+            }
+        }
+
+        this.selected = config.get('drive.default')
+        this.defaultDrive = config.get('drive.default')
+    }
+
+    public async createDefaultDrives(){
+
+        await DriveConfig.updateOrCreate('uploads', {
+            name: 'Uploads',
+            type: 'fs',
+            config: { directory: storagePath('uploads') }
+        })
+
+        if (!config.get('drive.default')) {
+            config.set('drive.default', 'uploads')
+        }
+
+        await this.load()
+    }
+
+    public validateUpload(options: ValidateUploadOptions, file: { mimetype: string, size: number },) {
+        const allowedTypes = options.mime_types.split(',').map(t => t.trim())
+
+        const isAllowed = allowedTypes.some(allowedType => {
+            if (!allowedType.endsWith('/*')) {
+                return allowedType === file.mimetype
+            }
+            
+            const baseType = allowedType.slice(0, -2)
+
+            return file.mimetype.startsWith(baseType + '/')
+        })
+
+        if (!isAllowed) {
+            throw new BaseException('MIME type not allowed', 403)
+        }
+
+        if (options.maxSize && file.size > options.maxSize) {
+            throw new BaseException('File size exceeds the maximum allowed', 403)
+        }
+    }
+}

package/src/server/services/EmmitterService.ts

@@ -0,0 +1,4 @@
+import BaseEmmitterService from "../../shared/services/EmmitterService";
+import type { EventContract } from '../contracts/EventContract';
+
+export default class EmmitterService extends BaseEmmitterService<EventContract> {}

package/src/server/services/EncryptService.ts

@@ -0,0 +1,166 @@
+import crypto from 'crypto'
+import ms from 'ms'
+import { format } from 'date-fns'
+import EnvService from './EnvService';
+import LoggerService from '#shared/services/LoggerService.ts';
+import { BaseException } from '#shared/index.ts';
+
+interface URLOptions {
+    data?: any;
+    expires?: ms.StringValue;
+    expireAt?: number | Date;
+}
+
+interface EncryptServiceOptions {
+    key?: string;
+    debug?: boolean;
+    logger?: LoggerService;
+    env?: EnvService;
+}
+
+export default class EncryptService {
+    public static __container_entry_key = 'EncryptService'
+
+    public debug = false
+    public env: EnvService
+    public logger: LoggerService
+
+    private readonly algorithm = 'aes-256-cbc'
+    private key: Buffer | null = null
+
+    constructor(options: EncryptServiceOptions) {
+        this.env = options.env || new EnvService()
+        this.logger = options.logger || new LoggerService()
+        this.debug = options.debug || false
+
+        if (options.key) {
+            this.key = crypto.scryptSync(options.key, 'salt', 32)
+        }
+    }
+
+    public static create(options: EncryptServiceOptions) {
+        return new EncryptService(options)
+    }
+
+    public setDebug(debug: boolean) {
+        this.debug = debug
+
+        if (this.debug) {
+            this.logger.debug('debug mode enabled')
+        }
+    }
+
+    public setLogger(logger: LoggerService) {
+        this.logger = logger
+    }
+
+    public setEnv(env: EnvService) {
+        this.env = env
+    }
+
+    public setKey(key: string) {
+        this.key = crypto.scryptSync(key, 'salt', 32)
+    }
+
+    public encrypt(text: string) {
+        if (!this.key) {
+            throw new Error('Encryption key not set')
+        }
+
+        const iv = crypto.randomBytes(16)
+        const cipher = crypto.createCipheriv(this.algorithm, this.key, iv)
+
+        let encrypted = cipher.update(text, 'utf8', 'hex')
+        encrypted += cipher.final('hex')
+
+        return `${iv.toString('hex')}:${encrypted}`
+    }
+
+
+
+    public decrypt(options: string): string {
+        if (!this.key) {
+            throw new Error('Encryption key not set')
+        }
+
+        const [iv, encrypted] = options.split(':')
+
+        const ivBuffer = Buffer.from(iv, 'hex')
+
+        const decipher = crypto.createDecipheriv(this.algorithm, this.key, ivBuffer)
+
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8')
+        decrypted += decipher.final('utf8')
+
+        return decrypted
+    }
+
+    public encryptObject(obj: any): string {
+        const jsonString = JSON.stringify(obj)
+
+        return this.encrypt(jsonString)
+    }
+
+    public decryptObject<T>(encryptedString: string): T {
+        const jsonString = this.decrypt(encryptedString)
+
+        return JSON.parse(jsonString) as T
+    }
+
+    public url(path: string, options?: URLOptions): string {
+        let expireAt = options?.expireAt
+
+        if (options?.expires) {
+            const expires = ms(options.expires) as number
+
+            expireAt = Date.now() + expires
+        }
+
+        if (!expireAt) {
+            expireAt = Date.now() + ms('15 minutes')
+        }
+
+        if (expireAt instanceof Date) {
+            expireAt = expireAt.getTime()
+        }
+
+        const payload = {
+            data: options?.data || {},
+            expireAt,
+            expireAtReadable: format(new Date(expireAt), 'yyyy-MM-dd HH:mm:ss')
+        }
+
+        const key = this.encrypt(JSON.stringify(payload))
+
+        const appUrl = this.env.get('ZENITH_APP_URL')
+
+        if (!appUrl) {
+            throw new BaseException('APP_URL not set in environment variables')
+        }
+
+        const url = new URL(path, appUrl)
+
+        url.searchParams.append('key', encodeURIComponent(key))
+
+        return url.toString()
+    }
+
+    public verifyUrl(encryptedKey: string): any {
+        const decryptedData = this.decrypt(decodeURIComponent(encryptedKey))
+
+        const payload = JSON.parse(decryptedData)
+
+        if (payload.expireAt && Date.now() > payload.expireAt) {
+            const error = new BaseException('URL has expired', 403)
+
+            Object.assign(error, {
+                expireAt: payload.expireAt,
+                expireAtReadable: payload.expireAtReadable
+            })
+
+            throw error
+        }
+
+        return payload.data
+    }
+}

package/src/server/services/EncryptService.unit.test.ts

@@ -0,0 +1,24 @@
+import {
+    describe,
+    it,
+    expect
+} from 'vitest'
+import EncryptService from './encrypt.service.ts'
+
+describe('EncryptService', () => {
+    it('should encrypt and decrypt text correctly', () => {
+        const service = new EncryptService()
+
+        service.load('test-secret-key')
+        
+        const originalText = 'Hello, World!'
+        
+        const encrypted = service.encrypt(originalText)        
+        
+        expect(encrypted).not.toBe(originalText)
+        
+        const decrypted = service.decrypt(encrypted)
+
+        expect(decrypted).toBe(originalText)
+    })
+})

package/src/server/services/EnvService.ts

@@ -0,0 +1,77 @@
+import dotenv from 'dotenv'
+import * as v from 'valibot'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import { envSchema } from '#server/schemas/envSchema.ts'
+import type { EnvSchema } from '#server/schemas/envSchema.ts'
+
+export default class EnvService {
+    public static __container_entry_key = 'EnvService'
+    private env: EnvSchema | null = null
+    private files: string[] = []
+
+    public static create() {
+        return new EnvService()
+    }
+
+    public static dotEnvConfig(options?: dotenv.DotenvConfigOptions) {
+        return dotenv.config(options)
+    }
+
+    public setFiles(files: string[]) {
+        this.files = files
+        return this
+    }
+
+    public addFile(file: string) {
+        this.files.push(file)
+        return this
+    }
+
+    public load() {
+        EnvService.dotEnvConfig({
+            path: this.files,
+            override: true,
+            quiet: true,
+        })
+
+        this.env = v.parse(envSchema, process.env)
+
+        return this
+    }
+
+    public get production(): boolean {
+        return this.get('NODE_ENV') === 'production'
+    }
+
+    public get development(): boolean {
+        return this.get('NODE_ENV') === 'development'
+    }
+
+    public get test(): boolean {
+        return this.get('NODE_ENV') === 'test'
+    }
+
+    public has<K extends keyof EnvSchema>(key: K): boolean {
+        if (!this.env) {
+            throw new BaseException('Environment variables not loaded. Call load() before accessing environment variables.')
+        }
+
+        return this.env![key] !== undefined
+    }
+
+    public get<K extends keyof EnvSchema>(key: K, defaultValue?: any): EnvSchema[K] {
+        if (!this.env) {
+            throw new BaseException('Environment variables not loaded. Call load() before accessing environment variables.')
+        }
+
+        return this.env![key] !== undefined ? this.env![key] : defaultValue
+    }
+
+    public set<K extends keyof EnvSchema>(key: K, value: EnvSchema[K]) {
+        if (!this.env) {
+            throw new BaseException('Environment variables not loaded. Call load() before accessing environment variables.')
+        }
+
+        this.env![key] = value
+    }
+}

package/src/server/services/ExceptionService.ts

@@ -0,0 +1,43 @@
+import type { Response } from 'express'
+import { BaseException, LoggerService } from '#shared/index.ts'
+import EnvService from './EnvService'
+
+export interface ExceptionServiceOptions {
+    ignoreCodeErrors?: number[]
+    logger?: LoggerService
+    env?: EnvService
+}
+
+export default class ExceptionService {
+    public static __container_entry_key = 'ExceptionService'
+    public ignoreCodeErrors: number[] = [400, 401, 403, 404, 422]
+    public logger: LoggerService
+    public env: EnvService
+
+    constructor(options: ExceptionServiceOptions = {}) {
+        this.logger = options.logger || new LoggerService()
+        this.env = options.env || new EnvService()
+
+        if (options.ignoreCodeErrors) {
+            this.ignoreCodeErrors = options.ignoreCodeErrors
+        }
+    }
+
+    public handle(error: Error, response: Response) {
+
+        const errorName = error.name || 'Internal Server Error'
+        const errorMessage = error.message || 'An unexpected error occurred'
+        const errorStatus = (error as any).status || 500
+
+        if (!this.ignoreCodeErrors.includes(errorStatus)) {
+            this.logger.error(error)
+        }
+
+        return response.status(errorStatus).json({
+            error: errorName,
+            message: errorMessage,
+            status: errorStatus,
+        })
+    }
+}
+

package/src/server/services/HasherService.ts

@@ -0,0 +1,14 @@
+import bcrypt from 'bcrypt'
+
+export default class HasherService {
+    public static __container_entry_key = 'HasherService'
+
+    public hash(value: string): Promise<string> {
+        return bcrypt.hash(value, 12)
+    }
+
+    async compare(a: string, b: string): Promise<boolean> {
+        return bcrypt.compare(a, b)
+    }
+}
+