@xrystal/core 3.18.0 → 3.18.2

package/bin/constants/index.mjs

@@ -1,14 +1,17 @@
-import path from 'path'
+import path from "node:path"
 
-import { __filename, __dirname } from '../helpers/index.mjs'
+export class Constants {
+    static packageName = '@xrystal/core'
 
-export const packageName = '@xrystal/core'
+    static defaultRootFolderName = 'x'
+    static defaultTmpFileName = 'tmp'
+    static defaultTmpFileExt = '.yml'
 
-export const tmpFileDefaultMainFolderName = 'x'
-export const tmpFileDefaultName = 'tmp'
-export const tmpFileDefaultExt = '.yml'
+    static defaultTmpFilePath = path.join(__dirname, `../../${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`)
+    static defaultOwnerTmpFilePath = path.join(process.cwd(),`./${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`)
 
-export const defaultTmpFilePath = path.resolve(__dirname(__filename(import.meta.url)), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
-export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
+    static publicFolderName = 'public'
+    static kafkaLogsTopic = 'logs'
 
-export const templateRepoUri = 'https://github.com/xdloper/xastral-general-project-tmp.git'
+    static templateRepoUri = 'https://github.com/xdloper/xastral-general-project-tmp.git'
+}

package/bin/main-cli.js

@@ -8,128 +8,124 @@ import chalk from "chalk"
 import ora from "ora"
 import yaml from "yaml"
 
-import {
-  defaultOwnerTmpFilePath,
-  defaultTmpFilePath,
-  packageName,
-  templateRepoUri,
-  tmpFileDefaultExt,
-  tmpFileDefaultMainFolderName,
-  tmpFileDefaultName
-} from "./constants/index.mjs"
+import { Constants } from "./constants/index.mjs"
 import { findFileRecursively, resolveObjWithHandlebars } from "./helpers/index.mjs"
 
 const setupCLI = async () => {
-  const cli = new Command()
+    const cli = new Command()
+
+    const isBun = !!process.versions.bun
+    const runtimeName = isBun ? "Bun" : "Node.js"
+    const packageManager = isBun ? "bun" : "npm"
+    const installCommand = isBun ? "bun install" : "npm install"
+    const devCommand = isBun ? "bun run dev:local" : "npm run dev:local"
+
+    try {
+        let ownerTmpFilePath = findFileRecursively(".", Constants.defaultTmpFileName, Constants.defaultTmpFileExt)
+
+        if (!ownerTmpFilePath) {
+            if (!Constants.defaultTmpFilePath || !fs.existsSync(Constants.defaultTmpFilePath)) {
+                throw new Error("Default template configuration file not found in package")
+            }
+
+            const folderPath = path.resolve(Constants.defaultRootFolderName)
+            if (!fs.existsSync(folderPath)) {
+                fs.mkdirSync(folderPath, { recursive: true })
+            }
+
+            const tmpFilePathBuffer = fs.readFileSync(Constants.defaultTmpFilePath)
+            fs.writeFileSync(Constants.defaultOwnerTmpFilePath, tmpFilePathBuffer)
+            ownerTmpFilePath = Constants.defaultOwnerTmpFilePath
+        }
 
-  const isBun = !!process.versions.bun
-  const runtimeName = isBun ? "Bun" : "Node.js"
-  const packageManager = isBun ? "bun" : "npm"
-  const installCommand = isBun ? "bun install" : "npm install"
-  const devCommand = isBun ? "bun run dev:local" : "npm run dev:local"
+        const ownerTmpFile = fs.readFileSync(ownerTmpFilePath, "utf8")
+        const parsedTmpObject = yaml.parse(ownerTmpFile)
+        const resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
 
-  try {
-    let ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt)
+        cli
+            .command("create <project-name> [target-path]")
+            .description(`Project initializer using ${runtimeName}`)
+            .action(async (projectName, targetDir) => {
+                let targetPath = ""
+                const isCurrentDir = projectName === "."
 
-    if (!ownerTmpFilePath) {
-      if (!defaultTmpFilePath || !fs.existsSync(defaultTmpFilePath)) {
-        throw new Error("Default template configuration file not found in package")
-      }
+                if (targetDir) {
+                    const baseDir = path.resolve(process.cwd(), targetDir)
+                    targetPath = isCurrentDir ? baseDir : path.join(baseDir, projectName)
+                } else {
+                    targetPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName)
+                }
 
-      const tmpFilePathBuffer = fs.readFileSync(defaultTmpFilePath)
-      const folderPath = path.resolve(tmpFileDefaultMainFolderName || ".xrystal")
+                if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
+                    console.log(chalk.red(`❌ Error: Target directory '${targetPath}' is not empty!`))
+                    process.exit(1)
+                }
 
-      if (!fs.existsSync(folderPath)) {
-        fs.mkdirSync(folderPath, { recursive: true })
-      }
+                const mainPath = resolvedTmpObject?.configs?.mainFolderPath || "./source"
 
-      fs.writeFileSync(defaultOwnerTmpFilePath, tmpFilePathBuffer)
-      ownerTmpFilePath = defaultOwnerTmpFilePath
-    }
+                if (!fs.existsSync(targetPath)) {
+                    fs.mkdirSync(targetPath, { recursive: true })
+                }
 
-    const ownerTmpFile = fs.readFileSync(ownerTmpFilePath, "utf8")
-    const parsedTmpObject = yaml.parse(ownerTmpFile)
-    const resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
+                const spinner = ora(`${runtimeName} environment detected. Cloning template...`).start()
 
-    const mainPath = resolvedTmpObject?.configs?.mainFolderPath || "./source"
-    const projectMainFolderPath = path.resolve(mainPath)
+                try {
+                    execSync(`git clone --depth 1 ${Constants.templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
 
-    if (!fs.existsSync(projectMainFolderPath)) {
-      fs.mkdirSync(projectMainFolderPath, { recursive: true })
-    }
+                    const gitFolder = path.join(targetPath, ".git")
+                    if (fs.existsSync(gitFolder)) {
+                        fs.rmSync(gitFolder, { recursive: true, force: true })
+                    }
 
-    cli
-      .command("create <project-name> [target-path]")
-      .description(`Project initializer using ${runtimeName}`)
-      .action(async (projectName, targetDir) => {
-        let targetPath = ""
-        const isCurrentDir = projectName === "."
-
-        if (targetDir) {
-          const baseDir = path.resolve(process.cwd(), targetDir)
-          targetPath = isCurrentDir ? baseDir : path.join(baseDir, projectName)
-        } else {
-          targetPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName)
-        }
+                    try {
+                        execSync(`git init`, { cwd: targetPath, stdio: "ignore" })
+                    } catch (e) {
+                        // Git init fail
+                    }
 
-        if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
-          console.log(chalk.red(`❌ Error: Target directory '${targetPath}' is not empty!`))
-          process.exit(1)
-        }
-
-        if (!fs.existsSync(targetPath)) {
-          fs.mkdirSync(targetPath, { recursive: true })
-        }
+                    const projectMainFolderPath = path.resolve(targetPath, mainPath)
+                    if (!fs.existsSync(projectMainFolderPath)) {
+                        fs.mkdirSync(projectMainFolderPath, { recursive: true })
+                    }
 
-        const spinner = ora(`${runtimeName} environment detected. Cloning template...`).start()
+                    spinner.succeed(chalk.green("Template cloned and git initialized!"))
+                    console.log(chalk.blue(`\n📦 Installing dependencies with ${packageManager}...`))
 
-        try {
-          execSync(`git clone --depth 1 ${templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
+                    execSync(installCommand, { cwd: targetPath, stdio: "inherit" })
 
-          const gitFolder = path.join(targetPath, ".git")
-          if (fs.existsSync(gitFolder)) {
-            fs.rmSync(gitFolder, { recursive: true, force: true })
-          }
+                    console.log(chalk.green("\n✅ Done!"))
 
-          try {
-            execSync(`git init`, { cwd: targetPath, stdio: "ignore" })
-          } catch (e) {
-          }
+                    const relativePath = path.relative(process.cwd(), targetPath)
+                    if (relativePath && relativePath !== ".") {
+                        console.log(chalk.cyan(`\n   cd ${relativePath}`))
+                    }
+                    console.log(chalk.cyan(`   ${devCommand}`))
 
-          spinner.succeed(chalk.green("Template cloned and git initialized!"))
-          console.log(chalk.blue(`\n📦 Installing dependencies with ${packageManager}...`))
+                } catch (err) {
+                    spinner.fail(chalk.red("Failed!"))
+                    console.error(chalk.red(`\nDetails: ${err.message}`))
 
-          execSync(installCommand, { cwd: targetPath, stdio: "inherit" })
+                    if (fs.existsSync(targetPath) && !isCurrentDir) {
+                        const files = fs.readdirSync(targetPath)
 
-          console.log(chalk.green("\n✅ Done!"))
+                        if (files.length < 5) {
+                            fs.rmSync(targetPath, { recursive: true, force: true })
+                            console.log(chalk.yellow(`🧹 Cleaned up failed installation at ${targetPath}`))
+                        }
+                    }
+                }
+            })
 
-          const relativePath = path.relative(process.cwd(), targetPath)
-          if (relativePath && relativePath !== ".") {
-            console.log(chalk.cyan(`\n   cd ${relativePath}`))
-          }
+        cli.parse(process.argv)
 
-          console.log(chalk.cyan(`   ${devCommand}`))
-
-        } catch (err) {
-          spinner.fail(chalk.red("Failed!"))
-          console.error(chalk.red(`\nDetails: ${err.message}`))
-
-          if (fs.existsSync(targetPath) && targetPath !== process.cwd() && fs.readdirSync(targetPath).length === 0) {
-            fs.rmSync(targetPath, { recursive: true, force: true })
-          }
-        }
-      })
-
-    cli.parse(process.argv)
-
-  } catch (error) {
-    console.error(`${packageName || "CLI"} Initialization Error:`, error?.message)
-  }
+    } catch (error) {
+        console.error(`${Constants.packageName || "CLI"} Initialization Error:`, error?.message)
+    }
 }
 
 process.on("uncaughtException", (error) => {
-  console.error("Critical Error:", error.message)
-  process.exit(1)
+    console.error("Critical Error:", error.message)
+    process.exit(1)
 })
 
 setupCLI()

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.18.0",
+  "version": "3.18.2",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

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

@@ -3,8 +3,8 @@ import { IService } from '../../utils';
 export default class ConfigsService implements IService {
     #private;
     private config;
-    publicFolderName: string;
-    kafkaLogsTopic: string;
+    readonly publicFolderName: string;
+    readonly kafkaLogsTopic: string;
     constructor({ systemService }: {
         systemService: SystemService;
     });

package/source/loader/configs/index.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
-import { kafkaLogsTopic, publicFolderName } from '../../utils';
+import { Constants } from '../../utils';
 export default class ConfigsService {
     config = {};
-    publicFolderName = publicFolderName;
-    kafkaLogsTopic = kafkaLogsTopic;
+    publicFolderName = Constants.publicFolderName;
+    kafkaLogsTopic = Constants.kafkaLogsTopic;
     #systemService;
     constructor({ systemService }) {
         this.#systemService = systemService;

package/source/loader/logger/index.js

@@ -151,7 +151,6 @@ export default class LoggerService {
             return;
         try {
             const { id, level, message, payload, code } = info;
-            console.log('geldii', this.kafkaTopic);
             await this.kafkaProducer.send({
                 topic: this.kafkaTopic,
                 messages: [{

package/source/project/index.js

@@ -1,6 +1,6 @@
 import path from 'path';
-import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader/index';
-import { packageName, x, getTmp, } from '../utils/index';
+import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader';
+import { Constants, x, getTmp, } from '../utils';
 //
 let coreHasRun = false;
 export const core = getTmp();
@@ -68,7 +68,7 @@ const coreLoader = async ({}) => {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`[${packageName} core failure]: ${errorMessage}`);
+        console.error(`[${Constants.packageName} core failure]: ${errorMessage}`);
     }
 };
 export default coreLoader;

package/source/utils/constants/index.d.ts

@@ -1,9 +1,10 @@
-export declare const packageName: string;
-export declare const tmpFileDefaultMainFolderName: string;
-export declare const tmpFileDefaultName: string;
-export declare const tmpFileDefaultExt = ".yml";
-export declare const defaultTmpFilePath: string;
-export declare const defaultOwnerTmpFilePath: string;
-export declare const systemLoggerLayer: string;
-export declare const publicFolderName = "public";
-export declare const kafkaLogsTopic = "logs";
+export declare class Constants {
+    static readonly packageName: string;
+    static readonly defaultRootFolderName: string;
+    static readonly defaultTmpFileName: string;
+    static readonly defaultTmpFileExt = ".yml";
+    static readonly defaultTmpFilePath: string;
+    static readonly defaultOwnerTmpFilePath: string;
+    static readonly publicFolderName = "public";
+    static readonly kafkaLogsTopic = "logs";
+}

package/source/utils/constants/index.js

@@ -1,11 +1,11 @@
-import path from 'path';
-import { __dirname } from '../helpers/path';
-export const packageName = 'x';
-export const tmpFileDefaultMainFolderName = 'x';
-export const tmpFileDefaultName = 'tmp';
-export const tmpFileDefaultExt = '.yml';
-export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
-export const publicFolderName = 'public';
-export const kafkaLogsTopic = 'logs';
+import path from "node:path";
+export class Constants {
+    static packageName = '@xrystal/core';
+    static defaultRootFolderName = 'x';
+    static defaultTmpFileName = 'tmp';
+    static defaultTmpFileExt = '.yml';
+    static defaultTmpFilePath = path.join(__dirname, `../../${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`);
+    static defaultOwnerTmpFilePath = path.join(process.cwd(), `./${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`);
+    static publicFolderName = 'public';
+    static kafkaLogsTopic = 'logs';
+}

package/source/utils/helpers/tmp/index.d.ts

@@ -13,4 +13,3 @@ export declare const argvsConverter: (argvs: string) => {
 };
 export declare const findExt: (filename: string) => string;
 export declare const changeExtensions: (filename: string, repalceExt: string) => string;
-export declare const webFileFindEngine: (folderPath: string) => string[];

package/source/utils/helpers/tmp/index.js

@@ -1,18 +1,18 @@
 import path from "path";
 import fs from 'fs';
 import Handlebars from 'handlebars';
-import { SupportFileExtensionsEnum, tmpFileDefaultExt, tmpFileDefaultName, TmpFileLoader } from "../../index.js";
+import { Constants, TmpFileLoader } from "../../index.js";
 export const getTmp = () => {
-    const ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt);
+    const ownerTmpFilePath = findFileRecursively(".", Constants.defaultTmpFileName, Constants.defaultTmpFileExt);
     if (!ownerTmpFilePath) {
-        throw new Error(`${tmpFileDefaultName} file not found`);
+        throw new Error(`${Constants.defaultTmpFileName} file not found`);
     }
     const tmpFileObject = getTmpConfig({});
     return {
         _: tmpFileObject
     };
 };
-export const getTmpConfig = ({ root = '.', tmpFileName = tmpFileDefaultName, ext = '.yml' }) => {
+export const getTmpConfig = ({ root = process.cwd(), tmpFileName = Constants.defaultTmpFileName, ext = Constants.defaultTmpFileExt }) => {
     const path = findFileRecursively(root, tmpFileName, ext);
     if (!path) {
         throw new Error(`${name}.${ext} file not found`);
@@ -95,33 +95,3 @@ export const findExt = (filename) => {
 export const changeExtensions = (filename, repalceExt) => {
     return filename.replace(findExt(filename), repalceExt);
 };
-export const webFileFindEngine = (folderPath) => {
-    try {
-        const files = fs.readdirSync(folderPath);
-        const fullFileExtension = Object.values(SupportFileExtensionsEnum).map(ext => '.' + ext);
-        const filteredFiles = [];
-        files.forEach(file => {
-            const filePath = path.join(folderPath, file);
-            const isDirectory = fs.statSync(filePath).isDirectory();
-            if (isDirectory) {
-                const subFolderFiles = webFileFindEngine(filePath);
-                subFolderFiles.forEach(subFile => {
-                    filteredFiles.push(path.join(file, subFile).split('\\').join('/')); // Alt klasördeki dosya yolunu, ana klasör yoluna ekleyerek dosyları benzersiz yapıyoruz sonda ise diğer işletim sistemlerien uygun hale getiriyoruz
-                });
-            }
-            else {
-                for (const ffn of fullFileExtension) {
-                    if (file.endsWith(ffn)) {
-                        filteredFiles.push(file);
-                        break;
-                    }
-                }
-            }
-        });
-        return filteredFiles;
-    }
-    catch (error /* unknow */) {
-        console.error('Error: ', error.message);
-        return [];
-    }
-};

package/source/utils/models/enums/index.d.ts

@@ -118,22 +118,3 @@ export declare enum EndpointResourceEnum {
     WEBHOOKS = "webhooks",
     OTHERS = "others"
 }
-export declare enum SupportFileExtensionsEnum {
-    'HTML' = "html",
-    'EJS' = "ejs",
-    'HBS' = "hbs",
-    "TS" = "",
-    "JS" = ".js",
-    "TSX" = "x",
-    "JSX" = ".jsx",
-    "TTF" = ".ttf",
-    "EOT" = ".eot",
-    "OTF" = ".otf",
-    "SVG" = ".svg",
-    "PNG" = ".png",
-    "WOFF" = ".woff",
-    "WOFF2" = ".woff2",
-    "CSS" = ".css",
-    "SCSS" = ".scss",
-    "SASS" = ".sass"
-}

package/source/utils/models/enums/index.js

@@ -137,23 +137,3 @@ export var EndpointResourceEnum;
     EndpointResourceEnum["WEBHOOKS"] = "webhooks";
     EndpointResourceEnum["OTHERS"] = "others";
 })(EndpointResourceEnum || (EndpointResourceEnum = {}));
-export var SupportFileExtensionsEnum;
-(function (SupportFileExtensionsEnum) {
-    SupportFileExtensionsEnum["HTML"] = "html";
-    SupportFileExtensionsEnum["EJS"] = "ejs";
-    SupportFileExtensionsEnum["HBS"] = "hbs";
-    SupportFileExtensionsEnum["TS"] = "";
-    SupportFileExtensionsEnum["JS"] = ".js";
-    SupportFileExtensionsEnum["TSX"] = "x";
-    SupportFileExtensionsEnum["JSX"] = ".jsx";
-    SupportFileExtensionsEnum["TTF"] = ".ttf";
-    SupportFileExtensionsEnum["EOT"] = ".eot";
-    SupportFileExtensionsEnum["OTF"] = ".otf";
-    SupportFileExtensionsEnum["SVG"] = ".svg";
-    SupportFileExtensionsEnum["PNG"] = ".png";
-    SupportFileExtensionsEnum["WOFF"] = ".woff";
-    SupportFileExtensionsEnum["WOFF2"] = ".woff2";
-    SupportFileExtensionsEnum["CSS"] = ".css";
-    SupportFileExtensionsEnum["SCSS"] = ".scss";
-    SupportFileExtensionsEnum["SASS"] = ".sass";
-})(SupportFileExtensionsEnum || (SupportFileExtensionsEnum = {}));