@flowerforce/flowerbase 1.0.1-beta.3

package/dist/utils/rules-matcher/utils.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operators = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const intersection_1 = __importDefault(require("lodash/intersection"));
+const trimStart_1 = __importDefault(require("lodash/trimStart"));
+const EMPTY_STRING_REGEXP = /^\s*$/;
+/**
+ * Defines a utility object named rulesMatcherUtils, which contains various helper functions used for processing rules and data in a rule-matching context.
+ */
+const rulesMatcherUtils = {
+    isNumber: (el) => {
+        const num = String(el);
+        return !!num.match(/(^-?|^\d+\.)\d+$/);
+    },
+    rule: (val, data, options) => {
+        var _a;
+        const { prefix } = options || {};
+        const path = Object.keys(val)[0];
+        const valueBlock = val;
+        const pathWithPrefix = rulesMatcherUtils.getPath(path, prefix);
+        const valueForKey = (0, get_1.default)(data, pathWithPrefix, undefined);
+        const { name } = (0, get_1.default)(valueBlock, [path], {}) || {};
+        const { op, value, opt } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
+        const valueRef = value && String(value).indexOf('$ref:') === 0
+            ? (0, get_1.default)(data, rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix), undefined)
+            : value;
+        if (!exports.operators[op]) {
+            throw new Error(`Error missing operator:${op}`);
+        }
+        const valid = (_a = exports.operators[op]) === null || _a === void 0 ? void 0 : _a.call(exports.operators, valueForKey, valueRef, opt, data);
+        return { valid, name: `${pathWithPrefix}___${name || op}` };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getKey: (block, keys, options) => {
+        if (Object.prototype.hasOwnProperty.call(block, '$and')) {
+            return block.$and.map((item) => rulesMatcherUtils.getKey(item, keys, options));
+        }
+        if (Object.prototype.hasOwnProperty.call(block, '$or')) {
+            return block.$or.map((item) => rulesMatcherUtils.getKey(item, keys, options));
+        }
+        const { prefix } = options || {};
+        const path = Object.keys(block)[0];
+        const valueBlock = block;
+        const res = rulesMatcherUtils.getPath(path, prefix);
+        const { value } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
+        if (value && String(value).indexOf('$ref:') === 0) {
+            keys[rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix)] = true;
+        }
+        return (keys[res] = true);
+    },
+    isDate: (v) => v instanceof Date,
+    isDefined: (v) => v !== null && v !== undefined,
+    isObject: (v) => v === Object(v),
+    isFunction: (v) => typeof v === 'function',
+    isString: (v) => typeof v === 'string',
+    getDefaultStringValue: (value) => {
+        switch (value) {
+            case '$required':
+                return { op: '$exists', value: true };
+            case '$exists':
+                return { op: '$exists', value: true };
+            default:
+                return { op: '$eq', value };
+        }
+    },
+    getTypeOf: (value) => Array.isArray(value)
+        ? 'array'
+        : rulesMatcherUtils.isNumber(value)
+            ? 'number'
+            : value === null
+                ? null
+                : typeof value,
+    getDefaultRule: (value) => {
+        const valueType = rulesMatcherUtils.getTypeOf(value);
+        switch (valueType) {
+            case 'number':
+                return { op: '$eq', value };
+            case 'string':
+                return rulesMatcherUtils.getDefaultStringValue(value);
+            case 'boolean':
+                return { op: '$exists', value };
+            case 'array':
+                return { op: '$in', value };
+            case 'object':
+                return Object.assign(Object.assign({}, value), { op: value.op || Object.keys(value)[0], value: value.value || value[Object.keys(value)[0]] });
+            default:
+                return { op: '$eq', value };
+        }
+    },
+    isEmpty: (value) => {
+        // Null and undefined are empty
+        if (!rulesMatcherUtils.isDefined(value)) {
+            return true;
+        }
+        // functions are non empty
+        if (rulesMatcherUtils.isFunction(value)) {
+            return false;
+        }
+        /*   if (isBool(value)) {
+            return false;
+          }
+         */
+        // Whitespace only strings are empty
+        if (rulesMatcherUtils.isString(value)) {
+            return EMPTY_STRING_REGEXP.test(value);
+        }
+        // For arrays we use the length property
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        // Dates have no attributes but aren't empty
+        if (rulesMatcherUtils.isDate(value)) {
+            return false;
+        }
+        // If we find at least one property we consider it non empty
+        let attr;
+        if (rulesMatcherUtils.isObject(value)) {
+            for (attr in value) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    },
+    forceArray: (a) => (Array.isArray(a) ? a : [a]),
+    getPath: (path, prefix) => {
+        if (path.indexOf('^') === 0) {
+            return (0, trimStart_1.default)(path, '^');
+        }
+        // da verificare se è ancora utilizzato
+        if (path.indexOf('$') === 0) {
+            return path;
+        }
+        return prefix ? `${prefix}.${path}` : path;
+    },
+    // TODO BUG NUMERI CON LETTERE 1asdas o solo
+    forceNumber: (el) => {
+        if (Array.isArray(el)) {
+            return el.length;
+        }
+        if (rulesMatcherUtils.isNumber(String(el))) {
+            return parseFloat(String(el));
+        }
+        // fix perchè un valore false < 1 è true, quindi sbagliato, mentre un valore undefined < 1 è false
+        return 0;
+    },
+    checkRule: (block, data, options) => {
+        if (!Array.isArray(block) &&
+            block &&
+            Object.prototype.hasOwnProperty.call(block, '$and')) {
+            if (block && block['$and'] && !block['$and'].length)
+                return true;
+            return block['$and'].every((item) => rulesMatcherUtils.checkRule(item, data, options));
+        }
+        if (!Array.isArray(block) &&
+            block &&
+            Object.prototype.hasOwnProperty.call(block, '$or')) {
+            if (block && block['$or'] && !block['$or'].length)
+                return true;
+            return block['$or'].some((item) => rulesMatcherUtils.checkRule(item, data, options));
+        }
+        const res = rulesMatcherUtils.rule(block, data, options);
+        return res.valid;
+    },
+    getKeys: (rules, options) => {
+        if (!rules)
+            return null;
+        if (typeof rules == 'function')
+            return [];
+        if (!rulesMatcherUtils.forceArray(rules).every((r) => rulesMatcherUtils.isObject(r)))
+            return null;
+        const keys = {};
+        const conditions = Array.isArray(rules) ? { $and: rules } : rules;
+        rulesMatcherUtils.getKey(conditions, keys, options !== null && options !== void 0 ? options : {});
+        return Object.keys(keys);
+    }
+};
+/**
+ * Defines a set of comparison operators used for matching rules against user input.
+ */
+exports.operators = {
+    $exists: (a, b) => !rulesMatcherUtils.isEmpty(a) === b,
+    $eq: (a, b) => a === b,
+    $ne: (a, b) => a !== b,
+    $gt: (a, b) => rulesMatcherUtils.forceNumber(a) > parseFloat(b),
+    $gte: (a, b) => rulesMatcherUtils.forceNumber(a) >= parseFloat(b),
+    $lt: (a, b) => rulesMatcherUtils.forceNumber(a) < parseFloat(b),
+    $lte: (a, b) => rulesMatcherUtils.forceNumber(a) <= parseFloat(b),
+    $strGt: (a, b) => String(a || '').length > parseFloat(b),
+    $strGte: (a, b) => String(a || '').length >= parseFloat(b),
+    $strLt: (a, b) => String(a || '').length < parseFloat(b),
+    $strLte: (a, b) => String(a || '').length <= parseFloat(b),
+    $in: (a, b) => rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => (0, intersection_1.default)(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
+        .length),
+    $nin: (a, b) => !rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => (0, intersection_1.default)(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
+        .length),
+    $all: (a, b) => rulesMatcherUtils
+        .forceArray(b)
+        .every((c) => (0, intersection_1.default)(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
+        .length),
+    $regex: (a, b, opt) => rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => (c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a)))
+};
+// export default operators
+exports.default = rulesMatcherUtils;

package/dist/utils/rules.d.ts

@@ -0,0 +1,2 @@
+export declare function expandQuery(template: Record<string, unknown>, objs: Record<string, unknown>): any;
+//# sourceMappingURL=rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/utils/rules.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAe3F"}

package/dist/utils/rules.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandQuery = expandQuery;
+const get_1 = __importDefault(require("lodash/get"));
+// Funzione che espande dinamicamente i placeholder con supporto per percorsi annidati
+function expandQuery(template, objs) {
+    let expandedQuery = JSON.stringify(template); // Converti l'oggetto in una stringa per sostituire i placeholder
+    const regex = /:\s*"%%([a-zA-Z0-9_.]+)"/g;
+    Object.keys(objs).forEach(() => {
+        // Espandi tutti i placeholder %%values.<nested.property>
+        const callback = (match, path) => {
+            const value = (0, get_1.default)(objs, `%%${path}`); // Recupera il valore annidato da values
+            const finalValue = typeof value === 'string' ? `"${value}"` : value && JSON.stringify(value);
+            return `:${value !== undefined ? finalValue : match}`; // Sostituisci se esiste, altrimenti lascia il placeholder
+        };
+        expandedQuery = expandedQuery.replace(regex, callback);
+    });
+    return JSON.parse(expandedQuery); // Converti la stringa JSON di nuovo in un oggetto
+}

package/jest.config.ts

@@ -0,0 +1,24 @@
+module.exports = {
+  preset: '../../jest.preset.js',
+  transform: {
+    '^.+\\.[tj]s$': [
+      'ts-jest',
+      {
+        tsconfig: './tsconfig.json'
+      }
+    ]
+  },
+  collectCoverage: false,
+  collectCoverageFrom: ['./**/*.ts'],
+  coverageDirectory: 'coverage',
+  coverageThreshold: {
+    global: {
+      branches: 50,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    }
+  },
+  testEnvironment: 'node',
+  testMatch: ['./**/*.test.ts']
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@flowerforce/flowerbase",
+  "version": "1.0.1-beta.3",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "npx jest",
+    "build": "rm -rf dist/ && tsc",
+    "start": "node src/index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@fastify/cors": "^10.0.1",
+    "@fastify/jwt": "^9.0.1",
+    "@fastify/mongodb": "^9.0.1",
+    "aws-sdk": "^2.1692.0",
+    "bson": "^6.8.0",
+    "dotenv": "^16.4.7",
+    "fastify": "^5.0.0",
+    "fastify-mongoose-driver": "^3.2.0",
+    "fastify-plugin": "^5.0.1",
+    "lodash": "^4.17.21",
+    "node-cron": "^3.0.3",
+    "@sendgrid/mail": "^8.1.4",
+    "nodemon": "^3.1.7",
+    "undici": "^7.1.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.26.4",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@eslint/compat": "^1.2.3",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.12.0",
+    "@types/cors": "^2.8.17",
+    "@types/jest": "^29.5.14",
+    "@types/lodash": "^4.17.9",
+    "@types/node": "22.6.1",
+    "@types/node-cron": "^3.0.11",
+    "@typescript-eslint/eslint-plugin": "^8.14.0",
+    "@typescript-eslint/parser": "^8.14.0",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-eslint-plugin": "^6.3.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "globals": "^15.11.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.8.1"
+  },
+  "peerDependencies": {}
+}

package/project.json

@@ -0,0 +1,10 @@
+{
+  "name": "flowerbase",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/flowerbase/src",
+  "projectType": "library",
+  "tags": [
+    "flowerbase"
+  ],
+  "targets": {}
+}

package/rollup.config.js

@@ -0,0 +1,17 @@
+const { withNx } = require('@nx/rollup/with-nx')
+
+module.exports = withNx(
+  {
+    main: './src/index.ts',
+    outputPath: './dist',
+    tsConfig: './tsconfig.lib.json',
+    compiler: 'tsc',
+    format: ['cjs', 'esm'],
+    generateExportsField: true
+  },
+  {
+    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+    // e.g.
+    // output: { sourcemap: true },
+  }
+)

package/src/auth/controller.ts

@@ -0,0 +1,78 @@
+import { ObjectId } from 'bson'
+import { FastifyInstance } from 'fastify'
+import { AUTH_CONFIG, DB_NAME } from '../constants'
+import { SessionCreatedDto } from './dtos'
+import { AUTH_ENDPOINTS, AUTH_ERRORS } from './utils'
+
+const HANDLER_TYPE = 'preHandler'
+
+/**
+ * Controller for handling user authentication, profile retrieval, and session management.
+ * @testable
+ * @param {FastifyInstance} app - The Fastify instance.
+ */
+export async function authController(app: FastifyInstance) {
+  const { authCollection, userCollection } = AUTH_CONFIG
+
+  const db = app.mongo.client.db(DB_NAME)
+
+  app.addHook(HANDLER_TYPE, app.jwtAuthentication)
+
+  /**
+   * Endpoint to retrieve the authenticated user's profile.
+   *
+   * @route {GET} /profile
+   * @param {import('fastify').FastifyRequest} req - The request object.
+   * @returns {Promise<Object>} A promise resolving with the user's profile data.
+   */
+  app.get(AUTH_ENDPOINTS.PROFILE, async function (req) {
+    const user = await db
+      .collection<Record<string, unknown>>(authCollection)
+      .findOne({ _id: ObjectId.createFromHexString(req.user.id) })
+    return {
+      _id: user?._id.toString(),
+      identities: user?.identities,
+      type: 'normal',
+      custom_data: user?.curstom_data,
+      data: {
+        _id: user?._id.toString(),
+        email: user?.email
+      }
+    }
+  })
+
+  /**
+   * Endpoint to create a new session and generate a new access token.
+   *
+   * @route {POST} /session
+   * @param {import('fastify').FastifyRequest} req - The request object containing the refresh token.
+   * @param {import('fastify').FastifyReply} res - The response object.
+   * @returns {Promise<SessionCreatedDto>} A promise resolving with the newly created session data.
+   */
+  app.post<{ Reply: SessionCreatedDto }>(
+    AUTH_ENDPOINTS.SESSION,
+    async function (req, res) {
+      if (req.user.typ !== 'refresh') {
+        throw new Error(AUTH_ERRORS.INVALID_TOKEN)
+      }
+
+      const auth_user = await db
+        ?.collection(authCollection)
+        .findOne({ _id: new this.mongo.ObjectId(req.user.sub) })
+
+      if (!auth_user) {
+        throw new Error(`User with ID ${req.user.sub} not found`)
+      }
+
+      const user = await db!.collection(userCollection).findOne({ [AUTH_CONFIG.user_id_field]: req.user.sub })
+
+      res.status(201)
+      return {
+        access_token: this.createAccessToken({
+          ...auth_user,
+          user_data: user
+        })
+      }
+    }
+  )
+}

package/src/auth/dtos.ts

@@ -0,0 +1,6 @@
+export type SessionCreatedDto = {
+  access_token: string
+}
+
+export type User = unknown
+export type Arguments<T = unknown> = T[]

package/src/auth/plugins/jwt.ts

@@ -0,0 +1,68 @@
+import fastifyJwt from '@fastify/jwt'
+import fp from 'fastify-plugin'
+import { Document, ObjectId, WithId } from 'mongodb'
+
+type Options = {
+  secret: string
+}
+
+/**
+ * This module is a Fastify plugin that sets up JWT-based authentication and token creation.
+ * It registers JWT authentication, and provides methods to create access and refresh tokens.
+ * @testable
+ * @param {import('fastify').FastifyInstance} fastify - The Fastify instance.
+ * @param {Object} opts - Options for the plugin.
+ * @param {string} opts.secret - The secret key used for signing JWTs.
+ */
+export default fp(async function (fastify, opts: Options) {
+  const BAAS_ID = new ObjectId().toString()
+
+  fastify.register(fastifyJwt, {
+    secret: opts.secret
+  })
+
+  fastify.decorate('jwtAuthentication', async function (request, reply) {
+    try {
+      await request.jwtVerify()
+    } catch (err) {
+      // TODO: handle error
+      reply.send(err)
+    }
+  })
+
+  fastify.decorate('createAccessToken', function (user: WithId<Document>) {
+    const id = user._id.toString()
+    const user_data = {
+      _id: id,
+      id,
+      ...user.user_data
+    }
+    return this.jwt.sign(
+      {
+        typ: 'access',
+        id,
+        user_data: user_data,
+        custom_data: user_data
+      },
+      {
+        iss: BAAS_ID,
+        jti: BAAS_ID,
+        sub: user._id.toJSON(),
+        expiresIn: '300m'
+      }
+    )
+  })
+
+  fastify.decorate('createRefreshToken', function (user: WithId<Document>) {
+    return this.jwt.sign(
+      {
+        typ: 'refresh',
+        baas_id: BAAS_ID
+      },
+      {
+        sub: user._id.toJSON(),
+        expiresIn: '60d'
+      }
+    )
+  })
+})