@superblocksteam/sdk 1.7.0 → 1.8.2

package/dist/client.d.ts

@@ -19,10 +19,12 @@ export interface MultiPageApplicationWrapper {
 export type PushApplicationWithCommitConfig = ApplicationWrapper & {
     commitId: string;
     commitMessage: string;
+    gitState: LocalGitRepoState;
 };
 export type PushMultiPageApplicationWithCommitConfig = MultiPageApplicationWrapper & {
     commitId: string;
     commitMessage: string;
+    gitState: LocalGitRepoState;
 };
 export interface ApiWrapper {
     apiPb: Record<string, any>;
@@ -32,6 +34,7 @@ export type PushApiWithCommitConfig = {
     apiPb: Record<string, any>;
     commitId: string;
     commitMessage: string;
+    gitState: LocalGitRepoState;
 };
 export type Branches = {
     branches: Branch[];

package/dist/client.js

@@ -249,7 +249,7 @@ async function validateGitSetup(cliVersion, resourceId, resourceType, event, loc
         else {
             message = `${e?.message ? e.message : e}`;
         }
-        const errorMessage = `Could not validate your git setup against Superblocks for the ${resourceType.toLowerCase()} ${resourceName ?? resourceId}${message ? "\n" + message : ""}`;
+        const errorMessage = `Could not validate your git setup against Superblocks for ${resourceType.toLowerCase()} ${resourceName ?? resourceId}${message ? "\n" + message : ""}`;
         // TODO(@taha-au @gpoulios-sb) Replace this check with a more robust one that uses error codes once
         // the backend starts returning them as part of the response body
         if (message.includes("Please initialize git locally")) {
@@ -477,6 +477,7 @@ async function pushApplication({ cliVersion, applicationId, token, superblocksBa
                     commitId: applicationConfig.commitId,
                     commitMessage: applicationConfig.commitMessage,
                     pages: applicationConfig.pages,
+                    gitState: applicationConfig.gitState,
                 })
                 : await socket.call.v1.public.application.pushCommit({
                     applicationId,
@@ -486,6 +487,7 @@ async function pushApplication({ cliVersion, applicationId, token, superblocksBa
                     commitId: applicationConfig.commitId,
                     commitMessage: applicationConfig.commitMessage,
                     page: applicationConfig.page,
+                    gitState: applicationConfig.gitState,
                 });
             socket.close();
             handleHttpError(resp.responseMeta.status);
@@ -565,6 +567,7 @@ async function pushApi({ cliVersion, apiId, token, superblocksBaseUrl, apiConfig
                 branchName: branch,
                 commitId: apiConfig.commitId,
                 commitMessage: apiConfig.commitMessage,
+                gitState: apiConfig.gitState,
             });
             socket.close();
             handleHttpError(resp.responseMeta.status);

package/dist/socket/handlers.d.ts

@@ -1,3 +1,4 @@
+import { LocalGitRepoState } from "@superblocksteam/util";
 import { ApiToSign, ApiToVerify, AppToSign, AppToVerify, MethodHandlers, RemoteCommitDto, Signature } from "../types";
 type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
 export interface ClientMethods {
@@ -85,6 +86,7 @@ export interface ServerMethods {
                     application: Record<string, unknown>;
                     page: Record<string, unknown>;
                     apis: Record<string, unknown>[];
+                    gitState: LocalGitRepoState;
                 }, RemoteCommitDto>;
             };
             api: {
@@ -94,6 +96,7 @@ export interface ServerMethods {
                     commitId: string;
                     commitMessage: string;
                     apiPb: Record<string, unknown>;
+                    gitState: LocalGitRepoState;
                 }, RemoteCommitDto>;
             };
         };
@@ -109,6 +112,7 @@ export interface ServerMethods {
                     application: Record<string, unknown>;
                     pages: Record<string, unknown>[];
                     apis: Record<string, unknown>[];
+                    gitState: LocalGitRepoState;
                 }, RemoteCommitDto>;
             };
         };

package/dist/socket/index.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="ws" />
-import WebSocket from "isomorphic-ws";
+import WebSocket from "ws";
 import { ServerMethods } from "./handlers";
 export type StdISocketRPCClient = ISocketClient<ServerMethods>;
 export declare function connectToISocketRPCServer({ superblocksBaseUrl, agentUrl, token, }: {

package/dist/socket/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectWebSocket = exports.connectISocket = exports.connectToISocketRPCServer = void 0;
 const tslib_1 = require("tslib");
-const isomorphic_ws_1 = tslib_1.__importDefault(require("isomorphic-ws"));
+const ws_1 = tslib_1.__importDefault(require("ws"));
 const handlers_1 = require("./handlers");
 const socket_1 = require("./socket");
 async function connectToISocketRPCServer({ superblocksBaseUrl, agentUrl, token, }) {
@@ -53,7 +53,7 @@ async function connectISocket(wsUrl, authorization, requestHandlers) {
 exports.connectISocket = connectISocket;
 function connectWebSocket(wsUrl) {
     return new Promise((resolve, reject) => {
-        const ws = new isomorphic_ws_1.default(wsUrl);
+        const ws = new ws_1.default(wsUrl);
         ws.addEventListener("open", () => {
             // Resolve the promise with the WebSocket instance when the connection is open
             resolve(ws);

package/dist/socket/socket.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="ws" />
-import WebSocket from "isomorphic-ws";
+import WebSocket from "ws";
 import { ISocketClient, MethodHandlers } from "../types";
 export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
     private readonly ws;
@@ -8,6 +7,7 @@ export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext
     private peerAuthorization?;
     private nxtRequestId;
     constructor(ws: WebSocket, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>);
+    private handleEvent;
     request<Params, Result>(method: string, params: Params, authorization?: string): Promise<Result>;
     private respond;
     private respondError;

package/dist/socket/socket.js

@@ -7,71 +7,73 @@ class ISocket {
         this.ws = ws;
         this.requestHandlers = requestHandlers;
         this.nxtRequestId = 0;
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        this.ws.addEventListener("message", async (event) => {
+        this.ws.addEventListener("message", (event) => {
             const eventData = JSON.parse(event.data.toString());
-            if (eventData.request) {
-                // Split the method string into parts
-                const parts = eventData.request.method.split(".");
-                let handlers = this.requestHandlers;
-                for (const part of parts) {
-                    // @ts-ignore
-                    handlers = handlers[part];
-                    if (!handlers) {
-                        return await this.respondError(eventData.request.id, {
-                            code: 2,
-                            message: `unknown method ${eventData.request.method}`,
-                        });
-                    }
-                }
-                if (!Array.isArray(handlers)) {
-                    return await this.respondError(eventData.request.id, {
+            void this.handleEvent(eventData);
+        });
+    }
+    async handleEvent(eventData) {
+        if (eventData.request) {
+            // Split the method string into parts
+            const parts = eventData.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, {
                         code: 2,
-                        message: "unknown method",
-                    });
-                }
-                if (eventData.request.setAuthorization) {
-                    this.peerAuthorization = eventData.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 client = createISocketClient(this);
-                try {
-                    for (const middlewareHandler of middlewareHandlers) {
-                        await middlewareHandler(eventData.request.payload, this.peerAuthorization, client, reqCtx);
-                    }
-                    response = await handler(eventData.request.payload, client, reqCtx);
-                }
-                catch (error) {
-                    return await this.respondError(eventData.request.id, {
-                        code: 3,
-                        message: error.toString(),
+                        message: `unknown method ${eventData.request.method}`,
                     });
                 }
-                await this.respond(eventData.request.id, response);
             }
-            else if (eventData.response && eventData.response.id) {
-                if (!this.responseHandler[eventData.response.id]) {
-                    return;
-                }
-                if (eventData.response.error) {
-                    this.responseHandler[eventData.response.id].reject(eventData.response.error);
+            if (!Array.isArray(handlers)) {
+                return this.respondError(eventData.request.id, {
+                    code: 2,
+                    message: "unknown method",
+                });
+            }
+            if (eventData.request.setAuthorization) {
+                this.peerAuthorization = eventData.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 client = createISocketClient(this);
+            try {
+                for (const middlewareHandler of middlewareHandlers) {
+                    await middlewareHandler(eventData.request.payload, this.peerAuthorization, client, reqCtx);
                 }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                this.responseHandler[eventData.response.id].resolve(eventData.response.payload);
-                delete this.responseHandler[eventData.response.id];
+                response = await handler(eventData.request.payload, client, reqCtx);
             }
-            else {
-                return await this.respondError(-1, {
+            catch (error) {
+                return this.respondError(eventData.request.id, {
                     code: 3,
-                    message: "unknown request id",
+                    message: error.toString(),
                 });
             }
-        });
+            this.respond(eventData.request.id, response);
+        }
+        else if (eventData.response && eventData.response.id) {
+            if (!this.responseHandler[eventData.response.id]) {
+                return;
+            }
+            if (eventData.response.error) {
+                this.responseHandler[eventData.response.id].reject(eventData.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];
+        }
+        else {
+            return this.respondError(-1, {
+                code: 3,
+                message: "unknown request id",
+            });
+        }
     }
     request(method, params, authorization) {
         return new Promise((resolve, reject) => {
@@ -91,7 +93,7 @@ class ISocket {
             this.ws.send(JSON.stringify(toSend));
         });
     }
-    async respond(requestId, result) {
+    respond(requestId, result) {
         const toSend = {
             response: {
                 payload: result,
@@ -101,7 +103,7 @@ class ISocket {
         };
         return this.ws.send(JSON.stringify(toSend));
     }
-    async respondError(requestId, error) {
+    respondError(requestId, error) {
         const toSend = {
             response: {
                 payload: null,

package/dist/types/common.d.ts

@@ -6,7 +6,7 @@ export interface UserMeDto {
 }
 export interface FlagBootstrap {
     "ui.enable-resource-signing"?: boolean;
-    "server.multipage.enabled"?: boolean;
+    "ui.multi-page.enabled"?: boolean;
 }
 export type User = {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/sdk",
-  "version": "1.7.0",
+  "version": "1.8.2",
   "description": "Superblocks JS SDK",
   "main": "./dist/index.js",
   "exports": {
@@ -31,9 +31,9 @@
     "typescript": "^5.1.3"
   },
   "dependencies": {
-    "@superblocksteam/util": "1.7.0",
+    "@superblocksteam/util": "1.8.2",
     "axios": "^1.3.5",
-    "isomorphic-ws": "^5.0.0"
+    "ws": "^8.17.0"
   },
   "homepage": "https://www.superblocks.com",
   "engines": {

package/src/client.ts

@@ -61,12 +61,14 @@ export interface MultiPageApplicationWrapper {
 export type PushApplicationWithCommitConfig = ApplicationWrapper & {
   commitId: string;
   commitMessage: string;
+  gitState: LocalGitRepoState;
 };
 
 export type PushMultiPageApplicationWithCommitConfig =
   MultiPageApplicationWrapper & {
     commitId: string;
     commitMessage: string;
+    gitState: LocalGitRepoState;
   };
 
 export interface ApiWrapper {
@@ -78,6 +80,7 @@ export type PushApiWithCommitConfig = {
   apiPb: Record<string, any>;
   commitId: string;
   commitMessage: string;
+  gitState: LocalGitRepoState;
 };
 
 export type Branches = {
@@ -114,7 +117,6 @@ export async function fetchApplication({
     const baseServerUrl = fetchSinglePageApplication
       ? BASE_SERVER_PUBLIC_API_URL_V1
       : BASE_SERVER_PUBLIC_API_URL_v2;
-
     const serverURL = branch
       ? new URL(
           `${baseServerUrl}/applications/${applicationId}/branches/${encodeURIComponent(
@@ -435,7 +437,7 @@ export async function validateGitSetup(
       message = `${e?.message ? e.message : e}`;
     }
 
-    const errorMessage = `Could not validate your git setup against Superblocks for the ${resourceType.toLowerCase()} ${
+    const errorMessage = `Could not validate your git setup against Superblocks for ${resourceType.toLowerCase()} ${
       resourceName ?? resourceId
     }${message ? "\n" + message : ""}`;
 
@@ -765,6 +767,7 @@ export async function pushApplication({
             pages: (
               applicationConfig as unknown as PushMultiPageApplicationWithCommitConfig
             ).pages,
+            gitState: applicationConfig.gitState,
           })
         : await socket.call.v1.public.application.pushCommit({
             applicationId,
@@ -776,6 +779,7 @@ export async function pushApplication({
             page: (
               applicationConfig as unknown as PushApplicationWithCommitConfig
             ).page,
+            gitState: applicationConfig.gitState,
           });
       socket.close();
       handleHttpError(resp.responseMeta.status);
@@ -897,6 +901,7 @@ export async function pushApi({
         branchName: branch,
         commitId: apiConfig.commitId,
         commitMessage: apiConfig.commitMessage,
+        gitState: apiConfig.gitState,
       });
       socket.close();
       handleHttpError(resp.responseMeta.status);

package/src/socket/handlers.ts

@@ -1,3 +1,4 @@
+import { LocalGitRepoState } from "@superblocksteam/util";
 import {
   ApiToSign,
   ApiToVerify,
@@ -97,6 +98,7 @@ export interface ServerMethods {
             application: Record<string, unknown>;
             page: Record<string, unknown>;
             apis: Record<string, unknown>[];
+            gitState: LocalGitRepoState;
           },
           RemoteCommitDto
         >;
@@ -109,6 +111,7 @@ export interface ServerMethods {
             commitId: string;
             commitMessage: string;
             apiPb: Record<string, unknown>;
+            gitState: LocalGitRepoState;
           },
           RemoteCommitDto
         >;
@@ -127,6 +130,7 @@ export interface ServerMethods {
             application: Record<string, unknown>;
             pages: Record<string, unknown>[];
             apis: Record<string, unknown>[];
+            gitState: LocalGitRepoState;
           },
           RemoteCommitDto
         >;

package/src/socket/index.ts

@@ -1,4 +1,4 @@
-import WebSocket from "isomorphic-ws";
+import WebSocket from "ws";
 import {
   ClientMethods,
   createRequestHandlers,

package/src/socket/socket.ts

@@ -1,4 +1,4 @@
-import WebSocket from "isomorphic-ws";
+import WebSocket from "ws";
 import {
   ISocketClient,
   MethodHandler,
@@ -57,87 +57,90 @@ export class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
     this.requestHandlers = requestHandlers;
     this.nxtRequestId = 0;
 
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    this.ws.addEventListener("message", async (event: MessageEvent) => {
+    this.ws.addEventListener("message", (event: WebSocket.MessageEvent) => {
       const eventData: SocketMessage = JSON.parse(event.data.toString());
-      if (eventData.request) {
-        // Split the method string into parts
-        const parts = eventData.request.method.split(".");
-        let handlers = this.requestHandlers;
-        for (const part of parts) {
-          // @ts-ignore
-          handlers = handlers[part];
-          if (!handlers) {
-            return await this.respondError(eventData.request.id, {
-              code: 2,
-              message: `unknown method ${eventData.request.method}`,
-            });
-          }
-        }
+      void this.handleEvent(eventData);
+    });
+  }
 
-        if (!Array.isArray(handlers)) {
-          return await this.respondError(eventData.request.id, {
+  private async handleEvent(eventData: SocketMessage<unknown, unknown>) {
+    if (eventData.request) {
+      // Split the method string into parts
+      const parts = eventData.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, {
             code: 2,
-            message: "unknown method",
+            message: `unknown method ${eventData.request.method}`,
           });
         }
-        if (eventData.request.setAuthorization) {
-          this.peerAuthorization = eventData.request.setAuthorization;
-        }
-        const middlewareHandlers = handlers.slice(0, -1) as MiddlewareHandler<
-          unknown,
-          CallableMethods,
-          RequestContext
-        >[];
-        const handler = handlers[handlers.length - 1] as MethodHandler<
-          unknown,
-          unknown,
-          CallableMethods,
-          RequestContext
-        >;
-        const reqCtx = {} as RequestContext;
-        let response: unknown;
-        // TODO(george): maybe we should not create a new client for each request
-        const client = createISocketClient(this);
-        try {
-          for (const middlewareHandler of middlewareHandlers) {
-            await middlewareHandler(
-              eventData.request.payload,
-              this.peerAuthorization,
-              client,
-              reqCtx
-            );
-          }
-          response = await handler(eventData.request.payload, client, reqCtx);
-        } catch (error: any) {
-          return await this.respondError(eventData.request.id, {
-            code: 3,
-            message: error.toString(),
-          });
-        }
-        await this.respond(eventData.request.id, response);
-      } else if (eventData.response && eventData.response.id) {
-        if (!this.responseHandler[eventData.response.id]) {
-          return;
-        }
-        if (eventData.response.error) {
-          this.responseHandler[eventData.response.id].reject(
-            eventData.response.error
+      }
+
+      if (!Array.isArray(handlers)) {
+        return this.respondError(eventData.request.id, {
+          code: 2,
+          message: "unknown method",
+        });
+      }
+      if (eventData.request.setAuthorization) {
+        this.peerAuthorization = eventData.request.setAuthorization;
+      }
+      const middlewareHandlers = handlers.slice(0, -1) as MiddlewareHandler<
+        unknown,
+        CallableMethods,
+        RequestContext
+      >[];
+      const handler = handlers[handlers.length - 1] as MethodHandler<
+        unknown,
+        unknown,
+        CallableMethods,
+        RequestContext
+      >;
+      const reqCtx = {} as RequestContext;
+      let response: unknown;
+      // TODO(george): maybe we should not create a new client for each request
+      const client = createISocketClient(this);
+      try {
+        for (const middlewareHandler of middlewareHandlers) {
+          await middlewareHandler(
+            eventData.request.payload,
+            this.peerAuthorization,
+            client,
+            reqCtx
           );
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.responseHandler[eventData.response.id].resolve(
-          eventData.response.payload as any
-        );
-        delete this.responseHandler[eventData.response.id];
-      } else {
-        return await this.respondError(-1, {
+        response = await handler(eventData.request.payload, client, reqCtx);
+      } catch (error: any) {
+        return this.respondError(eventData.request.id, {
           code: 3,
-          message: "unknown request id",
+          message: error.toString(),
         });
       }
-    });
+      this.respond(eventData.request.id, response);
+    } else if (eventData.response && eventData.response.id) {
+      if (!this.responseHandler[eventData.response.id]) {
+        return;
+      }
+      if (eventData.response.error) {
+        this.responseHandler[eventData.response.id].reject(
+          eventData.response.error
+        );
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.responseHandler[eventData.response.id].resolve(
+        eventData.response.payload as any
+      );
+      delete this.responseHandler[eventData.response.id];
+    } else {
+      return this.respondError(-1, {
+        code: 3,
+        message: "unknown request id",
+      });
+    }
   }
 
   public request<Params, Result>(
@@ -163,10 +166,7 @@ export class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
     });
   }
 
-  private async respond<Result>(
-    requestId: number,
-    result: Result
-  ): Promise<void> {
+  private respond<Result>(requestId: number, result: Result): void {
     const toSend: SocketMessage = {
       response: {
         payload: result,
@@ -177,10 +177,7 @@ export class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
     return this.ws.send(JSON.stringify(toSend));
   }
 
-  private async respondError(
-    requestId: number,
-    error: SocketError
-  ): Promise<void> {
+  private respondError(requestId: number, error: SocketError): void {
     const toSend: SocketMessage = {
       response: {
         payload: null,

package/src/types/common.ts

@@ -7,7 +7,8 @@ export interface UserMeDto {
 
 export interface FlagBootstrap {
   "ui.enable-resource-signing"?: boolean;
-  "server.multipage.enabled"?: boolean;
+  // BE and UI flags are merged so we are using UI flag here
+  "ui.multi-page.enabled"?: boolean;
 }
 
 export type User = {