@superblocksteam/sdk 1.8.2 → 1.9.1

package/src/sdk.ts

@@ -5,22 +5,23 @@ import {
 } from "@superblocksteam/util";
 import {
   fetchApi,
+  fetchApiCommits,
   fetchApis,
   fetchApplication,
   fetchApplicationBranches,
+  fetchApplicationCommits,
   fetchApplications,
   fetchApplicationWithComponents,
   fetchCurrentUser,
   pushApi,
   PushApiWithCommitConfig,
   pushApplication,
-  PushApplicationWithCommitConfig,
   PushMultiPageApplicationWithCommitConfig,
   registerComponents,
   uploadComponents,
   validateGitSetup,
-  ViewMode,
 } from "./client";
+import { ViewMode } from "./types";
 
 // Exporting here instead of index.ts because only sdk.ts is exposed outside in package.json
 export * from "./errors";
@@ -45,13 +46,13 @@ export class SuperblocksSdk {
     branch,
     headers = {},
     viewMode = "export-live",
-    fetchSinglePageApplication = false,
+    skipSigningVerification = false,
   }: {
     applicationId: string;
     branch?: string;
     headers?: Record<string, string>;
     viewMode?: ViewMode;
-    fetchSinglePageApplication?: boolean;
+    skipSigningVerification?: boolean;
   }) {
     return fetchApplication({
       cliVersion: this.cliVersion,
@@ -60,8 +61,8 @@ export class SuperblocksSdk {
       token: this.token,
       superblocksBaseUrl: this.superblocksBaseUrl,
       viewMode,
+      skipSigningVerification,
       injectedHeaders: headers,
-      fetchSinglePageApplication,
     });
   }
 
@@ -80,13 +81,15 @@ export class SuperblocksSdk {
     branch,
     headers = {},
     viewMode = "export-live",
-    fetchSinglePageApplication = false,
+    commitId,
+    skipSigningVerification = false,
   }: {
     applicationId: string;
     branch: string;
     headers?: Record<string, string>;
     viewMode?: ViewMode;
-    fetchSinglePageApplication?: boolean;
+    commitId?: string;
+    skipSigningVerification?: boolean;
   }) {
     return fetchApplicationWithComponents({
       cliVersion: this.cliVersion,
@@ -95,8 +98,59 @@ export class SuperblocksSdk {
       token: this.token,
       superblocksBaseUrl: this.superblocksBaseUrl,
       viewMode,
+      skipSigningVerification,
+      commitId,
       injectedHeaders: headers,
-      fetchSinglePageApplication,
+    });
+  }
+
+  async fetchApplicationCommits({
+    applicationId,
+    branch,
+    headers = {},
+    limit,
+    offset,
+  }: {
+    applicationId: string;
+    branch: string;
+    headers?: Record<string, string>;
+    limit?: number;
+    offset?: number;
+  }) {
+    return fetchApplicationCommits({
+      cliVersion: this.cliVersion,
+      applicationId,
+      branch,
+      token: this.token,
+      superblocksBaseUrl: this.superblocksBaseUrl,
+      injectedHeaders: headers,
+      limit,
+      offset,
+    });
+  }
+
+  async fetchApiCommits({
+    apiId,
+    branch,
+    headers = {},
+    limit,
+    offset,
+  }: {
+    apiId: string;
+    branch: string;
+    headers?: Record<string, string>;
+    limit?: number;
+    offset?: number;
+  }) {
+    return fetchApiCommits({
+      cliVersion: this.cliVersion,
+      applicationId: apiId,
+      branch,
+      token: this.token,
+      superblocksBaseUrl: this.superblocksBaseUrl,
+      injectedHeaders: headers,
+      limit,
+      offset,
     });
   }
 
@@ -109,18 +163,28 @@ export class SuperblocksSdk {
     );
   }
 
-  async fetchApi(
-    apiId: string,
-    viewMode: ViewMode = "export-live",
-    branch?: string
-  ) {
+  async fetchApi({
+    apiId,
+    branch,
+    viewMode = "export-live",
+    commitId,
+    skipSigningVerification = false,
+  }: {
+    apiId: string;
+    viewMode?: ViewMode;
+    branch?: string;
+    commitId?: string;
+    skipSigningVerification?: boolean;
+  }) {
     return fetchApi(
       this.cliVersion,
       apiId,
       this.token,
       this.superblocksBaseUrl,
       viewMode,
-      branch
+      branch,
+      commitId,
+      skipSigningVerification
     );
   }
 
@@ -194,15 +258,11 @@ export class SuperblocksSdk {
     applicationConfig,
     branch,
     headers = {},
-    multiPage = false,
   }: {
     applicationId: string;
-    applicationConfig:
-      | PushApplicationWithCommitConfig
-      | PushMultiPageApplicationWithCommitConfig;
+    applicationConfig: PushMultiPageApplicationWithCommitConfig;
     branch: string;
     headers?: Record<string, string>;
-    multiPage?: boolean;
   }) {
     return pushApplication({
       cliVersion: this.cliVersion,
@@ -212,7 +272,6 @@ export class SuperblocksSdk {
       branch,
       injectedHeaders: headers,
       applicationConfig,
-      multiPage,
     });
   }
   async pushApi({

package/src/socket/handlers.ts

@@ -7,6 +7,7 @@ import {
   MethodHandlers,
   RemoteCommitDto,
   Signature,
+  ViewMode,
 } from "../types";
 import { signResource, verifyResources } from "./signing";
 
@@ -108,12 +109,22 @@ export interface ServerMethods {
           {
             apiId: string;
             branchName: string;
-            commitId: string;
-            commitMessage: string;
+            commitId?: string;
+            commitMessage?: string;
             apiPb: Record<string, unknown>;
             gitState: LocalGitRepoState;
+            skipCommit: boolean;
           },
-          RemoteCommitDto
+          RemoteCommitDto | { updated: Date }
+        >;
+        get: ServerMethodSchema<
+          {
+            apiId: string;
+            branchName?: string;
+            viewMode: ViewMode;
+            commitId?: string;
+          },
+          any
         >;
       };
     };
@@ -125,14 +136,24 @@ export interface ServerMethods {
           {
             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;
+            skipCommit: boolean;
           },
-          RemoteCommitDto
+          RemoteCommitDto | { updated: Date }
+        >;
+        get: ServerMethodSchema<
+          {
+            applicationId: string;
+            viewMode: ViewMode;
+            branchName?: string;
+            commitId?: string;
+          },
+          any
         >;
       };
     };

package/src/socket/index.ts

@@ -1,4 +1,11 @@
 import WebSocket from "ws";
+import {
+  GenericMiddleware,
+  ISocketClient,
+  MethodHandlers,
+  RequestContextBase,
+  SocketTimeouts,
+} from "../types";
 import {
   ClientMethods,
   createRequestHandlers,
@@ -34,20 +41,26 @@ export async function connectToISocketRPCServer({
   } else if (wsUrl.hostname === "localhost") {
     wsUrl.hostname = "127.0.0.1";
   }
-  return await connectISocket<ServerMethods, ClientMethods, unknown>(
+
+  return await connectISocket<ServerMethods, ClientMethods>(
     wsUrl.href,
     authorization,
-    requestHandlers
+    requestHandlers,
+    [],
+    {
+      connectionTimeoutInSeconds: 6 * 60, // 6 minutes
+      noResponseTimeoutInSeconds: 5 * 60, // 5 minutes
+    }
   );
 }
 
 // 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<
+export class ISocketWithClientAuth<
   ImplementedMethods,
   CallableMethods,
-  RequestContext = void
+  RequestContext extends RequestContextBase
 > extends ISocket<ImplementedMethods, CallableMethods, RequestContext> {
   private readonly authorization?: string;
   private hasSentAuth = false;
@@ -59,9 +72,11 @@ class ISocketWithClientAuth<
       ImplementedMethods,
       CallableMethods,
       RequestContext
-    >
+    >,
+    globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[],
+    timeouts?: SocketTimeouts
   ) {
-    super(ws, requestHandlers);
+    super(ws, requestHandlers, globalMiddlewares, timeouts);
     this.authorization = authorization;
   }
 
@@ -85,7 +100,7 @@ class ISocketWithClientAuth<
 export async function connectISocket<
   CallableMethods,
   ImplementedMethods,
-  RequestContext = never
+  RequestContext extends RequestContextBase = RequestContextBase
 >(
   wsUrl: string,
   authorization: string | undefined,
@@ -93,10 +108,18 @@ export async function connectISocket<
     ImplementedMethods,
     CallableMethods,
     RequestContext
-  >
+  >,
+  globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[],
+  timeouts?: SocketTimeouts
 ): Promise<ISocketClient<CallableMethods>> {
   const ws = await connectWebSocket(wsUrl);
-  const isocket = new ISocketWithClientAuth(ws, authorization, requestHandlers);
+  const isocket = new ISocketWithClientAuth(
+    ws,
+    authorization,
+    requestHandlers,
+    globalMiddlewares,
+    timeouts
+  );
   return createISocketClient(isocket);
 }
 
@@ -117,48 +140,3 @@ export 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>;
-};