@superblocksteam/sdk 1.8.2 → 1.9.1

package/dist/sdk.js

@@ -14,7 +14,7 @@ class SuperblocksSdk {
         this.superblocksBaseUrl = superblocksBaseUrl;
         this.cliVersion = cliVersion;
     }
-    async fetchApplication({ applicationId, branch, headers = {}, viewMode = "export-live", fetchSinglePageApplication = false, }) {
+    async fetchApplication({ applicationId, branch, headers = {}, viewMode = "export-live", skipSigningVerification = false, }) {
         return (0, client_1.fetchApplication)({
             cliVersion: this.cliVersion,
             applicationId,
@@ -22,8 +22,8 @@ class SuperblocksSdk {
             token: this.token,
             superblocksBaseUrl: this.superblocksBaseUrl,
             viewMode,
+            skipSigningVerification,
             injectedHeaders: headers,
-            fetchSinglePageApplication,
         });
     }
     async fetchApplicationBranches(applicationId, headers = {}) {
@@ -35,7 +35,7 @@ class SuperblocksSdk {
             injectedHeaders: headers,
         });
     }
-    async fetchApplicationWithComponents({ applicationId, branch, headers = {}, viewMode = "export-live", fetchSinglePageApplication = false, }) {
+    async fetchApplicationWithComponents({ applicationId, branch, headers = {}, viewMode = "export-live", commitId, skipSigningVerification = false, }) {
         return (0, client_1.fetchApplicationWithComponents)({
             cliVersion: this.cliVersion,
             applicationId,
@@ -43,15 +43,40 @@ class SuperblocksSdk {
             token: this.token,
             superblocksBaseUrl: this.superblocksBaseUrl,
             viewMode,
+            skipSigningVerification,
+            commitId,
             injectedHeaders: headers,
-            fetchSinglePageApplication,
+        });
+    }
+    async fetchApplicationCommits({ applicationId, branch, headers = {}, limit, offset, }) {
+        return (0, client_1.fetchApplicationCommits)({
+            cliVersion: this.cliVersion,
+            applicationId,
+            branch,
+            token: this.token,
+            superblocksBaseUrl: this.superblocksBaseUrl,
+            injectedHeaders: headers,
+            limit,
+            offset,
+        });
+    }
+    async fetchApiCommits({ apiId, branch, headers = {}, limit, offset, }) {
+        return (0, client_1.fetchApiCommits)({
+            cliVersion: this.cliVersion,
+            applicationId: apiId,
+            branch,
+            token: this.token,
+            superblocksBaseUrl: this.superblocksBaseUrl,
+            injectedHeaders: headers,
+            limit,
+            offset,
         });
     }
     async fetchApplications(headers) {
         return (0, client_1.fetchApplications)(this.cliVersion, this.token, this.superblocksBaseUrl, headers);
     }
-    async fetchApi(apiId, viewMode = "export-live", branch) {
-        return (0, client_1.fetchApi)(this.cliVersion, apiId, this.token, this.superblocksBaseUrl, viewMode, branch);
+    async fetchApi({ apiId, branch, viewMode = "export-live", commitId, skipSigningVerification = false, }) {
+        return (0, client_1.fetchApi)(this.cliVersion, apiId, this.token, this.superblocksBaseUrl, viewMode, branch, commitId, skipSigningVerification);
     }
     async fetchApis() {
         return (0, client_1.fetchApis)(this.cliVersion, this.token, this.superblocksBaseUrl);
@@ -76,7 +101,7 @@ class SuperblocksSdk {
     async fetchCurrentUser() {
         return (0, client_1.fetchCurrentUser)(this.cliVersion, this.token, this.superblocksBaseUrl);
     }
-    async pushApplication({ applicationId, applicationConfig, branch, headers = {}, multiPage = false, }) {
+    async pushApplication({ applicationId, applicationConfig, branch, headers = {}, }) {
         return (0, client_1.pushApplication)({
             cliVersion: this.cliVersion,
             applicationId,
@@ -85,7 +110,6 @@ class SuperblocksSdk {
             branch,
             injectedHeaders: headers,
             applicationConfig,
-            multiPage,
         });
     }
     async pushApi({ apiId, apiConfig, branch, headers = {}, }) {

package/dist/socket/handlers.d.ts

@@ -1,5 +1,5 @@
 import { LocalGitRepoState } from "@superblocksteam/util";
-import { ApiToSign, ApiToVerify, AppToSign, AppToVerify, MethodHandlers, RemoteCommitDto, Signature } from "../types";
+import { ApiToSign, ApiToVerify, AppToSign, AppToVerify, MethodHandlers, RemoteCommitDto, Signature, ViewMode } from "../types";
 type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
 export interface ClientMethods {
     v1: {
@@ -93,11 +93,20 @@ export interface ServerMethods {
                 pushCommit: ServerMethodSchema<{
                     apiId: string;
                     branchName: string;
-                    commitId: string;
-                    commitMessage: string;
+                    commitId?: string;
+                    commitMessage?: string;
                     apiPb: Record<string, unknown>;
                     gitState: LocalGitRepoState;
-                }, RemoteCommitDto>;
+                    skipCommit: boolean;
+                }, RemoteCommitDto | {
+                    updated: Date;
+                }>;
+                get: ServerMethodSchema<{
+                    apiId: string;
+                    branchName?: string;
+                    viewMode: ViewMode;
+                    commitId?: string;
+                }, any>;
             };
         };
     };
@@ -107,13 +116,22 @@ export interface ServerMethods {
                 pushCommit: ServerMethodSchema<{
                     applicationId: string;
                     branchName: string;
-                    commitId: string;
-                    commitMessage: string;
+                    commitId?: string;
+                    commitMessage?: string;
                     application: Record<string, unknown>;
                     pages: Record<string, unknown>[];
                     apis: Record<string, unknown>[];
                     gitState: LocalGitRepoState;
-                }, RemoteCommitDto>;
+                    skipCommit: boolean;
+                }, RemoteCommitDto | {
+                    updated: Date;
+                }>;
+                get: ServerMethodSchema<{
+                    applicationId: string;
+                    viewMode: ViewMode;
+                    branchName?: string;
+                    commitId?: string;
+                }, any>;
             };
         };
     };

package/dist/socket/index.d.ts

@@ -1,26 +1,18 @@
 import WebSocket from "ws";
+import { GenericMiddleware, ISocketClient, MethodHandlers, RequestContextBase, SocketTimeouts } from "../types";
 import { ServerMethods } from "./handlers";
+import { ISocket } from "./socket";
 export type StdISocketRPCClient = ISocketClient<ServerMethods>;
 export declare function connectToISocketRPCServer({ superblocksBaseUrl, agentUrl, token, }: {
     superblocksBaseUrl: string;
     token: string;
     agentUrl?: string;
 }): Promise<StdISocketRPCClient>;
-export declare function connectISocket<CallableMethods, ImplementedMethods, RequestContext = never>(wsUrl: string, authorization: string | undefined, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>): Promise<ISocketClient<CallableMethods>>;
+export declare class ISocketWithClientAuth<ImplementedMethods, CallableMethods, RequestContext extends RequestContextBase> extends ISocket<ImplementedMethods, CallableMethods, RequestContext> {
+    private readonly authorization?;
+    private hasSentAuth;
+    constructor(ws: WebSocket, authorization: string | undefined, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>, globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[], timeouts?: SocketTimeouts);
+    request<Params, Result>(method: string, params: Params): Promise<Result>;
+}
+export declare function connectISocket<CallableMethods, ImplementedMethods, RequestContext extends RequestContextBase = RequestContextBase>(wsUrl: string, authorization: string | undefined, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>, globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[], timeouts?: SocketTimeouts): Promise<ISocketClient<CallableMethods>>;
 export declare function connectWebSocket(wsUrl: string): Promise<WebSocket>;
-type MethodHandler<Params, Result, PeerMethods, RequestContext> = (params: Params, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<Result>;
-type MiddlewareHandler<Params, PeerMethods, RequestContext> = (params: Params, peerAuthorization: string | undefined, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<void>;
-type MethodHandlers<Methods, PeerMethods, RequestContext> = {
-    [Key in keyof Methods]: Methods[Key] extends (params: infer Params) => Promise<infer Result> ? [
-        ...middlewareHandlers: MiddlewareHandler<Params, PeerMethods, RequestContext>[],
-        handler: MethodHandler<Params, Result, PeerMethods, RequestContext>
-    ] : Methods[Key] extends Record<string, unknown> ? MethodHandlers<Methods[Key], PeerMethods, RequestContext> : never;
-};
-type ISocketClientMethodCall<Methods> = {
-    [Key in keyof Methods]: Methods[Key] extends (params: infer P) => Promise<infer R> ? (params: P) => Promise<R> : Methods[Key] extends Record<string, unknown> ? ISocketClientMethodCall<Methods[Key]> : never;
-};
-type ISocketClient<Methods> = {
-    close: () => void;
-    call: ISocketClientMethodCall<Methods>;
-};
-export {};

package/dist/socket/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectWebSocket = exports.connectISocket = exports.connectToISocketRPCServer = void 0;
+exports.connectWebSocket = exports.connectISocket = exports.ISocketWithClientAuth = exports.connectToISocketRPCServer = void 0;
 const tslib_1 = require("tslib");
 const ws_1 = tslib_1.__importDefault(require("ws"));
 const handlers_1 = require("./handlers");
@@ -24,15 +24,18 @@ async function connectToISocketRPCServer({ superblocksBaseUrl, agentUrl, token,
     else if (wsUrl.hostname === "localhost") {
         wsUrl.hostname = "127.0.0.1";
     }
-    return await connectISocket(wsUrl.href, authorization, requestHandlers);
+    return await connectISocket(wsUrl.href, authorization, requestHandlers, [], {
+        connectionTimeoutInSeconds: 6 * 60,
+        noResponseTimeoutInSeconds: 5 * 60, // 5 minutes
+    });
 }
 exports.connectToISocketRPCServer = connectToISocketRPCServer;
 // a subclass of ISocket that sends an auth token on the first request
 // this is useful for client-side sockets that need to authenticate
 // TODO(george): if we start using this for long-lived connections, we should add a way to refresh the token
 class ISocketWithClientAuth extends socket_1.ISocket {
-    constructor(ws, authorization, requestHandlers) {
-        super(ws, requestHandlers);
+    constructor(ws, authorization, requestHandlers, globalMiddlewares, timeouts) {
+        super(ws, requestHandlers, globalMiddlewares, timeouts);
         this.hasSentAuth = false;
         this.authorization = authorization;
     }
@@ -45,9 +48,10 @@ class ISocketWithClientAuth extends socket_1.ISocket {
         return result;
     }
 }
-async function connectISocket(wsUrl, authorization, requestHandlers) {
+exports.ISocketWithClientAuth = ISocketWithClientAuth;
+async function connectISocket(wsUrl, authorization, requestHandlers, globalMiddlewares, timeouts) {
     const ws = await connectWebSocket(wsUrl);
-    const isocket = new ISocketWithClientAuth(ws, authorization, requestHandlers);
+    const isocket = new ISocketWithClientAuth(ws, authorization, requestHandlers, globalMiddlewares, timeouts);
     return (0, socket_1.createISocketClient)(isocket);
 }
 exports.connectISocket = connectISocket;

package/dist/socket/socket.d.ts

@@ -1,16 +1,60 @@
 import WebSocket from "ws";
-import { ISocketClient, MethodHandlers } from "../types";
-export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
+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?;
-    private nxtRequestId;
-    constructor(ws: WebSocket, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>);
-    private handleEvent;
+    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>;
-    private respond;
-    private respondError;
+    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>(socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>): ISocketClient<CallableMethods>;
+export declare function createISocketClient<CallableMethods, ImplementedMethods, RequestContext extends RequestContextBase>(socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>): ISocketClient<CallableMethods>;
+export {};

package/dist/socket/socket.js

@@ -1,72 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createISocketClient = exports.ISocket = void 0;
+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 {
-    constructor(ws, requestHandlers) {
-        this.responseHandler = {};
+    constructor(ws, requestHandlers, globalMiddlewares, timeouts, logger) {
+        this.responseHandler = new Map();
         this.ws = ws;
         this.requestHandlers = requestHandlers;
+        this.globalMiddlewares = globalMiddlewares;
         this.nxtRequestId = 0;
-        this.ws.addEventListener("message", (event) => {
+        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) => {
             const eventData = JSON.parse(event.data.toString());
-            void this.handleEvent(eventData);
+            return this.handleMessage(eventData);
         });
     }
-    async handleEvent(eventData) {
-        if (eventData.request) {
+    async handleMessage(message) {
+        this.resetConnectionTimeout();
+        if (message.request) {
             // Split the method string into parts
-            const parts = eventData.request.method.split(".");
+            const parts = message.request.method.split(".");
             let handlers = this.requestHandlers;
             for (const part of parts) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
                 handlers = handlers[part];
                 if (!handlers) {
-                    return this.respondError(eventData.request.id, {
+                    return this.respondError(message.request.id, {
                         code: 2,
-                        message: `unknown method ${eventData.request.method}`,
+                        message: `unknown method ${message.request.method}`,
                     });
                 }
             }
             if (!Array.isArray(handlers)) {
-                return this.respondError(eventData.request.id, {
+                return this.respondError(message.request.id, {
                     code: 2,
                     message: "unknown method",
                 });
             }
-            if (eventData.request.setAuthorization) {
-                this.peerAuthorization = eventData.request.setAuthorization;
+            handlers = [...this.globalMiddlewares, ...handlers];
+            if (message.request.setAuthorization) {
+                this.peerAuthorization = message.request.setAuthorization;
             }
-            const middlewareHandlers = handlers.slice(0, -1);
-            const handler = handlers[handlers.length - 1];
-            const reqCtx = {};
-            let response;
-            // TODO(george): maybe we should not create a new client for each request
+            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 {
-                for (const middlewareHandler of middlewareHandlers) {
-                    await middlewareHandler(eventData.request.payload, this.peerAuthorization, client, reqCtx);
-                }
-                response = await handler(eventData.request.payload, client, reqCtx);
+                // call the first handler in the chain
+                response = await generateNextFn(0)();
             }
             catch (error) {
-                return this.respondError(eventData.request.id, {
-                    code: 3,
-                    message: error.toString(),
-                });
+                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(eventData.request.id, response);
+            this.respond(message.request.id, response);
+            alreadyResponded = true;
         }
-        else if (eventData.response && eventData.response.id) {
-            if (!this.responseHandler[eventData.response.id]) {
+        else if (message.response && message.response.id) {
+            const responseHandler = this.responseHandler.get(message.response.id);
+            if (!responseHandler) {
                 return;
             }
-            if (eventData.response.error) {
-                this.responseHandler[eventData.response.id].reject(eventData.response.error);
+            if (message.response.error) {
+                responseHandler.reject(message.response.error);
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.responseHandler[eventData.response.id].resolve(eventData.response.payload);
-            delete this.responseHandler[eventData.response.id];
+            responseHandler.resolve(message.response.payload);
+            clearTimeout(responseHandler.timeout);
+            this.responseHandler.delete(message.response.id);
         }
         else {
             return this.respondError(-1, {
@@ -75,13 +117,16 @@ class ISocket {
             });
         }
     }
+    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[requestId] = {
+            this.responseHandler.set(requestId, {
                 resolve: (result) => resolve(result),
                 reject: (error) => reject(error),
-            };
+            });
             const toSend = {
                 request: {
                     method,
@@ -91,6 +136,7 @@ class ISocket {
                 },
             };
             this.ws.send(JSON.stringify(toSend));
+            this.resetNoResponseTimeout(requestId);
         });
     }
     respond(requestId, result) {
@@ -113,7 +159,52 @@ class ISocket {
         };
         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();
     }
 }
@@ -152,7 +243,7 @@ path) {
 function createISocketClient(socket) {
     return {
         close: () => socket.close(),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         call: createIsocketProxy(socket, undefined),
     };
 }

package/dist/types/common.d.ts

@@ -6,7 +6,6 @@ export interface UserMeDto {
 }
 export interface FlagBootstrap {
     "ui.enable-resource-signing"?: boolean;
-    "ui.multi-page.enabled"?: boolean;
 }
 export type User = {
     id: string;
@@ -123,3 +122,4 @@ export interface RemoteCommitDto {
     branchName: string;
     repositoryId: string;
 }
+export type ViewMode = "export-deployed" | "export-latest" | "export-live" | "export-commit";

package/dist/types/socket.d.ts

@@ -1,10 +1,13 @@
-export type MethodHandler<Params, Result, PeerMethods, RequestContext> = (params: Params, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<Result>;
-export type MiddlewareHandler<Params, PeerMethods, RequestContext> = (params: Params, peerAuthorization: string | undefined, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<void>;
+export interface RequestContextBase {
+    peerAuthorization?: string;
+    method: string;
+    requestId: number;
+}
+export type MethodHandler<Params, Result, PeerMethods, RequestContext> = (params: Params, ctx: RequestContext, peer: ISocketClient<PeerMethods>, next: () => Promise<Result>) => Promise<Result>;
+export type GenericMiddleware<PeerMethods, RequestContext> = MethodHandler<any, any, PeerMethods, RequestContext>;
+export type NonEmptyArray<T> = [...T[], T];
 export type MethodHandlers<Methods, PeerMethods, RequestContext> = {
-    [Key in keyof Methods]: Methods[Key] extends (params: infer Params) => Promise<infer Result> ? [
-        ...middlewareHandlers: MiddlewareHandler<Params, PeerMethods, RequestContext>[],
-        handler: MethodHandler<Params, Result, PeerMethods, RequestContext>
-    ] : Methods[Key] extends Record<string, unknown> ? MethodHandlers<Methods[Key], PeerMethods, RequestContext> : never;
+    [Key in keyof Methods]: Methods[Key] extends (params: infer Params) => Promise<infer Result> ? NonEmptyArray<MethodHandler<Params, Result, PeerMethods, RequestContext>> : Methods[Key] extends Record<string, unknown> ? MethodHandlers<Methods[Key], PeerMethods, RequestContext> : never;
 };
 type ISocketClientMethodCall<Methods> = {
     [Key in keyof Methods]: Methods[Key] extends (params: infer P) => Promise<infer R> ? (params: P) => Promise<R> : Methods[Key] extends Record<string, unknown> ? ISocketClientMethodCall<Methods[Key]> : never;
@@ -14,4 +17,14 @@ export type ISocketClient<Methods> = {
     call: ISocketClientMethodCall<Methods>;
 };
 export type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
+/** The exception type can be thrown to cause the default error handler to write a raw error response to the socket */
+export declare class SocketErrorException extends Error {
+    readonly code: number;
+    readonly message: string;
+    constructor(code: number, message: string);
+}
+export type SocketTimeouts = {
+    noResponseTimeoutInSeconds?: number;
+    connectionTimeoutInSeconds?: number;
+};
 export {};

package/dist/types/socket.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketErrorException = void 0;
+/** The exception type can be thrown to cause the default error handler to write a raw error response to the socket */
+class SocketErrorException extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+}
+exports.SocketErrorException = SocketErrorException;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/sdk",
-  "version": "1.8.2",
+  "version": "1.9.1",
   "description": "Superblocks JS SDK",
   "main": "./dist/index.js",
   "exports": {
@@ -31,7 +31,7 @@
     "typescript": "^5.1.3"
   },
   "dependencies": {
-    "@superblocksteam/util": "1.8.2",
+    "@superblocksteam/util": "1.9.1",
     "axios": "^1.3.5",
     "ws": "^8.17.0"
   },