drapcode-utility 2.0.1 → 2.0.2

package/build/utils/prepare-query.js

@@ -1,22 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonLookupSetting = exports.prepareChildRefCreatedByLookup = exports.prepareCreatedByLookup = void 0;
-var drapcode_constant_1 = require("drapcode-constant");
-var prepareCreatedByLookup = function (lookupConfig, aggregateQuery, field) {
-    var _a;
-    var enableLookup = lookupConfig.enableLookup, lookups = lookupConfig.lookups;
-    var findCollInLookup = lookups
-        ? lookups.find(function (lkp) { return lkp.collectionName === "createdBy"; })
+const drapcode_constant_1 = require("drapcode-constant");
+const prepareCreatedByLookup = (lookupConfig, aggregateQuery, field) => {
+    const { enableLookup, lookups } = lookupConfig;
+    const findCollInLookup = lookups
+        ? lookups.find((lkp) => lkp.collectionName === "createdBy")
         : null;
     if (!enableLookup || findCollInLookup) {
         aggregateQuery.push({
             $lookup: {
                 from: "user",
-                let: (_a = {}, _a["".concat(field.fieldName)] = "$".concat(field.fieldName), _a),
+                let: { [`${field.fieldName}`]: `$${field.fieldName}` },
                 pipeline: [
                     {
                         $match: {
-                            $expr: { $eq: ["$uuid", "$$".concat(field.fieldName)] },
+                            $expr: { $eq: ["$uuid", `$$${field.fieldName}`] },
                         },
                     },
                     { $project: { _id: 0, password: 0 } },
@@ -27,32 +26,39 @@ var prepareCreatedByLookup = function (lookupConfig, aggregateQuery, field) {
     }
 };
 exports.prepareCreatedByLookup = prepareCreatedByLookup;
-var prepareChildRefCreatedByLookup = function (collectionName, findCollInLookup, lookupConfig, field, aggregateQuery) {
-    var _a;
-    var enableLookup = lookupConfig.enableLookup;
-    var pPipeline = [];
+const prepareChildRefCreatedByLookup = (collectionName, findCollInLookup, lookupConfig, field, aggregateQuery) => {
+    const { enableLookup } = lookupConfig;
+    const pPipeline = [];
+    // pPipeline.push({
+    //   $match: {
+    //     $expr: {
+    //       $in: [
+    //         "$uuid",
+    //         {
+    //           $cond: {
+    //             if: {
+    //               $or: [
+    //                 { $eq: [`$$${field.fieldName}`, null] },
+    //                 { $eq: [`$$${field.fieldName}`, ""] },
+    //               ],
+    //             },
+    //             then: [],
+    //             else: { $ifNull: [`$$${field.fieldName}`, []] },
+    //           },
+    //         },
+    //       ],
+    //     },
+    //   },
+    // });
     pPipeline.push({
         $match: {
             $expr: {
-                $in: [
-                    "$uuid",
-                    {
-                        $cond: {
-                            if: {
-                                $in: ["$$".concat(field.fieldName), ["", null]],
-                            },
-                            then: [],
-                            else: {
-                                $ifNull: ["$$".concat(field.fieldName), []],
-                            },
-                        },
-                    },
-                ],
+                $in: ["$uuid", { $ifNull: [`$$${field.fieldName}`, []] }],
             },
         },
     });
-    var findChildLookup = findCollInLookup && findCollInLookup.childLookups
-        ? findCollInLookup.childLookups.find(function (chlkp) { return chlkp.collectionName === "createdBy"; })
+    const findChildLookup = findCollInLookup && findCollInLookup.childLookups
+        ? findCollInLookup.childLookups.find((chlkp) => chlkp.collectionName === "createdBy")
         : null;
     if (!enableLookup || findChildLookup) {
         pPipeline.push({
@@ -73,44 +79,42 @@ var prepareChildRefCreatedByLookup = function (collectionName, findCollInLookup,
     }
     aggregateQuery.push({
         $lookup: {
-            from: "".concat(collectionName),
-            let: (_a = {}, _a["".concat(field.fieldName)] = "$".concat(field.fieldName), _a),
+            from: `${collectionName}`,
+            let: { [`${field.fieldName}`]: `$${field.fieldName}` },
             pipeline: pPipeline,
             as: field.fieldName,
         },
     });
 };
 exports.prepareChildRefCreatedByLookup = prepareChildRefCreatedByLookup;
-var commonLookupSetting = function (field, lookupConfig, aggregateQuery) {
-    var _a;
-    console.log("lookupConfig commonLookupSetting", lookupConfig);
-    var enableLookup = lookupConfig.enableLookup, lookups = lookupConfig.lookups;
+const commonLookupSetting = (field, lookupConfig, aggregateQuery) => {
+    const { enableLookup, lookups } = lookupConfig;
     if (drapcode_constant_1.BelongsToReferenceField.includes(field.type)) {
-        var collectionName_1 = field.refCollection
+        let collectionName = field.refCollection
             ? field.refCollection["collectionName"]
             : null;
-        if (collectionName_1) {
-            var findCollInLookup = lookups
-                ? lookups.find(function (lkp) { return lkp.collectionName === collectionName_1; })
+        if (collectionName) {
+            const findCollInLookup = lookups
+                ? lookups.find((lkp) => lkp.collectionName === collectionName)
                 : null;
             if (!enableLookup || findCollInLookup) {
                 if (field.type === "belongsTo") {
                     aggregateQuery.push({
                         $lookup: {
-                            from: "".concat(collectionName_1),
+                            from: collectionName,
                             localField: field.fieldName,
                             foreignField: "uuid",
                             as: field.fieldName,
                         },
                     });
                     aggregateQuery.push({
-                        $addFields: (_a = {},
-                            _a["_$belongsToMetaData"] = field,
-                            _a),
+                        $addFields: {
+                            [`_$belongsToMetaData`]: trimFieldForRefCollection(field),
+                        },
                     });
                 }
                 else {
-                    (0, exports.prepareChildRefCreatedByLookup)(collectionName_1, findCollInLookup, lookupConfig, field, aggregateQuery);
+                    (0, exports.prepareChildRefCreatedByLookup)(collectionName, findCollInLookup, lookupConfig, field, aggregateQuery);
                 }
             }
         }
@@ -120,3 +124,26 @@ var commonLookupSetting = function (field, lookupConfig, aggregateQuery) {
     }
 };
 exports.commonLookupSetting = commonLookupSetting;
+const trimFieldForRefCollection = (field) => {
+    if (!field) {
+        return field;
+    }
+    const copyField = Object.assign({}, field);
+    delete copyField.fieldTitle;
+    delete copyField.placeholder;
+    delete copyField.validation;
+    delete copyField.createdAt;
+    delete copyField.updatedAt;
+    delete copyField._id;
+    delete copyField.isGenerateURL;
+    delete copyField.isGenerateIcons;
+    delete copyField.isPrivate;
+    delete copyField.encrypted;
+    delete copyField.isPluginField;
+    delete copyField.isMultiSelect;
+    if (!copyField.staticOptions || copyField.staticOptions.length === 0)
+        delete copyField.staticOptions;
+    delete copyField.required;
+    console.log("copyField :>> ", copyField);
+    return copyField;
+};

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

@@ -1,5 +1,43 @@
-export declare const saveProjectToFile: (project: any) => void;
-export declare const findProjectFromFile: (query: any) => any;
-export declare const updateProjectInFile: () => void;
-export declare const removeProjectFromFile: (project: any) => void;
-export declare const clearProjectSubfolder: (projectId: string, subfolder: string) => null | undefined;
+import { FileContent } from "./file-util";
+interface Project extends FileContent {
+    uuid: string;
+    seoName: string;
+    apiDomainName?: string;
+    domainName?: string;
+}
+interface ProjectQuery {
+    or?: Array<{
+        [key: string]: string;
+    }>;
+    apiDomainName?: string;
+    seoName?: string;
+    domainName?: string;
+    uuid?: string;
+}
+/**
+ * Saves a project to the file system
+ * @param project - The project to save
+ * @throws {ProjectError} If project is invalid or file operations fail
+ */
+export declare const saveProjectToFile: (project: Project) => void;
+/**
+ * Finds a project from the file system based on query parameters
+ * @param query - The query parameters to find the project
+ * @returns The found project or null if not found
+ * @throws {ProjectError} If file operations fail
+ */
+export declare const findProjectFromFile: (query: ProjectQuery) => Project | null;
+/**
+ * Removes a project from the file system
+ * @param project - The project to remove
+ * @throws {ProjectError} If project is invalid or file operations fail
+ */
+export declare const removeProjectFromFile: (project: Project) => void;
+/**
+ * Clears a project subfolder
+ * @param projectId - The project ID
+ * @param subfolder - The subfolder to clear
+ * @throws {ProjectError} If file operations fail
+ */
+export declare const clearProjectSubfolder: (projectId: string, subfolder: string) => void;
+export {};

package/build/utils/project-util.js

@@ -3,149 +3,204 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearProjectSubfolder = exports.removeProjectFromFile = exports.updateProjectInFile = exports.findProjectFromFile = exports.saveProjectToFile = void 0;
-var fs_1 = require("fs");
-var path_1 = __importDefault(require("path"));
-var file_util_1 = require("./file-util");
-var filePath = process.env.BUILD_FOLDER;
-var saveProjectToFile = function (project) {
-    if (!project) {
-        return;
-    }
-    (0, file_util_1.checkFolder)(filePath);
-    var projectPath = path_1.default.join(filePath, "projects");
-    (0, file_util_1.checkFolder)(projectPath);
-    var uuid = project.uuid, seoName = project.seoName, apiDomainName = project.apiDomainName, domainName = project.domainName;
-    console.log("Create UUID JSON file");
-    (0, file_util_1.createFile)(path_1.default.join(projectPath, "".concat(uuid, ".json")), project);
-    console.log("Create SeoName JSON file");
-    (0, file_util_1.createFile)(path_1.default.join(projectPath, "".concat(seoName, ".json")), project);
-    if (apiDomainName) {
-        console.log("Create API Domain JSON file");
-        (0, file_util_1.createFile)(path_1.default.join(projectPath, "".concat(apiDomainName, ".json")), project);
-    }
-    if (domainName) {
-        console.log("Create Domain JSON file");
-        (0, file_util_1.createFile)(path_1.default.join(projectPath, "".concat(domainName, ".json")), project);
+exports.clearProjectSubfolder = exports.removeProjectFromFile = exports.findProjectFromFile = exports.saveProjectToFile = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const file_util_1 = require("./file-util");
+// Constants
+const PROJECTS_FOLDER = "projects";
+const PROJECT_PREFIX = "project_";
+// Error types
+class ProjectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProjectError";
+    }
+}
+// Configuration
+const filePath = process.env.BUILD_FOLDER || "";
+/**
+ * Saves a project to the file system
+ * @param project - The project to save
+ * @throws {ProjectError} If project is invalid or file operations fail
+ */
+const saveProjectToFile = (project) => {
+    if (!project?.uuid || !project?.seoName) {
+        throw new ProjectError("Invalid project: missing required fields");
+    }
+    try {
+        (0, file_util_1.checkFolder)(filePath);
+        const projectPath = path_1.default.join(filePath, PROJECTS_FOLDER);
+        (0, file_util_1.checkFolder)(projectPath);
+        const filePaths = getProjectFilePaths(project, projectPath);
+        console.log("Creating project files...");
+        Object.entries(filePaths).forEach(([key, filePath]) => {
+            console.log("key :>> ", key);
+            if (filePath) {
+                (0, file_util_1.createFile)(filePath, project);
+            }
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to save project:", message);
+        throw new ProjectError(`Failed to save project: ${message}`);
     }
 };
 exports.saveProjectToFile = saveProjectToFile;
-var findProjectFromFile = function (query) {
-    var _a, _b;
-    var isMainExists = verifyProjectsFolder();
-    if (!isMainExists) {
+/**
+ * Finds a project from the file system based on query parameters
+ * @param query - The query parameters to find the project
+ * @returns The found project or null if not found
+ * @throws {ProjectError} If file operations fail
+ */
+const findProjectFromFile = (query) => {
+    try {
+        if (!verifyProjectsFolder()) {
+            return null;
+        }
+        const projectPath = path_1.default.join(filePath, PROJECTS_FOLDER);
+        const { or, apiDomainName, seoName, domainName, uuid } = query;
+        // Check by UUID first as it's the most reliable identifier
+        if (uuid) {
+            console.log("Checking for Project UUID");
+            return (0, file_util_1.readFile)(path_1.default.join(projectPath, `${uuid}.json`));
+        }
+        // Check other identifiers
+        const identifiers = [
+            { value: apiDomainName, type: "API Domain" },
+            { value: seoName, type: "SEO Name" },
+            { value: domainName, type: "Domain Name" },
+        ];
+        for (const { value, type } of identifiers) {
+            if (value) {
+                console.log(`Checking for Project ${type}`);
+                const project = (0, file_util_1.readFile)(path_1.default.join(projectPath, `${value}.json`));
+                if (project)
+                    return project;
+            }
+        }
+        // Check OR conditions
+        if (or?.length) {
+            const pSeoName = extractDomainSeo(or, "seoName")?.["seoName"];
+            const pDomainName = extractDomainSeo(or, "domainName")?.["domainName"];
+            if (pSeoName) {
+                console.log("Checking for Project SEO Name");
+                return (0, file_util_1.readFile)(path_1.default.join(projectPath, `${pSeoName}.json`));
+            }
+            if (pDomainName) {
+                console.log("Checking for Project Domain Name");
+                return (0, file_util_1.readFile)(path_1.default.join(projectPath, `${pDomainName}.json`));
+            }
+        }
         return null;
     }
-    var projectPath = path_1.default.join(filePath, "projects");
-    var or = query.or, apiDomainName = query.apiDomainName, seoName = query.seoName, domainName = query.domainName, uuid = query.uuid;
-    if (uuid) {
-        //If uuid exists then please check with this no need of or
-        console.log("Checking for Project UUID");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(uuid, ".json")));
-        return project;
-    }
-    if (apiDomainName) {
-        //If api domain exists then please check with this no need of or
-        console.log("Checking for Project API Domain");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(apiDomainName, ".json")));
-        return project;
-    }
-    if (seoName) {
-        //IF api seo name exists then not need to check or
-        console.log("Checking for Project SEO Name");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(seoName, ".json")));
-        return project;
-    }
-    if (domainName) {
-        //IF api seo name exists then not need to check or
-        console.log("Checking for Project SEO Name");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(domainName, ".json")));
-        return project;
-    }
-    if (!or || or.length === 0) {
-        return null;
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to find project:", message);
+        throw new ProjectError(`Failed to find project: ${message}`);
     }
-    var pSeoName = (_a = extractDomainSeo(or, "seoName")) === null || _a === void 0 ? void 0 : _a["seoName"];
-    var pDomainName = (_b = extractDomainSeo(or, "domainName")) === null || _b === void 0 ? void 0 : _b["domainName"];
-    // Now check with pSeoName and domainName
-    console.log("pSeoName :>> ", pSeoName);
-    console.log("domainName :>> ", domainName);
-    if (pSeoName) {
-        //IF api seo name exists then not need to check or
-        console.log("Checking for Project SEO Name");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(pSeoName, ".json")));
-        return project;
-    }
-    if (pDomainName) {
-        //IF api seo name exists then not need to check or
-        console.log("Checking for Project Domain Name");
-        var project = (0, file_util_1.readFile)(path_1.default.join(projectPath, "".concat(pDomainName, ".json")));
-        return project;
-    }
-    return null;
 };
 exports.findProjectFromFile = findProjectFromFile;
-var updateProjectInFile = function () { };
-exports.updateProjectInFile = updateProjectInFile;
-var removeProjectFromFile = function (project) {
-    //Check if projects folder exists in filePath or not
-    //Remove
-    if (!project) {
-        console.log("I do not have project");
-        return;
-    }
-    var isMainExists = verifyProjectsFolder();
-    console.log("Project Folder failed", isMainExists);
-    if (!isMainExists) {
-        return;
-    }
-    var projectPath = path_1.default.join(filePath, "projects");
-    console.log("Check path", projectPath);
-    var uuid = project.uuid, seoName = project.seoName, apiDomainName = project.apiDomainName, domainName = project.domainName;
-    console.log("Removing UUID JSON");
-    removeFile(path_1.default.join(projectPath, "".concat(uuid, ".json")));
-    console.log("Removing Seo Name JSON");
-    removeFile(path_1.default.join(projectPath, "".concat(seoName, ".json")));
-    if (apiDomainName) {
-        console.log("Removing API Domain JSON");
-        removeFile(path_1.default.join(projectPath, "".concat(apiDomainName, ".json")));
-    }
-    if (domainName) {
-        console.log("Removing Domain JSON");
-        removeFile(path_1.default.join(projectPath, "".concat(domainName, ".json")));
+/**
+ * Removes a project from the file system
+ * @param project - The project to remove
+ * @throws {ProjectError} If project is invalid or file operations fail
+ */
+const removeProjectFromFile = (project) => {
+    if (!project?.uuid || !project?.seoName) {
+        throw new ProjectError("Invalid project: missing required fields");
+    }
+    try {
+        if (!verifyProjectsFolder()) {
+            return;
+        }
+        const projectPath = path_1.default.join(filePath, PROJECTS_FOLDER);
+        const filePaths = getProjectFilePaths(project, projectPath);
+        console.log("Removing project files...");
+        Object.entries(filePaths).forEach(([key, filePath]) => {
+            console.log("key :>> ", key);
+            if (filePath) {
+                removeFile(filePath);
+            }
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to remove project:", message);
+        throw new ProjectError(`Failed to remove project: ${message}`);
     }
 };
 exports.removeProjectFromFile = removeProjectFromFile;
-var clearProjectSubfolder = function (projectId, subfolder) {
-    if (!projectId)
-        return;
-    var isMainExists = (0, file_util_1.verifyProjectSettingFolder)(projectId);
-    if (!isMainExists)
-        return null;
-    var projectPath = path_1.default.join(filePath, "project_".concat(projectId), subfolder);
-    removeFolder(projectPath);
+/**
+ * Clears a project subfolder
+ * @param projectId - The project ID
+ * @param subfolder - The subfolder to clear
+ * @throws {ProjectError} If file operations fail
+ */
+const clearProjectSubfolder = (projectId, subfolder) => {
+    if (!projectId) {
+        throw new ProjectError("Project ID is required");
+    }
+    if (!subfolder) {
+        throw new ProjectError("Sub Folder is required");
+    }
+    try {
+        if ((0, file_util_1.verifyProjectSettingFolder)(projectId)) {
+            return;
+        }
+        const projectPath = path_1.default.join(filePath, `${PROJECT_PREFIX}${projectId}`, subfolder);
+        removeFolder(projectPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to clear project subfolder:", message);
+        throw new ProjectError(`Failed to clear project subfolder: ${message}`);
+    }
 };
 exports.clearProjectSubfolder = clearProjectSubfolder;
-var verifyProjectsFolder = function () {
-    var projectPath = path_1.default.join(filePath, "projects");
+// Helper functions
+const verifyProjectsFolder = () => {
+    const projectPath = path_1.default.join(filePath, PROJECTS_FOLDER);
     return (0, fs_1.existsSync)(filePath) && (0, fs_1.existsSync)(projectPath);
 };
-var removeFile = function (filePath) {
+const removeFile = (filePath) => {
     try {
-        (0, fs_1.existsSync)(filePath) && (0, fs_1.unlinkSync)(filePath);
+        if ((0, fs_1.existsSync)(filePath)) {
+            (0, fs_1.unlinkSync)(filePath);
+        }
     }
     catch (error) {
-        console.log("error :>> ", error);
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to remove file:", message);
+        throw new ProjectError(`Failed to remove file: ${message}`);
     }
 };
-var removeFolder = function (folderPath) {
+const removeFolder = (folderPath) => {
     try {
-        (0, fs_1.existsSync)(folderPath) && (0, fs_1.rmdirSync)(folderPath, { recursive: true });
+        if ((0, fs_1.existsSync)(folderPath)) {
+            (0, fs_1.rmdirSync)(folderPath, { recursive: true });
+        }
     }
     catch (error) {
-        console.log("error :>> ", error);
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to remove folder:", message);
+        throw new ProjectError(`Failed to remove folder: ${message}`);
     }
 };
-function extractDomainSeo(or, key) {
-    return or.find(function (obj) { return Object.keys(obj)[0] === key; });
-}
+const extractDomainSeo = (or, key) => {
+    return or.find((obj) => Object.keys(obj)[0] === key);
+};
+const getProjectFilePaths = (project, projectPath) => {
+    const { uuid, seoName, apiDomainName, domainName } = project;
+    return {
+        uuidPath: path_1.default.join(projectPath, `${uuid}.json`),
+        seoNamePath: path_1.default.join(projectPath, `${seoName}.json`),
+        apiDomainNamePath: apiDomainName
+            ? path_1.default.join(projectPath, `${apiDomainName}.json`)
+            : undefined,
+        domainNamePath: domainName
+            ? path_1.default.join(projectPath, `${domainName}.json`)
+            : undefined,
+    };
+};

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

@@ -1,2 +1,2 @@
-export declare const queryParser: (collectionName: string, query: any, constants: any[], externalParams: any, currentUser: any, timezone: string, searchObj: any, refCollectionFieldsInItems: any, searchQueryTypeObj: any, currentTenant: any, currentUserSetting: any, currentSubTenant: any, lookupConfig: any, rowLevelSecurityFilter: any) => Promise<any>;
+export declare const queryParser: (collectionName: string, query: any, constants: any[], externalParams: any, currentUser: any | undefined, timezone: string, searchObj: any | undefined, refCollectionFieldsInItems: any | undefined, searchQueryTypeObj: any | undefined, currentTenant: any | undefined, currentUserSetting: any | undefined, currentSubTenant: any | undefined, lookupConfig: any | undefined, rowLevelSecurityFilter: any) => Promise<any>;
 export declare const isEntityInCondition: (value: any) => boolean;