@flowerforce/flowerbase 1.7.2 → 1.7.3-beta.1

package/dist/utils/context/index.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateContext = GenerateContext;
+exports.GenerateContextSync = GenerateContextSync;
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
@@ -108,6 +109,34 @@ const shouldFallbackFromVmModules = (error) => {
     const code = error.code;
     return code === 'ERR_VM_MODULES_DISABLED' || code === 'ERR_VM_MODULES_NOT_SUPPORTED';
 };
+const isExportedFunction = (value) => typeof value === 'function';
+const getDefaultExport = (value) => {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    if (!('default' in value))
+        return undefined;
+    const maybeDefault = value.default;
+    return isExportedFunction(maybeDefault) ? maybeDefault : undefined;
+};
+const resolveExport = (ctx) => {
+    var _a, _b, _c, _d, _e;
+    const moduleExports = (_b = (_a = ctx.module) === null || _a === void 0 ? void 0 : _a.exports) !== null && _b !== void 0 ? _b : (_c = ctx.__fb_module) === null || _c === void 0 ? void 0 : _c.exports;
+    if (isExportedFunction(moduleExports))
+        return moduleExports;
+    const contextExports = (_d = ctx.exports) !== null && _d !== void 0 ? _d : ctx.__fb_exports;
+    if (isExportedFunction(contextExports))
+        return contextExports;
+    return (_e = getDefaultExport(moduleExports)) !== null && _e !== void 0 ? _e : getDefaultExport(contextExports);
+};
+const buildVmContext = (contextData) => {
+    var _a, _b;
+    const sandboxModule = { exports: {} };
+    const entryFile = (_b = (_a = require.main) === null || _a === void 0 ? void 0 : _a.filename) !== null && _b !== void 0 ? _b : process.cwd();
+    const customRequire = (0, node_module_1.createRequire)(entryFile);
+    const vmContext = vm_1.default.createContext(Object.assign(Object.assign({}, contextData), { require: customRequire, exports: sandboxModule.exports, module: sandboxModule, __filename,
+        __dirname, __fb_require: customRequire, __fb_filename: __filename, __fb_dirname: __dirname }));
+    return { sandboxModule, entryFile, customRequire, vmContext };
+};
 /**
  * > Used to generate the current context
  * @testable
@@ -126,7 +155,7 @@ function GenerateContext(_a) {
         const functionsQueue = state_1.StateManager.select("functionsQueue");
         const functionToRun = Object.assign({ run_as_system: runAsSystem }, currentFunction);
         const run = () => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a;
             const contextData = (0, helpers_1.generateContextData)({
                 user,
                 services,
@@ -136,32 +165,10 @@ function GenerateContext(_a) {
                 functionName,
                 functionsList,
                 GenerateContext,
+                GenerateContextSync,
                 request
             });
-            const isExportedFunction = (value) => typeof value === 'function';
-            const getDefaultExport = (value) => {
-                if (!value || typeof value !== 'object')
-                    return undefined;
-                if (!('default' in value))
-                    return undefined;
-                const maybeDefault = value.default;
-                return isExportedFunction(maybeDefault) ? maybeDefault : undefined;
-            };
-            const resolveExport = (ctx) => {
-                var _a, _b, _c, _d, _e;
-                const moduleExports = (_b = (_a = ctx.module) === null || _a === void 0 ? void 0 : _a.exports) !== null && _b !== void 0 ? _b : (_c = ctx.__fb_module) === null || _c === void 0 ? void 0 : _c.exports;
-                if (isExportedFunction(moduleExports))
-                    return moduleExports;
-                const contextExports = (_d = ctx.exports) !== null && _d !== void 0 ? _d : ctx.__fb_exports;
-                if (isExportedFunction(contextExports))
-                    return contextExports;
-                return (_e = getDefaultExport(moduleExports)) !== null && _e !== void 0 ? _e : getDefaultExport(contextExports);
-            };
-            const sandboxModule = { exports: {} };
-            const entryFile = (_b = (_a = require.main) === null || _a === void 0 ? void 0 : _a.filename) !== null && _b !== void 0 ? _b : process.cwd();
-            const customRequire = (0, node_module_1.createRequire)(entryFile);
-            const vmContext = vm_1.default.createContext(Object.assign(Object.assign({}, contextData), { require: customRequire, exports: sandboxModule.exports, module: sandboxModule, __filename,
-                __dirname, __fb_require: customRequire, __fb_filename: __filename, __fb_dirname: __dirname }));
+            const { sandboxModule, entryFile, customRequire, vmContext } = buildVmContext(contextData);
             const vmModules = vm_1.default;
             const hasStaticImport = /\bimport\s+/.test(functionToRun.code);
             let usedVmModules = false;
@@ -211,7 +218,7 @@ function GenerateContext(_a) {
                     : functionToRun.code;
                 vm_1.default.runInContext(codeToRun, vmContext);
             }
-            sandboxModule.exports = (_c = resolveExport(vmContext)) !== null && _c !== void 0 ? _c : sandboxModule.exports;
+            sandboxModule.exports = (_a = resolveExport(vmContext)) !== null && _a !== void 0 ? _a : sandboxModule.exports;
             if (deserializeArgs) {
                 return yield sandboxModule.exports(...bson_1.EJSON.deserialize(args));
             }
@@ -221,3 +228,32 @@ function GenerateContext(_a) {
         return res;
     });
 }
+function GenerateContextSync({ args, app, rules, user, currentFunction, functionsList, services, functionName, runAsSystem, deserializeArgs = true, request }) {
+    var _a;
+    if (!currentFunction)
+        return;
+    const functionToRun = Object.assign({ run_as_system: runAsSystem }, currentFunction);
+    const contextData = (0, helpers_1.generateContextData)({
+        user,
+        services,
+        app,
+        rules,
+        currentFunction: functionToRun,
+        functionName,
+        functionsList,
+        GenerateContext,
+        GenerateContextSync,
+        request
+    });
+    const { sandboxModule, vmContext } = buildVmContext(contextData);
+    const codeToRun = functionToRun.code.includes('import ')
+        ? transformImportsToRequire(functionToRun.code)
+        : functionToRun.code;
+    vm_1.default.runInContext(codeToRun, vmContext);
+    sandboxModule.exports = (_a = resolveExport(vmContext)) !== null && _a !== void 0 ? _a : sandboxModule.exports;
+    const fn = sandboxModule.exports;
+    if (deserializeArgs) {
+        return fn(...bson_1.EJSON.deserialize(args));
+    }
+    return fn(...args);
+}

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

@@ -20,6 +20,7 @@ export interface GenerateContextParams {
 type ContextRequest = Pick<FastifyRequest, "ips" | "host" | "hostname" | "url" | "method" | "ip" | "id">;
 export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {
     GenerateContext: (params: GenerateContextParams) => Promise<unknown>;
+    GenerateContextSync: (params: GenerateContextParams) => unknown;
 }
 export {};
 //# sourceMappingURL=interface.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/context/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAEnD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,eAAe,CAAA;IACpB,eAAe,EAAE,QAAQ,CAAA;IACzB,aAAa,EAAE,SAAS,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AACxG,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,eAAe,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACrE"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/context/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAEnD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,eAAe,CAAA;IACpB,eAAe,EAAE,QAAQ,CAAA;IACzB,aAAa,EAAE,SAAS,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AACxG,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,eAAe,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACpE,mBAAmB,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAA;CAChE"}

package/package.json

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

package/src/features/functions/controller.ts

@@ -1,4 +1,4 @@
-import { ObjectId } from 'bson'
+import { EJSON, ObjectId } from 'bson'
 import type { FastifyRequest } from 'fastify'
 import { ChangeStream, Document } from 'mongodb';
 import { services } from '../../services'
@@ -141,7 +141,7 @@ export const functionsController: FunctionController = async (
         return JSON.stringify({ message: result.message, name: result.name })
       }
       res.type('application/json')
-      return JSON.stringify(result)
+      return JSON.stringify(EJSON.serialize(result, { relaxed: false }));
     } catch (error) {
       res.status(400)
       res.type('application/json')

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

@@ -60,7 +60,6 @@ describe('mongodb-atlas findOneAndUpdate', () => {
     const result = await operators.findOneAndUpdate({ _id: id }, { $set: { title: 'New' } })
 
     expect(findOne).toHaveBeenCalled()
-    expect(aggregate).toHaveBeenCalled()
     expect(findOneAndUpdate).toHaveBeenCalledWith(
       { $and: [{ _id: id }] },
       { $set: { title: 'New' } }

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

@@ -0,0 +1,274 @@
+import { ObjectId } from 'mongodb'
+import MongoDbAtlas from '..'
+import { Role, Rules } from '../../../features/rules/interface'
+
+const createAppWithCollection = (collection: Record<string, unknown>) => ({
+  mongo: {
+    client: {
+      db: jest.fn().mockReturnValue({
+        collection: jest.fn().mockReturnValue(collection)
+      })
+    }
+  }
+})
+
+const createRules = (roleOverrides: Partial<Role> = {}): Rules => ({
+  todos: {
+    database: 'db',
+    collection: 'todos',
+    filters: [],
+    roles: [
+      {
+        name: 'owner',
+        apply_when: {},
+        insert: true,
+        delete: true,
+        search: true,
+        read: true,
+        write: true,
+        ...roleOverrides
+      }
+    ]
+  }
+})
+
+describe('mongodb-atlas Realm compatibility', () => {
+  it('allows updateOne upsert when no document matches', async () => {
+    const updateResult = { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 1 }
+    const id = new ObjectId()
+    const findOne = jest.fn().mockResolvedValue(null)
+    const updateOne = jest.fn().mockResolvedValue(updateResult)
+    const collection = {
+      collectionName: 'todos',
+      findOne,
+      updateOne
+    }
+
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    const result = await operators.updateOne(
+      { _id: id },
+      { $set: { label: 'created-by-upsert' } },
+      { upsert: true }
+    )
+
+    expect(result).toEqual(updateResult)
+    expect(updateOne).toHaveBeenCalledWith(
+      { $and: [{ _id: id }] },
+      { $set: { label: 'created-by-upsert' } },
+      { upsert: true }
+    )
+  })
+
+  it('accepts plain documents in updateOne by normalizing them to $set', async () => {
+    const updateResult = { acknowledged: true, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 }
+    const id = new ObjectId()
+    const findOne = jest.fn().mockResolvedValue({ _id: id, label: 'before' })
+    const aggregate = jest.fn().mockReturnValue({
+      toArray: jest.fn().mockResolvedValue([{ _id: id, label: 'after', count: 5 }])
+    })
+    const updateOne = jest.fn().mockResolvedValue(updateResult)
+    const collection = {
+      collectionName: 'todos',
+      findOne,
+      aggregate,
+      updateOne
+    }
+
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    const replacementLikePayload = { label: 'after', count: 5 }
+    const result = await operators.updateOne({ _id: id }, replacementLikePayload)
+
+    expect(result).toEqual(updateResult)
+    expect(updateOne).toHaveBeenCalledWith(
+      { $and: [{ _id: id }] },
+      { $set: replacementLikePayload },
+      undefined
+    )
+  })
+
+  it('supports $inc in updateOne without using invalid aggregate stages', async () => {
+    const id = new ObjectId()
+    const findOne = jest.fn().mockResolvedValue({ _id: id, count: 1 })
+    const aggregate = jest.fn(() => {
+      throw new Error('aggregate should not be used for operator simulation')
+    })
+    const updateOne = jest.fn().mockResolvedValue({
+      acknowledged: true,
+      matchedCount: 1,
+      modifiedCount: 1
+    })
+    const collection = {
+      collectionName: 'todos',
+      findOne,
+      aggregate,
+      updateOne
+    }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    await operators.updateOne({ _id: id }, { $inc: { count: 1 } })
+
+    expect(updateOne).toHaveBeenCalledWith(
+      { $and: [{ _id: id }] },
+      { $inc: { count: 1 } },
+      undefined
+    )
+    expect(aggregate).not.toHaveBeenCalled()
+  })
+
+  it('supports $push in findOneAndUpdate without treating it as a pipeline stage', async () => {
+    const id = new ObjectId()
+    const findOne = jest.fn().mockResolvedValue({ _id: id, tags: ['old'] })
+    const aggregate = jest.fn(() => {
+      throw new Error('aggregate should not be used for operator simulation')
+    })
+    const findOneAndUpdate = jest.fn().mockResolvedValue({ _id: id, tags: ['old', 'new'] })
+    const collection = {
+      collectionName: 'todos',
+      findOne,
+      aggregate,
+      findOneAndUpdate
+    }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    await operators.findOneAndUpdate({ _id: id }, { $push: { tags: 'new' } } as any)
+
+    expect(findOneAndUpdate).toHaveBeenCalledWith(
+      { $and: [{ _id: id }] },
+      { $push: { tags: 'new' } }
+    )
+    expect(aggregate).not.toHaveBeenCalled()
+  })
+
+  it('supports operator updates in updateMany without using invalid aggregate stages', async () => {
+    const id = new ObjectId()
+    const find = jest.fn().mockReturnValue({
+      toArray: jest.fn().mockResolvedValue([{ _id: id, tags: ['old'] }])
+    })
+    const aggregate = jest.fn(() => {
+      throw new Error('aggregate should not be used for operator simulation')
+    })
+    const updateMany = jest.fn().mockResolvedValue({
+      acknowledged: true,
+      matchedCount: 1,
+      modifiedCount: 1
+    })
+    const collection = {
+      collectionName: 'todos',
+      find,
+      aggregate,
+      updateMany
+    }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    await operators.updateMany({ _id: id }, { $push: { tags: 'new' } } as any)
+
+    expect(updateMany).toHaveBeenCalledWith(
+      { $and: [{ _id: id }] },
+      { $push: { tags: 'new' } },
+      undefined
+    )
+    expect(aggregate).not.toHaveBeenCalled()
+  })
+
+  it('treats findOne second argument as options when it matches option keys', async () => {
+    const findOne = jest.fn().mockResolvedValue({ _id: new ObjectId() })
+    const collection = {
+      collectionName: 'todos',
+      findOne
+    }
+    const session = { id: 'tx-1' }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      run_as_system: true
+    }).db('db').collection('todos')
+
+    await operators.findOne({ key: 'value' }, { session } as any)
+
+    expect(findOne).toHaveBeenCalledWith({ key: 'value' }, { session })
+  })
+
+  it('treats find second argument as options when it matches option keys', async () => {
+    const cursor = {
+      toArray: jest.fn().mockResolvedValue([]),
+      sort: jest.fn(),
+      skip: jest.fn(),
+      limit: jest.fn()
+    }
+    const find = jest.fn().mockReturnValue(cursor)
+    const collection = {
+      collectionName: 'todos',
+      find
+    }
+    const session = { id: 'tx-2' }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      run_as_system: true
+    }).db('db').collection('todos')
+
+    operators.find({ active: true }, { session } as any)
+
+    expect(find).toHaveBeenCalledWith({ active: true }, { session })
+  })
+
+  it('returns insertMany insertedIds as an array', async () => {
+    const id0 = new ObjectId()
+    const id1 = new ObjectId()
+    const insertMany = jest.fn().mockResolvedValue({
+      acknowledged: true,
+      insertedCount: 2,
+      insertedIds: { 0: id0, 1: id1 }
+    })
+    const collection = {
+      collectionName: 'todos',
+      insertMany
+    }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      run_as_system: true
+    }).db('db').collection('todos')
+
+    const result = await operators.insertMany([{ a: 1 }, { a: 2 }])
+
+    expect(result.insertedIds).toEqual([id0, id1])
+  })
+
+  it('exposes startSession and delegates to the underlying MongoClient', async () => {
+    const mockSession = { withTransaction: jest.fn() }
+    const startSession = jest.fn().mockReturnValue(mockSession)
+    const app = {
+      mongo: {
+        client: {
+          startSession,
+          db: jest.fn().mockReturnValue({
+            collection: jest.fn().mockReturnValue({
+              collectionName: 'todos'
+            })
+          })
+        }
+      }
+    }
+
+    const service = MongoDbAtlas(app as any, {
+      run_as_system: true
+    })
+    const options = { causalConsistency: true }
+    const session = service.startSession(options as any)
+
+    expect(startSession).toHaveBeenCalledWith(options)
+    expect(session).toBe(mockSession)
+  })
+})