@notchjs/core 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Augustus Kamau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# @notchjs/core
+
+> A dependency injection based web framework (Node.js).
+
+## Installation
+
+Using npm:
+
+```sh
+npm install --save @notchjs/core
+```
+
+or using yarn:
+
+```sh
+yarn add @notchjs/core
+```
+
+## :memo: License
+
+This project is licensed under the **MIT license**.
+
+See [LICENSE](LICENSE) for more information.

package/dist/application.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'node:http';
+import * as https from 'node:https';
+import type { HttpAdapter } from '@notchjs/types';
+import type { HookCollector } from './hook-collector';
+import type { ApplicationEnvironment } from './interfaces';
+export declare class Application {
+    protected httpServer: http.Server | https.Server;
+    private readonly adapter;
+    private readonly hooks;
+    private readonly _environment;
+    private isInitialized;
+    private isListening;
+    constructor(adapter: HttpAdapter, hooks: HookCollector, environment: ApplicationEnvironment);
+    get environment(): ApplicationEnvironment;
+    init(): Promise<this>;
+    getHttpAdapter<T extends HttpAdapter = HttpAdapter>(): T;
+    getHttpServer(): http.Server | https.Server;
+    registerHttpServer(): void;
+    createServer<T = any>(): T;
+    listen(port: string | number, callback?: () => void): Promise<any>;
+    listen(port: string | number, hostname: string, callback?: () => void): Promise<any>;
+    close(signal?: string): Promise<void>;
+    getUrl(): Promise<string>;
+    protected dispose(): Promise<void>;
+    private formatAddress;
+    private getProtocol;
+}

package/dist/application.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const node_os_1 = require("node:os");
+const notions_1 = require("@hemjs/notions");
+class Application {
+    constructor(adapter, hooks, environment) {
+        this.isInitialized = false;
+        this.isListening = false;
+        this.adapter = adapter;
+        this.hooks = hooks;
+        this._environment = environment;
+        this.registerHttpServer();
+    }
+    get environment() {
+        return this._environment;
+    }
+    async init() {
+        if (this.isInitialized) {
+            return this;
+        }
+        await this.hooks.addStartupHook();
+        this.isInitialized = true;
+        return this;
+    }
+    getHttpAdapter() {
+        return this.adapter;
+    }
+    getHttpServer() {
+        return this.httpServer;
+    }
+    registerHttpServer() {
+        this.httpServer = this.createServer();
+    }
+    createServer() {
+        this.adapter.initHttpServer();
+        return this.adapter.getHttpServer();
+    }
+    async listen(port, ...args) {
+        if (!this.isInitialized)
+            await this.init();
+        return new Promise((resolve, reject) => {
+            const errorHandler = (e) => {
+                this.environment.log?.error(e?.toString?.());
+                reject(e);
+            };
+            this.httpServer.once('error', errorHandler);
+            const isCallbackInOriginalArgs = (0, notions_1.isFunction)(args[args.length - 1]);
+            const listenFnArgs = isCallbackInOriginalArgs
+                ? args.slice(0, args.length - 1)
+                : args;
+            this.httpServer.listen(port, ...listenFnArgs, (...originalCallbackArgs) => {
+                if (originalCallbackArgs[0] instanceof Error) {
+                    return reject(originalCallbackArgs[0]);
+                }
+                const address = this.httpServer.address();
+                if (address) {
+                    this.httpServer.removeListener('error', errorHandler);
+                    this.isListening = true;
+                    resolve(this.httpServer);
+                }
+                if (isCallbackInOriginalArgs) {
+                    args[args.length - 1](...originalCallbackArgs);
+                }
+            });
+        });
+    }
+    async close(signal) {
+        await this.dispose();
+        await this.hooks.addShutdownHook(signal);
+        this.isListening = false;
+    }
+    async getUrl() {
+        return new Promise((resolve, reject) => {
+            if (!this.isListening) {
+                reject('Server not listening!');
+                return;
+            }
+            const address = this.httpServer.address();
+            resolve(this.formatAddress(address));
+        });
+    }
+    async dispose() {
+        this.adapter && (await this.adapter.close());
+    }
+    formatAddress(address) {
+        if ((0, notions_1.isString)(address)) {
+            if ((0, node_os_1.platform)() === 'win32') {
+                return address;
+            }
+            const basePath = encodeURIComponent(address);
+            return `${this.getProtocol()}+unix://${basePath}`;
+        }
+        let host = address.address;
+        if ([6, 'IPv6'].includes(address.family)) {
+            if (host === '::') {
+                host = '[::1]';
+            }
+            else {
+                host = `[${host}]`;
+            }
+        }
+        else if (host === '0.0.0.0') {
+            host = '127.0.0.1';
+        }
+        return `${this.getProtocol()}://${host}:${address.port}`;
+    }
+    getProtocol() {
+        return this.environment.config?.tls ? 'https' : 'http';
+    }
+}
+exports.Application = Application;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HTTP_ADAPTER = "HTTP_ADAPTER";
+export declare const LOGGER = "LOGGER";

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGGER = exports.HTTP_ADAPTER = void 0;
+exports.HTTP_ADAPTER = 'HTTP_ADAPTER';
+exports.LOGGER = 'LOGGER';

package/dist/hook-collector.d.ts

@@ -0,0 +1,12 @@
+import type { HookProvider } from '@armscye/hooks';
+import type { HookFactory } from './hook-factory';
+export declare class HookCollector {
+    private readonly records;
+    constructor(factory: HookFactory, hooks?: HookProvider[]);
+    addStartupHook(): Promise<void>;
+    addShutdownHook(signal?: string): Promise<void>;
+    private runStartupHook;
+    private runShutdownHook;
+    private isStartupHook;
+    private isShutdownHook;
+}

package/dist/hook-collector.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookCollector = void 0;
+const notions_1 = require("@hemjs/notions");
+const iterare_1 = require("iterare");
+class HookCollector {
+    constructor(factory, hooks = []) {
+        this.records = factory.prepare(hooks);
+    }
+    async addStartupHook() {
+        await Promise.all(this.runStartupHook(this.records));
+    }
+    async addShutdownHook(signal) {
+        await Promise.all(this.runShutdownHook(this.records, signal));
+    }
+    runStartupHook(records) {
+        return (0, iterare_1.iterate)(records)
+            .filter((record) => !(0, notions_1.isNil)(record))
+            .filter(({ hook }) => this.isStartupHook(hook))
+            .map(async ({ hook }) => hook.onStartup())
+            .toArray();
+    }
+    runShutdownHook(records, signal) {
+        return (0, iterare_1.iterate)(records)
+            .filter((record) => !(0, notions_1.isNil)(record))
+            .filter(({ hook }) => this.isShutdownHook(hook))
+            .map(async ({ hook }) => hook.onShutdown(signal))
+            .toArray();
+    }
+    isStartupHook(hook) {
+        return (0, notions_1.isFunction)(hook.onStartup);
+    }
+    isShutdownHook(hook) {
+        return (0, notions_1.isFunction)(hook.onShutdown);
+    }
+}
+exports.HookCollector = HookCollector;

package/dist/hook-container.d.ts

@@ -0,0 +1,7 @@
+import type { Container, ProviderToken } from '@armscye/container';
+export declare class HookContainer implements Container {
+    private readonly container;
+    constructor(container: Container);
+    get<T>(token: ProviderToken): T;
+    has(token: ProviderToken): boolean;
+}

package/dist/hook-container.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookContainer = void 0;
+const util_1 = require("@notchjs/util");
+class HookContainer {
+    constructor(container) {
+        this.container = container;
+    }
+    get(token) {
+        if (!this.has(token)) {
+            throw new Error(`Cannot fetch hook provider for (${(0, util_1.stringify)(token)}); provider not registered.`);
+        }
+        return this.container.get(token);
+    }
+    has(token) {
+        if (this.container.has(token)) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.HookContainer = HookContainer;

package/dist/hook-factory.d.ts

@@ -0,0 +1,9 @@
+import type { HookContainer } from './hook-container';
+import type { HookRecord } from './interfaces';
+export declare class HookFactory {
+    private readonly container;
+    constructor(container: HookContainer);
+    prepare(hook: any): HookRecord | HookRecord[];
+    lazy<T>(hook: string | symbol): T;
+    pipeline(hooks: any[]): any[];
+}

package/dist/hook-factory.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookFactory = void 0;
+const notions_1 = require("@hemjs/notions");
+const util_1 = require("@notchjs/util");
+class HookFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    prepare(hook) {
+        if (Array.isArray(hook)) {
+            return this.pipeline(hook);
+        }
+        if ((0, notions_1.isObject)(hook)) {
+            return {
+                name: hook.constructor?.name,
+                hook: hook,
+            };
+        }
+        if ((0, notions_1.isFunction)(hook)) {
+            const funcAsString = hook.toString();
+            const isClass = /^class\s/.test(funcAsString);
+            if (isClass) {
+                return {
+                    name: hook.name,
+                    hook: new hook(),
+                };
+            }
+            return {
+                name: hook.name,
+                hook: hook(),
+            };
+        }
+        if (!(0, notions_1.isString)(hook) && !(0, notions_1.isSymbol)(hook)) {
+            throw new Error(`Hook (${(0, util_1.stringify)(hook)}) is neither a provider token, a class, a function, or an array of such arguments.`);
+        }
+        return {
+            name: (0, notions_1.isSymbol)(hook) ? hook.toString() : hook,
+            hook: this.lazy(hook),
+        };
+    }
+    lazy(hook) {
+        return this.container.get(hook);
+    }
+    pipeline(hooks) {
+        return hooks.map((hook) => this.prepare(hook));
+    }
+}
+exports.HookFactory = HookFactory;

package/dist/http-adapter-host.d.ts

@@ -0,0 +1,6 @@
+import type { HttpAdapter } from '@notchjs/types';
+export declare class HttpAdapterHost {
+    private _httpAdapter;
+    constructor(httpAdapter?: HttpAdapter);
+    get httpAdapter(): HttpAdapter | undefined;
+}

package/dist/http-adapter-host.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapterHost = void 0;
+class HttpAdapterHost {
+    constructor(httpAdapter) {
+        this._httpAdapter = httpAdapter;
+    }
+    get httpAdapter() {
+        return this._httpAdapter;
+    }
+}
+exports.HttpAdapterHost = HttpAdapterHost;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './application';
+export * from './constants';
+export * from './hook-collector';
+export * from './hook-container';
+export * from './hook-factory';
+export * from './http-adapter-host';
+export * from './interfaces';
+export * from './logger-host';
+export * from './notch.module';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./application"), exports);
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./hook-collector"), exports);
+tslib_1.__exportStar(require("./hook-container"), exports);
+tslib_1.__exportStar(require("./hook-factory"), exports);
+tslib_1.__exportStar(require("./http-adapter-host"), exports);
+tslib_1.__exportStar(require("./interfaces"), exports);
+tslib_1.__exportStar(require("./logger-host"), exports);
+tslib_1.__exportStar(require("./notch.module"), exports);

package/dist/interfaces/application-config.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { TlsOptions } from 'node:tls';
+export interface ApplicationConfig {
+    tls?: TlsOptions;
+}

package/dist/interfaces/application-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/application-environment.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '@armscye/logging';
+import type { ApplicationConfig } from './application-config';
+export interface ApplicationEnvironment {
+    log?: Logger;
+    config?: ApplicationConfig;
+}

package/dist/interfaces/application-environment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/hook-record.d.ts

@@ -0,0 +1,4 @@
+export interface HookRecord {
+    name: string;
+    hook: unknown;
+}

package/dist/interfaces/hook-record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './application-config';
+export * from './application-environment';
+export * from './hook-record';

package/dist/interfaces/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./application-config"), exports);
+tslib_1.__exportStar(require("./application-environment"), exports);
+tslib_1.__exportStar(require("./hook-record"), exports);

package/dist/logger-host.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '@armscye/logging';
+export declare class LoggerHost {
+    private _logger;
+    constructor(logger?: Logger);
+    get logger(): Logger | undefined;
+}

package/dist/logger-host.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerHost = void 0;
+class LoggerHost {
+    constructor(logger) {
+        this._logger = logger;
+    }
+    get logger() {
+        return this._logger;
+    }
+}
+exports.LoggerHost = LoggerHost;

package/dist/notch.module.d.ts

@@ -0,0 +1,7 @@
+import type { Provider } from '@armscye/container';
+import type { Module } from '@armscye/module';
+export declare class NotchModule implements Module {
+    register(): {
+        providers: Provider[];
+    };
+}

package/dist/notch.module.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotchModule = void 0;
+const util_1 = require("@notchjs/util");
+const application_1 = require("./application");
+const constants_1 = require("./constants");
+const hook_collector_1 = require("./hook-collector");
+const hook_container_1 = require("./hook-container");
+const hook_factory_1 = require("./hook-factory");
+const http_adapter_host_1 = require("./http-adapter-host");
+const logger_host_1 = require("./logger-host");
+class NotchModule {
+    register() {
+        return {
+            providers: [
+                {
+                    provide: http_adapter_host_1.HttpAdapterHost.name,
+                    useFactory: (container) => {
+                        const adapter = container.has(constants_1.HTTP_ADAPTER)
+                            ? container.get(constants_1.HTTP_ADAPTER)
+                            : undefined;
+                        return new http_adapter_host_1.HttpAdapterHost(adapter);
+                    },
+                },
+                {
+                    provide: logger_host_1.LoggerHost.name,
+                    useFactory: (container) => {
+                        const logger = container.has(constants_1.LOGGER)
+                            ? container.get(constants_1.LOGGER)
+                            : new util_1.NoopLogger();
+                        return new logger_host_1.LoggerHost(logger);
+                    },
+                },
+                {
+                    provide: hook_container_1.HookContainer.name,
+                    useFactory: (container) => {
+                        return new hook_container_1.HookContainer(container);
+                    },
+                },
+                {
+                    provide: hook_factory_1.HookFactory.name,
+                    useFactory: (container) => {
+                        return new hook_factory_1.HookFactory(container.get(hook_container_1.HookContainer.name));
+                    },
+                },
+                {
+                    provide: hook_collector_1.HookCollector.name,
+                    useFactory: (container) => {
+                        const config = container.has('config')
+                            ? container.get('config')
+                            : {};
+                        return new hook_collector_1.HookCollector(container.get(hook_factory_1.HookFactory.name), config.hooks);
+                    },
+                },
+                {
+                    provide: application_1.Application.name,
+                    useFactory: (container) => {
+                        const httpAdapterHost = container.get(http_adapter_host_1.HttpAdapterHost.name);
+                        if (!httpAdapterHost.httpAdapter) {
+                            throw new Error('HTTP adapter missing');
+                        }
+                        const config = container.has('config')
+                            ? container.get('config')
+                            : {};
+                        const loggerHost = container.get(logger_host_1.LoggerHost.name);
+                        const hooks = container.get(hook_collector_1.HookCollector.name);
+                        return new application_1.Application(httpAdapterHost.httpAdapter, hooks, {
+                            log: loggerHost.logger?.getLogger(application_1.Application.name),
+                            config: config.notch,
+                        });
+                    },
+                },
+            ],
+        };
+    }
+}
+exports.NotchModule = NotchModule;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@notchjs/core",
+  "version": "0.2.1",
+  "description": "A dependency injection based web framework (Node.js)",
+  "license": "MIT",
+  "author": "Augustus Kamau",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "notchjs",
+    "notch",
+    "framework"
+  ],
+  "scripts": {
+    "test": "jest --detectOpenHandles"
+  },
+  "dependencies": {
+    "@notchjs/util": "^0.2.1",
+    "iterare": "1.2.1",
+    "tslib": "2.6.2"
+  },
+  "devDependencies": {
+    "@notchjs/express": "^0.2.1",
+    "@notchjs/types": "^0.2.1"
+  },
+  "homepage": "https://github.com/notchjs/notch",
+  "bugs": {
+    "url": "https://github.com/notchjs/notch/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/notchjs/notch.git"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4776f48b4b1f809d36e2f3cf26f752956a21e3ab"
+}