@erkoware/init-core v0.2.0

Init Core Package

This is the core package for the Init project. It contains the core functionality used by other packages. It's general purpose is to provide a managed initialization process for applications.

Installation

npm install @erkoware/init-core

Usage

Configuration

The core package is configured using a Config array. This array is passed to the init class.

const config: Config = [
    {
        fn: () => {
        },
        stage: 0,
        fnType: FnType.DISPATCH
    },
    {
        fn: () => {
        },
        stage: 1,
        fnType: FnType.SYNC
    },
    {
        fn: async () => {
        },
        stage: 1,
        fnType: FnType.SYNC
    },
    {
        fn: () => {
        },
        stage: 2,
        fnType: FnType.SYNC
    },
];

In stage 0 we may want to dispatch a function call we don't care about awaiting. Stage 1 maybe has some tasks we want to run in parallel. And stage 2 should be run sequentially after stage 1.

Alternative Configuration

Alternatively you can use the InitConfigElement class to create a configuration. This also works mixed together with the Object initialization.

import { InitConfigElement } from './init';

const config: Config = [
    new InitConfigElement(
        () => {},
        0,
        FnType.DISPATCH
    ),
    new InitConfigElement(
        () => {},
        1,
        FnType.SYNC
    ),
    new InitConfigElement(
        async () => {},
        1,
        FnType.SYNC
    ),
    new InitConfigElement(
        () => {},
        2,
        FnType.SYNC
    ),
];

Configuration Properties

fn: () => void | Promise<void>;  // The function to be called.
stage: number;                   // The stage to run the function in.
fnType: FnType;                  // The type of function to run.
finished?: boolean;              // Optional, whether the function has finished running.

Initialization

Passing the configuration array to the init class and starting the initialization process.

const init = new Init(config);
await init.startInit();

or

const init = new Init();
init.setConfig(config);
await init.startInit();

Function Types

enum FnType {
    SYNC = 'sync',
    DISPATCH = 'dispatch',
}

SYNC is used to execute and await all functions of a stage in parallel. Execution order is not guaranteed. If you want to execute functions in a specific order, split them into different stages.

DISPATCH is used to execute and all functions of a stage but not await them at all.