@nest-yalc-2/app 1.3.3

package/src/base-app.service.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAppService = void 0;
+const common = __importStar(require("@nestjs/common"));
+const event_emitter_1 = require("@nestjs/event-emitter");
+const def_const_js_1 = require("@nest-yalc-2/app/def.const.js");
+const app_events_js_1 = require("./app.events.js");
+let BaseAppService = class BaseAppService {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    getHello(appName) {
+        return `Hello World from ${appName}!`;
+    }
+    handleBeforeAllRoutes(context) {
+        const handlerName = context.getHandler().name;
+        if (!handlerName.startsWith('_') && handlerName.includes('_'))
+            this.logger.debug?.(`Running Handler: ${handlerName}`);
+    }
+};
+exports.BaseAppService = BaseAppService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(app_events_js_1.AppEvents.BEFORE_ALL_ROUTES),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], BaseAppService.prototype, "handleBeforeAllRoutes", null);
+exports.BaseAppService = BaseAppService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(def_const_js_1.APP_LOGGER_SERVICE)),
+    __metadata("design:paramtypes", [Object])
+], BaseAppService);
+//# sourceMappingURL=base-app.service.js.map

package/src/base-app.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-app.service.js","sourceRoot":"","sources":["base-app.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uDAAyC;AACzC,yDAAgD;AAChD,gEAAmE;AACnE,mDAA4C;AAMrC,IAAM,cAAc,GAApB,MAAM,cAAc;IACzB,YAC+C,MAA4B;QAA5B,WAAM,GAAN,MAAM,CAAsB;IACxE,CAAC;IAKJ,QAAQ,CAAC,OAAe;QACtB,OAAO,oBAAoB,OAAO,GAAG,CAAC;IACxC,CAAC;IAGD,qBAAqB,CAAC,OAAgC;QACpD,MAAM,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC;QAE9C,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC3D,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,oBAAoB,WAAW,EAAE,CAAC,CAAC;IAC3D,CAAC;CACF,CAAA;AAnBY,wCAAc;AAazB;IADC,IAAA,uBAAO,EAAC,yBAAS,CAAC,iBAAiB,CAAC;;;;2DAMpC;yBAlBU,cAAc;IAD1B,MAAM,CAAC,UAAU,EAAE;IAGf,WAAA,MAAM,CAAC,MAAM,CAAC,iCAAkB,CAAC,CAAA;;GAFzB,cAAc,CAmB1B"}

package/src/base-app.service.ts

@@ -0,0 +1,29 @@
+import * as common from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { APP_LOGGER_SERVICE } from '@nest-yalc-2/app/def.const.js';
+import { AppEvents } from './app.events.js';
+
+/**
+ * Application service
+ */
+@common.Injectable()
+export class BaseAppService {
+  constructor(
+    @common.Inject(APP_LOGGER_SERVICE) protected logger: common.LoggerService,
+  ) {}
+
+  /**
+   * Hello world function
+   */
+  getHello(appName: string): string {
+    return `Hello World from ${appName}!`;
+  }
+
+  @OnEvent(AppEvents.BEFORE_ALL_ROUTES)
+  handleBeforeAllRoutes(context: common.ExecutionContext) {
+    const handlerName = context.getHandler().name;
+    // exclude special handlers such as _service
+    if (!handlerName.startsWith('_') && handlerName.includes('_'))
+      this.logger.debug?.(`Running Handler: ${handlerName}`);
+  }
+}

package/src/cls.module.d.ts

@@ -0,0 +1,15 @@
+import { ClsService } from 'nestjs-cls';
+import { ClsStore } from 'nestjs-cls/dist/src/lib/cls.options.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export interface IYalcCls extends ClsStore {
+    headers: Record<string, string>;
+}
+export declare class YalcGlobalClsService<TCls extends IYalcCls = IYalcCls> extends ClsService<TCls> {
+}
+export interface IYalcAsyncLocalStorageAls {
+    placeholder: string;
+}
+export declare class YalcAlsService<TStorage extends IYalcAsyncLocalStorageAls = IYalcAsyncLocalStorageAls> extends AsyncLocalStorage<TStorage> {
+}
+export declare class YalcClsModule {
+}

package/src/cls.module.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YalcClsModule = exports.YalcAlsService = exports.YalcGlobalClsService = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_cls_1 = require("nestjs-cls");
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+class YalcGlobalClsService extends nestjs_cls_1.ClsService {
+}
+exports.YalcGlobalClsService = YalcGlobalClsService;
+class YalcAlsService extends node_async_hooks_1.AsyncLocalStorage {
+}
+exports.YalcAlsService = YalcAlsService;
+let YalcClsModule = class YalcClsModule {
+};
+exports.YalcClsModule = YalcClsModule;
+exports.YalcClsModule = YalcClsModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            nestjs_cls_1.ClsModule.forRoot({
+                global: true,
+                middleware: {
+                    mount: true,
+                    setup: (cls, req) => {
+                        cls.set('headers', req.headers);
+                    },
+                    generateId: true,
+                    idGenerator: async (req) => req.headers['X-Request-Id']?.toString() ?? (0, node_crypto_1.randomUUID)(),
+                },
+            }),
+        ],
+        providers: [
+            {
+                provide: YalcGlobalClsService,
+                useExisting: nestjs_cls_1.ClsService,
+            },
+            {
+                provide: YalcAlsService,
+                useValue: new YalcAlsService(),
+            },
+        ],
+        exports: [YalcGlobalClsService],
+    })
+], YalcClsModule);
+//# sourceMappingURL=cls.module.js.map

package/src/cls.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cls.module.js","sourceRoot":"","sources":["cls.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AAExC,2CAAmD;AAEnD,uDAAqD;AACrD,6CAAyC;AASzC,MAAa,oBAEX,SAAQ,uBAAgB;CAAG;AAF7B,oDAE6B;AAS7B,MAAa,cAEX,SAAQ,oCAA2B;CAAG;AAFxC,wCAEwC;AAwCjC,IAAM,aAAa,GAAnB,MAAM,aAAa;CAAG,CAAA;AAAhB,sCAAa;wBAAb,aAAa;IAtCzB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,sBAAS,CAAC,OAAO,CAAC;gBAChB,MAAM,EAAE,IAAI;gBACZ,UAAU,EAAE;oBAGV,KAAK,EAAE,IAAI;oBAGX,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;wBAClB,GAAG,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;oBAClC,CAAC;oBAKD,UAAU,EAAE,IAAI;oBAChB,WAAW,EAAE,KAAK,EAAE,GAAmB,EAAE,EAAE,CACzC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,IAAI,IAAA,wBAAU,GAAE;iBAC1D;aACF,CAAC;SACH;QACD,SAAS,EAAE;YAIT;gBACE,OAAO,EAAE,oBAAoB;gBAC7B,WAAW,EAAE,uBAAU;aACxB;YACD;gBACE,OAAO,EAAE,cAAc;gBACvB,QAAQ,EAAE,IAAI,cAAc,EAAE;aAC/B;SACF;QACD,OAAO,EAAE,CAAC,oBAAoB,CAAC;KAChC,CAAC;GACW,aAAa,CAAG"}

package/src/cls.module.ts

@@ -0,0 +1,68 @@
+import { Module } from '@nestjs/common';
+import { FastifyRequest } from 'fastify/types/request.js';
+import { ClsModule, ClsService } from 'nestjs-cls';
+import { ClsStore } from 'nestjs-cls/dist/src/lib/cls.options.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+
+export interface IYalcCls extends ClsStore {
+  headers: Record<string, string>;
+}
+
+/**
+ * Global Cls. This is useful if you want to have a single Cls instance for your entire application.
+ */
+export class YalcGlobalClsService<
+  TCls extends IYalcCls = IYalcCls,
+> extends ClsService<TCls> {}
+
+export interface IYalcAsyncLocalStorageAls {
+  placeholder: string;
+}
+
+/**
+ * Module specific AsyncLocalStorage. This is useful if you want to have multiple AsyncLocalStorage instances for different modules.
+ */
+export class YalcAlsService<
+  TStorage extends IYalcAsyncLocalStorageAls = IYalcAsyncLocalStorageAls,
+> extends AsyncLocalStorage<TStorage> {}
+
+@Module({
+  imports: [
+    ClsModule.forRoot({
+      global: true,
+      middleware: {
+        // automatically mount the
+        // ClsMiddleware for all routes
+        mount: true,
+        // and use the setup method to
+        // provide default store values.
+        setup: (cls, req) => {
+          cls.set('headers', req.headers);
+        },
+        /**
+         * The generation of the id uses setIfUndefined internally
+         * So it won't be overwritten if it's already set (e.g. http local strategy case)
+         */
+        generateId: true,
+        idGenerator: async (req: FastifyRequest) =>
+          req.headers['X-Request-Id']?.toString() ?? randomUUID(),
+      },
+    }),
+  ],
+  providers: [
+    /**
+     * @see https://papooch.github.io/nestjs-cls/features-and-use-cases/type-safety-and-type-inference#using-a-custom-provider
+     */
+    {
+      provide: YalcGlobalClsService,
+      useExisting: ClsService,
+    },
+    {
+      provide: YalcAlsService,
+      useValue: new YalcAlsService(),
+    },
+  ],
+  exports: [YalcGlobalClsService],
+})
+export class YalcClsModule {}

package/src/conf.type.d.ts

@@ -0,0 +1,21 @@
+import type { LogLevel } from '@nestjs/common';
+import type { LoggerTypeEnum } from '@nest-yalc-2/logger/logger.enum.js';
+export interface IServiceConf {
+    appName: string;
+    loggerType: LoggerTypeEnum | string;
+    logLevels: LogLevel[];
+    logContextLevels?: {
+        [key: string]: LogLevel[];
+    };
+    domain?: string;
+    host: string;
+    port: number;
+    isDev: boolean;
+    isTest: boolean;
+    isPipeline: boolean;
+    isProduction: boolean;
+    env: typeof process.env.NODE_ENV;
+    apiPrefix?: string;
+    basePath?: string;
+    operationPrefix?: string;
+}

package/src/conf.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=conf.type.js.map

package/src/conf.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conf.type.js","sourceRoot":"","sources":["conf.type.ts"],"names":[],"mappings":""}

package/src/conf.type.ts

@@ -0,0 +1,22 @@
+import type { LogLevel } from '@nestjs/common';
+import type { LoggerTypeEnum } from '@nest-yalc-2/logger/logger.enum.js';
+
+export interface IServiceConf {
+  appName: string;
+  loggerType: LoggerTypeEnum | string;
+  logLevels: LogLevel[];
+  /** You can specialize log levels per each logger context. By default logLevels is used instead */
+  logContextLevels?: { [key: string]: LogLevel[] };
+  domain?: string;
+
+  host: string;
+  port: number;
+  isDev: boolean;
+  isTest: boolean;
+  isPipeline: boolean;
+  isProduction: boolean;
+  env: typeof process.env.NODE_ENV;
+  apiPrefix?: string;
+  basePath?: string;
+  operationPrefix?: string;
+}

package/src/db-conf.helper.ts-off

@@ -0,0 +1,93 @@
+import { IDbConfObject } from '@nestjs-yalc/database/conf.interface.js';
+import { getConnectionName } from '@nestjs-yalc/database/conn.helper.js';
+import { ClassType } from '@nestjs-yalc/types/globals.d.js';
+import { envIsTrue } from '@nestjs-yalc/utils/env.helper.js';
+import { EntitySchema } from 'typeorm';
+import { Seeder } from 'typeorm-seeding';
+import { getPrefixedEnv, ENV_PREFIX } from './conf.helper.js';
+
+type DbConfigObjectParams = {
+  realmAlias?: string;
+  entities: Array<ClassType | string | EntitySchema<any>>;
+  seeds?: { new (): Seeder }[];
+  sourceDir?: string;
+  migrationsDir?: string;
+  connectionName?: string;
+  type: DbType;
+};
+
+export function getRealmDbName(realmName: string, dbName: string) {
+  return `${realmName}_${dbName}`;
+}
+
+export function getRealmDbConnectionName(realmName: string, dbName: string) {
+  return getConnectionName(getRealmDbName(realmName, dbName));
+}
+
+export function realmDbConfFactory({
+  realmAlias,
+  entities,
+  seeds,
+  sourceDir,
+  migrationsDir,
+  connectionName = 'default',
+  type,
+}: DbConfigObjectParams) {
+  const connName = getRealmDbConnectionName(
+    realmAlias ?? 'default',
+    connectionName,
+  );
+
+  const dbConf: IDbConfObject = () => {
+    const _realmAlias = realmAlias || process.env.AC_API_REALM || undefined;
+    const prefix = `${ENV_PREFIX}${type}_`;
+
+    const dbName = getPrefixedEnv(prefix, 'MYSQL_DB_NAME', _realmAlias);
+
+    dbConf.dbName = dbName;
+
+    const noSelDb = envIsTrue(process.env.TYPEORM_NO_SEL_DB || 'false');
+    const sync = getPrefixedEnv(prefix, 'TYPEORM_SYNCHRONIZE', _realmAlias);
+    const logging = getPrefixedEnv(prefix, 'TYPEORM_LOGGING', _realmAlias);
+    const dbPort = getPrefixedEnv(prefix, 'MYSQL_PORT', _realmAlias);
+
+    const host =
+      global.__JEST_DISABLE_DB !== true
+        ? getPrefixedEnv(prefix, 'MYSQL_HOST', _realmAlias)
+        : 'jest-db-disabled';
+
+    const port = dbPort ? parseInt(dbPort, 10) : 3306;
+    const username =
+      getPrefixedEnv(prefix, 'MYSQL_USER', _realmAlias) || 'root';
+    const password =
+      getPrefixedEnv(prefix, 'MYSQL_PASSWORD', _realmAlias) ??
+      getPrefixedEnv(prefix, 'MYSQL_ROOT_PASSWORD', _realmAlias);
+
+    return {
+      host,
+      port,
+      username,
+      password,
+      type: 'mysql',
+      extra: {
+        decimalNumbers: true,
+      },
+      synchronize: envIsTrue(sync || 'false'),
+      logging: envIsTrue(logging || 'false'),
+      name: connectionName,
+      database: noSelDb ? undefined : dbName,
+      entities: noSelDb ? undefined : entities,
+      seeds,
+      factories: sourceDir ? [`${sourceDir}/**/*.factory.{ts,js}`] : undefined,
+      migrations: migrationsDir ? [`${migrationsDir}/**/*.{ts,js}`] : undefined,
+      cli: {
+        migrationsDir,
+      },
+    };
+  };
+
+  dbConf.connName = connName;
+  dbConf.dbName = connName;
+
+  return dbConf;
+}

package/src/def.const.d.ts

@@ -0,0 +1,10 @@
+export declare const APP_LOGGER_SERVICE = "APP_LOGGER_SERVICE";
+export declare const APP_EVENT_SERVICE = "APP_EVENT_SERVICE";
+export declare const SYSTEM_EVENT_SERVICE = "SYSTEM_EVENT_SERVICE";
+export declare const SYSTEM_LOGGER_SERVICE = "SYSTEM_LOGGER_SERVICE";
+export declare const CURAPP_CONF_ALIAS = "conf";
+export declare const APP_ALIAS_TOKEN = "APP_ALIAS_TOKEN";
+export declare const APP_OPTION_TOKEN = "APP_OPTION_TOKEN";
+export declare const MODULE_OPTION_TOKEN = "MODULE_OPTION_TOKEN";
+export declare const MODULE_ALIAS_TOKEN = "MODULE_ALIAS_TOKEN";
+export declare const MAIN_APP_CONFIG_SERVICE = "MAIN_APP_CONFIG_SERVICE";

package/src/def.const.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAIN_APP_CONFIG_SERVICE = exports.MODULE_ALIAS_TOKEN = exports.MODULE_OPTION_TOKEN = exports.APP_OPTION_TOKEN = exports.APP_ALIAS_TOKEN = exports.CURAPP_CONF_ALIAS = exports.SYSTEM_LOGGER_SERVICE = exports.SYSTEM_EVENT_SERVICE = exports.APP_EVENT_SERVICE = exports.APP_LOGGER_SERVICE = void 0;
+exports.APP_LOGGER_SERVICE = 'APP_LOGGER_SERVICE';
+exports.APP_EVENT_SERVICE = 'APP_EVENT_SERVICE';
+exports.SYSTEM_EVENT_SERVICE = 'SYSTEM_EVENT_SERVICE';
+exports.SYSTEM_LOGGER_SERVICE = 'SYSTEM_LOGGER_SERVICE';
+exports.CURAPP_CONF_ALIAS = 'conf';
+exports.APP_ALIAS_TOKEN = 'APP_ALIAS_TOKEN';
+exports.APP_OPTION_TOKEN = 'APP_OPTION_TOKEN';
+exports.MODULE_OPTION_TOKEN = 'MODULE_OPTION_TOKEN';
+exports.MODULE_ALIAS_TOKEN = 'MODULE_ALIAS_TOKEN';
+exports.MAIN_APP_CONFIG_SERVICE = 'MAIN_APP_CONFIG_SERVICE';
+//# sourceMappingURL=def.const.js.map

package/src/def.const.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"def.const.js","sourceRoot":"","sources":["def.const.ts"],"names":[],"mappings":";;;AAIa,QAAA,kBAAkB,GAAG,oBAAoB,CAAC;AAC1C,QAAA,iBAAiB,GAAG,mBAAmB,CAAC;AAKxC,QAAA,oBAAoB,GAAG,sBAAsB,CAAC;AAC9C,QAAA,qBAAqB,GAAG,uBAAuB,CAAC;AAEhD,QAAA,iBAAiB,GAAG,MAAM,CAAC;AAK3B,QAAA,eAAe,GAAG,iBAAiB,CAAC;AAIpC,QAAA,gBAAgB,GAAG,kBAAkB,CAAC;AAItC,QAAA,mBAAmB,GAAG,qBAAqB,CAAC;AAI5C,QAAA,kBAAkB,GAAG,oBAAoB,CAAC;AAE1C,QAAA,uBAAuB,GAAG,yBAAyB,CAAC"}

package/src/def.const.ts

@@ -0,0 +1,33 @@
+/**
+ * Exported by the app modules and used within the apps
+ * NOTE: a system can run multiple apps at the same time
+ */
+export const APP_LOGGER_SERVICE = 'APP_LOGGER_SERVICE';
+export const APP_EVENT_SERVICE = 'APP_EVENT_SERVICE';
+
+/**
+ * Globally exported from the main yalc module
+ */
+export const SYSTEM_EVENT_SERVICE = 'SYSTEM_EVENT_SERVICE';
+export const SYSTEM_LOGGER_SERVICE = 'SYSTEM_LOGGER_SERVICE';
+
+export const CURAPP_CONF_ALIAS = 'conf';
+
+/**
+ * Provider token to access the alias value of the app
+ */
+export const APP_ALIAS_TOKEN = 'APP_ALIAS_TOKEN';
+/**
+ * Provider token to access the option values of the app
+ */
+export const APP_OPTION_TOKEN = 'APP_OPTION_TOKEN';
+/**
+ * Provider token to access the option values of the current module
+ */
+export const MODULE_OPTION_TOKEN = 'MODULE_OPTION_TOKEN';
+/**
+ * Provider token to access the alias value of the current module
+ */
+export const MODULE_ALIAS_TOKEN = 'MODULE_ALIAS_TOKEN';
+
+export const MAIN_APP_CONFIG_SERVICE = 'MAIN_APP_CONFIG_SERVICE';

package/src/global.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum NODE_ENV {
+    DEVELOPMENT = "development",
+    PRODUCTION = "production",
+    TEST = "test",
+    PIPELINE = "pipeline"
+}

package/src/global.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_ENV = void 0;
+var NODE_ENV;
+(function (NODE_ENV) {
+    NODE_ENV["DEVELOPMENT"] = "development";
+    NODE_ENV["PRODUCTION"] = "production";
+    NODE_ENV["TEST"] = "test";
+    NODE_ENV["PIPELINE"] = "pipeline";
+})(NODE_ENV || (exports.NODE_ENV = NODE_ENV = {}));
+//# sourceMappingURL=global.enum.js.map

package/src/global.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.enum.js","sourceRoot":"","sources":["global.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,QAKX;AALD,WAAY,QAAQ;IAClB,uCAA2B,CAAA;IAC3B,qCAAyB,CAAA;IACzB,yBAAa,CAAA;IACb,iCAAqB,CAAA;AACvB,CAAC,EALW,QAAQ,wBAAR,QAAQ,QAKnB"}

package/src/global.enum.ts

@@ -0,0 +1,6 @@
+export enum NODE_ENV {
+  DEVELOPMENT = 'development',
+  PRODUCTION = 'production',
+  TEST = 'test',
+  PIPELINE = 'pipeline',
+}

package/src/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":""}

package/src/life-cycle-handler.service.d.ts

@@ -0,0 +1,13 @@
+import { type ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { type IYalcBaseAppOptions } from './base-app.interface.js';
+import { AppContextService } from './app-context.service.js';
+export declare class LifeCycleHandler implements OnModuleDestroy, OnModuleInit {
+    private readonly logger;
+    private readonly moduleAlias;
+    private readonly appContextService;
+    private readonly options?;
+    constructor(logger: ImprovedLoggerService, moduleAlias: string, appContextService: AppContextService, options?: IYalcBaseAppOptions | undefined);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+}

package/src/life-cycle-handler.service.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifeCycleHandler = void 0;
+const common_1 = require("@nestjs/common");
+const def_const_js_1 = require("./def.const.js");
+const app_context_service_js_1 = require("./app-context.service.js");
+let LifeCycleHandler = class LifeCycleHandler {
+    constructor(logger, moduleAlias, appContextService, options) {
+        this.logger = logger;
+        this.moduleAlias = moduleAlias;
+        this.appContextService = appContextService;
+        this.options = options;
+        this.logger.debug?.(`====================== Init ${this.moduleAlias} ======================`);
+        if (this.options?.skipDuplicateAppCheck !== true &&
+            this.appContextService.initializedApps.has(this.moduleAlias)) {
+            throw new Error(`Cannot initialize the same app (${this.moduleAlias}) twice`);
+        }
+        this.appContextService.initializedApps.add(this.moduleAlias);
+    }
+    onModuleInit() { }
+    onModuleDestroy() {
+        this.logger.debug?.(`====================== Close ${this.moduleAlias} ======================`);
+        this.appContextService.initializedApps.delete(this.moduleAlias);
+    }
+};
+exports.LifeCycleHandler = LifeCycleHandler;
+exports.LifeCycleHandler = LifeCycleHandler = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(def_const_js_1.APP_LOGGER_SERVICE)),
+    __param(1, (0, common_1.Inject)(def_const_js_1.MODULE_ALIAS_TOKEN)),
+    __param(2, (0, common_1.Inject)(app_context_service_js_1.AppContextService)),
+    __param(3, (0, common_1.Inject)(def_const_js_1.MODULE_OPTION_TOKEN)),
+    __metadata("design:paramtypes", [Object, String, app_context_service_js_1.AppContextService, Object])
+], LifeCycleHandler);
+//# sourceMappingURL=life-cycle-handler.service.js.map

package/src/life-cycle-handler.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"life-cycle-handler.service.js","sourceRoot":"","sources":["life-cycle-handler.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,2CAKwB;AAExB,iDAIwB;AACxB,qEAA6D;AAOtD,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IAO3B,YAC+C,MAA6B,EAC7B,WAAmB,EAE/C,iBAAoC,EAEpC,OAA6B;QALD,WAAM,GAAN,MAAM,CAAuB;QAC7B,gBAAW,GAAX,WAAW,CAAQ;QAE/C,sBAAiB,GAAjB,iBAAiB,CAAmB;QAEpC,YAAO,GAAP,OAAO,CAAsB;QAE9C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CACjB,+BAA+B,IAAI,CAAC,WAAW,yBAAyB,CACzE,CAAC;QACF,IACE,IAAI,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI;YAC5C,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,EAC5D,CAAC;YACD,MAAM,IAAI,KAAK,CACb,mCAAmC,IAAI,CAAC,WAAW,SAAS,CAC7D,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC/D,CAAC;IAED,YAAY,KAAI,CAAC;IAEjB,eAAe;QACb,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CACjB,gCAAgC,IAAI,CAAC,WAAW,yBAAyB,CAC1E,CAAC;QACF,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClE,CAAC;CACF,CAAA;AArCY,4CAAgB;2BAAhB,gBAAgB;IAD5B,IAAA,mBAAU,GAAE;IASR,WAAA,IAAA,eAAM,EAAC,iCAAkB,CAAC,CAAA;IAC1B,WAAA,IAAA,eAAM,EAAC,iCAAkB,CAAC,CAAA;IAC1B,WAAA,IAAA,eAAM,EAAC,0CAAiB,CAAC,CAAA;IAEzB,WAAA,IAAA,eAAM,EAAC,kCAAmB,CAAC,CAAA;qDADQ,0CAAiB;GAX5C,gBAAgB,CAqC5B"}

package/src/life-cycle-handler.service.ts

@@ -0,0 +1,58 @@
+import { type ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+import {
+  Injectable,
+  Inject,
+  OnModuleInit,
+  OnModuleDestroy,
+} from '@nestjs/common';
+import { type IYalcBaseAppOptions } from './base-app.interface.js';
+import {
+  APP_LOGGER_SERVICE,
+  MODULE_ALIAS_TOKEN,
+  MODULE_OPTION_TOKEN,
+} from './def.const.js';
+import { AppContextService } from './app-context.service.js';
+
+/**
+ * This class is used to handle the lifecycle of the app
+ * and apply some common logic and checks to all apps
+ */
+@Injectable()
+export class LifeCycleHandler implements OnModuleDestroy, OnModuleInit {
+  /**
+   * We do this in the constructor since onModuleInit doesn't seem to be called
+   * when we use 'useFactory' to create the provider
+   * @todo: investigate why onModuleInit is not called
+   *
+   */
+  constructor(
+    @Inject(APP_LOGGER_SERVICE) private readonly logger: ImprovedLoggerService,
+    @Inject(MODULE_ALIAS_TOKEN) private readonly moduleAlias: string,
+    @Inject(AppContextService)
+    private readonly appContextService: AppContextService,
+    @Inject(MODULE_OPTION_TOKEN)
+    private readonly options?: IYalcBaseAppOptions,
+  ) {
+    this.logger.debug?.(
+      `====================== Init ${this.moduleAlias} ======================`,
+    );
+    if (
+      this.options?.skipDuplicateAppCheck !== true &&
+      this.appContextService.initializedApps.has(this.moduleAlias)
+    ) {
+      throw new Error(
+        `Cannot initialize the same app (${this.moduleAlias}) twice`,
+      );
+    }
+    this.appContextService.initializedApps.add(this.moduleAlias);
+  }
+
+  onModuleInit() {}
+
+  onModuleDestroy() {
+    this.logger.debug?.(
+      `====================== Close ${this.moduleAlias} ======================`,
+    );
+    this.appContextService.initializedApps.delete(this.moduleAlias);
+  }
+}

package/src/unwrap-result.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class UnwrapResultInterceptor implements NestInterceptor {
+    intercept(_: ExecutionContext, next: CallHandler): Observable<any>;
+}