opticore-installer 1.2.49

package/dist/index.js

@@ -0,0 +1,951 @@
+#!/usr/bin/env node
+
+// src/core/installer.core.ts
+import { intro, cancel as cancel5 } from "@clack/prompts";
+import chalk6 from "chalk";
+import colors9 from "ansi-colors";
+
+// src/utils/console/welcomeMessage.util.ts
+import cfonts from "cfonts";
+import chalk from "chalk";
+var UWelcomeMessage = () => {
+  cfonts.say("OpticoreJS", {
+    font: "block",
+    align: "left",
+    colors: ["yellow", "#FF6B35"],
+    background: "transparent",
+    letterSpacing: 1,
+    lineHeight: 1,
+    space: true,
+    maxLength: "0"
+  });
+  const orange = chalk.bold.hex("#FF6B35");
+  const dim = chalk.bold.yellow;
+  console.log(`          ${orange("OPTICORE  F R A M E W O R K   I N S T A L L E R")}`);
+  console.log(`                ${dim("Create \xB7 Configure \xB7 Deploy")}
+`);
+  console.log(`   ${chalk.bold.dim("Documentation")}  ${chalk.underline.cyan("https://github.com/opticore/framework-installer")}
+`);
+};
+
+// src/domains/services/prompts/select/promptSelect.service.ts
+import { select, isCancel } from "@clack/prompts";
+
+// src/utils/operationCancelled.util.ts
+import { cancel } from "@clack/prompts";
+import colors from "ansi-colors";
+import fs from "fs";
+var UOperationCancelled = (arg) => {
+  cancel(colors.bgRed(colors.white("  Operation cancelled  ")));
+  if (arg) {
+    fs.rmSync(arg, { recursive: true, force: true });
+  }
+  process.exit(130);
+};
+
+// src/domains/services/prompts/select/promptSelect.service.ts
+var SPromptSelect = async (arg) => {
+  const outputSelect = await select(arg);
+  return isCancel(outputSelect) ? UOperationCancelled : outputSelect;
+};
+
+// src/domains/services/prompts/select/outputPromptSelect.service.ts
+var SOutputPromptSelect = async (arg) => {
+  return await SPromptSelect({
+    message: arg.message,
+    initialValue: arg.initialValue,
+    options: arg.options
+  });
+};
+
+// src/core/abstractions/enums/constants/generalMsg.constant.ts
+var CGeneralMsg = {
+  noDbCredentials: "You will have to manually set all the variable values in the .env file.",
+  starterMsg: "Which starter project would you like to use ?",
+  starterInitValue: "restfull_api_project",
+  starterOptionsRestFullLabel: "RestFull API project",
+  starterOptionsRestFullValue: "restfull_api_project",
+  starterOptionsRestFullHint: "OptiCoreJS app tailored to create a RestFull APIs",
+  projectNameMessage: "Enter the name of project :",
+  projectNamePlaceholder: "opticore",
+  projectNameInvalidValue: "Please the project name can't be empty.",
+  projectNameBadPattern: "Please enter a valide project name.",
+  wrong: "Something went wrong.",
+  existingProject: "already exist, please give it another name."
+};
+
+// src/core/abstractions/enums/constants/starterOptions.constant.ts
+var CStarterOptions = [
+  // { label: "RestFull API complete project", value: ["complete_restfull_project"], hint: "Everything you'll need to build a server render web project" },
+  { label: "Web project", value: ["web_project"], hint: "Everything you'll need to build a server render web project" },
+  { label: "Skeleton project", value: ["skeleton_project"], hint: "A lean OptiCoreJS application with the framework core" },
+  { label: CGeneralMsg.starterOptionsRestFullLabel, value: [CGeneralMsg.starterOptionsRestFullValue], hint: CGeneralMsg.starterOptionsRestFullHint },
+  // { label: "Complete restFull API project", value: ["complete_api_restfull_project"], hint: "OptiCoreJS app tailored to create a complete RestFull APIs" },
+  { label: "standard project", value: ["standard_project"], hint: "OptiCoreJS app tailored to create a standard Web project" }
+];
+
+// src/presentations/starter/starterOptions.starter.ts
+var StarterOptions = {
+  message: CGeneralMsg.starterMsg,
+  initialValue: [CGeneralMsg.starterInitValue],
+  options: CStarterOptions
+};
+
+// src/domains/services/prompts/text/promptText.service.ts
+import { text, isCancel as isCancel2 } from "@clack/prompts";
+var SPromptText = async (arg) => {
+  const textOutput = await text(arg.textOpt);
+  return isCancel2(textOutput) ? UOperationCancelled : textOutput;
+};
+
+// src/domains/services/validate.service.ts
+var SValidate = (value, messageInvalidValue, messageBadPattern, regex) => {
+  let pattern = new RegExp(regex);
+  if (!value) {
+    return messageInvalidValue;
+  }
+  if (!pattern.test(value)) {
+    return messageBadPattern;
+  }
+};
+
+// src/domains/services/prompts/text/outputPromptText.service.ts
+var SOutputPromptText = async (message, placeholder, messageInvalidValue, messageBadPattern, regex, projectPath, initialValue, defaultValue) => {
+  return await SPromptText({
+    textOpt: {
+      initialValue,
+      defaultValue,
+      message,
+      placeholder,
+      validate: (value) => SValidate(value, messageInvalidValue, messageBadPattern, regex)
+    },
+    projectPath
+  });
+};
+
+// src/presentations/starter/template.starter.ts
+import fs2 from "fs";
+import path from "path";
+import { promisify } from "util";
+
+// src/utils/logInfo.util.ts
+import { log } from "@clack/prompts";
+import chalk2 from "chalk";
+var ULogInfo = (logMessage) => {
+  log.info(chalk2.dim(logMessage));
+};
+
+// src/utils/logError.util.ts
+import { log as log2 } from "@clack/prompts";
+import chalk3 from "chalk";
+var ULogError = (logMessage) => {
+  log2.error(chalk3.red(logMessage));
+};
+
+// src/presentations/starter/template.starter.ts
+var templateStarter = async (projectName) => {
+  const mkdir = promisify(fs2.mkdir);
+  if (projectName) {
+    const currentPath = process.cwd();
+    const projectPath = path.join(currentPath, projectName);
+    if (fs2.existsSync(projectPath)) {
+      ULogInfo(`${projectName} ${CGeneralMsg.existingProject}`);
+      fs2.rmSync(projectPath, { recursive: true, force: true });
+      process.exit(1);
+    } else {
+      fs2.mkdirSync(projectPath);
+    }
+    const normalizedPath = path.normalize(projectPath);
+    await mkdir(normalizedPath, { recursive: true });
+    const normalizedCurrentPath = path.normalize(currentPath);
+    await mkdir(normalizedCurrentPath, { recursive: true });
+    return { normalizedCurrentPath, normalizedPath };
+  } else {
+    ULogError(CGeneralMsg.wrong);
+    process.exit();
+  }
+};
+
+// src/core/installer.core.ts
+import * as process5 from "process";
+
+// src/presentations/middlewares/selectDB.middleware.ts
+import { cancel as cancel4 } from "@clack/prompts";
+import colors8 from "ansi-colors";
+import process4 from "process";
+
+// src/core/abstractions/enums/constants/selectDBMessage.constant.ts
+var CSelectDBMessage = {
+  dbSelect: "Which database would you use ?",
+  dbCredentials: "Do you want create database credentials in .env file ?",
+  createDBCredentialsLabel: "Create database credentials",
+  createDBCredentialsValue: "create_db_credentials",
+  noDBCredentialsLabel: "No database credentials",
+  noDBCredentialsValue: "no_db_credentials"
+};
+
+// src/core/abstractions/enums/constants/dbNameLabel.constant.ts
+var CDbNameLabel = {
+  mysql: "MySQL",
+  mongodb: "Mongo DB",
+  postgresql: "Postgres",
+  oracle: "Oracle",
+  otherDb: "Other database",
+  createDbCredentials: "Create database credentials",
+  noDbCredentials: "No database credentials",
+  messageDBUser: "Enter your user database :",
+  messageDBPwd: "Enter the password of database :",
+  messageDBName: "Enter the name of database :",
+  placeholderDBUser: "user",
+  placeholderDBHost: "localhost",
+  placeholderDBName: "db_toto",
+  pwdMask: "*",
+  dbUserInvalidValue: "Please user database can't be empty.",
+  dbPwdInvalidValue: "Please a database password can't be empty.",
+  dbHostInvalidValue: "Please a database host can't be empty.",
+  dbNameInvalidValue: "Please database name can't be empty.",
+  dbUserBadPattern: "Please enter a valide user database.",
+  dbHostBadPattern: "Please enter a valide database host.",
+  dbPwdBadPattern: "Please enter a valide database password.",
+  dbNameBadPattern: "Please enter a valide database name.",
+  messageDBHost: "Enter the host of database :",
+  messageDBPort: "Enter the port of database :",
+  placeholderDBPort: "mysql: 3306",
+  dbPortInvalidValue: "Please a database port can't be empty.",
+  dbPortBadPattern: "Please enter a valide database port."
+};
+
+// src/core/abstractions/enums/constants/dbNameValue.constant.ts
+var CDbNameValue = {
+  mysql: "mysql",
+  mongodb: "mongodb",
+  postgresql: "postgresql",
+  oracle: "oracle",
+  otherDb: "other_db",
+  createDbCredentials: "create_db_credentials",
+  noDbCredentials: "no_db_credentials"
+};
+
+// src/presentations/middlewares/dbCredentials.middleware.ts
+import colors3 from "ansi-colors";
+import process3 from "process";
+import { cancel as cancel3 } from "@clack/prompts";
+
+// src/domains/services/promptsDBCredentials.service.ts
+import process2 from "process";
+import { cancel as cancel2 } from "@clack/prompts";
+import colors2 from "ansi-colors";
+
+// src/domains/services/prompts/password/promptPassword.service.ts
+import { password, isCancel as isCancel3 } from "@clack/prompts";
+var SPromptPassword = async (arg) => {
+  const outputConfirm = await password(arg);
+  return isCancel3(outputConfirm) ? UOperationCancelled : outputConfirm;
+};
+
+// src/domains/services/prompts/password/outputPromptPassword.service.ts
+var SOutputPromptPassword = async (message) => {
+  return await SPromptPassword({
+    message,
+    mask: "*",
+    validate: (value) => SValidate(
+      value,
+      "The password is required",
+      "The password can not be blank",
+      "[a-zA-Z0-9\\P{Z}]"
+    )
+  });
+};
+
+// src/domains/services/promptsDBCredentials.service.ts
+var SPromptsDBCredentials = class {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  async promptTextDatabaseUser() {
+    const user = await SOutputPromptText(
+      CDbNameLabel.messageDBUser,
+      CDbNameLabel.placeholderDBUser,
+      CDbNameLabel.dbUserInvalidValue,
+      CDbNameLabel.dbUserBadPattern,
+      "^[a-zA-Z0-9]+$",
+      this.projectPath
+    );
+    if (user instanceof Function) {
+      cancel2(colors2.bgRed(colors2.white("  Operation cancelled  ")));
+      process2.exit(130);
+    } else {
+      return user;
+    }
+  }
+  async promptPasswordDatabasePWD() {
+    const password2 = await SOutputPromptPassword(
+      CDbNameLabel.messageDBPwd
+    );
+    if (password2 instanceof Function) {
+      cancel2(colors2.bgRed(colors2.white("  Operation cancelled  ")));
+      process2.exit(130);
+    } else {
+      return password2;
+    }
+  }
+  async promptTextDatabaseHost() {
+    const host = await SOutputPromptText(
+      CDbNameLabel.messageDBHost,
+      CDbNameLabel.placeholderDBHost,
+      CDbNameLabel.dbHostInvalidValue,
+      CDbNameLabel.dbHostBadPattern,
+      "^[a-zA-Z]+$",
+      this.projectPath
+    );
+    if (host instanceof Function) {
+      cancel2(colors2.bgRed(colors2.white("  Operation cancelled  ")));
+      process2.exit(130);
+    } else {
+      return host;
+    }
+  }
+  async promptTextDatabasePort() {
+    const port = await SOutputPromptText(
+      CDbNameLabel.messageDBPort,
+      CDbNameLabel.placeholderDBPort,
+      CDbNameLabel.dbPortInvalidValue,
+      CDbNameLabel.dbPortBadPattern,
+      "^[0-9]+$",
+      this.projectPath
+    );
+    if (port instanceof Function) {
+      cancel2(colors2.bgRed(colors2.white("  Operation cancelled  ")));
+      process2.exit(130);
+    } else {
+      return port;
+    }
+  }
+  async promptTextDatabaseName() {
+    const dbName = await SOutputPromptText(
+      CDbNameLabel.messageDBName,
+      CDbNameLabel.placeholderDBName,
+      CDbNameLabel.dbNameInvalidValue,
+      CDbNameLabel.dbNameBadPattern,
+      "^[a-zA-Z0-9]+$",
+      this.projectPath
+    );
+    if (dbName instanceof Function) {
+      cancel2(colors2.bgRed(colors2.white("  Operation cancelled  ")));
+      process2.exit(130);
+    } else {
+      return dbName;
+    }
+  }
+};
+
+// src/presentations/middlewares/dbCredentials.middleware.ts
+var MDbCredentials = async (projectPath, currentPath, projectName) => {
+  const outputDBCredentials = await SOutputPromptSelect({
+    message: CSelectDBMessage.dbCredentials,
+    initialValue: [CDbNameLabel.createDbCredentials],
+    options: [
+      { label: CDbNameLabel.createDbCredentials, value: [CDbNameValue.createDbCredentials] },
+      { label: CDbNameLabel.noDbCredentials, value: [CDbNameValue.noDbCredentials] }
+    ]
+  });
+  let databaseUser;
+  let databasePassword;
+  let databaseHost;
+  let databasePort;
+  let databaseName;
+  if (outputDBCredentials instanceof Function) {
+    cancel3(colors3.bgRed(colors3.white("  Operation cancelled  ")));
+    process3.exit(130);
+  } else {
+    let credentials;
+    outputDBCredentials.map(async (outputDBCredential) => {
+      credentials = outputDBCredential;
+    });
+    if (credentials === CDbNameValue.noDbCredentials) {
+      return CDbNameValue.noDbCredentials;
+    } else {
+      const dbCredentials = new SPromptsDBCredentials(projectPath);
+      databaseUser = await dbCredentials.promptTextDatabaseUser();
+      databasePassword = await dbCredentials.promptPasswordDatabasePWD();
+      databasePort = await dbCredentials.promptTextDatabasePort();
+      databaseHost = await dbCredentials.promptTextDatabaseHost();
+      databaseName = await dbCredentials.promptTextDatabaseName();
+      return {
+        credentials,
+        databaseUser,
+        databasePassword,
+        databasePort,
+        databaseHost,
+        databaseName
+      };
+    }
+  }
+};
+
+// src/domains/services/transformDbCredentialsToFusedParams.service.ts
+function transformDbCredentialsToFusedParams(credentials) {
+  if (credentials === CDbNameValue.noDbCredentials) {
+    return CDbNameValue.noDbCredentials;
+  } else {
+    return credentials;
+  }
+}
+
+// src/domains/services/fetchCredentials.service.ts
+var SFetchCredentials = async (projectPath, currentPath, projectName) => {
+  let dbParams;
+  let envParams;
+  let fetchParams = "";
+  const dbCredentials = await MDbCredentials(projectPath, currentPath, projectName);
+  const params = transformDbCredentialsToFusedParams(dbCredentials);
+  if (params === CDbNameValue.noDbCredentials) {
+    return params;
+  } else {
+    const credParams = params;
+    dbParams = {
+      databaseHost: credParams.databaseHost,
+      databaseName: credParams.databaseName,
+      databasePassword: credParams.databasePassword,
+      databasePort: credParams.databasePort,
+      databaseUser: credParams.databaseUser,
+      projectPath
+    };
+    envParams = {
+      dbName: credParams.databaseName,
+      dbUser: credParams.databaseUser,
+      dbPwd: credParams.databasePassword,
+      dbHost: credParams.databaseHost,
+      dbPort: credParams.databasePort
+    };
+    const allParams = { dbCredentials, fetchParams, dbParams, envParams };
+    return allParams;
+  }
+};
+
+// src/presentations/starter/projectCreation.starter.ts
+import path2 from "path";
+import fs3 from "fs";
+import cp from "child_process";
+
+// src/utils/console/endingMessage.info.ts
+import chalk4 from "chalk";
+import { outro, log as log3 } from "@clack/prompts";
+function endingMessageInfo(projectName) {
+  log3.success(chalk4.green.bold("Your OpticoreJs project has been created successfully!"));
+  console.log(`
+   ${chalk4.bold("Next steps:")}`);
+  console.log(`   ${chalk4.dim("\u276F")} cd ${chalk4.cyan(projectName)}`);
+  console.log(`   ${chalk4.dim("\u276F")} ${chalk4.cyan("npm run start:dev")}
+`);
+  console.log(`   ${chalk4.dim("NB: Before running app, make sure to define in .env file application host and port.")}
+`);
+  outro(chalk4.dim("To install opticore components: ") + chalk4.green("npx opticore list"));
+}
+
+// src/presentations/starter/projectCreation.starter.ts
+import { promisify as promisify2 } from "util";
+
+// src/applications/services/packagesVersion.service.ts
+var GetLatestVersion = async (exec, pkgName) => {
+  try {
+    const { stdout } = await exec(`npm view ${pkgName} version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+};
+
+// src/applications/services/updateDependencies.service.ts
+var UpdateOpticoreDeps = async (exec, deps) => {
+  const updated = { ...deps };
+  const opticorePackages = Object.keys(deps).filter((name) => name.startsWith("opticore-"));
+  await Promise.all(opticorePackages.map(async (name) => {
+    const latest = await GetLatestVersion(exec, name);
+    if (latest) updated[name] = `^${latest}`;
+  }));
+  return updated;
+};
+
+// src/presentations/starter/projectCreation.starter.ts
+var SProjectCreation = async (gitRepo, projectPath, currentPath, projectName) => {
+  let ora = (await import("ora")).default;
+  const exec = promisify2(cp.exec);
+  const rm = promisify2(fs3.rm);
+  const gitSpinner = ora("Downloading files and project creation").start();
+  try {
+    await exec(`git clone --depth 1 ${gitRepo} ${projectPath} --quiet`);
+    gitSpinner.succeed();
+    const cleanSpinner = ora("Removing useless files").start();
+    await exec(`rm -rf ${path2.join(projectPath, ".git")}`);
+    const rmGit = rm(path2.join(projectPath, ".git"), { recursive: true, force: true });
+    const rmBin = rm(path2.join(currentPath, "opticore-installer"), { recursive: true, force: true });
+    await Promise.all([rmGit, rmBin]);
+    const escapedPath = projectPath.replace(/^"(.*)"$/, "$1");
+    process.chdir(escapedPath);
+    const pkgPath = path2.join(escapedPath, "package.json");
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    if (pkg.dependencies?.["opticore-feature-module"]) {
+      pkg.dependencies["opticore-feature-component"] = pkg.dependencies["opticore-feature-module"];
+      delete pkg.dependencies["opticore-feature-module"];
+    }
+    if (pkg.dependencies) pkg.dependencies = await UpdateOpticoreDeps(exec, pkg.dependencies);
+    if (pkg.devDependencies) pkg.devDependencies = await UpdateOpticoreDeps(exec, pkg.devDependencies);
+    fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
+    const lockPath = path2.join(escapedPath, "package-lock.json");
+    if (fs3.existsSync(lockPath)) fs3.unlinkSync(lockPath);
+    await exec("npm uninstall ora ansi-colors cli-spinner dotenv gradient-string util tsup path fs node ts-node tslib @types/cli-spinner @clack/prompts");
+    cleanSpinner.succeed();
+    const npmSpinner = ora("Installing dependencies").start();
+    await exec("npm install");
+    npmSpinner.succeed();
+    fs3.writeFileSync(path2.join(escapedPath, ".npmrc"), "loglevel=silent\n");
+    endingMessageInfo(projectName);
+  } catch (err) {
+    console.log("err is : ", err);
+    process.exit();
+  }
+};
+
+// src/core/abstractions/enums/constants/projectTemplatePath.constant.ts
+var CProjectTemplatePath = {
+  mysql: "https://github.com/guyzoum77/opticore-api-restfull-template-mysql.git",
+  postgresql: "https://github.com/guyzoum77/opticore-api-restfull-template-postgresdb.git",
+  mongodb: "https://github.com/guyzoum77/opticore-api-restfull-template-mongodb.git",
+  oracle: "https://github.com/guyzoum77/opticore-api-restfull-template-oracle.git",
+  nodbcredentials: "https://github.com/guyzoum77/opticore-api-restfull-template-no-db-credential.git",
+  otherdb: "https://github.com/guyzoum77/opticore-api-restfull-template-other-db.git"
+};
+
+// src/domains/services/updateEnv.service.ts
+import fs4 from "fs";
+var SUpdateEnv = class {
+  arg;
+  argumentConnection;
+  constructor(arg, argumentConnection) {
+    this.arg = arg;
+    this.argumentConnection = argumentConnection;
+    this.__init();
+  }
+  /**
+   *
+   * @private
+   */
+  __init() {
+    const envFileLines = fs4.readFileSync("config/env/.env", "utf8").split("\n");
+    this.updateDatabaseSection(envFileLines, this.arg);
+    this.updateArgConnexionSection(envFileLines, this.argumentConnection);
+    fs4.writeFileSync("config/env/.env", envFileLines.join("\n"));
+  }
+  /**
+   *
+   * @param envFileLines
+   * @param arg
+   * @protected
+   */
+  updateDatabaseSection(envFileLines, arg) {
+    const sectionHeader = "#DATABASE";
+    const sectionStart = envFileLines.findIndex((line) => line.trim() === sectionHeader);
+    if (sectionStart === -1) {
+      console.warn(`Section ${sectionHeader} not found in .env file`);
+      return;
+    }
+    for (let i = sectionStart + 1; i < envFileLines.length; i++) {
+      const line = envFileLines[i].trim();
+      if (line.startsWith("#") && line !== sectionHeader) {
+        break;
+      }
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      const [key] = line.split("=");
+      switch (key) {
+        case "DATA_BASE_NAME":
+          envFileLines[i] = `${key}=${arg.dbName ?? ""}`;
+          break;
+        case "DATA_BASE_USER":
+          envFileLines[i] = `${key}=${arg.dbUser ?? ""}`;
+          break;
+        case "DATA_BASE_PASSWORD":
+          envFileLines[i] = `${key}=${arg.dbPwd ?? ""}`;
+          break;
+        case "DATA_BASE_HOST":
+          envFileLines[i] = `${key}=${arg.dbHost ?? ""}`;
+          break;
+        case "DATA_BASE_PORT":
+          envFileLines[i] = `${key}=${arg.dbPort ?? ""}`;
+          break;
+      }
+    }
+  }
+  /**
+   *
+   * @param envFileLines
+   * @param argumentConnection
+   * @protected
+   */
+  updateArgConnexionSection(envFileLines, argumentConnection) {
+    const sectionHeader = "#ARG CONNEXION";
+    const sectionStart = envFileLines.findIndex((line) => line.trim() === sectionHeader);
+    if (sectionStart === -1) {
+      console.warn(`Section ${sectionHeader} not found in .env file`);
+      return;
+    }
+    if (argumentConnection === void 0) {
+      return;
+    }
+    let found = false;
+    for (let i = sectionStart + 1; i < envFileLines.length; i++) {
+      const line = envFileLines[i].trim();
+      if (line.startsWith("#") && line !== sectionHeader) {
+        break;
+      }
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      const [key] = line.split("=");
+      if (key === "ARGUMENTS_DATABASE_CONNECTION") {
+        envFileLines[i] = `${key}=${argumentConnection ?? ""}`;
+        found = true;
+        break;
+      }
+    }
+    if (!found && argumentConnection !== null) {
+      const insertPosition = sectionStart + 1;
+      envFileLines.splice(insertPosition, 0, `ARGUMENTS_DATABASE_CONNECTION=${argumentConnection}`);
+    }
+  }
+};
+
+// src/presentations/middlewares/templateProject/templateProject.middleware.ts
+var MTemplateProject = async (repoGit, projectPath, currentPath, callback, arg, projectName, argumentConnection) => {
+  await SProjectCreation(repoGit, projectPath, currentPath, projectName);
+  callback;
+  new SUpdateEnv(arg, argumentConnection);
+};
+
+// src/presentations/middlewares/database/createMongo.database.ts
+import fs6 from "fs";
+import colors5 from "ansi-colors";
+import { MongoClient } from "mongodb";
+
+// src/utils/logSuccess.util.ts
+import { log as log4 } from "@clack/prompts";
+import chalk5 from "chalk";
+var ULogSuccess = (logMessage) => {
+  log4.success(chalk5.green(logMessage));
+};
+
+// src/core/abstractions/enums/constants/mongoOutputText.constant.ts
+var CMongoText = {
+  msg: "Enter a collection of database :",
+  pHolder: "db_toto",
+  invalidValue: "Please collection's name can't be empty.",
+  badPattern: "Please enter a valide collection's name.",
+  unReachable: "Sorry, the database couldn't be created. In MongoDB, a database is not created until it gets content! MongoDB waits until you have created a collection (table), with at least one document (record) before it actually creates the database (and collection)."
+};
+
+// src/applications/exceptions/handledMongoDB.exception.ts
+import colors4 from "ansi-colors";
+import fs5 from "fs";
+var handledMongoDBException = (e, databasePort, databaseHost, projectPath) => {
+  if (e.code === 18) {
+    console.error(`${colors4.red(`Authentication failed, be sure the credentials is correct!`)}`);
+    fs5.rmSync(projectPath, { recursive: true, force: true });
+    process.exit();
+  }
+  if (e.cause.code === "ERR_INVALID_URL") {
+    console.error(`${colors4.red(`Unable to parse ${databaseHost}:${databasePort} with URL`)}`);
+    fs5.rmSync(projectPath, { recursive: true, force: true });
+    process.exit();
+  }
+  if (e.code === void 0) {
+    console.error(`${colors4.red(`MongoServerSelectionError: getaddrinfo EAI_AGAIN (${databaseHost} is not allow to database connection)`)}`);
+    fs5.rmSync(projectPath, { recursive: true, force: true });
+    process.exit();
+  }
+};
+
+// src/core/config/uri/configMongoUrl.config.ts
+import dotenv from "dotenv";
+var configMongoUrlConfig = (databaseHost, databasePort) => {
+  return typeof databasePort === "number" || !isNaN(databasePort) || isFinite(databasePort) ? `mongodb://${databaseHost}:${databasePort}/` : `mongodb://${databaseHost}:${dotenv.config().parsed.DATA_BASE_PORT}/`;
+};
+
+// src/core/config/paramters/mongoClient.parameter.ts
+import dotenv2 from "dotenv";
+var PMongoClient = (databaseUser, databasePassword) => {
+  return {
+    auth: {
+      username: databaseUser ?? dotenv2.config().parsed.DATA_BASE_USER,
+      password: databasePassword ?? dotenv2.config().parsed.DATA_BASE_PASSWORD
+    }
+  };
+};
+
+// src/presentations/middlewares/database/createMongo.database.ts
+var createMongoDatabase = async (arg) => {
+  try {
+    const client = new MongoClient(configMongoUrlConfig(arg.dbHost, arg.dbPort), PMongoClient(arg.dbUser, arg.dbPwd));
+    await client.connect();
+    const mongoOutputText = await SOutputPromptText(CMongoText.msg, CMongoText.pHolder, CMongoText.invalidValue, CMongoText.badPattern, arg.projectPath);
+    if (mongoOutputText) {
+      const db = client.db(arg.dbName);
+      typeof mongoOutputText === "string" ? await db.createCollection(mongoOutputText) : (() => {
+        console.error(mongoOutputText);
+        process.exit();
+      });
+      ULogSuccess(`${colors5.green(`Your database ${colors5.bgGreen(`${colors5.white(`${arg.dbName}`)}`)} has been created successfully.`)}`);
+    } else {
+      ULogInfo(CMongoText.unReachable);
+      fs6.rmSync(arg.projectPath, { recursive: true, force: true });
+      process.exit(0);
+    }
+  } catch (e) {
+    handledMongoDBException(e, arg.dbPort, arg.dbHost, arg.projectPath);
+  }
+};
+
+// src/presentations/middlewares/database/createPostgres.database.ts
+import { Client } from "pg";
+
+// src/core/config/paramters/postgres.paramaters.ts
+import dotenv3 from "dotenv";
+var PPostgres = (arg) => {
+  return {
+    host: arg.host ?? dotenv3.config()?.parsed?.DATA_BASE_HOST,
+    user: arg.user ?? dotenv3.config()?.parsed?.DATA_BASE_USER,
+    password: arg.password ?? dotenv3.config()?.parsed?.DATA_BASE_PASSWORD,
+    port: arg.port ?? dotenv3.config()?.parsed?.DATA_BASE_PORT
+  };
+};
+
+// src/applications/exceptions/handledPostgres.exception.ts
+import colors6 from "ansi-colors";
+import fs7 from "fs";
+var handledPostgresException = (arg, err) => {
+  console.error(`${colors6.red(`An error occurred while creating the database : ${err}`)}`);
+  fs7.rmSync(arg.projectName, { recursive: true, force: true });
+  process.exit(0);
+};
+
+// src/presentations/middlewares/database/createPostgres.database.ts
+async function createPostgresDatabase(arg) {
+  try {
+    const client = new Client(PPostgres(arg));
+    await client.connect();
+    await client.query(`CREATE DATABASE "${arg.database}";`);
+    await client.end();
+  } catch (err) {
+    handledPostgresException(arg, err);
+  }
+}
+
+// src/presentations/middlewares/database/createMySQL.database.ts
+import mySQL from "mysql2/promise";
+
+// src/core/config/paramters/mysql.parameters.ts
+import dotenv4 from "dotenv";
+var PMysql = (arg) => {
+  return {
+    host: arg.dbHost ?? dotenv4.config()?.parsed?.DATA_BASE_HOST,
+    user: arg.dbUser ?? dotenv4.config()?.parsed?.DATA_BASE_USER,
+    password: arg.dbPwd ?? dotenv4.config()?.parsed?.DATA_BASE_PASSWORD,
+    port: arg.dbPort ?? parseInt(dotenv4.config()?.parsed?.DATA_BASE_PORT)
+  };
+};
+
+// src/applications/exceptions/handledMySQL.exception.ts
+import fs8 from "fs";
+import colors7 from "ansi-colors";
+var handledMySQLException = (arg, err) => {
+  fs8.rmSync(arg.projectPath, { recursive: true, force: true });
+  switch (err.code) {
+    case "ER_NOT_SUPPORTED_AUTH_MODE":
+      console.error(`${colors7.red(`Client does not support authentication protocol requested by server. Please try to verify your database credentials.`)}`);
+      break;
+    case "ERR_SOCKET_BAD_PORT":
+      console.error(`${colors7.red(`${err.message}.`)}`);
+      break;
+    case "ERR_INVALID_ARG_TYPE":
+      console.error(`${colors7.red(`${err.message}.`)}`);
+      break;
+    case "EAI_AGAIN":
+      console.error(`${colors7.red(`${err.message}.`)}`);
+      break;
+    case "ECONNREFUSED":
+      console.error(`${colors7.red(`${err.message}. Try to check if the port is correct.`)}`);
+      break;
+    default:
+      console.error();
+      break;
+  }
+  console.error(`${colors7.red(`An error occurred while creating the database : ${err.message}`)}`);
+  fs8.rmSync(arg.projectPath, { recursive: true, force: true });
+  process.exit(0);
+};
+
+// src/presentations/middlewares/database/createMySQL.database.ts
+async function createMySQLDatabase(arg) {
+  let connection;
+  try {
+    connection = await mySQL.createConnection(PMysql(arg));
+    await connection.connect();
+    const createDatabaseQuery = `CREATE DATABASE IF NOT EXISTS ${arg.dbName}`;
+    await connection.query(createDatabaseQuery);
+    await connection.end();
+  } catch (err) {
+    handledMySQLException(arg, err);
+  }
+}
+
+// src/core/abstractions/enums/constants/connectionProperties.constant.ts
+var CConnectionProperties = "connection_limit=5&socket_timeout=3";
+
+// src/presentations/middlewares/selectDB.middleware.ts
+var MSelectDB = async (projectPath, currentPath, projectName) => {
+  const dbSelect = await SOutputPromptSelect({
+    message: CSelectDBMessage.dbSelect,
+    initialValue: [CDbNameLabel.mysql],
+    options: [
+      { label: CDbNameLabel.mysql, value: [CDbNameValue.mysql] },
+      { label: CDbNameLabel.mongodb, value: [CDbNameValue.mongodb] },
+      { label: CDbNameLabel.postgresql, value: [CDbNameValue.postgresql] },
+      { label: CDbNameLabel.oracle, value: [CDbNameValue.oracle] },
+      { label: CDbNameLabel.otherDb, value: [CDbNameValue.otherDb] }
+    ]
+  });
+  if (dbSelect instanceof Function) {
+    cancel4(colors8.bgRed(colors8.white("  Operation cancelled  ")));
+    process4.exit(130);
+  } else {
+    const params = await SFetchCredentials(projectPath, currentPath, projectName);
+    if (params.dbCredentials === void 0) {
+      let dbChosen = [];
+      dbSelect.map(async (item) => {
+        switch (item) {
+          case CDbNameValue.mysql:
+            await SProjectCreation(CProjectTemplatePath.mysql, projectPath, currentPath, projectName);
+            break;
+          case CDbNameValue.postgresql:
+            await SProjectCreation(CProjectTemplatePath.postgresql, projectPath, currentPath, projectName);
+            break;
+          case CDbNameValue.mongodb:
+            await SProjectCreation(CProjectTemplatePath.mongodb, projectPath, currentPath, projectName);
+            break;
+          case CDbNameValue.oracle:
+            await SProjectCreation(CProjectTemplatePath.oracle, projectPath, currentPath, projectName);
+            break;
+          case CDbNameValue.otherDb:
+            await SProjectCreation(CProjectTemplatePath.otherdb, projectPath, currentPath, projectName);
+            break;
+        }
+        dbChosen.push(item);
+      });
+      return dbChosen;
+    } else {
+      dbSelect.map(async (item) => {
+        switch (item) {
+          case CDbNameValue.mysql:
+            await MTemplateProject(
+              CProjectTemplatePath.mysql,
+              projectPath,
+              currentPath,
+              async () => await createMySQLDatabase(
+                //@ts-ignore
+                params.dbParams
+              ),
+              params.envParams,
+              projectName,
+              CConnectionProperties
+            );
+            break;
+          case CDbNameValue.postgresql:
+            await MTemplateProject(
+              CProjectTemplatePath.postgresql,
+              projectPath,
+              currentPath,
+              async () => await createPostgresDatabase(
+                //@ts-ignore
+                params.dbParams
+              ),
+              params.envParams,
+              projectName
+            );
+            break;
+          case CDbNameValue.mongodb:
+            await MTemplateProject(
+              CProjectTemplatePath.mongodb,
+              projectPath,
+              currentPath,
+              async () => await createMongoDatabase(params),
+              params.envParams,
+              projectName
+            );
+            break;
+          case CDbNameValue.oracle:
+            await MTemplateProject(
+              CProjectTemplatePath.oracle,
+              projectPath,
+              currentPath,
+              async () => {
+              },
+              params.envParams,
+              projectName
+            );
+            break;
+          case CDbNameValue.otherDb:
+            await MTemplateProject(
+              CProjectTemplatePath.otherdb,
+              projectPath,
+              currentPath,
+              async () => {
+              },
+              params.envParams,
+              projectName
+            );
+            break;
+        }
+      });
+    }
+  }
+};
+
+// src/domains/services/shellEscape.service.ts
+var SShellEscape = (str) => {
+  return `"${str.replace(/(["$`\\])/g, "\\$1")}"`;
+};
+
+// src/core/installer.core.ts
+var installerCore = async () => {
+  let projectName;
+  UWelcomeMessage();
+  intro(chalk6.bgYellow.black("  Opticore Framework Installer  "));
+  const starter = await SOutputPromptSelect(StarterOptions);
+  starter instanceof Function ? (() => {
+    cancel5(colors9.bgRed(colors9.white("  Operation cancelled  ")));
+    process5.exit(130);
+  })() : starter.map(async (value) => {
+    switch (value) {
+      case CGeneralMsg.starterInitValue:
+        projectName = await SOutputPromptText(
+          CGeneralMsg.projectNameMessage,
+          CGeneralMsg.projectNamePlaceholder,
+          CGeneralMsg.projectNameInvalidValue,
+          CGeneralMsg.projectNameBadPattern,
+          "^[a-zA-Z0-9]+$"
+        );
+        if (typeof projectName === "string") {
+          const tpl = await templateStarter(projectName);
+          const escapedProjectPath = SShellEscape(tpl.normalizedPath);
+          const escapedCurrentPath = SShellEscape(tpl.normalizedCurrentPath);
+          await MSelectDB(escapedProjectPath, escapedCurrentPath, projectName);
+        }
+        break;
+    }
+  });
+};
+
+// src/index.ts
+(async () => await installerCore())();