Samet Digital : Scheduler Client [Client]

 ▗▄▄▖ ▗▄▄▖▗▖ ▗▖▗▄▄▄▖▗▄▄▄ ▗▖ ▗▖▗▖   ▗▄▄▄▖▗▄▄▖      ▗▄▄▖▗▖   ▗▄▄▄▖▗▄▄▄▖▗▖  ▗▖▗▄▄▄▖
▐▌   ▐▌   ▐▌ ▐▌▐▌   ▐▌  █▐▌ ▐▌▐▌   ▐▌   ▐▌ ▐▌    ▐▌   ▐▌     █  ▐▌   ▐▛▚▖▐▌  █  
 ▝▀▚▖▐▌   ▐▛▀▜▌▐▛▀▀▘▐▌  █▐▌ ▐▌▐▌   ▐▛▀▀▘▐▛▀▚▖    ▐▌   ▐▌     █  ▐▛▀▀▘▐▌ ▝▜▌  █  
▗▄▄▞▘▝▚▄▄▖▐▌ ▐▌▐▙▄▄▖▐▙▄▄▀▝▚▄▞▘▐▙▄▄▖▐▙▄▄▖▐▌ ▐▌    ▝▚▄▄▖▐▙▄▄▖▗▄█▄▖▐▙▄▄▖▐▌  ▐▌  █  

• EN: todo
• TR: todo

Usage

• EN: How to add into your project?
• TR: Projene nasıl eklersin?

npm i @samet-digital/scheduler-client

import {SchedulerBase} from "@samet-digital/scheduler-client";
import {Injectable, Logger} from "@nestjs/common";

/**
 * Your full data structure
 * */
interface FullLike {
    success?: number;
    failed?: number;
    partial?: number;
    ignored?: number;
}

/**
 * Your semi data structure (possibly latest context data)
 * */
interface SemiLike {
    processId: number;
}

/**
 * Your state structure (possibly latest context data)
 * */
interface StateLike {
    processId: number;
}

const waitedSamples = [101, 102, 103, 104, 105];

@Injectable() // to provide dependency injection
export class SampleProcessTask extends SchedulerBase<FinishLike, SemiLike, StateLike> {

    constructor() {
        super('* * * * *');
    }

    async run(): Promise<void> {
        for (const sample of waitedSample) {
            try {
                // ....
                // do something for sample
                // ....

                /*
                * Case-V: SEMI IS SUCCESS
                * 
                * Rule: semiSuccess([message], [data])
                * */
                this.semiSuccess(); // V1: without any information
                this.semiSuccess('sample processed'); // V2: with only message
                this.semiSuccess({sample}); // V3: with only data
                this.semiSuccess('sample processed', {sample}); // V4: with message and data

            } catch (error) {

                /*
                * Case-X: SEMI IS FAILED
                * 
                * Rule: semiFailed([message], [data], error)
                * !! Error is mandatory
                * */
                this.semiFailed('sample failed', {sample}, error); // X1: with message and data and error
                this.semiFailed('sample failed', error); // X2: with message and data
                this.semiFailed({sample}, error); // X3: with data and error
                this.semiFailed(error); // X4: with only error
            }

            /*
            * Case-Y: SEMI IS PARTIAL
            * 
            * Rule: semiPartial([message], [data], [error])
            * */
            this.semiPartial(); // Y1: without any information
            this.semiPartial('sample partial success'); // Y2: with only message
            this.semiPartial('sample partial success', {sample}); // Y3: with message and data
            this.semiPartial('sample partial success', {sample}, error); // Y4: with message and data and error
            this.semiPartial('sample partial success', error); // Y5: with message and error
            this.semiPartial({sample}); // Y6: with only data
            this.semiPartial({sample}, error); // Y7: with data and error
            this.semiPartial(error); // Y8: with error

            /*
            * Case-Z: SEMI IS IGNORED
            * 
            * Rule: semiIgnored([message], [data])
            * */
            this.semiIgnored(); // Z1: without any information
            this.semiIgnored('sample is ignored'); // Z2: with only message
            this.semiIgnored({sample}); // Z3: with only data
            this.semiIgnored('sample is ignored', {sample}); // Z4: with message and data
            
            // [OPTIONAL] to store latest processed state
            this.setState({sample}).then();
        }

        /*
        * Case-A: FULL IS SUCCESS
        * If full process is success
        * 
        * Rule: fullSuccess([message], [data])
        * */
        this.fullSuccess(); // A1: without any information
        this.fullSuccess('samples are processed'); // A2: with only message
        this.fullSuccess({success: 101}); // A3: with only data
        this.fullSuccess('samples are processed', {success: 245, ignored: 3}); // A4: with message and data


        /*
        * Case-B: FULL IS FAILED
        * If full process is failed, or there may be no any semi operation
        * 
        * Rule: fullFailed([message], [data], error)
        * !! Error is mandatory
        * */
        this.fullFailed('samples are failed', error); // B1: with message and error
        this.fullFailed('samples are failed', {failed: 87, ignored: 7}, error); // B2: with message and data and error
        this.fullFailed({failed: 15}, error); // B3: with data and error
        this.fullFailed(error); // B4: with only error

        /*
        * Case-C: FULL IS PARTIAL
        * If there is semi operations and some of them are failed, some of them are success, ...
        * 
        * Rule: fullFailed([message], [data], [error])
        * */
        this.fullPartial(); // C1: without any information
        this.fullPartial('samples are partly success'); // C2: with only message
        this.fullPartial('samples are partly success', {success: 3, failed: 15, ignored: 7, partial: 5}); // C3: with message and data
        this.fullPartial('samples are partly success', {success: 3, failed: 15}, error); // C4: with message and data and error
        this.fullPartial('samples are partly success', {success: 3, failed: 15}); // C5: with message and error
        this.fullPartial({success: 3, failed: 15}); // C6: with only data
        this.fullPartial({success: 3, failed: 15}, error); // C7: with data and error
        this.fullPartial(error); // C8: with error

        /*
        * Case-D: FULL IS NOTHING
        * 
        * If there is not any processed task, you can inform
        * 
        * Rule: fullNothing([reason])
        * */
        this.fullNothing(); // D1: without any information
        this.fullNothing('No waiting records'); // D2: with a reason

        /*
        * Case-E: FULL IS IGNORED
        * 
        * If you ignore current running session, you can inform
        * 
        * Rule: fullIgnored([reason])
        * */
        this.fullIgnored(); // E1: without any information
        this.fullIgnored('Any reason'); // E2: with a reason

    }
}

Environments

@see Config

| Name | Type | Default | Notes | |-----------------|--------|---------|-------| | SCHEDULER_URL | string | none | |

Contents

• schedulerClientConfig - Scheduler configuration
• SchedulerBase - Abstract class

Development

You can start to develop on it

Step 1

• EN: Go to your project folder
• TR: Bilgisayarında proje klasörüne git

# Windows
cd C:\\projects\samet-digital

# Mac
cd /Users/{user}/projects/samet-digital

Step 2

• EN: Clone the project
• TR: Projeyi bilgisiyarına çek

git clone https://github.com/samet-digital/scheduler-client.git -b development

Dependencies

• base-common - samet-digital
• api-common - samet-digital context and error usage
• client-common - samet-digital http client usage
• node-cron cron management

Commands

# Collects all dependencies
npm i

# Builds project dist (TS -> JS, src -> dist)
npm run build

# Publishes component on http://npmjs.com/
npm run publish:public

# Clears `dist` and `coverage` folders
npm run clear

# Clear `node_modules` folder
npm run clear:nm

# Validates lint for only errors @see (./eslint.config.mjs) for rules
npm run lint

# Validates lint with warnings
npm run lint:verbose

# Runs test cases
npm run test

# Exports coverage report, @see (./coverage/lcov-report/index.html)
npm run coverage

# Finds outdated/legacy dependencies
npm outdated

Standards

+ language: TS 
+ lint: eslint
+ inspections: intelli-j code inspections
+ ddd: domain driven development
+ edd: exception driven development
! tdd: test driven development
+ ldd: log driven development
+ ddd: document driven development

History

| Date | Developer | Info | Ticket | |------------|----------------|-----------|----------------| | 2025-08-11 | Mustafa Yelmer | Created | ~~none~~ |