@superblocksteam/sdk 1.4.2 → 1.5.1

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({ agentUrl, token, }: {
+    token: string;
+    agentUrl?: string;
+}): MethodHandlers<ClientMethods, ServerMethods, unknown>;
+export {};

package/dist/socket/handlers.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandlers = void 0;
+const signing_1 = require("./signing");
+function createRequestHandlers({ agentUrl, token, }) {
+    const requestHandlers = {
+        v1: {
+            signing: {
+                signApplication: [
+                    async ({ branchName, toSign, }) => {
+                        if (!agentUrl) {
+                            throw new Error("Agent url not specified. This shouldn't happen.");
+                        }
+                        const signature = await (0, signing_1.signResource)({
+                            agentUrl,
+                            token: token,
+                            branchName,
+                            resource: {
+                                literal: {
+                                    data: toSign.rootHash,
+                                },
+                            },
+                        });
+                        return { signature: signature };
+                    },
+                ],
+                signApis: [
+                    async ({ branchName, toSign, }) => {
+                        const signatures = [];
+                        for (const { apiPb } of toSign) {
+                            if (!agentUrl) {
+                                throw new Error("Agent url not specified. This shouldn't happen.");
+                            }
+                            const signature = await (0, signing_1.signResource)({
+                                agentUrl,
+                                token: token,
+                                branchName,
+                                resource: { api: apiPb },
+                            });
+                            signatures.push(signature);
+                        }
+                        return { signatures };
+                    },
+                ],
+                verifyApplication: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            if (!agentUrl) {
+                                throw new Error("Agent url not specified. This shouldn't happen.");
+                            }
+                            await (0, signing_1.verifyResources)({
+                                agentUrl,
+                                token,
+                                branchName,
+                                resources: [
+                                    {
+                                        literal: {
+                                            data: toVerify.rootHash,
+                                            signature: toVerify.signature,
+                                        },
+                                    },
+                                ],
+                            });
+                            return { ok: true };
+                        }
+                        catch {
+                            return { ok: false };
+                        }
+                    },
+                ],
+                verifyApi: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            if (!agentUrl) {
+                                throw new Error("Agent url not specified. This shouldn't happen.");
+                            }
+                            await (0, signing_1.verifyResources)({
+                                agentUrl,
+                                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, 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 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, agentUrl, token, }) {
+    const requestHandlers = (0, handlers_1.createRequestHandlers)({
+        agentUrl,
+        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, agentUrl, }: {
+    token: string;
+    branchName: string;
+    resource: ApiResource | GenericResource;
+    agentUrl: string;
+}): Promise<Signature>;
+export declare function verifyResources({ agentUrl, token, branchName, resources, }: {
+    resources: Array<GenericResource | ApiResource>;
+    token: string;
+    branchName: string;
+    agentUrl: string;
+}): Promise<void>;

package/dist/socket/signing.js

@@ -0,0 +1,70 @@
+"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, agentUrl, }) {
+    const requestResource = {
+        branchName: 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;
+    }
+    const resp = await callAgent({
+        baseUrl: agentUrl,
+        path: "v1/signature/sign",
+        method: "post",
+        token: token,
+        data: { resource: requestResource },
+    });
+    return resp.signature;
+}
+exports.signResource = signResource;
+async function verifyResources({ agentUrl, token, branchName, resources, }) {
+    await callAgent({
+        baseUrl: agentUrl,
+        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 ?? "main",
+                    };
+                }
+                return {
+                    ...res,
+                    branchName: branchName ?? "main",
+                };
+            }),
+        },
+    });
+}
+exports.verifyResources = verifyResources;
+async function callAgent({ baseUrl, path, method, token, data, }) {
+    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 (error) {
+        throw new Error(`Failed to request the agent ${baseUrl}. Error: ${error}`);
+    }
+}

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;

package/dist/types/common.d.ts

@@ -0,0 +1,111 @@
+export interface UserMeDto {
+    user: User;
+    organizations: Organization[];
+    agents: Agent[];
+    flagBootstrap: FlagBootstrap;
+}
+export interface FlagBootstrap {
+    "ui.enable-resource-signing"?: boolean;
+}
+export type User = {
+    id: string;
+    email: string;
+    currentOrganizationId: string;
+    organizationIds: string[];
+    username: string;
+    name: string;
+    anonymousId: string;
+    isAnonymous: boolean;
+    isAdmin: boolean;
+    metadata: Record<string, unknown>;
+};
+export interface Organization {
+    id: string;
+    name: string;
+    displayName: string;
+    agents?: Agent[];
+    apiKey: string;
+    agentType: AgentType;
+    minExternalAgentVersion: string;
+    profiles?: Profile[];
+}
+export type Agent = {
+    id: string;
+    key: string;
+    environment: string;
+    status: AgentStatus;
+    version: string;
+    versionExternal: string;
+    url: string;
+    type: AgentType;
+    updated: Date;
+    created: Date;
+    tags: AgentTags;
+    verificationKeyIds?: null | string[];
+    signingKeyId?: null | string;
+};
+export declare enum AgentStatus {
+    ACTIVE = "Active",
+    DISCONNECTED = "Disconnected",
+    BROWSER_UNREACHABLE = "Browser Unreachable",
+    PENDING_REGISTRATION = "Pending Registration",
+    STALE = "Stale"
+}
+export declare enum AgentType {
+    MULTITENANT = 0,
+    DEDICATED = 1,
+    ONPREMISE = 2
+}
+export type AgentTags = Record<string, string[]>;
+export declare class Profile {
+    id: string;
+    key: string;
+    displayName: string;
+    description: string;
+    type: ProfileType;
+    constructor({ id, key, displayName, description, type, }: {
+        id: string;
+        key: string;
+        displayName: string;
+        description: string;
+        type: ProfileType;
+    });
+}
+export declare enum ProfileType {
+    RESERVED = "RESERVED",
+    CUSTOM = "CUSTOM"
+}
+export type Api = {
+    metadata: {
+        name: string;
+        id: string;
+        organization: string;
+        timestamps?: {
+            created: string;
+            updated: string;
+            deactivated: boolean;
+        };
+        creator?: {
+            id: string;
+            name: string;
+        };
+        folder?: string;
+    };
+    blocks?: any[];
+    trigger: any;
+    signature?: Signature;
+};
+/** A signature, as produced by the agent. */
+export interface Signature {
+    /** The id of the key used to sign the data. */
+    keyId: string;
+    /** The actual signature, in base64. */
+    data: string;
+}
+export interface RemoteCommitDto {
+    commitId: string;
+    remoteCommitId: string;
+    remoteCommitDate: Date;
+    branchName: string;
+    repositoryId: string;
+}