@clairejs/server 3.12.13 → 3.13.1

package/dist/job/AbstractJobController.d.ts

@@ -1,5 +1,5 @@
-import { Transactionable } from "../common/Transactionable";
-import { JobInfoMetadata } from "./interfaces";
-export declare abstract class AbstractJobController extends Transactionable {
-    getAllJobs(): JobInfoMetadata[];
-}
+import { Transactionable } from "../common/Transactionable";
+import { JobInfoMetadata } from "./interfaces";
+export declare abstract class AbstractJobController extends Transactionable {
+    getAllJobs(): JobInfoMetadata[];
+}

package/dist/job/AbstractJobRepository.d.ts

@@ -1,17 +1,17 @@
-import { CustomJobInfo } from "./interfaces";
-export declare abstract class AbstractJobRepository {
-    /**
-     * Return all persisted jobs
-     */
-    abstract getJobs(): Promise<CustomJobInfo[]>;
-    /**
-     * Save the job info and return a unique id
-     * @param jobInfo The custom job info to save
-     */
-    abstract saveJob(jobInfo: CustomJobInfo): Promise<string>;
-    /**
-     * Remove job info by id
-     * @param jobId Unique id of job
-     */
-    abstract removeJobById(jobId: string): Promise<void>;
-}
+import { CustomJobInfo } from "./interfaces";
+export declare abstract class AbstractJobRepository {
+    /**
+     * Return all persisted jobs
+     */
+    abstract getJobs(): Promise<CustomJobInfo[]>;
+    /**
+     * Save the job info and return a unique id
+     * @param jobInfo The custom job info to save
+     */
+    abstract saveJob(jobInfo: CustomJobInfo): Promise<string>;
+    /**
+     * Remove job info by id
+     * @param jobId Unique id of job
+     */
+    abstract removeJobById(jobId: string): Promise<void>;
+}

package/dist/job/AbstractJobScheduler.d.ts

@@ -1,38 +1,38 @@
-import { AbstractLogger } from "@clairejs/core";
-import { CustomJobInfo, JobInfo, JobInfoMetadata, ScheduledJob } from "./interfaces";
-interface JobHandlerMetadata extends JobInfoMetadata {
-    handlerFn: (params?: any[]) => Promise<void>;
-}
-export declare abstract class AbstractJobScheduler {
-    readonly logger: AbstractLogger;
-    protected abstract isActiveScheduler(): boolean;
-    private _jobs;
-    constructor(logger: AbstractLogger);
-    protected getAvailableJobInfo(): Promise<JobHandlerMetadata[]>;
-    abstract getAllScheduledJobs(): Promise<ScheduledJob[]>;
-    /**
-     * Return unique job id which can then be used to cancel the job
-     * @param jobInfo the necessary info to launch the job
-     */
-    protected abstract scheduleJob(jobInfo: JobInfo): Promise<string>;
-    /**
-     * Sync all jobs to running state. This should be called only at init time.
-     */
-    abstract syncJobs(): Promise<void>;
-    /**
-     * Return unique job id which can then be used to cancel the job
-     * @param jobInfo the necessary info to launch the job
-     */
-    scheduleJobAt(jobInfo: CustomJobInfo): Promise<string>;
-    /**
-     * Remove the scheduled job and prevent if from running in the future
-     * @param jobId The job id returned from scheduleJobAt function
-     */
-    abstract removeJob(jobId: string): Promise<void>;
-    /**
-     * Execute the scheduled job
-     * @param job The schedled job info to execute
-     */
-    protected executeJob(job: ScheduledJob): Promise<void>;
-}
-export {};
+import { AbstractLogger } from "@clairejs/core";
+import { CustomJobInfo, JobInfo, JobInfoMetadata, ScheduledJob } from "./interfaces";
+interface JobHandlerMetadata extends JobInfoMetadata {
+    handlerFn: (params?: any[]) => Promise<void>;
+}
+export declare abstract class AbstractJobScheduler {
+    readonly logger: AbstractLogger;
+    protected abstract isActiveScheduler(): boolean;
+    private _jobs;
+    constructor(logger: AbstractLogger);
+    protected getAvailableJobInfo(): Promise<JobHandlerMetadata[]>;
+    abstract getAllScheduledJobs(): Promise<ScheduledJob[]>;
+    /**
+     * Return unique job id which can then be used to cancel the job
+     * @param jobInfo the necessary info to launch the job
+     */
+    protected abstract scheduleJob(jobInfo: JobInfo): Promise<string>;
+    /**
+     * Sync all jobs to running state. This should be called only at init time.
+     */
+    abstract syncJobs(): Promise<void>;
+    /**
+     * Return unique job id which can then be used to cancel the job
+     * @param jobInfo the necessary info to launch the job
+     */
+    scheduleJobAt(jobInfo: CustomJobInfo): Promise<string>;
+    /**
+     * Remove the scheduled job and prevent if from running in the future
+     * @param jobId The job id returned from scheduleJobAt function
+     */
+    abstract removeJob(jobId: string): Promise<void>;
+    /**
+     * Execute the scheduled job
+     * @param job The schedled job info to execute
+     */
+    protected executeJob(job: ScheduledJob): Promise<void>;
+}
+export {};

package/dist/job/AwsJobScheduler.d.ts

@@ -1,48 +1,48 @@
-import { AbstractLogger, IInit } from "@clairejs/core";
-import { AbstractJobScheduler } from "./AbstractJobScheduler";
-import { JobInfo, ScheduledJob } from "./interfaces";
-export declare class AwsJobScheduler extends AbstractJobScheduler implements IInit {
-    readonly logger: AbstractLogger;
-    readonly redisServerUrl: string;
-    readonly uniqueIdKey: string;
-    readonly apiLambdaFunctionArn: string;
-    readonly stepFunctionName: string;
-    /**
-     * This IAM role must have following permissions:
-     * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
-     * - trigger lambda function specified in apiLambdaFunctionArn (so state machine can trigger API)
-     *
-     * In addition, the role which this API server assumes must have following permissions:
-     * - create event bridge rules, describe rules, remove rule, list and create rule targets
-     * - create state machines, list state machines
-     */
-    readonly iamRoleArn: string;
-    readonly eventBusName: string;
-    readonly jobNamePrefix: string;
-    readonly oneMinuteRule: string;
-    private eventbridge;
-    private stepfunctions;
-    private redisClient;
-    constructor(logger: AbstractLogger, redisServerUrl: string, uniqueIdKey: string, apiLambdaFunctionArn: string, stepFunctionName: string, 
-    /**
-     * This IAM role must have following permissions:
-     * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
-     * - trigger lambda function specified in apiLambdaFunctionArn (so state machine can trigger API)
-     *
-     * In addition, the role which this API server assumes must have following permissions:
-     * - create event bridge rules, describe rules, remove rule, list and create rule targets
-     * - create state machines, list state machines
-     */
-    iamRoleArn: string, eventBusName?: string, jobNamePrefix?: string, oneMinuteRule?: string);
-    init(): Promise<void>;
-    exit(): void;
-    handleInterval(interval: number): Promise<void>;
-    handleCron(jobInfo: ScheduledJob): Promise<void>;
-    private generateCronFromTimestamp;
-    protected isActiveScheduler(): boolean;
-    getAllScheduledJobs(): Promise<ScheduledJob[]>;
-    protected scheduleJob(jobInfo: JobInfo): Promise<string>;
-    syncJobs(): Promise<void>;
-    removeJob(jobId: string): Promise<void>;
-    private checkIntervalScheduler;
-}
+import { AbstractLogger, IInit } from "@clairejs/core";
+import { AbstractJobScheduler } from "./AbstractJobScheduler";
+import { JobInfo, ScheduledJob } from "./interfaces";
+export declare class AwsJobScheduler extends AbstractJobScheduler implements IInit {
+    readonly logger: AbstractLogger;
+    readonly redisServerUrl: string;
+    readonly uniqueIdKey: string;
+    readonly apiLambdaFunctionArn: string;
+    readonly stepFunctionName: string;
+    /**
+     * This IAM role must have following permissions:
+     * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
+     * - trigger lambda function specified in apiLambdaFunctionArn (so state machine can trigger API)
+     *
+     * In addition, the role which this API server assumes must have following permissions:
+     * - create event bridge rules, describe rules, remove rule, list and create rule targets
+     * - create state machines, list state machines
+     */
+    readonly iamRoleArn: string;
+    readonly eventBusName: string;
+    readonly jobNamePrefix: string;
+    readonly oneMinuteRule: string;
+    private eventbridge;
+    private stepfunctions;
+    private redisClient;
+    constructor(logger: AbstractLogger, redisServerUrl: string, uniqueIdKey: string, apiLambdaFunctionArn: string, stepFunctionName: string, 
+    /**
+     * This IAM role must have following permissions:
+     * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
+     * - trigger lambda function specified in apiLambdaFunctionArn (so state machine can trigger API)
+     *
+     * In addition, the role which this API server assumes must have following permissions:
+     * - create event bridge rules, describe rules, remove rule, list and create rule targets
+     * - create state machines, list state machines
+     */
+    iamRoleArn: string, eventBusName?: string, jobNamePrefix?: string, oneMinuteRule?: string);
+    init(): Promise<void>;
+    exit(): void;
+    handleInterval(interval: number): Promise<void>;
+    handleCron(jobInfo: ScheduledJob): Promise<void>;
+    private generateCronFromTimestamp;
+    protected isActiveScheduler(): boolean;
+    getAllScheduledJobs(): Promise<ScheduledJob[]>;
+    protected scheduleJob(jobInfo: JobInfo): Promise<string>;
+    syncJobs(): Promise<void>;
+    removeJob(jobId: string): Promise<void>;
+    private checkIntervalScheduler;
+}

package/dist/job/LocalJobScheduler.d.ts

@@ -1,88 +1,88 @@
-import { AbstractLogger, IInit } from "@clairejs/core";
-import { AbstractJobScheduler } from "./AbstractJobScheduler";
-import { JobInfo, ScheduledJob } from "./interfaces";
-import { AbstractJobRepository } from "./AbstractJobRepository";
-export declare class LocalJobScheduler extends AbstractJobScheduler implements IInit {
-    /**
-     * Logger
-     */
-    readonly logger: AbstractLogger;
-    /**
-     * The job repository
-     */
-    readonly jobRepo: AbstractJobRepository;
-    /**
-     * Redis server connection string
-     */
-    readonly redisServerUrl: string;
-    /**
-     * Redus lock key to select active scheduler
-     */
-    readonly lockMutexKey: string;
-    /**
-     * Redis key to hold active scheduler role
-     */
-    readonly holdMutexKey: string;
-    /**
-     * Redis key to get unique incremental id
-     */
-    readonly uniqueIdKey: string;
-    /**
-     * The channel for communication between passive and active schedulers
-     */
-    readonly multiClientChannel: string;
-    /**
-     * The time to lock active scheduler
-     */
-    readonly keyRetentionDurationSecond: number;
-    protected intervals: any[];
-    private mutexHoldInterval?;
-    private redisClient;
-    private subscribeClient;
-    private isActive;
-    private notifyResolver;
-    private jobHolder;
-    constructor(
-    /**
-     * Logger
-     */
-    logger: AbstractLogger, 
-    /**
-     * The job repository
-     */
-    jobRepo: AbstractJobRepository, 
-    /**
-     * Redis server connection string
-     */
-    redisServerUrl: string, 
-    /**
-     * Redus lock key to select active scheduler
-     */
-    lockMutexKey: string, 
-    /**
-     * Redis key to hold active scheduler role
-     */
-    holdMutexKey: string, 
-    /**
-     * Redis key to get unique incremental id
-     */
-    uniqueIdKey: string, 
-    /**
-     * The channel for communication between passive and active schedulers
-     */
-    multiClientChannel: string, 
-    /**
-     * The time to lock active scheduler
-     */
-    keyRetentionDurationSecond?: number);
-    private sendJob;
-    private processMessage;
-    private extendMutexKey;
-    init(): Promise<void>;
-    exit(): void;
-    protected isActiveScheduler(): boolean;
-    getAllScheduledJobs(): Promise<ScheduledJob[]>;
-    syncJobs(): Promise<void>;
-    protected scheduleJob(jobInfo: JobInfo): Promise<string>;
-    removeJob(jobId: string): Promise<void>;
-}
+import { AbstractLogger, IInit } from "@clairejs/core";
+import { AbstractJobScheduler } from "./AbstractJobScheduler";
+import { JobInfo, ScheduledJob } from "./interfaces";
+import { AbstractJobRepository } from "./AbstractJobRepository";
+export declare class LocalJobScheduler extends AbstractJobScheduler implements IInit {
+    /**
+     * Logger
+     */
+    readonly logger: AbstractLogger;
+    /**
+     * The job repository
+     */
+    readonly jobRepo: AbstractJobRepository;
+    /**
+     * Redis server connection string
+     */
+    readonly redisServerUrl: string;
+    /**
+     * Redus lock key to select active scheduler
+     */
+    readonly lockMutexKey: string;
+    /**
+     * Redis key to hold active scheduler role
+     */
+    readonly holdMutexKey: string;
+    /**
+     * Redis key to get unique incremental id
+     */
+    readonly uniqueIdKey: string;
+    /**
+     * The channel for communication between passive and active schedulers
+     */
+    readonly multiClientChannel: string;
+    /**
+     * The time to lock active scheduler
+     */
+    readonly keyRetentionDurationSecond: number;
+    protected intervals: any[];
+    private mutexHoldInterval?;
+    private redisClient;
+    private subscribeClient;
+    private isActive;
+    private notifyResolver;
+    private jobHolder;
+    constructor(
+    /**
+     * Logger
+     */
+    logger: AbstractLogger, 
+    /**
+     * The job repository
+     */
+    jobRepo: AbstractJobRepository, 
+    /**
+     * Redis server connection string
+     */
+    redisServerUrl: string, 
+    /**
+     * Redus lock key to select active scheduler
+     */
+    lockMutexKey: string, 
+    /**
+     * Redis key to hold active scheduler role
+     */
+    holdMutexKey: string, 
+    /**
+     * Redis key to get unique incremental id
+     */
+    uniqueIdKey: string, 
+    /**
+     * The channel for communication between passive and active schedulers
+     */
+    multiClientChannel: string, 
+    /**
+     * The time to lock active scheduler
+     */
+    keyRetentionDurationSecond?: number);
+    private sendJob;
+    private processMessage;
+    private extendMutexKey;
+    init(): Promise<void>;
+    exit(): void;
+    protected isActiveScheduler(): boolean;
+    getAllScheduledJobs(): Promise<ScheduledJob[]>;
+    syncJobs(): Promise<void>;
+    protected scheduleJob(jobInfo: JobInfo): Promise<string>;
+    removeJob(jobId: string): Promise<void>;
+}

package/dist/job/decorators.d.ts

@@ -1,5 +1,5 @@
-import { AbstractJobController } from "./AbstractJobController";
-import { JobInterval } from "./interfaces";
-export declare const IntervalJob: (jobName: string, interval: JobInterval) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;
-export declare const CronJob: (jobName: string, cron: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;
-export declare const CustomJob: (jobName: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;
+import { AbstractJobController } from "./AbstractJobController";
+import { JobInterval } from "./interfaces";
+export declare const IntervalJob: (jobName: string, interval: JobInterval) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;
+export declare const CronJob: (jobName: string, cron: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;
+export declare const CustomJob: (jobName: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T) => void;

package/dist/job/interfaces.d.ts

@@ -1,50 +1,50 @@
-import { ObjectMetadata } from "@clairejs/core";
-export declare const INTERVAL_REQUEST_METHOD = "interval";
-export declare const CRON_REQUEST_METHOD = "cron";
-export declare enum JobInterval {
-    EVERY_5S = 5,
-    EVERY_10S = 10,
-    EVERY_15S = 15,
-    EVERY_20S = 20,
-    EVERY_30S = 30
-}
-export interface JobInfoMetadata {
-    /**
-     * Unique name of job
-     */
-    jobName: string;
-    /**
-     * Interval in seconds
-     */
-    interval?: JobInterval;
-    /**
-     * Run with cron expression, does not support seconds precision
-     */
-    cron?: string;
-    /**
-     * Run at specific timestamp, does not support seconds precision
-     */
-    at?: number;
-    /**
-     * Name of the function handle
-     */
-    handlerName: string;
-}
-export interface JobControllerMetadata extends ObjectMetadata {
-    jobs?: JobInfoMetadata[];
-}
-export interface CustomJobInfo {
-    jobName: string;
-    at: number;
-    params?: any[];
-}
-export interface JobInfo {
-    jobName: string;
-    params?: any[];
-    at?: number;
-    interval?: JobInterval;
-    cron?: string;
-}
-export interface ScheduledJob extends JobInfo {
-    jobId: string;
-}
+import { ObjectMetadata } from "@clairejs/core";
+export declare const INTERVAL_REQUEST_METHOD = "interval";
+export declare const CRON_REQUEST_METHOD = "cron";
+export declare enum JobInterval {
+    EVERY_5S = 5,
+    EVERY_10S = 10,
+    EVERY_15S = 15,
+    EVERY_20S = 20,
+    EVERY_30S = 30
+}
+export interface JobInfoMetadata {
+    /**
+     * Unique name of job
+     */
+    jobName: string;
+    /**
+     * Interval in seconds
+     */
+    interval?: JobInterval;
+    /**
+     * Run with cron expression, does not support seconds precision
+     */
+    cron?: string;
+    /**
+     * Run at specific timestamp, does not support seconds precision
+     */
+    at?: number;
+    /**
+     * Name of the function handle
+     */
+    handlerName: string;
+}
+export interface JobControllerMetadata extends ObjectMetadata {
+    jobs?: JobInfoMetadata[];
+}
+export interface CustomJobInfo {
+    jobName: string;
+    at: number;
+    params?: any[];
+}
+export interface JobInfo {
+    jobName: string;
+    params?: any[];
+    at?: number;
+    interval?: JobInterval;
+    cron?: string;
+}
+export interface ScheduledJob extends JobInfo {
+    jobId: string;
+}

package/dist/logging/FileLogMedium.d.ts

@@ -1,13 +1,13 @@
-import { LogLevel, ILogMedium } from "@clairejs/core";
-export declare class FileLogMedium implements ILogMedium {
-    private static readonly levels;
-    private readonly destination;
-    private readonly separated;
-    constructor(config: {
-        destination: string;
-        separated?: boolean;
-    });
-    init(): Promise<void>;
-    exit(): void;
-    write(level: LogLevel, content: string): void;
-}
+import { LogLevel, ILogMedium } from "@clairejs/core";
+export declare class FileLogMedium implements ILogMedium {
+    private static readonly levels;
+    private readonly destination;
+    private readonly separated;
+    constructor(config: {
+        destination: string;
+        separated?: boolean;
+    });
+    init(): Promise<void>;
+    exit(): void;
+    write(level: LogLevel, content: string): void;
+}

package/dist/services/AbstractCacheService.d.ts

@@ -1,22 +1,22 @@
-export interface MutexLock {
-    unlock(): Promise<void>;
-}
-export interface ICacheTransaction {
-    hset(hash: string, key: string, value: any): void;
-    set(key: string, value: any): void;
-    del(key: string): void;
-    hdel(hash: string, key: string): void;
-    exec(): Promise<any[]>;
-}
-export declare abstract class AbstractCacheService {
-    abstract hget<T>(hash: string, key: string): Promise<T | undefined>;
-    abstract hset<T>(hash: string, key: string, value: T): Promise<void>;
-    abstract hkeys(hash: string): Promise<string[]>;
-    abstract get<T>(key: string): Promise<T | undefined>;
-    abstract set<T>(key: string, value: T, expiredSeconds?: number): Promise<void>;
-    abstract del(key: string): Promise<void>;
-    abstract hdel(hash: string, key: string): Promise<void>;
-    abstract flush(): Promise<void>;
-    abstract lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
-    abstract createTransaction(): ICacheTransaction;
-}
+export interface MutexLock {
+    unlock(): Promise<void>;
+}
+export interface ICacheTransaction {
+    hset(hash: string, key: string, value: any): void;
+    set(key: string, value: any): void;
+    del(key: string): void;
+    hdel(hash: string, key: string): void;
+    exec(): Promise<any[]>;
+}
+export declare abstract class AbstractCacheService {
+    abstract hget<T>(hash: string, key: string): Promise<T | undefined>;
+    abstract hset<T>(hash: string, key: string, value: T): Promise<void>;
+    abstract hkeys(hash: string): Promise<string[]>;
+    abstract get<T>(key: string): Promise<T | undefined>;
+    abstract set<T>(key: string, value: T, expiredSeconds?: number): Promise<void>;
+    abstract del(key: string): Promise<void>;
+    abstract hdel(hash: string, key: string): Promise<void>;
+    abstract flush(): Promise<void>;
+    abstract lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
+    abstract createTransaction(): ICacheTransaction;
+}

package/dist/services/AbstractFileService.d.ts

@@ -1,15 +1,15 @@
-import { FileOperation } from "../common/FileOperation";
-export declare abstract class AbstractFileService {
-    abstract getFileSize(objectKeys: string[]): Promise<number[]>;
-    abstract getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
-    abstract getPresignedUrl(operation: FileOperation, uris: string[]): Promise<string[]>;
-    abstract moveObject(uris: {
-        fromURI: string;
-        toURI: string;
-    }[]): Promise<void>;
-    abstract copyObject(uris: {
-        fromURI: string;
-        toURI: string;
-    }[]): Promise<void>;
-    abstract removeObject(uris: string[]): Promise<void>;
-}
+import { FileOperation } from "../common/FileOperation";
+export declare abstract class AbstractFileService {
+    abstract getFileSize(objectKeys: string[]): Promise<number[]>;
+    abstract getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
+    abstract getPresignedUrl(operation: FileOperation, uris: string[]): Promise<string[]>;
+    abstract moveObject(uris: {
+        fromURI: string;
+        toURI: string;
+    }[]): Promise<void>;
+    abstract copyObject(uris: {
+        fromURI: string;
+        toURI: string;
+    }[]): Promise<void>;
+    abstract removeObject(uris: string[]): Promise<void>;
+}