@decaf-ts/for-nest 0.0.2

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Tiago Venceslau and Contributors
+
+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,93 @@
+[![Banner](./workdocs/assets/Banner.png)](https://decaf-ts.github.io/ts-workspace/)
+## Typescript Template
+
+This repository is meant to provide an enterprise template for any standard Typescript project
+
+
+![Licence](https://img.shields.io/github/license/decaf-ts/for-nest.svg?style=plastic)
+![GitHub language count](https://img.shields.io/github/languages/count/decaf-ts/for-nest?style=plastic)
+![GitHub top language](https://img.shields.io/github/languages/top/decaf-ts/for-nest?style=plastic)
+
+[![Build & Test](https://github.com/decaf-ts/for-nest/actions/workflows/nodejs-build-prod.yaml/badge.svg)](https://github.com/decaf-ts/for-nest/actions/workflows/nodejs-build-prod.yaml)
+[![CodeQL](https://github.com/decaf-ts/for-nest/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/decaf-ts/for-nest/actions/workflows/codeql-analysis.yml)[![Snyk Analysis](https://github.com/decaf-ts/for-nest/actions/workflows/snyk-analysis.yaml/badge.svg)](https://github.com/decaf-ts/for-nest/actions/workflows/snyk-analysis.yaml)
+[![Pages builder](https://github.com/decaf-ts/for-nest/actions/workflows/pages.yaml/badge.svg)](https://github.com/decaf-ts/for-nest/actions/workflows/pages.yaml)
+[![.github/workflows/release-on-tag.yaml](https://github.com/decaf-ts/for-nest/actions/workflows/release-on-tag.yaml/badge.svg?event=release)](https://github.com/decaf-ts/for-nest/actions/workflows/release-on-tag.yaml)
+
+![Open Issues](https://img.shields.io/github/issues/decaf-ts/for-nest.svg)
+![Closed Issues](https://img.shields.io/github/issues-closed/decaf-ts/for-nest.svg)
+![Pull Requests](https://img.shields.io/github/issues-pr-closed/decaf-ts/for-nest.svg)
+![Maintained](https://img.shields.io/badge/Maintained%3F-yes-green.svg)
+
+![Forks](https://img.shields.io/github/forks/decaf-ts/for-nest.svg)
+![Stars](https://img.shields.io/github/stars/decaf-ts/for-nest.svg)
+![Watchers](https://img.shields.io/github/watchers/decaf-ts/for-nest.svg)
+
+![Node Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=Node&query=$.engines.node&colorB=blue)
+![NPM Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=NPM&query=$.engines.npm&colorB=purple)
+
+Documentation available [here](https://decaf-ts.github.io/for-nest/)
+
+### Description
+
+No one needs the hassle of setting up new repos every time.
+
+Now you can create new repositories from this template and enjoy having everything set up for you.
+
+
+
+### How to Use
+
+- [Initial Setup](./workdocs/tutorials/For%20Developers.md#_initial-setup_)
+- [Installation](./workdocs/tutorials/For%20Developers.md#installation)
+- [Scripts](./workdocs/tutorials/For%20Developers.md#scripts)
+- [Linting](./workdocs/tutorials/For%20Developers.md#testing)
+- [CI/CD](./workdocs/tutorials/For%20Developers.md#continuous-integrationdeployment)
+- [Publishing](./workdocs/tutorials/For%20Developers.md#publishing)
+- [Structure](./workdocs/tutorials/For%20Developers.md#repository-structure)
+- [IDE Integrations](./workdocs/tutorials/For%20Developers.md#ide-integrations)
+  - [VSCode(ium)](./workdocs/tutorials/For%20Developers.md#visual-studio-code-vscode)
+  - [WebStorm](./workdocs/tutorials/For%20Developers.md#webstorm)
+- [Considerations](./workdocs/tutorials/For%20Developers.md#considerations)
+
+
+
+
+### Related
+
+[![Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=ts-workspace)](https://github.com/decaf-ts/ts-workspace)
+
+### Social
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/decaf-ts/)
+
+
+
+
+#### Languages
+
+![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
+![JavaScript](https://img.shields.io/badge/JavaScript-F7DF1E?style=for-the-badge&logo=javascript&logoColor=black)
+![NodeJS](https://img.shields.io/badge/Node.js-43853D?style=for-the-badge&logo=node.js&logoColor=white)
+![ShellScript](https://img.shields.io/badge/Shell_Script-121011?style=for-the-badge&logo=gnu-bash&logoColor=white)
+
+## Getting help
+
+If you have bug reports, questions or suggestions please [create a new issue](https://github.com/decaf-ts/ts-workspace/issues/new/choose).
+
+## Contributing
+
+I am grateful for any contributions made to this project. Please read [this](./workdocs/98-Contributing.md) to get started.
+
+## Supporting
+
+The first and easiest way you can support it is by [Contributing](./workdocs/98-Contributing.md). Even just finding a typo in the documentation is important.
+
+Financial support is always welcome and helps keep both me and the project alive and healthy.
+
+So if you can, if this project in any way. either by learning something or simply by helping you save precious time, please consider donating.
+
+## License
+
+This project is released under the [MIT License](./LICENSE.md).
+
+By developers, for developers...

package/dist/for-nest.cjs

@@ -0,0 +1,112 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/decoration'), require('tslib'), require('@nestjs/common'), require('@nestjs/core'), require('@decaf-ts/logging/lib/LoggedClass')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/decoration', 'tslib', '@nestjs/common', '@nestjs/core', '@decaf-ts/logging/lib/LoggedClass'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["for-nest"] = {}, global.decoration, global.tslib, global.common, global.core, global.LoggedClass));
+})(this, (function (exports, decoration, tslib, common, core, LoggedClass) { 'use strict';
+
+    const DECAF_MODULE_OPTIONS = "DecafModuleOptions";
+    const DECAF_ADAPTER_ID = "DecafAdapter";
+
+    var DecafCoreModule_1;
+    let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedClass.LoggedClass {
+        constructor(options, moduleRef) {
+            super();
+            this.options = options;
+            this.moduleRef = moduleRef;
+        }
+        static forRoot(options) {
+            const typeOrmModuleOptions = {
+                provide: DECAF_MODULE_OPTIONS,
+                useValue: options,
+            };
+            const adapter = {
+                useFactory: async (opts) => {
+                    return new opts.adapter(opts.conf, opts.alias);
+                },
+                provide: DECAF_ADAPTER_ID,
+                durable: true,
+                scope: common.Scope.DEFAULT,
+                inject: [DECAF_MODULE_OPTIONS],
+            };
+            const providers = [adapter, typeOrmModuleOptions];
+            const exports = [adapter];
+            return {
+                module: DecafCoreModule_1,
+                providers,
+                exports,
+            };
+        }
+        async onApplicationShutdown() {
+            const adapter = this.moduleRef.get(DECAF_ADAPTER_ID);
+            try {
+                if (adapter) {
+                    this.log.info("Shutting down");
+                    await adapter.shutdown();
+                }
+            }
+            catch (e) {
+                this.log.error(`Failed to shutdown application`, e);
+            }
+        }
+    };
+    DecafCoreModule = DecafCoreModule_1 = tslib.__decorate([
+        common.Global(),
+        common.Module({}),
+        tslib.__param(0, common.Inject(DECAF_MODULE_OPTIONS)),
+        tslib.__metadata("design:paramtypes", [Object, core.ModuleRef])
+    ], DecafCoreModule);
+
+    var DecafModule_1;
+    /**
+     * @publicApi
+     */
+    exports.DecafModule = DecafModule_1 = class DecafModule {
+        static forRoot(options) {
+            return {
+                module: DecafModule_1,
+                imports: [DecafCoreModule.forRoot(options)],
+            };
+        }
+    };
+    exports.DecafModule = DecafModule_1 = tslib.__decorate([
+        common.Module({})
+    ], exports.DecafModule);
+
+    /**
+     * @module ts-workspace
+     * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports
+     * functionality from various submodules and utilities within the project.
+     *
+     * The module includes:
+     * 1. Utility functions and types from the "./utils" directory:
+     *    - These likely contain helper functions, common types, and shared functionality used throughout the project.
+     *    - May include operations for data manipulation, type checking, or other general-purpose utilities.
+     *
+     * 2. A namespace and related types from the "./namespace" directory:
+     *    - This could contain domain-specific code or a collection of related functionality.
+     *    - Might include interfaces, types, or classes that represent core concepts in the library.
+     *
+     * 3. A VERSION constant:
+     *    - Represents the current version of the module.
+     *    - Useful for version checking and compatibility purposes.
+     *
+     * This structure provides a clean and organized export of the module's functionality, allowing consumers
+     * to easily import and use specific parts of the library as needed.
+     */
+    /**
+     * Represents the current version of the ts-workspace module.
+     * The actual version number is replaced during the build process.
+     * @constant
+     * @type {string}
+     */
+    const VERSION = "0.0.1";
+    const PACKAGE_NAME = "##PACKAGE_NAME##";
+    decoration.Metadata.registerLibrary(PACKAGE_NAME, VERSION);
+
+    exports.DECAF_ADAPTER_ID = DECAF_ADAPTER_ID;
+    exports.DECAF_MODULE_OPTIONS = DECAF_MODULE_OPTIONS;
+    exports.PACKAGE_NAME = PACKAGE_NAME;
+    exports.VERSION = VERSION;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-nest.cjs","sources":["../src/constants.ts","../src/core-module.ts","../src/module.ts","../src/index.ts"],"sourcesContent":["export const DECAF_MODULE_OPTIONS = \"DecafModuleOptions\";\nexport const DECAF_ADAPTER_ID = \"DecafAdapter\";\n","import {\n  DynamicModule,\n  Global,\n  Inject,\n  Module,\n  OnApplicationShutdown,\n  Scope,\n} from \"@nestjs/common\";\nimport { ModuleRef } from \"@nestjs/core\";\nimport type { DecafModuleOptions } from \"./types\";\nimport { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS } from \"./constants\";\nimport { FactoryProvider } from \"@nestjs/common/interfaces/modules/provider.interface\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { LoggedClass } from \"@decaf-ts/logging/lib/LoggedClass\";\n\n@Global()\n@Module({})\nexport class DecafCoreModule<\n    CONF,\n    ADAPTER extends Adapter<CONF, any, any, any, any>,\n  >\n  extends LoggedClass\n  implements OnApplicationShutdown\n{\n  constructor(\n    @Inject(DECAF_MODULE_OPTIONS)\n    private readonly options: DecafModuleOptions<CONF, ADAPTER>,\n    private readonly moduleRef: ModuleRef\n  ) {\n    super();\n  }\n\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    const typeOrmModuleOptions = {\n      provide: DECAF_MODULE_OPTIONS,\n      useValue: options,\n    };\n\n    const adapter: FactoryProvider<any> = {\n      useFactory: async (opts: DecafModuleOptions) => {\n        return new opts.adapter(opts.conf, opts.alias);\n      },\n      provide: DECAF_ADAPTER_ID,\n      durable: true,\n      scope: Scope.DEFAULT,\n      inject: [DECAF_MODULE_OPTIONS],\n    };\n\n    const providers = [adapter, typeOrmModuleOptions];\n    const exports = [adapter];\n\n    return {\n      module: DecafCoreModule,\n      providers,\n      exports,\n    };\n  }\n\n  async onApplicationShutdown(): Promise<void> {\n    const adapter = this.moduleRef.get<ADAPTER>(DECAF_ADAPTER_ID);\n    try {\n      if (adapter) {\n        this.log.info(\"Shutting down\");\n        await adapter.shutdown();\n      }\n    } catch (e: unknown) {\n      this.log.error(`Failed to shutdown application`, e as Error);\n    }\n  }\n}\n","import { DynamicModule, Module } from \"@nestjs/common\";\nimport { DecafModuleOptions } from \"./types\";\nimport { DecafCoreModule } from \"./core-module\";\n\n/**\n * @publicApi\n */\n@Module({})\nexport class DecafModule {\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    return {\n      module: DecafModule,\n      imports: [DecafCoreModule.forRoot(options)],\n    };\n  }\n}\n","/**\n * @module ts-workspace\n * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports\n * functionality from various submodules and utilities within the project.\n *\n * The module includes:\n * 1. Utility functions and types from the \"./utils\" directory:\n *    - These likely contain helper functions, common types, and shared functionality used throughout the project.\n *    - May include operations for data manipulation, type checking, or other general-purpose utilities.\n *\n * 2. A namespace and related types from the \"./namespace\" directory:\n *    - This could contain domain-specific code or a collection of related functionality.\n *    - Might include interfaces, types, or classes that represent core concepts in the library.\n *\n * 3. A VERSION constant:\n *    - Represents the current version of the module.\n *    - Useful for version checking and compatibility purposes.\n *\n * This structure provides a clean and organized export of the module's functionality, allowing consumers\n * to easily import and use specific parts of the library as needed.\n */\n\nimport { Metadata } from \"@decaf-ts/decoration\";\n\nexport * from \"./constants\";\nexport * from \"./module\";\nexport * from \"./types\";\n\n/**\n * Represents the current version of the ts-workspace module.\n * The actual version number is replaced during the build process.\n * @constant\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE_NAME##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["LoggedClass","Scope","__decorate","Global","Module","__param","Inject","ModuleRef","DecafModule","Metadata"],"mappings":";;;;;;AAAO,UAAM,oBAAoB,GAAG;AAC7B,UAAM,gBAAgB,GAAG;;;ICgBzB,IAAM,eAAe,GAAA,iBAAA,GAArB,MAAM,eAIX,SAAQA,uBAAW,CAAA;QAGnB,WAEmB,CAAA,OAA0C,EAC1C,SAAoB,EAAA;IAErC,QAAA,KAAK,EAAE;YAHU,IAAO,CAAA,OAAA,GAAP,OAAO;YACP,IAAS,CAAA,SAAA,GAAT,SAAS;;QAK5B,OAAO,OAAO,CAAC,OAA2B,EAAA;IACxC,QAAA,MAAM,oBAAoB,GAAG;IAC3B,YAAA,OAAO,EAAE,oBAAoB;IAC7B,YAAA,QAAQ,EAAE,OAAO;aAClB;IAED,QAAA,MAAM,OAAO,GAAyB;IACpC,YAAA,UAAU,EAAE,OAAO,IAAwB,KAAI;IAC7C,gBAAA,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;iBAC/C;IACD,YAAA,OAAO,EAAE,gBAAgB;IACzB,YAAA,OAAO,EAAE,IAAI;gBACb,KAAK,EAAEC,YAAK,CAAC,OAAO;gBACpB,MAAM,EAAE,CAAC,oBAAoB,CAAC;aAC/B;IAED,QAAA,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACjD,QAAA,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC;YAEzB,OAAO;IACL,YAAA,MAAM,EAAE,iBAAe;gBACvB,SAAS;gBACT,OAAO;aACR;;IAGH,IAAA,MAAM,qBAAqB,GAAA;YACzB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAU,gBAAgB,CAAC;IAC7D,QAAA,IAAI;gBACF,IAAI,OAAO,EAAE;IACX,gBAAA,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC;IAC9B,gBAAA,MAAM,OAAO,CAAC,QAAQ,EAAE;;;YAE1B,OAAO,CAAU,EAAE;gBACnB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAgC,8BAAA,CAAA,EAAE,CAAU,CAAC;;;KAGjE;IApDY,eAAe,GAAA,iBAAA,GAAAC,gBAAA,CAAA;IAF3B,IAAAC,aAAM,EAAE;QACRC,aAAM,CAAC,EAAE,CAAC;IASN,IAAAC,aAAA,CAAA,CAAA,EAAAC,aAAM,CAAC,oBAAoB,CAAC,CAAA;uDAEDC,cAAS,CAAA;IAV5B,CAAA,EAAA,eAAe,CAoD3B;;;ICjED;;IAEG;AAEUC,uBAAW,GAAjB,aAAA,GAAA,MAAM,WAAW,CAAA;QACtB,OAAO,OAAO,CAAC,OAA2B,EAAA;YACxC,OAAO;IACL,YAAA,MAAM,EAAE,aAAW;gBACnB,OAAO,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;aAC5C;;;AALQA,uBAAW,GAAA,aAAA,GAAAN,gBAAA,CAAA;QADvBE,aAAM,CAAC,EAAE;IACG,CAAA,EAAAI,mBAAW,CAOvB;;ICfD;;;;;;;;;;;;;;;;;;;;IAoBG;IAQH;;;;;IAKG;AACI,UAAM,OAAO,GAAG;AAChB,UAAM,YAAY,GAAG;AAE5BC,uBAAQ,CAAC,eAAe,CAAC,YAAY,EAAE,OAAO,CAAC;;;;;;;;;;;"}

package/dist/for-nest.esm.cjs

@@ -0,0 +1,107 @@
+import { Metadata } from '@decaf-ts/decoration';
+import { __decorate, __param, __metadata } from 'tslib';
+import { Global, Module, Inject, Scope } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { LoggedClass } from '@decaf-ts/logging/lib/LoggedClass';
+
+const DECAF_MODULE_OPTIONS = "DecafModuleOptions";
+const DECAF_ADAPTER_ID = "DecafAdapter";
+
+var DecafCoreModule_1;
+let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedClass {
+    constructor(options, moduleRef) {
+        super();
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options) {
+        const typeOrmModuleOptions = {
+            provide: DECAF_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const adapter = {
+            useFactory: async (opts) => {
+                return new opts.adapter(opts.conf, opts.alias);
+            },
+            provide: DECAF_ADAPTER_ID,
+            durable: true,
+            scope: Scope.DEFAULT,
+            inject: [DECAF_MODULE_OPTIONS],
+        };
+        const providers = [adapter, typeOrmModuleOptions];
+        const exports = [adapter];
+        return {
+            module: DecafCoreModule_1,
+            providers,
+            exports,
+        };
+    }
+    async onApplicationShutdown() {
+        const adapter = this.moduleRef.get(DECAF_ADAPTER_ID);
+        try {
+            if (adapter) {
+                this.log.info("Shutting down");
+                await adapter.shutdown();
+            }
+        }
+        catch (e) {
+            this.log.error(`Failed to shutdown application`, e);
+        }
+    }
+};
+DecafCoreModule = DecafCoreModule_1 = __decorate([
+    Global(),
+    Module({}),
+    __param(0, Inject(DECAF_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ModuleRef])
+], DecafCoreModule);
+
+var DecafModule_1;
+/**
+ * @publicApi
+ */
+let DecafModule = DecafModule_1 = class DecafModule {
+    static forRoot(options) {
+        return {
+            module: DecafModule_1,
+            imports: [DecafCoreModule.forRoot(options)],
+        };
+    }
+};
+DecafModule = DecafModule_1 = __decorate([
+    Module({})
+], DecafModule);
+
+/**
+ * @module ts-workspace
+ * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports
+ * functionality from various submodules and utilities within the project.
+ *
+ * The module includes:
+ * 1. Utility functions and types from the "./utils" directory:
+ *    - These likely contain helper functions, common types, and shared functionality used throughout the project.
+ *    - May include operations for data manipulation, type checking, or other general-purpose utilities.
+ *
+ * 2. A namespace and related types from the "./namespace" directory:
+ *    - This could contain domain-specific code or a collection of related functionality.
+ *    - Might include interfaces, types, or classes that represent core concepts in the library.
+ *
+ * 3. A VERSION constant:
+ *    - Represents the current version of the module.
+ *    - Useful for version checking and compatibility purposes.
+ *
+ * This structure provides a clean and organized export of the module's functionality, allowing consumers
+ * to easily import and use specific parts of the library as needed.
+ */
+/**
+ * Represents the current version of the ts-workspace module.
+ * The actual version number is replaced during the build process.
+ * @constant
+ * @type {string}
+ */
+const VERSION = "0.0.1";
+const PACKAGE_NAME = "##PACKAGE_NAME##";
+Metadata.registerLibrary(PACKAGE_NAME, VERSION);
+
+export { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS, DecafModule, PACKAGE_NAME, VERSION };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/cli-module.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = nest;
+const commander_1 = require("commander");
+const utils_1 = require("@decaf-ts/utils");
+const logging_1 = require("@decaf-ts/logging");
+var Projects;
+(function (Projects) {
+    Projects["NEST_PROJECT"] = "nest-project";
+})(Projects || (Projects = {}));
+var Types;
+(function (Types) {
+    Types["CONTROLLER"] = "page";
+    Types["SCHEMATICS"] = "schematics";
+})(Types || (Types = {}));
+const logger = logging_1.Logging.for("nestjs-cli");
+/**
+ * Creates and returns a Command object for the Angular CLI module in decaf-ts.
+ * This function sets up a 'generate' command that can create various Angular artifacts.
+ *
+ * @returns {Command} A Command object configured with the 'generate' subcommand and its action.
+ *
+ * The command syntax is: generate <type> <name> [project]
+ * @param {Types} type - The type of artifact to generate (e.g., service, component, directive, page).
+ * @param {string} name - The name of the artifact to be generated.
+ * @param {Projects} [project=Projects.FOR_ANGULAR] - The project for which to generate the artifact.
+ *                   Defaults to the main Angular project if not specified.
+ *
+ * @throws {Error} If an invalid type is provided.
+ *
+ * @example
+ * // Usage in CLI
+ * // decaf-ts generate service my-service
+ * // decaf-ts generate component my-component for-angular-app
+ */
+function nest() {
+    return new commander_1.Command()
+        .name("nest")
+        .command("generate <type> <name> [project]")
+        .description(`decaf-ts NestJS CLI module`)
+        .action(async (type, name, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    project = Projects.NEST_PROJECT) => {
+        if (!validateType(type))
+            return logger.error(`${type} is not valid. Use service, component or directive.`);
+        //
+        //   if (type === Types.SCHEMATICS) return await generateSchematics();
+        //
+        //   if (type === Types.CONTROLLER) {
+        //     logger.info(
+        //       `Pages can be only generate for app. Forcing project to: ${Projects.FOR_ANGULAR_APP}`
+        //     );
+        //     project = Projects.FOR_ANGULAR_APP;
+        //   }
+        //
+        //   (project as string) = parseProjectName(project);
+        //
+        //   if (!validateProject(project)) project = Projects.NEST_PROJECT;
+        //   const command =
+        //     project === Projects.FOR_ANGULAR_APP
+        //       ? "ionic generate"
+        //       : `ng generate --project=${Projects.NEST_PROJECT} --path=src/lib/${type}s`;
+        //
+        //   try {
+        //     const result = await execute(`${command} ${type} ${name}`);
+        //     logger.info(result as string);
+        //   } catch (error: any) {
+        //     logger.error(error?.message || error);
+        //   }
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function generateSchematics() {
+    return Promise.all([
+        execute(`npm link schematics`),
+        execute(`cd schematics`),
+        execute(`npm install`),
+        execute(`npm run build`),
+        execute(`npx schematics .:schematics --name=decaf`),
+    ])
+        .then((res) => res)
+        .catch((error) => error);
+}
+/**
+ * Executes a shell command asynchronously.
+ *
+ * @param command - The shell command to execute.
+ * @returns A Promise that resolves with the command's stdout output as a string if successful,
+ *          or rejects with an error message if the command fails or produces stderr output.
+ */
+async function execute(command) {
+    try {
+        return await (0, utils_1.runCommand)(command).promise;
+    }
+    catch (error) {
+        logger.error(error?.message || error);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function parseProjectName(value) {
+    return value.toLowerCase();
+}
+/**
+ * Validates if the given type value is a valid enum member of Types.
+ *
+ * @param value - The type value to validate.
+ * @returns A boolean indicating whether the value is a valid Types enum member.
+ */
+function validateType(value) {
+    return Object.values(Types).includes(value);
+}
+/**
+ * Validates if the given project value is a valid enum member of Projects.
+ *
+ * @param value - The project value to validate.
+ * @returns A boolean indicating whether the value is a valid Projects enum member.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function validateProject(value) {
+    return Object.values(Projects).includes(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-module.js","sourceRoot":"","sources":["../src/cli-module.ts"],"names":[],"mappings":";;AAkCA,uBA0CC;AA5ED,yCAAoC;AACpC,2CAA6C;AAC7C,+CAA4C;AAE5C,IAAK,QAEJ;AAFD,WAAK,QAAQ;IACX,yCAA6B,CAAA;AAC/B,CAAC,EAFI,QAAQ,KAAR,QAAQ,QAEZ;AAED,IAAK,KAGJ;AAHD,WAAK,KAAK;IACR,4BAAmB,CAAA;IACnB,kCAAyB,CAAA;AAC3B,CAAC,EAHI,KAAK,KAAL,KAAK,QAGT;AAED,MAAM,MAAM,GAAG,iBAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAwB,IAAI;IAC1B,OAAO,IAAI,mBAAO,EAAE;SACjB,IAAI,CAAC,MAAM,CAAC;SACZ,OAAO,CAAC,kCAAkC,CAAC;SAC3C,WAAW,CAAC,4BAA4B,CAAC;SACzC,MAAM,CACL,KAAK,EACH,IAAW,EACX,IAAY;IACZ,6DAA6D;IAC7D,UAAoB,QAAQ,CAAC,YAAY,EACzC,EAAE;QACF,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;YACrB,OAAO,MAAM,CAAC,KAAK,CACjB,GAAG,IAAI,qDAAqD,CAC7D,CAAC;QACJ,EAAE;QACF,sEAAsE;QACtE,EAAE;QACF,qCAAqC;QACrC,mBAAmB;QACnB,8FAA8F;QAC9F,SAAS;QACT,0CAA0C;QAC1C,MAAM;QACN,EAAE;QACF,qDAAqD;QACrD,EAAE;QACF,oEAAoE;QACpE,oBAAoB;QACpB,2CAA2C;QAC3C,2BAA2B;QAC3B,oFAAoF;QACpF,EAAE;QACF,UAAU;QACV,kEAAkE;QAClE,qCAAqC;QACrC,2BAA2B;QAC3B,6CAA6C;QAC7C,MAAM;IACR,CAAC,CACF,CAAC;AACN,CAAC;AAED,6DAA6D;AAC7D,KAAK,UAAU,kBAAkB;IAC/B,OAAO,OAAO,CAAC,GAAG,CAAC;QACjB,OAAO,CAAC,qBAAqB,CAAC;QAC9B,OAAO,CAAC,eAAe,CAAC;QACxB,OAAO,CAAC,aAAa,CAAC;QACtB,OAAO,CAAC,eAAe,CAAC;QACxB,OAAO,CAAC,0CAA0C,CAAC;KACpD,CAAC;SACC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC;SAClB,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,OAAO,CAAC,OAAe;IACpC,IAAI,CAAC;QACH,OAAO,MAAM,IAAA,kBAAU,EAAC,OAAO,CAAC,CAAC,OAAO,CAAC;IAC3C,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,IAAI,KAAK,CAAC,CAAC;IACxC,CAAC;AACH,CAAC;AAED,6DAA6D;AAC7D,SAAS,gBAAgB,CAAC,KAAa;IACrC,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,KAAY;IAChC,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;GAKG;AACH,6DAA6D;AAC7D,SAAS,eAAe,CAAC,KAAa;IACpC,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAiB,CAAC,CAAC;AAC7D,CAAC","sourcesContent":["import { Command } from \"commander\";\nimport { runCommand } from \"@decaf-ts/utils\";\nimport { Logging } from \"@decaf-ts/logging\";\n\nenum Projects {\n  NEST_PROJECT = \"nest-project\",\n}\n\nenum Types {\n  CONTROLLER = \"page\",\n  SCHEMATICS = \"schematics\",\n}\n\nconst logger = Logging.for(\"nestjs-cli\");\n\n/**\n * Creates and returns a Command object for the Angular CLI module in decaf-ts.\n * This function sets up a 'generate' command that can create various Angular artifacts.\n *\n * @returns {Command} A Command object configured with the 'generate' subcommand and its action.\n *\n * The command syntax is: generate <type> <name> [project]\n * @param {Types} type - The type of artifact to generate (e.g., service, component, directive, page).\n * @param {string} name - The name of the artifact to be generated.\n * @param {Projects} [project=Projects.FOR_ANGULAR] - The project for which to generate the artifact.\n *                   Defaults to the main Angular project if not specified.\n *\n * @throws {Error} If an invalid type is provided.\n *\n * @example\n * // Usage in CLI\n * // decaf-ts generate service my-service\n * // decaf-ts generate component my-component for-angular-app\n */\nexport default function nest() {\n  return new Command()\n    .name(\"nest\")\n    .command(\"generate <type> <name> [project]\")\n    .description(`decaf-ts NestJS CLI module`)\n    .action(\n      async (\n        type: Types,\n        name: string,\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        project: Projects = Projects.NEST_PROJECT\n      ) => {\n        if (!validateType(type))\n          return logger.error(\n            `${type} is not valid. Use service, component or directive.`\n          );\n        //\n        //   if (type === Types.SCHEMATICS) return await generateSchematics();\n        //\n        //   if (type === Types.CONTROLLER) {\n        //     logger.info(\n        //       `Pages can be only generate for app. Forcing project to: ${Projects.FOR_ANGULAR_APP}`\n        //     );\n        //     project = Projects.FOR_ANGULAR_APP;\n        //   }\n        //\n        //   (project as string) = parseProjectName(project);\n        //\n        //   if (!validateProject(project)) project = Projects.NEST_PROJECT;\n        //   const command =\n        //     project === Projects.FOR_ANGULAR_APP\n        //       ? \"ionic generate\"\n        //       : `ng generate --project=${Projects.NEST_PROJECT} --path=src/lib/${type}s`;\n        //\n        //   try {\n        //     const result = await execute(`${command} ${type} ${name}`);\n        //     logger.info(result as string);\n        //   } catch (error: any) {\n        //     logger.error(error?.message || error);\n        //   }\n      }\n    );\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nasync function generateSchematics() {\n  return Promise.all([\n    execute(`npm link schematics`),\n    execute(`cd schematics`),\n    execute(`npm install`),\n    execute(`npm run build`),\n    execute(`npx schematics .:schematics --name=decaf`),\n  ])\n    .then((res) => res)\n    .catch((error) => error);\n}\n\n/**\n * Executes a shell command asynchronously.\n *\n * @param command - The shell command to execute.\n * @returns A Promise that resolves with the command's stdout output as a string if successful,\n *          or rejects with an error message if the command fails or produces stderr output.\n */\nasync function execute(command: string): Promise<string | void> {\n  try {\n    return await runCommand(command).promise;\n  } catch (error: any) {\n    logger.error(error?.message || error);\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction parseProjectName(value: string): string {\n  return value.toLowerCase();\n}\n\n/**\n * Validates if the given type value is a valid enum member of Types.\n *\n * @param value - The type value to validate.\n * @returns A boolean indicating whether the value is a valid Types enum member.\n */\nfunction validateType(value: Types): boolean {\n  return Object.values(Types).includes(value);\n}\n\n/**\n * Validates if the given project value is a valid enum member of Projects.\n *\n * @param value - The project value to validate.\n * @returns A boolean indicating whether the value is a valid Projects enum member.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction validateProject(value: string): boolean {\n  return Object.values(Projects).includes(value as Projects);\n}\n"]}

package/lib/cli-module.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Creates and returns a Command object for the Angular CLI module in decaf-ts.
+ * This function sets up a 'generate' command that can create various Angular artifacts.
+ *
+ * @returns {Command} A Command object configured with the 'generate' subcommand and its action.
+ *
+ * The command syntax is: generate <type> <name> [project]
+ * @param {Types} type - The type of artifact to generate (e.g., service, component, directive, page).
+ * @param {string} name - The name of the artifact to be generated.
+ * @param {Projects} [project=Projects.FOR_ANGULAR] - The project for which to generate the artifact.
+ *                   Defaults to the main Angular project if not specified.
+ *
+ * @throws {Error} If an invalid type is provided.
+ *
+ * @example
+ * // Usage in CLI
+ * // decaf-ts generate service my-service
+ * // decaf-ts generate component my-component for-angular-app
+ */
+export default function nest(): {
+    [key: string]: any;
+    args: string[];
+    version(str: string, flags?: string): /*elided*/ any;
+    command(name: string, desc?: string, opts?: import("commander").CommandOptions): /*elided*/ any;
+    arguments(desc: string): /*elided*/ any;
+    parseExpectedArgs(args: string[]): /*elided*/ any;
+    action(fn: (...args: any[]) => void): /*elided*/ any;
+    option(flags: string, description?: string, fn?: ((arg1: any, arg2: any) => void) | RegExp, defaultValue?: any): /*elided*/ any;
+    option(flags: string, description?: string, defaultValue?: any): /*elided*/ any;
+    allowUnknownOption(arg?: boolean): /*elided*/ any;
+    parse(argv: string[]): /*elided*/ any;
+    parseOptions(argv: string[]): import("commander").ParseOptionsResult;
+    opts(): {
+        [key: string]: any;
+    };
+    description(str: string, argsDescription?: {
+        [argName: string]: string;
+    }): /*elided*/ any;
+    description(): string;
+    alias(alias: string): /*elided*/ any;
+    alias(): string;
+    usage(str: string): /*elided*/ any;
+    usage(): string;
+    name(str: string): /*elided*/ any;
+    name(): string;
+    outputHelp(cb?: (str: string) => string): void;
+    help(cb?: (str: string) => string): never;
+};

package/lib/constants.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DECAF_ADAPTER_ID = exports.DECAF_MODULE_OPTIONS = void 0;
+exports.DECAF_MODULE_OPTIONS = "DecafModuleOptions";
+exports.DECAF_ADAPTER_ID = "DecafAdapter";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLG9CQUFvQixHQUFHLG9CQUFvQixDQUFDO0FBQzVDLFFBQUEsZ0JBQWdCLEdBQUcsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IERFQ0FGX01PRFVMRV9PUFRJT05TID0gXCJEZWNhZk1vZHVsZU9wdGlvbnNcIjtcbmV4cG9ydCBjb25zdCBERUNBRl9BREFQVEVSX0lEID0gXCJEZWNhZkFkYXB0ZXJcIjtcbiJdfQ==

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DECAF_MODULE_OPTIONS = "DecafModuleOptions";
+export declare const DECAF_ADAPTER_ID = "DecafAdapter";

package/lib/core-module.cjs

@@ -0,0 +1,69 @@
+"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); }
+};
+var DecafCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecafCoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("./constants.cjs");
+const LoggedClass_1 = require("@decaf-ts/logging/lib/LoggedClass");
+let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedClass_1.LoggedClass {
+    constructor(options, moduleRef) {
+        super();
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options) {
+        const typeOrmModuleOptions = {
+            provide: constants_1.DECAF_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const adapter = {
+            useFactory: async (opts) => {
+                return new opts.adapter(opts.conf, opts.alias);
+            },
+            provide: constants_1.DECAF_ADAPTER_ID,
+            durable: true,
+            scope: common_1.Scope.DEFAULT,
+            inject: [constants_1.DECAF_MODULE_OPTIONS],
+        };
+        const providers = [adapter, typeOrmModuleOptions];
+        const exports = [adapter];
+        return {
+            module: DecafCoreModule_1,
+            providers,
+            exports,
+        };
+    }
+    async onApplicationShutdown() {
+        const adapter = this.moduleRef.get(constants_1.DECAF_ADAPTER_ID);
+        try {
+            if (adapter) {
+                this.log.info("Shutting down");
+                await adapter.shutdown();
+            }
+        }
+        catch (e) {
+            this.log.error(`Failed to shutdown application`, e);
+        }
+    }
+};
+exports.DecafCoreModule = DecafCoreModule;
+exports.DecafCoreModule = DecafCoreModule = DecafCoreModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(constants_1.DECAF_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], DecafCoreModule);
+//# sourceMappingURL=data:application/json;base64,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