@nsshunt/stsappframework 3.1.216 → 3.1.218

package/src/socketIoServerHelper.ts_bak

@@ -1,165 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { JSONObject, ISTSLogger } from '@nsshunt/stsutils'
-
-import { Server, Namespace, Socket } from "socket.io";
-
-import { STSSocketIONamespace, STSServerSocket, STSNamespace, 
-    ISocketIoServerHelper, ServerEventCb, InterServerEvents, STSSocketIONamespaces } from './commonTypes'
-
-import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stsobservability'
-
-export interface ISocketIoServerHelperOptions {
-    logger: ISTSLogger
-}
-
-export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientToServerEvents, ServerToClientEvents extends STSDefaultServerToClientEvents> implements ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>
-{
-    #socketIoServerHelperOptions: ISocketIoServerHelperOptions
-    #namespace: STSSocketIONamespaces = { };
-
-    constructor(options: ISocketIoServerHelperOptions) { // IProcessBase
-        this.#socketIoServerHelperOptions = options;
-    }
-
-    LogMessage(namespace: STSSocketIONamespace, message: any) {
-        this.#socketIoServerHelperOptions.logger.debug(`${namespace.namespace}: ${message}`);
-    }
-
-    LeaveRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
-        this.LogMessage(namespace, `${namespace.socketionamespace.name}: Leaving room [${room}]`);
-        socket.leave(room);
-    };
-
-    JoinRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
-        this.LogMessage(namespace, `${namespace.socketionamespace.name}: Socket joining room [${room}], ID: [${socket.id}]`);
-        socket.join(room);
-    };
-
-    #SetupStandardEvents = (namespace: STSSocketIONamespace, socket: Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents>): void => {
-        socket.on('disconnect', (reason: string) => {
-            this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
-        });
-
-        socket.on('disconnecting', (reason: string) => {
-            this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket disconnecting, ID: [${socket.id}] [${reason}]`);
-        });
-
-        socket.on('error', (error: Error) => {
-            this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket error, ID: [${socket.id}] [${error}]`);
-        });
-
-        socket.on("__STSdisconnect", (reason: string) => {
-            this.LogMessage(namespace, `${namespace.socketionamespace.name}: __STSdisconnect: socket disconnect, ID: [${socket.id}] [${reason}]`);
-        });
-
-        socket.on("__STSdisconnecting", (reason, callBackResult) => {
-            this.LogMessage(namespace, `${namespace.socketionamespace.name}: __STSdisconnecting: socket disconnecting, ID: [${socket.id}] [${reason}]`);
-            callBackResult("__STSdisconnecting accepted by server.");
-        });
-
-        socket.on('__STSjoinRoom', (rooms: string[]): void => { //@@ names
-            rooms.forEach((room) => {
-                this.JoinRoom(namespace, socket, room)
-            });
-        });
-
-        socket.on('__STSleaveRoom', (rooms: string[]): void => { //@@ names
-            rooms.forEach((room) => {
-                this.LeaveRoom(namespace, socket, room);
-            });
-        });
-
-        socket.on('__STSsendToRoom', (rooms: string[], payload: { command: string, payload: JSONObject }): void => {
-            rooms.forEach((room) => {
-                this.LogMessage(namespace, `${namespace.socketionamespace.name}:socket.on:sendToRoom: __STSsendToRoom: Sending to room [${room}], ID: [${socket.id}]`);
-                 
-                namespace.socketionamespace.to(room).emit(payload.command as any, payload);
-            });
-        });
-    }
-
-    // Use this middleward to check every incomming connection
-    #SetupConnectionMiddleware = (nameSpace: STSSocketIONamespace) => {
-        nameSpace.socketionamespace.use((socket, next) => {
-            //if (isValid(socket.request)) {
-            const a=5; // for lint purposes
-            if (a === 5) {
-                next();
-            } else {
-                next(new Error("invalid"));
-            }
-        });
-    }
-
-    // Use this middleware to check very packet being received
-    #SetupMessageMiddleware = (socket: STSServerSocket) => {
-        socket.use(([event, ...args], next) => {
-            /*
-            if (isUnauthorized(event)) {
-                return next(new Error("unauthorized event"));
-            }
-            */
-            next();
-        });
-    }
-    
-    SetupNamespace = (io: Server, namespace: STSNamespace, rooms: string[], autoJoinRooms: boolean, /* serverSocketEvents: ServerSocketEvent[], */
-        socketConnectCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null,
-        socketEventsCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null
-    ): Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents> => {
-        // Create STS Command Centre Client namespace
-        this.#namespace[namespace] = {
-            namespace: namespace,
-            pid: process.pid,
-            socketionamespace: io.of(`/${namespace}/`)
-        }
-
-        this.#SetupConnectionMiddleware(this.#namespace[namespace]);
-
-        this.#namespace[namespace].socketionamespace.on("connection", socket => {
-            this.LogMessage(this.#namespace[namespace], `${namespace}: Socket connected, ID: [${socket.id}]`);
-            this.LogMessage(this.#namespace[namespace], `${namespace}: Authentication Handshake: [${JSON.stringify(socket.handshake.auth)}]`);
-
-            this.#SetupMessageMiddleware(socket);
-
-            if (autoJoinRooms) {
-                rooms.map((room) => {
-                    this.JoinRoom(this.#namespace[namespace], socket, room);
-                });
-            }
-
-            this.#SetupStandardEvents(this.#namespace[namespace], socket);
-
-            if (socketConnectCallBack) {
-                setTimeout(() => {
-                    socketConnectCallBack(socket);
-                }, 0);
-            }
-
-            if (socketEventsCallBack) {
-                socketEventsCallBack(socket);
-            }
-        });
-
-        return this.#namespace[namespace].socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>;
-    }
-
-    GetSTSSocketIONamespace = (namespace: string): STSSocketIONamespace => {
-        return this.#namespace[namespace];
-    }
-
-    GetSTSSocketIONamespaces = (): STSSocketIONamespaces => {
-        return this.#namespace;
-    }
-
-    DisconnectSockets = (): void => {
-        for (const [, namespace] of Object.entries(this.#namespace)) {
-            namespace.socketionamespace.disconnectSockets();
-        }
-        this.#namespace = { };
-    }
-
-    SetupEvent(event: ClientToServerEvents, eventCb: ServerEventCb): ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents> {
-        return this as any;
-    }
-}

package/src/testHelpers.ts

@@ -1,327 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import chalk from 'chalk'
-
-import * as tough from 'tough-cookie'
-
-import https from 'https'
-import crypto from 'crypto';
-
-import axios from 'axios';
-
-import { GenericContainer, Network, Wait } from "testcontainers";
-
-import { goptions, $ResetOptions } from '@nsshunt/stsconfig'
-
-import { Sleep, defaultLogger } from '@nsshunt/stsutils'
-
-import { AuthUtilsNode } from './authutilsnode'
-
-export class TestHelper {
-    //#regexBase64URL = /^[A-Za-z0-9_-]+$/ // Base64URL  - https://base64.guru/standards/base64url
-    #regexURLSafeStringComponent = /[-a-zA-Z0-9@:%._+~#=]{1,256}/ // URL safe string component
-    //#regexBase64 = /(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?/ // Base64 - https://stackoverflow.com/questions/475074/regex-to-parse-or-validate-base64-data
-    #regexSTSBase64 = /SES_(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?/ // Base64
-    #regexJWT = /[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+/ // JWT (Base64URL.Base64URL.Base64URL)
-
-    #authUtilsNode = new AuthUtilsNode(defaultLogger);
-
-    #databaseContainer: any;
-    #stsAuthContainer: any;
-    #network: any;
-    #authEndpoint = '';
-    #authPort = '';
-    #authHost = '';
-    #httpsAgent: https.Agent | null = null;
-
-    constructor() {
-        this.#authEndpoint = 'https://localhost:3002'; //@@
-    }
-
-    LogDebugMessage(message: any) {
-        defaultLogger.debug(message);
-    }
-
-    #GetHttpsAgent = () =>
-    {
-        if (this.#httpsAgent === null) {
-            // https://nodejs.org/api/http.html#class-httpagent
-            this.#httpsAgent = new https.Agent({ 
-                keepAlive: goptions.keepAlive,
-                maxSockets: goptions.maxSockets,
-                maxTotalSockets: goptions.maxTotalSockets,
-                maxFreeSockets: goptions.maxFreeSockets,
-                timeout: goptions.timeout,
-                rejectUnauthorized: false
-            });
-        }
-        return this.#httpsAgent;
-    }
-
-    StartNetwork = async () => {
-        this.#network = await new Network().start();
-    }
-
-    StopNetwork = async () => {
-        await this.#network.stop();
-    }
-
-    get network() {
-        return this.#network;
-    }
-
-    get authPort() {
-        return this.#authPort;
-    }
-
-    get authHost() {
-        return this.#authHost;
-    }
-
-    get authEndpoint() {
-        return this.#authEndpoint;
-    }
-
-    get getHttpsAgent() {
-        return this.#GetHttpsAgent();
-    }
-
-    CreateRandomString = () => {
-        const charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~.'; //    /[0-9A-Za-z\-_~.]/
-        let random = '';
-        const randomValues: number[] = Array.from(crypto.getRandomValues(new Uint8Array(43)));
-        randomValues.forEach(v => (random += charset[v % charset.length]));
-        return random;
-    }
-
-    Login = async (username: string, password: string) => {
-        const client_id = process.env.CLIENT_ID as string;
-        const nonce = crypto.randomBytes(43).toString('base64'); //CreateRandomString();
-        const response_type = 'code';
-        const redirect_uri = process.env.REDIRECT_URI as string;
-        const response_mode = 'query';
-        const scope = process.env.SCOPE as string;
-        const state = crypto.randomBytes(43).toString('base64'); // CreateRandomString();
-        const code_verifier = this.CreateRandomString();
-        const code_challenge = crypto.createHash('sha256').update(code_verifier).digest('base64');
-        const code_challenge_method = 'S256';
-
-        const authoriseOptions: any = {
-            email: username,
-            password,
-            client_id,
-            nonce,
-            response_type,
-            redirect_uri,
-            response_mode,
-            scope,
-            state,
-            code_challenge,
-            code_challenge_method
-        }
-
-        const url = `${this.#authEndpoint}${goptions.asapiroot}/login`;
-        const headers = { 'Content-Type': 'application/json'};
-
-        const retVal = await axios({
-            url
-            ,method: 'post'
-            ,data: authoriseOptions
-            ,headers: headers
-            ,httpsAgent: this.#GetHttpsAgent()
-        });
-
-        //const cookieString = retVal.headers['set-cookie'];
-
-        /*
-        const api = request(this.#endpoint);
-        const retVal: any = await (api as any)
-            .post(`${goptions.asapiroot}/login`)
-            .send(authoriseOptions)
-        //.expect('set-cookie', /consent_cookie=.*; Max-Age=86; Path=\/; Expires=.*; HttpOnly; Secure; SameSite=Strict/);
-
-        const cookieString = retVal.header['set-cookie'];
-
-        if (cookieString) {
-            retVal.cookie = new Cookie(cookieString[0]);
-        }
-        */
-
-        return retVal;
-    }
-
-    /*
-    GetAuthServerAPITokenFromServer = async (): Promise<string> => {
-        return await this.#authUtilsNode.GetAPITokenFromAuthServer(STSClientID.STSTestingService, 
-            "eN9u0mHZLGWZrdnE1zit2vL6xwUFW466sTZcbkXDml5KWxlvKaZ1uiOZmA==", 
-            goptions.asapiidentifier, this.#authEndpoint)
-    }
-    */
-
-    ValidateJWT = async (token: string): Promise<string> => {
-        return await this.#authUtilsNode.ValidateJWT(token, goptions.asapiidentifier, this.#authEndpoint);
-    }
-
-    StartDatabase = async () => {
-        this.#databaseContainer = await new GenericContainer("postgres")
-            .withExposedPorts(5432)
-            .withEnvironment({
-                POSTGRES_PASSWORD: "postgres",
-                //UV_THREADPOOL_SIZE: "64"
-            })
-            .withNetwork(this.#network)
-            .withNetworkAliases("database")
-            .start();
-
-        const httpPort = this.#databaseContainer.getMappedPort(5432);
-        const host = this.#databaseContainer.getHost();
-        const networkIpAddress = this.#databaseContainer.getIpAddress(this.#network.getName());
-        
-        process.env.DB_HOST = `${host}:${httpPort}`;
-
-        $ResetOptions();
-
-        this.LogDebugMessage(chalk.green(`httpPort: [${httpPort}]`));
-        this.LogDebugMessage(chalk.green(`host: [${host}]`));
-        this.LogDebugMessage(chalk.green(`networkIpAddress: [${networkIpAddress}]`));
-        this.LogDebugMessage(chalk.green(`connectionString: [${goptions.connectionString}]`));
-        this.LogDebugMessage(chalk.green(`defaultDatabaseConnectionString: [${goptions.defaultDatabaseConnectionString }]`));
-    }
-
-    StopDatabase = async () => {
-        if (this.#databaseContainer) {
-            await this.#databaseContainer.stop();
-
-            this.LogDebugMessage(chalk.yellow(`Used the following parameters for the database during testing:`));
-            this.LogDebugMessage(chalk.yellow(`connectionString: [${goptions.connectionString}]`));
-            this.LogDebugMessage(chalk.yellow(`defaultDatabaseConnectionString: [${goptions.defaultDatabaseConnectionString }]`));
-        }
-    }
-
-    // Note: .withCopyFilesToContainer and .withCopyContentToContainer have a defect in that Jest will not close. A file handle/stream is left open
-    // within the underlying code.
-    InitializeDatabase = async () => {
-        const stsAuthContainerInit = await new GenericContainer("serza/stsauth:latest")
-            .withEnvironment({
-                DB_USER: "postgres",
-                DB_PASSWORD: "postgres",
-                DB_HOST: "database:5432", // "192.168.14.101",
-                POOL_SIZE: "50",
-                MAX_CPU: "2",
-                DEBUG: "proc*",
-                HTTPS_SERVER_KEY_PATH: "/var/lib/sts/stsglobalresources/keys-tmp/server.key",
-                HTTPS_SERVER_CERT_PATH: "/var/lib/sts/stsglobalresources/keys-tmp/server.cert",
-                AS_ENDPOINT: "https://stscore.stsmda.org"
-            })
-            .withCommand(["node", "dist/app", "create"])
-            .withNetwork(this.#network)
-            .withNetworkAliases("stsauthrunnerinit")
-            .withWaitStrategy(Wait.forLogMessage(`User registered: {"status":200,"detail":{"id":"USR_STSGlobalAdminUser@stsmda.com","name":"STSGlobalAdminUser@stsmda.com","email":"STSGlobalAdminUser@stsmda.com","roles":[]}}`))
-            .start();
-
-        await Sleep(500);
-
-        await stsAuthContainerInit.stop();
-    }
-
-    StartAuthService = async () => {
-        this.#stsAuthContainer = await new GenericContainer("serza/stsauth:latest")
-            .withExposedPorts(3002)
-            .withEnvironment({
-                DB_USER: "postgres",
-                DB_PASSWORD: "postgres",
-                DB_HOST: "database:5432", 
-                POOL_SIZE: "50",
-                MAX_CPU: "2",
-                DEBUG: "proc*",
-                HTTPS_SERVER_KEY_PATH: "/var/lib/sts/stsglobalresources/keys-tmp/server.key",
-                HTTPS_SERVER_CERT_PATH: "/var/lib/sts/stsglobalresources/keys-tmp/server.cert",
-                AS_ENDPOINT: "https://stscore.stsmda.org"
-            })
-            .withNetwork(this.#network)
-            .withNetworkAliases("stsauthrunner")
-            .withWaitStrategy(Wait.forHttp("/stsauth/v1.0/latency", 3002).usingTls().allowInsecure())
-            .start();
-
-        const httpAuthPort = this.#stsAuthContainer.getMappedPort(3002);
-
-        await Sleep(200);
-        this.LogDebugMessage(chalk.green(`-------------------------------------------------------------------------------------------`));
-        this.LogDebugMessage(chalk.green(`                                 *** STSAuth Started ***: [${httpAuthPort}]`));
-        this.LogDebugMessage(chalk.green(`-------------------------------------------------------------------------------------------`));
-
-        this.#authHost = 'https://localhost'
-        this.#authPort = httpAuthPort;
-        this.#authEndpoint = `${this.#authHost}:${this.#authPort}`;
-    }
-
-    StopAuthService = async () => {
-        if (this.#stsAuthContainer) {
-            await this.#stsAuthContainer.stop();
-            await Sleep(200);
-        }
-    }
-
-    TestLoginAndVerify = async () => {
-        expect.assertions(4);
-
-        const retVal = await this.Login('user01@stsmda.com.au', 'user01password');
-        expect(retVal.status).toEqual(200);
-
-        this.LogDebugMessage(chalk.red(`${JSON.stringify(retVal.data)}`));
-        this.LogDebugMessage(chalk.magenta(`${JSON.stringify(retVal.headers)}`));
-        this.LogDebugMessage(chalk.yellow(`${JSON.stringify(retVal.headers['set-cookie'])}`));
-
-        const cookies = retVal.headers['set-cookie'] as string[];
-        this.LogDebugMessage(chalk.yellow(`${cookies[0]}`));
-        this.LogDebugMessage(chalk.green(`${JSON.stringify(tough.Cookie.parse(cookies[0]))}`));
-
-        const cookie = tough.Cookie.parse(cookies[0]) as tough.Cookie;
-
-        const desiredCookieResultAxios = {
-            key: 'consent_cookie',
-            value: expect.stringMatching(this.#regexURLSafeStringComponent),
-            path: '/',
-            secure: true,
-            httpOnly: true,
-            sameSite: 'strict',
-        }
-
-        const cookieResult = JSON.parse(JSON.stringify(cookie));
-        expect(cookieResult).toMatchObject(desiredCookieResultAxios);
-
-        const cookieExpireDate = new Date(cookie.expires);
-        expect(cookieExpireDate.getTime()).toBeGreaterThan(new Date().getTime());
-
-        const desiredResult = {
-            sessionId: expect.stringMatching(this.#regexSTSBase64),
-            id_token: expect.stringMatching(this.#regexJWT),
-            consentRequired: [
-                'api://d8277fce-bb48-44c2-bbf1-257fe13a444b/res01.create',
-                'api://d8277fce-bb48-44c2-bbf1-257fe13a444b/res01.read',
-                'api://d8277fce-bb48-44c2-bbf1-257fe13a444b/res01.update',
-                'api://d8277fce-bb48-44c2-bbf1-257fe13a444b/res01.delete'
-            ]
-        }
-        expect(retVal.data.detail).toMatchObject(desiredResult);
-    }
-
-    /*
-    TestValidateJWT = async () => {
-        expect.assertions(1);
-
-        const access_token = await this.GetAuthServerAPITokenFromServer();
-        this.LogDebugMessage(chalk.green(`access_token: [${access_token}]`));
-
-        const retVal = await this.ValidateJWT(access_token);
-        // https://jestjs.io/docs/expect#tomatchobjectobject
-        const desiredJWT = {
-            scope: 'offline_access session.read session.update',
-            iss: 'https://stscore.stsmda.org/oauth2/v2.0',
-            aud: 'https://stsmda.com.au/stsauthapi/v1.0/',
-            sub: 'session'
-        };
-
-        expect(retVal).toMatchObject(desiredJWT);
-    }
-    */
-}

package/types/authutilsnode.d.ts

@@ -1,27 +0,0 @@
-import tough from 'tough-cookie';
-import { ISTSLogger } from '@nsshunt/stsutils';
-import { PublishInstrumentController } from '@nsshunt/stsobservability';
-export interface IAuthUtilsNodeOptions {
-    permissions: string[];
-}
-export interface IGetAPITokenFromAuthServerUsingScopeOptions {
-    clientId: string;
-    authClientSecret: string;
-    scope: string;
-    endPoint: string;
-    instrumentController?: PublishInstrumentController;
-    outputErrorsToConsole?: boolean;
-}
-export declare class AuthUtilsNode {
-    #private;
-    constructor(logger: ISTSLogger);
-    ResetAgent: () => void;
-    VerifyRequestMiddlewareFactory: (options: IAuthUtilsNodeOptions) => (req: any, res: any, next: any) => Promise<void>;
-    verifyRequestMiddleware(req: any, res: any, next: any): Promise<void>;
-    SetCookiesToJar: (headers: Record<string, any>, endpoint: string) => Promise<tough.Cookie[]>;
-    GetCookiesFromJar: (endpoint: string) => Promise<tough.Cookie[]>;
-    ValidateJWT: (token: string, audience: string, endpoint?: string) => Promise<string>;
-    ExtractOrigin: (uri: string) => string | null;
-    GetAPITokenFromAuthServerUsingScope: (options: IGetAPITokenFromAuthServerUsingScopeOptions, errorCb: (error: Error) => void) => Promise<string>;
-}
-//# sourceMappingURL=authutilsnode.d.ts.map

package/types/authutilsnode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authutilsnode.d.ts","sourceRoot":"","sources":["../src/authutilsnode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,cAAc,CAAC;AAUjC,OAAO,EAAmB,UAAU,EAAc,MAAM,mBAAmB,CAAA;AAQ3E,OAAO,EAAS,2BAA2B,EAAE,MAAM,2BAA2B,CAAA;AAI9E,MAAM,WAAW,qBAAqB;IAClC,WAAW,EAAE,MAAM,EAAE,CAAA;CACxB;AAED,MAAM,WAAW,2CAA2C;IACxD,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,oBAAoB,CAAC,EAAE,2BAA2B,CAAA;IAClD,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAClC;AAWD,qBAAa,aAAa;;gBAUV,MAAM,EAAE,UAAU;IAyB9B,UAAU,aAET;IAED,8BAA8B,YAAa,qBAAqB,WAEzC,GAAG,OAAO,GAAG,QAAQ,GAAG,mBAyC9C;IAmBK,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG;IAyB3D,eAAe,YAAmB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAY,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAgB/F;IAEF,iBAAiB,aAAoB,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAGnE;IAEF,WAAW,UAAiB,MAAM,YAAY,MAAM,aAAa,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAgCxF;IAGD,aAAa,QAAS,MAAM,mBAG3B;IAED,mCAAmC,YAAmB,2CAA2C,WAAW,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAG,OAAO,CAAC,MAAM,CAAC,CA6HnJ;CACJ"}

package/types/testHelpers.d.ts

@@ -1,23 +0,0 @@
-import https from 'https';
-export declare class TestHelper {
-    #private;
-    constructor();
-    LogDebugMessage(message: any): void;
-    StartNetwork: () => Promise<void>;
-    StopNetwork: () => Promise<void>;
-    get network(): any;
-    get authPort(): string;
-    get authHost(): string;
-    get authEndpoint(): string;
-    get getHttpsAgent(): https.Agent;
-    CreateRandomString: () => string;
-    Login: (username: string, password: string) => Promise<import("axios").AxiosResponse<any, any>>;
-    ValidateJWT: (token: string) => Promise<string>;
-    StartDatabase: () => Promise<void>;
-    StopDatabase: () => Promise<void>;
-    InitializeDatabase: () => Promise<void>;
-    StartAuthService: () => Promise<void>;
-    StopAuthService: () => Promise<void>;
-    TestLoginAndVerify: () => Promise<void>;
-}
-//# sourceMappingURL=testHelpers.d.ts.map

package/types/testHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testHelpers.d.ts","sourceRoot":"","sources":["../src/testHelpers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAA;AAazB,qBAAa,UAAU;;;IAqBnB,eAAe,CAAC,OAAO,EAAE,GAAG;IAoB5B,YAAY,sBAEX;IAED,WAAW,sBAEV;IAED,IAAI,OAAO,QAEV;IAED,IAAI,QAAQ,WAEX;IAED,IAAI,QAAQ,WAEX;IAED,IAAI,YAAY,WAEf;IAED,IAAI,aAAa,gBAEhB;IAED,kBAAkB,eAMjB;IAED,KAAK,aAAoB,MAAM,YAAY,MAAM,sDAsDhD;IAUD,WAAW,UAAiB,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAEnD;IAED,aAAa,sBAwBZ;IAED,YAAY,sBAQX;IAID,kBAAkB,sBAsBjB;IAED,gBAAgB,sBA6Bf;IAED,eAAe,sBAKd;IAED,kBAAkB,sBA0CjB;CAqBJ"}