@flowerforce/flowerbase 1.0.1-beta.3

package/src/utils/roles/machines/write/A/index.ts

@@ -0,0 +1,25 @@
+import { evaluateDocumentFiltersFn } from '../../commonValidators'
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+
+export const STEP_A_STATES: States = {
+  checkDocumentsFilters: async ({ context, next, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "A", step: 1, stepName: "checkDocumentsFilters" })
+    const { role } = context
+    if (role.document_filters) {
+      return next('evaluateDocumentsFiltersWrite')
+    }
+    return goToNextValidationStage()
+  },
+  evaluateDocumentsFiltersWrite: async ({
+    context,
+    endValidation,
+    goToNextValidationStage
+  }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 2, stepName: "evaluateDocumentsFiltersWrite" })
+    const check = await evaluateDocumentFiltersFn(context, "write")
+    return check ? goToNextValidationStage() : endValidation({ success: false })
+  }
+}
+
+

package/src/utils/roles/machines/write/B/index.ts

@@ -0,0 +1,43 @@
+import { checkFieldsPropertyExists, evaluateTopLevelPermissionsFn } from '../../commonValidators'
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+
+export const STEP_B_STATES: States = {
+  checkDeleteRequest: async ({ context, next }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 1, stepName: "checkDeleteRequest" })
+    if (context.params.type === 'delete') {
+      return next('evaluateTopLevelDelete')
+    }
+    return next('evaluateTopLevelWrite')
+  },
+  evaluateTopLevelDelete: async ({
+    context,
+    endValidation,
+  }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 2, stepName: "evaluateTopLevelDelete" })
+    const check = await evaluateTopLevelPermissionsFn(context, "delete")
+    return endValidation({ success: !!check })
+  },
+  evaluateTopLevelWrite: async ({ context, next, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 3, stepName: "evaluateTopLevelWrite" })
+    const check = await evaluateTopLevelPermissionsFn(context, "write")
+    if (check) return context.params.type === "insert" ? next('evaluateTopLevelInsert') : endValidation({ success: true })
+    return check === false
+      ? endValidation({ success: false })
+      : next('checkFieldsProperty')
+  },
+  checkFieldsProperty: async ({ context, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 4, stepName: "checkFieldsProperty" })
+    const check = checkFieldsPropertyExists(context)
+    return goToNextValidationStage(
+      check ? 'checkIsValidFieldName' : 'checkAdditionalFields'
+    )
+  },
+  evaluateTopLevelInsert: async ({ context, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 5, stepName: "evaluateTopLevelInsert" })
+    const check = await evaluateTopLevelPermissionsFn(context, "insert")
+    return endValidation({ success: !!check })
+  }
+}
+
+

package/src/utils/roles/machines/write/C/index.ts

@@ -0,0 +1,20 @@
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+import {
+  checkAdditionalFieldsFn,
+  checkIsValidFieldNameFn,
+} from './validators'
+
+export const STEP_C_STATES: States = {
+  checkAdditionalFields: async ({ context, next, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 1, stepName: "checkAdditionalFields" })
+    const check = checkAdditionalFieldsFn(context)
+    return check ? next('checkIsValidFieldName') : endValidation({ success: false })
+  },
+  checkIsValidFieldName: async ({ context, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "D", step: 2, stepName: "checkIsValidFieldName" })
+    const document = checkIsValidFieldNameFn(context)
+    return endValidation({ success: !!Object.keys(document).length, document })
+  },
+}
+

package/src/utils/roles/machines/write/C/validators.ts

@@ -0,0 +1,24 @@
+import { MachineContext } from "../../interface"
+
+
+export const checkAdditionalFieldsFn = ({ role }: MachineContext) => {
+  return !!Object.keys(role.additional_fields || {}).length
+}
+
+export const checkIsValidFieldNameFn = ({ role, params }: MachineContext) => {
+  const { cursor } = params
+
+  const { fields = {}, additional_fields = {} } = role
+  const rulesOnId = !!(fields["_id"] || additional_fields["_id"])
+  const filteredDocument = Object.entries(cursor).reduce((filteredDocument, [key, value]) => {
+    if (fields![key]) {
+      return role.fields![key].write ? { ...filteredDocument, [key]: value } : filteredDocument
+    }
+    if (additional_fields[key]) {
+      return additional_fields[key]?.write ? { ...filteredDocument, [key]: value } : filteredDocument
+    }
+    return { ...filteredDocument, [key]: value }
+  }, {})
+
+  return (rulesOnId || cursor._id === undefined) ? filteredDocument : { ...filteredDocument, "_id": cursor._id }
+}

package/src/utils/roles/machines/write/index.ts

@@ -0,0 +1,5 @@
+import { STEP_A_STATES } from "./A";
+import { STEP_B_STATES } from "./B";
+import { STEP_C_STATES } from "./C";
+
+export const WRITE_MACHINE = [STEP_A_STATES, STEP_B_STATES, STEP_C_STATES]

package/src/utils/rules-matcher/interface.ts

@@ -0,0 +1,365 @@
+export type CheckTypeOf = (v: any) => boolean
+
+export type CheckOperationObj = {
+  op: keyof Operators
+  value: any
+  opt?: any
+}
+
+export interface RulesMatcherUtils {
+  /**
+   * @param el
+   *
+   * Determines if a given value is a number.
+   * It checks if the value matches a numeric pattern using a regular expression.
+   *
+   * @returns
+   */
+  isNumber: <T>(el: T) => boolean
+  /**
+   * @param val
+   * @param data
+   * @param options
+   *
+   * Processes a single rule against provided data to check its validity.
+   * Returns a boolean indicating whether the rule is valid and a name for the rule.
+   *
+   * @returns
+   */
+  rule: (
+    block: Record<string, any>,
+    keys: Record<string, any>,
+    options?: Record<string, any>
+  ) => {
+    valid: boolean
+    name: string
+  }
+  /**
+   * @param block
+   * @param keys
+   * @param options
+   *
+   * Extracts keys from a rule object.
+   * It recursively traverses through the rule object and extracts keys while handling $and and $or logical operators.
+   *
+   * @returns
+   */
+  getKey: (
+    block: RulesObject<any>,
+    keys: Record<string, any>,
+    options: Record<string, any>
+  ) => Record<string, any>
+  /**
+   * @param v
+   *
+   * Checks if a given value is a Date object.
+   *
+   * @returns
+   */
+  isDate: CheckTypeOf
+  /**
+   * @param v
+   *
+   * Checks if a given value is defined (neither null nor undefined).
+   *
+   * @returns
+   */
+  isDefined: CheckTypeOf
+  /**
+   * @param v
+   *
+   * Checks if a given value is an object (it will return true if pass an Array).
+   *
+   * @returns
+   */
+  isObject: CheckTypeOf
+  /**
+   * @param v
+   *
+   * Checks if a given value is a function.
+   *
+   * @returns
+   */
+  isFunction: CheckTypeOf
+  /**
+   * @param v
+   *
+   * Checks if a given value is a string.
+   *
+   * @returns
+   */
+  isString: CheckTypeOf
+  /**
+   * @param value
+   *
+   * Returns the default comparison operation for a string value.
+   *
+   * @returns
+   */
+  getDefaultStringValue: (value: '$required' | '$exists' | string) => CheckOperationObj
+  /**
+   * @param value
+   *
+   * Determines the type of a given value.
+   *
+   * @returns
+   */
+  getTypeOf: (value: any) => string | null
+  /**
+   * @param value
+   *
+   * Returns the default rule configuration based on the type of the value.
+   *
+   * @returns
+   */
+  getDefaultRule: (value: any) => CheckOperationObj
+  /**
+   * @param value
+   *
+   * Checks if a value is empty.
+   * Handles various data types including null, undefined, functions, strings, arrays, objects, and dates.
+   *
+   * @returns
+   */
+  isEmpty: (value: any) => boolean
+  /**
+   * @param a
+   *
+   * Converts a value into an array if it is not already.
+   *
+   * @returns
+   */
+  forceArray: <T>(value: T) => Array<T>
+  /**
+   * @param path
+   * @param prefix
+   *
+   * Constructs a path with a prefix if provided.
+   * Handles special characters such as '^' and '$'.
+   *
+   * @returns
+   */
+  getPath: (path: string, prefix?: string) => string
+  /**
+   * @param el
+   *
+   * Converts a value into a number.
+   * Handles cases where the value might be a string representation of a number or an array.
+   *
+   * @returns
+   */
+  forceNumber: <T>(value: T) => number
+  /**
+   * @param block
+   * @param data
+   * @param options
+   *
+   * Checks if a given rule is valid against the provided data.
+   *
+   * @returns
+   */
+  checkRule: <T extends Record<string, any>>(
+    block: RulesObject<T>,
+    data: T,
+    options?: Record<string, any>
+  ) => boolean
+  /**
+   * @param rules
+   * @param options
+   *
+   * Extracts keys from a set of rules.
+   *
+   * @returns
+   */
+  getKeys: <T extends Record<string, any>>(
+    rules?: T,
+    options?: Record<string, any>
+  ) => string[] | null
+}
+
+export type OperatorsFunction = (a: any, b: any, opt?: any, data?: any) => boolean
+
+export type Operators = {
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if a value exists or not.
+   * If the user input is not empty, it returns true if the rule value is true, otherwise false.
+   *
+   * @returns
+   */
+  $exists: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if two values are equal.
+   *
+   * @returns
+   */
+  $eq: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if two values are not equal.
+   *
+   * @returns
+   */
+  $ne: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is greater than the rule value after converting them both to numbers.
+   *
+   * @returns
+   */
+  $gt: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is greater than or equal to the rule value.
+   *
+   * @returns
+   */
+  $gte: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is less than the rule value.
+   *
+   * @returns
+   */
+  $lt: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is less than or equal to the rule value.
+   *
+   * @returns
+   */
+  $lte: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Compares the lengths of two strings and checks if the length of the user input string is greater than the rule value.
+   *
+   * @returns
+   */
+  $strGt: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Compares the lengths of two strings and checks if the length of the user input string is greater than or equal to the rule value.
+   *
+   * @returns
+   */
+  $strGte: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Compares the lengths of two strings and checks if the length of the user input string is less than the rule value.
+   *
+   * @returns
+   */
+  $strLt: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Compares the lengths of two strings and checks if the length of the user input string is less than or equal to the rule value.
+   *
+   * @returns
+   */
+  $strLte: OperatorsFunction
+
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is in the array of rule values.
+   * It checks for intersection between the user input array and each rule value array.
+   *
+   * @returns
+   */
+  $in: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if the user input value is not in the array of rule values.
+   * It checks for the absence of intersection between the user input array and each rule value array.
+   *
+   * @returns
+   */
+  $nin: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   *
+   * Checks if all elements in the user input array are present in the array of rule values.
+   * It checks for intersection between each element of the user input array and each rule value array.
+   *
+   * @returns
+   */
+  $all: OperatorsFunction
+  /**
+   * @param a
+   * @param b
+   * @param opt
+   *
+   * Performs a regular expression match on the user input value with the rule value(s).
+   * It supports either a single regular expression or an array of regular expressions.
+   *
+   * @returns
+   */
+  $regex: OperatorsFunction
+}
+
+export enum RulesOperators {
+  $exists = '$exists',
+  $eq = '$eq',
+  $ne = '$ne',
+  $gt = '$gt',
+  $gte = '$gte',
+  $lt = '$lt',
+  $lte = '$lte',
+  $strGt = '$strGt',
+  $strGte = '$strGte',
+  $strLt = '$strLt',
+  $strLte = '$strLte',
+  $in = '$in',
+  $nin = '$nin',
+  $all = '$all',
+  $regex = '$regex'
+}
+
+export type RulesOperatorsInArray<T> = Partial<{
+  [KEY in keyof T]: Partial<{
+    [K in keyof typeof RulesOperators]: T[KEY]
+  }>
+}>
+
+export type RulesValuesType<T> = { '$form.isValid'?: boolean } & T
+
+export enum RulesModes {
+  $and = '$and',
+  $or = '$or'
+}
+
+export type RulesObject<T> =
+  | RulesValuesType<T>
+  | {
+    [K in keyof typeof RulesModes]:
+    | Array<RulesOperatorsInArray<RulesValuesType<T>>>
+    | Array<RulesObject<RulesValuesType<T>>>
+  }
+  | Array<Exclude<RulesOperatorsInArray<RulesValuesType<T>>, undefined>>