@flowerforce/flowerbase 1.7.5-beta.2 → 1.7.5-beta.4

package/src/features/functions/controller.ts

@@ -54,11 +54,29 @@ const serializeEjson = (value: unknown) =>
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === 'object' && !Array.isArray(value)
 
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
+  if (!isRecord(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+const isCursorLike = (
+  value: unknown
+): value is { toArray: () => Promise<unknown> | unknown } => {
+  if (!value || typeof value !== 'object') return false
+  return typeof (value as { toArray?: unknown }).toArray === 'function'
+}
+
+const normalizeFunctionResult = async (value: unknown) => {
+  if (!isCursorLike(value)) return value
+  return await value.toArray()
+}
+
 type WatchSubscriber = {
   id: string
   user: Record<string, any>
   response: ServerResponse
-  extraFilter?: Document
+  documentFilter?: Document
 }
 
 type SharedWatchStream = {
@@ -74,13 +92,221 @@ type SharedWatchStream = {
 
 const sharedWatchStreams = new Map<string, SharedWatchStream>()
 let watchSubscriberCounter = 0
+const maxSharedWatchStreams = Number(process.env.MAX_SHARED_WATCH_STREAMS || 200)
+const debugWatchStreams = process.env.DEBUG_FUNCTIONS === 'true'
+
+const changeEventRootKeys = new Set([
+  '_id',
+  'operationType',
+  'clusterTime',
+  'txnNumber',
+  'lsid',
+  'ns',
+  'documentKey',
+  'fullDocument',
+  'updateDescription'
+])
+
+const isChangeEventPath = (key: string) => {
+  if (changeEventRootKeys.has(key)) return true
+  return (
+    key.startsWith('ns.') ||
+    key.startsWith('documentKey.') ||
+    key.startsWith('fullDocument.') ||
+    key.startsWith('updateDescription.')
+  )
+}
+
+const isOpaqueChangeEventObjectKey = (key: string) =>
+  key === 'ns' || key === 'documentKey' || key === 'fullDocument' || key === 'updateDescription'
+
+export const mapWatchFilterToChangeStreamMatch = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapWatchFilterToChangeStreamMatch(item))
+  }
+
+  if (!isPlainRecord(value)) return value
+
+  return Object.entries(value).reduce<Record<string, unknown>>((acc, [key, current]) => {
+    if (key.startsWith('$')) {
+      acc[key] = mapWatchFilterToChangeStreamMatch(current)
+      return acc
+    }
+
+    if (isOpaqueChangeEventObjectKey(key)) {
+      acc[key] = current
+      return acc
+    }
+
+    if (isChangeEventPath(key)) {
+      acc[key] = mapWatchFilterToChangeStreamMatch(current)
+      return acc
+    }
+
+    acc[`fullDocument.${key}`] = mapWatchFilterToChangeStreamMatch(current)
+    return acc
+  }, {})
+}
+
+const isLogicalOperator = (key: string) => key === '$and' || key === '$or' || key === '$nor'
+
+export const mapWatchFilterToDocumentQuery = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    const mapped = value
+      .map((item) => mapWatchFilterToDocumentQuery(item))
+      .filter((item) => !(isRecord(item) && Object.keys(item).length === 0))
+    return mapped
+  }
+
+  if (!isPlainRecord(value)) return value
+
+  return Object.entries(value).reduce<Record<string, unknown>>((acc, [key, current]) => {
+    if (key.startsWith('$')) {
+      const mapped = mapWatchFilterToDocumentQuery(current)
+      if (isLogicalOperator(key) && Array.isArray(mapped)) {
+        if (mapped.length > 0) {
+          acc[key] = mapped
+        }
+        return acc
+      }
+      if (typeof mapped !== 'undefined') {
+        acc[key] = mapped
+      }
+      return acc
+    }
+
+    if (key === 'fullDocument') {
+      if (!isPlainRecord(current)) return acc
+      const mapped = mapWatchFilterToDocumentQuery(current)
+      if (isRecord(mapped)) {
+        Object.assign(acc, mapped)
+      }
+      return acc
+    }
+
+    if (key.startsWith('fullDocument.')) {
+      const docKey = key.slice('fullDocument.'.length)
+      if (!docKey) return acc
+      acc[docKey] = mapWatchFilterToDocumentQuery(current)
+      return acc
+    }
+
+    if (isChangeEventPath(key)) {
+      return acc
+    }
+
+    acc[key] = mapWatchFilterToDocumentQuery(current)
+    return acc
+  }, {})
+}
+
+const toStableValue = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map((item) => toStableValue(item))
+  }
+  if (!isPlainRecord(value)) return value
+
+  const sortedEntries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+  return sortedEntries.reduce<Record<string, unknown>>((acc, [key, current]) => {
+    acc[key] = toStableValue(current)
+    return acc
+  }, {})
+}
+
+const stableSerialize = (value: unknown) => {
+  const serialized = EJSON.serialize(value, { relaxed: false })
+  return JSON.stringify(toStableValue(serialized))
+}
+
+const getWatchPermissionContext = (user: Record<string, any>) => ({
+  role: user.role,
+  roles: user.roles,
+  data: user.data,
+  custom_data: user.custom_data,
+  user_data: user.user_data
+})
+
+const resolveWatchStream = (
+  database: string,
+  collection: string,
+  watchArgs: Record<string, unknown>,
+  user: Record<string, any>
+) => {
+  const keys = Object.keys(watchArgs)
+  const hasOnlyAllowedKeys = keys.every((key) => key === 'filter' || key === 'ids')
+  if (!hasOnlyAllowedKeys) {
+    throw new Error('watch options support only "filter" or "ids"')
+  }
+
+  const extraFilter = parseWatchFilter(watchArgs)
+  const ids = watchArgs.ids
+  if (extraFilter && typeof ids !== 'undefined') {
+    throw new Error('watch options cannot include both "ids" and "filter"')
+  }
+
+  const pipeline: Document[] = []
+  if (extraFilter) {
+    pipeline.push({ $match: mapWatchFilterToChangeStreamMatch(extraFilter) as Document })
+  }
+
+  if (typeof ids !== 'undefined') {
+    if (!Array.isArray(ids)) {
+      throw new Error('watch ids must be an array')
+    }
+    pipeline.push({
+      $match: {
+        $or: [
+          { 'documentKey._id': { $in: ids } },
+          { 'fullDocument._id': { $in: ids } }
+        ]
+      }
+    })
+  }
+
+  const options = { fullDocument: 'updateLookup' }
+  const streamKey = stableSerialize({
+    database,
+    collection,
+    pipeline,
+    options,
+    permissionContext: getWatchPermissionContext(user)
+  })
+
+  return { extraFilter, options, pipeline, streamKey }
+}
+
+const getWatchStats = () => {
+  let subscribers = 0
+  for (const hub of sharedWatchStreams.values()) {
+    subscribers += hub.subscribers.size
+  }
+  return {
+    hubs: sharedWatchStreams.size,
+    subscribers
+  }
+}
+
+const logWatchStats = (
+  event: string,
+  details?: Record<string, unknown>
+) => {
+  if (!debugWatchStreams) return
+  const stats = getWatchStats()
+  console.log('[watch-pool]', event, {
+    hubs: stats.hubs,
+    subscribers: stats.subscribers,
+    ...details
+  })
+}
 
 const parseWatchFilter = (args: unknown): Document | undefined => {
   if (!isRecord(args)) return undefined
-  const candidate =
-    (isRecord(args.filter) ? args.filter : undefined) ??
-    (isRecord(args.query) ? args.query : undefined)
-  return candidate ? (candidate as Document) : undefined
+  const candidate = isRecord(args.filter) ? args.filter : undefined
+  if (!candidate) return undefined
+  if ('$match' in candidate) {
+    throw new Error('watch filter must be a query object, not a $match stage')
+  }
+  return candidate as Document
 }
 
 const isReadableDocumentResult = (value: unknown) =>
@@ -177,12 +403,13 @@ export const functionsController: FunctionController = async (
         functionsList,
         services
       })
-      if (isReturnedError(result)) {
+      const normalizedResult = await normalizeFunctionResult(result)
+      if (isReturnedError(normalizedResult)) {
         res.type('application/json')
-        return JSON.stringify({ message: result.message, name: result.name })
+        return JSON.stringify({ message: normalizedResult.message, name: normalizedResult.name })
       }
       res.type('application/json')
-      return serializeEjson(result)
+      return serializeEjson(normalizedResult)
     } catch (error) {
       res.status(400)
       res.type('application/json')
@@ -211,7 +438,9 @@ export const functionsController: FunctionController = async (
     )
     const config = EJSON.deserialize(decodedConfig) as Base64Function
 
-    const [{ database, collection, ...watchArgs }] = config.arguments
+    const [{ database, collection, ...watchArgsInput }] = config.arguments
+    const watchArgs = isRecord(watchArgsInput) ? watchArgsInput : {}
+    console.log("🚀 ~ functionsController ~ watchArgs:", watchArgs)
 
     const headers = {
       'Content-Type': 'text/event-stream',
@@ -222,21 +451,33 @@ export const functionsController: FunctionController = async (
       "access-control-allow-headers": "X-Stitch-Location, X-Baas-Location, Location",
     };
 
-    res.raw.writeHead(200, headers)
-    res.raw.flushHeaders();
-
-    const streamKey = `${database}::${collection}`
     const subscriberId = `${Date.now()}-${watchSubscriberCounter++}`
-    const extraFilter = parseWatchFilter(watchArgs)
-    const mongoClient = app.mongo.client as unknown as {
-      db: (name: string) => { collection: (name: string) => { watch: (...args: any[]) => any } }
-    }
+    const {
+      streamKey,
+      extraFilter,
+      options: watchOptions,
+      pipeline: watchPipeline
+    } = resolveWatchStream(database, collection, watchArgs, user)
 
     let hub = sharedWatchStreams.get(streamKey)
     if (!hub) {
-      const stream = mongoClient.db(database).collection(collection).watch([], {
-        fullDocument: 'whenAvailable'
+      if (sharedWatchStreams.size >= maxSharedWatchStreams) {
+        res.status(503)
+        return JSON.stringify({
+          error: JSON.stringify({
+            message: 'Watch stream limit reached',
+            name: 'WatchStreamLimitError'
+          }),
+          error_code: 'WatchStreamLimitError'
+        })
+      }
+      const stream = services['mongodb-atlas'](app, {
+        user,
+        rules
       })
+        .db(database)
+        .collection(collection)
+        .watch(watchPipeline, watchOptions)
       hub = {
         database,
         collection,
@@ -244,8 +485,14 @@ export const functionsController: FunctionController = async (
         subscribers: new Map<string, WatchSubscriber>()
       }
       sharedWatchStreams.set(streamKey, hub)
+      logWatchStats('hub-created', { streamKey, database, collection })
+    } else {
+      logWatchStats('hub-reused', { streamKey, database, collection })
     }
 
+    res.raw.writeHead(200, headers)
+    res.raw.flushHeaders();
+
     const ensureHubListeners = (currentHub: SharedWatchStream) => {
       if ((currentHub as SharedWatchStream & { listenersBound?: boolean }).listenersBound) {
         return
@@ -255,6 +502,7 @@ export const functionsController: FunctionController = async (
         currentHub.stream.off('change', onHubChange)
         currentHub.stream.off('error', onHubError)
         sharedWatchStreams.delete(streamKey)
+        logWatchStats('hub-closed', { streamKey, database, collection })
         try {
           await currentHub.stream.close()
         } catch {
@@ -263,11 +511,13 @@ export const functionsController: FunctionController = async (
       }
 
       const onHubChange = async (change: Document) => {
+        console.log("🚀 ~ onHubChange ~ change:", change)
         const subscribers = Array.from(currentHub.subscribers.values())
         await Promise.all(subscribers.map(async (subscriber) => {
           const subscriberRes = subscriber.response
           if (subscriberRes.writableEnded || subscriberRes.destroyed) {
             currentHub.subscribers.delete(subscriber.id)
+            logWatchStats('subscriber-auto-removed', { streamKey, subscriberId: subscriber.id })
             return
           }
 
@@ -276,8 +526,8 @@ export const functionsController: FunctionController = async (
             (change as { fullDocument?: { _id?: unknown } })?.fullDocument?._id
           if (typeof docId === 'undefined') return
 
-          const readQuery = subscriber.extraFilter
-            ? ({ $and: [subscriber.extraFilter, { _id: docId }] } as Document)
+          const readQuery = subscriber.documentFilter
+            ? ({ $and: [subscriber.documentFilter, { _id: docId }] } as Document)
             : ({ _id: docId } as Document)
 
           try {
@@ -288,6 +538,7 @@ export const functionsController: FunctionController = async (
               .db(currentHub.database)
               .collection(currentHub.collection)
               .findOne(readQuery)
+            console.log("🚀 ~ onHubChange ~ readableDoc:", readableDoc)
 
             if (!isReadableDocumentResult(readableDoc)) return
             subscriberRes.write(`data: ${serializeEjson(change)}\n\n`)
@@ -295,6 +546,7 @@ export const functionsController: FunctionController = async (
             subscriberRes.write(`event: error\ndata: ${formatFunctionExecutionError(error)}\n\n`)
             subscriberRes.end()
             currentHub.subscribers.delete(subscriber.id)
+            logWatchStats('subscriber-error-removed', { streamKey, subscriberId: subscriber.id })
           }
         }))
 
@@ -326,17 +578,25 @@ export const functionsController: FunctionController = async (
       id: subscriberId,
       user,
       response: res.raw,
-      extraFilter
+      documentFilter: (() => {
+        if (!extraFilter) return undefined
+        const mapped = mapWatchFilterToDocumentQuery(extraFilter)
+        if (!isRecord(mapped) || Object.keys(mapped).length === 0) return undefined
+        return mapped as Document
+      })()
     }
     hub.subscribers.set(subscriberId, subscriber)
+    logWatchStats('subscriber-added', { streamKey, subscriberId })
 
     req.raw.on('close', () => {
       const currentHub = sharedWatchStreams.get(streamKey)
       if (!currentHub) return
       currentHub.subscribers.delete(subscriberId)
+      logWatchStats('subscriber-closed', { streamKey, subscriberId })
       if (!currentHub.subscribers.size) {
         void currentHub.stream.close()
         sharedWatchStreams.delete(streamKey)
+        logWatchStats('hub-empty-closed', { streamKey })
       }
     })
   })

package/src/features/triggers/__tests__/index.test.ts

@@ -21,8 +21,8 @@ describe('activateTriggers', () => {
 
   it('skips triggers marked as disabled', async () => {
     const functionsList = {
-      runEnabled: jest.fn(),
-      runDisabled: jest.fn()
+      runEnabled: { code: 'exports = async () => {}' },
+      runDisabled: { code: 'exports = async () => {}' }
     }
 
     await activateTriggers({

package/src/services/mongodb-atlas/__tests__/findOneAndUpdate.test.ts

@@ -171,7 +171,7 @@ describe('mongodb-atlas findOneAndUpdate', () => {
 
     const app = createAppWithCollection(collection)
     const operators = MongoDbAtlas(app as any, {
-      rules: createRules({ insert: false }),
+      rules: createRules({ write: undefined, insert: false }),
       user: { id: 'user-1' }
     })
       .db('db')

package/src/services/mongodb-atlas/utils.ts

@@ -323,9 +323,10 @@ export function getHiddenFieldsFromRulesConfig(rulesConfig?: { roles?: Role[] })
 function collectHiddenFieldsFromRoles(roles: Role[] = []) {
   const hiddenFields = new Set<string>()
 
-  const collectFromFields = (
-    fields?: Role['fields'] | Role['additional_fields']
-  ) => {
+  const isFieldPermissionObject = (value: unknown): value is { read?: unknown; write?: unknown } =>
+    !!value && typeof value === 'object' && ('read' in value || 'write' in value)
+
+  const collectFromFields = (fields?: Role['fields']) => {
     if (!fields) return
     Object.entries(fields).forEach(([fieldName, permissions]) => {
       const canRead = Boolean(permissions?.read || permissions?.write)
@@ -335,9 +336,23 @@ function collectHiddenFieldsFromRoles(roles: Role[] = []) {
     })
   }
 
+  const collectFromAdditionalFields = (fields?: Role['additional_fields']) => {
+    if (!fields || typeof fields !== 'object') return
+    // Global additional_fields permissions (read/write) apply to unknown fields and cannot be mapped.
+    if (isFieldPermissionObject(fields)) return
+
+    Object.entries(fields).forEach(([fieldName, permissions]) => {
+      if (!isFieldPermissionObject(permissions)) return
+      const canRead = Boolean(permissions.read || permissions.write)
+      if (!canRead) {
+        hiddenFields.add(fieldName)
+      }
+    })
+  }
+
   roles.forEach((role) => {
     collectFromFields(role.fields)
-    collectFromFields(role.additional_fields)
+    collectFromAdditionalFields(role.additional_fields)
   })
 
   return Array.from(hiddenFields)

package/src/utils/__tests__/STEP_A_STATES.test.ts

@@ -1,8 +1,13 @@
+import { evaluateTopLevelPermissionsFn } from '../roles/machines/commonValidators'
 import { MachineContext } from '../roles/machines/interface'
 import { STEP_A_STATES } from '../roles/machines/read/A'
 import * as Utils from '../roles/machines/utils'
 const { evaluateSearch, checkSearchRequest } = STEP_A_STATES
 
+jest.mock('../roles/machines/commonValidators', () => ({
+  evaluateTopLevelPermissionsFn: jest.fn()
+}))
+
 const endValidation = jest.fn()
 const goToNextValidationStage = jest.fn()
 const next = jest.fn()
@@ -57,16 +62,33 @@ describe('STEP_A_STATES', () => {
     })
     expect(goToNextValidationStage).toHaveBeenCalled()
   })
-  it('evaluateSearch should end a failed validation ', () => {
+  it('evaluateSearch should go to next validation stage when search is allowed', async () => {
+    (evaluateTopLevelPermissionsFn as jest.Mock).mockResolvedValueOnce(true)
+    const mockContext = {
+      role: {
+        name: 'test'
+      }
+    } as MachineContext
+    await evaluateSearch({
+      endValidation,
+      context: mockContext,
+      goToNextValidationStage,
+      next,
+      initialStep: null
+    })
+    expect(goToNextValidationStage).toHaveBeenCalled()
+  })
+  it('evaluateSearch should end a failed validation when search is denied', async () => {
     const mockedLogInfo = jest
       .spyOn(Utils, 'logMachineInfo')
       .mockImplementation(() => 'Mocked Value')
+      ; (evaluateTopLevelPermissionsFn as jest.Mock).mockResolvedValueOnce(false)
     const mockContext = {
       role: {
         name: 'test'
       }
     } as MachineContext
-    evaluateSearch({
+    await evaluateSearch({
       endValidation,
       context: mockContext,
       goToNextValidationStage,

package/src/utils/__tests__/STEP_C_STATES.test.ts

@@ -22,7 +22,7 @@ describe('STEP_C_STATES', () => {
   beforeEach(() => {
     jest.clearAllMocks()
   })
-  it('evaluateTopLevelRead should go to evaluateTopLevelWrite if evaluateTopLevelReadFn returns false ', async () => {
+  it('evaluateTopLevelRead should pass readCheck=false to evaluateTopLevelWrite', async () => {
     const mockedLogInfo = jest
       .spyOn(Utils, 'logMachineInfo')
       .mockImplementation(() => 'Mocked Value')
@@ -35,7 +35,7 @@ describe('STEP_C_STATES', () => {
       next,
       initialStep: null
     })
-    expect(next).toHaveBeenCalledWith('evaluateTopLevelWrite', { check: false })
+    expect(next).toHaveBeenCalledWith('evaluateTopLevelWrite', { readCheck: false })
     expect(mockedLogInfo).toHaveBeenCalledWith({
       enabled: mockContext.enableLog,
       machine: 'C',
@@ -44,7 +44,7 @@ describe('STEP_C_STATES', () => {
     })
     mockedLogInfo.mockRestore()
   })
-  it('evaluateTopLevelRead should go to evaluateTopLevelWrite if evaluateTopLevelReadFn returns undefined ', async () => {
+  it('evaluateTopLevelRead should pass readCheck=undefined to evaluateTopLevelWrite', async () => {
     (evaluateTopLevelReadFn as jest.Mock).mockReturnValueOnce(undefined)
     const mockContext = {} as MachineContext
     await evaluateTopLevelRead({
@@ -54,9 +54,9 @@ describe('STEP_C_STATES', () => {
       next,
       initialStep: null
     })
-    expect(next).toHaveBeenCalledWith('evaluateTopLevelWrite', { check: undefined })
+    expect(next).toHaveBeenCalledWith('evaluateTopLevelWrite', { readCheck: undefined })
   })
-  it('evaluateTopLevelRead should endValidation validation if evaluateTopLevelReadFn returns true ', async () => {
+  it('evaluateTopLevelRead should pass readCheck=true to evaluateTopLevelWrite', async () => {
     (evaluateTopLevelReadFn as jest.Mock).mockReturnValueOnce(true)
     const mockContext = {} as MachineContext
     await evaluateTopLevelRead({
@@ -66,13 +66,12 @@ describe('STEP_C_STATES', () => {
       next,
       initialStep: null
     })
-    expect(endValidation).toHaveBeenCalledWith({ success: true })
+    expect(next).toHaveBeenCalledWith('evaluateTopLevelWrite', { readCheck: true })
   })
-  it('checkFieldsProperty should go to next validation stage if checkFieldsPropertyExists returns true with initialStep checkIsValidFieldName', async () => {
+  it('checkFieldsProperty should go to next validation stage with initialStep checkIsValidFieldName', async () => {
     const mockedLogInfo = jest
       .spyOn(Utils, 'logMachineInfo')
       .mockImplementation(() => 'Mocked Value')
-    ;(checkFieldsPropertyExists as jest.Mock).mockReturnValue(true)
     const mockContext = {} as MachineContext
     await checkFieldsProperty({
       endValidation,
@@ -90,24 +89,13 @@ describe('STEP_C_STATES', () => {
     })
     mockedLogInfo.mockRestore()
   })
-  it('checkFieldsProperty should go to next validation stage if checkFieldsPropertyExists returns fslse with initialStep checkAdditionalFields', async () => {
-    (checkFieldsPropertyExists as jest.Mock).mockReturnValue(false)
-    const mockContext = {} as MachineContext
-    await checkFieldsProperty({
-      endValidation,
-      context: mockContext,
-      goToNextValidationStage,
-      next,
-      initialStep: null
-    })
-    expect(goToNextValidationStage).toHaveBeenCalledWith('checkAdditionalFields')
-  })
-  it('evaluateTopLevelWrite should end a success validation if evaluateTopLevelWriteFn returns true', async () => {
+  it('evaluateTopLevelWrite should end a success validation when read is true', async () => {
     const mockedLogInfo = jest
       .spyOn(Utils, 'logMachineInfo')
       .mockImplementation(() => 'Mocked Value')
-    ;(evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(true)
-    const mockContext = {} as MachineContext
+    ;(evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(false)
+    ;(checkFieldsPropertyExists as jest.Mock).mockReturnValue(false)
+    const mockContext = { prevParams: { readCheck: true } } as unknown as MachineContext
     await evaluateTopLevelWrite({
       endValidation,
       context: mockContext,
@@ -124,11 +112,23 @@ describe('STEP_C_STATES', () => {
     })
     mockedLogInfo.mockRestore()
   })
-  it('evaluateTopLevelWrite should end a failed validation if evaluateTopLevelWriteFn returns false and prevParams.check is false', async () => {
+  it('evaluateTopLevelWrite should end a success validation when read is false and write is true', async () => {
+    ;(evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(true)
+    const mockContext = { prevParams: { readCheck: false } } as unknown as MachineContext
+    await evaluateTopLevelWrite({
+      endValidation,
+      context: mockContext,
+      goToNextValidationStage,
+      next,
+      initialStep: null
+    })
+    expect(endValidation).toHaveBeenCalledWith({ success: true })
+  })
+  it('evaluateTopLevelWrite should end a failed validation when read is false and write is not true', async () => {
     (evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(false)
     const mockContext = {
       prevParams: {
-        check: false
+        readCheck: false
       }
     } as unknown as MachineContext
     await evaluateTopLevelWrite({
@@ -140,11 +140,28 @@ describe('STEP_C_STATES', () => {
     })
     expect(endValidation).toHaveBeenCalledWith({ success: false })
   })
-  it('evaluateTopLevelWrite should go to next step checkFieldsProperty if evaluateTopLevelWriteFn returns false and prevParams.check is not false ', async () => {
+  it('evaluateTopLevelWrite should end a success validation when read is undefined and write is true', async () => {
+    ;(evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(true)
+    const mockContext = {
+      prevParams: {
+        readCheck: undefined
+      }
+    } as unknown as MachineContext
+    await evaluateTopLevelWrite({
+      endValidation,
+      context: mockContext,
+      goToNextValidationStage,
+      next,
+      initialStep: null
+    })
+    expect(endValidation).toHaveBeenCalledWith({ success: true })
+  })
+  it('evaluateTopLevelWrite should go to checkFieldsProperty when read and write are undefined/false but fields exist', async () => {
     (evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(false)
+    ;(checkFieldsPropertyExists as jest.Mock).mockReturnValue(true)
     const mockContext = {
       prevParams: {
-        check: true
+        readCheck: undefined
       }
     } as unknown as MachineContext
     await evaluateTopLevelWrite({
@@ -156,4 +173,21 @@ describe('STEP_C_STATES', () => {
     })
     expect(next).toHaveBeenCalledWith('checkFieldsProperty')
   })
+  it('evaluateTopLevelWrite should end a failed validation when read and write are undefined/false and no field rules exist', async () => {
+    ;(evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(undefined)
+    ;(checkFieldsPropertyExists as jest.Mock).mockReturnValue(false)
+    const mockContext = {
+      prevParams: {
+        readCheck: undefined
+      }
+    } as unknown as MachineContext
+    await evaluateTopLevelWrite({
+      endValidation,
+      context: mockContext,
+      goToNextValidationStage,
+      next,
+      initialStep: null
+    })
+    expect(endValidation).toHaveBeenCalledWith({ success: false })
+  })
 })