@expressots/shared 0.1.0

package/lib/cjs/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./env"), exports);
+__exportStar(require("./utils"), exports);

package/lib/cjs/types/config/index.d.ts

@@ -0,0 +1 @@
+export { Pattern, ExpressoConfig } from "./project-config";

package/lib/cjs/types/config/project-config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Enum representing different string patterns.
+ *
+ * - LOWER_CASE: Represents strings in all lowercase letters. E.g. "hello"
+ * - KEBAB_CASE: Represents strings separated by hyphens. E.g. "hello-world"
+ * - PASCAL_CASE: Represents strings where the first letter of each word is capitalized. E.g. "HelloWorld"
+ * - CAMEL_CASE: Represents strings where the first letter of the first word is lowercase and the first letter of subsequent words are capitalized. E.g. "helloWorld"
+ * @public API
+ */
+export declare const enum Pattern {
+    LOWER_CASE = "lowercase",
+    KEBAB_CASE = "kebab-case",
+    PASCAL_CASE = "PascalCase",
+    CAMEL_CASE = "camelCase"
+}
+/**
+ * The configuration object for the Expresso CLI.
+ * @property {Pattern} scaffoldPattern - The pattern to use when scaffolding files.
+ * @property {string} sourceRoot - The root directory for the source files.
+ * @property {boolean} opinionated - Whether or not to use the opinionated configuration.
+ * @property {IProviders} providers - Specific configuration for each provider added.
+ * @public API
+ */
+export interface ExpressoConfig {
+    scaffoldPattern: Pattern;
+    sourceRoot: string;
+    opinionated: boolean;
+    scaffoldSchematics?: {
+        entity?: string;
+        controller?: string;
+        usecase?: string;
+        dto?: string;
+        module?: string;
+        provider?: string;
+        middleware?: string;
+    };
+}

package/lib/cjs/types/env/cli-options.d.ts

@@ -0,0 +1,7 @@
+import { IConfigOptions } from "./interfaces";
+/**
+ * Matches the options passed in the command line
+ * @param args - The arguments passed in the command line
+ * @returns The options passed in the command line
+ */
+export declare function optionMatcher(args: Array<string>): IConfigOptions;

package/lib/cjs/types/env/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LINE_REGEX is a regular expression that matches a line in a .env file.
+ * It is used to parse the content of the .env file.
+ */
+export declare const LINE_REGEX: RegExp;
+/**
+ * ENV_VAR_REGEX is a regular expression that matches an environment variable in the command line.
+ * It is used to parse the options passed in the command line.
+ */
+export declare const ENV_VAR_REGEX: RegExp;

package/lib/cjs/types/env/env-options.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Module EnvOptions
+ * Responsible for setting the options for the dotenv configuration if provided otherwise it will use the default values.
+ */
+import { IConfigOptions } from "./interfaces";
+/**
+ * The options for the dotenv configuration.
+ */
+export declare const OPTIONS: IConfigOptions;

package/lib/cjs/types/env/environment.d.ts

@@ -0,0 +1,83 @@
+import { IConfigOptions, IConfigOutput, IEnvObject } from "./interfaces";
+/**
+ * Module to parse the .env.vault file
+ * @param options - The configuration options
+ * @returns The parsed object
+ */
+declare function _parseVault(options: IConfigOptions): IEnvObject;
+/**
+ * Module to verify and return the .env.vault file path
+ * @param options - The configuration options
+ * @returns The .env.vault file path
+ */
+declare function _vaultPath(options: any): any;
+/**
+ * Module to verify and return the DOTENV_KEY vault key
+ * @param options - The configuration options
+ * @returns The DOTENV_KEY as a string
+ */
+declare function _dotenvKey(options?: IConfigOptions): string;
+/**
+ * Module to get instructions for decrypting the .env.vault file
+ * @param result -
+ * @param dotenvKey
+ * @returns
+ */
+declare function _instructions(result: IConfigOutput, dotenvKey: string): {
+    ciphertext: string;
+    key: any;
+};
+/**
+ * Module responsible to resolve home path
+ * @param envPath - The path to resolve
+ * @returns The resolved path
+ */
+declare function _resolveHome(envPath: string): string;
+/**
+ * Module to load environment variables from .env.vault file
+ * @param options - The configuration options
+ * @returns The parsed object
+ */
+export declare function _configVault(options: IConfigOptions): IConfigOutput;
+/**
+ * Module to load environment variables from .env file
+ * @param options - The configuration options
+ * @returns The parsed object
+ * @public API
+ */
+export declare function config(options?: IConfigOptions): IConfigOutput;
+/**
+ * Module to load environment variables from .env file
+ * @param options - The configuration options
+ * @returns The parsed object
+ * @public API
+ */
+export declare function configDotenv(options?: IConfigOptions): IConfigOutput;
+/**
+ * Module to load environment variables from .env file
+ * @param envFile - The source of the .env file
+ * @returns The parsed object
+ * @public API
+ */
+export declare function parse(envFile: Buffer | string): Record<string, string>;
+/**
+ * Decrypts a base64 encoded string
+ * @param encrypted - The base64 encoded string to decrypt
+ * @param keyStr - The key to use for decryption
+ * @returns The decrypted string
+ * @public API
+ */
+export declare function decrypt(encrypted: string, keyStr: string): string;
+/**
+ * Populates the environment with the given parsed object
+ * @param envObject - The object to populate the environment with (e.g. process.env)
+ * @param parsed - The parsed object
+ * @param options - The configuration options
+ * @public API
+ */
+export declare function populate(envObject: IEnvObject, // Usually process.env
+parsed: IEnvObject, options?: IConfigOptions): void;
+/**
+ * Test swap for private functions
+ */
+export { _parseVault, _vaultPath, _dotenvKey, _instructions, _resolveHome };

package/lib/cjs/types/env/index.d.ts

@@ -0,0 +1,2 @@
+export { IEnvObject, IConfigOptions, IConfigOutput } from "./interfaces";
+export * from "./environment";

package/lib/cjs/types/env/interfaces.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Interface for config options
+ * @public API
+ */
+export interface IConfigOptions {
+    /**
+     * Default: `path.resolve(process.cwd(), '.env')`
+     *
+     * Specify a custom path if your file containing environment variables is located elsewhere.
+     * Can also be an array of strings, specifying multiple paths.
+     *
+     * example: `require('dotenv').config({ path: '/custom/path/to/.env' })`
+     * example: `require('dotenv').config({ path: ['/path/to/first.env', '/path/to/second.env'] })`
+     */
+    path?: string | Array<string> | URL;
+    /**
+     * Default: `utf8`
+     *
+     * Specify the encoding of your file containing environment variables.
+     *
+     * example: `require('dotenv').config({ encoding: 'latin1' })`
+     */
+    encoding?: string;
+    /**
+     * Default: `false`
+     *
+     * Turn on logging to help debug why certain keys or values are not being set as you expect.
+     *
+     * example: `require('dotenv').config({ debug: process.env.DEBUG })`
+     */
+    debug?: boolean;
+    /**
+     * Default: `false`
+     *
+     * Override any environment variables that have already been set on your machine with values from your .env file.
+     *
+     * example: `require('dotenv').config({ override: true })`
+     */
+    override?: boolean;
+    /**
+     * Default: `process.env`
+     *
+     * Specify an object to write your secrets to. Defaults to process.env environment variables.
+     *
+     * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+     */
+    envObject?: IEnvObject;
+    /**
+     * Default: `undefined`
+     *
+     * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file.
+     *
+     * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })`
+     */
+    vaultEnvKey?: string;
+}
+/**
+ * Interface for environment variables
+ * @public API
+ */
+export interface IEnvObject {
+    [name: string]: string;
+}
+/**
+ * Interface for dotenv parse output
+ * @public API
+ */
+export interface IConfigOutput {
+    error?: Error;
+    parsed?: IEnvObject;
+}

package/lib/cjs/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./config";
+export * from "./env";
+export * from "./utils";

package/lib/cjs/types/utils/compiler.d.ts

@@ -0,0 +1,17 @@
+import { Service } from "ts-node";
+import { ExpressoConfig } from "../config";
+export declare function printError(message: string, component: string): void;
+/**
+ * Singleton compiler class
+ */
+export declare class Compiler {
+    private static instance;
+    private constructor();
+    static get Instance(): Compiler;
+    getService(): Promise<Service>;
+    static interopRequireDefault(obj: any): {
+        default: any;
+    };
+    static findConfig(dir: string): Promise<string>;
+    static loadConfig(): Promise<ExpressoConfig>;
+}

package/lib/cjs/types/utils/index.d.ts

@@ -0,0 +1 @@
+export { Compiler } from "./compiler";

package/lib/cjs/types/utils/logger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Logger utility for dotenv
+ */
+export declare enum LogLevel {
+    Info = "info",
+    Warn = "warn",
+    Debug = "debug"
+}
+/**
+ * Log a message
+ * @param message - The message to log
+ * @param logLevel - The log level. Defaults to LogLevel.Info
+ */
+export declare function log(message: string, logLevel?: LogLevel): void;
+export declare function printError(message: string, component: string): void;
+export declare function printSuccess(message: string, component: string): void;
+export declare function printWarning(message: string, component?: string): void;
+export declare function printGenerateError(schematic: string, file: string): Promise<void>;
+export declare function printGenerateSuccess(schematic: string, file: string): Promise<void>;

package/lib/cjs/utils/compiler.js

@@ -0,0 +1,99 @@
+"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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+exports.printError = printError;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const node_fs_1 = require("node:fs");
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function printError(message, component) {
+    console.error(chalk_1.default.red(`${message}:`, chalk_1.default.bold(chalk_1.default.white(`[${component}] ❌`))));
+}
+/**
+ * The path to the expressots.config.ts file
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const EXPRESSOTS_CONFIG = path_1.default.join(process.cwd(), "expressots.config.ts");
+/**
+ * The config object
+ */
+let globalConfigObject = null;
+/**
+ * The ts-node register options
+ */
+const regOpt = {
+    compilerOptions: {
+        module: "commonjs",
+    },
+    moduleTypes: {
+        "**": "cjs",
+    },
+};
+/**
+ * Singleton compiler class
+ */
+class Compiler {
+    constructor() { }
+    static get Instance() {
+        if (!Compiler.instance) {
+            Compiler.instance = new Compiler();
+        }
+        return Compiler.instance;
+    }
+    async getService() {
+        const tsnode = await Promise.resolve().then(() => __importStar(require("ts-node")));
+        const compiler = tsnode.register(regOpt);
+        return compiler;
+    }
+    static interopRequireDefault(obj) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const module = require(obj);
+        return module && module.__esModule ? module : { default: module };
+    }
+    static async findConfig(dir) {
+        const configPath = path_1.default.join(dir, "expressots.config.ts");
+        const exists = (0, node_fs_1.existsSync)(configPath);
+        if (exists)
+            return configPath;
+        const parentDir = path_1.default.join(dir, "..");
+        if (parentDir === dir) {
+            printError("No config file found!", "expressots.config.ts");
+            process.exit(1);
+        }
+        return Compiler.findConfig(parentDir);
+    }
+    static async loadConfig() {
+        const compiler = await Compiler.Instance.getService();
+        compiler.enabled(true);
+        globalConfigObject = Compiler.interopRequireDefault(await Compiler.findConfig(process.cwd()));
+        compiler.enabled(false);
+        return globalConfigObject.default;
+    }
+}
+exports.Compiler = Compiler;

package/lib/cjs/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return compiler_1.Compiler; } });

package/lib/cjs/utils/logger.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+exports.log = log;
+exports.printError = printError;
+exports.printSuccess = printSuccess;
+exports.printWarning = printWarning;
+exports.printGenerateError = printGenerateError;
+exports.printGenerateSuccess = printGenerateSuccess;
+const process_1 = require("process");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Logger utility for dotenv
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Debug"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Log a message
+ * @param message - The message to log
+ * @param logLevel - The log level. Defaults to LogLevel.Info
+ */
+function log(message, logLevel = LogLevel.Info) {
+    switch (logLevel) {
+        case LogLevel.Info:
+            process_1.stdout.write(`[ExpressoTS][INFO] ${message}\n`);
+            break;
+        case LogLevel.Warn:
+            process_1.stdout.write(`[ExpressoTS][WARN] ${message}\n`);
+            break;
+        case LogLevel.Debug:
+            process_1.stdout.write(`[ExpressoTS][DEBUG] ${message}\n`);
+            break;
+    }
+}
+function printError(message, component) {
+    const formattedMessage = message ? `${message}: ` : ": ";
+    const formattedComponent = component ? `[${component}]` : "[]";
+    const output = chalk_1.default.red(`${formattedMessage}${chalk_1.default.bold(chalk_1.default.white(`${formattedComponent} ❌\n`))}`);
+    process_1.stdout.write(output);
+}
+function printSuccess(message, component) {
+    const formattedMessage = message ? `${message}: ` : ": ";
+    const formattedComponent = component ? `[${component}]` : "[]";
+    const output = chalk_1.default.green(`${formattedMessage}${chalk_1.default.bold(chalk_1.default.white(`${formattedComponent} ✔️\n`))}`);
+    process_1.stdout.write(output);
+}
+function printWarning(message, component) {
+    if (component === undefined) {
+        process_1.stdout.write(chalk_1.default.yellow(`${message} ⚠️\n`));
+        return;
+    }
+    process_1.stdout.write(chalk_1.default.yellow(`${message}:`, chalk_1.default.bold(chalk_1.default.white(`[${component}] ⚠️\n`))));
+}
+async function printGenerateError(schematic, file) {
+    const schematicFormatted = `[${schematic}]`.padEnd(14);
+    const fileNameFormatted = chalk_1.default.bold.white(`${file.split(".")[0]} not created! ❌\n`);
+    const output = chalk_1.default.redBright(schematicFormatted) + fileNameFormatted;
+    process_1.stdout.write(output);
+}
+async function printGenerateSuccess(schematic, file) {
+    const schematicFormatted = `[${schematic}]`.padEnd(14);
+    const fileNameFormatted = chalk_1.default.bold.white(`${file.split(".")[0]} created! ✔️\n`);
+    const output = chalk_1.default.greenBright(schematicFormatted) + fileNameFormatted;
+    process_1.stdout.write(output);
+}

package/lib/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "@expressots/shared",
+  "version": "0.0.1-beta.1",
+  "description": "Shared library for ExpressoTS modules 🐎",
+  "author": "Richard Zampieri <richard.zampieri@expresso-ts.com>",
+  "main": "./lib/cjs/index.js",
+  "types": "./lib/cjs/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/esm/types/index.d.ts",
+        "default": "./lib/esm/index.mjs"
+      },
+      "require": {
+        "types": "./lib/cjs/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "license": "MIT",
+  "homepage": "https://expresso-ts.com",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/expressots"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expressots/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/expressots/shared/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "expressots",
+    "nodejs",
+    "typescript",
+    "clean-architecture",
+    "typescript-framework",
+    "framework",
+    "server-side",
+    "backend",
+    "library"
+  ],
+  "engines": {
+    "node": ">=18.10.0"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "clean": "node scripts/rm.js lib",
+    "copy": "node scripts/copy.js package.json README.md CHANGELOG.md lib",
+    "build": "npm run clean && npm run build:cjs && npm run copy",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "release": "release-it",
+    "prepublish": "npm run build && npm pack",
+    "publish": "npm publish --tag latest",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "coverage": "jest --coverage",
+    "format": "prettier --write \"src/**/*.ts\" --cache",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix"
+  },
+  "dependencies": {
+    "reflect-metadata": "0.2.2",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.4.1",
+    "@commitlint/config-conventional": "19.2.2",
+    "@release-it/conventional-changelog": "8.0.1",
+    "@types/express": "4.17.21",
+    "@types/jest": "^29.5.13",
+    "@types/node": "20.14.10",
+    "@typescript-eslint/eslint-plugin": "7.16.1",
+    "@typescript-eslint/parser": "7.16.1",
+    "chalk": "^4.1.2",
+    "eslint": "8.57.0",
+    "eslint-config-prettier": "9.1.0",
+    "husky": "9.1.1",
+    "jest": "^29.7.0",
+    "prettier": "3.3.3",
+    "release-it": "17.6.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "5.5.3"
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore(release): ${version}"
+    },
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": false
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "infile": "CHANGELOG.md",
+        "preset": {
+          "name": "conventionalcommits",
+          "types": [
+            {
+              "type": "feat",
+              "section": "Features"
+            },
+            {
+              "type": "fix",
+              "section": "Bug Fixes"
+            },
+            {
+              "type": "perf",
+              "section": "Performance Improvements"
+            },
+            {
+              "type": "revert",
+              "section": "Reverts"
+            },
+            {
+              "type": "docs",
+              "section": "Documentation"
+            },
+            {
+              "type": "refactor",
+              "section": "Code Refactoring"
+            },
+            {
+              "type": "test",
+              "section": "Tests"
+            },
+            {
+              "type": "build",
+              "section": "Build System"
+            },
+            {
+              "type": "ci",
+              "section": "Continuous Integrations"
+            }
+          ]
+        }
+      }
+    }
+  }
+}