@xrystal/core 3.2.3

package/README.md

@@ -0,0 +1 @@
+##  **DOCUMENT**

package/bin/constants/index.mjs

@@ -0,0 +1,14 @@
+import path from 'path'
+
+import { __filename, __dirname } from '../helpers/index.mjs'
+
+export const packageName = 'tmp-project-tool'
+
+export const tmpFileDefaultMainFolderName = 'x'
+export const tmpFileDefaultName = 'tmp'
+export const tmpFileDefaultExt = '.yml'
+
+export const defaultTmpFilePath = path.resolve(__dirname(__filename(import.meta.url)), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
+export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
+
+export const templateRepoUri = 'https://github.com/xdloper/xastral-general-project-tmp.git'

package/bin/helpers/index.mjs

@@ -0,0 +1,83 @@
+import path from 'path'
+import fs from 'fs'
+import url, { fileURLToPath } from 'url'
+import Handlebars from 'handlebars'
+
+export function __filename(fileUrl) {
+    return fileURLToPath(fileUrl)
+}
+
+export function __dirname(__filename) {
+    return path.dirname(__filename)
+}
+
+export function findFileRecursively(
+    startDir,
+    baseName,
+    extName = '',
+    excludedDirs = ['node_modules', '.git']
+) {
+    if (typeof startDir !== 'string' || !fs.existsSync(startDir)) {
+        return null
+    }
+
+    const targetName = baseName + (extName.startsWith('.') ? extName : (extName ? `.${extName}` : ''))
+
+    try {
+        const entries = fs.readdirSync(startDir, { withFileTypes: true })
+
+        for (const entry of entries) {
+            const fullPath = path.join(startDir, entry.name)
+
+            if (entry.isFile()) {
+
+                if (!extName) {
+                    const entryExt = path.extname(entry.name)
+                    const entryBase = path.basename(entry.name, entryExt)
+
+                    if (entryBase === baseName) {
+                        return fullPath
+                    }
+                } else {
+                    if (entry.name === targetName) {
+                        return fullPath
+                    }
+                }
+            }
+
+            if (entry.isDirectory()) {
+                const isHiddenOrExcluded = entry.name.startsWith('.') || excludedDirs.includes(entry.name)
+
+                if (isHiddenOrExcluded) {
+                    continue
+                }
+
+                const foundPath = findFileRecursively(fullPath, baseName, extName, excludedDirs)
+
+                if (foundPath) {
+                    return foundPath
+                }
+            }
+        }
+
+        return null
+    } catch (error) {
+        if (error.code === 'EACCES') {
+            return null
+        }
+
+        return null
+    }
+}
+
+export function resolveObjWithHandlebars(obj, context) {
+     if (typeof obj === "string") {
+          const compileResult = Handlebars.compile(obj)
+          return compileResult(context)
+     } else if (typeof obj === "object" && obj !== null) {
+          for (const key in obj) {
+               obj[key] = resolveObjWithHandlebars(obj[key], context)
+          }
+     }
+     return obj
+}

package/bin/main-cli.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+import yaml from 'yaml'
+import { Command } from 'commander'
+import chalk from 'chalk'
+import ora from 'ora'
+
+import { defaultOwnerTmpFilePath, defaultTmpFilePath, packageName, templateRepoUri, tmpFileDefaultExt, tmpFileDefaultMainFolderName, tmpFileDefaultName } from './constants/index.mjs'
+import { findFileRecursively, resolveObjWithHandlebars } from './helpers/index.mjs'
+
+let cli = null
+
+let ownerTmpFilePath = null
+let ownerTmpFile = null
+
+let parsedTmpObject = null
+let resolvedTmpObject = null
+
+let projectMainFolderPath = null
+
+try {
+  cli = new Command()
+
+  try {
+    ownerTmpFilePath = findFileRecursively('.', tmpFileDefaultName, tmpFileDefaultExt)
+
+    if(!ownerTmpFilePath){
+      const tmpFilePathBuffer = fs.readFileSync(defaultTmpFilePath)
+
+      fs.mkdirSync(path.resolve(tmpFileDefaultMainFolderName), {recursive:true})
+
+      fs.writeFileSync(defaultOwnerTmpFilePath, tmpFilePathBuffer)
+
+      ownerTmpFilePath = defaultOwnerTmpFilePath
+    }
+
+    ownerTmpFile = fs.readFileSync(ownerTmpFilePath)
+
+    if(!ownerTmpFile){
+        throw new Error(`${tmpFileDefaultName} File not read.`)
+    }
+
+    parsedTmpObject = yaml.parse(ownerTmpFile.toString())
+
+    resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
+
+    projectMainFolderPath = path.resolve(resolvedTmpObject.configs.mainFolderPath)
+
+    if(!fs.existsSync(path.resolve(projectMainFolderPath))){
+      fs.mkdirSync(path.resolve(projectMainFolderPath))
+    }
+
+  } catch (error) {
+    console.error(`${packageName} Error:`, error?.message)
+  }
+
+  cli
+  .command('webpack')
+  .action(function (pathOption, options) {
+    if(resolvedTmpFile.configs.worker === 'development'){
+      exec(
+        `node --loader ts-node/esm node_modules/tmp-project-tool/node_modules/webpack-dev-server/bin/webpack-dev-server --config ${
+          path.resolve(resolvedTmpFile.configs.webpack.location.worker[resolvedTmpFile.configs.worker])
+        }`, {cwd: path.resolve()}, (error, stdout, stderr) => {
+
+        if (error) {
+          console.error(`error: ${error.message}`)
+          return
+        }
+
+        if (stderr) {
+          console.error(`stderr: ${stderr}`)
+          return
+        }
+
+        console.log(`stdout: ${stdout}`)
+      })
+    }else{
+      exec(
+        `node --loader ts-node/esm node_modules/tmp-project-tool/node_modules/webpack-cli/bin/cli.js --config ${
+          path.resolve(resolvedTmpFile.configs.webpack.location.worker[resolvedTmpFile.configs.worker])
+        }`, {cwd: path.resolve()}, (error, stdout, stderr) => {
+
+        if (error) {
+          console.error(error, stderr)
+          return
+        }
+
+        if (stderr) {
+          console.error(`stderr: ${stderr}`)
+          return
+        }
+
+        console.log(`stdout: ${stdout}`)
+      })
+    }
+  })
+
+  /*
+    exec(`node --loader ts-node/esm ./${packagePathname}/src/index.ts ${options.config ? `--config ${options.config}` : ''}` , (error, stdout, stderr) => {
+      if (error) {
+        console.error(`error: ${error.message}`)
+        return
+      }
+
+      if (stderr) {
+        console.error(`stderr: ${stderr}`)
+        return
+      }
+
+      console.log(`stdout: ${stdout}`)
+    })
+  */
+
+  cli
+  .command('create <project-name>')
+  .description('Clone template from GitHub (Private/Public)')
+  .action(async (projectName) => {
+    const targetPath = path.join(process.cwd(), projectName)
+
+    // 1. Klasör Kontrolü
+    if (fs.existsSync(targetPath)) {
+      console.log(chalk.red(`❌ Error: '${projectName}' folder already exists!`))
+      process.exit(1)
+    }
+
+    const repoURL = templateRepoUri
+
+    const spinner = ora('Cloning template from GitHub...').start()
+
+    try {
+      execSync(`git clone --depth 1 ${repoURL} "${targetPath}"`, {
+        stdio: 'ignore'
+      })
+
+      const gitFolder = path.join(targetPath, '.git')
+      if (fs.existsSync(gitFolder)) {
+        fs.rmSync(gitFolder, { recursive: true, force: true })
+      }
+
+      spinner.succeed(chalk.green('Template cloned successfully!'))
+
+      console.log(chalk.blue(`\n📦 Dependencies loading... (${projectName})`))
+
+      execSync('npm install', {
+        cwd: targetPath,
+        stdio: 'inherit'
+      })
+
+      console.log(chalk.green('\n✅ Project Ready!'))
+      console.log(chalk.white(`\nStart Project:\n`))
+      console.log(chalk.cyan(`   cd ${projectName}`))
+      console.log(chalk.cyan(`   npm run dev`))
+
+    } catch (err) {
+      spinner.fail(chalk.red('Failed to clone or install!'))
+
+      console.error(chalk.red('\nPossible reasons:'))
+      console.error(chalk.yellow('1. You might not have access to this private repo.'))
+      console.error(chalk.yellow('2. Git is not installed or configured on this machine.'))
+      console.error(chalk.red(`\nError details: ${err.message}`))
+
+      if (fs.existsSync(targetPath)) {
+        fs.rmSync(targetPath, { recursive: true, force: true })
+      }
+    }
+  })
+
+  cli.parse(process.argv)
+} catch (error) {
+  console.error(`x cli:${error?.message}`)
+}
+
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error.message)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@xrystal/core",
+  "version": "3.2.3",
+  "description": "Project core for xrystal",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xdloper/-xrystal-core.git"
+  },
+  "files": [
+    "source",
+    "bin",
+    "x",
+    "README.md"
+  ],
+  "main": "source/index.ts",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./source/index.d.ts",
+      "import": "./source/index.js",
+      "require": "./source/index.js"
+    },
+    "./*": {
+      "types": "./source/*.d.ts",
+      "import": "./source/*.js"
+    }
+  },
+  "type": "module",
+  "bin": {
+    "tmp": "./bin/main-cli.js"
+  },
+  "scripts": {
+    "dev": "tsx watch --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env --include \"./source/**/*.ts\" --include \"./x\" --exclude node_modules --exclude x/ts-build source/index.ts",
+    "lint": "eslint .",
+    "build": "./node_modules/.bin/tsc",
+    "start": "node ./x/ts-build/index.js",
+    "webpack-dev": "node --loader ts-node/esm node_modules/webpack-dev-server/bin/webpack-dev-server --config ./x/webpack/webpack.config.dev.ts",
+    "webpack-prod": "node --loader ts-node/esm node_modules/webpack-cli/bin/cli.js --config ./x/webpack/webpack.config.prod.ts"
+  },
+  "dependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.4",
+    "@babel/preset-env": "^7.21.4",
+    "@babel/preset-react": "^7.18.6",
+    "@types/bcrypt": "^5.0.2",
+    "@types/webpack": "^5.28.3",
+    "@types/webpack-dev-server": "^4.7.2",
+    "@types/webpack-merge": "^5.0.0",
+    "@types/webpack-node-externals": "^3.0.4",
+    "@types/yaml": "^1.9.7",
+    "axios": "^1.13.2",
+    "babel-loader": "^9.1.2",
+    "chalk": "^5.6.2",
+    "clean-webpack-plugin": "^4.0.0",
+    "commander": "^13.0.0",
+    "copy-webpack-plugin": "^11.0.0",
+    "css-loader": "^6.7.3",
+    "dotenv": "^16.3.1",
+    "ejs": "^3.1.9",
+    "ejs-compiled-loader": "^3.1.0",
+    "ejs-loader": "^0.5.0",
+    "ejs-webpack-loader": "^2.2.2",
+    "file-loader": "^6.2.0",
+    "handlebars": "^4.7.8",
+    "handlebars-loader": "^1.7.3",
+    "html-loader": "^4.2.0",
+    "html-webpack-plugin": "^5.6.0",
+    "i18next": "^25.6.3",
+    "i18next-fs-backend": "^2.6.1",
+    "i18next-http-middleware": "^3.8.2",
+    "jquery": "^3.7.1",
+    "kafkajs": "^2.2.4",
+    "logform": "^2.7.0",
+    "mini-css-extract-plugin": "^2.9.0",
+    "minimist": "^1.2.8",
+    "moment-timezone": "^0.6.0",
+    "nodemailer": "^7.0.11",
+    "nodemailer-express-handlebars": "^7.0.0",
+    "ora": "^9.0.0",
+    "postcss-loader": "^7.2.4",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "sass": "^1.62.0",
+    "sass-loader": "^13.2.2",
+    "soap": "^1.6.0",
+    "ts-loader": "^8.0.0",
+    "url-loader": "^4.1.1",
+    "webpack-dev-server": "^4.13.3",
+    "webpack-merge": "^6.0.1",
+    "webpack-node-externals": "^3.0.0",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "winston-mongodb": "^7.0.1",
+    "yaml": "^2.5.0"
+  },
+  "author": "y.yasir.k",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/minimist": "^1.2.5",
+    "@types/nodemailer": "^7.0.4",
+    "@types/nodemailer-express-handlebars": "^4.0.6",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.5.3",
+    "webpack": "^5.104.1",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/source/index.d.ts

@@ -0,0 +1,2 @@
+declare let tmp: any;
+export default tmp;

package/source/index.js

@@ -0,0 +1,8 @@
+import coreLoader from "./project/index.js";
+let tmp;
+// => tmp project tool => xrystal
+await (async () => {
+    tmp = await coreLoader();
+})();
+//
+export default tmp;

package/source/loader/configs/index.d.ts

@@ -0,0 +1,13 @@
+import SystemService from '../system/index';
+export default class ConfigsService {
+    protected _globalEnvFileName: string;
+    protected _systemService: SystemService;
+    static tmpFolderPath: string;
+    private _envLoadPath;
+    load: ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }: {
+        tmpFolderPath: string;
+        systemService: SystemService;
+        envLoadPath: string;
+        globalEnvFileName?: string | null;
+    }) => any;
+}

package/source/loader/configs/index.js

@@ -0,0 +1,17 @@
+export default class ConfigsService {
+    _globalEnvFileName = 'global';
+    _systemService;
+    static tmpFolderPath;
+    _envLoadPath = '';
+    load = ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }) => {
+        ConfigsService.tmpFolderPath = tmpFolderPath;
+        this._systemService = systemService;
+        this._envLoadPath = `${envLoadPath}`;
+        /*
+        this._dynamicEnvLoader({
+            nodeEnv
+            globalEnvFileName
+        })
+        */
+    };
+}

package/source/loader/events/index.d.ts

@@ -0,0 +1,6 @@
+export default class EventsService {
+    private logger;
+    load: ({}: {}) => any;
+    private _globalLoader;
+    get global(): any;
+}

package/source/loader/events/index.js

@@ -0,0 +1,25 @@
+import LoggersLoader from '../logger/index';
+import { x, LoggerLayerEnum } from '../../utils/index';
+export default class EventsService {
+    logger = x.get(LoggersLoader);
+    load = ({}) => {
+        this._globalLoader();
+    };
+    _globalLoader = () => {
+        process.on("uncaughtException", (exception) => {
+            this.logger.winston.log({
+                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                message: `UncaughtException: ${exception}`,
+            });
+        });
+        process.on("unhandledRejection", (exception) => {
+            this.logger.winston.log({
+                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                message: `UnhandledRejection: ${exception}`,
+            });
+        });
+    };
+    get global() {
+        return this._globalLoader();
+    }
+}

package/source/loader/index.d.ts

@@ -0,0 +1,6 @@
+import SystemService from "./system";
+import ConfigsService from "./configs";
+import LoggerService from "./logger";
+import EventsService from "./events";
+import LocalizationsService from "./localizations";
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/source/loader/index.js

@@ -0,0 +1,6 @@
+import SystemService from "./system";
+import ConfigsService from "./configs";
+import LoggerService from "./logger";
+import EventsService from "./events";
+import LocalizationsService from "./localizations";
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/source/loader/localizations/index.d.ts

@@ -0,0 +1,14 @@
+export default class LocalizationsService {
+    _instance: any;
+    load: ({ loadPath, fallbackLang, preloadLang, }: {
+        loadPath: string;
+        fallbackLang: string;
+        preloadLang: string;
+    }) => any;
+    i18next: ({ loadPath, fallbackLang, preloadLang, }: {
+        loadPath?: string;
+        fallbackLang?: string;
+        preloadLang?: any;
+    }) => any;
+    get instance(): any;
+}

package/source/loader/localizations/index.js

@@ -0,0 +1,32 @@
+import i18next from "i18next";
+import Backend from 'i18next-fs-backend';
+import * as middleware from 'i18next-http-middleware';
+export default class LocalizationsService {
+    _instance = null;
+    load = ({ loadPath, fallbackLang, preloadLang, }) => {
+        this.i18next({
+            loadPath,
+            fallbackLang,
+            preloadLang,
+        });
+    };
+    i18next = ({ loadPath, fallbackLang, preloadLang, }) => {
+        if (this._instance) {
+            return this._instance;
+        }
+        i18next
+            .use(Backend)
+            .use(middleware.LanguageDetector)
+            .init({
+            fallbackLng: fallbackLang,
+            preload: preloadLang,
+            backend: { loadPath: `${loadPath}/{{lng}}.json` }
+        });
+        if (i18next)
+            this._instance = i18next;
+        return i18next;
+    };
+    get instance() {
+        return this._instance;
+    }
+}

package/source/loader/logger/index.d.ts

@@ -0,0 +1,22 @@
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+interface CustomLogger extends winston.Logger {
+    critical: winston.LeveledLogMethod;
+}
+export default class LoggerService {
+    private serviceName;
+    private environment;
+    private kafkaProducer;
+    private kafkaTopic;
+    private isKafkaReady;
+    private getConsoleFormat;
+    winston: CustomLogger;
+    constructor();
+    load: (config: any) => Promise<void>;
+    winstonLoader: ({ loadPath, loggerLevel }: {
+        loadPath: string;
+        loggerLevel: string;
+    }) => CustomLogger;
+    private logToKafka;
+}
+export {};