drapcode-utility 2.0.0 → 2.0.2

package/build/utils/date-util.js

@@ -1,98 +1,136 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatProjectDates = exports.timezoneDateParse = exports.nextDayDate = exports.getDateRangeValue = exports.getDateValue = exports.createLogsDateFormat = exports.createLoggerPreviouseDateFormat = exports.createLoggerDateFormat = exports.DATE_REGEX = void 0;
-var drapcode_constant_1 = require("drapcode-constant");
-var moment = require("moment");
+exports.formatProjectDates = exports.timezoneDateParse = exports.nextDayDate = exports.getDateRangeValue = exports.getDateValue = exports.createLogsDateFormat = exports.createLoggerPreviousDateFormat = exports.createLoggerDateFormat = exports.DATE_REGEX = void 0;
+const drapcode_constant_1 = require("drapcode-constant");
+const moment_1 = __importDefault(require("moment"));
+const dateFormat = "YYYY-MM-DDTHH:mm:ss.SSS";
 exports.DATE_REGEX = /^[12]\d{3}(-(0[1-9]|1[0-2])(-(0[1-9]|[12][0-9]|3[01]))?)(T| )?(([01][0-9]|2[0-3]):[0-5]\d(:[0-5]\d(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/;
-var createLoggerDateFormat = function (timezone) {
-    if (timezone === void 0) { timezone = ""; }
-    var result = moment();
-    result = timezone ? result.utcOffset(timezone) : result;
-    return result.format("YYYY-MM-DD");
+const createLoggerDateFormat = (timezone) => {
+    try {
+        let result = (0, moment_1.default)();
+        if (timezone) {
+            if (!/^[+-]\d{2}:\d{2}$/.test(timezone)) {
+                throw new Error("Invalid timezone format. Expected format: +/-HH:mm");
+            }
+            result = result.utcOffset(timezone);
+        }
+        return result.format("YYYY-MM-DD");
+    }
+    catch (error) {
+        console.error("Error in createLoggerDateFormat:", error);
+        return (0, moment_1.default)().format("YYYY-MM-DD");
+    }
 };
 exports.createLoggerDateFormat = createLoggerDateFormat;
-var createLoggerPreviouseDateFormat = function () {
-    return moment().subtract(10, "days").format("YYYY-MM-DD");
+const createLoggerPreviousDateFormat = () => {
+    return (0, moment_1.default)().subtract(10, "days").format("YYYY-MM-DD");
 };
-exports.createLoggerPreviouseDateFormat = createLoggerPreviouseDateFormat;
-var createLogsDateFormat = function (timezone) {
-    if (timezone === void 0) { timezone = ""; }
-    var result = moment();
-    result = timezone ? result.utcOffset(timezone) : result;
-    return result.format("YYYY-MM-DDTHH:mm:ss.SSS");
+exports.createLoggerPreviousDateFormat = createLoggerPreviousDateFormat;
+const createLogsDateFormat = (timezone) => {
+    try {
+        let result = (0, moment_1.default)();
+        if (timezone) {
+            if (!/^[+-]\d{2}:\d{2}$/.test(timezone)) {
+                throw new Error("Invalid timezone format. Expected format: +/-HH:mm");
+            }
+            result = result.utcOffset(timezone);
+        }
+        return result.format("YYYY-MM-DDTHH:mm:ss.SSS");
+    }
+    catch (error) {
+        console.error("Error in createLogsDateFormat:", error);
+        return (0, moment_1.default)().format("YYYY-MM-DDTHH:mm:ss.SSS");
+    }
 };
 exports.createLogsDateFormat = createLogsDateFormat;
-var getDateValue = function (value, timezone) {
-    if (timezone === void 0) { timezone = ""; }
-    if (!value)
-        return (0, exports.createLogsDateFormat)(timezone);
-    var dateFormat = "YYYY-MM-DDTHH:mm:ss.SSS";
-    var _a = value.split(":"), type = _a[0], number = _a[1], unit = _a[2];
-    if (!["ADD", "SUB"].includes(type))
-        return (0, exports.createLogsDateFormat)(timezone);
-    var dateUnit = getDateUnit(unit);
-    var result;
-    if (type === "ADD") {
-        result = moment().add(number, dateUnit);
+const getDateValue = (value, timezone) => {
+    try {
+        if (!value)
+            return (0, exports.createLogsDateFormat)(timezone);
+        const dateFormat = "YYYY-MM-DDTHH:mm:ss.SSS";
+        const [type, number, unit] = value.split(":");
+        if (!["ADD", "SUB"].includes(type)) {
+            return (0, exports.createLogsDateFormat)(timezone);
+        }
+        const dateUnit = getDateUnit(unit);
+        if (!dateUnit) {
+            throw new Error(`Invalid date unit: ${unit}`);
+        }
+        let result = (0, moment_1.default)();
+        if (type === "ADD") {
+            result = result.add(Number(number), dateUnit);
+        }
+        else if (type === "SUB") {
+            result = result.subtract(Number(number), dateUnit);
+        }
+        if (timezone) {
+            if (!/^[+-]\d{2}:\d{2}$/.test(timezone)) {
+                throw new Error("Invalid timezone format. Expected format: +/-HH:mm");
+            }
+            result = result.utcOffset(timezone);
+        }
+        return result.format(dateFormat);
     }
-    else if (type === "SUB") {
-        result = moment().subtract(number, dateUnit);
+    catch (error) {
+        console.error("Error in getDateValue:", error);
+        return (0, exports.createLogsDateFormat)(timezone);
     }
-    result = timezone ? result.utcOffset(timezone) : result;
-    return result.format(dateFormat);
 };
 exports.getDateValue = getDateValue;
-var getDateRangeValue = function (key, field, value) {
-    var _a, _b, _c, _d;
-    var dateFormat = "YYYY-MM-DDTHH:mm:ss.SSS";
-    var finalValue = "";
-    var startValue = "";
-    var endValue = "";
-    switch (value) {
-        case drapcode_constant_1.CURRENT_MONTH:
-            startValue = moment().startOf("month");
-            endValue = moment().endOf("month");
-            break;
-        case drapcode_constant_1.CURRENT_YEAR:
-            startValue = moment().startOf("year");
-            endValue = moment().endOf("year");
-            break;
-        default:
-            break;
-    }
-    if (key === drapcode_constant_1.EQUALS) {
-        finalValue = (_a = {},
-            _a[field] = {
-                $gte: startValue.format(dateFormat),
-                $lte: endValue.format(dateFormat),
-            },
-            _a);
-    }
-    else if (key === drapcode_constant_1.NOT_EQUAL) {
-        finalValue = {
-            $or: [
-                (_b = {}, _b[field] = { $gte: endValue.format(dateFormat) }, _b),
-                (_c = {}, _c[field] = { $lte: startValue.format(dateFormat) }, _c),
-            ],
-        };
-    }
-    else if (key === drapcode_constant_1.EQUALS_OR_IGNORE) {
-        if (startValue && endValue) {
-            finalValue = (_d = {},
-                _d[field] = {
-                    $gte: startValue.format(dateFormat),
-                    $lte: endValue.format(dateFormat),
+const getDateRangeValue = (key, field, value) => {
+    try {
+        let startValue = null;
+        let endValue = null;
+        switch (value) {
+            case drapcode_constant_1.CURRENT_MONTH:
+                startValue = (0, moment_1.default)().startOf("month");
+                endValue = (0, moment_1.default)().endOf("month");
+                break;
+            case drapcode_constant_1.CURRENT_YEAR:
+                startValue = (0, moment_1.default)().startOf("year");
+                endValue = (0, moment_1.default)().endOf("year");
+                break;
+            default:
+                return {};
+        }
+        if (!startValue || !endValue) {
+            return {};
+        }
+        startValue = formatDate(startValue);
+        endValue = formatDate(endValue);
+        if ([drapcode_constant_1.EQUALS, drapcode_constant_1.EQUALS_OR_IGNORE].includes(key)) {
+            return {
+                [field]: {
+                    $gte: startValue,
+                    $lte: endValue,
                 },
-                _d);
+            };
         }
-        else {
-            finalValue = {};
+        else if (key === drapcode_constant_1.NOT_EQUAL) {
+            return {
+                $or: [
+                    { [field]: { $gte: endValue } },
+                    { [field]: { $lte: startValue } },
+                ],
+            };
         }
+        return {};
+    }
+    catch (error) {
+        console.error("Error in getDateRangeValue:", error);
+        return {};
     }
-    return finalValue;
 };
 exports.getDateRangeValue = getDateRangeValue;
-var getDateUnit = function (unit) {
+const formatDate = (date) => {
+    if (!date)
+        return `${date}`;
+    return date.format(dateFormat);
+};
+const getDateUnit = (unit) => {
     switch (unit) {
         case drapcode_constant_1.HOUR:
             return "hour";
@@ -105,64 +143,79 @@ var getDateUnit = function (unit) {
         case drapcode_constant_1.YEAR:
             return "years";
         default:
-            return "";
+            return null;
     }
 };
-var nextDayDate = function (date) {
-    date = new Date(date);
-    return moment(date).add(1, "days").format("YYYY-MM-DD");
+const nextDayDate = (date) => {
+    try {
+        const parsedDate = (0, moment_1.default)(date);
+        if (!parsedDate.isValid()) {
+            throw new Error("Invalid date input");
+        }
+        return parsedDate.add(1, "days").format("YYYY-MM-DD");
+    }
+    catch (error) {
+        console.error("Error in nextDayDate:", error);
+        return (0, moment_1.default)().add(1, "days").format("YYYY-MM-DD");
+    }
 };
 exports.nextDayDate = nextDayDate;
-var timezoneDateParse = function (value, nextDay, prevDay) {
-    if (nextDay === void 0) { nextDay = false; }
-    if (prevDay === void 0) { prevDay = false; }
-    var timeZoneDate = moment(value);
-    if (nextDay && value.length <= 10) {
-        timeZoneDate = timeZoneDate.add(1, "days");
-    }
-    if (prevDay && value.length <= 10) {
-        timeZoneDate = timeZoneDate.subtract(1, "days");
-    }
-    timeZoneDate = timeZoneDate.format("YYYY-MM-DDTHH:mm:ss");
-    return new Date(timeZoneDate);
+const timezoneDateParse = (value, nextDay = false, prevDay = false) => {
+    try {
+        let timeZoneDate = (0, moment_1.default)(value);
+        if (!timeZoneDate.isValid()) {
+            throw new Error("Invalid date input");
+        }
+        if (nextDay && value.length <= 10) {
+            timeZoneDate = timeZoneDate.add(1, "days");
+        }
+        if (prevDay && value.length <= 10) {
+            timeZoneDate = timeZoneDate.subtract(1, "days");
+        }
+        const formatted = timeZoneDate.format("YYYY-MM-DDTHH:mm:ss");
+        return new Date(formatted);
+        // return timeZoneDate.toDate();
+    }
+    catch (error) {
+        console.error("Error in timezoneDateParse:", error);
+        return new Date();
+    }
 };
 exports.timezoneDateParse = timezoneDateParse;
-var formatItemDates = function (item, fields, dateFormat, reverse) {
-    if (item && typeof item === "object") {
-        var dateTimeFormat_1 = "YYYY-MM-DD";
-        var dateFormat1_1 = reverse ? dateFormat : "YYYY-MM-DD";
-        var dateFormat2_1 = reverse ? "YYYY-MM-DD" : dateFormat;
-        Object.keys(item).forEach(function (fieldName) {
-            var _a;
-            var field = fields.find(function (field) { return field.fieldName === fieldName; });
-            if (field && (field === null || field === void 0 ? void 0 : field.type) === "date") {
-                if (((_a = field === null || field === void 0 ? void 0 : field.extraFieldSetting) === null || _a === void 0 ? void 0 : _a.dateDisplayType) === "datetime-local") {
-                    if (moment(item[fieldName], dateTimeFormat_1).isValid()) {
-                        item[fieldName] = item[fieldName];
-                    }
-                    else
-                        item[fieldName] = "";
-                }
-                else {
-                    if (moment(item[fieldName], dateFormat1_1).isValid()) {
-                        item[fieldName] = moment(item[fieldName], dateFormat1_1).format(dateFormat2_1);
-                    }
-                    else
-                        item[fieldName] = "";
-                }
-            }
-        });
+const formatItemDates = (item, fields, dateFormat, reverse) => {
+    if (!item || typeof item !== "object") {
+        return item;
     }
+    const dateTimeFormat = "YYYY-MM-DD";
+    const dateFormat1 = reverse ? dateFormat : "YYYY-MM-DD";
+    const dateFormat2 = reverse ? "YYYY-MM-DD" : dateFormat;
+    Object.keys(item).forEach((fieldName) => {
+        const field = fields.find((field) => field.fieldName === fieldName);
+        if (field?.type === "date") {
+            if (field?.extraFieldSetting?.dateDisplayType === "datetime-local") {
+                item[fieldName] = (0, moment_1.default)(item[fieldName], dateTimeFormat).isValid()
+                    ? item[fieldName]
+                    : "";
+            }
+            else {
+                item[fieldName] = (0, moment_1.default)(item[fieldName], dateFormat1).isValid()
+                    ? (0, moment_1.default)(item[fieldName], dateFormat1).format(dateFormat2)
+                    : "";
+            }
+        }
+    });
     return item;
 };
-var formatProjectDates = function (item, dateFormat, fields, reverse) {
-    if (Array.isArray(item)) {
-        item = item.map(function (item) {
-            return formatItemDates(item, fields, dateFormat, reverse);
-        });
-    }
-    else
-        item = formatItemDates(item, fields, dateFormat, reverse);
-    return item;
+const formatProjectDates = (item, dateFormat, fields, reverse) => {
+    try {
+        if (Array.isArray(item)) {
+            return item.map((item) => formatItemDates(item, fields, dateFormat, reverse));
+        }
+        return formatItemDates(item, fields, dateFormat, reverse);
+    }
+    catch (error) {
+        console.error("Error in formatProjectDates:", error);
+        return item;
+    }
 };
 exports.formatProjectDates = formatProjectDates;

package/build/utils/file-util.d.ts

@@ -1,7 +1,52 @@
-export declare const checkFolder: (path: string | any) => void;
+export interface FileContent {
+    [key: string]: unknown;
+}
+export interface PageContent extends FileContent {
+    slug: string;
+    isDefaultPage?: boolean;
+}
+export interface WebhookContent extends FileContent {
+    uuid: string;
+}
+export interface ExternalApiContent extends FileContent {
+    uuid: string;
+}
+export interface CustomComponentContent extends FileContent {
+    uuid: string;
+}
+export interface CustomMappingContent extends FileContent {
+    uuid: string;
+}
+export interface TaskContent extends FileContent {
+    uuid: string;
+}
+export interface EventContent extends FileContent {
+    uuid: string;
+}
+export interface SnippetContent extends FileContent {
+    uuid: string;
+}
+export interface LocalizationContent extends FileContent {
+    language: string;
+    isDefault?: boolean;
+}
+export interface PluginContent extends FileContent {
+    code: string;
+}
+export interface DevApiContent extends FileContent {
+    uuid: string;
+}
+export interface TemplateContent extends FileContent {
+    uuid: string;
+}
+export interface CollectionContent extends FileContent {
+    uuid: string;
+    collectionName: string;
+}
+export declare const checkFolder: (folderPath: string) => void;
 export declare const verifyProjectSettingFolder: (projectId: string) => boolean;
-export declare const readFile: (filePath: string | any) => any;
-export declare const createFile: (filePath: string | any, content: any) => void;
-export declare const loadJsonFilesFromSubfolder: (projectId: string, subfolder: string, excludeFiles?: string[]) => any[];
-export declare const loadSingleJsonFromSubfolder: (projectId: string, subfolder: string, fileName: string) => any;
-export declare const saveEntities: (projectId: string, folderName: string, entities: any[], getFileName: (entity: any) => string, handleExtraSave?: ((folderPath: string, entity: any) => void) | undefined) => void;
+export declare const readFile: (filePath: string) => FileContent | null;
+export declare const createFile: (filePath: string, content: FileContent) => void;
+export declare const loadJsonFilesFromSubfolder: (projectId: string, subfolder: string, excludeFiles?: string[]) => FileContent[];
+export declare const loadSingleJsonFromSubfolder: (projectId: string, subfolder: string, fileName: string) => FileContent | null;
+export declare const saveEntities: <T extends FileContent>(projectId: string, folderName: string, entities: T[], getFileName: (entity: T) => string, handleExtraSave?: (folderPath: string, entity: T) => void) => void;

package/build/utils/file-util.js

@@ -4,70 +4,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveEntities = exports.loadSingleJsonFromSubfolder = exports.loadJsonFilesFromSubfolder = exports.createFile = exports.readFile = exports.verifyProjectSettingFolder = exports.checkFolder = void 0;
-var fs_1 = require("fs");
-var path_1 = __importDefault(require("path"));
-var filePath = process.env.BUILD_FOLDER;
-var checkFolder = function (path) {
-    if (!path) {
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const filePath = process.env.BUILD_FOLDER || "";
+const checkFolder = (folderPath) => {
+    if (!folderPath) {
         return;
     }
-    if (!(0, fs_1.existsSync)(path)) {
+    if (!(0, fs_1.existsSync)(folderPath)) {
         try {
-            (0, fs_1.mkdirSync)(path);
+            (0, fs_1.mkdirSync)(folderPath);
         }
         catch (error) {
-            console.error(error);
+            console.error("Failed to create folder:", error);
         }
     }
 };
 exports.checkFolder = checkFolder;
-var verifyProjectSettingFolder = function (projectId) {
-    var projectPath = path_1.default.join(filePath, "project_".concat(projectId));
+const verifyProjectSettingFolder = (projectId) => {
+    const projectPath = path_1.default.join(filePath, `project_${projectId}`);
     return (0, fs_1.existsSync)(filePath) && (0, fs_1.existsSync)(projectPath);
 };
 exports.verifyProjectSettingFolder = verifyProjectSettingFolder;
-var readFile = function (filePath) {
+const readFile = (filePath) => {
     try {
         if (!(0, fs_1.existsSync)(filePath)) {
             return null;
         }
-        var content = (0, fs_1.readFileSync)(filePath, "utf8");
+        const content = (0, fs_1.readFileSync)(filePath, "utf8");
         if (!content)
             return null;
         return JSON.parse(content);
     }
     catch (error) {
-        console.log("error :>> ", error);
+        console.error("Failed to read file:", error);
         return null;
     }
 };
 exports.readFile = readFile;
-var createFile = function (filePath, content) {
+const createFile = (filePath, content) => {
     try {
-        (0, fs_1.writeFileSync)(filePath, JSON.stringify(content));
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(content, null, 2));
     }
     catch (error) {
-        console.log("error :>> ", error);
+        console.error("Failed to create file:", error);
     }
 };
 exports.createFile = createFile;
-var loadJsonFilesFromSubfolder = function (projectId, subfolder, excludeFiles) {
-    if (excludeFiles === void 0) { excludeFiles = []; }
+const loadJsonFilesFromSubfolder = (projectId, subfolder, excludeFiles = []) => {
     if (!projectId)
         return [];
-    var isMainExists = (0, exports.verifyProjectSettingFolder)(projectId);
+    const isMainExists = (0, exports.verifyProjectSettingFolder)(projectId);
     if (!isMainExists)
         return [];
-    var folderPath = path_1.default.join(filePath, "project_".concat(projectId), subfolder);
+    const folderPath = path_1.default.join(filePath, `project_${projectId}`, subfolder);
     if (!(0, fs_1.existsSync)(folderPath))
         return [];
-    var files = (0, fs_1.readdirSync)(folderPath);
-    var result = [];
-    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
-        var file = files_1[_i];
+    const files = (0, fs_1.readdirSync)(folderPath);
+    const result = [];
+    for (const file of files) {
         if (!file.endsWith(".json") || excludeFiles.includes(file))
             continue;
-        var json = (0, exports.readFile)(path_1.default.join(folderPath, file));
+        const json = (0, exports.readFile)(path_1.default.join(folderPath, file));
         if (json) {
             result.push(json);
         }
@@ -75,43 +73,41 @@ var loadJsonFilesFromSubfolder = function (projectId, subfolder, excludeFiles) {
     return result;
 };
 exports.loadJsonFilesFromSubfolder = loadJsonFilesFromSubfolder;
-var loadSingleJsonFromSubfolder = function (projectId, subfolder, fileName) {
+const loadSingleJsonFromSubfolder = (projectId, subfolder, fileName) => {
     if (!projectId || !fileName)
         return null;
-    var isMainExists = (0, exports.verifyProjectSettingFolder)(projectId);
+    const isMainExists = (0, exports.verifyProjectSettingFolder)(projectId);
     if (!isMainExists)
         return null;
-    var folderPath = path_1.default.join(filePath, "project_".concat(projectId), subfolder);
+    const folderPath = path_1.default.join(filePath, `project_${projectId}`, subfolder);
     if (!(0, fs_1.existsSync)(folderPath))
         return null;
-    var iFilePath = path_1.default.join(folderPath, "".concat(fileName, ".json"));
-    return (0, exports.readFile)(iFilePath);
+    const fullFilePath = path_1.default.join(folderPath, `${fileName}.json`);
+    return (0, exports.readFile)(fullFilePath);
 };
 exports.loadSingleJsonFromSubfolder = loadSingleJsonFromSubfolder;
-var saveEntities = function (projectId, folderName, entities, getFileName, handleExtraSave) {
+const saveEntities = (projectId, folderName, entities, getFileName, handleExtraSave) => {
     if (!projectId || !Array.isArray(entities) || entities.length === 0) {
         return;
     }
     (0, exports.checkFolder)(filePath);
-    var projectFolder = path_1.default.join(filePath, "project_".concat(projectId));
+    const projectFolder = path_1.default.join(filePath, `project_${projectId}`);
     (0, exports.checkFolder)(projectFolder);
-    var targetFolder = path_1.default.join(projectFolder, folderName);
+    const targetFolder = path_1.default.join(projectFolder, folderName);
     (0, exports.checkFolder)(targetFolder);
-    for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
-        var entity = entities_1[_i];
-        var fileName = getFileName(entity);
+    for (const entity of entities) {
+        const fileName = getFileName(entity);
         if (!fileName || typeof fileName !== "string")
             continue;
         try {
-            var filePath_1 = path_1.default.join(targetFolder, "".concat(fileName, ".json"));
-            console.log("".concat(folderName, " filePath :>> "), filePath_1);
-            (0, exports.createFile)(filePath_1, entity);
+            const filePath = path_1.default.join(targetFolder, `${fileName}.json`);
+            (0, exports.createFile)(filePath, entity);
             if (handleExtraSave) {
                 handleExtraSave(targetFolder, entity);
             }
         }
         catch (error) {
-            console.error("Failed to save ".concat(folderName, " \"").concat(fileName, "\":"), error);
+            console.error(`Failed to save ${folderName} "${fileName}":`, error);
         }
     }
 };