@sidekick-coder/zenith-kit 0.4.3 → 0.4.4

package/src/server/gateways/DriveS3Gateway.ts

@@ -1,17 +1,7 @@
 import { Readable } from 'stream'
 import { dirname } from 'path'
 import ms from 'ms'
-import {
-    S3Client,
-    ListObjectsV2Command,
-    GetObjectCommand,
-    PutObjectCommand,
-    DeleteObjectCommand,
-    DeleteObjectsCommand,
-    HeadObjectCommand,
-} from '@aws-sdk/client-s3'
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
-import { Upload } from '@aws-sdk/lib-storage'
+import type { S3Client } from '@aws-sdk/client-s3'
 import type { InferOutput } from 'valibot'
 import mime from 'mime'
 import DriveEntity from '#shared/entities/DriveEntryEntity.ts'
@@ -31,6 +21,28 @@ const schema = validator.create((v) => v.object({
 
 export type S3DriveConfig = InferOutput<typeof schema>
 
+type S3Sdk = typeof import('@aws-sdk/client-s3')
+type S3PresignerSdk = typeof import('@aws-sdk/s3-request-presigner')
+type S3StorageSdk = typeof import('@aws-sdk/lib-storage')
+
+interface S3SdkModules {
+    s3: S3Sdk
+    presigner: S3PresignerSdk
+    storage: S3StorageSdk
+}
+
+let s3SdkModules: Promise<S3SdkModules> | undefined
+
+function loadS3SdkModules(): Promise<S3SdkModules> {
+    s3SdkModules ??= Promise.all([
+        import('@aws-sdk/client-s3'),
+        import('@aws-sdk/s3-request-presigner'),
+        import('@aws-sdk/lib-storage'),
+    ]).then(([s3, presigner, storage]) => ({ s3, presigner, storage }))
+
+    return s3SdkModules
+}
+
 function streamToUint8Array(stream: any): Promise<Uint8Array> {
     if (!stream || typeof stream !== 'object' || typeof stream.on !== 'function') {
         return Promise.resolve(new Uint8Array())
@@ -49,6 +61,8 @@ export default class DriveS3 extends BaseDrive {
 
     private _client?: S3Client
 
+    private _clientPromise?: Promise<S3Client>
+
     constructor(data: Pick<BaseDrive, 'id' | 'name' | 'description' | 'config'>) {
         super(data)
     }
@@ -86,32 +100,55 @@ export default class DriveS3 extends BaseDrive {
         return `${cleanPrefix}${cleanFilename}`
     }
 
-    protected get client(): S3Client {
+    protected async getClient(): Promise<S3Client> {
         if (this._client) {
             return this._client
         }
 
+        if (this._clientPromise) {
+            return this._clientPromise
+        }
+
         const config = this.config as S3DriveConfig
+        const clientPromise = loadS3SdkModules().then(({ s3: { S3Client } }) => {
+            const client = new S3Client({
+                region: config.region,
+                endpoint: config.endpoint,
+                credentials: {
+                    accessKeyId: config.accessKeyId,
+                    secretAccessKey: config.secretAccessKey,
+                    sessionToken: config.sessionToken,
+                }
+            })
 
-        this._client = new S3Client({
-            region: config.region,
-            endpoint: config.endpoint,
-            credentials: {
-                accessKeyId: config.accessKeyId,
-                secretAccessKey: config.secretAccessKey,
-                sessionToken: config.sessionToken,
-            }
+            this._client = client
+
+            return client
         })
 
-        return this._client
+        this._clientPromise = clientPromise
+
+        try {
+            return await clientPromise
+        } catch (error) {
+            if (this._clientPromise === clientPromise) {
+                this._clientPromise = undefined
+            }
+
+            throw error
+        }
     }
 
     public exists: BaseDrive['exists'] = async (filename) => {
         this.checkValid()
 
         const Key = this.getKey(filename)
+        const [{ s3: { HeadObjectCommand } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
-        return this.client.send(new HeadObjectCommand({
+        return client.send(new HeadObjectCommand({
             Bucket: this.bucket,
             Key
         }))
@@ -128,13 +165,18 @@ export default class DriveS3 extends BaseDrive {
             Prefix += '/'
         }
 
+        const [{ s3: { ListObjectsV2Command } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
+
         const command = new ListObjectsV2Command({
             Bucket: this.bucket,
             Prefix,
             Delimiter: '/',
         })
 
-        const resp = await this.client.send(command)
+        const resp = await client.send(command)
 
         const entries: DriveEntity[] = []
 
@@ -217,8 +259,12 @@ export default class DriveS3 extends BaseDrive {
         this.checkValid()
 
         const Key = this.getKey(filename)
+        const [{ s3: { GetObjectCommand } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
-        const resp = await this.client.send(new GetObjectCommand({
+        const resp = await client.send(new GetObjectCommand({
             Bucket: this.bucket,
             Key
         }))
@@ -232,13 +278,17 @@ export default class DriveS3 extends BaseDrive {
         this.checkValid()
 
         const Key = this.getKey(filename)
+        const [{ s3: { GetObjectCommand } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
         const command = new GetObjectCommand({
             Bucket: this.bucket,
             Key
         })
 
-        const resp = await this.client.send(command)
+        const resp = await client.send(command)
 
         const body = resp.Body as any
 
@@ -249,8 +299,12 @@ export default class DriveS3 extends BaseDrive {
         this.checkValid()
 
         const Key = this.getKey(filename)
+        const [{ s3: { PutObjectCommand } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
-        await this.client.send(new PutObjectCommand({
+        await client.send(new PutObjectCommand({
             Bucket: this.bucket,
             Key,
             Body: Buffer.from(data)
@@ -261,9 +315,13 @@ export default class DriveS3 extends BaseDrive {
         this.checkValid()
 
         const Key = this.getKey(filename)
+        const [{ storage: { Upload } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
         const upload = new Upload({
-            client: this.client,
+            client,
             params: {
                 Bucket: this.bucket,
                 Key,
@@ -280,6 +338,10 @@ export default class DriveS3 extends BaseDrive {
         const Key = this.getKey(filename)
 
         const entry = await this.find(filename)
+        const [{ s3: { DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
         if (entry.type === 'file') {
             const command = new DeleteObjectCommand({
@@ -287,13 +349,13 @@ export default class DriveS3 extends BaseDrive {
                 Key
             })
 
-            await this.client.send(command)
+            await client.send(command)
 
             return
         }
 
 
-        const listResponse = await this.client.send(new ListObjectsV2Command({
+        const listResponse = await client.send(new ListObjectsV2Command({
             Bucket: this.bucket,
             Prefix: Key
         }))
@@ -304,7 +366,7 @@ export default class DriveS3 extends BaseDrive {
             return
         }
 
-        await this.client.send(new DeleteObjectsCommand({
+        await client.send(new DeleteObjectsCommand({
             Bucket: this.bucket,
             Delete: { Objects: toDelete }
         }))
@@ -324,8 +386,12 @@ export default class DriveS3 extends BaseDrive {
 
         const expiresMs = ms(options?.expires || '30m') || 30 * 60 * 1000
         const expiresSeconds = Math.max(1, Math.round(expiresMs / 1000))
+        const [{ s3: { GetObjectCommand }, presigner: { getSignedUrl } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
-        return getSignedUrl(this.client, new GetObjectCommand({
+        return getSignedUrl(client, new GetObjectCommand({
             Bucket: this.bucket,
             Key
         }), { expiresIn: expiresSeconds })
@@ -338,12 +404,16 @@ export default class DriveS3 extends BaseDrive {
 
         const expiresMs = ms(options?.expires || '30m') || 30 * 60 * 1000
         const expiresSeconds = Math.max(1, Math.round(expiresMs / 1000))
+        const [{ s3: { PutObjectCommand }, presigner: { getSignedUrl } }, client] = await Promise.all([
+            loadS3SdkModules(),
+            this.getClient(),
+        ])
 
         const command = new PutObjectCommand({
             Bucket: this.bucket,
             Key,
         })
 
-        return getSignedUrl(this.client, command, { expiresIn: expiresSeconds })
+        return getSignedUrl(client, command, { expiresIn: expiresSeconds })
     }
 }

package/src/server/gateways/GitGateway.ts

@@ -1,8 +1,8 @@
 import { writeFile } from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
-import LoggerService from '../../shared/services/LoggerService.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import { tmpPath } from '#server/utils/basePath.ts'
-import { tryCatch } from '#shared/index.ts'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
 import ShellService from '#server/services/ShellService.ts'
 
 export interface GitRepoInfo {

package/src/server/globals.ts

@@ -1,4 +1,5 @@
-import type { ContainerService, tryCatch } from '#shared/index.ts'
+import type ContainerService from '#shared/services/ContainerService.ts'
+import type { tryCatch } from '#shared/utils/tryCatch.ts'
 import type TranslatorService from '#shared/services/TranslatorService.ts'
 
 export { }

package/src/server/index.ts

@@ -26,8 +26,6 @@ export * from './services/HasherService.ts'
 export { default as HasherService } from './services/HasherService.ts'
 export * from './services/HttpService.ts'
 export { default as HttpService } from './services/HttpService.ts'
-export * from './services/HttpTesterService.ts'
-export { default as HttpTesterService } from './services/HttpTesterService.ts'
 export * from './services/LifecycleService.ts'
 export { default as LifecycleService } from './services/LifecycleService.ts'
 export * from './services/MetadataQueryService.ts'
@@ -114,6 +112,8 @@ export * from './facades/hasher.ts'
 export { default as hasher } from './facades/hasher.ts'
 export * from './facades/http.ts'
 export { default as http } from './facades/http.ts'
+export * from './facades/lifecycle.ts'
+export { default as lifecycle } from './facades/lifecycle.ts'
 export * from './facades/logger.ts'
 export { default as logger } from './facades/logger.ts'
 export * from './facades/migrator.ts'
@@ -208,6 +208,7 @@ export * from './utils/addIdColumn.ts'
 export * from './utils/addSoftDeleteColumn.ts'
 export * from './utils/addTimestampColumns.ts'
 export * from './utils/basePath.ts'
+export * from './utils/config.ts'
 export * from './utils/createLoaderFactory.ts'
 export * from './utils/cuid.ts'
 export * from './utils/defineHandler.ts'

package/src/server/loaders/hasManyThroughLoader.ts

@@ -27,7 +27,7 @@ export async function loadHasManyThrough<
     TTargetEntity extends Record<string, any> = Record<string, any>
 >(payload: any | any[], options: HasManyThroughLoaderOptions<TEntity, TPivotEntity, TTargetEntity>) {
     const entities = Array.isArray(payload) ? payload : [payload]
-    const target = options.target 
+    const target = options.target
     const pivot = options.pivot
 
     function findKey(entity: any, keyOrFn: KeyOrFunction<any>): any {
@@ -36,23 +36,32 @@ export async function loadHasManyThrough<
         }
 
         return get(entity, keyOrFn)
-        
+
     }
 
-    const pivoIds = entities.map(e => findKey(e, pivot.sourceKey)).filter(Boolean)
+    const pivoIds = entities.map(e => findKey(e, pivot.sourceKey))
+        .filter(id => id !== undefined && id !== null)
+        .filter((value, index, self) => self.indexOf(value) === index)
+
     const pivotEntities = await pivot.findEntities(pivoIds)
-    const targetIds = pivotEntities.map((p: any) => findKey(p, pivot.targetKey)).filter(Boolean)
+
+    const targetIds = pivotEntities.map((p: any) => findKey(p, target.sourceKey))
+        .filter(id => id !== undefined && id !== null)
+        .filter((value, index, self) => self.indexOf(value) === index)
+
     const targetEntities = await target.findEntities(targetIds)
 
     for (const entity of entities) {
-        const pivots = pivotEntities.filter((p: any) => findKey(p, pivot.sourceKey) === findKey(entity, pivot.sourceKey))
+        const pivots = pivotEntities.filter((p: any) => findKey(p, pivot.targetKey) === findKey(entity, pivot.sourceKey))
 
         if (!pivots.length) {
             set(entity, options.key, [])
             continue
         }
 
-        const targets = targetEntities.filter((t: any) => pivots.some((p: any) => findKey(p, target.sourceKey) === findKey(t, target.targetKey)))
+        const targets = targetEntities.filter((t: any) =>
+            pivots.some((p: any) => findKey(p, target.sourceKey) === findKey(t, target.targetKey))
+        )
 
         set(entity, options.key, targets)
     }

package/src/server/loaders/loadMetas.ts

@@ -1,5 +1,5 @@
 import { set, get } from 'lodash-es'
-import { unflatten } from '#shared/index.ts'
+import { unflatten } from '#shared/utils/flatten.ts'
 import { defineLoader } from '#server/utils/defineLoader.ts'
 
 interface RepositoryMeta {

package/src/server/middlewares/AuthMiddleware.ts

@@ -1,6 +1,7 @@
-import type { Token, UserEntity } from '@sidekick-coder/zenith-kit/shared'
-import type {  Middleware, } from '#server/contracts/RouterContract.ts'
-import { BaseException } from '#shared/index.ts'
+import type { Token } from '#shared/schemas/tokenSchema.ts'
+import type UserEntity from '#shared/entities/UserEntity.ts'
+import type { Middleware, } from '#server/contracts/RouterContract.ts'
+import BaseException from '#shared/exceptions/BaseException.ts'
 
 export type AuthMiddlewareContext = {
     user: UserEntity

package/src/server/repositories/ConfigRepository.ts

@@ -1,4 +1,4 @@
-import { orderBy } from 'lodash-es'
+import orderBy from 'lodash-es/orderBy.js'
 import BaseException from '#shared/exceptions/BaseException.ts'
 import type ConfigService from '#shared/services/ConfigService.ts'
 import { createId } from '#shared/utils/createId.ts'

package/src/server/repositories/UserRepository.ts

@@ -1,6 +1,6 @@
 import emmitter from '#server/facades/emmitter.ts'
 import hasher from '#server/facades/hasher.ts'
-import type { UserEntity } from '#shared/index.ts'
+import type UserEntity from '#shared/entities/UserEntity.ts'
 import DatabaseRepository from './DatabaseRepository'
 
 export interface UserRepositoryQueryOptions {

package/src/server/schemas/envSchema.ts

@@ -35,7 +35,7 @@ const keyValue = v.pipe(v.string(), v.transform((value) => {
 const stringArray = v.pipe(
     v.string(),
     v.transform((value) => value
-        .split(',')
+        .split(':')
         .map(s => s.trim())
         .filter(Boolean)
     )
@@ -73,6 +73,7 @@ export const envSchema = v.looseObject({
     ZENITH_CONFIG_S3_ENDPOINT: v.optional(v.string()),
     ZENITH_CONFIG_S3_PREFIX: v.optional(v.string(), ''),
 
-    ZENITH_PLUGINS_DIRS: v.optional(stringArray, ''),
+    ZENITH_PLUGINS_DIR: v.optional(stringArray, ''),
+    ZENITH_COMMAND_DIR: v.optional(stringArray, ''),
 })
 

package/src/server/services/CliService.ts

@@ -2,7 +2,9 @@ import { Command as CommanderCommand } from 'commander'
 import chalk from 'chalk'
 import { printTable, printObject } from '../utils/printTable.ts'
 import { importAll } from '#server/utils/importAll.ts'
-import { EmmitterService, LoggerService, tryCatch } from '#shared/index.ts'
+import EmmitterService from '#shared/services/EmmitterService.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
 import * as inquirer from '@inquirer/prompts'
 
 export interface CliEvents {
@@ -71,8 +73,10 @@ export default class CliService extends CliCommand {
     }
 
     public async loadDir(dir: string) {
+        const startTime = Date.now()
+
         const mods = await importAll(dir, {
-            exclude: ['.test.ts', '.spec.ts', '.test.js', '.spec.js'],
+            exclude: ['.test.ts', '.spec.ts', '.test.js', '.spec.js', '.d.ts', '.d.mts', '.d.cts'],
             onError: ({ error, filename }) => {
                 Object.assign(error, { filename })
 
@@ -109,6 +113,12 @@ export default class CliService extends CliCommand {
             }
 
         }
+
+        const endTime = Date.now()
+
+        if (this.debug) {
+            this.logger.debug(`loaded commands from dir ${dir} in ${endTime - startTime}ms`)
+        }
     }
 
     public async load() {

package/src/server/services/CliWrapperService.ts

@@ -1,6 +1,6 @@
 import cp from 'child_process';
 import path from 'path';
-import { LoggerService } from '#shared/index.ts';
+import LoggerService from '#shared/services/LoggerService.ts';
 
 export default class CliWrapperService {
     public process: cp.ChildProcess | null = null;
@@ -74,8 +74,26 @@ export default class CliWrapperService {
         const configArguments = Array.from(this.configArguments.entries())
             .map(([key, value]) => `${key}=${value}`).join(';');
 
-        this.addEnv('ZENITH_CONFIG_ARGUMENTS', configArguments); 
+        this.addEnv('ZENITH_CONFIG_ARGUMENTS', configArguments);
         this.addEnv('ZENITH_CONFIG_FILES', this.configFiles.join(','));
+
+
+        // 1. Force color output even when stdio is piped
+        // Respect existing environment settings if FORCE_COLOR is already set externally
+        if (process.env.FORCE_COLOR !== undefined) {
+            this.addEnv('FORCE_COLOR', process.env.FORCE_COLOR);
+        } else {
+            // '1' enables basic colors, '2' for 256 colors, '3' for 16m truecolor
+            this.addEnv('FORCE_COLOR', '1');
+        }
+
+        // 2. Set COLORTERM to signal truecolor support to library detectors
+        if (process.env.COLORTERM) {
+            this.addEnv('COLORTERM', process.env.COLORTERM);
+        }
+
+        // 3. Force chalk/supports-color to keep colors enabled
+        this.addEnv('CLI_COLOR', '1');
     }
 
     public loadArguments(args: string[] = []) {
@@ -83,11 +101,24 @@ export default class CliWrapperService {
 
         const forwardArgs = args.filter(arg => !namespaces.some(ns => arg.startsWith(ns)));
 
+        if (process.env.NODE_ENV === 'production') {
+            const filename = path.join(this.appBasePath, 'dist', 'server', 'cli.mjs');
+
+            this.args = [
+                filename,
+                ...forwardArgs,
+            ]
+
+            return
+        }
+
+        const filename = path.join(this.appBasePath, 'src', 'server', 'cli.ts');
+
         this.args = [
             '--no-warnings',
             '--experimental-strip-types',
             '--enable-source-maps',
-            path.join(this.appBasePath, 'server', 'cli.ts'),
+            filename,
             ...forwardArgs,
         ];
 
@@ -119,14 +150,29 @@ export default class CliWrapperService {
             })
         }
 
+        // Pipe stdout and stderr so we can manage and flush output directly
         this.process = cp.spawn('node', this.args, {
-            stdio: 'inherit',
+            stdio: ['inherit', 'pipe', 'pipe'],
             env: {
                 ...process.env,
                 ...Object.fromEntries(this.env.entries()),
             }
         });
 
+        if (this.process.stdout) {
+            this.process.stdout.pipe(process.stdout);
+        }
+
+        if (this.process.stderr) {
+            // Forward child process stderr to parent process stdout if stdout is piped
+            // This ensures tools like `grep` catch error logs without needing `2>&1`
+            if (!process.stdout.isTTY) {
+                this.process.stderr.pipe(process.stdout);
+            } else {
+                this.process.stderr.pipe(process.stderr);
+            }
+        }
+
         process.on('SIGINT', () => this.kill());
         process.on('SIGTERM', () => this.kill());
         process.on('exit', () => this.kill());

package/src/server/services/ConfigManagerService.ts

@@ -1,11 +1,11 @@
-import ConfigFSService from '#server/services/ConfigFSService.ts'
-import ConfigS3Service from '#server/services/ConfigS3Service.ts'
-import { BaseException, type LoggerService } from '#shared/index.ts'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import ConfigService from '#shared/services/ConfigService.ts'
 import { flatten } from '#shared/utils/flatten.ts'
 import type EnvService from './EnvService.ts'
-import fs from 'fs'
-import yaml from 'js-yaml'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url) 
 
 export interface ConfigManagerOptions {
     env: EnvService
@@ -31,6 +31,8 @@ export default class ConfigManagerService {
     }
 
     private async loadS3Config() {
+        const ConfigS3Service = await import('#server/services/ConfigS3Service.ts').then(m => m.default)
+
         const service = new ConfigS3Service({
             bucket: this.env.get('ZENITH_CONFIG_S3_BUCKET')!,
             region: this.env.get('ZENITH_CONFIG_S3_REGION')!,
@@ -58,6 +60,8 @@ export default class ConfigManagerService {
     }
 
     private async loadFSConfig() {
+        const ConfigFSService = await import('#server/services/ConfigFSService.ts').then(m => m.default)
+
         const service = new ConfigFSService({
             directory: this.env.get('ZENITH_CONFIG_FS_PATH'),
             debug: this.env.get('ZENITH_CONFIG_DEBUG'),
@@ -86,6 +90,8 @@ export default class ConfigManagerService {
     }
 
     public loadConfigFromFile(service: ConfigService, file: string) {
+        const fs = require('fs') 
+
         if (!fs.existsSync(file)) {
             this.logger.warn(`configuration file not found: ${file}`)
             return
@@ -95,6 +101,8 @@ export default class ConfigManagerService {
         let data: Record<string, any> | null = null
 
         if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+            const yaml = require('js-yaml')
+
             data = yaml.load(text) as Record<string, any>
         }
 

package/src/server/services/EncryptService.ts

@@ -3,7 +3,7 @@ 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';
+import BaseException from '#shared/exceptions/BaseException.ts';
 
 interface URLOptions {
     data?: any;

package/src/server/services/EnvService.ts

@@ -1,8 +1,12 @@
-import dotenv from 'dotenv'
-import * as v from 'valibot'
+// import dotenv from 'dotenv'
+// import * as v from 'valibot'
+import type { DotenvConfigOptions } from 'dotenv'
 import BaseException from '#shared/exceptions/BaseException.ts'
-import { envSchema } from '#server/schemas/envSchema.ts'
+// import { envSchema } from '#server/schemas/envSchema.ts'
 import type { EnvSchema } from '#server/schemas/envSchema.ts'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
 
 export default class EnvService {
     public static __container_entry_key = 'EnvService'
@@ -13,7 +17,9 @@ export default class EnvService {
         return new EnvService()
     }
 
-    public static dotEnvConfig(options?: dotenv.DotenvConfigOptions) {
+    public static dotEnvConfig(options?: DotenvConfigOptions) {
+        const dotenv = require('dotenv')
+
         return dotenv.config(options)
     }
 
@@ -34,6 +40,9 @@ export default class EnvService {
             quiet: true,
         })
 
+        const v = require('valibot')
+        const envSchema = require('#server/schemas/envSchema.ts').envSchema
+
         this.env = v.parse(envSchema, process.env)
 
         return this

package/src/server/services/ExceptionService.ts

@@ -1,5 +1,5 @@
 import type { Response } from 'express'
-import { BaseException, LoggerService } from '#shared/index.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import EnvService from './EnvService'
 
 export interface ExceptionServiceOptions {
@@ -37,6 +37,7 @@ export default class ExceptionService {
             error: errorName,
             message: errorMessage,
             status: errorStatus,
+            stack: this.env.development ? error.stack : undefined,
         })
     }
 }