drapcode-utility 1.0.0

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

@@ -0,0 +1,132 @@
+export declare const prepareCollectionQuery: (matchQuery: object, filterId: string) => ({
+    $match: object;
+    $addFields?: undefined;
+    $unwind?: undefined;
+    $group?: undefined;
+    $project?: undefined;
+} | {
+    $addFields: {
+        finder: {
+            $filter: {
+                input: string;
+                as: string;
+                cond: {
+                    $eq: string[];
+                };
+            };
+        };
+        refCollectionFields: {
+            $filter: {
+                input: string;
+                as: string;
+                cond: {
+                    $or: {
+                        $eq: string[];
+                    }[];
+                };
+            };
+        };
+        filterFinder?: undefined;
+    };
+    $match?: undefined;
+    $unwind?: undefined;
+    $group?: undefined;
+    $project?: undefined;
+} | {
+    $unwind: string;
+    $match?: undefined;
+    $addFields?: undefined;
+    $group?: undefined;
+    $project?: undefined;
+} | {
+    $addFields: {
+        filterFinder: string;
+        finder?: undefined;
+        refCollectionFields?: undefined;
+    };
+    $match?: undefined;
+    $unwind?: undefined;
+    $group?: undefined;
+    $project?: undefined;
+} | {
+    $unwind: {
+        path: string;
+        preserveNullAndEmptyArrays: boolean;
+    };
+    $match?: undefined;
+    $addFields?: undefined;
+    $group?: undefined;
+    $project?: undefined;
+} | {
+    $group: {
+        _id: null;
+        filterFinder: {
+            $first: string;
+        };
+        fields: {
+            $first: string;
+        };
+        noOfExternalParams: {
+            $first: string;
+        };
+        isPrivate: {
+            $first: string;
+        };
+        finder: {
+            $first: string;
+        };
+        refCollectionFields: {
+            $first: string;
+        };
+        constants: {
+            $first: string;
+        };
+        isInMemory: {
+            $first: string;
+        };
+        projectId: {
+            $first: string;
+        };
+        lastRefreshTime: {
+            $first: string;
+        };
+        collectionName: {
+            $first: string;
+        };
+        externalParams: {
+            $push: {
+                $cond: (string | {
+                    $and: ({
+                        $gt: (string | number)[];
+                        $eq?: undefined;
+                    } | {
+                        $eq: (string | boolean)[];
+                        $gt?: undefined;
+                    })[];
+                })[];
+            };
+        };
+    };
+    $match?: undefined;
+    $addFields?: undefined;
+    $unwind?: undefined;
+    $project?: undefined;
+} | {
+    $project: {
+        noOfExternalParams: number;
+        finder: string;
+        isInMemory: number;
+        lastRefreshTime: number;
+        constants: number;
+        collectionName: number;
+        refCollectionFields: number;
+        externalParams: number;
+        projectId: number;
+        isPrivate: number;
+        fields: number;
+    };
+    $match?: undefined;
+    $addFields?: undefined;
+    $unwind?: undefined;
+    $group?: undefined;
+})[];

package/build/utils/prepare-query.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareCollectionQuery = void 0;
+var prepareCollectionQuery = function (matchQuery, filterId) {
+    var query = [
+        { $match: matchQuery },
+        {
+            $addFields: {
+                finder: {
+                    $filter: {
+                        input: "$finders",
+                        as: "finder",
+                        cond: { $eq: ["$$finder.uuid", filterId] },
+                    },
+                },
+                refCollectionFields: {
+                    $filter: {
+                        input: "$fields",
+                        as: "fields",
+                        cond: {
+                            $or: [
+                                { $eq: ["$$fields.type", "reference"] },
+                                { $eq: ["$$fields.type", "multi_reference"] },
+                                { $eq: ["$$fields.type", "belongsTo"] },
+                                { $eq: ["$$fields.type", "createdBy"] },
+                            ],
+                        },
+                    },
+                },
+            },
+        },
+        { $unwind: "$finder" },
+        {
+            $addFields: { filterFinder: "$finder" },
+        },
+        {
+            $unwind: {
+                path: "$finder.conditions",
+                preserveNullAndEmptyArrays: true,
+            },
+        },
+        {
+            $group: {
+                _id: null,
+                filterFinder: { $first: "$filterFinder" },
+                fields: { $first: "$fields" },
+                noOfExternalParams: { $first: "$finder.noOfExternalParams" },
+                isPrivate: { $first: "$finder.isPrivate" },
+                finder: { $first: "$finder" },
+                refCollectionFields: { $first: "$refCollectionFields" },
+                constants: { $first: "$constants" },
+                isInMemory: { $first: "$isInMemory" },
+                projectId: { $first: "$projectId" },
+                lastRefreshTime: { $first: "$lastRefreshTime" },
+                collectionName: { $first: "$collectionName" },
+                externalParams: {
+                    $push: {
+                        $cond: [
+                            {
+                                $and: [
+                                    {
+                                        $gt: ["$finder.noOfExternalParams", 0],
+                                    },
+                                    {
+                                        $eq: ["$finder.conditions.requiredExternal", true],
+                                    },
+                                ],
+                            },
+                            "$finder.conditions.query.value",
+                            "$$REMOVE",
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            $project: {
+                noOfExternalParams: 1,
+                finder: "$filterFinder",
+                isInMemory: 1,
+                lastRefreshTime: 1,
+                constants: 1,
+                collectionName: 1,
+                refCollectionFields: 1,
+                externalParams: 1,
+                projectId: 1,
+                isPrivate: 1,
+                fields: 1,
+            },
+        },
+    ];
+    return query;
+};
+exports.prepareCollectionQuery = prepareCollectionQuery;

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

@@ -0,0 +1,11 @@
+export declare const queryParser: (collectionName: string, query: any, constants: any[], externalParams: any, currentUser: any, timezone: string, searchObj?: any, refCollectionFieldsInItems?: any, searchQueryTypeObj?: any, currentTenant?: any) => Promise<string>;
+export declare const isEntityInCondition: (value: any) => boolean;
+export declare const getMinMaxValue: (value: any) => {
+    startValue: any;
+    endValue: any;
+    isInteger: any;
+} | {
+    startValue: string;
+    endValue: string;
+    isInteger?: undefined;
+};