@superblocksteam/sdk 1.4.2 → 1.5.0

package/src/client.ts

@@ -1,21 +1,25 @@
 import * as fs from "fs";
 import {
+  COMPONENT_EVENT_HEADER,
   ComponentEvent,
   getBucketeerUrlFromSuperblocksUrl,
   getContentType,
-  COMPONENT_EVENT_HEADER,
-  NotFoundError,
   LocalGitRepoState,
-  ValidateGitSetupRequestBody,
+  NotFoundError,
   SuperblocksResourceType,
   unreachable,
+  ValidateGitSetupRequestBody,
 } from "@superblocksteam/util";
 import axios, { AxiosError, AxiosRequestConfig } from "axios";
-import * as FormData from "form-data";
+import FormData from "form-data";
 import { isEmpty } from "lodash";
 import { BranchNotCheckedOutError, CommitAlreadyExistsError } from "./errors";
+import { signingEnabled } from "./flag";
+import { connectToISocketRPCServer } from "./socket";
+import { AgentType, RemoteCommitDto, UserMeDto } from "./types";
+import { getAgentUrls } from "./utils";
 
-const BASE_BUCKETEER_URL = "api/v1";
+const BASE_BUCKETEER_URL = "api";
 const BASE_SERVER_PUBLIC_API_URL = "api/v1/public";
 
 const SUPERBLOCKS_MAX_FILE_SIZE_MB = 10;
@@ -204,7 +208,7 @@ export async function fetchApplicationWithComponents({
   // fetch files from bucketeer
   const branchPath = branch ? `/branches/${encodeURIComponent(branch)}` : "";
   const componentFileURL = new URL(
-    `${BASE_BUCKETEER_URL}/components/${applicationId}${branchPath}?commit=${commitId}&viewMode=${viewMode}`,
+    `${BASE_BUCKETEER_URL}/v1/components/${applicationId}${branchPath}?commit=${commitId}&viewMode=${viewMode}`,
     bucketeerBaseUrl
   ).toString();
 
@@ -408,25 +412,49 @@ export async function registerComponents(
   token: string,
   superblocksBaseUrl: string,
   branch: string | null,
-  injectedHeaders?: Record<string, string>
+  injectedHeaders: Record<string, string>
 ) {
   try {
     const branchPath = branch ? `/branches/${encodeURIComponent(branch)}` : "";
-    const config: AxiosRequestConfig = {
-      method: "put",
-      url: new URL(
-        `${BASE_SERVER_PUBLIC_API_URL}/application/${applicationId}${branchPath}/components`,
-        superblocksBaseUrl
-      ).toString(),
-      headers: {
-        Authorization: "Bearer " + token,
-        [CLI_VERSION_HEADER]: cliVersion,
-        ...injectedHeaders,
-      },
-      data: { components: componentConfigs },
-    };
-    const response = await axios(config);
-    return response.data;
+    const userMe = await fetchCurrentUser(
+      cliVersion,
+      token,
+      superblocksBaseUrl
+    );
+    const organization = userMe.organizations[0];
+    if (organization.agentType == AgentType.ONPREMISE && signingEnabled(userMe.flagBootstrap)) {
+      const agentUrls = getAgentUrls(userMe.agents, organization.agentType);
+      const socket = await connectToISocketRPCServer({
+        agentUrls,
+        superblocksBaseUrl,
+        token,
+      });
+      const resp = await socket.call.v1.public.application.component.register({
+        applicationId,
+        branchName: branch || "",
+        cliVersion: cliVersion,
+        componentEvent: injectedHeaders[COMPONENT_EVENT_HEADER],
+        components: componentConfigs,
+      });
+      socket.close();
+      return resp.data;
+    } else {
+      const config: AxiosRequestConfig = {
+        method: "put",
+        url: new URL(
+          `${BASE_SERVER_PUBLIC_API_URL}/application/${applicationId}${branchPath}/components`,
+          superblocksBaseUrl
+        ).toString(),
+        headers: {
+          Authorization: "Bearer " + token,
+          [CLI_VERSION_HEADER]: cliVersion,
+          ...injectedHeaders,
+        },
+        data: { components: componentConfigs },
+      };
+      const response = await axios(config);
+      return response.data;
+    }
   } catch (e: any) {
     if (e instanceof AxiosError) {
       const message: string =
@@ -496,7 +524,7 @@ export async function uploadComponents({
     buildFiles,
   });
   const postURL = new URL(
-    `${BASE_BUCKETEER_URL}/components/upload`,
+    `${BASE_BUCKETEER_URL}/v2/components/upload`,
     bucketeerBaseUrl
   ).toString();
 
@@ -526,13 +554,42 @@ You can reduce your component bundle size by uploading static assets to a separa
         [CLI_VERSION_HEADER]: cliVersion,
         [COMPONENT_EVENT_HEADER]: ComponentEvent.UPLOAD,
         [SUPERBLOCKS_URL_HEADER]: superblocksBaseUrl,
-        ...formHeaders,
+          ...formHeaders,
       },
     };
 
-    const response = await axios.post(postURL, formData, config);
+    const uploadResponse = await axios.post(postURL, formData, config);
 
-    return response.data;
+    const userMe = await fetchCurrentUser(
+      cliVersion,
+      token,
+      superblocksBaseUrl
+    );
+    const organization = userMe.organizations[0];
+    const signingRequired = organization.agentType == AgentType.ONPREMISE && signingEnabled(userMe.flagBootstrap);
+    let agentUrls: string[] = [];
+    if (signingRequired) {
+      agentUrls = getAgentUrls(userMe.agents, organization.agentType);
+    }
+    const socket = await connectToISocketRPCServer({
+      agentUrls,
+      superblocksBaseUrl,
+      token,
+    });
+    try {
+      await socket.call.v1.public.application.component.update({
+        applicationId,
+        branchName: branch ?? undefined,
+        srcFiles: srcFiles.map((file) => file.filename),
+        buildFiles: buildFiles.map((file) => file.filename),
+        registeredComponents: componentConfigs,
+        cliVersion,
+        componentBaseUrl: uploadResponse.data.componentBaseUrl,
+        signingRequired,
+      });
+    } finally {
+      socket.close();
+    }
   } catch (e: any) {
     if (e instanceof AxiosError && e.response?.status === 413) {
       throw new Error(
@@ -559,7 +616,7 @@ export async function fetchCurrentUser(
   cliVersion: string,
   token: string,
   superblocksBaseUrl: string
-) {
+): Promise<UserMeDto> {
   try {
     const config: AxiosRequestConfig = {
       method: "get",
@@ -574,7 +631,7 @@ export async function fetchCurrentUser(
       },
     };
     const response = await axios(config);
-    return response.data.data.user;
+    return response.data.data as UserMeDto;
   } catch (e: any) {
     let message: string;
     if (e instanceof AxiosError) {
@@ -607,7 +664,7 @@ export async function pushApplication({
   branch: string;
   injectedHeaders: Record<string, string>;
   applicationConfig: PushApplicationWithCommitConfig;
-}): Promise<ApplicationWrapper | undefined> {
+}): Promise<RemoteCommitDto | undefined> {
   const serverURL = new URL(
     `${BASE_SERVER_PUBLIC_API_URL}/applications/${applicationId}/branches/${encodeURIComponent(
       branch
@@ -617,17 +674,43 @@ export async function pushApplication({
   let serverResponse;
 
   try {
-    const config: AxiosRequestConfig = {
-      method: "post",
-      url: serverURL.toString(),
-      headers: {
-        Authorization: "Bearer " + token,
-        [CLI_VERSION_HEADER]: cliVersion,
-        ...injectedHeaders,
-      },
-      data: applicationConfig,
-    };
-    serverResponse = await axios<ResponseWithMeta<ApplicationWrapper>>(config);
+    const userMe = await fetchCurrentUser(
+      cliVersion,
+      token,
+      superblocksBaseUrl
+    );
+    const organization = userMe.organizations[0];
+    if (organization.agentType == AgentType.ONPREMISE && signingEnabled(userMe.flagBootstrap)) {
+      const agentUrls = getAgentUrls(userMe.agents, organization.agentType);
+      const socket = await connectToISocketRPCServer({
+        agentUrls,
+        superblocksBaseUrl,
+        token,
+      });
+      const resp = await socket.call.v1.public.application.pushCommit({
+        applicationId,
+        apis: applicationConfig.apis,
+        application: applicationConfig.application,
+        branchName: branch,
+        commitId: applicationConfig.commitId,
+        commitMessage: applicationConfig.commitMessage,
+        page: applicationConfig.page,
+      });
+      socket.close();
+      return resp.data;
+    } else {
+      const config: AxiosRequestConfig = {
+        method: "post",
+        url: serverURL.toString(),
+        headers: {
+          Authorization: "Bearer " + token,
+          [CLI_VERSION_HEADER]: cliVersion,
+          ...injectedHeaders,
+        },
+        data: applicationConfig,
+      };
+      serverResponse = await axios<ResponseWithMeta<RemoteCommitDto>>(config);
+    }
   } catch (e) {
     if (axios.isAxiosError(e)) {
       const respCode =
@@ -686,19 +769,43 @@ export async function pushApi({
   let serverResponse;
 
   try {
-    const config: AxiosRequestConfig = {
-      method: "post",
-      url: serverURL.toString(),
-      headers: {
-        Authorization: "Bearer " + token,
-        [CLI_VERSION_HEADER]: cliVersion,
-        ...injectedHeaders,
-      },
-      data: apiConfig,
-    };
-    serverResponse = await axios<ResponseWithMeta<{ commitId: string }>>(
-      config
+    const userMe = await fetchCurrentUser(
+      cliVersion,
+      token,
+      superblocksBaseUrl
     );
+    const organization = userMe.organizations[0];
+    if (organization.agentType == AgentType.ONPREMISE && signingEnabled(userMe.flagBootstrap)) {
+      const agentUrls = getAgentUrls(userMe.agents, organization.agentType);
+      const socket = await connectToISocketRPCServer({
+        agentUrls,
+        superblocksBaseUrl,
+        token,
+      });
+      const resp = await socket.call.v1.public.api.pushCommit({
+        apiId,
+        apiPb: apiConfig.apiPb,
+        branchName: branch,
+        commitId: apiConfig.commitId,
+        commitMessage: apiConfig.commitMessage,
+      });
+      socket.close();
+      return resp.data;
+    } else {
+      const config: AxiosRequestConfig = {
+        method: "post",
+        url: serverURL.toString(),
+        headers: {
+          Authorization: "Bearer " + token,
+          [CLI_VERSION_HEADER]: cliVersion,
+          ...injectedHeaders,
+        },
+        data: apiConfig,
+      };
+      serverResponse = await axios<ResponseWithMeta<{ commitId: string }>>(
+        config
+      );
+    }
   } catch (e) {
     if (axios.isAxiosError(e)) {
       if (e.response?.data?.responseMeta?.status === 405) {

package/src/flag.ts

@@ -0,0 +1,5 @@
+import { FlagBootstrap } from "./types";
+
+export const signingEnabled = (flags: FlagBootstrap): boolean => {
+  return flags["ui.enable-resource-signing"] ?? false;
+};

package/src/sdk.ts

@@ -7,18 +7,18 @@ import {
   fetchApi,
   fetchApis,
   fetchApplication,
-  fetchApplicationWithComponents,
+  fetchApplicationBranches,
   fetchApplications,
-  registerComponents,
-  uploadComponents,
+  fetchApplicationWithComponents,
   fetchCurrentUser,
-  ViewMode,
+  pushApi,
+  PushApiWithCommitConfig,
   pushApplication,
   PushApplicationWithCommitConfig,
-  fetchApplicationBranches,
-  PushApiWithCommitConfig,
-  pushApi,
+  registerComponents,
+  uploadComponents,
   validateGitSetup,
+  ViewMode,
 } from "./client";
 
 // Exporting here instead of index.ts because only sdk.ts is exposed outside in package.json
@@ -144,7 +144,7 @@ export class SuperblocksSdk {
     applicationId: string,
     componentConfigs: Record<string, any>,
     branch: string | null,
-    injectedHeaders?: Record<string, string>
+    injectedHeaders: Record<string, string>
   ) {
     return registerComponents(
       this.cliVersion,

package/src/socket/handlers.ts

@@ -0,0 +1,228 @@
+import {
+  ApiToSign,
+  ApiToVerify,
+  AppToSign,
+  AppToVerify,
+  MethodHandlers,
+  RemoteCommitDto,
+  Signature,
+} from "../types";
+import { signResource, verifyResources } from "./signing";
+
+type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
+
+export interface ClientMethods {
+  v1: {
+    signing: {
+      signApplication: MethodSchema<
+        { branchName: string; toSign: AppToSign },
+        { signature: Signature }
+      >;
+      signApis: MethodSchema<
+        { branchName: string; toSign: ApiToSign[] },
+        { signatures: Signature[] }
+      >;
+      verifyApplication: MethodSchema<
+        { branchName: string; toVerify: AppToVerify },
+        { ok: boolean }
+      >;
+      verifyApi: MethodSchema<
+        { branchName: string; toVerify: ApiToVerify[] },
+        { ok: boolean }
+      >;
+    };
+  };
+}
+
+type ServerMethodSchema<Params, Response> = MethodSchema<
+  Params,
+  ResponseDto<Response>
+>;
+
+// This file contains the definition of the protocol used for communication between the SB server and clients
+
+type ResponseDto<T> = {
+  responseMeta: ResponseMeta;
+  data: T;
+};
+
+export type ResponseMeta = {
+  status: number;
+  success: boolean;
+  error?: APIResponseError;
+};
+
+type APIResponseError = {
+  code: number;
+  message: string;
+};
+
+export interface ServerMethods {
+  v1: {
+    echo: MethodSchema<{ message: string }, { message: string }>;
+    public: {
+      application: {
+        component: {
+          register: ServerMethodSchema<
+            {
+              applicationId: string;
+              branchName: string;
+              cliVersion: string;
+              componentEvent: string;
+              components: Record<string, unknown>;
+            },
+            { success: boolean }
+          >;
+          update: ServerMethodSchema<
+            {
+              applicationId: string;
+              branchName?: string;
+              srcFiles: string[];
+              buildFiles: string[];
+              registeredComponents: Record<string, unknown>;
+              cliVersion: string | undefined;
+              componentBaseUrl: string;
+              signingRequired: boolean;
+            },
+            { success: boolean }
+          >;
+        };
+        pushCommit: ServerMethodSchema<
+          {
+            applicationId: string;
+            branchName: string;
+            commitId: string;
+            commitMessage: string;
+            application: Record<string, unknown>;
+            page: Record<string, unknown>;
+            apis: Record<string, unknown>[];
+          },
+          RemoteCommitDto
+        >;
+      };
+      api: {
+        pushCommit: ServerMethodSchema<
+          {
+            apiId: string;
+            branchName: string;
+            commitId: string;
+            commitMessage: string;
+            apiPb: Record<string, unknown>;
+          },
+          RemoteCommitDto
+        >;
+      };
+    };
+  };
+}
+
+export function createRequestHandlers({
+  agentUrls,
+  token,
+}: {
+  token: string;
+  agentUrls: string[];
+}) {
+  const requestHandlers: MethodHandlers<ClientMethods, ServerMethods, unknown> =
+    {
+      v1: {
+        signing: {
+          signApplication: [
+            async ({
+              branchName,
+              toSign,
+            }: {
+              branchName: string;
+              toSign: AppToSign;
+            }) => {
+              const signature = await signResource({
+                agentUrls,
+                token: token,
+                branchName,
+                resource: {
+                  literal: {
+                    data: toSign.rootHash,
+                  },
+                },
+              });
+              return { signature: signature };
+            },
+          ],
+          signApis: [
+            async ({
+              branchName,
+              toSign,
+            }: {
+              branchName: string;
+              toSign: ApiToSign[];
+            }) => {
+              const signatures: Signature[] = [];
+              for (const { apiPb } of toSign) {
+                const signature = await signResource({
+                  agentUrls,
+                  token: token,
+                  branchName,
+                  resource: { api: apiPb },
+                });
+                signatures.push(signature);
+              }
+              return { signatures };
+            },
+          ],
+          verifyApplication: [
+            async ({
+              branchName,
+              toVerify,
+            }: {
+              branchName: string;
+              toVerify: AppToVerify;
+            }) => {
+              try {
+                await verifyResources({
+                  agentUrls,
+                  token,
+                  branchName,
+                  resources: [
+                    {
+                      literal: {
+                        data: toVerify.rootHash,
+                        signature: toVerify.signature,
+                      },
+                    },
+                  ],
+                });
+                return { ok: true };
+              } catch {
+                return { ok: false };
+              }
+            },
+          ],
+
+          verifyApi: [
+            async ({
+              branchName,
+              toVerify,
+            }: {
+              branchName: string;
+              toVerify: ApiToVerify[];
+            }) => {
+              try {
+                await verifyResources({
+                  agentUrls,
+                  token,
+                  branchName,
+                  resources: toVerify.map(({ apiPb }) => ({
+                    api: apiPb,
+                  })),
+                });
+                return { ok: true };
+              } catch {
+                return { ok: false };
+              }
+            },
+          ],
+        },
+      },
+    };
+  return requestHandlers;
+}