@flowerforce/flowerbase 1.7.5-beta.1 → 1.7.5-beta.3

package/dist/features/functions/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/features/functions/controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAoFhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAqPjC,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/features/functions/controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAgGhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAsPjC,CAAA"}

package/dist/features/functions/controller.js

@@ -58,6 +58,16 @@ const isReturnedError = (value) => {
 };
 const serializeEjson = (value) => JSON.stringify(bson_1.EJSON.serialize(value, { relaxed: false }));
 const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const isCursorLike = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    return typeof value.toArray === 'function';
+};
+const normalizeFunctionResult = (value) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isCursorLike(value))
+        return value;
+    return yield value.toArray();
+});
 const sharedWatchStreams = new Map();
 let watchSubscriberCounter = 0;
 const parseWatchFilter = (args) => {
@@ -136,12 +146,13 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 functionsList,
                 services: services_1.services
             });
-            if (isReturnedError(result)) {
+            const normalizedResult = yield normalizeFunctionResult(result);
+            if (isReturnedError(normalizedResult)) {
                 res.type('application/json');
-                return JSON.stringify({ message: result.message, name: result.name });
+                return JSON.stringify({ message: normalizedResult.message, name: normalizedResult.name });
             }
             res.type('application/json');
-            return serializeEjson(result);
+            return serializeEjson(normalizedResult);
         }
         catch (error) {
             res.status(400);

package/dist/features/triggers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/features/triggers/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAA;AAG/C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAU,0CAIpC,sBAAsB,kBAoExB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/features/triggers/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAA;AAG/C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAU,0CAIpC,sBAAsB,kBAqExB,CAAA"}

package/dist/features/triggers/index.js

@@ -79,6 +79,8 @@ const activateTriggers = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fa
                 _f = false;
                 const trigger = _d;
                 const { content } = trigger;
+                if (content.disabled)
+                    continue;
                 const { type, config, event_processors } = content;
                 const functionName = event_processors.FUNCTION.config.function_name;
                 const triggerHandler = functionsList[functionName];

package/dist/services/api/index.d.ts

@@ -30,6 +30,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -58,6 +59,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -86,6 +88,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -114,6 +117,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;

package/dist/services/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,MAAM;IAAE,UAAU,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE;UAG5D,CAAC,wCAAoD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuB7D,CAAC,gGASX,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BD,CAAC,gGASV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+BG,CAAC,wEAOb,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAA;AAED,eAAe,GAAG,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,MAAM;IAAE,UAAU,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE;UAG5D,CAAC,wCAAoD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuB7D,CAAC,gGASX,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BD,CAAC,gGASV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+BG,CAAC,wEAOb,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAA;AAED,eAAe,GAAG,CAAA"}

package/dist/services/api/utils.d.ts

@@ -29,6 +29,7 @@ export declare const makeRequest: <T = null>({ method, url, headers, body, resol
         bytes: () => Uint8Array<ArrayBuffer>;
     };
     statusCode: number;
+    statusText: string;
     headers: import("undici/types/header").IncomingHttpHeaders;
     trailers: Record<string, string>;
     opaque: T;

package/dist/services/api/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgBlD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,6CAMzC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgBlD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,6CAMzC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAA"}

package/dist/services/index.d.ts

@@ -27,6 +27,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -55,6 +56,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -83,6 +85,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -111,6 +114,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;

package/dist/services/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;kBAMoG,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA2hB,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;sBAA0/F,CAAC;yBAAa,CAAC;;;;;;;;;;;CAD9rH,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;kBAMoG,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA2hB,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;sBAA0/F,CAAC;yBAAa,CAAC;;;;;;;;;;;CAD9rH,CAAA"}

package/dist/services/mongodb-atlas/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EACL,mBAAmB,EAEnB,MAAM,EAEN,UAAU,EACV,KAAK,EAGN,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAGlD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,IAAI,GAAG,MAAM,EAAE,2BAInD,kBAAkB,CAAC,CAAC,CAAC,QA8BvB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAS,MAAM,EAAO,EACtB,QAAQ,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EACtD,OAAO,IAAI,8BAcZ,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,UAAS,MAAM,EAAO,EACtB,OAAO,IAAI,KACV,UAAU,GAAG,IAaf,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,UAAU,mBAAmB,EAC7B,OAAO,MAAM,CACX,MAAM,EACN;IACE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CACf,CACF,EACD,MAAM,IAAI,EACV,gBAAgB,MAAM,EACtB,UAAU;IACR,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,KACA,mBA6GF,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,gBAAgB,MAAM,EACtB,WAAW,eAAe,SAM3B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE;;;;;;;;iBA2HuvrS,CAAC;sBAAgC,CAAC;2BAAsC,CAAC;;;;IAnH93rS;AAED,eAAO,MAAM,0BAA0B,GAAI,UAAU,QAAQ,EAAE,aAgC9D,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,mBAAmB,QA+BvE;AAED,wBAAgB,8BAA8B,CAAC,WAAW,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,YAK9E;AAyBD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,EAAE,uBAKtF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EACL,mBAAmB,EAEnB,MAAM,EAEN,UAAU,EACV,KAAK,EAGN,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAGlD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,IAAI,GAAG,MAAM,EAAE,2BAInD,kBAAkB,CAAC,CAAC,CAAC,QA8BvB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAS,MAAM,EAAO,EACtB,QAAQ,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EACtD,OAAO,IAAI,8BAcZ,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,UAAS,MAAM,EAAO,EACtB,OAAO,IAAI,KACV,UAAU,GAAG,IAaf,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,UAAU,mBAAmB,EAC7B,OAAO,MAAM,CACX,MAAM,EACN;IACE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CACf,CACF,EACD,MAAM,IAAI,EACV,gBAAgB,MAAM,EACtB,UAAU;IACR,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,KACA,mBA6GF,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,gBAAgB,MAAM,EACtB,WAAW,eAAe,SAM3B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE;;;;;;;;iBA0I8iqS,CAAC;sBAAgC,CAAC;2BAAsC,CAAC;;;;IAlIrrqS;AAED,eAAO,MAAM,0BAA0B,GAAI,UAAU,QAAQ,EAAE,aAgC9D,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,mBAAmB,QA+BvE;AAED,wBAAgB,8BAA8B,CAAC,WAAW,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,YAK9E;AAwCD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,EAAE,uBAKtF"}

package/dist/services/mongodb-atlas/utils.js

@@ -217,6 +217,7 @@ function getHiddenFieldsFromRulesConfig(rulesConfig) {
 }
 function collectHiddenFieldsFromRoles(roles = []) {
     const hiddenFields = new Set();
+    const isFieldPermissionObject = (value) => !!value && typeof value === 'object' && ('read' in value || 'write' in value);
     const collectFromFields = (fields) => {
         if (!fields)
             return;
@@ -227,9 +228,24 @@ function collectHiddenFieldsFromRoles(roles = []) {
             }
         });
     };
+    const collectFromAdditionalFields = (fields) => {
+        if (!fields || typeof fields !== 'object')
+            return;
+        // Global additional_fields permissions (read/write) apply to unknown fields and cannot be mapped.
+        if (isFieldPermissionObject(fields))
+            return;
+        Object.entries(fields).forEach(([fieldName, permissions]) => {
+            if (!isFieldPermissionObject(permissions))
+                return;
+            const canRead = Boolean(permissions.read || permissions.write);
+            if (!canRead) {
+                hiddenFields.add(fieldName);
+            }
+        });
+    };
     roles.forEach((role) => {
         collectFromFields(role.fields);
-        collectFromFields(role.additional_fields);
+        collectFromAdditionalFields(role.additional_fields);
     });
     return Array.from(hiddenFields);
 }

package/dist/utils/context/helpers.d.ts

@@ -82,6 +82,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -110,6 +111,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -138,6 +140,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -166,6 +169,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -230,6 +234,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -258,6 +263,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -286,6 +292,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -314,6 +321,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -377,6 +385,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -405,6 +414,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -433,6 +443,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -461,6 +472,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;

package/dist/utils/context/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;sCA1HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsGT,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAyEF,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAiBrE,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;sCA1HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsGT,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAyEF,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAiBrE,CAAA"}

package/dist/utils/roles/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAIrD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,CAAC,QAAQ,CAAC,EAChC,aAAa,oBAAoB,EACjC,OAAO,cAAc,CAAC,MAAM,CAAC,KAC5B,OAAO,CAAC,OAAO,CAgBjB,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAgBrD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,CAAC,QAAQ,CAAC,EAChC,aAAa,oBAAoB,EACjC,OAAO,cAAc,CAAC,MAAM,CAAC,KAC5B,OAAO,CAAC,OAAO,CAiBjB,CAAA"}

package/dist/utils/roles/helpers.js

@@ -19,26 +19,41 @@ const context_1 = require("../context");
 const rules_1 = require("../rules");
 const utils_1 = __importDefault(require("../rules-matcher/utils"));
 const functionsConditions = ['%%true', '%%false'];
+const normalizeUserRole = (user) => {
+    if (!user)
+        return user;
+    if (typeof user !== 'object')
+        return user;
+    const candidate = user;
+    if (typeof candidate.role === 'string')
+        return user;
+    const customRole = typeof candidate.custom_data === 'object' && candidate.custom_data !== null
+        ? candidate.custom_data.role
+        : undefined;
+    return typeof customRole === 'string' ? Object.assign(Object.assign({}, candidate), { role: customRole }) : user;
+};
 const evaluateExpression = (params, expression, user) => __awaiter(void 0, void 0, void 0, function* () {
     if (!expression || typeof expression === 'boolean')
         return !!expression;
-    const value = Object.assign(Object.assign(Object.assign({}, params.expansions), params.cursor), { '%%user': user, '%%true': true });
+    const normalizedUser = normalizeUserRole(user);
+    const value = Object.assign(Object.assign(Object.assign({}, params.expansions), params.cursor), { '%%user': normalizedUser, '%%true': true });
     const conditions = (0, rules_1.expandQuery)(expression, value);
     const complexCondition = Object.entries(conditions).find(([key]) => functionsConditions.includes(key));
     return complexCondition
-        ? yield evaluateComplexExpression(complexCondition, params, user)
+        ? yield evaluateComplexExpression(complexCondition, params, normalizedUser)
         : utils_1.default.checkRule(conditions, value, {});
 });
 exports.evaluateExpression = evaluateExpression;
 const evaluateComplexExpression = (condition, params, user) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const [key, config] = condition;
+    const normalizedUser = normalizeUserRole(user);
     const functionConfig = config['%function'];
     const { name, arguments: fnArguments } = functionConfig;
     const functionsList = state_1.StateManager.select('functions');
     const app = state_1.StateManager.select('app');
     const currentFunction = functionsList[name];
-    const expansionContext = Object.assign(Object.assign(Object.assign({}, params.expansions), params.cursor), { '%%root': params.cursor, '%%user': user, '%%true': true, '%%false': false });
+    const expansionContext = Object.assign(Object.assign(Object.assign({}, params.expansions), params.cursor), { '%%root': params.cursor, '%%user': normalizedUser, '%%true': true, '%%false': false });
     const expandedArguments = fnArguments && fnArguments.length
         ? ((_a = (0, rules_1.expandQuery)({ args: fnArguments }, expansionContext)
             .args) !== null && _a !== void 0 ? _a : [])
@@ -47,7 +62,7 @@ const evaluateComplexExpression = (condition, params, user) => __awaiter(void 0,
         args: expandedArguments,
         app,
         rules: state_1.StateManager.select("rules"),
-        user,
+        user: normalizedUser,
         currentFunction,
         functionName: name,
         functionsList,

package/dist/utils/roles/interface.d.ts

@@ -1,7 +1,13 @@
-export type PermissionExpression = boolean;
+export type PermissionExpression = boolean | Record<string, unknown>;
 export type FieldPermissionExpression = {
-    read?: boolean;
-    write?: boolean;
+    read?: PermissionExpression;
+    write?: PermissionExpression;
+    fields?: {
+        [K: string]: FieldPermissionExpression;
+    };
+};
+export type AdditionalFieldsPermissionExpression = FieldPermissionExpression | {
+    [K: string]: FieldPermissionExpression;
 };
 export interface DocumentFiltersPermissions {
     read?: PermissionExpression;
@@ -19,9 +25,7 @@ export interface Role {
     fields?: {
         [K: string]: FieldPermissionExpression;
     };
-    additional_fields?: {
-        [K: string]: FieldPermissionExpression;
-    };
+    additional_fields?: AdditionalFieldsPermissionExpression;
 }
 export interface Params {
     roles: Role[];

package/dist/utils/roles/interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/interface.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAA;AAE1C,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,oBAAoB,CAAA;CAC7B;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IAEZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,gBAAgB,CAAC,EAAE,0BAA0B,CAAA;IAC7C,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,oBAAoB,CAAA;IAC5B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,MAAM,CAAC,EAAE;QACP,CAAC,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAA;KACvC,CAAA;IACD,iBAAiB,CAAC,EAAE;QAClB,CAAC,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAA;KACvC,CAAA;CACF;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,IAAI,EAAE,CAAA;IAEb,MAAM,EAAE,GAAG,CAAA;IAEX,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAA;CACxD;AAGD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/interface.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEpE,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,oBAAoB,CAAA;IAC5B,MAAM,CAAC,EAAE;QACP,CAAC,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAA;KACvC,CAAA;CACF,CAAA;AAED,MAAM,MAAM,oCAAoC,GAC5C,yBAAyB,GACzB;IACE,CAAC,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAA;CACvC,CAAA;AAEL,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,oBAAoB,CAAA;CAC7B;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IAEZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,gBAAgB,CAAC,EAAE,0BAA0B,CAAA;IAC7C,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,oBAAoB,CAAA;IAC5B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,MAAM,CAAC,EAAE,oBAAoB,CAAA;IAC7B,MAAM,CAAC,EAAE;QACP,CAAC,CAAC,EAAE,MAAM,GAAG,yBAAyB,CAAA;KACvC,CAAA;IACD,iBAAiB,CAAC,EAAE,oCAAoC,CAAA;CACzD;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,IAAI,EAAE,CAAA;IAEb,MAAM,EAAE,GAAG,CAAA;IAEX,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAA;CACxD;AAGD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA"}

package/dist/utils/roles/machines/commonValidators.js

@@ -29,9 +29,9 @@ const evaluateTopLevelPermissionsFn = (_a, currentType_1) => __awaiter(void 0, [
 });
 exports.evaluateTopLevelPermissionsFn = evaluateTopLevelPermissionsFn;
 const checkFieldsPropertyExists = ({ role }) => {
-    var _a, _b;
+    var _a;
     const hasFields = !!Object.keys((_a = role === null || role === void 0 ? void 0 : role.fields) !== null && _a !== void 0 ? _a : {}).length;
-    const hasAdditional = !!Object.keys((_b = role === null || role === void 0 ? void 0 : role.additional_fields) !== null && _b !== void 0 ? _b : {}).length;
+    const hasAdditional = typeof (role === null || role === void 0 ? void 0 : role.additional_fields) !== 'undefined';
     return hasFields || hasAdditional;
 };
 exports.checkFieldsPropertyExists = checkFieldsPropertyExists;

package/dist/utils/roles/machines/fieldPermissions.d.ts

@@ -0,0 +1,8 @@
+import { Document } from 'mongodb';
+import { Role } from '../interface';
+import { MachineContext } from './interface';
+export declare const hasAdditionalFieldsDefined: (role?: Role) => boolean;
+export declare const filterDocumentByFieldPermissions: (context: Pick<MachineContext, "params" | "role" | "user">, mode: "read" | "write", options?: {
+    defaultAllow?: boolean;
+}) => Promise<Document>;
+//# sourceMappingURL=fieldPermissions.d.ts.map

package/dist/utils/roles/machines/fieldPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldPermissions.d.ts","sourceRoot":"","sources":["../../../../src/utils/roles/machines/fieldPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAGL,IAAI,EACL,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AA4C5C,eAAO,MAAM,0BAA0B,GAAI,OAAO,IAAI,YACN,CAAA;AAEhD,eAAO,MAAM,gCAAgC,GAC3C,SAAS,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC,EACzD,MAAM,MAAM,GAAG,OAAO,EACtB,UAAU;IACR,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,KACA,OAAO,CAAC,QAAQ,CAyBlB,CAAA"}

package/dist/utils/roles/machines/fieldPermissions.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterDocumentByFieldPermissions = exports.hasAdditionalFieldsDefined = void 0;
+const helpers_1 = require("../helpers");
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const isFieldPermissionExpression = (value) => isObject(value) && ('read' in value || 'write' in value);
+const getAdditionalFieldPermission = (additionalFields, fieldName) => {
+    if (!additionalFields || !isObject(additionalFields))
+        return undefined;
+    const byField = additionalFields[fieldName];
+    if (isFieldPermissionExpression(byField)) {
+        return byField;
+    }
+    if (isFieldPermissionExpression(additionalFields)) {
+        return additionalFields;
+    }
+    return undefined;
+};
+const canReadField = (context, permission) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!permission)
+        return false;
+    const read = yield (0, helpers_1.evaluateExpression)(context.params, permission.read, context.user);
+    if (read)
+        return true;
+    return yield (0, helpers_1.evaluateExpression)(context.params, permission.write, context.user);
+});
+const canWriteField = (context, permission) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!permission)
+        return false;
+    return yield (0, helpers_1.evaluateExpression)(context.params, permission.write, context.user);
+});
+const hasAdditionalFieldsDefined = (role) => typeof (role === null || role === void 0 ? void 0 : role.additional_fields) !== 'undefined';
+exports.hasAdditionalFieldsDefined = hasAdditionalFieldsDefined;
+const filterDocumentByFieldPermissions = (context, mode, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const source = (_a = context.params) === null || _a === void 0 ? void 0 : _a.cursor;
+    if (!isObject(source))
+        return {};
+    const document = {};
+    const fields = (_b = context.role.fields) !== null && _b !== void 0 ? _b : {};
+    const additionalFields = context.role.additional_fields;
+    for (const [key, value] of Object.entries(source)) {
+        const fieldPermission = fields[key];
+        const permission = fieldPermission !== null && fieldPermission !== void 0 ? fieldPermission : getAdditionalFieldPermission(additionalFields, key);
+        let allowed = (options === null || options === void 0 ? void 0 : options.defaultAllow) === true;
+        if (permission) {
+            allowed =
+                mode === 'read'
+                    ? yield canReadField(context, permission)
+                    : yield canWriteField(context, permission);
+        }
+        if (allowed) {
+            document[key] = value;
+        }
+    }
+    return document;
+});
+exports.filterDocumentByFieldPermissions = filterDocumentByFieldPermissions;

package/dist/utils/roles/machines/read/A/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/A/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAGxC,eAAO,MAAM,aAAa,EAAE,MAuB3B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/A/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAGxC,eAAO,MAAM,aAAa,EAAE,MAuB3B,CAAA"}

package/dist/utils/roles/machines/read/A/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STEP_A_STATES = void 0;
+const commonValidators_1 = require("../../commonValidators");
 const utils_1 = require("../../utils");
 exports.STEP_A_STATES = {
     checkSearchRequest: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, next, goToNextValidationStage }) {
@@ -24,14 +25,14 @@ exports.STEP_A_STATES = {
         }
         return goToNextValidationStage();
     }),
-    evaluateSearch: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, endValidation }) {
+    evaluateSearch: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, endValidation, goToNextValidationStage }) {
         (0, utils_1.logMachineInfo)({
             enabled: context.enableLog,
             machine: 'A',
             step: 2,
             stepName: 'evaluateSearch'
         });
-        // NOTE -> we don't support search operations
-        return endValidation({ success: false });
+        const check = yield (0, commonValidators_1.evaluateTopLevelPermissionsFn)(context, 'search');
+        return check ? goToNextValidationStage() : endValidation({ success: false });
     })
 };

package/dist/utils/roles/machines/read/C/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/C/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAGxC,eAAO,MAAM,aAAa,EAAE,MAyC3B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/C/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAQxC,eAAO,MAAM,aAAa,EAAE,MAyC3B,CAAA"}

package/dist/utils/roles/machines/read/C/index.js

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STEP_C_STATES = void 0;
-const validators_1 = require("./validators");
 const utils_1 = require("../../utils");
+const validators_1 = require("./validators");
 exports.STEP_C_STATES = {
-    evaluateTopLevelRead: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, next, endValidation }) {
+    evaluateTopLevelRead: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, next }) {
         (0, utils_1.logMachineInfo)({
             enabled: context.enableLog,
             machine: 'C',
@@ -21,12 +21,7 @@ exports.STEP_C_STATES = {
             stepName: 'evaluateTopLevelRead'
         });
         const check = yield (0, validators_1.evaluateTopLevelReadFn)(context);
-        if (check) {
-            return (0, validators_1.checkFieldsPropertyExists)(context)
-                ? next('checkFieldsProperty')
-                : endValidation({ success: true });
-        }
-        return next('evaluateTopLevelWrite', { check });
+        return next('evaluateTopLevelWrite', { readCheck: check });
     }),
     evaluateTopLevelWrite: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, next, endValidation }) {
         var _b;
@@ -36,12 +31,18 @@ exports.STEP_C_STATES = {
             step: 2,
             stepName: 'evaluateTopLevelWrite'
         });
-        const check = yield (0, validators_1.evaluateTopLevelWriteFn)(context);
-        if (check)
-            return endValidation({ success: true });
-        return ((_b = context === null || context === void 0 ? void 0 : context.prevParams) === null || _b === void 0 ? void 0 : _b.check) === false
-            ? endValidation({ success: false })
-            : next('checkFieldsProperty');
+        const writeCheck = yield (0, validators_1.evaluateTopLevelWriteFn)(context);
+        const readCheck = (_b = context === null || context === void 0 ? void 0 : context.prevParams) === null || _b === void 0 ? void 0 : _b.readCheck;
+        if (readCheck === true || writeCheck === true) {
+            return (0, validators_1.checkFieldsPropertyExists)(context)
+                ? next('checkFieldsProperty')
+                : endValidation({ success: true });
+        }
+        if (readCheck === false)
+            return endValidation({ success: false });
+        return (0, validators_1.checkFieldsPropertyExists)(context)
+            ? next('checkFieldsProperty')
+            : endValidation({ success: false });
     }),
     checkFieldsProperty: (_a) => __awaiter(void 0, [_a], void 0, function* ({ context, goToNextValidationStage }) {
         (0, utils_1.logMachineInfo)({
@@ -50,7 +51,6 @@ exports.STEP_C_STATES = {
             step: 3,
             stepName: 'checkFieldsProperty'
         });
-        const check = (0, validators_1.checkFieldsPropertyExists)(context);
-        return goToNextValidationStage(check ? 'checkIsValidFieldName' : 'checkAdditionalFields');
+        return goToNextValidationStage('checkIsValidFieldName');
     })
 };

package/dist/utils/roles/machines/read/C/validators.js

@@ -12,14 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkFieldsPropertyExists = exports.evaluateTopLevelWriteFn = exports.evaluateTopLevelReadFn = void 0;
 const commonValidators_1 = require("../../commonValidators");
 const evaluateTopLevelReadFn = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    if (context.params.type !== 'read') {
+    if (!['read', 'search'].includes(context.params.type)) {
         return false;
     }
     return (0, commonValidators_1.evaluateTopLevelPermissionsFn)(context, 'read');
 });
 exports.evaluateTopLevelReadFn = evaluateTopLevelReadFn;
 const evaluateTopLevelWriteFn = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!['read', 'write'].includes(context.params.type)) {
+    if (!['read', 'search', 'write'].includes(context.params.type)) {
         return undefined;
     }
     return (0, commonValidators_1.evaluateTopLevelPermissionsFn)(context, 'write');

package/dist/utils/roles/machines/read/D/index.js

@@ -19,7 +19,7 @@ const runCheckIsValidFieldName = (_a) => __awaiter(void 0, [_a], void 0, functio
         step: 2,
         stepName: 'checkIsValidFieldName'
     });
-    const document = (0, validators_1.checkIsValidFieldNameFn)(context);
+    const document = yield (0, validators_1.checkIsValidFieldNameFn)(context);
     return endValidation({ success: !!Object.keys(document).length, document });
 });
 exports.STEP_D_STATES = {

package/dist/utils/roles/machines/read/D/validators.d.ts

@@ -1,4 +1,4 @@
 import { MachineContext } from '../../interface';
 export declare const checkAdditionalFieldsFn: ({ role }: MachineContext) => boolean;
-export declare const checkIsValidFieldNameFn: ({ role, params }: MachineContext) => {};
+export declare const checkIsValidFieldNameFn: (context: MachineContext) => Promise<import("bson/bson").Document>;
 //# sourceMappingURL=validators.d.ts.map

package/dist/utils/roles/machines/read/D/validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/D/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,kBAAkB,cAAc,OAyBvE,CAAA"}
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/D/validators.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAU,SAAS,cAAc,0CAOpE,CAAA"}