@boltic/sdk 0.1.3 → 0.1.4

package/dist/types/index.d.ts

@@ -172,6 +172,7 @@ export declare class BolticClient {
     private indexResource;
     private databaseResource;
     private workflowResource;
+    private serverlessResource;
     private currentDatabase;
     private clientOptions;
     constructor(apiKey: string, options?: ClientOptions);
@@ -311,6 +312,48 @@ export declare class BolticClient {
         getIntegrationResource: (params: GetIntegrationResourceParams) => Promise<BolticErrorResponse | BolticSuccessResponse<IntegrationResourceData>>;
         getIntegrationForm: (params: GetIntegrationFormParams) => Promise<BolticErrorResponse | BolticSuccessResponse<Record<string, unknown> | IntegrationFormJsonSchema>>;
     };
+    /**
+     * 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(): {
+        list: (params?: ListServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ListServerlessData>>;
+        get: (appId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        create: (params: CreateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        createAndWait: (params: CreateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        update: (params: UpdateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        updateAndWait: (params: UpdateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        getBuilds: (params: GetBuildsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetBuildsData>>;
+        getLogs: (params: GetLogsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetLogsData>>;
+        getBuildLogs: (params: GetBuildLogsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetBuildLogsData>>;
+        pollStatus: (appId: string, options?: {
+            intervalMs?: number;
+            maxAttempts?: number;
+        }) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+    };
     getSqlResource(): SqlResource;
     updateApiKey(newApiKey: string): void;
     updateConfig(updates: Partial<ClientConfig>): void;
@@ -482,6 +525,22 @@ export declare function createClient(apiKey: string, options?: ClientOptions): B
  */
 export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
 
+export declare type CreateServerlessData = ServerlessData;
+
+export declare interface CreateServerlessParams {
+    Name: string;
+    Description?: string;
+    Runtime: ServerlessRuntime;
+    Env?: Record<string, string>;
+    PortMap?: ServerlessPortMap[];
+    Scaling?: ServerlessScaling;
+    Resources?: ServerlessResources;
+    Timeout?: number;
+    Validations?: unknown;
+    CodeOpts?: ServerlessCodeOpts;
+    ContainerOpts?: ServerlessContainerOpts;
+}
+
 /** Data returned from the get-credentials API */
 export declare type CredentialsListData = Record<string, unknown>;
 
@@ -623,6 +682,21 @@ declare const DateFormatEnum: Readonly<{
 
 declare type DecimalType = '00' | '0.0' | '0.00' | '0.000' | '0.0000' | '0.00000' | '0.000000';
 
+/** Default resource allocation for new serverless functions */
+export declare const DEFAULT_RESOURCES: {
+    readonly CPU: 0.1;
+    readonly MemoryMB: 128;
+    readonly MemoryMaxMB: 128;
+};
+
+/** Default scaling configuration for new serverless functions */
+export declare const DEFAULT_SCALING: {
+    readonly AutoStop: false;
+    readonly Min: 1;
+    readonly Max: 1;
+    readonly MaxIdleTime: 0;
+};
+
 declare interface DeleteIndexResponse {
     message?: string;
 }
@@ -755,6 +829,26 @@ export declare interface FormField {
     };
 }
 
+export declare type GetBuildLogsData = ServerlessBuildLogEntry[];
+
+export declare interface GetBuildLogsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** The build ID. */
+    buildId: string;
+}
+
+export declare type GetBuildsData = ServerlessBuild[];
+
+export declare interface GetBuildsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 20 */
+    limit?: number;
+}
+
 /** Parameters accepted by `workflow.getCredentials()`. */
 export declare interface GetCredentialsParams {
     /** Integration name (e.g. "freshsales"). Automatically uppercased by the SDK. */
@@ -823,6 +917,30 @@ export declare interface GetIntegrationsParams {
     per_page?: number;
 }
 
+export declare type GetLogsData = ServerlessLogEntry[];
+
+export declare interface GetLogsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 50 */
+    limit?: number;
+    /** Sort direction. @defaultValue 'DESC' */
+    sortOrder?: 'ASC' | 'DESC';
+    /** Unix epoch start (seconds). Defaults to 24h ago. */
+    timestampStart?: number;
+    /** Unix epoch end (seconds). Defaults to now. */
+    timestampEnd?: number;
+}
+
+export declare type GetServerlessData = ServerlessData;
+
+export declare interface GetServerlessParams {
+    /** The serverless function ID. */
+    appId: string;
+}
+
 declare interface HttpAdapter {
     request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
 }
@@ -947,6 +1065,24 @@ declare interface ListIndexesResponse {
     };
 }
 
+export declare type ListServerlessData = ServerlessData[];
+
+export declare interface ListServerlessParams {
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 20 */
+    limit?: number;
+    /** Field to sort by. @defaultValue 'CreatedAt' */
+    sortBy?: string;
+    /** Sort direction. @defaultValue 'desc' */
+    sortOrder?: 'asc' | 'desc';
+    /** Search query string to filter by name. */
+    query?: string;
+}
+
+/** Maximum number of status polling attempts before timeout */
+export declare const MAX_STATUS_POLLING_ATTEMPTS = 60;
+
 export declare interface PaginationInfo {
     total_count: number;
     total_pages: number;
@@ -1223,11 +1359,313 @@ export declare interface RetryConfig {
     maximum_interval: number;
 }
 
+export declare class ServerlessApiClient extends BaseApiClient {
+    constructor(apiKey: string, config?: Omit<BaseApiClientConfig, 'apiKey'>);
+    /**
+     * List all serverless functions with optional pagination and search.
+     */
+    list(params?: ListServerlessParams): Promise<ServerlessResponse<ListServerlessData>>;
+    /**
+     * Get a serverless function by its ID.
+     */
+    get(appId: string): Promise<ServerlessResponse<GetServerlessData>>;
+    /**
+     * Create a new serverless function.
+     */
+    create(payload: CreateServerlessParams): Promise<ServerlessResponse<CreateServerlessData>>;
+    /**
+     * Update an existing serverless function.
+     */
+    update(params: UpdateServerlessParams): Promise<ServerlessResponse<UpdateServerlessData>>;
+    /**
+     * List builds for a serverless function.
+     */
+    getBuilds(params: GetBuildsParams): Promise<ServerlessResponse<GetBuildsData>>;
+    /**
+     * Get runtime logs for a serverless function.
+     */
+    getLogs(params: GetLogsParams): Promise<ServerlessResponse<GetLogsData>>;
+    /**
+     * Get build logs for a specific build of a serverless function.
+     */
+    getBuildLogs(params: GetBuildLogsParams): Promise<ServerlessResponse<GetBuildLogsData>>;
+}
+
+export declare interface ServerlessApiEndpoint {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    authenticated: boolean;
+}
+
+export declare interface ServerlessAppDomain {
+    DomainName: string;
+    BaseUrl?: string;
+}
+
+export declare interface ServerlessBuild {
+    ID: string;
+    Version?: number;
+    Status?: string;
+    StatusHistory?: ServerlessBuildStatusEntry[];
+    CreatedAt?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessBuildLogEntry {
+    Log?: string;
+    Timestamp?: number;
+    Message?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessBuildStatusEntry {
+    Status: string;
+    Timestamp?: string;
+}
+
+export declare interface ServerlessCodeOpts {
+    Language: string;
+    Packages?: string[];
+    Code?: string;
+}
+
+export declare interface ServerlessConfig {
+    Name: string;
+    Description?: string;
+    Runtime: ServerlessRuntime;
+    Env?: Record<string, string>;
+    PortMap?: ServerlessPortMap[];
+    Scaling?: ServerlessScaling;
+    Resources?: ServerlessResources;
+    Timeout?: number;
+    Validations?: unknown;
+    CodeOpts?: ServerlessCodeOpts;
+    ContainerOpts?: ServerlessContainerOpts;
+}
+
+export declare interface ServerlessContainerOpts {
+    Image: string;
+    Args?: string[];
+    Command?: string;
+}
+
+export declare interface ServerlessData {
+    ID: string;
+    ParentID?: string;
+    Status: ServerlessStatus;
+    Config: ServerlessConfig;
+    Links?: {
+        Git?: {
+            Repository?: ServerlessGitRepository;
+        };
+    };
+    AppDomain?: ServerlessAppDomain[];
+    RegionID?: string;
+    CreatedAt?: string;
+    UpdatedAt?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessGitRepository {
+    SshURL?: string;
+    HtmlURL?: string;
+    CloneURL?: string;
+}
+
+export declare interface ServerlessLogEntry {
+    Timestamp?: number;
+    Severity?: string;
+    Log?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessPortMap {
+    ContainerPort?: number;
+    HostPort?: number;
+    Protocol?: string;
+}
+
+export declare class ServerlessResource extends BaseResource {
+    private apiClient;
+    constructor(client: BaseClient);
+    /**
+     * 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 });
+     * ```
+     */
+    list(params?: ListServerlessParams): Promise<BolticSuccessResponse<ListServerlessData> | BolticErrorResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    get(appId: string): Promise<BolticSuccessResponse<GetServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 = ...' },
+     * });
+     * ```
+     */
+    create(params: CreateServerlessParams): Promise<BolticSuccessResponse<CreateServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 },
+     * });
+     * ```
+     */
+    createAndWait(params: CreateServerlessParams): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 } },
+     * });
+     * ```
+     */
+    update(params: UpdateServerlessParams): Promise<BolticSuccessResponse<UpdateServerlessData> | BolticErrorResponse>;
+    /**
+     * 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
+     */
+    updateAndWait(params: UpdateServerlessParams): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+    /**
+     * 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' });
+     * ```
+     */
+    getBuilds(params: GetBuildsParams): Promise<BolticSuccessResponse<GetBuildsData> | BolticErrorResponse>;
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    getLogs(params: GetLogsParams): Promise<BolticSuccessResponse<GetLogsData> | BolticErrorResponse>;
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    getBuildLogs(params: GetBuildLogsParams): Promise<BolticSuccessResponse<GetBuildLogsData> | BolticErrorResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    pollStatus(appId: string, options?: {
+        intervalMs?: number;
+        maxAttempts?: number;
+    }): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+}
+
+export declare interface ServerlessResources {
+    CPU: number;
+    MemoryMB: number;
+    MemoryMaxMB: number;
+}
+
+declare type ServerlessResponse<T> = BolticSuccessResponse<T> | BolticErrorResponse;
+
+export declare type ServerlessRuntime = 'code' | 'git' | 'container';
+
+export declare interface ServerlessScaling {
+    AutoStop: boolean;
+    Min: number;
+    Max: number;
+    MaxIdleTime: number;
+}
+
+export declare type ServerlessStatus = 'running' | 'draft' | 'building' | 'pending' | 'stopped' | 'failed' | 'degraded' | 'suspended';
+
 /** Well-known service paths used across the SDK */
 export declare const SERVICE_PATHS: {
     readonly DATABASES: "/service/sdk/boltic-tables/v1";
     readonly WORKFLOW_TEMPORAL: "/service/panel/temporal/v1.0";
     readonly INTEGRATION: "/service/panel/integration/v1";
+    readonly SERVERLESS: "/service/panel/serverless/v1.0";
 };
 
 export declare interface ServiceAuthConfig extends AuthConfig_2 {
@@ -1266,6 +1704,9 @@ declare class SqlResource {
     executeSQL(query: string, dbId?: string): Promise<ExecuteSQLApiResponse | BolticErrorResponse>;
 }
 
+/** Polling interval in milliseconds between status checks */
+export declare const STATUS_POLLING_INTERVAL_MS = 5000;
+
 /**
  * Table Builder - provides a fluent interface for creating tables
  */
@@ -1541,6 +1982,9 @@ declare interface TableUpdateRequest {
     fields?: Array<keyof TableRecord>;
 }
 
+/** Serverless statuses that indicate the function has reached a terminal state */
+export declare const TERMINAL_STATUSES: readonly ["running", "failed", "degraded", "suspended"];
+
 declare interface TextToSQLOptions {
     currentQuery?: string;
 }
@@ -1584,6 +2028,15 @@ export declare function transformFormToDefaults(fields: FormField[], skipFields?
  */
 export declare function transformFormToJsonSchema(fields: FormField[], skipFields?: Set<string>): IntegrationFormJsonSchema;
 
+export declare type UpdateServerlessData = ServerlessData;
+
+export declare interface UpdateServerlessParams {
+    /** The serverless function ID to update. */
+    appId: string;
+    /** The update payload — partial config fields to update. */
+    payload: Partial<CreateServerlessParams>;
+}
+
 export declare const VERSION = "1.0.0";
 
 export declare interface WhereCondition {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boltic/sdk",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "TypeScript SDK for Boltic databases infrastructure",
   "main": "dist/sdk.js",
   "module": "dist/sdk.mjs",