@breautek/storm 9.2.7 → 9.3.0

package/src/ForbiddenError.ts

@@ -0,0 +1,41 @@
+/*
+   Copyright 2017-2026 Norman Breau
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import {StormError} from './StormError';
+import {ErrorCode} from './ErrorCode';
+import {StatusCode} from './StatusCode';
+
+export class ForbiddenError extends StormError {
+    public constructor() {
+        super();
+    }
+
+    public getMessage(): string {
+        return `Access Denied.`;
+    }
+
+    public getCode(): ErrorCode {
+        return 0;
+    }
+
+    public getHTTPCode(): StatusCode {
+        return StatusCode.ERR_FORBIDDEN;
+    }
+
+    public override getLocaleCode(): string {
+        return '@breautek/storm/ForbiddenError/message';
+    }
+}

package/src/JWTVerifyOptionsParser.ts

@@ -17,9 +17,7 @@
 import {IJWTVerifyOptions} from './IJWTVerifyOptions';
 
 export class JWTVerifyOptionsParser {
-    constructor() {
-        throw new Error('JWTVerifyOptionsParser is an static class.');
-    }
+    private constructor() {}
 
     // Parses IJWTVerifyOptions to jwt options
     public static parse(options: IJWTVerifyOptions): any {

package/src/MetricStore.ts

@@ -0,0 +1,61 @@
+
+export type TSupportedMetricStoreValues = string | number | boolean;
+
+export class MetricStore {
+    private static $instance: MetricStore;
+
+    private $data: Record<string, TSupportedMetricStoreValues>;
+
+    private constructor() {
+        this.$data = {};
+    }
+
+    public static getInstance(): MetricStore {
+        if (!MetricStore.$instance) {
+            MetricStore.$instance = new MetricStore();
+        }
+
+        return MetricStore.$instance;
+    }
+
+    public purge(): void {
+        this.$data = {};
+    }
+
+    public set(key: string, value: TSupportedMetricStoreValues): void {
+        this.$data[key] = value;
+    }
+
+    public get(key: string): TSupportedMetricStoreValues | null {
+        let value: TSupportedMetricStoreValues = this.$data[key];
+        if (value === undefined) return null;
+        return value;
+    }
+
+    public increment(key: string): void {
+        let value: TSupportedMetricStoreValues = this.get(key);
+        
+        if (!value) {
+            value = 0;
+        }
+
+        if (typeof value !== 'number') {
+            this.set(key, 0);
+            return;
+        }
+
+        value++;
+        this.set(key, value);
+    }
+
+    public decrement(key: string): void {
+        let value: TSupportedMetricStoreValues = this.get(key);
+        if (value === null || value === undefined || typeof value !== 'number') {
+            this.set(key, 0);
+            return;
+        }
+
+        value--;
+        this.set(key, value);
+    }
+}

package/src/MySQLConnection.ts

@@ -40,6 +40,7 @@ import { GetProcessList, IGetProcessListOutput } from './private/GetProcessList'
 import { GetMySQLVersion, IGetMySQLVersionResult } from './GetMySQLVersion';
 import { GetPrimaryPositionQuery } from './private/GetPrimaryPositionQuery';
 import { queryFormatter } from './mysql/queryFormatter';
+import { MetricStore } from './MetricStore';
 
 const DEFAULT_HIGH_WATERMARK: number = 512; // in number of result objects
 const TAG: string = 'MySQLConnection';
@@ -342,35 +343,25 @@ export class MySQLConnection extends DatabaseConnection<MySQL.PoolConnection> {
         });
     }
 
-    protected _close(forceClose: boolean): Promise<void> {
+    protected async _close(forceClose: boolean): Promise<void> {
         if (!forceClose && this.isTransaction()) {
             return Promise.reject(new Error('Cannot close a connection while there is an active transaction. Use commit or rollback first.'));
         }
 
         this.$opened = false;
-        
-        return new Promise<void>((resolve, reject) => {
-            let rollbackPromise: Promise<void> = null;
-            if (forceClose) {
-                if (this.isTransaction()) {
-                    rollbackPromise = this.rollback();
+
+        if (forceClose) {
+            if (this.isTransaction()) {
+                try {
+                    await this.rollback();
                 }
-                else {
-                    rollbackPromise = Promise.resolve();
+                catch (ex) {
+                    getInstance().getLogger().error(TAG, ex);
                 }
             }
-            else {
-                rollbackPromise = Promise.resolve();
-            }
+        }
 
-            rollbackPromise.then(() => {
-                this.getAPI().release();
-                resolve();
-            }).catch((error: any) => {
-                getInstance().getLogger().error(TAG, error);
-                this.getAPI().release();
-                resolve();
-            });
-        });
+        this.getAPI().release();
+        MetricStore.getInstance().decrement('mysql.active_connections');
     }
 }

package/src/MySQLDatabase.ts

@@ -21,6 +21,7 @@ import {getInstance} from './instance';
 import { IDatabasePosition } from './IDatabasePosition';
 import { ConnectionReplicationWaiter } from './private/ConnectionReplicationWaiter';
 import { ILogger } from '@arashi/interfaces';
+import { MetricStore } from './MetricStore';
 
 const TAG: string = 'MySQLDatabase';
 
@@ -69,6 +70,7 @@ export class MySQLDatabase extends Database<MySQL.PoolOptions, MySQL.PoolConnect
                     return;
                 }
     
+                MetricStore.getInstance().increment('mysql.active_connections');
                 resolve(new MySQLConnection(connection, instantationStack, !requireWriteAccess));
             });
         });
@@ -85,7 +87,6 @@ export class MySQLDatabase extends Database<MySQL.PoolOptions, MySQL.PoolConnect
         logger.trace(TAG, `Replication Enabled: ${conn.hasReplicationEnabled() ? 'true' : 'false'}`);
         logger.trace(TAG, `Connection Replicating: ${conn.isReplication() ? 'true' : 'false'}`);
 
-
         if (conn.hasReplicationEnabled() && conn.isReplication() && position && position.page && position.position) {
             logger.trace(TAG, 'Connection is waiting on Replication');
             // master connections will not wait on database positions

package/src/Transaction.ts

@@ -83,7 +83,7 @@ export class Transaction implements IQueryable<void> {
         let attemptCount: number = 0;
         do {
             attemptCount++;
-            this.$application.getLogger().info(TAG, `Starting transaction attempt ${attemptCount} of ${this.$retryLimit === Infinity ? 'Infinity' : this.$retryLimit.toString()}`);
+            this.$application.getLogger().trace(TAG, `Starting transaction attempt ${attemptCount} of ${this.$retryLimit === Infinity ? 'Infinity' : this.$retryLimit.toString()}`);
             await connection.startTransaction(this.$isolationLevel, this.$accessLevel);
             try {
                 await this.$executor(connection);

package/src/api.ts

@@ -48,6 +48,7 @@ export {GetMySQLVersion, IGetMySQLVersionResult, IGetMySQLVersionRow} from './Ge
 // Errors
 export {ErrorCode} from './ErrorCode';
 export {RawError} from './RawError';
+export {ForbiddenError} from './ForbiddenError';
 export {
     StormError,
     IErrorResponse,
@@ -104,6 +105,7 @@ export {TokenManager, TExpiresIn} from './TokenManager';
 
 // Utils
 export {ExitCode} from './ExitCode';
+export {MetricStore} from './MetricStore';
 
 // Database Objects
 export {TCoordinate} from './TCoordinate';

package/src/handlers/HealthHandler.ts

@@ -0,0 +1,37 @@
+
+import { IAuthTokenData } from '@arashi/token';
+import { Application } from '../Application';
+import {Handler} from '../Handler';
+import { Request } from '../Request';
+import { MetricStore } from '../MetricStore';
+import { ForbiddenError } from '../ForbiddenError';
+
+export interface IHealthHandlerMySQLStats {
+    activeConnections: number;
+}
+
+export interface IHealthHandlerOutput {
+    mysql: IHealthHandlerMySQLStats;
+}
+
+export class HealthHandler extends Handler<
+    Application,
+    void,
+    IHealthHandlerOutput
+> {
+    protected override async _get(request: Request<void, IAuthTokenData>): Promise<IHealthHandlerOutput> {
+
+        if (request.getIP() !== '127.0.0.1') {
+            throw new ForbiddenError();
+        }
+
+        let metrics: MetricStore = MetricStore.getInstance();
+        let out: IHealthHandlerOutput = {
+            mysql: {
+                activeConnections: metrics.get('mysql.active_connections') as number
+            }
+        };
+
+        return out;
+    }
+}