@flowerforce/flowerbase 1.9.1-beta.0 → 1.10.1-beta.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 1.10.0 (2026-05-28)
+
+
+### 🚀 Features
+
+- enhance rule evaluation and testing for scalar equality with array ([#71](https://github.com/flowerforce/flowerbase/pull/71))
+
 ## 1.9.0 (2026-05-06)
 
 

package/dist/utils/context/helpers.d.ts

@@ -1,6 +1,14 @@
 import { mongodb } from '@fastify/mongodb';
-import { Arguments } from '../../auth/dtos';
+import { Arguments, User } from '../../auth/dtos';
 import { GenerateContextDataParams } from './interface';
+/** Realm-compatible system user for run_as_system execution with no authenticated caller. */
+export declare const REALM_SYSTEM_USER: {
+    readonly type: "system";
+    readonly data: {};
+    readonly custom_data: {};
+    readonly identities: readonly [];
+};
+export declare const contextUserForRun: (user: User, runAsSystem: boolean) => User;
 type JwtUtils = {
     encode: (signingMethod: string, payload: unknown, secret: string | Buffer, customHeaderFields?: Record<string, unknown>) => string;
     decode: (jwtString: string, key: string | Buffer, returnHeader?: boolean, acceptedSigningMethods?: string[]) => unknown;
@@ -24,7 +32,6 @@ export declare const generateContextData: ({ user, services, app, rules, current
         deserialize: (ejson: mongodb.BSON.Document, options?: mongodb.BSON.EJSONOptions) => any;
     };
     Buffer: BufferConstructor;
-    fetch: typeof fetch;
     utils: {
         jwt: JwtUtils;
     };
@@ -47,6 +54,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
             action: string;
         };
         user: unknown;
+        runningAsSystem: () => boolean;
         environment: {
             tag: string | undefined;
         };

package/dist/utils/context/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;;uBA6DP,SAAS;yBAGP,SAAS;;;;;;;;;;;0BAoBmB,MAAM,GAAG,SAAS;2BACV,MAAM,GAAG,SAAS;;;;;;;;;uBAS1D,MAAM;;;;;;+BA7DU,MAAM,OAAO,QAAQ;;;;sCA1HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsGT,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BA0FF,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAkBrE,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,6FAA6F;AAC7F,eAAO,MAAM,iBAAiB;;;;;CAKpB,CAAA;AAKV,eAAO,MAAM,iBAAiB,GAAI,MAAM,IAAI,EAAE,aAAa,OAAO,KAAG,IACR,CAAA;AAE7D,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;0BAoBmB,MAAM,GAAG,SAAS;2BACV,MAAM,GAAG,SAAS;;;;;;;;;;uBAU1D,MAAM;;;;;;+BA7DU,MAAM,OAAO,QAAQ;;;;sCAjJtD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAkHM,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAlHtB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkHM,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAlHtB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkHM,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAqGA,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAkBrE,CAAA"}

package/dist/utils/context/helpers.js

@@ -33,10 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateContextData = void 0;
+exports.generateContextData = exports.contextUserForRun = exports.REALM_SYSTEM_USER = void 0;
 const mongodb_1 = require("@fastify/mongodb");
 const bson_1 = require("bson");
 const jwt = __importStar(require("jsonwebtoken"));
+/** Realm-compatible system user for run_as_system execution with no authenticated caller. */
+exports.REALM_SYSTEM_USER = {
+    type: 'system',
+    data: {},
+    custom_data: {},
+    identities: []
+};
+const isEmptyUser = (user) => user != null && typeof user === 'object' && !Array.isArray(user) && Object.keys(user).length === 0;
+const contextUserForRun = (user, runAsSystem) => runAsSystem && isEmptyUser(user) ? exports.REALM_SYSTEM_USER : user;
+exports.contextUserForRun = contextUserForRun;
 const normalizePayload = (payload) => {
     if (typeof payload !== 'string')
         return payload;
@@ -150,7 +160,6 @@ const generateContextData = ({ user, services, app, rules, currentFunction, func
         BSON,
         EJSON: bson_1.EJSON,
         Buffer,
-        fetch,
         utils,
         console: {
             log: (...args) => {
@@ -180,6 +189,7 @@ const generateContextData = ({ user, services, app, rules, currentFunction, func
                 action: ''
             },
             user,
+            runningAsSystem: () => Boolean(currentFunction.run_as_system),
             environment: {
                 tag: process.env.NODE_ENV
             },

package/dist/utils/context/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/context/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA8RnD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACP,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CA2G1C;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CA0BjC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/context/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA8RnD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACP,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CA4G1C;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CA2BjC"}

package/dist/utils/context/index.js

@@ -238,10 +238,11 @@ function GenerateContext(_a) {
         const functionsQueue = state_1.StateManager.select("functionsQueue");
         const effectiveRunAsSystem = Boolean(runAsSystem || currentFunction.run_as_system);
         const functionToRun = Object.assign(Object.assign({}, currentFunction), { run_as_system: effectiveRunAsSystem });
+        const contextUser = (0, helpers_1.contextUserForRun)(user, effectiveRunAsSystem);
         const run = () => __awaiter(this, void 0, void 0, function* () {
             var _a;
             const contextData = (0, helpers_1.generateContextData)({
-                user,
+                user: contextUser,
                 services,
                 app,
                 rules,
@@ -315,8 +316,9 @@ function GenerateContextSync({ args, app, rules, user, currentFunction, function
         return;
     const effectiveRunAsSystem = Boolean(runAsSystem || currentFunction.run_as_system);
     const functionToRun = Object.assign(Object.assign({}, currentFunction), { run_as_system: effectiveRunAsSystem });
+    const contextUser = (0, helpers_1.contextUserForRun)(user, effectiveRunAsSystem);
     const contextData = (0, helpers_1.generateContextData)({
-        user,
+        user: contextUser,
         services,
         app,
         rules,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase",
-  "version": "1.9.1-beta.0",
+  "version": "1.10.1-beta.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -157,25 +157,4 @@ describe('context.functions.execute compatibility', () => {
     expect(result).toEqual({ address: 'rome', total: 10 })
     fs.rmSync(tempDir, { recursive: true, force: true })
   })
-
-  it('exposes native fetch in the sandbox global scope', () => {
-    const functionsList = {
-      caller: {
-        code: 'module.exports = function() { return fetch === globalThis.fetch && typeof fetch === "function" }'
-      }
-    } as Functions
-
-    const result = GenerateContextSync({
-      args: [],
-      app: {} as any,
-      rules: {} as any,
-      user: {} as any,
-      currentFunction: functionsList.caller,
-      functionsList,
-      services: mockServices,
-      functionName: 'caller'
-    })
-
-    expect(result).toBe(true)
-  })
 })

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

@@ -4,7 +4,7 @@ import { User } from '../../auth/dtos'
 import { Functions } from '../../features/functions/interface'
 import { Rules } from '../../features/rules/interface'
 import { services } from '../../services'
-import { generateContextData } from '../context/helpers'
+import { contextUserForRun, generateContextData, REALM_SYSTEM_USER } from '../context/helpers'
 
 const originalEnv = process.env
 
@@ -47,7 +47,7 @@ describe('generateContextData', () => {
 
   it('should return an object with context configuration', async () => {
     const mockApp = Fastify()
-    const { context, console: contextConsole, BSON, fetch } = generateContextData({
+    const { context, console: contextConsole, BSON } = generateContextData({
       services,
       app: mockApp,
       functionsList: mockFunctions,
@@ -66,8 +66,6 @@ describe('generateContextData', () => {
 
     expect(context.user).toEqual(mockUser)
 
-    expect(fetch).toBe(global.fetch)
-
     const mockedLog = jest.spyOn(console, 'log').mockImplementation(() => { })
     contextConsole.log('Test', 'generateContextData')
     expect(mockedLog).toHaveBeenCalledWith('Test', 'generateContextData')
@@ -115,4 +113,49 @@ describe('generateContextData', () => {
     const binaryObject = Binary.fromBase64Binary(base64, 0)
     expect(binaryObject).toBeInstanceOf(BSON.Binary)
   })
+
+  it('exposes Realm system user and runningAsSystem when run_as_system is enabled', () => {
+    const mockApp = Fastify()
+    const systemFunction = { ...currentFunction, run_as_system: true }
+    const { context } = generateContextData({
+      services,
+      app: mockApp,
+      functionsList: mockFunctions,
+      currentFunction: systemFunction,
+      GenerateContext: GenerateContextMock,
+      GenerateContextSync: GenerateContextSyncMock,
+      user: REALM_SYSTEM_USER,
+      rules: mockRules
+    })
+
+    expect(context.user).toEqual(REALM_SYSTEM_USER)
+    expect(context.runningAsSystem()).toBe(true)
+  })
+
+  it('runningAsSystem is false for regular function execution', () => {
+    const mockApp = Fastify()
+    const { context } = generateContextData({
+      services,
+      app: mockApp,
+      functionsList: mockFunctions,
+      currentFunction,
+      GenerateContext: GenerateContextMock,
+      GenerateContextSync: GenerateContextSyncMock,
+      user: { id: 'user-1', type: 'normal', data: {}, custom_data: {}, identities: [] },
+      rules: mockRules
+    })
+
+    expect(context.runningAsSystem()).toBe(false)
+  })
+})
+
+describe('contextUserForRun', () => {
+  it('returns Realm system user for empty user with run_as_system', () => {
+    expect(contextUserForRun({}, true)).toEqual(REALM_SYSTEM_USER)
+  })
+
+  it('returns the user unchanged when not running as system', () => {
+    const user = { id: 'user-1' }
+    expect(contextUserForRun(user, false)).toBe(user)
+  })
 })

package/src/utils/context/helpers.ts

@@ -1,10 +1,24 @@
 import { mongodb } from '@fastify/mongodb'
 import { EJSON } from 'bson'
 import * as jwt from 'jsonwebtoken'
-import { Arguments } from '../../auth/dtos'
+import { Arguments, User } from '../../auth/dtos'
 import { Function } from '../../features/functions/interface'
 import { GenerateContextDataParams } from './interface'
 
+/** Realm-compatible system user for run_as_system execution with no authenticated caller. */
+export const REALM_SYSTEM_USER = {
+  type: 'system',
+  data: {},
+  custom_data: {},
+  identities: []
+} as const
+
+const isEmptyUser = (user: User) =>
+  user != null && typeof user === 'object' && !Array.isArray(user) && Object.keys(user).length === 0
+
+export const contextUserForRun = (user: User, runAsSystem: boolean): User =>
+  runAsSystem && isEmptyUser(user) ? REALM_SYSTEM_USER : user
+
 type JwtUtils = {
   encode: (
     signingMethod: string,
@@ -176,7 +190,6 @@ export const generateContextData = ({
     BSON,
     EJSON,
     Buffer,
-    fetch,
     utils,
     console: {
       log: (...args: Arguments) => {
@@ -208,6 +221,7 @@ export const generateContextData = ({
         action: ''
       },
       user,
+      runningAsSystem: () => Boolean(currentFunction.run_as_system),
       environment: {
         tag: process.env.NODE_ENV
       },

package/src/utils/context/index.ts

@@ -6,7 +6,7 @@ import vm from 'vm'
 import { EJSON } from 'bson'
 import { StateManager } from '../../state'
 import { Function as AppFunction } from '../../features/functions/interface'
-import { generateContextData } from './helpers'
+import { contextUserForRun, generateContextData } from './helpers'
 import { GenerateContextParams } from './interface'
 
 const dynamicImport = new Function('specifier', 'return import(specifier)') as (
@@ -323,11 +323,12 @@ export async function GenerateContext({
   const functionsQueue = StateManager.select("functionsQueue")
   const effectiveRunAsSystem = Boolean(runAsSystem || currentFunction.run_as_system)
   const functionToRun = { ...currentFunction, run_as_system: effectiveRunAsSystem }
+  const contextUser = contextUserForRun(user, effectiveRunAsSystem)
 
   const run = async () => {
 
     const contextData = generateContextData({
-      user,
+      user: contextUser,
       services,
       app,
       rules,
@@ -443,8 +444,9 @@ export function GenerateContextSync({
 
   const effectiveRunAsSystem = Boolean(runAsSystem || currentFunction.run_as_system)
   const functionToRun = { ...currentFunction, run_as_system: effectiveRunAsSystem }
+  const contextUser = contextUserForRun(user, effectiveRunAsSystem)
   const contextData = generateContextData({
-    user,
+    user: contextUser,
     services,
     app,
     rules,