@superblocksteam/sdk 1.14.2 → 1.99.99-next.2

package/.eslintrc.json

@@ -1,55 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "plugins": [
-    "@typescript-eslint",
-    "prettier",
-    "import",
-    "unicorn"
-  ],
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/recommended-requiring-type-checking",
-    "plugin:prettier/recommended",
-    "prettier",
-    "plugin:import/typescript"
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module",
-    "project": "./tsconfig.json"
-  },
-  "rules": {
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/no-var-requires": "off",
-    "@typescript-eslint/no-unsafe-return": "off",
-    "@typescript-eslint/no-unsafe-member-access": "off",
-    "@typescript-eslint/restrict-template-expressions": "off",
-    "@typescript-eslint/no-unsafe-assignment": "off",
-    "@typescript-eslint/no-unsafe-argument": "off",
-    "@typescript-eslint/no-unsafe-call": "off",
-    "import/order": [
-      "error",
-      {
-        "alphabetize": { "order": "asc" },
-        "groups": [
-          "builtin",
-          "external",
-          "internal",
-          "parent",
-          "sibling",
-          "index",
-          "object",
-          "type"
-        ]
-      }
-    ],
-    "import/no-cycle": "error",
-    "no-template-curly-in-string": "off",
-    "no-useless-escape": "off",
-    "no-void": ["error", { "allowAsStatement": true }]
-  },
-  "ignorePatterns": ["public", "build", "node_modules", "dist"]
-}

package/dist/socket/socket.d.ts

@@ -1,60 +0,0 @@
-import WebSocket from "ws";
-import { ISocketClient, MethodHandler, MethodHandlers, RequestContextBase, SocketTimeouts, GenericMiddleware } from "../types";
-interface SocketRequest<Payload = unknown> {
-    method: string;
-    payload: Payload;
-    id: number;
-    setAuthorization?: string;
-}
-interface SocketResponse<Payload = unknown> {
-    id: number;
-    payload: Payload;
-    error: SocketError | null;
-}
-export interface SocketMessage<RequestPayload = unknown, ResponsePayload = unknown> {
-    request?: SocketRequest<RequestPayload>;
-    response?: SocketResponse<ResponsePayload>;
-}
-export interface SocketError {
-    message: string;
-    code: number;
-}
-/**
- * ISocket is a class that wraps a WebSocket connection and provides a simple interface for sending and receiving messages.
- * ISocket is initialized by both server and client and request/response is called symmetrically.
- *
- * ISocket handles has two timeout actions:
- * 1. Connection timeout: If the connection is not closed after a certain time, the connection is closed.
- *  - This is useful to prevent a connection from being open indefinitely. This is mainly used in the server side since
- *    the client side manages connection lifecycle manually.
- * 2. No response timeout: If the response is not received after a certain time, the request is timed out.
- *  - This is mainly used by CLI to handle the case where the server is not responding.
- *
- * It is expected that timeouts should be relatively sorted in the order of connection timeout > request timeout > no response timeout.
- */
-export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext extends RequestContextBase> {
-    private readonly ws;
-    private readonly requestHandlers;
-    private readonly globalMiddlewares;
-    private readonly responseHandler;
-    private peerAuthorization?;
-    protected nxtRequestId: number;
-    private connectionTimeout?;
-    private logger;
-    private timeouts?;
-    constructor(ws: WebSocket, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>, globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[], timeouts?: SocketTimeouts, logger?: {
-        error: (message?: string) => void;
-    });
-    protected handleMessage(message: SocketMessage): Promise<void>;
-    protected callHandler<Params, Result, CallableMethods, RequestContext extends RequestContextBase>(handler: MethodHandler<Params, Result, CallableMethods, RequestContext>, params: Params, ctx: RequestContext, client: ISocketClient<CallableMethods>, next: () => Promise<Result>): Promise<Result>;
-    request<Params, Result>(method: string, params: Params, authorization?: string): Promise<Result>;
-    protected respond<Result>(requestId: number, result: Result): void;
-    protected respondError(requestId: number, error: SocketError): void;
-    private resetConnectionTimeout;
-    private handleConnectionTimeout;
-    private resetNoResponseTimeout;
-    private handleNoResponseTimeout;
-    close(): void;
-}
-export declare function createISocketClient<CallableMethods, ImplementedMethods, RequestContext extends RequestContextBase>(socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>): ISocketClient<CallableMethods>;
-export {};

package/dist/socket/socket.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ISocket = void 0;
-exports.createISocketClient = createISocketClient;
-const types_1 = require("../types");
-/**
- * ISocket is a class that wraps a WebSocket connection and provides a simple interface for sending and receiving messages.
- * ISocket is initialized by both server and client and request/response is called symmetrically.
- *
- * ISocket handles has two timeout actions:
- * 1. Connection timeout: If the connection is not closed after a certain time, the connection is closed.
- *  - This is useful to prevent a connection from being open indefinitely. This is mainly used in the server side since
- *    the client side manages connection lifecycle manually.
- * 2. No response timeout: If the response is not received after a certain time, the request is timed out.
- *  - This is mainly used by CLI to handle the case where the server is not responding.
- *
- * It is expected that timeouts should be relatively sorted in the order of connection timeout > request timeout > no response timeout.
- */
-class ISocket {
-    ws;
-    requestHandlers;
-    globalMiddlewares;
-    responseHandler = new Map();
-    peerAuthorization;
-    nxtRequestId;
-    connectionTimeout;
-    // pino library not available in shared
-    logger;
-    timeouts;
-    constructor(ws, requestHandlers, globalMiddlewares, timeouts, logger) {
-        this.ws = ws;
-        this.requestHandlers = requestHandlers;
-        this.globalMiddlewares = globalMiddlewares;
-        this.nxtRequestId = 0;
-        this.logger = logger ?? { error: console.error };
-        this.timeouts = timeouts;
-        // reset connection timeout in each message received. It means connection still active
-        this.resetConnectionTimeout();
-        this.ws.addEventListener("message", 
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (event) => {
-            // eslint-disable-next-line @typescript-eslint/no-base-to-string
-            const eventData = JSON.parse(event.data.toString());
-            return this.handleMessage(eventData);
-        });
-    }
-    async handleMessage(message) {
-        this.resetConnectionTimeout();
-        if (message.request) {
-            // Split the method string into parts
-            const parts = message.request.method.split(".");
-            let handlers = this.requestHandlers;
-            for (const part of parts) {
-                handlers = handlers[part];
-                if (!handlers) {
-                    return this.respondError(message.request.id, {
-                        code: 2,
-                        message: `unknown method ${message.request.method}`,
-                    });
-                }
-            }
-            if (!Array.isArray(handlers)) {
-                return this.respondError(message.request.id, {
-                    code: 2,
-                    message: "unknown method",
-                });
-            }
-            handlers = [...this.globalMiddlewares, ...handlers];
-            if (message.request.setAuthorization) {
-                this.peerAuthorization = message.request.setAuthorization;
-            }
-            const reqCtx = {
-                peerAuthorization: this.peerAuthorization,
-                method: message.request.method,
-                requestId: message.request.id,
-            };
-            const client = createISocketClient(this);
-            const payload = message.request.payload;
-            let alreadyResponded = false;
-            const generateNextFn = (idx) => {
-                let wasCalled = false;
-                return async () => {
-                    if (alreadyResponded) {
-                        throw new types_1.SocketErrorException(4, "next() was called after the response was sent");
-                    }
-                    const handler = handlers[idx];
-                    if (!handler) {
-                        throw new types_1.SocketErrorException(5, "cannot call past the last handler in the chain");
-                    }
-                    if (wasCalled) {
-                        throw new types_1.SocketErrorException(6, "next() was called multiple times");
-                    }
-                    wasCalled = true;
-                    return this.callHandler(handler, payload, reqCtx, client, generateNextFn(idx + 1));
-                };
-            };
-            let response;
-            try {
-                // call the first handler in the chain
-                response = await generateNextFn(0)();
-            }
-            catch (error) {
-                const socketError = error instanceof types_1.SocketErrorException
-                    ? { code: error.code, message: error.message }
-                    : { code: 3, message: error.toString() };
-                return this.respondError(message.request.id, socketError);
-            }
-            this.respond(message.request.id, response);
-            alreadyResponded = true;
-        }
-        else if (message.response && message.response.id) {
-            const responseHandler = this.responseHandler.get(message.response.id);
-            if (!responseHandler) {
-                return;
-            }
-            if (message.response.error) {
-                responseHandler.reject(message.response.error);
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            responseHandler.resolve(message.response.payload);
-            clearTimeout(responseHandler.timeout);
-            this.responseHandler.delete(message.response.id);
-        }
-        else {
-            return this.respondError(-1, {
-                code: 3,
-                message: "unknown request id",
-            });
-        }
-    }
-    async callHandler(handler, params, ctx, client, next) {
-        return handler(params, ctx, client, next);
-    }
-    request(method, params, authorization) {
-        return new Promise((resolve, reject) => {
-            const requestId = ++this.nxtRequestId;
-            this.responseHandler.set(requestId, {
-                resolve: (result) => resolve(result),
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject: (error) => reject(error),
-            });
-            const toSend = {
-                request: {
-                    method,
-                    payload: params,
-                    id: requestId,
-                    setAuthorization: authorization,
-                },
-            };
-            this.ws.send(JSON.stringify(toSend));
-            this.resetNoResponseTimeout(requestId);
-        });
-    }
-    respond(requestId, result) {
-        const toSend = {
-            response: {
-                payload: result,
-                id: requestId,
-                error: null,
-            },
-        };
-        return this.ws.send(JSON.stringify(toSend));
-    }
-    respondError(requestId, error) {
-        const toSend = {
-            response: {
-                payload: null,
-                id: requestId,
-                error: error,
-            },
-        };
-        return this.ws.send(JSON.stringify(toSend));
-    }
-    resetConnectionTimeout() {
-        if (!this.timeouts?.connectionTimeoutInSeconds) {
-            return;
-        }
-        if (this.connectionTimeout) {
-            clearTimeout(this.connectionTimeout);
-        }
-        // Set a new timeout for the next message
-        this.connectionTimeout = setTimeout(this.handleConnectionTimeout(), this.timeouts?.connectionTimeoutInSeconds * 1000);
-    }
-    handleConnectionTimeout() {
-        return () => {
-            this.logger.error(`Connection timed out after ${this.timeouts?.connectionTimeoutInSeconds} seconds`);
-            this.close();
-        };
-    }
-    resetNoResponseTimeout(requestId) {
-        if (!this.timeouts?.noResponseTimeoutInSeconds) {
-            return;
-        }
-        const responseHandler = this.responseHandler.get(requestId);
-        if (!responseHandler) {
-            return;
-        }
-        const noResponseTimeout = responseHandler.timeout;
-        const reject = responseHandler.reject;
-        if (responseHandler.timeout) {
-            clearTimeout(noResponseTimeout);
-        }
-        // Set a new timeout for the next message
-        responseHandler.timeout = setTimeout(this.handleNoResponseTimeout(reject), this.timeouts?.noResponseTimeoutInSeconds * 1000);
-    }
-    handleNoResponseTimeout(reject) {
-        return () => {
-            const message = `Request timed out after ${this.timeouts?.noResponseTimeoutInSeconds} seconds`;
-            this.logger.error(message);
-            reject({ code: 7, message });
-        };
-    }
-    close() {
-        clearTimeout(this.connectionTimeout);
-        this.responseHandler.forEach((handler, key) => {
-            clearTimeout(handler.timeout);
-            this.logger.error(`Rejecting pending requestId ${key} due to connection close`);
-            handler.reject({ code: 8, message: "Connection closed" });
-        });
-        this.ws.close();
-    }
-}
-exports.ISocket = ISocket;
-const proxyTarget = Object.freeze(() => {
-    /* return nothing */
-});
-function createIsocketProxy(socket, 
-// if path is undefined, it means the current object is the root object
-path) {
-    return new Proxy(proxyTarget, {
-        get(_target, prop) {
-            const childPath = path ? `${path}.${prop}` : prop;
-            // sometimes, when `createISocketClient` is called from an async function, JS will implicitly call the `then` method on
-            // its return value, because promises can be arbitrarily nested
-            // so return undefined for the `then` method to avoid this
-            if (childPath === "then") {
-                return undefined;
-            }
-            return createIsocketProxy(socket, childPath);
-        },
-        apply(_target, _thisArg, args) {
-            if (path === undefined) {
-                throw new Error("The root object is not callable");
-            }
-            if (path.endsWith(".apply") &&
-                args.length === 2 &&
-                Array.isArray(args[1])) {
-                path = path.slice(0, -".apply".length);
-                args = args[1];
-            }
-            return socket.request(path, args[0]);
-        },
-    });
-}
-function createISocketClient(socket) {
-    return {
-        close: () => socket.close(),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        call: createIsocketProxy(socket, undefined),
-    };
-}