@just-in/core
Version:
A TypeScript-first framework for building adaptive digital health interventions.
270 lines • 11.5 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.JustIn = exports.JustInWrapper = void 0;
const data_manager_1 = __importDefault(require("./data-manager/data-manager"));
const event_handler_manager_1 = require("./event/event-handler-manager");
const event_queue_1 = require("./event/event-queue");
const task_manager_1 = require("./handlers/task.manager");
const decision_rule_manager_1 = require("./handlers/decision-rule.manager");
const logger_manager_1 = require("./logger/logger-manager");
const data_manager_constants_1 = require("./data-manager/data-manager.constants");
const user_manager_1 = require("./user-manager/user-manager");
const interval_timer_event_generator_1 = require("./event/interval-timer-event-generator");
const result_recorder_1 = require("./handlers/result-recorder");
/**
* JustInWrapper class provides a unified interface for managing application-level configurations,
* event registrations, data manager initialization, and orchestrating the event queue for processing.
*/
class JustInWrapper {
constructor() {
this.dataManager = data_manager_1.default.getInstance();
this.eventHandlerManager = event_handler_manager_1.EventHandlerManager.getInstance();
this.isInitialized = false;
this.initializedAt = null;
this.intervalTimerEventGenerators = new Map();
this.isInitialized = false;
this.initializedAt = new Date();
}
/**
* Retrieves the singleton instance of JustInWrapper.
* @returns {JustInWrapper} The singleton instance.
*/
static getInstance() {
if (!JustInWrapper.instance) {
JustInWrapper.instance = new JustInWrapper();
}
return JustInWrapper.instance;
}
/**
* Deletes the singleton instance of JustInWrapper.
*/
static killInstance() {
if (JustInWrapper.instance) {
JustInWrapper.instance = null;
}
}
/**
* Returns the initialization status of the JustInWrapper.
* @returns {boolean} The initialization status.
*/
getInitializationStatus() {
return this.isInitialized;
}
/**
* Initializes the DataManager and UserManager, setting up the database connection.
* This should be called before any operations that depend on the database.
* @param {DBType} dbType - The type of database to initialize (default is MongoDB).
* @returns {Promise<void>}
*/
async init(dbType = data_manager_constants_1.DBType.MONGO) {
if (this.getInitializationStatus()) {
logger_manager_1.Log.warn('JustInWrapper is already initialized.');
return;
}
await this.dataManager.init(dbType);
await user_manager_1.UserManager.init();
this.isInitialized = true;
logger_manager_1.Log.info('JustIn initialized successfully.');
}
/**
* Shuts down data manager, user manager, and event queue.
* Clears all interval timer event generators and event handlers.
* This should be called when the application is shutting down.
*/
async shutdown() {
try {
if (!this.getInitializationStatus()) {
logger_manager_1.Log.warn('JustInWrapper is not initialized.');
return;
}
await this.stopEngine();
user_manager_1.UserManager.shutdown();
await this.dataManager.close();
this.intervalTimerEventGenerators.clear();
this.eventHandlerManager.clearEventHandlers();
this.isInitialized = false;
this.initializedAt = null;
logger_manager_1.Log.info('JustIn shut down successfully.');
}
catch (error) {
logger_manager_1.Log.warn('Error shutting down JustInWrapper:', error);
}
}
/**
* Starts the event queue engine, processing all queued events.
* This should be called after init().
*/
async startEngine() {
logger_manager_1.Log.dev('Starting engine...');
await (0, event_queue_1.startEventQueueProcessing)();
this.intervalTimerEventGenerators.forEach((eventGenerator, eventTypeName) => {
logger_manager_1.Log.info(`Starting interval timer event generator for event type: ${eventTypeName}`);
eventGenerator.start();
});
await (0, event_queue_1.processEventQueue)();
logger_manager_1.Log.info(`Engine started and processing events at ${new Date().toISOString()}.`);
}
/**
* Stops the engine, halts event processing, and unregisters all clock events.
* This can be called to stop the engine without shutting down the application.
*/
async stopEngine() {
this.intervalTimerEventGenerators.forEach((eventGenerator, eventTypeName) => {
logger_manager_1.Log.info(`Stopping interval timer event generator for event type: ${eventTypeName}`);
eventGenerator.stop();
});
(0, event_queue_1.stopEventQueueProcessing)();
logger_manager_1.Log.info('Engine stopped and cleared of all events.');
}
/**
* Adds a list of new users to the database.
* @param {NewUserRecord[]} users - The list of new users to add.
* @returns {Promise<(JUser | null)[]>} The list of added users, or null if not found.
*/
async addUsers(users) {
return await user_manager_1.UserManager.addUsers(users);
}
/**
* Retrieves a list of users from the database.
* @returns {Promise<(JUser | null)[]>} The list of users, or null if not found.
*/
async getAllUsers() {
return await user_manager_1.UserManager.getAllUsers();
}
/**
* Adds a new user to the database.
* @param {NewUserRecord} newUserRecord - The new user record to add.
* @returns {Promise<JUser>} The added user.
*/
async addUser(newUserRecord) {
return await user_manager_1.UserManager.addUser(newUserRecord);
}
/**
* Retrieves a user from the database by their unique identifier.
* @param {string} uniqueIdentifier - The unique identifier of the user.
* @returns {Promise<JUser | null>} The user, or null if not found.
*/
async getUser(uniqueIdentifier) {
return await user_manager_1.UserManager.getUserByUniqueIdentifier(uniqueIdentifier);
}
/**
* Retrieves a user from the database by their unique identifier.
* @param {string} uniqueIdentifier - The unique identifier of the user.
* @param {Record<string, any>} attributesToUpdate - The attributes to update in the user record.
* @returns {Promise<JUser | null>} The user, or null if not found.
*/
async updateUser(uniqueIdentifier, attributesToUpdate) {
return await user_manager_1.UserManager.updateUserByUniqueIdentifier(uniqueIdentifier, attributesToUpdate);
}
/**
* Deletes a user from the database by their unique identifier.
* @param {string} uniqueIdentifier - The unique identifier of the user.
* @returns {Promise<void>} A promise that resolves when the user is deleted.
*/
async deleteUser(uniqueIdentifier) {
return await user_manager_1.UserManager.deleteUserByUniqueIdentifier(uniqueIdentifier);
}
/**
* Registers a new event type and adds it to the queue.
* @param {string} eventType - The type of the event.
* @param {string[]} handlers - The ordered task or decision rule names for the event.
*/
async registerEventHandlers(eventType, handlers) {
await this.eventHandlerManager.registerEventHandlers(eventType, handlers);
}
/**
* Unregisters an existing event by name.
* @param {string} eventType - The type of the event to unregister.
*/
unregisterEventHandlers(eventType) {
this.eventHandlerManager.unregisterEventHandlers(eventType);
}
/**
* Creates a new interval timer event generator.
* @param {string} eventTypeName - The name of the event type.
* @param {number} intervalInMs - The interval in milliseconds.
* @param {IntervalTimerEventGeneratorOptions} options - The options for the event generator.
*/
createIntervalTimerEventGenerator(eventTypeName, intervalInMs, options = {}) {
const eventGenerator = new interval_timer_event_generator_1.IntervalTimerEventGenerator(intervalInMs, eventTypeName, options);
this.intervalTimerEventGenerators.set(eventTypeName, eventGenerator);
}
/**
* Returns the interval timer event generators.
* @returns {Map<string, IntervalTimerEventGenerator>} The interval timer event generators.
*/
getIntervalTimerEventGenerators() {
return this.intervalTimerEventGenerators;
}
/**
* Publishes an event, adding it to the processing queue.
* @param {string} eventType - The type of the event.
* @param {Date} generatedTimestamp - The timestamp of the event.
* @param {object} eventDetails - The details of the event instance.
* NOTE: publishEventDetails expects a Record,
* but I don't think we want to expose this to 3PDs
*/
async publishEvent(eventType, generatedTimestamp, eventDetails) {
await (0, event_queue_1.publishEvent)(eventType, generatedTimestamp, eventDetails);
}
/**
* Sets up the event queue listener.
*/
setupEventQueueListener() {
(0, event_queue_1.setupEventQueueListener)();
}
/**
* Registers a new task within the framework.
* @param {TaskRegistration} task - The task to register.
*/
registerTask(task) {
(0, task_manager_1.registerTask)(task);
}
/**
* Registers a new decision rule within the framework.
* @param {DecisionRuleRegistration} decisionRule - The decision rule to register.
*/
registerDecisionRule(decisionRule) {
(0, decision_rule_manager_1.registerDecisionRule)(decisionRule);
}
/**
* Configures the logger with a custom logger instance.
* @param {Logger} logger - The logger implementation to use.
*/
configureLogger(logger) {
(0, logger_manager_1.setLogger)(logger);
}
/**
* Configures the writer for a task result with a custom function.
* Will default to writing to the db
* @param {RecordResultFunction} taskWriter - The function to take in the results of a task
*/
configureTaskResultWriter(taskWriter) {
(0, result_recorder_1.setTaskResultRecorder)(taskWriter);
}
/**
* Configures the writer for a decision rule result with a custom function.
* Will default to writing to the db
* @param {RecordResultFunction} decisionRuleWriter - The function to take in the results of a task
*/
configureDecisionRuleResultWriter(decisionRuleWriter) {
(0, result_recorder_1.setDecisionRuleResultRecorder)(decisionRuleWriter);
}
/**
* Sets the logging levels for the application.
* @param levels - The logging levels to enable or disable.
*/
setLoggingLevels(levels) {
(0, logger_manager_1.setLogLevels)(levels);
}
}
exports.JustInWrapper = JustInWrapper;
JustInWrapper.instance = null;
const JustIn = () => {
return JustInWrapper.getInstance();
};
exports.JustIn = JustIn;
//# sourceMappingURL=JustInWrapper.js.map