@extrahorizon/javascript-sdk 8.10.0-dev-159-0e9a0f1 → 8.10.0-dev-161-c1dd6ca

package/build/services/tasks/functions/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { FunctionsService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => FunctionsService;
+export default _default;

package/build/services/tasks/functions/types.d.ts

@@ -0,0 +1,171 @@
+import { OptionsBase, type AffectedRecords, type PagedResult } from '../../types';
+import { Task } from '../types';
+export interface FunctionsService {
+    /**
+     * View a list of functions.
+     *
+     * Although this endpoint is a paged-like endpoint, it will return all functions in a single page.
+     * RQL is not supported for this endpoint, and any RQL provided will be ignored.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASK_FUNCTIONS` | `global` | **Required** for this endpoint
+     */
+    find(options?: OptionsBase): Promise<PagedResult<FunctionBase>>;
+    /**
+     * View a list of functions.
+     *
+     * Although this endpoint is a paged-like endpoint, it will return all functions in a single page.
+     * RQL is not supported for this endpoint, and any RQL provided will be ignored.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASK_FUNCTIONS` | `global` | **Required** for this endpoint
+     */
+    create(body: FunctionCreation, options?: OptionsBase): Promise<FunctionDetails>;
+    /**
+     * View details of a function by its name.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASK_FUNCTION_DETAILS` | `global` | **Required** for this endpoint
+     *
+     * @throws {ResourceUnknownError} When no function with the specified name is found
+     */
+    getByName(name: string, options?: OptionsBase): Promise<FunctionDetails>;
+    /**
+     * Update a function by its name.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `UPDATE_TASK_FUNCTION` | `global` | **Required** for this endpoint
+     *
+     * @throws {ResourceUnknownError} When no function with the specified name is found
+     */
+    update(name: string, body: Partial<FunctionCreation>, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * Delete a function by its name.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `DELETE_TASK_FUNCTION` | `global` | **Required** for this endpoint
+     *
+     * @throws {ResourceUnknownError} When no function with the specified name is found
+     */
+    remove(name: string, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * Enable a function by its name.
+     *
+     * Does nothing if the function is already enabled.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `UPDATE_TASK_FUNCTION` | `global` | **Required** for this endpoint
+     *
+     * @throws {ResourceUnknownError} When no function with the specified name is found
+     */
+    enable(name: string, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * Disable a function by its name.
+     *
+     * Does nothing if the function is already disabled.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `UPDATE_TASK_FUNCTION` | `global` | **Required** for this endpoint
+     *
+     * @throws {ResourceUnknownError} When no function with the specified name is found
+     */
+    disable(name: string, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * ## Execute a Function directly
+     *
+     * A Function may be executed directly, the function will be executed synchronously and the response may be awaited by the caller.
+     *
+     * **Default Permissions:**
+     * - Any party may execute Functions with the `public` permission mode
+     * - Any authenticated user may execute Functions with the `allUsers` permission mode
+     *
+     * **Global Permissions:**
+     * - `EXECUTE_TASK_FUNCTION` - A user may execute all Functions
+     * - `EXECUTE_TASK_FUNCTION:{FUNCTION_NAME}` - A user may execute the Function specified by the FUNCTION_NAME
+     *
+     * @param functionName {@link string} - The functionName property serves as the unique identifier amongst all Functions
+     * @param data {@link U} - The data to be sent to the Function, the type may be specified by the user
+     * @param options {@link OptionsBase} - Additional options for the request
+     * @returns {@link DirectExecutionResponse} - The response returned from the Function, the response data and results may be user defined
+     */
+    execute<T = any, U = any>(functionName: string, data?: U, options?: OptionsBase): Promise<DirectExecutionResponse<T, U>>;
+}
+export interface FunctionBase {
+    /** The name of the Function */
+    name: string;
+    /** A description of the Function */
+    description: string;
+    /** The timestamp when the Function was last updated */
+    updateTimestamp: Date;
+}
+export interface FunctionCreation {
+    /** The name of the Function, this serves as the unique identifier amongst all Functions */
+    name: string;
+    /** A description of the Function */
+    description?: string;
+    /** Base64 Encoded binary value of the compressed (.zip) function code */
+    code: string;
+    /** Entry point for execution of the function, e.g. `index.handler` */
+    entryPoint: string;
+    /**
+     * The runtime environment for the Function, e.g. `nodejs24.x`
+     * The supported runtimes can be found in the [task service documentation](https://docs.extrahorizon.com/extrahorizon/services/automation/task-service/functions#runtime)
+     */
+    runtime: string;
+    /**
+     * Maximum execution time (seconds) of the function.
+     * Should be between 3 and 300 seconds, defaults to 30 seconds if not provided.
+     */
+    timeLimit?: number;
+    /**
+     * Memory limit (MB) for the function.
+     * Should be between 128 and 10240, defaults to 128 if not provided.
+     */
+    memoryLimit?: number;
+    /** Environment variables to be made available to the function during execution */
+    environmentVariables?: {
+        [key: string]: {
+            value: string;
+        };
+    };
+    /** Options related to the execution of the function, such as permission an priority */
+    executionOptions?: {
+        /** Defines access for executing the function directly or for invoking it as an API function. */
+        permissionMode?: FunctionPermissionMode;
+        /** The default priority assigned to all tasks created for this function, unless a priority is specified for a task explicitly */
+        defaultPriority?: number;
+    };
+    /** The policy that determines system behavior after the execution of a Function fails. */
+    retryPolicy?: {
+        /**
+         * The retry policy is disabled by default, If this field is set to true, the retry policy becomes active.
+         * If active the policy will retry a maximum of 3 times, with an increasing timeout of 2, 5 and 10 seconds respectively.
+         */
+        enabled: boolean;
+        /** A list of error names that should trigger a retry. If not specified, the default is to retry on all errors. */
+        errorsToRetry: string[];
+    };
+}
+export declare type FunctionDetails = Omit<FunctionCreation, 'code'> & FunctionBase & {
+    /** Indicates whether the function is enabled or disabled for execution/invocation. Enabled by default. */
+    enabled: boolean;
+};
+export declare enum FunctionPermissionMode {
+    /** To execute this function directly the user needs the EXECUTE_TASK_FUNCTION permission */
+    PERMISSION_REQUIRED = "permissionRequired",
+    /** Every logged in user can execute this function directly */
+    ALL_USERS = "allUsers",
+    /** The function can be executed even by unauthenticated requests */
+    PUBLIC = "public"
+}
+export interface DirectExecutionResponse<T, U> extends Task<U> {
+    /** The result of the Function execution, this may be user defined */
+    result: T;
+}

package/build/services/tasks/index.d.ts

@@ -0,0 +1,15 @@
+import { ApiRequestService } from '../../types';
+import type { ApiService, FunctionsService, HttpInstance, LogsService, SchedulesService } from '../../types';
+import api from './api';
+import apiRequests from './apiRequests';
+import functions from './functions';
+import logs from './logs';
+import schedules from './schedules';
+import { TasksService } from './types';
+export declare const tasksService: (httpWithAuth: HttpInstance) => TasksService & {
+    schedules: SchedulesService;
+    functions: FunctionsService;
+    api: ApiService;
+    logs: LogsService;
+    apiRequests: ApiRequestService;
+};

package/build/services/tasks/logs/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { LogsService } from './types';
+declare const _default: (client: HttpClient, httpWithAuth: HttpInstance) => LogsService;
+export default _default;

package/build/services/tasks/logs/types.d.ts

@@ -0,0 +1,28 @@
+import { ObjectId, OptionsWithRql } from '../../types';
+export interface LogsService {
+    /**
+     * ## Retrieve a list of logs for a task
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_LOGS` - **Required** for this endpoint
+     *
+     * @param taskId {@link string} The id of the targeted task
+     * @param options {@link OptionsWithRql} - Additional options for the request
+     * @returns An array of task logs {@link LogLine LineLog[]}
+     */
+    find(taskId: ObjectId, options?: OptionsWithRql): Promise<LogLine[]>;
+    /**
+     * ## Retrieve the first queried task log
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_LOGS` - **Required** for this endpoint
+     *
+     * @param taskId {@link string} The id of the targeted task
+     * @param options {@link OptionsWithRql} - Additional options for the request
+     * @returns The first element of the queried task logs {@link LogLine}     */
+    findFirst(taskId: ObjectId, options?: OptionsWithRql): Promise<LogLine | undefined>;
+}
+export interface LogLine {
+    message: string;
+    timestamp: Date;
+}

package/build/services/tasks/schedules/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { SchedulesService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => SchedulesService;
+export default _default;

package/build/services/tasks/schedules/types.d.ts

@@ -0,0 +1,92 @@
+import { FindAllIterator } from '../../helpers';
+import { AffectedRecords, ObjectId, OptionsBase, OptionsWithRql, PagedResultWithPager } from '../../types';
+export interface SchedulesService {
+    /**
+     * ## Create a new Schedule
+     *
+     * **Global Permissions:**
+     * - `CREATE_TASK_SCHEDULE` - Allows a user to create schedules
+     *
+     * @param schedule - The data used to create the schedule
+     * @param options - Additional options for the request
+     */
+    create<T>(schedule: ScheduleCreation<T>, options?: OptionsBase): Promise<Schedule<T>>;
+    /**
+     * ## Delete a Schedule
+     *
+     * **Global Permissions:**
+     * - `DELETE_TASK_SCHEDULE` - Allows a user to delete schedules
+     *
+     * @param scheduleId - The id of the schedule to delete
+     * @param options - Additional options for the request
+     */
+    remove(scheduleId: ObjectId, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * @deprecated Use `remove` instead.
+     */
+    delete(scheduleId: ObjectId, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * ## Retrieve a paged list of schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns A paged list of schedules {@link PagedResultWithPager PagedResultWithPager<Schedule>}
+     */
+    find<T>(options?: OptionsWithRql): Promise<PagedResultWithPager<Schedule<T>>>;
+    /**
+     * ## Retrieve a list of all Schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An array of Schedules {@link Schedule Schedule[]}
+     * @throws {@link Error} Do not pass in limit operator with findAll
+     */
+    findAll<T>(options?: OptionsWithRql): Promise<Schedule<T>[]>;
+    /**
+     * ## Retrieve a paged list of Schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view Schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An iterator for the queried schedules {@link FindAllIterator FindAllIterator<Schedule>}
+     */
+    findAllIterator<T>(options?: OptionsWithRql): FindAllIterator<Schedule<T>>;
+    /**
+     * ## Retrieve the first queried Schedule
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view Schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns The first element of the queried Schedules {@link Schedule}
+     */
+    findFirst<T>(options?: OptionsWithRql): Promise<Schedule<T> | undefined>;
+}
+export interface ScheduleCreation<T = Record<string, any>> {
+    /** The period in seconds, for which the function defined will execute recurrently */
+    interval: number;
+    /** The functionName property serves as the unique identifier amongst all Functions */
+    functionName: string;
+    /** The data to be provided to the Function, the type may be user defined */
+    data?: T;
+    /** The priority of the schedule (Higher priorities shall execute first) */
+    priority?: number;
+    /** The timestamp at which the schedule will start executing */
+    startTimestamp?: Date;
+}
+export interface Schedule<T = Record<string, any>> extends ScheduleCreation<T> {
+    id: ObjectId;
+    /** The timestamp at which the schedule will start executing */
+    startTimestamp: Date;
+    /** The timestamp at which the schedule was last updated */
+    updateTimestamp: Date;
+    /** The timestamp at which the schedule was created */
+    creationTimestamp: Date;
+    /** The timestamp at which the schedule will next execute */
+    nextTimestamp: Date;
+}

package/build/services/tasks/tasks.d.ts

@@ -0,0 +1,5 @@
+import type { HttpInstance } from '../../types';
+import { HttpClient } from '../http-client';
+import type { TasksService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => TasksService;
+export default _default;

package/build/services/tasks/types.d.ts

@@ -0,0 +1,118 @@
+import { FindAllIterator } from '../../services/helpers';
+import type { AffectedRecords, ObjectId, OptionsBase, OptionsWithRql, PagedResult } from '../types';
+export * from './api/types';
+export * from './apiRequests/types';
+export * from './functions/types';
+export * from './logs/types';
+export * from './schedules/types';
+export declare enum TaskStatus {
+    NEW = "new",
+    IN_PROGRESS = "inProgress",
+    COMPLETE = "complete",
+    FAILED = "failed",
+    RETRIED = "retried",
+    CANCELED = "canceled"
+}
+export interface Task<DataType = any> {
+    id?: ObjectId;
+    status?: TaskStatus;
+    statusChangedTimestamp?: Date;
+    /**
+     * AWS Lambda function name
+     */
+    functionName: string;
+    /**
+     * Data send to the function
+     */
+    data?: DataType;
+    startTimestamp?: Date;
+    tags?: Array<string>;
+    priority?: number;
+    creationTimestamp?: Date;
+    updateTimestamp?: Date;
+    /** The Extra Horizon document id for the application used to make the request */
+    createdByApplicationId?: ObjectId;
+    /** The Extra Horizon document id for the user who made the request */
+    createdByUserId?: ObjectId;
+    /** Set for tasks in the `retried` status */
+    retriedByTaskId?: ObjectId;
+    /** Set for tasks that are being retried for other tasks */
+    retryForTaskIds?: ObjectId[];
+    /** Set for tasks in the `failed` status */
+    error?: {
+        type: 'runtime' | 'invocation';
+        name?: string;
+        message: string;
+    };
+}
+export declare type TaskInput = Pick<Task, 'functionName' | 'data' | 'startTimestamp' | 'priority' | 'tags'>;
+export interface TasksService {
+    /**
+     * View a list of tasks
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @returns PagedResult<Task>
+     */
+    find(options?: OptionsWithRql): Promise<PagedResult<Task>>;
+    /**
+     * Find By Id
+     * @param id the Id to search for
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findById(id: ObjectId, options?: OptionsWithRql): Promise<Task | undefined>;
+    /**
+     * Request a list of all tasks
+     *
+     * Do not pass in an rql with limit operator!
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns Task[]
+     */
+    findAll(options?: OptionsWithRql): Promise<Task[]>;
+    /**
+     * Request a list of all tasks
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns Task[]
+     */
+    findAllIterator(options?: OptionsWithRql): FindAllIterator<Task>;
+    /**
+     * Find First
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findFirst(options?: OptionsWithRql): Promise<Task | undefined>;
+    /**
+     * Create a task
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `CREATE_TASKS` | `gobal` | **Required** for this endpoint
+     * @param requestBody
+     * @returns Task Success
+     */
+    create(requestBody: TaskInput, options?: OptionsBase): Promise<Task>;
+    /**
+     * Cancel a task
+     *
+     * The targeted task **MUST** be in the `new` status.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `CANCEL_TASKS` | `gobal` | **Required** for this endpoint
+     * @param taskId The id of the targeted task
+     * @returns AffectedRecords
+     * @throws {IllegalStateException}
+     * @throws {ResourceUnknownException}
+     */
+    cancel(taskId: ObjectId, options?: OptionsBase): Promise<AffectedRecords>;
+}

package/build/services/templates/index.d.ts

@@ -0,0 +1,3 @@
+import type { HttpInstance } from '../../types';
+import { TemplatesService } from './types';
+export declare const templatesService: (httpWithAuth: HttpInstance) => TemplatesService;

package/build/services/templates/templates.d.ts

@@ -0,0 +1,5 @@
+import type { HttpInstance } from '../../types';
+import { HttpClient } from '../http-client';
+import type { TemplatesService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => TemplatesService;
+export default _default;