@flowerforce/flowerbase 1.0.1-beta.3

package/src/features/functions/controller.ts

@@ -0,0 +1,102 @@
+import { ObjectId } from 'bson'
+
+
+import { services } from '../../services'
+import { StateManager } from '../../state'
+import { GenerateContext } from '../../utils/context'
+import { Base64Function, FunctionCallBase64Dto, FunctionCallDto } from './dtos'
+import { FunctionController } from './interface'
+import { executeQuery } from './utils'
+
+/**
+ * > Creates a pre handler for every query
+ * @param app -> the fastify instance
+ * @param functionsList -> the list of all functions
+ * @param rules -> all the rules
+ */
+export const functionsController: FunctionController = async (
+  app,
+  { functionsList, rules }
+) => {
+  app.addHook('preHandler', app.jwtAuthentication)
+
+  app.post<{ Body: FunctionCallDto }>('/call', async (req, res) => {
+    const { user } = req
+    const { name: method, arguments: args } = req.body
+
+    if ('service' in req.body) {
+      const serviceFn = services[req.body.service]
+      if (!serviceFn) {
+        throw new Error(`Service "${req.body.service}" does not exist`)
+      }
+      const [{ database, collection, query, update, document }] = args
+
+      const currentMethod = serviceFn(app, { rules, user })
+        .db(database)
+        .collection(collection)[method]
+
+      const operatorsByType = await executeQuery({
+        currentMethod,
+        query,
+        update,
+        document
+      })
+      return operatorsByType[method as keyof typeof operatorsByType]()
+    }
+
+    const currentFunction = functionsList[method]
+
+    if (!currentFunction) {
+      throw new Error(`Function "${req.body.name}" does not exist`)
+    }
+
+    if (currentFunction.private) {
+      throw new Error(`Function "${req.body.name}" is private`)
+    }
+
+
+    const result = await GenerateContext({
+      args: req.body.arguments,
+      app,
+      rules,
+      user: { ...user, _id: new ObjectId(user.id) },
+      currentFunction,
+      functionsList,
+      services
+    })
+    res.type("application/json")
+    return JSON.stringify(result)
+  })
+  app.get<{
+    Querystring: FunctionCallBase64Dto,
+  }>('/call', async (req, res) => {
+    const { query, user } = req
+    const { baas_request, stitch_request } = query
+
+    const config: Base64Function = JSON.parse(Buffer.from(baas_request || stitch_request || "", "base64").toString("utf8"));
+    const [{ database, collection }] = config.arguments
+    const app = StateManager.select("app")
+    const services = StateManager.select("services")
+
+    const changeStream = await services["mongodb-atlas"](app, {
+      user,
+      rules
+    }).db(database).collection(collection).watch([], { fullDocument: "whenAvailable" })
+
+    res.header('Content-Type', 'text/event-stream');
+    res.header('Cache-Control', 'no-cache');
+    res.header('Connection', 'keep-alive');
+    res.raw.flushHeaders();
+
+
+    changeStream.on('change', (change) => {
+      res.raw.write(`data: ${JSON.stringify(change)}\n\n`);
+    });
+
+    req.raw.on('close', () => {
+      changeStream.close();
+    });
+  })
+
+
+}

package/src/features/functions/dtos.ts

@@ -0,0 +1,41 @@
+import { Document } from "mongodb"
+import { Arguments } from '../../auth/dtos'
+import { GetOperatorsFunction } from '../../services/mongodb-atlas/model'
+
+type MethodName = Exclude<keyof ReturnType<GetOperatorsFunction>, 'match'>
+
+export type FunctionCallDto =
+  | {
+    name: MethodName
+    arguments: ArgumentsData
+  }
+  | {
+    arguments: ArgumentsData
+    name: MethodName
+    service: 'mongodb-atlas'
+  }
+
+export type FunctionCallBase64Dto = {
+  baas_request?: string
+  stitch_request?: string
+}
+
+type ArgumentsData = Arguments<{
+  database: string
+  collection: string
+  query: Parameters<GetOperatorsFunction>
+  update: Document
+  document: Document
+}>
+
+
+export type Base64Function = {
+  name: string
+  arguments: Argument[]
+  service: string
+}
+
+type Argument = {
+  database: string
+  collection: string
+}

package/src/features/functions/index.ts

@@ -0,0 +1,21 @@
+import { API_VERSION } from '../../constants'
+import { functionsController } from './controller'
+import { RegisterFunctionsParams } from './interface'
+
+/**
+ * > Registers the functions controller
+ * @param app -> the fastify instance
+ * @param functionsList -> the list of all functions
+ * @param rulesList -> the list of all rules
+ */
+export const registerFunctions = async ({
+  app,
+  rulesList,
+  functionsList
+}: RegisterFunctionsParams) => {
+  await app.register(functionsController, {
+    functionsList,
+    rules: rulesList,
+    prefix: `${API_VERSION}/app/:appId/functions`
+  })
+}

package/src/features/functions/interface.ts

@@ -0,0 +1,38 @@
+import { FastifyInstance } from 'fastify'
+import { Document } from "mongodb"
+import { GetOperatorsFunction } from '../../services/mongodb-atlas/model'
+import { Rules } from '../rules/interface'
+
+export interface FunctionConfig {
+  name: string
+  private?: boolean
+  run_as_system?: boolean
+  disable_arg_logs?: boolean
+}
+
+export type Function = Omit<FunctionConfig, 'name'> & { code: string }
+
+export type Functions = Record<string, Function>
+
+export type RegisterFunctionsParams = {
+  app: FastifyInstance
+  functionsList: Functions
+  rulesList: Rules
+}
+
+export type ExecuteQueryParams = {
+  currentMethod: ReturnType<GetOperatorsFunction>[keyof ReturnType<GetOperatorsFunction>]
+  query: Parameters<GetOperatorsFunction>
+  update: Document
+  document: Document
+}
+
+type FunctionsControllerOptions = {
+  functionsList: Functions
+  rules: Rules
+}
+
+export type FunctionController = (
+  app: FastifyInstance,
+  { functionsList, rules }: FunctionsControllerOptions
+) => Promise<void>

package/src/features/functions/utils.ts

@@ -0,0 +1,82 @@
+import fs from 'fs'
+import path from 'node:path'
+import { EJSON } from 'bson'
+import { GetOperatorsFunction } from '../../services/mongodb-atlas/model'
+import { ExecuteQueryParams, Functions } from './interface'
+
+/**
+ * > Loads the functions config json file
+ * @testable
+ */
+export const loadFunctions = async (rootDir = process.cwd()): Promise<Functions> => {
+  const fnDir = 'functions'
+  const configFile = path.join(rootDir, fnDir, 'config.json')
+  const config = JSON.parse(fs.readFileSync(configFile, 'utf-8')) as {
+    name: string
+  }[]
+
+  const functions = config.reduce((acc, { name, ...opts }) => {
+    const extensions = ['.js', '.ts'];
+    let code = '';
+    const fnPath = extensions
+      .map(ext => path.join(rootDir, fnDir, `${name}${ext}`))
+      .find(fs.existsSync);
+
+    if (!fnPath) {
+      throw new Error(`File ${name}.js or ${name}.ts not found`);
+    }
+    code = fs.readFileSync(fnPath, 'utf-8');
+    acc[name] = { code, ...opts }
+
+    return acc
+  }, {} as Functions)
+
+  return 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 const executeQuery = async ({
+  currentMethod,
+  query,
+  update,
+  document
+}: ExecuteQueryParams) => {
+  return {
+    find: async () =>
+      await (currentMethod as ReturnType<GetOperatorsFunction>['find'])(
+        EJSON.deserialize(query)
+      ).toArray(),
+    findOne: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['findOne'])(
+        EJSON.deserialize(query)
+      ),
+    deleteOne: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['deleteOne'])(
+        EJSON.deserialize(query)
+      ),
+    insertOne: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['insertOne'])(
+        EJSON.deserialize(document)
+      ),
+    updateOne: () => currentMethod(EJSON.deserialize(query), EJSON.deserialize(update)),
+    aggregate: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['aggregate'])(
+        EJSON.deserialize(query)
+      ),
+    insertMany: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['insertMany'])(
+        EJSON.deserialize(query)
+      ),
+    updateMany: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['updateMany'])(
+        EJSON.deserialize(query), EJSON.deserialize(update)
+      ),
+
+
+  }
+}

package/src/features/rules/interface.ts

@@ -0,0 +1,24 @@
+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>

package/src/features/rules/utils.ts

@@ -0,0 +1,20 @@
+import fs from 'fs'
+import path from 'node:path'
+import { readJsonContent } from '../../utils'
+import { Rules, RulesConfig } from './interface'
+
+export const loadRules = async (rootDir = process.cwd()): Promise<Rules> => {
+  const rulesRoot = path.join(rootDir, 'data_sources', 'mongodb-atlas')
+  const files = fs.readdirSync(rulesRoot, { recursive: true }) as string[]
+  const rulesFiles = files.filter((x) => (x as string).endsWith('rules.json'))
+
+  const rulesByCollection = rulesFiles.reduce((acc, rulesFile) => {
+    const filePath = path.join(rulesRoot, rulesFile)
+    const collectionRules = readJsonContent(filePath) as RulesConfig
+    acc[collectionRules.collection] = collectionRules
+
+    return acc
+  }, {} as Rules)
+
+  return rulesByCollection
+}

package/src/features/triggers/dtos.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
+}

package/src/features/triggers/index.ts

@@ -0,0 +1,34 @@
+import { services } from '../../services'
+import { Function, Functions } from '../functions/interface'
+import { ActivateTriggersParams } from './dtos'
+import { TRIGGER_HANDLERS } from './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
+ */
+export const activateTriggers = async ({
+  fastify,
+  triggersList,
+  functionsList
+}: ActivateTriggersParams) => {
+  try {
+    for await (const trigger of triggersList) {
+      const { content } = trigger
+      const { type, config, event_processors } = content
+
+      const functionName: keyof Functions = event_processors.FUNCTION.config.function_name
+      const triggerHandler = functionsList[functionName] as Function
+
+      await TRIGGER_HANDLERS[type]({ config, triggerHandler, app: fastify, services, functionsList })
+
+    }
+  } catch (e) {
+    console.error('Error while activating triggers', (e as Error).message)
+  }
+}
+
+

package/src/features/triggers/interface.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
+}

package/src/features/triggers/utils.ts

@@ -0,0 +1,157 @@
+import fs from 'fs'
+import path from 'node:path'
+import cron from "node-cron"
+import { AUTH_CONFIG } from '../../constants'
+import { readJsonContent } from '../../utils'
+import { GenerateContext } from '../../utils/context'
+import { HandlerParams, Trigger, 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 const loadTriggers = async (rootDir = process.cwd()): Promise<Triggers> => {
+  const triggersPath = path.join(rootDir, 'triggers')
+  const files = fs.readdirSync(triggersPath)
+
+  const triggers = files
+    .filter((fileName) => fileName.endsWith('.json'))
+    .map((fileName) => ({
+      fileName,
+      content: readJsonContent(path.join(triggersPath, fileName)) as Trigger
+    }))
+
+  return triggers
+}
+
+/**
+ * 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 = async ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => {
+  cron.schedule(config.schedule, async () => {
+    await GenerateContext({
+      args: [],
+      app,
+      rules: {},
+      user: {},
+      currentFunction: triggerHandler,
+      functionsList,
+      services
+    })
+
+  });
+}
+
+const handleAuthenticationTrigger = async ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => {
+  const { database } = config
+  const pipeline = [{
+    $match: {
+      operationType: { $in: ["INSERT"] }
+    }
+  }]
+  const changeStream = app.mongo.client.db(database).collection(AUTH_CONFIG.authCollection).watch(pipeline, {
+    fullDocument: 'whenAvailable'
+  })
+  changeStream.on('change', async function (change) {
+    const document = change["fullDocument" as keyof typeof change] as Record<string, string> //TODO -> define user type
+
+    if (document) {
+      delete document.password
+
+      const currentUser = { ...document }
+      delete currentUser.password
+      await 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 = async ({ config, triggerHandler, functionsList, services, app }: HandlerParams) => {
+  const {
+    database,
+    collection: collectionName,
+    operation_types = [],
+    match = {},
+    project = {}
+  } = config
+
+  const collection = app.mongo.client.db(database).collection(collectionName)
+  const pipeline = [
+    {
+      $match: {
+        operationType: { $in: operation_types.map((op: string) => op.toLowerCase()) },
+        ...match
+      }
+    },
+    Object.keys(project).length
+      ? {
+        $project: project
+      }
+      : undefined
+  ].filter(Boolean) as Parameters<typeof collection.watch>[0]
+  const changeStream = collection.watch(pipeline, {
+    fullDocument: config.full_document ? 'whenAvailable' : undefined,
+    fullDocumentBeforeChange: config.full_document_before_change
+      ? 'whenAvailable'
+      : undefined
+  })
+  changeStream.on('change', async function (change) {
+    await GenerateContext({
+      args: [change],
+      app,
+      rules: {},
+      user: {},
+      currentFunction: triggerHandler,
+      functionsList,
+      services
+    })
+  })
+  // TODO -> gestire close dello stream
+}
+
+export const TRIGGER_HANDLERS = {
+  SCHEDULED: handleCronTrigger,
+  DATABASE: handleDataBaseTrigger,
+  AUTHENTICATION: handleAuthenticationTrigger
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+import 'dotenv/config'
+import Fastify from 'fastify'
+import { DEFAULT_CONFIG } from './constants'
+import { generateEndpoints } from './features/endpoints'
+import { loadEndpoints } from './features/endpoints/utils'
+import { registerFunctions } from './features/functions'
+import { loadFunctions } from './features/functions/utils'
+import { loadRules } from './features/rules/utils'
+import { activateTriggers } from './features/triggers'
+import { loadTriggers } from './features/triggers/utils'
+import { services } from './services'
+import { StateManager } from './state'
+import { exposeRoutes } from './utils/initializer/exposeRoutes'
+import { registerPlugins } from './utils/initializer/registerPlugins'
+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 async function initialize({
+  projectId,
+  host,
+  jwtSecret = DEFAULT_CONFIG.JWT_SECRET,
+  port = DEFAULT_CONFIG.PORT,
+  mongodbUrl = DEFAULT_CONFIG.MONGODB_URL
+}: InitializeConfig) {
+  const fastify = Fastify({
+    logger: false
+  })
+
+
+  const functionsList = await loadFunctions()
+  const triggersList = await loadTriggers()
+  const endpointsList = await loadEndpoints()
+  const rulesList = await loadRules()
+  const stateConfig = {
+    functions: functionsList,
+    triggers: triggersList,
+    endpoints: endpointsList,
+    rules: rulesList,
+    app: fastify,
+    services
+  }
+
+  Object.entries(stateConfig).forEach(([key, value]) => StateManager.setData(key as Parameters<typeof StateManager.setData>[0], value))
+
+  await registerPlugins({
+    register: fastify.register,
+    mongodbUrl,
+    jwtSecret,
+    functionsList
+  })
+  await exposeRoutes(fastify)
+  await registerFunctions({ app: fastify, functionsList, rulesList })
+
+  await generateEndpoints({ app: fastify, functionsList, endpointsList })
+
+  fastify.ready(() => activateTriggers({ fastify, triggersList, functionsList }))
+  await fastify.listen({ port, host })
+
+  fastify.log.info(`[${projectId}] Server listening on port ${port}`)
+}

package/src/model.ts

@@ -0,0 +1 @@
+export { Document, WithId } from 'mongodb';