@superblocksteam/sabs-client 0.0.1-demo-databricks-deploy

package/src/sabs.ts

@@ -0,0 +1,502 @@
+import {
+  ApplicationMetadata,
+  BuildRequest,
+  BuildResponse,
+  BuildStatus,
+  DeployDatabricksRequest,
+  DeployDatabricksResponse,
+  ListRequest,
+  ListResponse,
+  StatusResponse,
+  TerminateRequest,
+  TerminateResponse,
+  BulkStatusRequest,
+  BulkStatusResponse,
+  CreateLiveEditRequest,
+  CreateLiveEditResponse,
+  TerminateLiveEditResponse,
+  TerminateLiveEditRequest
+} from '@superblocksteam/sabs-types';
+import axios, { AxiosRequestConfig, RawAxiosRequestHeaders } from 'axios';
+
+import { createErrorFromStatusCode, createClientError, createNetworkError } from './errors';
+
+/**
+ * SABS (Superblocks Application Build System) TypeScript Client
+ *
+ * Provides methods to interact with the SABS API for building and managing applications.
+ *
+ * All error types inherit from the standard `HttpError` class that extends the standard `Error` class,
+ * ensuring backward compatibility with existing error handling code that catches generic `Error` instances
+ * used in earlier versions of the client library.
+ */
+export class SabsClient {
+  private readonly baseUrl: string;
+
+  public constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  /**
+   * Start a new build for an application
+   *
+   * @param params - Build parameters
+   * @param params.directoryHash - Hash of the application directory to build
+   * @param params.meta - Application metadata (ID and organization ID)
+   * @param params.buildKey - Secret build key for authentication
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to build information including build ID
+   * @throws BadRequestError if the directory hash, application metadata, application ID, organization ID, build key, or access token are empty or invalid
+   * @throws ForbiddenError if the access token is invalid or missing the required scopes
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async build({
+    directoryHash,
+    meta,
+    buildKey,
+    accessToken
+  }: {
+    directoryHash: string;
+    meta: ApplicationMetadata;
+    buildKey: string;
+    accessToken?: string;
+  }): Promise<BuildResponse> {
+    if (!directoryHash || directoryHash.length === 0) {
+      throw createClientError('Directory hash is required');
+    }
+    if (!meta) {
+      throw createClientError('Application metadata is required');
+    }
+    if (!meta.id || meta.id.length === 0) {
+      throw createClientError('Application ID is required');
+    }
+    if (!meta.organizationId || meta.organizationId.length === 0) {
+      throw createClientError('Organization ID is required');
+    }
+    if (!buildKey || buildKey.length === 0) {
+      throw createClientError('Build key is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new BuildRequest({
+      directoryHash: directoryHash,
+      applicationMetadata: meta,
+      buildKey
+    });
+
+    return this.executeRequest<BuildResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Start a new Databricks build for an application and deploy it to Databricks
+   *
+   * @param params - Build parameters
+   * @param params.directoryHash - Hash of the application directory to build
+   * @param params.meta - Application metadata (ID and organization ID)
+   * @param params.buildKey - Secret build key for authentication
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to build information including build ID
+   * @throws BadRequestError if the directory hash, application metadata, application ID, organization ID, build key, or access token are empty or invalid
+   * @throws ForbiddenError if the access token is invalid or missing the required scopes
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async deployDatabricks({
+    directoryHash,
+    meta,
+    buildKey,
+    accessToken
+  }: {
+    directoryHash: string;
+    meta: ApplicationMetadata;
+    buildKey: string;
+    accessToken?: string;
+  }): Promise<DeployDatabricksResponse> {
+    if (!directoryHash || directoryHash.length === 0) {
+      throw createClientError('Directory hash is required');
+    }
+    if (!meta) {
+      throw createClientError('Application metadata is required');
+    }
+    if (!meta.id || meta.id.length === 0) {
+      throw createClientError('Application ID is required');
+    }
+    if (!meta.organizationId || meta.organizationId.length === 0) {
+      throw createClientError('Organization ID is required');
+    }
+    if (!buildKey || buildKey.length === 0) {
+      throw createClientError('Build key is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new DeployDatabricksRequest({
+      directoryHash: directoryHash,
+      applicationMetadata: meta,
+      buildKey
+    });
+
+    return this.executeRequest<DeployDatabricksResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds/deploy-databricks`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Get the status of a build
+   *
+   * @param params - Status query parameters
+   * @param params.buildId - ID of the build to check
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to build status information
+   * @throws BadRequestError if the build ID or access token is empty or invalid
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws NotFoundError if the build ID is invalid
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async status({ buildId, accessToken }: { buildId: string; accessToken?: string }): Promise<StatusResponse> {
+    if (!buildId || buildId.length === 0) {
+      throw createClientError('Build ID is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    return this.executeRequest<StatusResponse>(
+      {
+        method: 'GET',
+        url: `${this.baseUrl}/v1/builds/${buildId}`
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Get the status of multiple builds at once
+   *
+   * @param params - Bulk status query parameters
+   * @param params.organizationId - Organization ID
+   * @param params.applicationId - Application ID
+   * @param params.directoryHashes - Array of directory hashes to check
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to multiple build status information
+   * @throws BadRequestError if the organization ID, application ID, directory hashes, or access token are empty or invalid
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws NotFoundError if the organization ID or application ID is invalid
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async bulkStatus({
+    organizationId,
+    applicationId,
+    directoryHashes,
+    accessToken
+  }: {
+    organizationId: string;
+    applicationId: string;
+    directoryHashes: string[];
+    accessToken?: string;
+  }): Promise<BulkStatusResponse> {
+    if (!organizationId || organizationId.length === 0) {
+      throw createClientError('Organization ID is required');
+    }
+    if (!applicationId || applicationId.length === 0) {
+      throw createClientError('Application ID is required');
+    }
+    if (!directoryHashes || directoryHashes.length === 0) {
+      throw createClientError('Directory hashes are required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new BulkStatusRequest({
+      organizationId,
+      applicationId,
+      directoryHashes
+    });
+
+    return this.executeRequest<BulkStatusResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds/${organizationId}/${applicationId}/bulk-status`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * List all builds for a specific application and directory
+   *
+   * @param params - List query parameters
+   * @param params.organizationId - Organization ID
+   * @param params.applicationId - Application ID
+   * @param params.directoryHash - Hash of the application directory
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to list of builds
+   * @throws BadRequestError if the organization ID, application ID, directory hash, or access token are empty or invalid
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws NotFoundError if the organization ID or application ID is invalid
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async list({
+    organizationId,
+    applicationId,
+    directoryHash,
+    accessToken
+  }: {
+    organizationId: string;
+    applicationId: string;
+    directoryHash: string;
+    accessToken?: string;
+  }): Promise<ListResponse> {
+    if (!organizationId || organizationId.length === 0) {
+      throw createClientError('Organization ID is required');
+    }
+    if (!applicationId || applicationId.length === 0) {
+      throw createClientError('Application ID is required');
+    }
+    if (!directoryHash || directoryHash.length === 0) {
+      throw createClientError('Directory hash is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new ListRequest({
+      organizationId,
+      applicationId,
+      directoryHash
+    });
+
+    return this.executeRequest<ListResponse>(
+      {
+        method: 'GET',
+        url: `${this.baseUrl}/v1/build`,
+        params: data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Terminate a running build with a final status
+   *
+   * @param params - Termination parameters
+   * @param params.buildId - ID of the build to terminate
+   * @param params.status - Final status of the build
+   * @param params.buildKey - Secret build key for authentication
+   * @param params.error - Optional error message if build failed
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to termination confirmation
+   * @throws BadRequestError if the build ID, build status, build key, or access token are empty or invalid
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws NotFoundError if the build ID is invalid
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async terminate({
+    buildId,
+    status,
+    buildKey,
+    error,
+    accessToken
+  }: {
+    buildId: string;
+    status: BuildStatus;
+    buildKey?: string;
+    error?: string;
+    accessToken?: string;
+  }): Promise<TerminateResponse> {
+    if (!buildId || buildId.length === 0) {
+      throw createClientError('Build ID is required');
+    }
+    if (!status) {
+      throw createClientError('Build status is required');
+    }
+    if (!buildKey || buildKey.length === 0) {
+      throw createClientError('Build key is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new TerminateRequest({
+      buildId,
+      status,
+      error,
+      buildKey
+    });
+
+    return this.executeRequest<TerminateResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds/${buildId}/terminate`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Create a new live edit session for real-time development
+   *
+   * @param params - Live edit creation parameters
+   * @param params.applicationId - Application ID
+   * @param params.organizationId - Organization ID
+   * @param params.branch - Git branch name
+   * @param params.expiresIn - Session duration in seconds
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to live edit session information
+   * @throws BadRequestError if the application ID, organization ID, branch, or access token are empty or invalid, or expiresIn is not greater than 0
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async createLiveEdit({
+    applicationId,
+    organizationId,
+    branch,
+    expiresIn,
+    accessToken
+  }: {
+    applicationId: string;
+    organizationId: string;
+    branch: string;
+    expiresIn: number;
+    accessToken: string;
+  }): Promise<CreateLiveEditResponse> {
+    if (!applicationId || applicationId.length === 0) {
+      throw createClientError('Application ID is required');
+    }
+    if (!organizationId || organizationId.length === 0) {
+      throw createClientError('Organization ID is required');
+    }
+    if (!branch || branch.length === 0) {
+      throw createClientError('Branch is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+    if (!expiresIn || expiresIn <= 0) {
+      throw createClientError('Expires in is required and must be greater than 0');
+    }
+
+    const data = new CreateLiveEditRequest({
+      application: {
+        applicationId,
+        organizationId: organizationId,
+        branch: branch
+      },
+      sessionJwt: accessToken,
+      expiresIn: BigInt(expiresIn)
+    });
+
+    return this.executeRequest<CreateLiveEditResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/live-edit`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  /**
+   * Terminate an active live edit session
+   *
+   * @param params - Live edit termination parameters
+   * @param params.liveEditId - ID of the live edit session to terminate
+   * @param params.accessToken - JWT access token for authorization
+   * @returns Promise resolving to termination confirmation
+   * @throws BadRequestError if the live edit ID or access token are empty or invalid
+   * @throws UnauthorizedError if the access token is invalid or missing the required scopes
+   * @throws NotFoundError if the live edit ID is invalid
+   * @throws InternalServerError if the service has an unexpected error while performing this request
+   * @throws HttpError if the request fails for an unknown reason
+   */
+  public async terminateLiveEdit({
+    liveEditId,
+    accessToken
+  }: {
+    liveEditId: string;
+    accessToken: string;
+  }): Promise<TerminateLiveEditResponse> {
+    if (!liveEditId || liveEditId.length === 0) {
+      throw createClientError('Live edit ID is required');
+    }
+    if (!accessToken || accessToken.length === 0) {
+      throw createClientError('Access token is required');
+    }
+
+    const data = new TerminateLiveEditRequest({
+      liveEditId
+    });
+
+    return this.executeRequest<TerminateLiveEditResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/live-edit/${liveEditId}/terminate`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  private async executeRequest<T>(config: AxiosRequestConfig, accessToken?: string): Promise<T> {
+    let headers: RawAxiosRequestHeaders | undefined;
+    if (accessToken || config.headers) {
+      headers = {
+        ...config.headers,
+        Authorization: accessToken ? `Bearer ${accessToken}` : undefined
+      };
+    }
+
+    try {
+      const response = await axios.request<T>({
+        ...config,
+        headers
+      });
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const statusCode = error.response?.status ?? 500;
+        const statusText = error.response?.statusText ?? 'Unknown Error';
+        const responseData = error.response?.data;
+
+        let message: string;
+        if (responseData && typeof responseData === 'object' && responseData.message) {
+          message = responseData.message;
+        } else if (responseData && typeof responseData === 'string') {
+          message = responseData;
+        } else {
+          message = `${statusText} (${statusCode})`;
+        }
+
+        throw createErrorFromStatusCode(statusCode, message);
+      } else {
+        // Network error or other non-HTTP error
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        throw createNetworkError(message, error instanceof Error ? error : undefined);
+      }
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "composite": true,
+    "incremental": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "strictNullChecks": true,
+    "allowJs": false,
+    "skipLibCheck": true
+  },
+  "exclude": ["./dist", "./node_modules"],
+  "include": ["./**/*.ts"]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": true
+  },
+  "include": ["./test/**/*.ts", "./src/**/*.ts", "./*.config.js", "./src/**/*.json"],
+  "exclude": ["node_modules"]
+}