@flowerforce/flowerbase 1.0.1-beta.3

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

@@ -0,0 +1,74 @@
+import { mongodb } from '@fastify/mongodb';
+import { Arguments } from '../../auth/dtos';
+import { GenerateContextDataParams } from './interface';
+/**
+ * > Used to generate the current context data
+ * @testable
+ * @param user -> the current user
+ * @param services -> the list of all services
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ */
+export declare const generateContextData: ({ user, services, app, rules, currentFunction, functionsList, GenerateContext }: GenerateContextDataParams) => {
+    BSON: typeof mongodb.BSON;
+    console: {
+        log: (...args: Arguments) => void;
+    };
+    context: {
+        user: unknown;
+        environment: {
+            tag: string | undefined;
+        };
+        values: {
+            get: (key: string) => string | undefined;
+        };
+        services: {
+            get: (serviceName: keyof typeof services) => {
+                db: (dbName: string) => {
+                    collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
+                };
+            } | {
+                get: <T = null>({ url, headers }: import("../../services/api/model").GetParams) => Promise<{
+                    status: number;
+                    headers: import("undici/types/header").IncomingHttpHeaders;
+                    body: {
+                        message: string;
+                    };
+                } | import("undici").Dispatcher.ResponseData<T>>;
+                post: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("../../services/api/model").PostParams) => Promise<{
+                    status: number;
+                    headers: import("undici/types/header").IncomingHttpHeaders;
+                    body: {
+                        message: string;
+                    };
+                } | import("undici").Dispatcher.ResponseData<T>>;
+                put: <T = null>({ scheme, host, path, url: currentUrl, headers, body, encodeBodyAsJSON }: import("../../services/api/model").PutParams) => Promise<{
+                    status: number;
+                    headers: import("undici/types/header").IncomingHttpHeaders;
+                    body: {
+                        message: string;
+                    };
+                } | import("undici").Dispatcher.ResponseData<T>>;
+                delete: <T = null>({ scheme, host, path, url: currentUrl, headers }: import("../../services/api/model").DeleteParams) => Promise<{
+                    status: number;
+                    headers: import("undici/types/header").IncomingHttpHeaders;
+                    body: {
+                        message: string;
+                    };
+                } | import("undici").Dispatcher.ResponseData<T>>;
+            } | {
+                lambda: (region: string) => import("aws-sdk").Lambda & {
+                    Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
+                    InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
+                };
+                s3: (region: string) => import("aws-sdk").S3;
+            } | undefined;
+        };
+        functions: {
+            execute: (name: keyof typeof functionsList, ...args: Arguments) => Promise<void>;
+        };
+    };
+};
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,iFAQjC,yBAAyB;;;uBAGT,SAAS;;;;;;;;uBAUX,MAAM;;;+BAGE,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA1BpC,GAAE;;;;;;;4BA2CU,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAclE,CAAA"}

package/dist/utils/context/helpers.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateContextData = void 0;
+const mongodb_1 = require("@fastify/mongodb");
+/**
+ * > Used to generate the current context data
+ * @testable
+ * @param user -> the current user
+ * @param services -> the list of all services
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ */
+const generateContextData = ({ user, services, app, rules, currentFunction, functionsList, GenerateContext }) => ({
+    BSON: mongodb_1.mongodb.BSON,
+    console: {
+        log: (...args) => {
+            console.log(...args);
+        }
+    },
+    context: {
+        user,
+        environment: {
+            tag: process.env.NODE_ENV
+        },
+        values: {
+            get: (key) => process.env[key],
+        },
+        services: {
+            get: (serviceName) => {
+                try {
+                    return services[serviceName](app, {
+                        rules,
+                        user,
+                        run_as_system: currentFunction.run_as_system
+                    });
+                }
+                catch (error) {
+                    console.error('Something went wrong while generating context function', serviceName, error);
+                }
+            }
+        },
+        functions: {
+            execute: (name, ...args) => {
+                const currentFunction = functionsList[name];
+                return GenerateContext({
+                    args,
+                    app,
+                    rules,
+                    user,
+                    currentFunction,
+                    functionsList,
+                    services
+                });
+            }
+        }
+    }
+});
+exports.generateContextData = generateContextData;

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

@@ -0,0 +1,14 @@
+import { GenerateContextParams } from './interface';
+/**
+ * > Used to generate the current context
+ * @testable
+ * @param args -> generic arguments
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param user -> the current user
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ * @param services -> the list of all services
+ */
+export declare function GenerateContext({ args, app, rules, user, currentFunction, functionsList, services }: GenerateContextParams): Promise<any>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/context/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACT,EAAE,qBAAqB,gBA0BvB"}

package/dist/utils/context/index.js

@@ -0,0 +1,50 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateContext = GenerateContext;
+const module_1 = __importDefault(require("module"));
+const vm_1 = __importDefault(require("vm"));
+const bson_1 = require("bson");
+const helpers_1 = require("./helpers");
+/**
+ * > Used to generate the current context
+ * @testable
+ * @param args -> generic arguments
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param user -> the current user
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ * @param services -> the list of all services
+ */
+function GenerateContext(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ args, app, rules, user, currentFunction, functionsList, services }) {
+        const contextData = (0, helpers_1.generateContextData)({
+            user,
+            services,
+            app,
+            rules,
+            currentFunction,
+            functionsList,
+            GenerateContext
+        });
+        try {
+            vm_1.default.runInContext(module_1.default.wrap(currentFunction.code), vm_1.default.createContext(contextData))(exports, require, module, __filename, __dirname);
+        }
+        catch (e) {
+            console.log(e);
+        }
+        return yield module.exports(...bson_1.EJSON.deserialize(args));
+    });
+}

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

@@ -0,0 +1,18 @@
+import { FastifyInstance } from 'fastify';
+import { Arguments, User } from '../../auth/dtos';
+import { Function, Functions } from '../../features/functions/interface';
+import { Rules } from '../../features/rules/interface';
+import { Services } from '../../services/interface';
+export interface GenerateContextParams {
+    app: FastifyInstance;
+    currentFunction: Function;
+    functionsList: Functions;
+    rules: Rules;
+    user: User;
+    services: Services;
+    args: Arguments;
+}
+export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {
+    GenerateContext: (params: GenerateContextParams) => Promise<void>;
+}
+//# sourceMappingURL=interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/context/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAEnD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,eAAe,CAAA;IACpB,eAAe,EAAE,QAAQ,CAAA;IACzB,aAAa,EAAE,SAAS,CAAA;IACxB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,eAAe,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE"}

package/dist/utils/context/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/crypto/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * > Creates the hash for a string
+ * @param plaintext -> the string that should be encrypted
+ * @tested
+ */
+export declare const hashPassword: (plaintext: string) => Promise<string>;
+/**
+ * > Compares two strings
+ * @param plaintext -> the first string
+ * @param storedPassword -> the second string
+ * @tested
+ */
+export declare const comparePassword: (plaintext: string, storedPassword: string) => Promise<boolean>;
+/**
+ * > Generate a random token
+ * @param length -> the token length
+ */
+export declare const generateToken: (length?: number) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto/index.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAU,WAAW,MAAM,oBAInD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAU,WAAW,MAAM,EAAE,gBAAgB,MAAM,qBAK9E,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,eAAW,WAExC,CAAA"}

package/dist/utils/crypto/index.js

@@ -0,0 +1,50 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToken = exports.comparePassword = exports.hashPassword = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_util_1 = require("node:util");
+const scrypt = (0, node_util_1.promisify)(node_crypto_1.default.scrypt);
+/**
+ * > Creates the hash for a string
+ * @param plaintext -> the string that should be encrypted
+ * @tested
+ */
+const hashPassword = (plaintext) => __awaiter(void 0, void 0, void 0, function* () {
+    const salt = node_crypto_1.default.randomBytes(128).toString('hex');
+    const buffer = (yield scrypt(plaintext, salt, 64));
+    return `${buffer.toString('hex')}.${salt}`;
+});
+exports.hashPassword = hashPassword;
+/**
+ * > Compares two strings
+ * @param plaintext -> the first string
+ * @param storedPassword -> the second string
+ * @tested
+ */
+const comparePassword = (plaintext, storedPassword) => __awaiter(void 0, void 0, void 0, function* () {
+    const [storedHash, storedSalt] = storedPassword.split('.');
+    const storedBuffer = Buffer.from(storedHash, 'hex');
+    const buffer = (yield scrypt(plaintext, storedSalt, 64));
+    return node_crypto_1.default.timingSafeEqual(buffer, storedBuffer);
+});
+exports.comparePassword = comparePassword;
+/**
+ * > Generate a random token
+ * @param length -> the token length
+ */
+const generateToken = (length = 32) => {
+    return node_crypto_1.default.randomBytes(length).toString('hex');
+};
+exports.generateToken = generateToken;

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

@@ -0,0 +1,12 @@
+/**
+ * Asynchronously checks if at least one element in the array satisfies the given asynchronous callback function.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to iterate over.
+ * @param {(element: T, index: number, arr: T[]) => Promise<boolean>} callback - An asynchronous function that takes an element, its index, and the original array,
+ * and returns a Promise resolving to `true` if the condition is met, otherwise `false`.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if at least one element satisfies the callback condition, otherwise `false`.
+ * @tested
+ */
+export declare function someAsync<T>(array: T[], callback: (element: T, index: number, arr: T[]) => Promise<boolean>): Promise<boolean>;
+//# sourceMappingURL=someAsync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"someAsync.d.ts","sourceRoot":"","sources":["../../../src/utils/helpers/someAsync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,GACpE,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/utils/helpers/someAsync.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.someAsync = someAsync;
+/**
+ * Asynchronously checks if at least one element in the array satisfies the given asynchronous callback function.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to iterate over.
+ * @param {(element: T, index: number, arr: T[]) => Promise<boolean>} callback - An asynchronous function that takes an element, its index, and the original array,
+ * and returns a Promise resolving to `true` if the condition is met, otherwise `false`.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if at least one element satisfies the callback condition, otherwise `false`.
+ * @tested
+ */
+function someAsync(array, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, array_1, array_1_1;
+        var _b, e_1, _c, _d;
+        let i = 0;
+        try {
+            for (_a = true, array_1 = __asyncValues(array); array_1_1 = yield array_1.next(), _b = array_1_1.done, !_b; _a = true) {
+                _d = array_1_1.value;
+                _a = false;
+                const el = _d;
+                const isValid = yield callback(el, i, array);
+                if (isValid) {
+                    return true;
+                }
+                i++;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = array_1.return)) yield _c.call(array_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    });
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export declare const readFileContent: (filePath: string) => string;
+export declare const readJsonContent: (filePath: string) => unknown;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,WAAuC,CAAA;AACvF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KACL,OAAO,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonContent = exports.readFileContent = void 0;
+const fs_1 = __importDefault(require("fs"));
+const readFileContent = (filePath) => fs_1.default.readFileSync(filePath, 'utf-8');
+exports.readFileContent = readFileContent;
+const readJsonContent = (filePath) => JSON.parse((0, exports.readFileContent)(filePath));
+exports.readJsonContent = readJsonContent;

package/dist/utils/initializer/exposeRoutes.d.ts

@@ -0,0 +1,8 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * > Used to expose all app routes
+ * @param fastify -> the fastify instance
+ * @tested
+ */
+export declare const exposeRoutes: (fastify: FastifyInstance) => Promise<void>;
+//# sourceMappingURL=exposeRoutes.d.ts.map

package/dist/utils/initializer/exposeRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposeRoutes.d.ts","sourceRoot":"","sources":["../../../src/utils/initializer/exposeRoutes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAU,SAAS,eAAe,kBAgB1D,CAAA"}

package/dist/utils/initializer/exposeRoutes.js

@@ -0,0 +1,41 @@
+"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.exposeRoutes = void 0;
+const node_process_1 = require("node:process");
+const constants_1 = require("../../constants");
+/**
+ * > Used to expose all app routes
+ * @param fastify -> the fastify instance
+ * @tested
+ */
+const exposeRoutes = (fastify) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        fastify.get(`${constants_1.API_VERSION}/app/:appId/location`, (req) => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                deployment_model: 'LOCAL',
+                location: 'IE',
+                hostname: `http://${req.headers.host}`,
+                ws_hostname: `wss://${req.headers.host}`
+            });
+        }));
+        fastify.get('/health', () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                status: 'ok',
+                uptime: (0, node_process_1.uptime)()
+            });
+        }));
+    }
+    catch (e) {
+        console.error('Error while exposing routes', e.message);
+    }
+});
+exports.exposeRoutes = exposeRoutes;

package/dist/utils/initializer/registerPlugins.d.ts

@@ -0,0 +1,19 @@
+import { FastifyInstance } from 'fastify';
+import { Functions } from '../../features/functions/interface';
+type RegisterFunction = FastifyInstance['register'];
+type RegisterPluginsParams = {
+    register: RegisterFunction;
+    mongodbUrl: string;
+    jwtSecret: string;
+    functionsList: Functions;
+};
+/**
+ * > Used to register all plugins
+ * @param register -> the fastify register method
+ * @param mongodbUrl -> the database connection string
+ * @param jwtSecret -> connection jwt
+ * @tested
+ */
+export declare const registerPlugins: ({ register, mongodbUrl, jwtSecret, functionsList }: RegisterPluginsParams) => Promise<void>;
+export {};
+//# sourceMappingURL=registerPlugins.d.ts.map

package/dist/utils/initializer/registerPlugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerPlugins.d.ts","sourceRoot":"","sources":["../../../src/utils/initializer/registerPlugins.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAKzC,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AAE9D,KAAK,gBAAgB,GAAG,eAAe,CAAC,UAAU,CAAC,CAAA;AAGnD,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,SAAS,CAAA;CACzB,CAAA;AAOD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAU,oDAKnC,qBAAqB,kBAcvB,CAAA"}

package/dist/utils/initializer/registerPlugins.js

@@ -0,0 +1,84 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPlugins = void 0;
+const cors_1 = __importDefault(require("@fastify/cors"));
+const mongodb_1 = __importDefault(require("@fastify/mongodb"));
+const controller_1 = require("../../auth/controller");
+const jwt_1 = __importDefault(require("../../auth/plugins/jwt"));
+const controller_2 = require("../../auth/providers/local-userpass/controller");
+const constants_1 = require("../../constants");
+/**
+ * > Used to register all plugins
+ * @param register -> the fastify register method
+ * @param mongodbUrl -> the database connection string
+ * @param jwtSecret -> connection jwt
+ * @tested
+ */
+const registerPlugins = (_a) => __awaiter(void 0, [_a], void 0, function* ({ register, mongodbUrl, jwtSecret, functionsList }) {
+    try {
+        const registersConfig = yield getRegisterConfig({
+            mongodbUrl,
+            jwtSecret,
+            functionsList
+        });
+        registersConfig.forEach(({ plugin, options }) => {
+            register(plugin, options);
+        });
+    }
+    catch (e) {
+        console.error('Error while registering plugins', e.message);
+    }
+});
+exports.registerPlugins = registerPlugins;
+/**
+ * > Used to generate the register congig
+ * @param mongodbUrl -> the database connection string
+ * @param jwtSecret -> connection jwt
+ * @testable
+ */
+const getRegisterConfig = (_a) => __awaiter(void 0, [_a], void 0, function* ({ mongodbUrl, jwtSecret }) {
+    return [
+        {
+            plugin: cors_1.default,
+            options: {
+                origin: '*',
+                methods: ['POST', 'GET']
+            }
+        },
+        {
+            plugin: mongodb_1.default,
+            options: {
+                forceClose: true,
+                url: mongodbUrl
+            }
+        },
+        {
+            plugin: jwt_1.default,
+            options: {
+                secret: jwtSecret
+            }
+        },
+        {
+            plugin: controller_1.authController,
+            options: { prefix: `${constants_1.API_VERSION}/auth` }
+        },
+        {
+            plugin: controller_2.localUserPassController,
+            options: {
+                prefix: `${constants_1.API_VERSION}/app/:appId/auth/providers/local-userpass`
+            }
+        }
+    ];
+});

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

@@ -0,0 +1,4 @@
+import { PermissionExpression } from './interface';
+import { MachineContext } from './machines/interface';
+export declare const evaluateExpression: (params: MachineContext["params"], expression?: PermissionExpression, user?: MachineContext["user"]) => Promise<boolean>;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +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,GAAU,QAAQ,cAAc,CAAC,QAAQ,CAAC,EAAE,aAAa,oBAAoB,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,OAAO,CAa5J,CAAA"}

package/dist/utils/roles/helpers.js

@@ -0,0 +1,47 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = void 0;
+const services_1 = require("../../services");
+const state_1 = require("../../state");
+const context_1 = require("../context");
+const rules_1 = require("../rules");
+const utils_1 = __importDefault(require("../rules-matcher/utils"));
+const functionsConditions = ["%%true", "%%false"];
+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 conditions = (0, rules_1.expandQuery)(expression, value);
+    const complexCondition = Object.entries(conditions).find(([key]) => functionsConditions.includes(key));
+    return complexCondition ? yield evaluateComplexExpression(complexCondition, params, user) : utils_1.default.checkRule(conditions, value, {});
+});
+exports.evaluateExpression = evaluateExpression;
+const evaluateComplexExpression = (condition, params, user) => __awaiter(void 0, void 0, void 0, function* () {
+    const [key, config] = condition;
+    const { name } = config["%function"];
+    const functionsList = state_1.StateManager.select("functions");
+    const app = state_1.StateManager.select("app");
+    const currentFunction = functionsList[name];
+    const response = yield (0, context_1.GenerateContext)({
+        args: [params.cursor],
+        app,
+        rules: {},
+        user,
+        currentFunction,
+        functionsList,
+        services: services_1.services
+    });
+    return key === "%%true" ? response : !response;
+});