@superblocksteam/sdk 1.4.1 → 1.5.0

package/dist/sdk.js

@@ -6,14 +6,17 @@ const client_1 = require("./client");
 // Exporting here instead of index.ts because only sdk.ts is exposed outside in package.json
 tslib_1.__exportStar(require("./errors"), exports);
 class SuperblocksSdk {
-    constructor(accessToken, superblocksBaseUrl) {
+    constructor(accessToken, superblocksBaseUrl, cliVersion) {
         this.token = "";
         this.superblocksBaseUrl = "";
+        this.cliVersion = "";
         this.token = accessToken;
         this.superblocksBaseUrl = superblocksBaseUrl;
+        this.cliVersion = cliVersion;
     }
     async fetchApplication({ applicationId, branch, headers = {}, viewMode = "export-live", }) {
         return (0, client_1.fetchApplication)({
+            cliVersion: this.cliVersion,
             applicationId,
             branch,
             token: this.token,
@@ -24,6 +27,7 @@ class SuperblocksSdk {
     }
     async fetchApplicationBranches(applicationId, headers = {}) {
         return (0, client_1.fetchApplicationBranches)({
+            cliVersion: this.cliVersion,
             applicationId,
             token: this.token,
             superblocksBaseUrl: this.superblocksBaseUrl,
@@ -32,6 +36,7 @@ class SuperblocksSdk {
     }
     async fetchApplicationWithComponents({ applicationId, branch, headers = {}, viewMode = "export-live", }) {
         return (0, client_1.fetchApplicationWithComponents)({
+            cliVersion: this.cliVersion,
             applicationId,
             branch,
             token: this.token,
@@ -41,22 +46,23 @@ class SuperblocksSdk {
         });
     }
     async fetchApplications(headers) {
-        return (0, client_1.fetchApplications)(this.token, this.superblocksBaseUrl, headers);
+        return (0, client_1.fetchApplications)(this.cliVersion, this.token, this.superblocksBaseUrl, headers);
     }
-    async fetchApi(apiId, viewMode = "export-live") {
-        return (0, client_1.fetchApi)(apiId, this.token, this.superblocksBaseUrl, viewMode);
+    async fetchApi(apiId, viewMode = "export-live", branch) {
+        return (0, client_1.fetchApi)(this.cliVersion, apiId, this.token, this.superblocksBaseUrl, viewMode, branch);
     }
     async fetchApis() {
-        return (0, client_1.fetchApis)(this.token, this.superblocksBaseUrl);
+        return (0, client_1.fetchApis)(this.cliVersion, this.token, this.superblocksBaseUrl);
     }
     async validateGitSetup(resourceId, resourceType, event, localGitRepoState, injectedHeaders) {
-        return (0, client_1.validateGitSetup)(resourceId, resourceType, event, localGitRepoState, this.token, this.superblocksBaseUrl, injectedHeaders);
+        return (0, client_1.validateGitSetup)(this.cliVersion, resourceId, resourceType, event, localGitRepoState, this.token, this.superblocksBaseUrl, injectedHeaders);
     }
     async registerComponents(applicationId, componentConfigs, branch, injectedHeaders) {
-        return (0, client_1.registerComponents)(applicationId, componentConfigs, this.token, this.superblocksBaseUrl, branch, injectedHeaders);
+        return (0, client_1.registerComponents)(this.cliVersion, applicationId, componentConfigs, this.token, this.superblocksBaseUrl, branch, injectedHeaders);
     }
     async uploadComponents(applicationId, componentConfigs, files, branch) {
         return (0, client_1.uploadComponents)({
+            cliVersion: this.cliVersion,
             applicationId,
             componentConfigs,
             files,
@@ -66,10 +72,11 @@ class SuperblocksSdk {
         });
     }
     async fetchCurrentUser() {
-        return (0, client_1.fetchCurrentUser)(this.token, this.superblocksBaseUrl);
+        return (0, client_1.fetchCurrentUser)(this.cliVersion, this.token, this.superblocksBaseUrl);
     }
     async pushApplication({ applicationId, applicationConfig, branch, headers = {}, }) {
         return (0, client_1.pushApplication)({
+            cliVersion: this.cliVersion,
             applicationId,
             token: this.token,
             superblocksBaseUrl: this.superblocksBaseUrl,
@@ -80,6 +87,7 @@ class SuperblocksSdk {
     }
     async pushApi({ apiId, apiConfig, branch, headers = {}, }) {
         return (0, client_1.pushApi)({
+            cliVersion: this.cliVersion,
             apiId,
             apiConfig,
             token: this.token,

package/dist/socket/handlers.d.ts

@@ -0,0 +1,105 @@
+import { ApiToSign, ApiToVerify, AppToSign, AppToVerify, MethodHandlers, RemoteCommitDto, Signature } from "../types";
+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>>;
+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 declare function createRequestHandlers({ agentUrls, token, }: {
+    token: string;
+    agentUrls: string[];
+}): MethodHandlers<ClientMethods, ServerMethods, unknown>;
+export {};

package/dist/socket/handlers.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandlers = void 0;
+const signing_1 = require("./signing");
+function createRequestHandlers({ agentUrls, token, }) {
+    const requestHandlers = {
+        v1: {
+            signing: {
+                signApplication: [
+                    async ({ branchName, toSign, }) => {
+                        const signature = await (0, signing_1.signResource)({
+                            agentUrls,
+                            token: token,
+                            branchName,
+                            resource: {
+                                literal: {
+                                    data: toSign.rootHash,
+                                },
+                            },
+                        });
+                        return { signature: signature };
+                    },
+                ],
+                signApis: [
+                    async ({ branchName, toSign, }) => {
+                        const signatures = [];
+                        for (const { apiPb } of toSign) {
+                            const signature = await (0, signing_1.signResource)({
+                                agentUrls,
+                                token: token,
+                                branchName,
+                                resource: { api: apiPb },
+                            });
+                            signatures.push(signature);
+                        }
+                        return { signatures };
+                    },
+                ],
+                verifyApplication: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            await (0, signing_1.verifyResources)({
+                                agentUrls,
+                                token,
+                                branchName,
+                                resources: [
+                                    {
+                                        literal: {
+                                            data: toVerify.rootHash,
+                                            signature: toVerify.signature,
+                                        },
+                                    },
+                                ],
+                            });
+                            return { ok: true };
+                        }
+                        catch {
+                            return { ok: false };
+                        }
+                    },
+                ],
+                verifyApi: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            await (0, signing_1.verifyResources)({
+                                agentUrls,
+                                token,
+                                branchName,
+                                resources: toVerify.map(({ apiPb }) => ({
+                                    api: apiPb,
+                                })),
+                            });
+                            return { ok: true };
+                        }
+                        catch {
+                            return { ok: false };
+                        }
+                    },
+                ],
+            },
+        },
+    };
+    return requestHandlers;
+}
+exports.createRequestHandlers = createRequestHandlers;

package/dist/socket/index.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="ws" />
+import WebSocket from "isomorphic-ws";
+import { ServerMethods } from "./handlers";
+export type StdISocketRPCClient = ISocketClient<ServerMethods>;
+export declare function connectToISocketRPCServer({ superblocksBaseUrl, agentUrls, token, }: {
+    superblocksBaseUrl: string;
+    agentUrls: string[];
+    token: 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 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

@@ -0,0 +1,69 @@
+"use strict";
+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 handlers_1 = require("./handlers");
+const socket_1 = require("./socket");
+async function connectToISocketRPCServer({ superblocksBaseUrl, agentUrls, token, }) {
+    const requestHandlers = (0, handlers_1.createRequestHandlers)({
+        agentUrls,
+        token,
+    });
+    const authorization = `Bearer ${token}`;
+    const wsUrl = new URL("api/v1/rpc-ws", superblocksBaseUrl);
+    if (wsUrl.protocol === "http:") {
+        wsUrl.protocol = "ws:";
+    }
+    else if (wsUrl.protocol === "https:") {
+        wsUrl.protocol = "wss:";
+    }
+    if (wsUrl.host === "localhost:3000") {
+        wsUrl.host = "127.0.0.1:8080";
+    }
+    else if (wsUrl.hostname === "localhost") {
+        wsUrl.hostname = "127.0.0.1";
+    }
+    return await connectISocket(wsUrl.href, authorization, requestHandlers);
+}
+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);
+        this.hasSentAuth = false;
+        this.authorization = authorization;
+    }
+    // override `request` from the base class to send `authorization` when appropriate
+    async request(method, params) {
+        // only send `authorization` on the first request
+        const authorization = this.hasSentAuth ? undefined : this.authorization;
+        const result = await super.request(method, params, authorization);
+        this.hasSentAuth = true;
+        return result;
+    }
+}
+async function connectISocket(wsUrl, authorization, requestHandlers) {
+    const ws = await connectWebSocket(wsUrl);
+    const isocket = new ISocketWithClientAuth(ws, authorization, requestHandlers);
+    return (0, socket_1.createISocketClient)(isocket);
+}
+exports.connectISocket = connectISocket;
+function connectWebSocket(wsUrl) {
+    return new Promise((resolve, reject) => {
+        const ws = new isomorphic_ws_1.default(wsUrl);
+        ws.addEventListener("open", () => {
+            // Resolve the promise with the WebSocket instance when the connection is open
+            resolve(ws);
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ws.addEventListener("error", (error) => {
+            // Reject the promise if there's an error
+            reject(error);
+        });
+    });
+}
+exports.connectWebSocket = connectWebSocket;

package/dist/socket/signing.d.ts

@@ -0,0 +1,13 @@
+import { ApiResource, GenericResource, Signature } from "../types";
+export declare function signResource({ token, branchName, resource, agentUrls, }: {
+    token: string;
+    branchName: string;
+    resource: ApiResource | GenericResource;
+    agentUrls: string[];
+}): Promise<Signature>;
+export declare function verifyResources({ agentUrls, token, branchName, resources, }: {
+    resources: Array<GenericResource | ApiResource>;
+    token: string;
+    branchName: string;
+    agentUrls: string[];
+}): Promise<void>;

package/dist/socket/signing.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyResources = exports.signResource = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const utils_1 = require("../utils");
+async function signResource({ token, branchName, resource, agentUrls, }) {
+    const requestResource = {
+        branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+    };
+    if (resource.api) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        requestResource.api = (0, utils_1.getSanitizedApi)(resource.api);
+    }
+    else {
+        requestResource.literal = resource.literal;
+    }
+    try {
+        const resp = await callAgentFallBack({
+            baseUrls: agentUrls,
+            path: "v1/signature/sign",
+            method: "post",
+            token: token,
+            data: { resource: requestResource },
+        });
+        return resp.signature;
+    }
+    catch (e) {
+        throw new Error("No agents available to sign the resource");
+    }
+}
+exports.signResource = signResource;
+async function verifyResources({ agentUrls, token, branchName, resources, }) {
+    try {
+        await callAgentFallBack({
+            baseUrls: agentUrls,
+            path: "v1/signature/verify",
+            method: "post",
+            token: token,
+            data: {
+                resources: resources.map((res) => {
+                    if (res.api) {
+                        return {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            api: (0, utils_1.getSanitizedApi)(res.api),
+                            branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+                        };
+                    }
+                    return {
+                        ...res,
+                        branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+                    };
+                }),
+            },
+        });
+    }
+    catch (e) {
+        throw new Error("No agents available to verify the resource");
+    }
+}
+exports.verifyResources = verifyResources;
+async function callAgentFallBack({ baseUrls, path, method, token, data, }) {
+    for (const baseUrl of baseUrls) {
+        try {
+            const url = new URL(path, baseUrl);
+            const config = {
+                url: url.toString(),
+                method: method,
+                headers: {
+                    Authorization: "Bearer " + token,
+                },
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                data: data,
+            };
+            const resp = await (0, axios_1.default)(config);
+            return resp.data;
+        }
+        catch (e) { }
+    }
+    throw new Error("Failed to request ");
+}

package/dist/socket/socket.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="ws" />
+import WebSocket from "isomorphic-ws";
+import { ISocketClient, MethodHandlers } from "../types";
+export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
+    private readonly ws;
+    private readonly requestHandlers;
+    private readonly responseHandler;
+    private peerAuthorization?;
+    private nxtRequestId;
+    constructor(ws: WebSocket, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>);
+    request<Params, Result>(method: string, params: Params, authorization?: string): Promise<Result>;
+    private respond;
+    private respondError;
+    close(): void;
+}
+export declare function createISocketClient<CallableMethods, ImplementedMethods, RequestContext>(socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>): ISocketClient<CallableMethods>;

package/dist/socket/socket.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createISocketClient = exports.ISocket = void 0;
+class ISocket {
+    constructor(ws, requestHandlers) {
+        this.responseHandler = {};
+        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) => {
+            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, {
+                        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(),
+                    });
+                }
+                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);
+                }
+                // 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 await this.respondError(-1, {
+                    code: 3,
+                    message: "unknown request id",
+                });
+            }
+        });
+    }
+    request(method, params, authorization) {
+        return new Promise((resolve, reject) => {
+            const requestId = ++this.nxtRequestId;
+            this.responseHandler[requestId] = {
+                resolve: (result) => resolve(result),
+                reject: (error) => reject(error),
+            };
+            const toSend = {
+                request: {
+                    method,
+                    payload: params,
+                    id: requestId,
+                    setAuthorization: authorization,
+                },
+            };
+            this.ws.send(JSON.stringify(toSend));
+        });
+    }
+    async respond(requestId, result) {
+        const toSend = {
+            response: {
+                payload: result,
+                id: requestId,
+                error: null,
+            },
+        };
+        return this.ws.send(JSON.stringify(toSend));
+    }
+    async respondError(requestId, error) {
+        const toSend = {
+            response: {
+                payload: null,
+                id: requestId,
+                error: error,
+            },
+        };
+        return this.ws.send(JSON.stringify(toSend));
+    }
+    close() {
+        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,@typescript-eslint/no-unsafe-assignment
+        call: createIsocketProxy(socket, undefined),
+    };
+}
+exports.createISocketClient = createISocketClient;