@boltic/sdk 0.1.3 → 0.1.4

package/dist/sdk.mjs

@@ -547,7 +547,8 @@ class AuthManager2 {
 const SERVICE_PATHS = {
   DATABASES: "/service/sdk/boltic-tables/v1",
   WORKFLOW_TEMPORAL: "/service/panel/temporal/v1.0",
-  INTEGRATION: "/service/panel/integration/v1"
+  INTEGRATION: "/service/panel/integration/v1",
+  SERVERLESS: "/service/panel/serverless/v1.0"
 };
 class BaseApiClient {
   constructor(apiKey, config = {}, servicePath = SERVICE_PATHS.DATABASES) {
@@ -4784,7 +4785,7 @@ function buildExecuteActivityBody(params) {
     result: params.result ?? buildDefaultResultPayload()
   };
 }
-function sleep(ms) {
+function sleep$1(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 class WorkflowResource extends BaseResource {
@@ -4982,7 +4983,7 @@ class WorkflowResource extends BaseResource {
         }
         return result;
       }
-      await sleep(POLLING_INTERVAL_MS);
+      await sleep$1(POLLING_INTERVAL_MS);
     }
     return {
       error: {
@@ -4996,6 +4997,485 @@ class WorkflowResource extends BaseResource {
     };
   }
 }
+const STATUS_POLLING_INTERVAL_MS = 5e3;
+const MAX_STATUS_POLLING_ATTEMPTS = 60;
+const TERMINAL_STATUSES = [
+  "running",
+  "failed",
+  "degraded",
+  "suspended"
+];
+const DEFAULT_RESOURCES = {
+  CPU: 0.1,
+  MemoryMB: 128,
+  MemoryMaxMB: 128
+};
+const DEFAULT_SCALING = {
+  AutoStop: false,
+  Min: 1,
+  Max: 1,
+  MaxIdleTime: 0
+};
+const SERVERLESS_ENDPOINTS = {
+  list: {
+    path: "/apps",
+    method: "GET",
+    authenticated: true
+  },
+  get: {
+    path: "/apps/{app_id}",
+    method: "GET",
+    authenticated: true
+  },
+  create: {
+    path: "/apps",
+    method: "POST",
+    authenticated: true
+  },
+  update: {
+    path: "/apps/{app_id}",
+    method: "PUT",
+    authenticated: true
+  },
+  getBuilds: {
+    path: "/apps/{app_id}/builds",
+    method: "GET",
+    authenticated: true
+  },
+  getLogs: {
+    path: "/apps/{app_id}/logs",
+    method: "GET",
+    authenticated: true
+  },
+  getBuildLogs: {
+    path: "/apps/{app_id}/builds/{build_id}/logs",
+    method: "GET",
+    authenticated: true
+  }
+};
+function buildServerlessEndpointPath(endpoint, params = {}) {
+  let path = endpoint.path;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(`{${key}}`, value);
+  }
+  return path;
+}
+class ServerlessApiClient extends BaseApiClient {
+  constructor(apiKey, config = {}) {
+    super(apiKey, config, SERVICE_PATHS.SERVERLESS);
+  }
+  /**
+   * List all serverless functions with optional pagination and search.
+   */
+  async list(params = {}) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.list;
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 20),
+        sortBy: params.sortBy ?? "CreatedAt",
+        sortOrder: params.sortOrder ?? "desc"
+      });
+      if (params.query) {
+        query.set("q", params.query);
+      }
+      const url = `${this.baseURL}${endpoint.path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get a serverless function by its ID.
+   */
+  async get(appId) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.get;
+      const path = buildServerlessEndpointPath(endpoint, { app_id: appId });
+      const url = `${this.baseURL}${path}`;
+      console.log("url", url);
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      console.log("response", response.data);
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Create a new serverless function.
+   */
+  async create(payload) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.create;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: payload,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Update an existing serverless function.
+   */
+  async update(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.update;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const url = `${this.baseURL}${path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: params.payload,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * List builds for a serverless function.
+   */
+  async getBuilds(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getBuilds;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 20),
+        sortBy: "CreatedAt",
+        sortOrder: "desc"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get runtime logs for a serverless function.
+   */
+  async getLogs(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getLogs;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const now = Math.floor(Date.now() / 1e3);
+      const defaultStart = now - 24 * 60 * 60;
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 50),
+        sortBy: "Timestamp",
+        sortOrder: params.sortOrder ?? "DESC",
+        timestampStart: String(params.timestampStart ?? defaultStart),
+        timestampEnd: String(params.timestampEnd ?? now),
+        metric_interval: "60"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get build logs for a specific build of a serverless function.
+   */
+  async getBuildLogs(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getBuildLogs;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId,
+        build_id: params.buildId
+      });
+      const query = new URLSearchParams({
+        limit: "-1",
+        tail: "false",
+        sortOrder: "asc",
+        sortBy: "Timestamp"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class ServerlessResource extends BaseResource {
+  constructor(client) {
+    super(client, "/serverless");
+    const config = client.getConfig();
+    this.apiClient = new ServerlessApiClient(config.apiKey, {
+      environment: config.environment,
+      region: config.region,
+      timeout: config.timeout,
+      debug: config.debug
+    });
+  }
+  /**
+   * List all serverless functions with optional pagination and search.
+   *
+   * @param params - Optional pagination and filter parameters
+   * @returns Paginated list of serverless functions
+   *
+   * @example
+   * ```typescript
+   * const list = await client.serverless.list();
+   * const filtered = await client.serverless.list({ query: 'my-func', limit: 10 });
+   * ```
+   */
+  async list(params = {}) {
+    return this.apiClient.list(params);
+  }
+  /**
+   * Get a serverless function by its ID.
+   *
+   * @param appId - The serverless function ID
+   * @returns The serverless function details
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.get('serverless-id');
+   * ```
+   */
+  async get(appId) {
+    return this.apiClient.get(appId);
+  }
+  /**
+   * Create a new serverless function.
+   *
+   * Supports three runtime types:
+   * - `code` — deploy code directly (blueprint)
+   * - `git` — deploy from a Git repository
+   * - `container` — deploy a Docker container
+   *
+   * @param params - The serverless creation payload
+   * @returns The created serverless function
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.create({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   *   CodeOpts: { Language: 'nodejs/20', Code: 'module.exports.handler = ...' },
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.apiClient.create(params);
+  }
+  /**
+   * Create a serverless function and poll until it reaches a terminal state.
+   *
+   * Combines `create()` + `pollStatus()` for a simpler workflow.
+   *
+   * @param params - The serverless creation payload
+   * @returns The final serverless state after reaching a terminal status
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.createAndWait({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   CodeOpts: { Language: 'nodejs/20', Code: '...' },
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   * });
+   * ```
+   */
+  async createAndWait(params) {
+    const createResult = await this.apiClient.create(params);
+    if (isErrorResponse(createResult)) {
+      return createResult;
+    }
+    const appId = createResult.data?.ID;
+    if (!appId) {
+      return {
+        error: {
+          code: "SERVERLESS_MISSING_ID",
+          message: "Create API response did not contain an ID",
+          meta: []
+        }
+      };
+    }
+    return this.pollStatus(appId);
+  }
+  /**
+   * Update an existing serverless function.
+   *
+   * @param params - The update parameters (appId + partial payload)
+   * @returns The updated serverless function
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.serverless.update({
+   *   appId: 'serverless-id',
+   *   payload: { Scaling: { AutoStop: true, Min: 0, Max: 3, MaxIdleTime: 300 } },
+   * });
+   * ```
+   */
+  async update(params) {
+    return this.apiClient.update(params);
+  }
+  /**
+   * Update a serverless function and poll until it reaches a terminal state.
+   *
+   * @param params - The update parameters (appId + partial payload)
+   * @returns The final serverless state after reaching a terminal status
+   */
+  async updateAndWait(params) {
+    const updateResult = await this.apiClient.update(params);
+    if (isErrorResponse(updateResult)) {
+      return updateResult;
+    }
+    return this.pollStatus(params.appId);
+  }
+  /**
+   * List builds for a serverless function.
+   *
+   * @param params - The app ID and optional pagination
+   * @returns List of builds
+   *
+   * @example
+   * ```typescript
+   * const builds = await client.serverless.getBuilds({ appId: 'serverless-id' });
+   * ```
+   */
+  async getBuilds(params) {
+    return this.apiClient.getBuilds(params);
+  }
+  /**
+   * Get runtime logs for a serverless function.
+   *
+   * @param params - The app ID and optional time range / pagination
+   * @returns Log entries
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.serverless.getLogs({ appId: 'serverless-id' });
+   * const recentLogs = await client.serverless.getLogs({
+   *   appId: 'serverless-id',
+   *   limit: 100,
+   *   sortOrder: 'DESC',
+   * });
+   * ```
+   */
+  async getLogs(params) {
+    return this.apiClient.getLogs(params);
+  }
+  /**
+   * Get build logs for a specific build.
+   *
+   * @param params - The app ID and build ID
+   * @returns Build log entries
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.serverless.getBuildLogs({
+   *   appId: 'serverless-id',
+   *   buildId: 'build-id',
+   * });
+   * ```
+   */
+  async getBuildLogs(params) {
+    return this.apiClient.getBuildLogs(params);
+  }
+  /**
+   * Poll a serverless function until it reaches a terminal status
+   * (running, failed, degraded, or suspended).
+   *
+   * @param appId - The serverless function ID to poll
+   * @param options - Optional polling configuration overrides
+   * @returns The final serverless state or a timeout error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.serverless.pollStatus('serverless-id');
+   * ```
+   */
+  async pollStatus(appId, options = {}) {
+    const interval = options.intervalMs ?? STATUS_POLLING_INTERVAL_MS;
+    const maxAttempts = options.maxAttempts ?? MAX_STATUS_POLLING_ATTEMPTS;
+    const debug = this.client.getConfig().debug;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.apiClient.get(appId);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      const status = result.data?.Status;
+      if (debug) {
+        console.log(
+          `[ServerlessResource] Poll #${attempt + 1}: status=${status}`
+        );
+      }
+      if (status && TERMINAL_STATUSES.includes(status)) {
+        if (debug) {
+          console.log(
+            `[ServerlessResource] Reached terminal state: ${status} after ${attempt + 1} poll(s)`
+          );
+        }
+        return result;
+      }
+      await sleep(interval);
+    }
+    return {
+      error: {
+        code: "SERVERLESS_STATUS_TIMEOUT",
+        message: `Serverless ${appId} did not reach a terminal state within ${maxAttempts} polling attempts`,
+        meta: [
+          `app_id: ${appId}`,
+          `max_attempts: ${maxAttempts}`,
+          `interval_ms: ${interval}`
+        ]
+      }
+    };
+  }
+}
 class BolticClient {
   constructor(apiKey, options = {}) {
     this.currentDatabase = null;
@@ -5019,6 +5499,7 @@ class BolticClient {
     this.indexResource = new IndexResource(this.baseClient);
     this.databaseResource = new DatabaseResource(this.baseClient);
     this.workflowResource = new WorkflowResource(this.baseClient);
+    this.serverlessResource = new ServerlessResource(this.baseClient);
     this.currentDatabase = null;
   }
   /**
@@ -5200,6 +5681,47 @@ class BolticClient {
       getIntegrationForm: (params) => this.workflowResource.getIntegrationForm(params)
     };
   }
+  /**
+   * Serverless function operations.
+   *
+   * @example
+   * ```typescript
+   * // List all serverless functions
+   * const list = await client.serverless.list();
+   *
+   * // Create a new serverless function
+   * const fn = await client.serverless.create({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   CodeOpts: { Language: 'nodejs/20', Code: '...' },
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   * });
+   *
+   * // Get a serverless function by ID
+   * const details = await client.serverless.get('serverless-id');
+   *
+   * // Get builds
+   * const builds = await client.serverless.getBuilds({ appId: 'id' });
+   *
+   * // Get runtime logs
+   * const logs = await client.serverless.getLogs({ appId: 'id' });
+   * ```
+   */
+  get serverless() {
+    return {
+      list: (params) => this.serverlessResource.list(params),
+      get: (appId) => this.serverlessResource.get(appId),
+      create: (params) => this.serverlessResource.create(params),
+      createAndWait: (params) => this.serverlessResource.createAndWait(params),
+      update: (params) => this.serverlessResource.update(params),
+      updateAndWait: (params) => this.serverlessResource.updateAndWait(params),
+      getBuilds: (params) => this.serverlessResource.getBuilds(params),
+      getLogs: (params) => this.serverlessResource.getLogs(params),
+      getBuildLogs: (params) => this.serverlessResource.getBuildLogs(params),
+      pollStatus: (appId, options) => this.serverlessResource.pollStatus(appId, options)
+    };
+  }
   // SQL resource access for testing
   getSqlResource() {
     return this.sqlResource;
@@ -5283,6 +5805,7 @@ class BolticClient {
     this.indexResource = new IndexResource(this.baseClient);
     this.databaseResource = new DatabaseResource(this.baseClient);
     this.workflowResource = new WorkflowResource(this.baseClient);
+    this.serverlessResource = new ServerlessResource(this.baseClient);
   }
   // Security methods to prevent API key exposure
   toString() {
@@ -5311,7 +5834,14 @@ const VERSION = "1.0.0";
 export {
   AuthManager$1 as AuthManager,
   BolticClient,
+  DEFAULT_RESOURCES,
+  DEFAULT_SCALING,
+  MAX_STATUS_POLLING_ATTEMPTS,
   SERVICE_PATHS,
+  STATUS_POLLING_INTERVAL_MS,
+  ServerlessApiClient,
+  ServerlessResource,
+  TERMINAL_STATUSES,
   VERSION,
   WorkflowResource,
   createClient,