@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/connector-run.d.ts

@@ -0,0 +1,62 @@
+import { ApiError, type ApiErrorFields } from '../../http/api/errors.js';
+import { type ConnectorAccount, type ConnectorArgs, type ConnectorAttachmentUploadInput, type ConnectorAttachmentUploadResult, type ConnectorCallOptions, type ConnectorCallResult, type ConnectorCatalogEntry, type ConnectorResult, type ConnectorTool } from './connectors.js';
+export interface ConnectorCallErrorFields extends ApiErrorFields {
+    reason: string;
+    connector: string;
+    action: string;
+    binding?: string | null;
+    upstreamStatus?: number | null;
+    retryAfterSeconds?: number | null;
+    connectUrl?: string | null;
+    hint?: string | null;
+    availableAccounts?: string[];
+    requestedAccount?: string | null;
+}
+export declare class ConnectorCallError extends ApiError {
+    reason: string;
+    connector: string;
+    action: string;
+    binding: string | null;
+    upstreamStatus: number | null;
+    retryAfterSeconds: number | null;
+    connectUrl: string | null;
+    hint: string | null;
+    availableAccounts: string[];
+    requestedAccount: string | null;
+    constructor(message: string, fields: ConnectorCallErrorFields);
+}
+export declare class ConnectorApprovalPendingError extends Error {
+    connector: string;
+    action: string;
+    reason: string | null;
+    executionId: string | null;
+    approvalUrl: string | null;
+    approvalSummary: string | null;
+    approvalInstructions: string | null;
+    retryable: boolean;
+    constructor(connector: string, action: string, result: ConnectorCallResult);
+}
+export declare class ConnectorPageLimitError extends Error {
+    readonly code = "max_pages_exceeded";
+    connector: string;
+    action: string;
+    maxPages: number;
+    nextArgs: Record<string, unknown>;
+    constructor(connector: string, action: string, maxPages: number, nextArgs: Record<string, unknown>);
+}
+export declare function runConnector<T = unknown>(projectId: string | undefined, slug: string, action: string, args?: Record<string, unknown>, options?: ConnectorCallOptions): Promise<T>;
+export interface ConnectorPaginateOptions<O, A> extends ConnectorCallOptions {
+    next: (page: O, args: A) => A | null | undefined;
+    maxPages?: number;
+}
+export declare function paginateConnector<O = unknown, A extends Record<string, unknown> = Record<string, unknown>>(projectId: string | undefined, slug: string, action: string, args: A, options: ConnectorPaginateOptions<O, A>): AsyncGenerator<O, void, undefined>;
+export interface ConnectorHandle<S extends string = string> {
+    readonly slug: S;
+    run<A extends string>(action: A, args: ConnectorArgs<S, A>, options?: ConnectorCallOptions): Promise<ConnectorResult<S, A>>;
+    call<A extends string>(action: A, args: ConnectorArgs<S, A>, options?: ConnectorCallOptions): Promise<ConnectorCallResult<unknown, ConnectorResult<S, A>>>;
+    describe(): Promise<ConnectorCatalogEntry | null>;
+    describe(action: string): Promise<ConnectorTool | null>;
+    accounts(): Promise<ConnectorAccount[]>;
+    paginate<A extends string>(action: A, args: ConnectorArgs<S, A>, options: ConnectorPaginateOptions<ConnectorResult<S, A>, ConnectorArgs<S, A>>): AsyncGenerator<ConnectorResult<S, A>, void, undefined>;
+    uploadAttachment(content: Uint8Array | ArrayBuffer | Blob, input: Omit<ConnectorAttachmentUploadInput, 'connector'>): Promise<ConnectorAttachmentUploadResult>;
+}

package/dist/core/rest/projects-client/connector-run.js

@@ -0,0 +1,155 @@
+import { ApiError } from '../../http/api/errors.js';
+import { callConnector, } from './connectors.js';
+export class ConnectorCallError extends ApiError {
+    reason;
+    connector;
+    action;
+    binding;
+    upstreamStatus;
+    retryAfterSeconds;
+    connectUrl;
+    hint;
+    availableAccounts;
+    requestedAccount;
+    constructor(message, fields) {
+        const { reason, connector, action, binding, upstreamStatus, retryAfterSeconds, connectUrl, hint, availableAccounts, requestedAccount, ...apiFields } = fields;
+        super(message, { ...apiFields, name: 'ConnectorCallError' });
+        this.reason = reason;
+        this.connector = connector;
+        this.action = action;
+        this.binding = binding ?? null;
+        this.upstreamStatus = upstreamStatus ?? null;
+        this.retryAfterSeconds = retryAfterSeconds ?? null;
+        this.connectUrl = connectUrl ?? null;
+        this.hint = hint ?? null;
+        this.availableAccounts = availableAccounts ?? [];
+        this.requestedAccount = requestedAccount ?? null;
+    }
+}
+export class ConnectorApprovalPendingError extends Error {
+    connector;
+    action;
+    reason;
+    executionId;
+    approvalUrl;
+    approvalSummary;
+    approvalInstructions;
+    retryable;
+    constructor(connector, action, result) {
+        super(`${connector}.${action} is waiting for approval` +
+            (result.approval_url ? `: ${result.approval_url}` : ''));
+        this.name = 'ConnectorApprovalPendingError';
+        this.connector = connector;
+        this.action = action;
+        this.reason = result.reason ?? null;
+        this.executionId = result.execution_id ?? null;
+        this.approvalUrl = result.approval_url ?? null;
+        this.approvalSummary = result.approval_summary ?? null;
+        this.approvalInstructions = result.approval_instructions ?? null;
+        this.retryable = result.retryable ?? false;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class ConnectorPageLimitError extends Error {
+    code = 'max_pages_exceeded';
+    connector;
+    action;
+    maxPages;
+    nextArgs;
+    constructor(connector, action, maxPages, nextArgs) {
+        super(`${connector}.${action} has more than ${maxPages} pages; resume with nextArgs`);
+        this.name = 'ConnectorPageLimitError';
+        this.connector = connector;
+        this.action = action;
+        this.maxPages = maxPages;
+        this.nextArgs = nextArgs;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+const str = (value) => (typeof value === 'string' && value ? value : null);
+function reasonCode(reason) {
+    return /^([a-z][a-z0-9_]*)(?::|$)/.exec(reason)?.[1] ?? 'connector_error';
+}
+function retryAfterHeader(response) {
+    const value = response?.headers?.get('retry-after');
+    return value && /^\d+$/.test(value.trim()) ? Number(value) : null;
+}
+function toConnectorCallError(error, connector, action) {
+    if (!(error instanceof ApiError) || typeof error.status !== 'number')
+        return error;
+    const body = error.details && typeof error.details === 'object' ? error.details : {};
+    const reason = str(body.reason) ?? str(body.error) ?? error.message;
+    const prefixed = /^upstream_(\d{3})\b/.exec(reason);
+    const upstreamStatus = typeof body.upstream_status === 'number' ? body.upstream_status : prefixed ? Number(prefixed[1]) : null;
+    return new ConnectorCallError(str(body.message) ?? str(body.hint) ?? reason, {
+        status: error.status,
+        code: upstreamStatus === null ? reasonCode(reason) : `upstream_${upstreamStatus}`,
+        details: error.details,
+        data: error.details,
+        response: error.response,
+        reason,
+        connector: str(body.connector) ?? connector,
+        action: str(body.action) ?? action,
+        binding: str(body.binding),
+        upstreamStatus,
+        retryAfterSeconds: typeof body.retry_after_seconds === 'number'
+            ? body.retry_after_seconds
+            : retryAfterHeader(error.response),
+        connectUrl: str(body.connect_url),
+        hint: str(body.hint),
+        availableAccounts: Array.isArray(body.available_accounts) ? body.available_accounts : [],
+        requestedAccount: str(body.requested_account),
+    });
+}
+function callOutput(result) {
+    if ('output' in result)
+        return result.output;
+    const data = result.data;
+    if (data?.provider === 'composio' && 'result' in data)
+        return data.result;
+    if (data?.jsonrpc === '2.0' && data.result)
+        return data.result.structuredContent ?? data.result.content;
+    return result.data;
+}
+export async function runConnector(projectId, slug, action, args = {}, options = {}) {
+    const connector = slug.trim();
+    const actionPath = action.trim();
+    if (!connector || !actionPath)
+        throw new Error('connector slug and action are required');
+    let result;
+    try {
+        result = await callConnector(projectId, `${connector}.${actionPath}`, args, options);
+    }
+    catch (error) {
+        throw toConnectorCallError(error, connector, actionPath);
+    }
+    if (result.status === 'pending_approval') {
+        throw new ConnectorApprovalPendingError(connector, actionPath, result);
+    }
+    if (!result.ok || result.upstream_error) {
+        const reason = result.upstream_error ?? result.reason ?? 'connector_error';
+        throw new ConnectorCallError(reason, {
+            status: 200,
+            code: result.upstream_error ? 'upstream_error' : reasonCode(reason),
+            details: result,
+            data: result,
+            reason,
+            connector,
+            action: actionPath,
+            binding: result.binding ?? null,
+            upstreamStatus: result.upstream_status ?? null,
+        });
+    }
+    return callOutput(result);
+}
+export async function* paginateConnector(projectId, slug, action, args, options) {
+    const { next, maxPages = 100, ...callOptions } = options;
+    let pageArgs = args;
+    for (let page = 0; pageArgs; page++) {
+        if (page >= maxPages)
+            throw new ConnectorPageLimitError(slug, action, maxPages, pageArgs);
+        const output = await runConnector(projectId, slug, action, pageArgs, callOptions);
+        yield output;
+        pageArgs = next(output, pageArgs);
+    }
+}