@clairejs/server 3.20.2 → 3.21.1

package/README.md

@@ -1,5 +1,10 @@
 ## Change Log
 
+#### 3.21.1:
+
+-   add log to aws job scheduler & fix cronjob sync
+-   simplify lambda job scheduler, remove job interval that is less than 60s
+
 #### 3.20.2:
 
 -   fix redlock timeout issue

package/dist/job/AwsJobScheduler.d.ts

@@ -1,43 +1,17 @@
 import { AbstractLogger } from "@clairejs/core";
 import { AbstractDbAdapter, ITransaction } from "@clairejs/orm";
 import aws from "aws-sdk";
-import Redis from "ioredis";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { JobInfo, ScheduledJob } from "./interfaces";
 export declare class AwsJobScheduler extends AbstractJobScheduler {
     protected readonly logger: AbstractLogger;
     protected readonly db: AbstractDbAdapter;
-    protected readonly redisClient: Redis;
-    protected readonly uniqueIdKey: string;
+    protected readonly uniqueJobIdFactory: () => string;
     protected readonly apiLambdaFunctionArn: string;
-    protected 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
-     */
-    protected readonly iamRoleArn: string;
     protected readonly eventBusName: string;
     protected readonly jobNamePrefix: string;
-    protected readonly oneMinuteRule: string;
     protected readonly eventbridge: aws.EventBridge;
-    protected readonly stepfunctions: aws.StepFunctions;
-    constructor(logger: AbstractLogger, db: AbstractDbAdapter, redisClient: Redis, 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);
-    handleInterval(interval: number): Promise<void>;
+    constructor(logger: AbstractLogger, db: AbstractDbAdapter, uniqueJobIdFactory: () => string, apiLambdaFunctionArn: string, eventBusName?: string, jobNamePrefix?: string);
     handleCron(jobInfo: ScheduledJob): Promise<void>;
     protected afterJob(_job: ScheduledJob, _tx: ITransaction): Promise<void>;
     private generateCronFromTimestamp;
@@ -46,5 +20,4 @@ export declare class AwsJobScheduler extends AbstractJobScheduler {
     protected scheduleJob(jobInfo: JobInfo): Promise<string>;
     syncJobs(): Promise<void>;
     removeJob(jobId: string): Promise<void>;
-    private checkIntervalScheduler;
 }

package/dist/job/AwsJobScheduler.js

@@ -10,140 +10,25 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { AbstractLogger, Errors, LogContext } from "@clairejs/core";
 import { AbstractDbAdapter } from "@clairejs/orm";
 import aws from "aws-sdk";
-import Redis from "ioredis";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
-import { JobInterval } from "./interfaces";
-const gcdBetween = (a, b) => {
-    const greater = a > b ? a : b;
-    const smaller = a > b ? b : a;
-    if (greater <= 0 || smaller <= 0) {
-        return 1;
-    }
-    else if (greater % smaller === 0) {
-        return smaller;
-    }
-    else {
-        const result = Math.trunc(greater / smaller);
-        return gcdBetween(smaller, greater - smaller * result);
-    }
-};
-const gcdOf = (val, arr) => {
-    if (!arr.length) {
-        return val;
-    }
-    else {
-        return gcdOf(gcdBetween(val, arr[0]), arr.slice(1));
-    }
-};
-const getWaitExpression = (interval) => `Wait ${interval} seconds`;
-const oneMinuteFunctionFactory = (lambdaFunctionARN, intervals) => {
-    //-- find most greatest common divisor of intervals
-    let gcd = JobInterval.EVERY_30S;
-    if (intervals.length) {
-        //-- re-calculate gcd
-        gcd = gcdOf(intervals[0], intervals.slice(1));
-        if (gcd < JobInterval.EVERY_5S) {
-            gcd = JobInterval.EVERY_5S;
-        }
-    }
-    //-- create loop array
-    const itemCount = Math.trunc(60 / gcd);
-    const itemArray = [];
-    for (let i = 0; i < itemCount; i++) {
-        itemArray.push(i * gcd);
-    }
-    const definition = `
-    {
-        "StartAt": "Create items",
-        "States": {
-          "Create items": {
-            "Type": "Pass",
-            "Next": "Loop",
-            "Result": ${JSON.stringify(itemArray)}
-          },
-          "Loop": {
-            "Type": "Map",
-            "End": true,
-            "Iterator": {
-              "StartAt": "${getWaitExpression(gcd)}",
-              "States": {
-                "${getWaitExpression(gcd)}": {
-                  "Type": "Wait",
-                  "Seconds": ${gcd},
-                  "Next": "Convert time to request object"
-                },
-                "Convert time to request object": {
-                  "Type": "Pass",
-                  "Next": "Lambda Invoke",
-                  "Result": {
-                    "requestContext": {
-                      "intervalScheduler": {
-                        "time": "$"
-                      }
-                    }
-                  }
-                },
-                "Lambda Invoke": {
-                  "Type": "Task",
-                  "Resource": "arn:aws:states:::lambda:invoke",
-                  "Parameters": {
-                    "Payload.$": "$",
-                    "FunctionName": "${lambdaFunctionARN}:$LATEST"
-                  },
-                  "End": true,
-                  "OutputPath": "$.Payload"
-                }
-              }
-            },
-            "MaxConcurrency": 1
-          }
-        },
-        "Comment": "One minute loop to trigger lambda function"
-      }
-    `;
-    return [gcd, definition];
-};
 let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     logger;
     db;
-    redisClient;
-    uniqueIdKey;
+    uniqueJobIdFactory;
     apiLambdaFunctionArn;
-    stepFunctionName;
-    iamRoleArn;
     eventBusName;
     jobNamePrefix;
-    oneMinuteRule;
     eventbridge = new aws.EventBridge();
-    stepfunctions = new aws.StepFunctions({ apiVersion: "2016-11-23" });
-    constructor(logger, db, redisClient, uniqueIdKey, apiLambdaFunctionArn, stepFunctionName, 
-    /**
-     * 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, eventBusName = "default", jobNamePrefix = "claire-aws-job-", oneMinuteRule = "one-minute-step-function-trigger") {
+    constructor(logger, db, uniqueJobIdFactory, 
+    //-- ARN of the API lambda function, following EventBrige permissions is required: listRules, putRule, deleteRule, listTargetsByRule, putTargets, removeTargets
+    apiLambdaFunctionArn, eventBusName = "default", jobNamePrefix = "claire-aws-job-") {
         super(logger, db);
         this.logger = logger;
         this.db = db;
-        this.redisClient = redisClient;
-        this.uniqueIdKey = uniqueIdKey;
+        this.uniqueJobIdFactory = uniqueJobIdFactory;
         this.apiLambdaFunctionArn = apiLambdaFunctionArn;
-        this.stepFunctionName = stepFunctionName;
-        this.iamRoleArn = iamRoleArn;
         this.eventBusName = eventBusName;
         this.jobNamePrefix = jobNamePrefix;
-        this.oneMinuteRule = oneMinuteRule;
-    }
-    async handleInterval(interval) {
-        this.logger.debug(`Handle interval`, interval, typeof interval);
-        const allJobs = await this.getAvailableJobInfo();
-        const timedJobs = allJobs.filter((job) => job.interval && interval % job.interval === 0);
-        await Promise.all(timedJobs.map((job) => this.executeJob({ ...job, id: job.jobName })));
     }
     async handleCron(jobInfo) {
         this.logger.debug(`Handle cron`, jobInfo);
@@ -168,7 +53,6 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         return false;
     }
     async getAllScheduledJobs() {
-        const availableJobs = await this.getAvailableJobInfo();
         const allRules = await this.eventbridge
             .listRules({
             EventBusName: this.eventBusName,
@@ -191,15 +75,12 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
             return jobInfo;
         }));
         //-- concat with interval jobs because we don't register them
-        return allJobs
-            .filter((job) => !!job)
-            .concat(availableJobs.filter((j) => j.interval).map((j) => ({ ...j, id: j.jobName })));
+        return allJobs.filter((job) => !!job);
     }
     async scheduleJob(jobInfo) {
         this.logger.debug("Scheduling job: ", jobInfo);
         if (jobInfo.cron || jobInfo.at) {
-            const uniqueId = await this.redisClient.incr(this.uniqueIdKey);
-            const jobId = `${this.jobNamePrefix}${uniqueId}`;
+            const jobId = `${this.jobNamePrefix}${this.uniqueJobIdFactory()}`;
             //-- generate pattern from cron (add * at the end for year) / at timestamp
             const cronExpression = jobInfo.cron ? `${jobInfo.cron} *` : this.generateCronFromTimestamp(jobInfo.at);
             this.logger.debug("Cron expression", cronExpression);
@@ -234,23 +115,20 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
                 .promise();
             return jobId;
         }
-        else if (jobInfo.interval) {
-            //-- interval job does not need to persist, the step function will take care of it
-            return jobInfo.jobName;
-        }
         else {
             throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
         }
     }
     async syncJobs() {
-        //-- check and init step function: step function must trigger lambda every 5s
-        this.logger.debug("Checking interval scheduler");
-        await this.checkIntervalScheduler();
         //-- check jobs
+        console.log("syncJobs started");
         const scheduledJobs = await this.getAllScheduledJobs();
+        console.log("scheduledJobs", scheduledJobs);
         const allJobs = await this.getAvailableJobInfo();
+        console.log("allJobs", allJobs);
         //-- remove job that no more exist
         const nomoreExistJobs = scheduledJobs.filter((job) => !allJobs.find((j) => j.jobName === job.jobName));
+        console.log("nomoreExistJobs", nomoreExistJobs);
         for (const job of nomoreExistJobs) {
             this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.id}`);
             await this.removeJob(job.id);
@@ -258,21 +136,26 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         if (nomoreExistJobs.length) {
             this.logger.info(`Cleaned up: ${nomoreExistJobs.length} stale jobs`);
         }
-        //-- remove scheduled cron jobs
+        //-- remove scheduled cron jobs that diff the cron expression
         this.logger.debug("Remove scheduled cron jobs");
         const scheduledCronJobs = scheduledJobs.filter((j) => j.cron);
-        await Promise.all(scheduledCronJobs.map((j) => this.removeJob(j.id)));
-        //-- reschedule cron & interval jobs because we might have updated the cron expression / interval value
-        const cronJobs = allJobs.filter((job) => job.cron || job.interval);
-        this.logger.debug("Scheduling cron & interval jobs");
-        for (const job of cronJobs) {
-            await this.scheduleJob({
-                jobName: job.jobName,
-                cron: job.cron,
-                interval: job.interval,
-            });
+        const unmatchedCronJobs = scheduledCronJobs.filter((j) => j.cron && !allJobs.find((job) => job.jobName === j.jobName && job.cron === j.cron));
+        if (unmatchedCronJobs.length) {
+            await Promise.all(unmatchedCronJobs.map((j) => this.removeJob(j.id)));
+            //-- reschedule new cron jobs and those which are not synced
+            const resyncCronJobs = allJobs.filter((job) => job.cron &&
+                (unmatchedCronJobs.some((j) => j.jobName === job.jobName) ||
+                    !scheduledCronJobs.some((j) => j.jobName === job.jobName)));
+            this.logger.debug("Reschedule cron jobs", resyncCronJobs);
+            for (const job of resyncCronJobs) {
+                await this.scheduleJob({
+                    jobName: job.jobName,
+                    cron: job.cron,
+                });
+            }
         }
         //-- keep "at" jobs as is
+        console.log("syncJobs finished");
     }
     async removeJob(jobId) {
         await this.eventbridge
@@ -289,125 +172,10 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         })
             .promise();
     }
-    async checkIntervalScheduler() {
-        //-- check and create the step function
-        const allJobs = await this.getAvailableJobInfo();
-        const intervalJobs = allJobs.filter((j) => j.interval);
-        const allIntervals = intervalJobs.map((j) => j.interval);
-        const [interval, oneMinuteFunctionDefinition] = oneMinuteFunctionFactory(this.apiLambdaFunctionArn, allIntervals);
-        this.logger.debug("Listing all state machines");
-        const allMachines = await this.stepfunctions.listStateMachines({}).promise();
-        let oldStateMachineArn = allMachines.stateMachines.find((s) => s.name.includes(this.stepFunctionName))?.stateMachineArn;
-        let newStateMachineArn = oldStateMachineArn;
-        if (oldStateMachineArn) {
-            //-- check definition, if different then clear newStateMachineArn to create new one
-            const describeResult = await this.stepfunctions
-                .describeStateMachine({
-                stateMachineArn: oldStateMachineArn,
-            })
-                .promise();
-            //-- check the interval
-            if (!describeResult.definition.includes(getWaitExpression(interval))) {
-                this.logger.debug("Step function definition changed, create new state machine");
-                newStateMachineArn = "";
-            }
-        }
-        const awsStateMachineName = `${this.stepFunctionName}-${interval}`;
-        if (!newStateMachineArn) {
-            this.logger.debug(`Create new step function with interval ${interval} seconds`);
-            const result = await this.stepfunctions
-                .createStateMachine({
-                definition: oneMinuteFunctionDefinition,
-                name: awsStateMachineName,
-                roleArn: this.iamRoleArn,
-                type: "EXPRESS",
-            })
-                .promise();
-            newStateMachineArn = result.stateMachineArn;
-        }
-        this.logger.debug("Step function ARNs old / new", oldStateMachineArn, newStateMachineArn);
-        //-- check and create the one-minute-rule that trigger step function
-        this.logger.debug("Getting one minute rule");
-        const matchedRules = await this.eventbridge
-            .listRules({
-            EventBusName: this.eventBusName,
-            NamePrefix: this.oneMinuteRule,
-        })
-            .promise();
-        const oneMinuteRule = matchedRules.Rules?.find((r) => r.Name == this.oneMinuteRule);
-        if (!oneMinuteRule) {
-            this.logger.debug("Create new one minute rule");
-            //-- one minute rule does not exist, create new
-            await this.eventbridge
-                .putRule({
-                EventBusName: this.eventBusName,
-                Name: this.oneMinuteRule,
-                Description: "One minute trigger function for step function",
-                ScheduleExpression: "rate(1 minute)",
-                State: "ENABLED",
-            })
-                .promise();
-        }
-        this.logger.debug("Adding step function state machine as target");
-        if (newStateMachineArn !== oldStateMachineArn) {
-            //-- if there is old target then remove it
-            if (oldStateMachineArn) {
-                this.logger.debug("Removing old target", oldStateMachineArn);
-                //-- remove old target
-                await this.eventbridge
-                    .removeTargets({
-                    EventBusName: this.eventBusName,
-                    Rule: this.oneMinuteRule,
-                    Ids: [this.stepFunctionName],
-                })
-                    .promise();
-                this.logger.debug("Removing old state machine function");
-                await this.stepfunctions
-                    .deleteStateMachine({
-                    stateMachineArn: oldStateMachineArn,
-                })
-                    .promise();
-            }
-            //-- add the step function as call target
-            this.logger.debug("Adding new target", newStateMachineArn);
-            await this.eventbridge
-                .putTargets({
-                Rule: this.oneMinuteRule,
-                Targets: [
-                    {
-                        Arn: newStateMachineArn,
-                        Id: this.stepFunctionName,
-                        RoleArn: this.iamRoleArn,
-                    },
-                ],
-            })
-                .promise();
-        }
-        //-- if we don't have any interval job then disable the one minuter
-        if (!intervalJobs.length && oneMinuteRule?.State) {
-            this.logger.info("No interval job found, disable one minute rule");
-            await this.eventbridge
-                .disableRule({
-                EventBusName: this.eventBusName,
-                Name: this.oneMinuteRule,
-            })
-                .promise();
-        }
-        else {
-            this.logger.info("Interval job found, enable one minute rule");
-            await this.eventbridge
-                .enableRule({
-                EventBusName: this.eventBusName,
-                Name: this.oneMinuteRule,
-            })
-                .promise();
-        }
-    }
 };
 AwsJobScheduler = __decorate([
     LogContext(),
     __metadata("design:paramtypes", [AbstractLogger,
-        AbstractDbAdapter,
-        Redis, String, String, String, String, Object, Object, Object])
+        AbstractDbAdapter, Function, String, Object, Object])
 ], AwsJobScheduler);
 export { AwsJobScheduler };

package/dist/job/LocalJobScheduler.js

@@ -175,7 +175,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             //-- schedule all cron & interval jobs
             const allJobs = await this.getAvailableJobInfo();
             for (const job of allJobs) {
-                if (job.cron || job.interval) {
+                if (job.cron) {
                     await this.scheduleJob(job);
                 }
             }
@@ -214,16 +214,6 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                 this.jobHolder[id] = { jobCanceler: () => clearTimeout(timeout), jobInfo: { ...jobInfo, id } };
                 return id;
             }
-            else if (jobInfo.interval) {
-                const id = jobInfo.jobName;
-                //-- set interval and does not need to persist
-                const scheduledJob = { ...jobInfo, id };
-                const interval = setInterval(() => {
-                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
-                }, jobInfo.interval);
-                this.jobHolder[id] = { jobCanceler: () => clearInterval(interval), jobInfo: { ...jobInfo, id } };
-                return id;
-            }
             else if (jobInfo.cron) {
                 const id = jobInfo.jobName;
                 //-- set cron and does not need to persist

package/dist/job/decorators.d.ts

@@ -1,5 +1,3 @@
 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/decorators.js

@@ -1,23 +1,4 @@
 import { Errors, initObjectMetadata } from "@clairejs/core";
-export const IntervalJob = (
-/**
- * Unique name of job
- */
-jobName, 
-/**
- * Interval duration in second
- */
-interval) => (prototype, propertyKey) => {
-    const metadata = initObjectMetadata(prototype);
-    if (!metadata.jobs) {
-        metadata.jobs = [];
-    }
-    metadata.jobs.push({
-        jobName,
-        interval,
-        handlerName: propertyKey,
-    });
-};
 export const CronJob = (
 /**
  * Unique name of job

package/dist/job/interfaces.d.ts

@@ -1,22 +1,10 @@
 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
      */
@@ -44,7 +32,6 @@ export interface JobInfo {
     jobName: string;
     params?: any;
     at?: number;
-    interval?: JobInterval;
     cron?: string;
 }
 export interface ScheduledJob extends JobInfo {

package/dist/job/interfaces.js

@@ -1,10 +1 @@
-export const INTERVAL_REQUEST_METHOD = "interval";
 export const CRON_REQUEST_METHOD = "cron";
-export var JobInterval;
-(function (JobInterval) {
-    JobInterval[JobInterval["EVERY_5S"] = 5] = "EVERY_5S";
-    JobInterval[JobInterval["EVERY_10S"] = 10] = "EVERY_10S";
-    JobInterval[JobInterval["EVERY_15S"] = 15] = "EVERY_15S";
-    JobInterval[JobInterval["EVERY_20S"] = 20] = "EVERY_20S";
-    JobInterval[JobInterval["EVERY_30S"] = 30] = "EVERY_30S";
-})(JobInterval || (JobInterval = {}));

package/dist/system/LambdaWrapper.js

@@ -1,7 +1,7 @@
 import { getServiceProvider, HttpMethod, SocketMethod, Errors } from "@clairejs/core";
 import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
 import { AwsJobScheduler } from "../job/AwsJobScheduler";
-import { CRON_REQUEST_METHOD, INTERVAL_REQUEST_METHOD } from "../job/interfaces";
+import { CRON_REQUEST_METHOD } from "../job/interfaces";
 import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
 const convertCorsToHeaders = (origin, cors) => {
     const headers = {};
@@ -99,10 +99,6 @@ export class LambdaWrapper {
         if (requestOptions.method === HttpMethod.OPTIONS) {
             return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
         }
-        if (requestOptions.method === INTERVAL_REQUEST_METHOD) {
-            await this.jobScheduler?.handleInterval(requestOptions.body);
-            return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
-        }
         if (requestOptions.method === CRON_REQUEST_METHOD) {
             await this.jobScheduler?.handleCron(requestOptions.body);
             return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });

package/dist/system/lamba-request-mapper.js

@@ -1,5 +1,5 @@
 import { SocketMethod } from "@clairejs/core";
-import { CRON_REQUEST_METHOD, INTERVAL_REQUEST_METHOD } from "../job/interfaces";
+import { CRON_REQUEST_METHOD } from "../job/interfaces";
 const parseCookie = (cookieArray) => {
     let result = {};
     for (const cookie of cookieArray) {
@@ -21,14 +21,6 @@ export const lambdaRequestMapper = (event) => {
             body: method === SocketMethod.CONNECT ? { queries: event.queryStringParameters } : body,
         };
     }
-    if (event.requestContext.intervalScheduler) {
-        //-- interval scheduler
-        return {
-            method: INTERVAL_REQUEST_METHOD,
-            rawPath: "",
-            body: event.requestContext.intervalScheduler.time,
-        };
-    }
     if (event.requestContext.cronScheduler) {
         //-- cron scheduler
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.20.2",
+    "version": "3.21.1",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -34,7 +34,7 @@
         "ws": "^7.5.5"
     },
     "peerDependencies": {
-        "@clairejs/core": "^3.8.4",
+        "@clairejs/core": "^3.8.7",
         "@clairejs/orm": "^3.16.0"
     },
     "devDependencies": {