drapcode-utility 2.0.0 → 2.0.2

package/build/utils/uuid-generator.d.ts

@@ -1 +1,20 @@
-export declare const nextGeneratedString: (str: string, prepend: string, minLength: number, append: string, algorithm: string) => string;
+declare const ALLOWED_CHARS: {
+    readonly alphanumeric: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    readonly numeric: "0123456789";
+};
+type Algorithm = keyof typeof ALLOWED_CHARS;
+interface GenerationOptions {
+    prepend?: string;
+    minLength?: number;
+    append?: string;
+    algorithm: Algorithm;
+}
+/**
+ * Generates the next string in sequence based on the input string and options
+ * @param str - The input string to generate the next value from
+ * @param options - The generation options
+ * @returns The next generated string
+ * @throws {UUIDGenerationError} If the input string is invalid
+ */
+export declare const nextGeneratedString: (str: string, options: GenerationOptions) => string;
+export {};

package/build/utils/uuid-generator.js

@@ -4,62 +4,126 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nextGeneratedString = void 0;
-var voca_1 = __importDefault(require("voca"));
-var allowedAlphaNumericChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var allowedNumericChars = "0123456789";
-var nextGeneratedString = function (str, prepend, minLength, append, algorithm) {
-    var allowedChars = "";
-    if (algorithm === "alphanumeric") {
-        allowedChars = allowedAlphaNumericChars;
-    }
-    else if (algorithm === "numeric") {
-        allowedChars = allowedNumericChars;
+const voca_1 = __importDefault(require("voca"));
+// Constants
+const ALLOWED_CHARS = {
+    alphanumeric: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    numeric: "0123456789",
+};
+class UUIDGenerationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UUIDGenerationError";
     }
-    var nextIds = calculateNext(str, allowedChars);
-    console.log("nextIds 1", nextIds);
-    if (!nextIds || nextIds.length === 0) {
-        nextIds = [0];
+}
+// Cache for character lookups
+const charIndexCache = new Map();
+/**
+ * Gets the allowed characters based on the algorithm
+ * @param algorithm - The algorithm to use
+ * @returns The string of allowed characters
+ * @throws {UUIDGenerationError} If the algorithm is invalid
+ */
+const getAllowedChars = (algorithm) => {
+    const chars = ALLOWED_CHARS[algorithm];
+    if (!chars) {
+        throw new UUIDGenerationError(`Invalid algorithm: ${algorithm}`);
     }
-    console.log("next 2", nextIds);
-    var r = [];
-    for (var _i = 0, nextIds_1 = nextIds; _i < nextIds_1.length; _i++) {
-        var char = nextIds_1[_i];
-        r.unshift(allowedChars[char]);
+    return chars;
+};
+/**
+ * Gets the index of a character in the allowed characters string
+ * @param char - The character to look up
+ * @param allowedChars - The string of allowed characters
+ * @returns The index of the character
+ */
+const getCharIndex = (char, allowedChars) => {
+    const cacheKey = `${char}-${allowedChars}`;
+    if (!charIndexCache.has(cacheKey)) {
+        charIndexCache.set(cacheKey, allowedChars.indexOf(char));
     }
-    console.log("r 3", r);
-    var finalValue = r.join("");
-    console.log("finalValue 5", finalValue);
-    if (voca_1.default.isDigit(finalValue) && !+finalValue) {
-        r[0] = "1";
-        finalValue = r.join("");
+    return charIndexCache.get(cacheKey);
+};
+/**
+ * Validates if the input string contains only allowed characters
+ * @param str - The input string to validate
+ * @param allowedChars - The string of allowed characters
+ * @returns True if the input string is valid
+ */
+const isValidInput = (str, allowedChars) => {
+    return str.split("").every((char) => allowedChars.includes(char));
+};
+/**
+ * Handles leading zeros for numeric values
+ * @param value - The value to process
+ * @returns The processed value
+ */
+const handleLeadingZeros = (value) => {
+    if (voca_1.default.isDigit(value) && !+value) {
+        return "1" + value.slice(1);
     }
-    console.log("finalValue", finalValue);
+    return value;
+};
+/**
+ * Applies formatting to the generated value
+ * @param value - The value to format
+ * @param options - The formatting options
+ * @returns The formatted value
+ */
+const applyFormatting = (value, options) => {
+    const { minLength, prepend, append } = options;
+    let result = value;
     if (minLength) {
-        finalValue = voca_1.default.padLeft(finalValue, minLength, "0");
-    }
-    if (prepend) {
-        finalValue = "".concat(prepend).concat(finalValue);
+        result = voca_1.default.padLeft(result, minLength, "0");
     }
-    if (append) {
-        finalValue = "".concat(finalValue).concat(append);
-    }
-    return finalValue;
+    return `${prepend}${result}${append}`;
 };
-exports.nextGeneratedString = nextGeneratedString;
-var calculateNext = function (str, allowedChars) {
-    var nnext = str.split("").map(function (key, index) { return allowedChars.indexOf(key); });
-    console.log("final calculateNext", nnext);
-    nnext = nnext.reverse();
-    for (var i = 0; i < nnext.length; i++) {
-        var val = ++nnext[i];
-        if (val >= allowedChars.length) {
-            nnext[i] = 0;
+/**
+ * Calculates the next sequence of indices
+ * @param str - The input string
+ * @param allowedChars - The string of allowed characters
+ * @returns The next sequence of indices
+ */
+const calculateNext = (str, allowedChars) => {
+    const nextSequence = str
+        .split("")
+        .map((char) => getCharIndex(char, allowedChars))
+        .reverse();
+    for (let i = 0; i < nextSequence.length; i++) {
+        const nextValue = nextSequence[i] + 1;
+        if (nextValue >= allowedChars.length) {
+            nextSequence[i] = 0;
         }
         else {
-            return nnext;
+            nextSequence[i] = nextValue;
+            return nextSequence;
         }
     }
-    console.log("calculateNext nnext", nnext);
-    nnext.push(0);
-    return nnext;
+    nextSequence.push(0);
+    return nextSequence;
+};
+/**
+ * Generates the next string in sequence based on the input string and options
+ * @param str - The input string to generate the next value from
+ * @param options - The generation options
+ * @returns The next generated string
+ * @throws {UUIDGenerationError} If the input string is invalid
+ */
+const nextGeneratedString = (str, options) => {
+    const { prepend = "", minLength = 0, append = "", algorithm } = options;
+    if (!str) {
+        throw new UUIDGenerationError("Input string cannot be empty");
+    }
+    const allowedChars = getAllowedChars(algorithm);
+    if (!isValidInput(str, allowedChars)) {
+        throw new UUIDGenerationError(`Input string contains invalid characters for algorithm: ${algorithm}`);
+    }
+    const nextIds = calculateNext(str, allowedChars) || [0];
+    const result = nextIds
+        .reverse()
+        .map((index) => allowedChars[index])
+        .join("");
+    const finalValue = handleLeadingZeros(result);
+    return applyFormatting(finalValue, { minLength, prepend, append });
 };
+exports.nextGeneratedString = nextGeneratedString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drapcode-utility",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -26,7 +26,8 @@
     "@types/mime-types": "^2.1.4",
     "@types/uuid": "^9.0.8",
     "del-cli": "^5.0.0",
-    "typescript": "^4.0.2"
+    "typescript": "^5.3.3",
+    "ts-loader": "^9.5.1"
   },
   "dependencies": {
     "@aws-sdk/client-kms": "^3.540.0",
@@ -39,10 +40,11 @@
     "@types/voca": "^1.4.2",
     "aws4": "^1.13.2",
     "axios": "^1.1.2",
+    "date-fns": "^4.1.0",
     "dompurify": "^3.1.7",
-    "drapcode-constant": "^1.7.1",
-    "drapcode-logger": "^1.3.4",
-    "drapcode-redis": "^1.2.6",
+    "drapcode-constant": "^1.7.3",
+    "drapcode-logger": "^1.3.5",
+    "drapcode-redis": "^1.2.8",
     "exiftool-vendored": "^28.2.1",
     "express": "^4.17.1",
     "gm": "^1.25.0",

package/build/middlewares/interceptor-logger-new.d.ts

@@ -1,2 +0,0 @@
-import { NextFunction } from "express";
-export declare const interceptLoggerNew: (req: any, res: any, next: NextFunction) => void;

package/build/middlewares/interceptor-logger-new.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interceptLoggerNew = void 0;
-var drapcode_logger_1 = require("drapcode-logger");
-var date_util_1 = require("../utils/date-util");
-var fs_1 = __importDefault(require("fs"));
-var interceptLoggerNew = function (req, res, next) {
-    var todayFilePath = "/tmp/log";
-    var loggerPath = process.env.LOG_FOLDER_PATH || todayFilePath;
-    var originalUrl = req.originalUrl, method = req.method, body = req.body, params = req.params, query = req.query, db = req.db, projectName = req.projectName, projectId = req.projectId, ip = req.ip;
-    var reqObject = {
-        uri: originalUrl,
-        method: method,
-        body: body,
-        params: params,
-        query: query,
-        dbName: "",
-        message: "",
-        line: "",
-        ip: ip,
-    };
-    if (db) {
-        reqObject["dbName"] = db.name;
-    }
-    var PreviouseFilePath;
-    if (projectName) {
-        loggerPath = "".concat(loggerPath, "/").concat(projectName, "/").concat((0, date_util_1.createLoggerDateFormat)(), "/output");
-        PreviouseFilePath = "".concat(loggerPath, "/").concat(projectName, "/").concat((0, date_util_1.createLoggerPreviouseDateFormat)(), "/");
-    }
-    else if (projectId) {
-        loggerPath = "".concat(loggerPath, "/").concat(projectId, "/").concat((0, date_util_1.createLoggerDateFormat)(), "/output");
-        PreviouseFilePath = "".concat(loggerPath, "/").concat(projectId, "/").concat((0, date_util_1.createLoggerPreviouseDateFormat)(), "/");
-    }
-    else {
-        loggerPath = "".concat(loggerPath, "/").concat((0, date_util_1.createLoggerDateFormat)(), "/output");
-        PreviouseFilePath = "".concat(loggerPath, "/").concat((0, date_util_1.createLoggerPreviouseDateFormat)(), "/");
-    }
-    if (fs_1.default.existsSync(PreviouseFilePath)) {
-        fs_1.default.rmSync(PreviouseFilePath, { recursive: true, force: true });
-    }
-    var logger = new drapcode_logger_1.FileLogger(loggerPath).createLogger();
-    var oldSend = res.send;
-    res.send = function (data) {
-        logger.info(data);
-        oldSend.apply(res, arguments);
-        // saveRequest(req, data);
-    };
-    next();
-};
-exports.interceptLoggerNew = interceptLoggerNew;

package/build/middlewares/interceptor-logger.d.ts

@@ -1,2 +0,0 @@
-import { NextFunction } from "express";
-export declare const interceptLogger: (req: any, res: any, next: NextFunction) => void;

package/build/middlewares/interceptor-logger.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interceptLogger = void 0;
-var interceptLogger = function (req, res, next) {
-    return next();
-    /**
-    let loggerPath = process.env.LOG_FOLDER_PATH || "/tmp/logs";
-    const {
-      originalUrl,
-      method,
-      body,
-      params,
-      query,
-      db,
-      projectName,
-      projectId,
-      ip,
-    } = req;
-  
-    const reqObject = {
-      uri: originalUrl,
-      method,
-      body,
-      params,
-      query,
-      dbName: "",
-      message: "",
-      line: "",
-      ip,
-    };
-    if (db) {
-      reqObject["dbName"] = db.name;
-    }
-  
-    if (projectName) {
-      loggerPath = `${loggerPath}/${projectName}/${createLoggerDateFormat()}`;
-    } else if (projectId) {
-      loggerPath = `${loggerPath}/${projectId}/${createLoggerDateFormat()}`;
-    } else {
-      loggerPath = `${loggerPath}/${createLoggerDateFormat()}`;
-    }
-    const logger = new FileLogger(loggerPath).createLogger();
-    let oldSend = res.send;
-    res.send = function (data: any) {
-      logger.info(data);
-      oldSend.apply(res, arguments);
-      // saveRequest(req, data);
-    };
-    next();
-     */
-};
-exports.interceptLogger = interceptLogger;

package/build/utils/query-parser-new.d.ts

@@ -1 +0,0 @@
-export declare const queryParserNew: (collectionName: string, query: any, constants: any[], externalParams: any, currentUser: any, timezone: string, searchObj?: any, refCollectionFieldsInItems?: any, searchQueryTypeObj?: any, lookupConfig?: any) => Promise<any>;