@omnitronix/game-engine-sdk 1.0.1

package/dist/common/secrets-provider/secrets-provider.local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets-provider.local.d.ts","sourceRoot":"","sources":["../../../src/common/secrets-provider/secrets-provider.local.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBACa,oBAAqB,YAAW,eAAe;IAC1D,OAAO,CAAC,YAAY,CAAkC;;IAMtD,OAAO,CAAC,WAAW;IAUb,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAM/C"}

package/dist/common/secrets-provider/secrets-provider.local.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSecretsProvider = void 0;
+const common_1 = require("@nestjs/common");
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let LocalSecretsProvider = class LocalSecretsProvider {
+    constructor() {
+        this.secretsCache = new Map();
+        this.loadSecrets();
+    }
+    loadSecrets() {
+        const envPath = path.resolve(process.cwd(), '.secrets.env');
+        if (fs.existsSync(envPath)) {
+            const parsed = dotenv.parse(fs.readFileSync(envPath));
+            Object.entries(parsed).forEach(([key, value]) => {
+                this.secretsCache.set(key, value);
+            });
+        }
+    }
+    async get(secretName) {
+        if (this.secretsCache.has(secretName)) {
+            return this.secretsCache.get(secretName);
+        }
+        throw new Error(`Secret ${secretName} not found in local secrets file`);
+    }
+};
+exports.LocalSecretsProvider = LocalSecretsProvider;
+exports.LocalSecretsProvider = LocalSecretsProvider = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], LocalSecretsProvider);

package/dist/common/secrets-provider/secrets-provider.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class SecretsModule {
+    static register(): DynamicModule;
+}
+//# sourceMappingURL=secrets-provider.module.d.ts.map

package/dist/common/secrets-provider/secrets-provider.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets-provider.module.d.ts","sourceRoot":"","sources":["../../../src/common/secrets-provider/secrets-provider.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAkB,MAAM,gBAAgB,CAAC;AAO/D,qBAIa,aAAa;IACxB,MAAM,CAAC,QAAQ,IAAI,aAAa;CAsBjC"}

package/dist/common/secrets-provider/secrets-provider.module.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SecretsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretsModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const secrets_provider_1 = require("./secrets-provider");
+const secrets_provider_aws_1 = require("./secrets-provider.aws");
+const secrets_provider_local_1 = require("./secrets-provider.local");
+let SecretsModule = SecretsModule_1 = class SecretsModule {
+    static register() {
+        return {
+            module: SecretsModule_1,
+            providers: [
+                {
+                    provide: secrets_provider_1.SECRETS_PROVIDER,
+                    useFactory: async (configService) => {
+                        const useLocalSecrets = configService.get('LOCAL_SECRETS') === 'true';
+                        if (useLocalSecrets) {
+                            return new secrets_provider_local_1.LocalSecretsProvider();
+                        }
+                        else {
+                            const awsSecretsProvider = new secrets_provider_aws_1.AwsSecretsProvider(configService);
+                            await awsSecretsProvider.register();
+                            return awsSecretsProvider;
+                        }
+                    },
+                    inject: [config_1.ConfigService],
+                },
+            ],
+            exports: [secrets_provider_1.SECRETS_PROVIDER],
+        };
+    }
+};
+exports.SecretsModule = SecretsModule;
+exports.SecretsModule = SecretsModule = SecretsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [config_1.ConfigModule],
+    })
+], SecretsModule);

package/dist/esm/bootstrap/index.js

@@ -0,0 +1,120 @@
+import { Logger } from '../common/logger/logger';
+import { ExceptionsFilter } from '../common/error-handling/all-exceptions.filter';
+import { InternalErrorCode } from '../common/error-handling/internal-error-code';
+import { setupDocumentation } from '../common/api-docs/setup-documentation';
+import { SHUTDOWN_OUT_PORT, } from '../health/application/ports/out/shutdown.out-port';
+import { GameEngineGrpcInAdapter } from '../grpc/game-engine.grpc.in-adapter';
+import { createConnectRouter } from '../grpc/connect-router.middleware';
+import { BadRequestException, RequestMethod, ValidationPipe } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { NestFactory } from '@nestjs/core';
+import * as http2 from 'http2';
+/**
+ * Creates and bootstraps a game engine NestJS application with
+ * standard configuration: CORS, validation pipes, exception filters,
+ * Swagger docs, Connect RPC gRPC server, and graceful shutdown.
+ */
+export async function createGameEngineApp(options) {
+    const { serviceName, appModule, bootstrapOptions } = options;
+    const logger = new Logger(serviceName);
+    const moduleArg = bootstrapOptions
+        ? appModule.register
+            ? appModule.register(bootstrapOptions)
+            : appModule
+        : appModule;
+    const app = await NestFactory.create(moduleArg, {
+        logger: logger,
+    });
+    app.enableCors({ origin: true });
+    const configService = app.get(ConfigService);
+    const shutdownService = app.get(SHUTDOWN_OUT_PORT);
+    let isShuttingDown = false;
+    const handleFatalError = async (errorType, error) => {
+        logger.error(`${errorType}:`, {
+            error: error.message,
+            stack: error.stack,
+        });
+        if (isShuttingDown) {
+            logger.warn('Shutdown already in progress, ignoring additional error');
+            return;
+        }
+        isShuttingDown = true;
+        try {
+            logger.warn(`Initiating graceful shutdown due to ${errorType}...`);
+            await shutdownService.startGracefulShutdown();
+            logger.log('Graceful shutdown completed, exiting process');
+        }
+        catch (shutdownError) {
+            logger.error('Error during graceful shutdown:', shutdownError);
+        }
+        finally {
+            process.exit(1);
+        }
+    };
+    process.on('uncaughtException', (error) => {
+        logger.error('Uncaught Exception:', {
+            error: error.message,
+            stack: error.stack,
+        });
+        void handleFatalError('uncaughtException', error);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        logger.error('Unhandled Rejection:', {
+            reason: reason.message,
+            stack: reason.stack,
+            promise,
+        });
+        void handleFatalError('unhandledRejection', reason);
+    });
+    app.setGlobalPrefix('api', {
+        exclude: [
+            { path: 'health', method: RequestMethod.GET },
+            { path: 'ready', method: RequestMethod.GET },
+            { path: 'metrics', method: RequestMethod.GET },
+        ],
+    });
+    app.useGlobalPipes(new ValidationPipe({
+        whitelist: true,
+        forbidNonWhitelisted: true,
+        transform: true,
+        exceptionFactory: errors => {
+            const messages = errors.map(error => Object.values(error.constraints || {}).join(', '));
+            return new BadRequestException({
+                statusCode: 400,
+                internalCode: InternalErrorCode.VALIDATION_ERROR,
+                message: messages,
+                timestamp: new Date().toISOString(),
+                path: '/api',
+            });
+        },
+    }));
+    app.useGlobalFilters(app.get(ExceptionsFilter));
+    const PORT = configService.get('PORT') || 3000;
+    await setupDocumentation(app, PORT, serviceName);
+    // Setup Connect RPC server
+    const gameEngineAdapter = app.get(GameEngineGrpcInAdapter);
+    const connectRouter = createConnectRouter(gameEngineAdapter);
+    // Mount Connect router on /connect path
+    app.use('/connect', connectRouter);
+    app.enableShutdownHooks(['SIGTERM', 'SIGINT']);
+    // Start separate h2c (HTTP/2 cleartext) server for Connect RPC
+    const GRPC_PORT = configService.get('GRPC_PORT', 50051);
+    const h2cServer = http2.createServer({}, connectRouter);
+    h2cServer.on('error', (err) => {
+        logger.error('h2c gRPC server error:', err);
+    });
+    h2cServer.listen(GRPC_PORT, '0.0.0.0', () => {
+        logger.log(`Connect RPC (h2c) is available on: http://localhost:${GRPC_PORT}`);
+    });
+    // Close h2c server during graceful shutdown
+    const closeH2c = () => {
+        h2cServer.close(() => {
+            logger.log('h2c gRPC server closed');
+        });
+    };
+    process.on('SIGTERM', closeH2c);
+    process.on('SIGINT', closeH2c);
+    await app.listen(PORT, '0.0.0.0');
+    logger.log(`Application is running on: http://localhost:${PORT}`);
+    return app;
+}

package/dist/esm/common/api-docs/setup-documentation.js

@@ -0,0 +1,23 @@
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { Logger } from '../logger/logger';
+const logger = new Logger('ApiDocs');
+export const setupDocumentation = async (app, port, serviceName) => {
+    const config = new DocumentBuilder()
+        .setTitle(serviceName ? `${serviceName} API` : 'Game Engine API')
+        .setDescription('API documentation')
+        .setOpenAPIVersion('3.0.0')
+        .build();
+    const document = SwaggerModule.createDocument(app, config);
+    SwaggerModule.setup('docs', app, document, {
+        jsonDocumentUrl: 'docs/json',
+        yamlDocumentUrl: 'docs/yaml',
+        swaggerOptions: {
+            tagsSorter: 'alpha',
+            operationsSorter: 'alpha',
+            docExpansion: 'list',
+            filter: true,
+            showRequestHeaders: true,
+        },
+    });
+    logger.log(`Documentation is available on: http://localhost:${port}/docs`);
+};

package/dist/esm/common/application-bootstrap-options.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/common/error-handling/all-exceptions.filter.js

@@ -0,0 +1,128 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ExceptionsFilter_1;
+import { Logger } from '../logger/logger';
+import { METRICS_PORT } from '../metrics/metrics.port';
+import { Catch, HttpException, HttpStatus, Inject, } from '@nestjs/common';
+import { DomainException } from './domain.exception';
+import { ErrorCodeMapper } from './error-code-mapper';
+import { InternalErrorCode } from './internal-error-code';
+let ExceptionsFilter = ExceptionsFilter_1 = class ExceptionsFilter {
+    constructor(metricsPort) {
+        this.metricsPort = metricsPort;
+        this.logger = new Logger(ExceptionsFilter_1.name);
+    }
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const errorResponse = this.buildErrorResponse(exception, request);
+        response.status(errorResponse.statusCode).json(errorResponse);
+    }
+    buildErrorResponse(exception, request) {
+        if (exception instanceof DomainException) {
+            return this.handleDomainException(exception, request);
+        }
+        if (exception instanceof HttpException) {
+            return this.handleHttpException(exception, request);
+        }
+        if (exception instanceof Error) {
+            return this.handleGenericError(exception, request);
+        }
+        return this.handleUnknownError(exception, request);
+    }
+    handleDomainException(exception, request) {
+        const status = ErrorCodeMapper.mapToHttpStatus(exception.errorCode);
+        const level = status >= 500 ? 'error' : 'warn';
+        this.logger.log(`DomainException (status: ${status} at ${request.method} ${request.url}): Internal Code ${exception.errorCode} Message: ${exception.message}`, { level });
+        if (exception.cause) {
+            this.logger.error('Exception cause:', exception.cause);
+        }
+        return this.buildResponsePayload({
+            status,
+            internalCode: exception.errorCode,
+            message: exception.message,
+            path: request.url,
+        });
+    }
+    handleHttpException(exception, request) {
+        const status = exception.getStatus();
+        const responseData = exception.getResponse();
+        // Check if this is a custom validation error response
+        if (typeof responseData === 'object' &&
+            responseData.internalCode &&
+            responseData.statusCode) {
+            return responseData;
+        }
+        let message = 'HTTP Exception';
+        if (typeof responseData === 'string') {
+            message = responseData;
+        }
+        else if (typeof responseData === 'object' && responseData.message) {
+            message = responseData.message;
+        }
+        const level = status >= 500 ? 'error' : 'warn';
+        this.logger.log(`HttpException (status: ${status} at ${request.method} ${request.url}): ${message}`, { level });
+        if (status === 401 || status === 403) {
+            const internalCode = status === 401 ? InternalErrorCode.UNAUTHORIZED : InternalErrorCode.FORBIDDEN;
+            return this.buildResponsePayload({
+                status,
+                internalCode,
+                message,
+                path: request.url,
+            });
+        }
+        if (status === HttpStatus.INTERNAL_SERVER_ERROR) {
+            this.logger.error('HttpException stack:', exception.stack);
+        }
+        return this.buildResponsePayload({
+            status,
+            internalCode: InternalErrorCode.INTERNAL_SERVER_ERROR,
+            message,
+            path: request.url,
+        });
+    }
+    handleGenericError(exception, request) {
+        this.logger.error(`Unhandled Error (status: ${HttpStatus.INTERNAL_SERVER_ERROR} at ${request.method} ${request.url}): ${exception.stack}`);
+        return this.buildResponsePayload({
+            status: HttpStatus.INTERNAL_SERVER_ERROR,
+            internalCode: InternalErrorCode.INTERNAL_SERVER_ERROR,
+            message: exception.message,
+            path: request.url,
+        });
+    }
+    handleUnknownError(exception, request) {
+        this.logger.error(`Unknown error type (status: ${HttpStatus.INTERNAL_SERVER_ERROR} at ${request.method} ${request.url}): ${String(exception)}`);
+        return this.buildResponsePayload({
+            status: HttpStatus.INTERNAL_SERVER_ERROR,
+            internalCode: InternalErrorCode.INTERNAL_SERVER_ERROR,
+            message: 'Internal server error',
+            path: request.url,
+        });
+    }
+    buildResponsePayload({ status, internalCode, message, path, }) {
+        return {
+            statusCode: status,
+            internalCode,
+            message,
+            timestamp: new Date().toISOString(),
+            path,
+        };
+    }
+};
+ExceptionsFilter = ExceptionsFilter_1 = __decorate([
+    Catch(),
+    __param(0, Inject(METRICS_PORT)),
+    __metadata("design:paramtypes", [Object])
+], ExceptionsFilter);
+export { ExceptionsFilter };

package/dist/esm/common/error-handling/domain.exception.js

@@ -0,0 +1,10 @@
+export class DomainException extends Error {
+    constructor(errorCode, message, cause) {
+        super(message);
+        this.errorCode = errorCode;
+        this.message = message;
+        this.cause = cause;
+        this.name = 'DomainException';
+        this.cause = cause;
+    }
+}

package/dist/esm/common/error-handling/error-code-mapper.js

@@ -0,0 +1,89 @@
+import { InternalErrorCode } from './internal-error-code';
+// HTTP status codes
+const HttpStatus = {
+    BAD_REQUEST: 400,
+    CONFLICT: 409,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    UNPROCESSABLE_ENTITY: 422,
+    INTERNAL_SERVER_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503,
+};
+export class ErrorCodeMapper {
+    static mapToHttpStatus(errorCode) {
+        return this.ERROR_CODE_TO_HTTP_MAP[errorCode] || HttpStatus.BAD_REQUEST;
+    }
+}
+ErrorCodeMapper.ERROR_CODE_TO_HTTP_MAP = {
+    [InternalErrorCode.FORBIDDEN]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.INVALID_CURRENCY_CODE]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INSUFFICIENT_FUNDS]: HttpStatus.UNPROCESSABLE_ENTITY,
+    [InternalErrorCode.INTERNAL_SERVER_ERROR]: HttpStatus.INTERNAL_SERVER_ERROR,
+    // Game Catalog errors
+    [InternalErrorCode.GAME_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.GAME_CONFIG_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.GAME_CONFIG_ALREADY_EXISTS_WITH_SAME_JURISDICTION_AND_RTP]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.OPERATOR_GAME_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.OPERATOR_GAME_ALREADY_ENABLED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INVALID_GAME_CONFIG_DATA]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INVALID_GAME_UPDATE_DATA]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.GAME_CODE_ALREADY_EXISTS]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.GAME_OR_GAME_CONFIG_DISABLED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.DEBUG_COMMANDS_DISABLED]: HttpStatus.FORBIDDEN,
+    // Game Orchestrator errors
+    [InternalErrorCode.INVALID_SESSION]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SESSION_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.SESSION_NOT_ACTIVE]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SESSION_MISMATCH]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INVALID_STATE_TRANSITION]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INVALID_BET_AMOUNT]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.REALITY_CHECK_IN_PROGRESS]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.UNKNOWN_COMMAND]: HttpStatus.NOT_FOUND,
+    // Operator errors
+    [InternalErrorCode.MISSING_OPERATOR_CODE]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INVALID_OPERATOR_CODE]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.OPERATOR_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.OPERATOR_INACTIVE]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.COUNTRY_CODE_RESTRICTED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.UNAUTHORIZED]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.AUTH_VALIDATION_FAILED]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.BALANCE_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.INVALID_AUTH_DATA]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.VALIDATION_ERROR]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.JURISDICTION_CONFIG_ALREADY_EXISTS]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.JURISDICTION_CONFIG_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.OPERATOR_JURISDICTION_CONFIG_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.GAME_ENGINE_ERROR]: HttpStatus.INTERNAL_SERVER_ERROR,
+    [InternalErrorCode.DEBIT_FAILED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.CREDIT_FAILED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.GAME_ROUND_LOG_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    // Geo Validation errors
+    [InternalErrorCode.COUNTRY_NOT_PERMITTED]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.GEO_VALIDATION_SERVICE_UNAVAILABLE]: HttpStatus.INTERNAL_SERVER_ERROR,
+    [InternalErrorCode.RESOURCE_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.FINANCIAL_TRANSACTION_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.SESSION_TERMINATED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SESSION_CANNOT_BE_TERMINATED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SESSION_AUTO_RESOLVE_FAILED]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SESSION_ALREADY_EXISTS]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.INCOMPATIBLE_GAMEPLAY_CONFIG]: HttpStatus.BAD_REQUEST,
+    // Health check errors
+    [InternalErrorCode.HEALTH_CHECK_FAILED]: HttpStatus.SERVICE_UNAVAILABLE,
+    //Jackpot errors
+    [InternalErrorCode.JACKPOT_TYPE_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.JACKPOT_TIER_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.JACKPOT_CONFIGURATION_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.JACKPOT_CONFIGURATION_IS_ACTIVE]: HttpStatus.BAD_REQUEST,
+    // RNG and Replay errors
+    [InternalErrorCode.RNG_SEED_NOT_FOUND]: HttpStatus.NOT_FOUND,
+    [InternalErrorCode.RNG_SEED_MISMATCH]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.MASTER_HASH_INVALID]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.REPLAY_OUTCOME_MISMATCH]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.JACKPOT_POOL_CONTRIBUTION_ALREADY_PROCESSED]: HttpStatus.INTERNAL_SERVER_ERROR,
+    [InternalErrorCode.JACKPOT_TYPE_DOES_NOT_SUPPORT_TIERS]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.CONCURRENT_MODIFICATION]: HttpStatus.CONFLICT,
+    [InternalErrorCode.ACCOUNT_LOCKED]: HttpStatus.FORBIDDEN,
+    [InternalErrorCode.DAILY_LIMIT_EXCEEDED]: HttpStatus.UNPROCESSABLE_ENTITY,
+    [InternalErrorCode.INVALID_AMOUNT]: HttpStatus.BAD_REQUEST,
+    [InternalErrorCode.SERVICE_UNAVAILABLE]: HttpStatus.SERVICE_UNAVAILABLE,
+};

package/dist/esm/common/error-handling/internal-error-code.js

@@ -0,0 +1,77 @@
+export var InternalErrorCode;
+(function (InternalErrorCode) {
+    InternalErrorCode["FORBIDDEN"] = "FORBIDDEN";
+    InternalErrorCode["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    InternalErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+    InternalErrorCode["INVALID_CURRENCY_CODE"] = "INVALID_CURRENCY_CODE";
+    // Game Catalog errors
+    InternalErrorCode["GAME_NOT_FOUND"] = "GAME_NOT_FOUND";
+    InternalErrorCode["GAME_CONFIG_NOT_FOUND"] = "GAME_CONFIG_NOT_FOUND";
+    InternalErrorCode["GAME_CONFIG_ALREADY_EXISTS_WITH_SAME_JURISDICTION_AND_RTP"] = "GAME_CONFIG_ALREADY_EXISTS_WITH_SAME_JURISDICTION_AND_RTP";
+    InternalErrorCode["OPERATOR_GAME_NOT_FOUND"] = "OPERATOR_GAME_NOT_FOUND";
+    InternalErrorCode["OPERATOR_GAME_ALREADY_ENABLED"] = "OPERATOR_GAME_ALREADY_ENABLED";
+    InternalErrorCode["INVALID_GAME_CONFIG_DATA"] = "INVALID_GAME_CONFIG_DATA";
+    InternalErrorCode["INVALID_GAME_UPDATE_DATA"] = "INVALID_GAME_UPDATE_DATA";
+    InternalErrorCode["GAME_CODE_ALREADY_EXISTS"] = "GAME_CODE_ALREADY_EXISTS";
+    InternalErrorCode["GAME_ENGINE_ERROR"] = "GAME_ENGINE_ERROR";
+    InternalErrorCode["GAME_OR_GAME_CONFIG_DISABLED"] = "GAME_OR_GAME_CONFIG_DISABLED";
+    InternalErrorCode["DEBUG_COMMANDS_DISABLED"] = "DEBUG_COMMANDS_DISABLED";
+    // Game Orchestrator errors
+    InternalErrorCode["INVALID_SESSION"] = "INVALID_SESSION";
+    InternalErrorCode["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
+    InternalErrorCode["SESSION_NOT_ACTIVE"] = "SESSION_NOT_ACTIVE";
+    InternalErrorCode["SESSION_MISMATCH"] = "SESSION_MISMATCH";
+    InternalErrorCode["INVALID_STATE_TRANSITION"] = "INVALID_STATE_TRANSITION";
+    InternalErrorCode["INVALID_BET_AMOUNT"] = "INVALID_BET_AMOUNT";
+    InternalErrorCode["REALITY_CHECK_IN_PROGRESS"] = "REALITY_CHECK_IN_PROGRESS";
+    InternalErrorCode["SESSION_TERMINATED"] = "SESSION_TERMINATED";
+    InternalErrorCode["SESSION_CANNOT_BE_TERMINATED"] = "SESSION_CANNOT_BE_TERMINATED";
+    InternalErrorCode["SESSION_AUTO_RESOLVE_FAILED"] = "SESSION_AUTO_RESOLVE_FAILED";
+    InternalErrorCode["SESSION_ALREADY_EXISTS"] = "SESSION_ALREADY_EXISTS";
+    InternalErrorCode["INCOMPATIBLE_GAMEPLAY_CONFIG"] = "INCOMPATIBLE_GAMEPLAY_CONFIG";
+    InternalErrorCode["UNKNOWN_COMMAND"] = "UNKNOWN_COMMAND";
+    // Operator errors
+    InternalErrorCode["MISSING_OPERATOR_CODE"] = "MISSING_OPERATOR_CODE";
+    InternalErrorCode["INVALID_OPERATOR_CODE"] = "INVALID_OPERATOR_CODE";
+    InternalErrorCode["OPERATOR_NOT_FOUND"] = "OPERATOR_NOT_FOUND";
+    InternalErrorCode["OPERATOR_INACTIVE"] = "OPERATOR_INACTIVE";
+    InternalErrorCode["COUNTRY_CODE_RESTRICTED"] = "COUNTRY_CODE_RESTRICTED";
+    InternalErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    InternalErrorCode["AUTH_VALIDATION_FAILED"] = "AUTH_VALIDATION_FAILED";
+    InternalErrorCode["BALANCE_NOT_FOUND"] = "BALANCE_NOT_FOUND";
+    InternalErrorCode["DEBIT_FAILED"] = "DEBIT_FAILED";
+    InternalErrorCode["CREDIT_FAILED"] = "CREDIT_FAILED";
+    InternalErrorCode["INVALID_AUTH_DATA"] = "INVALID_AUTH_DATA";
+    InternalErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    InternalErrorCode["JURISDICTION_CONFIG_ALREADY_EXISTS"] = "JURISDICTION_CONFIG_ALREADY_EXISTS";
+    InternalErrorCode["JURISDICTION_CONFIG_NOT_FOUND"] = "JURISDICTION_CONFIG_NOT_FOUND";
+    InternalErrorCode["OPERATOR_JURISDICTION_CONFIG_NOT_FOUND"] = "OPERATOR_JURISDICTION_CONFIG_NOT_FOUND";
+    // Game round log errors
+    InternalErrorCode["GAME_ROUND_LOG_NOT_FOUND"] = "GAME_ROUND_LOG_NOT_FOUND";
+    // Geo Validation errors
+    InternalErrorCode["COUNTRY_NOT_PERMITTED"] = "COUNTRY_NOT_PERMITTED";
+    InternalErrorCode["GEO_VALIDATION_SERVICE_UNAVAILABLE"] = "GEO_VALIDATION_SERVICE_UNAVAILABLE";
+    InternalErrorCode["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+    // Financial transaction errors
+    InternalErrorCode["FINANCIAL_TRANSACTION_NOT_FOUND"] = "FINANCIAL_TRANSACTION_NOT_FOUND";
+    //Health check errors
+    InternalErrorCode["HEALTH_CHECK_FAILED"] = "HEALTH_CHECK_FAILED";
+    //Jackpot errors
+    InternalErrorCode["JACKPOT_TYPE_NOT_FOUND"] = "JACKPOT_TYPE_NOT_FOUND";
+    InternalErrorCode["JACKPOT_TIER_NOT_FOUND"] = "JACKPOT_TIER_NOT_FOUND";
+    InternalErrorCode["JACKPOT_CONFIGURATION_NOT_FOUND"] = "JACKPOT_CONFIGURATION_NOT_FOUND";
+    InternalErrorCode["JACKPOT_CONFIGURATION_IS_ACTIVE"] = "JACKPOT_CONFIGURATION_IS_ACTIVE";
+    InternalErrorCode["JACKPOT_POOL_CONTRIBUTION_ALREADY_PROCESSED"] = "JACKPOT_POOL_CONTRIBUTION_ALREADY_PROCESSED";
+    InternalErrorCode["JACKPOT_TYPE_DOES_NOT_SUPPORT_TIERS"] = "JACKPOT_TYPE_DOES_NOT_SUPPORT_TIERS";
+    // RNG and Replay errors
+    InternalErrorCode["RNG_SEED_NOT_FOUND"] = "RNG_SEED_NOT_FOUND";
+    InternalErrorCode["RNG_SEED_MISMATCH"] = "RNG_SEED_MISMATCH";
+    InternalErrorCode["MASTER_HASH_INVALID"] = "MASTER_HASH_INVALID";
+    InternalErrorCode["REPLAY_OUTCOME_MISMATCH"] = "REPLAY_OUTCOME_MISMATCH";
+    // Concurrency
+    InternalErrorCode["CONCURRENT_MODIFICATION"] = "CONCURRENT_MODIFICATION";
+    InternalErrorCode["ACCOUNT_LOCKED"] = "ACCOUNT_LOCKED";
+    InternalErrorCode["DAILY_LIMIT_EXCEEDED"] = "DAILY_LIMIT_EXCEEDED";
+    InternalErrorCode["INVALID_AMOUNT"] = "INVALID_AMOUNT";
+    InternalErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+})(InternalErrorCode || (InternalErrorCode = {}));

package/dist/esm/common/index.js

@@ -0,0 +1,25 @@
+// Logger
+export { Logger } from './logger/logger';
+export { LoggerModule } from './logger/logger.module';
+export { LoggingMiddleware } from './logger/logging.middleware';
+// Error Handling
+export { DomainException } from './error-handling/domain.exception';
+export { InternalErrorCode } from './error-handling/internal-error-code';
+export { ErrorCodeMapper } from './error-handling/error-code-mapper';
+export { ExceptionsFilter } from './error-handling/all-exceptions.filter';
+// Secrets Provider
+export { SECRETS_PROVIDER } from './secrets-provider/secrets-provider';
+export { SecretsModule } from './secrets-provider/secrets-provider.module';
+export { LocalSecretsProvider } from './secrets-provider/secrets-provider.local';
+export { AwsSecretsProvider } from './secrets-provider/secrets-provider.aws';
+// Retry
+export { RetryPolicy } from './retry/retry-policy';
+export { RetryPolicies, HTTP_RETRYABLE_ERRORS } from './retry/retry-policies';
+// Metrics
+export { METRICS_PORT } from './metrics/metrics.port';
+export { PrometheusService } from './metrics/prometheus.service';
+export { MetricsModule } from './metrics/metrics.module';
+export { DatabaseMetricsService } from './metrics/database-metrics.service';
+export { toMinorUnits, getEventCountBucket, getStreamVersionBucket, sanitizeRoute, } from './metrics/helpers/metrics.helpers';
+// API Docs
+export { setupDocumentation } from './api-docs/setup-documentation';