@flowerforce/flowerbase 1.0.1-beta.3

package/src/auth/providers/local-userpass/controller.ts

@@ -0,0 +1,226 @@
+import sendGrid from "@sendgrid/mail"
+import { FastifyInstance } from 'fastify'
+import { AUTH_CONFIG, DB_NAME } from '../../../constants'
+import { StateManager } from "../../../state"
+import { GenerateContext } from "../../../utils/context"
+import { comparePassword, generateToken, hashPassword } from '../../../utils/crypto'
+import {
+  AUTH_ENDPOINTS,
+  AUTH_ERRORS,
+  CONFIRM_RESET_SCHEMA,
+  getMailConfig,
+  LOGIN_SCHEMA,
+  PROVIDER_TYPE,
+  REGISTRATION_SCHEMA,
+  RESET_SCHEMA
+} from '../../utils'
+import { ConfirmResetPasswordDto, LoginDto, RegistrationDto, ResetPasswordDto } from './dtos'
+
+/**
+ * Controller for handling local user registration and login.
+ * @testable
+ * @param {FastifyInstance} app - The Fastify instance.
+ */
+export async function localUserPassController(app: FastifyInstance) {
+  const { authCollection } = AUTH_CONFIG
+  const db = app.mongo.client.db(DB_NAME)
+
+  /**
+   * Endpoint for user registration.
+   *
+   * @route {POST} /register
+   * @param {RegistrationDto} req - The request object with registration data.
+   * @param {FastifyReply} res - The response object.
+   * @returns {Promise<Object>} A promise resolving with the newly created user's ID.
+   */
+  app.post<RegistrationDto>(
+    AUTH_ENDPOINTS.REGISTRATION,
+    {
+      schema: REGISTRATION_SCHEMA
+    },
+    async function (req, res) {
+      const { email, password } = req.body
+      const hashedPassword = await hashPassword(password)
+
+      const existingUser = await db.collection(authCollection!).findOne({
+        email
+      })
+
+      if (existingUser) {
+        res.status(409)
+        return {
+          error: 'This email address is already used'
+        }
+      }
+
+      const result = await db.collection(authCollection!).insertOne({
+        email: email,
+        password: hashedPassword,
+        custom_data: {
+          // todo li faremo arrivare
+        }
+      })
+
+      await db?.collection(authCollection!).updateOne(
+        {
+          email: email
+        },
+        {
+          $set: {
+            identities: [
+              {
+                id: result?.insertedId.toString(),
+                provider_id: result?.insertedId.toString(),
+                provider_type: PROVIDER_TYPE,
+                provider_data: { email }
+              }
+            ]
+          }
+        }
+      )
+
+      res.status(201)
+      return {
+        userId: result?.insertedId
+      }
+    }
+  )
+
+  /**
+   * Endpoint for user login.
+   *
+   * @route {POST} /login
+   * @param {LoginDto} req - The request object with login data.
+   * @returns {Promise<Object>} A promise resolving with access and refresh tokens.
+   */
+  app.post<LoginDto>(
+    AUTH_ENDPOINTS.LOGIN,
+    {
+      schema: LOGIN_SCHEMA
+    },
+    async function (req) {
+
+      const storedUser = await db.collection(authCollection!).findOne({
+        email: req.body.username
+      })
+
+      if (!storedUser) {
+        throw new Error(AUTH_ERRORS.INVALID_CREDENTIALS)
+      }
+
+      const passwordMatches = await comparePassword(
+        req.body.password,
+        storedUser.password
+      )
+
+      if (!passwordMatches) {
+        throw new Error(AUTH_ERRORS.INVALID_CREDENTIALS)
+      }
+
+      return {
+        access_token: this.createAccessToken(storedUser),
+        refresh_token: this.createRefreshToken(storedUser),
+        device_id: '',
+        user_id: storedUser._id.toString()
+      }
+    }
+  )
+
+  /**
+ * Endpoint for reset password.
+ *
+ * @route {POST} /reset/call
+ * @param {ResetPasswordDto} req - The request object with th reset request.
+ * @returns {Promise<void>}
+ */
+  app.post<ResetPasswordDto>(
+    AUTH_ENDPOINTS.RESET,
+    {
+      schema: RESET_SCHEMA
+    },
+    async function (req) {
+      const { resetPasswordCollection, resetPasswordConfig } = AUTH_CONFIG
+      const email = req.body.email
+      const storedUser = await db.collection(authCollection!).findOne({
+        email
+      })
+
+      if (!storedUser) {
+        throw new Error(AUTH_ERRORS.INVALID_CREDENTIALS)
+      }
+
+      const token = generateToken()
+      const tokenId = generateToken()
+
+      await db?.collection(resetPasswordCollection).updateOne(
+        { email },
+        { $set: { token, tokenId, email, createdAt: new Date() } },
+        { upsert: true }
+      );
+
+
+      if (resetPasswordConfig.runResetFunction && resetPasswordConfig.resetFunctionName) {
+        const functionsList = StateManager.select("functions")
+        const services = StateManager.select("services")
+        const currentFunction = functionsList[resetPasswordConfig.resetFunctionName]
+        await GenerateContext({
+          args: [{ token, tokenId, email }],
+          app,
+          rules: {},
+          user: {},
+          currentFunction,
+          functionsList,
+          services
+        })
+        return
+      }
+
+      const { from, subject, mailToken, body } = getMailConfig(resetPasswordConfig, token, tokenId)
+      sendGrid.setApiKey(mailToken)
+      await sendGrid.send({
+        to: email,
+        from,
+        subject,
+        html: body
+      });
+
+    }
+  )
+
+  /**
+* Endpoint for confirm reset password.
+*
+* @route {POST} /reset
+* @param {ConfirmResetPasswordDto} req - The request object with reset data.
+* @returns {Promise<void>}
+*/
+  app.post<ConfirmResetPasswordDto>(
+    AUTH_ENDPOINTS.CONFIRM_RESET,
+    {
+      schema: CONFIRM_RESET_SCHEMA
+    },
+    async function (req) {
+      const { resetPasswordCollection } = AUTH_CONFIG
+      const { token, tokenId, password } = req.body
+
+      const resetRequest = await db?.collection(resetPasswordCollection).findOne(
+        { token, tokenId },
+      );
+
+      if (!resetRequest) {
+        throw new Error(AUTH_ERRORS.INVALID_RESET_PARAMS)
+      }
+      const hashedPassword = await hashPassword(password)
+      await db.collection(authCollection!).updateOne({ email: resetRequest.email, }, {
+        $set: {
+          password: hashedPassword
+        }
+      })
+
+      await db?.collection(resetPasswordCollection).deleteOne(
+        { _id: resetRequest._id },
+      );
+
+    }
+  )
+}

package/src/auth/providers/local-userpass/dtos.ts

@@ -0,0 +1,40 @@
+export type RegisterUserDto = {
+  email: string
+  password: string
+}
+
+export type LoginUserDto = {
+  username: string
+  password: string
+}
+
+export type LoginSuccessDto = {
+  access_token: string
+  device_id: string
+  refresh_token: string
+  user_id: string
+}
+
+export interface RegistrationDto {
+  Body: RegisterUserDto
+}
+
+export interface LoginDto {
+  Body: LoginUserDto
+  Reply: LoginSuccessDto
+}
+
+export interface ResetPasswordDto {
+  Body: {
+    email: string
+    password: string
+  }
+}
+
+export interface ConfirmResetPasswordDto {
+  Body: {
+    token: string
+    tokenId: string
+    password: string
+  }
+}

package/src/auth/utils.ts

@@ -0,0 +1,165 @@
+import fs from 'fs'
+
+export const LOGIN_SCHEMA = {
+  body: {
+    type: 'object',
+    properties: {
+      username: { type: 'string' },
+      password: { type: 'string' }
+    },
+    required: ['username', 'password']
+  }
+}
+
+export const RESET_SCHEMA = {
+  body: {
+    type: 'object',
+    properties: {
+      email: { type: 'string' },
+      password: { type: 'string' }
+    },
+    required: ['email', 'password']
+  }
+}
+
+
+export const CONFIRM_RESET_SCHEMA = {
+  body: {
+    type: 'object',
+    properties: {
+      password: { type: 'string' },
+      token: { type: 'string' },
+      tokenId: { type: 'string' }
+    },
+    required: ['password', 'token', 'tokenId']
+  }
+}
+
+
+export const REGISTRATION_SCHEMA = {
+  body: {
+    type: 'object',
+    properties: {
+      email: { type: 'string' },
+      password: { type: 'string' }
+    },
+    required: ['email', 'password']
+  }
+}
+
+export enum AUTH_ENDPOINTS {
+  LOGIN = '/login',
+  REGISTRATION = '/register',
+  PROFILE = '/profile',
+  SESSION = '/session',
+  RESET = '/reset/call',
+  CONFIRM_RESET = "/reset"
+}
+
+export enum AUTH_ERRORS {
+  INVALID_CREDENTIALS = 'Invalid credentials',
+  INVALID_TOKEN = 'Invalid refresh token provided',
+  INVALID_RESET_PARAMS = 'Invalid token or tokenId provided'
+}
+
+export interface AuthConfig {
+  auth_collection?: string
+  'api-key': ApiKey
+  'local-userpass': LocalUserpass
+}
+
+interface ApiKey {
+  name: string
+  type: string
+  disabled: boolean
+}
+interface LocalUserpass {
+  name: string
+  type: string
+  disabled: boolean
+  config: Config
+}
+
+export interface Config {
+  autoConfirm: boolean
+  resetFunctionName: string
+  resetPasswordUrl: string
+  runConfirmationFunction: boolean
+  runResetFunction: boolean
+  mailConfig: {
+    from: string
+    subject: string
+    mailToken: string
+  }
+}
+
+export interface CustomUserDataConfig {
+  enabled: boolean
+  mongo_service_name: string
+  database_name: string
+  collection_name: string
+  user_id_field: string
+}
+
+export const PROVIDER_TYPE = 'local-userpass'
+
+/**
+ * > Loads the auth config json file
+ * @testable
+ */
+export const loadAuthConfig = (): AuthConfig => {
+  return JSON.parse(fs.readFileSync('auth/providers.json', 'utf-8'))
+}
+
+/**
+ * > Loads the custom user data config json file
+ * @testable
+ */
+export const loadCustomUserData = (): CustomUserDataConfig => {
+  return JSON.parse(fs.readFileSync('auth/custom_user_data.json', 'utf-8'))
+}
+
+
+
+export const getMailConfig = (resetPasswordConfig: Config, token: string, tokenId: string) => {
+  const { mailConfig, resetPasswordUrl } = resetPasswordConfig
+  const ENV_PREFIX = "ENV"
+  const { from, subject, mailToken } = mailConfig
+
+  const [fromPrefix, fromPath] = from.split(".")
+  const currentSender = (fromPrefix === ENV_PREFIX ? process.env[fromPath] : from) ?? ""
+  const [subjectPrefix, subjectPath] = subject.split(".")
+  const currentSubject = (subjectPrefix === ENV_PREFIX ? process.env[subjectPath] : subject) ?? ""
+  const [mailTokenPrefix, mailTokenPath] = mailToken.split(".")
+  const currentMailToken = (mailTokenPrefix === "ENV" ? process.env[mailTokenPath] : mailToken) ?? ""
+
+  const link = `${resetPasswordUrl}/${token}/${tokenId}`;
+  const body = `<body style="font-family: Arial, sans-serif; background-color: #f4f4f4; text-align: center; padding: 20px;">
+  <table width="100%" cellspacing="0" cellpadding="0">
+      <tr>
+          <td align="center">
+              <table width="600" cellspacing="0" cellpadding="0" style="background: #ffffff; padding: 20px; border-radius: 8px; box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);">
+                  <tr>
+                      <td align="center">
+                          <h2>Password Reset Request</h2>
+                          <p>If you requested a password reset, click the button below to reset your password.</p>
+                          <p>If you did not request this, please ignore this email.</p>
+                          <p>
+                              <a href="${link}" style="display: inline-block; padding: 12px 20px; font-size: 16px; color: #ffffff; background: #007bff; text-decoration: none; border-radius: 5px;">Reset Password</a>
+                          </p>
+                          <p style="margin-top: 20px; font-size: 12px; color: #777;">If the button does not work, copy and paste the following link into your browser:</p>
+                          <p style="font-size: 12px; color: #777;">${link}</p>
+                      </td>
+                  </tr>
+              </table>
+          </td>
+      </tr>
+  </table>
+</body>`
+  return {
+    from: currentSender ?? "",
+    subject: currentSubject,
+    mailToken: currentMailToken,
+    body
+  }
+}

package/src/babel.config.json

@@ -0,0 +1,3 @@
+{
+    "presets": ["@babel/preset-env"]
+}

package/src/constants.ts

@@ -0,0 +1,22 @@
+import { loadAuthConfig, loadCustomUserData } from './auth/utils'
+
+const { database_name, collection_name = 'users', user_id_field = "id" } = loadCustomUserData()
+const { auth_collection = 'auth_users', ...configuration } = loadAuthConfig()
+
+export const DEFAULT_CONFIG = {
+  PORT: Number(process.env.PORT) || 3000,
+  MONGODB_URL: process.env.MONGODB_URL || '',
+  JWT_SECRET: process.env.JWT_SECRET || '',
+  API_VERSION: process.env.API_VERSION || "v2.0",
+  HTTPS_SCHEMA: process.env.HTTPS_SCHEMA || 'https'
+}
+export const API_VERSION = `/api/client/${DEFAULT_CONFIG.API_VERSION}`
+export const HTTPS_SCHEMA = DEFAULT_CONFIG.HTTPS_SCHEMA
+export const DB_NAME = database_name
+export const AUTH_CONFIG = {
+  authCollection: auth_collection,
+  userCollection: collection_name,
+  resetPasswordCollection: "reset-password-requests",
+  resetPasswordConfig: configuration['local-userpass'].config,
+  user_id_field
+}

package/src/fastify.d.ts

@@ -0,0 +1,28 @@
+import { FastifyRequest as FastifyRequestType } from 'fastify'
+
+type User = Record<string, unknown>
+type UserData = Record<string, unknown>
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    jwtAuthentication(req: FastifyRequestType, rep: FastifyReply): Promise<void>
+    createAccessToken(user: User): string
+    createRefreshToken(user: User): string
+  }
+
+  interface FastifyRequest {
+    user:
+      | {
+          id: string
+          typ: 'refresh'
+          sub: string
+          user_data: UserData
+          user: User
+        }
+      | {
+          typ: 'access'
+          user_data: UserData
+          id: string
+        }
+  }
+}

package/src/features/endpoints/index.ts

@@ -0,0 +1,27 @@
+import { GenerateEndpointsParams } from './interface'
+import { generateHandler, getMethodsConfig } from './utils'
+
+/**
+ * > Generates all HTTP endpoints
+ * @testable
+ * @param app -> the fastify instance
+ * @param functionsList -> the list of all functions
+ * @param endpointsList -> the list of all endpoints
+ */
+export const generateEndpoints = async ({
+  app,
+  functionsList,
+  endpointsList
+}: GenerateEndpointsParams) => {
+  endpointsList.forEach(({ http_method, route, disabled, function_name }) => {
+    const currentFunction = functionsList[function_name]
+
+    if (disabled || !currentFunction) return
+
+    const handler = generateHandler({ app, currentFunction, functionsList })
+    const currentMethod = getMethodsConfig(app, handler, `/app/:appId/endpoint/${route}`)[
+      http_method
+    ]
+    currentMethod()
+  })
+}

package/src/features/endpoints/interface.ts

@@ -0,0 +1,29 @@
+import { FastifyInstance } from 'fastify'
+import { Function, Functions } from '../functions/interface'
+
+export type GenerateEndpointsParams = {
+  app: FastifyInstance
+  functionsList: Functions
+  endpointsList: Endpoints
+}
+
+export type GenerateHandlerParams = {
+  app: FastifyInstance
+  currentFunction: Function
+  functionsList: Functions
+}
+
+type HTTP_METHOD<T> = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | T
+
+export type Endpoint<T = 'ALL'> = {
+  http_method: HTTP_METHOD<T>
+  route: string
+  function_name: string
+  secret_name: string
+  validation_method: string
+  respond_result: boolean
+  fetch_custom_user_data: boolean
+  create_user_on_auth: boolean
+  disabled: boolean
+}
+export type Endpoints<T = 'ALL'> = Endpoint<T>[]

package/src/features/endpoints/utils.ts

@@ -0,0 +1,72 @@
+import fs from 'fs'
+import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
+
+import { services } from '../../services'
+
+import { GenerateContext } from '../../utils/context'
+import { Endpoints, GenerateHandlerParams } from './interface'
+
+/**
+ * > Loads the endpoint config json file
+ * @testable
+ */
+export const loadEndpoints = async (): Promise<Endpoints> => {
+  const config: Endpoints<'*'> = JSON.parse(
+    fs.readFileSync('http_endpoints/config.json', 'utf-8')
+  )
+  return config.map(({ http_method, ...endpoint }) => ({
+    http_method: http_method === '*' ? 'ALL' : http_method,
+    ...endpoint
+  }))
+}
+
+/**
+ * > Creates an object with a config for all HTTP methods
+ * @testable
+ * @param app -> the fastify instance
+ * @param handler -> the handler function for that route
+ * @param endpoint -> the current endpoint
+ */
+export const getMethodsConfig = (
+  app: FastifyInstance,
+  handler: ReturnType<typeof generateHandler>,
+  endpoint: string
+) => ({
+  ALL: () => app.all(endpoint, handler),
+  GET: () => app.get(endpoint, handler),
+  POST: () => app.post(endpoint, handler),
+  PUT: () => app.put(endpoint, handler),
+  PATCH: () => app.patch(endpoint, handler),
+  DELETE: () => app.delete(endpoint, handler)
+})
+
+/**
+ * > Creates an handler function for a single endpoint
+ * @testable
+ * @param app -> the fastify instance
+ * @param currentFunction -> the name of the function that should be called for that endpoint
+ * @param functionsList -> the list of all functions
+ */
+export const generateHandler = ({
+  app,
+  currentFunction,
+  functionsList
+}: GenerateHandlerParams) => {
+  return async (req: FastifyRequest, res: FastifyReply) => {
+    try {
+      const response = await GenerateContext({
+        args: [req],
+        app,
+        rules: {}, //TODO -> check rules
+        user: req.user,
+        currentFunction,
+        functionsList,
+        services
+      })
+      res.send(response)
+    } catch (e) {
+      console.log(e)
+    }
+    return {}
+  }
+}