@flowerforce/flowerbase 1.0.1-beta.10

package/dist/features/functions/utils.d.ts

@@ -0,0 +1,23 @@
+import { ExecuteQueryParams, Functions } from './interface';
+/**
+ * > Loads the functions config json file
+ * @testable
+ */
+export declare const loadFunctions: (rootDir?: string) => Promise<Functions>;
+/**
+ * > Executes a single query
+ * @param currentMethod -> the method that should be called
+ * @param query -> the query data
+ * @param update -> the update Document that should be deserialized
+ */
+export declare const executeQuery: ({ currentMethod, query, update, document }: ExecuteQueryParams) => Promise<{
+    find: () => Promise<any[]>;
+    findOne: () => Promise<unknown>;
+    deleteOne: () => Promise<unknown>;
+    insertOne: () => Promise<import("mongodb/mongodb").InsertOneResult<import("bson").Document>>;
+    updateOne: () => Promise<unknown> | import("mongodb/mongodb").FindCursor<any> | import("mongodb/mongodb").ChangeStream<import("bson").Document, import("bson").Document> | import("mongodb/mongodb").AggregationCursor<import("bson").Document>;
+    aggregate: () => import("mongodb/mongodb").AggregationCursor<import("bson").Document>;
+    insertMany: () => Promise<import("mongodb/mongodb").InsertManyResult<import("bson").Document>>;
+    updateMany: () => Promise<import("mongodb/mongodb").UpdateResult<import("bson").Document>>;
+}>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/features/functions/utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAU,gBAAuB,KAAG,OAAO,CAAC,SAAS,CAwB9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAU,4CAKhC,kBAAkB;;;;;;;;;EAkCpB,CAAA"}

package/dist/features/functions/utils.js

@@ -0,0 +1,75 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeQuery = exports.loadFunctions = void 0;
+const fs_1 = __importDefault(require("fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const bson_1 = require("bson");
+/**
+ * > Loads the functions config json file
+ * @testable
+ */
+const loadFunctions = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (rootDir = process.cwd()) {
+    const fnDir = 'functions';
+    const configFile = node_path_1.default.join(rootDir, fnDir, 'config.json');
+    const config = JSON.parse(fs_1.default.readFileSync(configFile, 'utf-8'));
+    const functions = config.reduce((acc, _a) => {
+        var { name } = _a, opts = __rest(_a, ["name"]);
+        const extensions = ['.js', '.ts'];
+        let code = '';
+        const fnPath = extensions
+            .map(ext => node_path_1.default.join(rootDir, fnDir, `${name}${ext}`))
+            .find(fs_1.default.existsSync);
+        if (!fnPath) {
+            throw new Error(`File ${name}.js or ${name}.ts not found`);
+        }
+        code = fs_1.default.readFileSync(fnPath, 'utf-8');
+        acc[name] = Object.assign({ code }, opts);
+        return acc;
+    }, {});
+    return functions;
+});
+exports.loadFunctions = loadFunctions;
+/**
+ * > Executes a single query
+ * @param currentMethod -> the method that should be called
+ * @param query -> the query data
+ * @param update -> the update Document that should be deserialized
+ */
+const executeQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ currentMethod, query, update, document }) {
+    return {
+        find: () => __awaiter(void 0, void 0, void 0, function* () {
+            return yield currentMethod(bson_1.EJSON.deserialize(query)).toArray();
+        }),
+        findOne: () => currentMethod(bson_1.EJSON.deserialize(query)),
+        deleteOne: () => currentMethod(bson_1.EJSON.deserialize(query)),
+        insertOne: () => currentMethod(bson_1.EJSON.deserialize(document)),
+        updateOne: () => currentMethod(bson_1.EJSON.deserialize(query), bson_1.EJSON.deserialize(update)),
+        aggregate: () => currentMethod(bson_1.EJSON.deserialize(query)),
+        insertMany: () => currentMethod(bson_1.EJSON.deserialize(query)),
+        updateMany: () => currentMethod(bson_1.EJSON.deserialize(query), bson_1.EJSON.deserialize(update)),
+    };
+});
+exports.executeQuery = executeQuery;

package/dist/features/rules/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/features/rules/index.tsx"],"names":[],"mappings":""}

package/dist/features/rules/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/features/rules/interface.d.ts

@@ -0,0 +1,22 @@
+export interface Filter {
+    name: string;
+    query: Record<string, unknown>;
+    apply_when: Record<string, unknown>;
+}
+export interface Role {
+    name: string;
+    apply_when: Record<string, unknown>;
+    insert: boolean;
+    delete: boolean;
+    search: boolean;
+    read: boolean;
+    write: boolean;
+}
+export interface RulesConfig {
+    database: string;
+    collection: string;
+    filters: Filter[];
+    roles: Role[];
+}
+export type Rules = Record<string, RulesConfig>;
+//# sourceMappingURL=interface.d.ts.map

package/dist/features/rules/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/features/rules/interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,IAAI,EAAE,CAAA;CACd;AAED,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA"}

package/dist/features/rules/interface.js

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

package/dist/features/rules/utils.d.ts

@@ -0,0 +1,3 @@
+import { Rules } from './interface';
+export declare const loadRules: (rootDir?: string) => Promise<Rules>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/features/rules/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/features/rules/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAe,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,SAAS,GAAU,gBAAuB,KAAG,OAAO,CAAC,KAAK,CActE,CAAA"}

package/dist/features/rules/utils.js

@@ -0,0 +1,31 @@
+"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.loadRules = void 0;
+const fs_1 = __importDefault(require("fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("../../utils");
+const loadRules = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (rootDir = process.cwd()) {
+    const rulesRoot = node_path_1.default.join(rootDir, 'data_sources', 'mongodb-atlas');
+    const files = fs_1.default.readdirSync(rulesRoot, { recursive: true });
+    const rulesFiles = files.filter((x) => x.endsWith('rules.json'));
+    const rulesByCollection = rulesFiles.reduce((acc, rulesFile) => {
+        const filePath = node_path_1.default.join(rulesRoot, rulesFile);
+        const collectionRules = (0, utils_1.readJsonContent)(filePath);
+        acc[collectionRules.collection] = collectionRules;
+        return acc;
+    }, {});
+    return rulesByCollection;
+});
+exports.loadRules = loadRules;

package/dist/features/triggers/dtos.d.ts

@@ -0,0 +1,9 @@
+import { FastifyInstance } from 'fastify';
+import { Functions } from '../functions/interface';
+import { Triggers } from './interface';
+export type ActivateTriggersParams = {
+    fastify: FastifyInstance;
+    triggersList: Triggers;
+    functionsList: Functions;
+};
+//# sourceMappingURL=dtos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dtos.d.ts","sourceRoot":"","sources":["../../../src/features/triggers/dtos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,EAAE,QAAQ,CAAA;IACtB,aAAa,EAAE,SAAS,CAAA;CACzB,CAAA"}

package/dist/features/triggers/dtos.js

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

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

@@ -0,0 +1,10 @@
+import { ActivateTriggersParams } from './dtos';
+/**
+ * > Used to activate all app triggers
+ * @testable
+ * @param fastify -> the fastify instance
+ * @param triggersList -> the list of all triggers
+ * @param functionsList -> the list of all functions
+ */
+export declare const activateTriggers: ({ fastify, triggersList, functionsList }: ActivateTriggersParams) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/features/triggers/index.js

@@ -0,0 +1,59 @@
+"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.activateTriggers = void 0;
+const services_1 = require("../../services");
+const utils_1 = require("./utils");
+/**
+ * > Used to activate all app triggers
+ * @testable
+ * @param fastify -> the fastify instance
+ * @param triggersList -> the list of all triggers
+ * @param functionsList -> the list of all functions
+ */
+const activateTriggers = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fastify, triggersList, functionsList }) {
+    var _b, triggersList_1, triggersList_1_1;
+    var _c, e_1, _d, _e;
+    console.log("START ACTIVATION TRIGGERS");
+    try {
+        try {
+            for (_b = true, triggersList_1 = __asyncValues(triggersList); triggersList_1_1 = yield triggersList_1.next(), _c = triggersList_1_1.done, !_c; _b = true) {
+                _e = triggersList_1_1.value;
+                _b = false;
+                const trigger = _e;
+                const { content } = trigger;
+                const { type, config, event_processors } = content;
+                const functionName = event_processors.FUNCTION.config.function_name;
+                const triggerHandler = functionsList[functionName];
+                yield utils_1.TRIGGER_HANDLERS[type]({ config, triggerHandler, app: fastify, services: services_1.services, functionsList });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_b && !_c && (_d = triggersList_1.return)) yield _d.call(triggersList_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        console.log("TRIGGERS ACTIVATION COMPLETED");
+    }
+    catch (e) {
+        console.error('Error while activating triggers', e.message);
+    }
+});
+exports.activateTriggers = activateTriggers;

package/dist/features/triggers/interface.d.ts

@@ -0,0 +1,44 @@
+import { FastifyInstance } from "fastify";
+import { Services } from "../../services/interface";
+import { Function, Functions } from "../functions/interface";
+export interface Trigger {
+    name: string;
+    type: TriggerType;
+    disabled: boolean;
+    config: Config;
+    event_processors: {
+        FUNCTION: {
+            config: {
+                function_name: string;
+            };
+        };
+    };
+}
+type Config = {
+    collection: string;
+    database: string;
+    full_document: boolean;
+    full_document_before_change: boolean;
+    match: Record<string, unknown>;
+    operation_types: string[];
+    project: Record<string, unknown>;
+    service_name: string;
+    skip_catchup_events: boolean;
+    tolerate_resume_errors: boolean;
+    unordered: boolean;
+    schedule: string;
+};
+export type TriggerType = "SCHEDULED" | "DATABASE" | "AUTHENTICATION";
+export type Triggers = {
+    fileName: string;
+    content: Trigger;
+}[];
+export type HandlerParams = {
+    config: Config;
+    triggerHandler: Function;
+    app: FastifyInstance;
+    services: Services;
+    functionsList: Functions;
+};
+export {};
+//# sourceMappingURL=interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/features/triggers/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAE5D,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE;QAChB,QAAQ,EAAE;YACR,MAAM,EAAE;gBACN,aAAa,EAAE,MAAM,CAAA;aACtB,CAAA;SACF,CAAA;KACF,CAAA;CACF;AAED,KAAK,MAAM,GAAG;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,OAAO,CAAA;IACtB,2BAA2B,EAAE,OAAO,CAAA;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,YAAY,EAAE,MAAM,CAAA;IACpB,mBAAmB,EAAE,OAAO,CAAA;IAC5B,sBAAsB,EAAE,OAAO,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,gBAAgB,CAAA;AACrE,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,EAAE,CAAA;AAG/D,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,QAAQ,CAAC;IACzB,GAAG,EAAE,eAAe,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,SAAS,CAAA;CACzB,CAAA"}

package/dist/features/triggers/interface.js

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

package/dist/features/triggers/utils.d.ts

@@ -0,0 +1,16 @@
+import { HandlerParams, Triggers } from './interface';
+/**
+ * Loads trigger files from the specified directory and returns them as an array of objects.
+ * Each object contains the file name and the parsed JSON content.
+ *
+ * @testable
+ * @param {string} [rootDir=process.cwd()] - The root directory from which to load the triggers. Defaults to the current working directory.
+ * @returns {Promise<Triggers>} A promise that resolves to an array of trigger objects.
+ */
+export declare const loadTriggers: (rootDir?: string) => Promise<Triggers>;
+export declare const TRIGGER_HANDLERS: {
+    SCHEDULED: ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => Promise<void>;
+    DATABASE: ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => Promise<void>;
+    AUTHENTICATION: ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => Promise<void>;
+};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/features/triggers/utils.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAU,gBAAuB,KAAG,OAAO,CAAC,QAAQ,CAY5E,CAAA;AA4HD,eAAO,MAAM,gBAAgB;0EA9G8D,aAAa;yEAmET,aAAa;+EApDP,aAAa;CAmGjH,CAAA"}

package/dist/features/triggers/utils.js

@@ -0,0 +1,153 @@
+"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.TRIGGER_HANDLERS = exports.loadTriggers = void 0;
+const fs_1 = __importDefault(require("fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_cron_1 = __importDefault(require("node-cron"));
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const context_1 = require("../../utils/context");
+/**
+ * Loads trigger files from the specified directory and returns them as an array of objects.
+ * Each object contains the file name and the parsed JSON content.
+ *
+ * @testable
+ * @param {string} [rootDir=process.cwd()] - The root directory from which to load the triggers. Defaults to the current working directory.
+ * @returns {Promise<Triggers>} A promise that resolves to an array of trigger objects.
+ */
+const loadTriggers = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (rootDir = process.cwd()) {
+    const triggersPath = node_path_1.default.join(rootDir, 'triggers');
+    const files = fs_1.default.readdirSync(triggersPath);
+    const triggers = files
+        .filter((fileName) => fileName.endsWith('.json'))
+        .map((fileName) => ({
+        fileName,
+        content: (0, utils_1.readJsonContent)(node_path_1.default.join(triggersPath, fileName))
+    }));
+    return triggers;
+});
+exports.loadTriggers = loadTriggers;
+/**
+ * Handles the scheduling of a cron job and triggers the appropriate function.
+ *
+ * @testable
+ * @param {Object} params - The parameters for the handler.
+ * @param {Object} params.config - Configuration object for the cron trigger.
+ * @param {string} params.config.schedule - Cron schedule string (e.g., "* * * * *" for every minute).
+ * @param {Function} params.triggerHandler - The function to be triggered when the cron job executes.
+ * @param {Array<Function>} params.functionsList - List of available functions.
+ * @param {Object} params.services - Services available to the handler.
+ * @param {Object} params.app - The app instance for context.
+ */
+const handleCronTrigger = (_a) => __awaiter(void 0, [_a], void 0, function* ({ config, triggerHandler, functionsList, services, app }) {
+    node_cron_1.default.schedule(config.schedule, () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, context_1.GenerateContext)({
+            args: [],
+            app,
+            rules: {},
+            user: {},
+            currentFunction: triggerHandler,
+            functionsList,
+            services
+        });
+    }));
+});
+const handleAuthenticationTrigger = (_a) => __awaiter(void 0, [_a], void 0, function* ({ config, triggerHandler, functionsList, services, app }) {
+    const { database } = config;
+    const pipeline = [{
+            $match: {
+                operationType: { $in: ["INSERT"] }
+            }
+        }];
+    const changeStream = app.mongo.client.db(database).collection(constants_1.AUTH_CONFIG.authCollection).watch(pipeline, {
+        fullDocument: 'whenAvailable'
+    });
+    changeStream.on('change', function (change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const document = change["fullDocument"]; //TODO -> define user type
+            if (document) {
+                delete document.password;
+                const currentUser = Object.assign({}, document);
+                delete currentUser.password;
+                yield (0, context_1.GenerateContext)({
+                    args: [{ user: currentUser }],
+                    app,
+                    rules: {},
+                    user: {},
+                    currentFunction: triggerHandler,
+                    functionsList,
+                    services
+                });
+            }
+        });
+    });
+});
+/**
+ * Handles a database trigger by watching changes in a specified collection and triggering the appropriate handler.
+ *
+ * @testable
+ * @param {Object} params - The parameters for the handler.
+ * @param {Object} params.config - Configuration object for the database trigger.
+ * @param {string} params.config.database - The name of the database to watch.
+ * @param {string} params.config.collection - The name of the collection to watch.
+ * @param {Array<string>} [params.config.operation_types=[]] - List of operation types to watch (e.g., "insert", "update").
+ * @param {Object} [params.config.match={}] - Additional match criteria for the change stream.
+ * @param {Object} [params.config.project={}] - Projection to apply to the change stream results.
+ * @param {boolean} [params.config.full_document] - Whether to include the full document in the change stream results.
+ * @param {boolean} [params.config.full_document_before_change] - Whether to include the full document before the change.
+ * @param {Function} params.triggerHandler - The function to be triggered on database changes.
+ * @param {Array<Function>} params.functionsList - List of available functions.
+ * @param {Object} params.services - Services available to the handler.
+ * @param {Object} params.app - The app instance for context.
+ */
+const handleDataBaseTrigger = (_a) => __awaiter(void 0, [_a], void 0, function* ({ config, triggerHandler, functionsList, services, app }) {
+    const { database, collection: collectionName, operation_types = [], match = {}, project = {} } = config;
+    const collection = app.mongo.client.db(database).collection(collectionName);
+    const pipeline = [
+        {
+            $match: Object.assign({ operationType: { $in: operation_types.map((op) => op.toLowerCase()) } }, match)
+        },
+        Object.keys(project).length
+            ? {
+                $project: project
+            }
+            : undefined
+    ].filter(Boolean);
+    const changeStream = collection.watch(pipeline, {
+        fullDocument: config.full_document ? 'whenAvailable' : undefined,
+        fullDocumentBeforeChange: config.full_document_before_change
+            ? 'whenAvailable'
+            : undefined
+    });
+    changeStream.on('change', function (change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, context_1.GenerateContext)({
+                args: [change],
+                app,
+                rules: {},
+                user: {},
+                currentFunction: triggerHandler,
+                functionsList,
+                services
+            });
+        });
+    });
+    // TODO -> gestire close dello stream
+});
+exports.TRIGGER_HANDLERS = {
+    SCHEDULED: handleCronTrigger,
+    DATABASE: handleDataBaseTrigger,
+    AUTHENTICATION: handleAuthenticationTrigger
+};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import 'dotenv/config';
+export * from "./model";
+export type InitializeConfig = {
+    projectId: string;
+    mongodbUrl?: string;
+    jwtSecret?: string;
+    port?: number;
+    host?: string;
+};
+/**
+ * > Used to initialize fastify app
+ * @param projectId -> the project id string
+ * @param host -> the host string
+ * @param jwtSecret -> connection jwt
+ * @param port -> the serve port number
+ * @param mongodbUrl -> the database connection string
+ */
+export declare function initialize({ projectId, host, jwtSecret, port, mongodbUrl }: InitializeConfig): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAA;AActB,cAAc,SAAS,CAAC;AAExB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,EAC/B,SAAS,EACT,IAAI,EACJ,SAAqC,EACrC,IAA0B,EAC1B,UAAuC,EACxC,EAAE,gBAAgB,iBAmDlB"}

package/dist/index.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.initialize = initialize;
+require("dotenv/config");
+const fastify_1 = __importDefault(require("fastify"));
+const constants_1 = require("./constants");
+const endpoints_1 = require("./features/endpoints");
+const utils_1 = require("./features/endpoints/utils");
+const functions_1 = require("./features/functions");
+const utils_2 = require("./features/functions/utils");
+const utils_3 = require("./features/rules/utils");
+const triggers_1 = require("./features/triggers");
+const utils_4 = require("./features/triggers/utils");
+const services_1 = require("./services");
+const state_1 = require("./state");
+const exposeRoutes_1 = require("./utils/initializer/exposeRoutes");
+const registerPlugins_1 = require("./utils/initializer/registerPlugins");
+__exportStar(require("./model"), exports);
+/**
+ * > Used to initialize fastify app
+ * @param projectId -> the project id string
+ * @param host -> the host string
+ * @param jwtSecret -> connection jwt
+ * @param port -> the serve port number
+ * @param mongodbUrl -> the database connection string
+ */
+function initialize(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ projectId, host, jwtSecret = constants_1.DEFAULT_CONFIG.JWT_SECRET, port = constants_1.DEFAULT_CONFIG.PORT, mongodbUrl = constants_1.DEFAULT_CONFIG.MONGODB_URL }) {
+        var _b;
+        const fastify = (0, fastify_1.default)({
+            logger: !!constants_1.DEFAULT_CONFIG.ENABLE_LOGGER
+        });
+        const basePath = (_b = require.main) === null || _b === void 0 ? void 0 : _b.path;
+        console.log("BASE PATH", basePath);
+        console.log("CURRENT PORT", port);
+        console.log("CURRENT HOST", host);
+        const functionsList = yield (0, utils_2.loadFunctions)(basePath);
+        console.log("Functions LOADED");
+        const triggersList = yield (0, utils_4.loadTriggers)(basePath);
+        console.log("Triggers LOADED");
+        const endpointsList = yield (0, utils_1.loadEndpoints)(basePath);
+        console.log("Endpoints LOADED");
+        const rulesList = yield (0, utils_3.loadRules)(basePath);
+        console.log("Rules LOADED");
+        const stateConfig = {
+            functions: functionsList,
+            triggers: triggersList,
+            endpoints: endpointsList,
+            rules: rulesList,
+            app: fastify,
+            services: services_1.services
+        };
+        Object.entries(stateConfig).forEach(([key, value]) => state_1.StateManager.setData(key, value));
+        yield (0, registerPlugins_1.registerPlugins)({
+            register: fastify.register,
+            mongodbUrl,
+            jwtSecret,
+            functionsList
+        });
+        console.log("Plugins registration COMPLETED");
+        yield (0, exposeRoutes_1.exposeRoutes)(fastify);
+        console.log("APP Routes registration COMPLETED");
+        yield (0, functions_1.registerFunctions)({ app: fastify, functionsList, rulesList });
+        console.log("Functions registration COMPLETED");
+        yield (0, endpoints_1.generateEndpoints)({ app: fastify, functionsList, endpointsList });
+        console.log("HTTP Endpoints registration COMPLETED");
+        fastify.ready(() => {
+            console.log("FASTIFY IS READY");
+            (triggersList === null || triggersList === void 0 ? void 0 : triggersList.length) > 0 && (0, triggers_1.activateTriggers)({ fastify, triggersList, functionsList });
+        });
+        yield fastify.listen({ port, host });
+        fastify.log.info(`[${projectId}] Server listening on port ${port}`);
+    });
+}

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+export { Document, WithId } from 'mongodb';
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC"}

package/dist/model.js

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