@flowerforce/flowerbase 1.5.1-beta.3 → 1.6.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 1.6.0 (2026-01-28)
+
+
+### 🚀 Features
+
+- added cli run function ([fb2e418](https://github.com/flowerforce/flowerbase/commit/fb2e418))
+
+
+### 🩹 Fixes
+
+- trigger db update ([8eed422](https://github.com/flowerforce/flowerbase/commit/8eed422))
+
+- trigger test e2e full_document_before_change ([117e89c](https://github.com/flowerforce/flowerbase/commit/117e89c))
+
+- trigger fullDocumentBeforeChange ([a659a8d](https://github.com/flowerforce/flowerbase/commit/a659a8d))
+
+- revert trigger fullDocumentBeforeChange ([f1736b5](https://github.com/flowerforce/flowerbase/commit/f1736b5))
+
 ## 1.5.0 (2026-01-26)
 
 

package/dist/auth/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/auth/utils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;CAcxB,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAa7B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CAe7B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAUhC,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;CAS/B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;CAAoB,CAAA;AAE7C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;CAc/B,CAAA;AAED,oBAAY,cAAc;IACxB,KAAK,WAAW;IAChB,YAAY,cAAc;IAC1B,OAAO,aAAa;IACpB,OAAO,aAAa;IACpB,OAAO,aAAa;IACpB,KAAK,gBAAgB;IACrB,UAAU,gBAAgB;IAC1B,aAAa,WAAW;IACxB,UAAU,sBAAsB;CACjC;AAED,oBAAY,WAAW;IACrB,mBAAmB,wBAAwB;IAC3C,aAAa,mCAAmC;IAChD,oBAAoB,sCAAsC;IAC1D,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;CAC1C;AAED,MAAM,WAAW,UAAU;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,aAAa,CAAA;IAC/B,iBAAiB,EAAE,cAAc,CAAA;IACjC,WAAW,CAAC,EAAE,QAAQ,CAAA;CACvB;AAED,UAAU,MAAM;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;CAClB;AACD,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,UAAU,cAAc;IACtB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE;QACN,kBAAkB,EAAE,MAAM,CAAA;KAC3B,CAAA;CACF;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,MAAM;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,iBAAiB,EAAE,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,CAAA;IACxB,uBAAuB,EAAE,OAAO,CAAA;IAChC,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;IACrB,8BAA8B,EAAE,MAAM,CAAA;CACvC;AAMD;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,UAGjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,oBAGrC,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,eAAW,WAG3C,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/auth/utils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;CAcxB,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAa7B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CAe7B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAUhC,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;CAS/B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;CAAoB,CAAA;AAE7C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;CAc/B,CAAA;AAED,oBAAY,cAAc;IACxB,KAAK,WAAW;IAChB,YAAY,cAAc;IAC1B,OAAO,aAAa;IACpB,OAAO,aAAa;IACpB,OAAO,aAAa;IACpB,KAAK,gBAAgB;IACrB,UAAU,gBAAgB;IAC1B,aAAa,WAAW;IACxB,UAAU,sBAAsB;CACjC;AAED,oBAAY,WAAW;IACrB,mBAAmB,wBAAwB;IAC3C,aAAa,mCAAmC;IAChD,oBAAoB,sCAAsC;IAC1D,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;CAC1C;AAED,MAAM,WAAW,UAAU;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,aAAa,CAAA;IAC/B,iBAAiB,EAAE,cAAc,CAAA;IACjC,WAAW,CAAC,EAAE,QAAQ,CAAA;CACvB;AAED,UAAU,MAAM;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;CAClB;AACD,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,UAAU,cAAc;IACtB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE;QACN,kBAAkB,EAAE,MAAM,CAAA;KAC3B,CAAA;CACF;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,MAAM;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,iBAAiB,EAAE,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,CAAA;IACxB,uBAAuB,EAAE,OAAO,CAAA;IAChC,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;IACrB,8BAA8B,EAAE,MAAM,CAAA;CACvC;AAMD;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,UAuCjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,oBAarC,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,eAAW,WAG3C,CAAA"}

package/dist/auth/utils.js

@@ -117,6 +117,42 @@ const resolveAppPath = () => { var _a, _b, _c; return (_c = (_a = process.env.FL
  */
 const loadAuthConfig = () => {
     const authPath = path_1.default.join(resolveAppPath(), 'auth/providers.json');
+    if (!fs_1.default.existsSync(authPath)) {
+        return {
+            auth_collection: 'auth_users',
+            'api-key': {
+                name: 'api-key',
+                type: 'api-key',
+                disabled: true
+            },
+            'local-userpass': {
+                name: 'local-userpass',
+                type: 'local-userpass',
+                disabled: true,
+                config: {
+                    autoConfirm: true,
+                    confirmationFunctionName: '',
+                    resetFunctionName: '',
+                    resetPasswordUrl: '',
+                    runConfirmationFunction: false,
+                    runResetFunction: false
+                }
+            },
+            'custom-function': {
+                name: 'custom-function',
+                type: 'custom-function',
+                disabled: true,
+                config: {
+                    authFunctionName: ''
+                }
+            },
+            'anon-user': {
+                name: 'anon-user',
+                type: 'anon-user',
+                disabled: false
+            }
+        };
+    }
     return JSON.parse(fs_1.default.readFileSync(authPath, 'utf-8'));
 };
 exports.loadAuthConfig = loadAuthConfig;
@@ -125,7 +161,18 @@ exports.loadAuthConfig = loadAuthConfig;
  * @testable
  */
 const loadCustomUserData = () => {
+    var _a;
     const userDataPath = path_1.default.join(resolveAppPath(), 'auth/custom_user_data.json');
+    if (!fs_1.default.existsSync(userDataPath)) {
+        return {
+            enabled: false,
+            mongo_service_name: 'mongodb-atlas',
+            database_name: (_a = process.env.DB_NAME) !== null && _a !== void 0 ? _a : '',
+            collection_name: 'users',
+            user_id_field: 'id',
+            on_user_creation_function_name: ''
+        };
+    }
     return JSON.parse(fs_1.default.readFileSync(userDataPath, 'utf-8'));
 };
 exports.loadCustomUserData = loadCustomUserData;

package/dist/cli/call-function.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+//# sourceMappingURL=call-function.d.ts.map

package/dist/cli/call-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-function.d.ts","sourceRoot":"","sources":["../../src/cli/call-function.ts"],"names":[],"mappings":";AACA,OAAO,eAAe,CAAA"}

package/dist/cli/call-function.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const bson_1 = require("bson");
+const state_1 = require("../state");
+const context_1 = require("../utils/context");
+const HELP_TEXT = `
+Usage:
+  flowerbase-function --app-id <id> --name <function> [options]
+
+Options:
+  --base-path <path>      Project base path (default: cwd)
+  --mongodb-url <url>     MongoDB connection string
+  --jwt-secret <secret>   JWT secret
+  --app-id <id>           App ID (optional)
+  --name <name>           Function name (required)
+  --args <json>           JSON arguments (array or single value)
+  --args-file <path>      JSON arguments file
+  --stdin                 Read JSON arguments from stdin
+  --user <json>           User payload JSON
+  --user-file <path>      User payload JSON file
+  --user-id <id>          User id shortcut
+  --user-email <email>    User email shortcut
+  --user-role <role>      User role shortcut
+  --port <number>         Server port
+  --host <string>         Server host
+  --help                  Show help
+
+Env:
+  MONGODB_URL, JWT_SECRET
+`;
+const readStdin = () => __awaiter(void 0, void 0, void 0, function* () {
+    return yield new Promise((resolve, reject) => {
+        let data = '';
+        node_process_1.default.stdin.setEncoding('utf8');
+        node_process_1.default.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        node_process_1.default.stdin.on('end', () => resolve(data));
+        node_process_1.default.stdin.on('error', reject);
+    });
+});
+const getArgValue = (argv, name) => {
+    const index = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
+    if (index === -1)
+        return undefined;
+    const direct = argv[index];
+    if (direct.includes('=')) {
+        return direct.split('=').slice(1).join('=');
+    }
+    return argv[index + 1];
+};
+const hasFlag = (argv, name) => argv.includes(name);
+const parseArgs = (argv) => {
+    if (hasFlag(argv, '--help') || hasFlag(argv, '-h')) {
+        console.log(HELP_TEXT.trim());
+        return null;
+    }
+    const appId = getArgValue(argv, '--app-id');
+    const name = getArgValue(argv, '--name') || '';
+    const basePath = getArgValue(argv, '--base-path');
+    const mongodbUrl = getArgValue(argv, '--mongodb-url') || node_process_1.default.env.MONGODB_URL;
+    const jwtSecret = getArgValue(argv, '--jwt-secret') || node_process_1.default.env.JWT_SECRET;
+    const portValue = getArgValue(argv, '--port');
+    const host = getArgValue(argv, '--host');
+    const port = portValue ? Number(portValue) : undefined;
+    return {
+        appId,
+        name,
+        basePath,
+        mongodbUrl,
+        jwtSecret,
+        port,
+        host,
+    };
+};
+const parseJsonValue = (value, sourceLabel) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON from ${sourceLabel}: ${message}`);
+    }
+};
+const loadArgs = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const argsValue = getArgValue(argv, '--args');
+    const argsFile = getArgValue(argv, '--args-file');
+    const useStdin = hasFlag(argv, '--stdin');
+    const shouldReadStdin = useStdin || (!node_process_1.default.stdin.isTTY && !argsValue && !argsFile);
+    if (argsValue) {
+        return parseJsonValue(argsValue, '--args');
+    }
+    if (argsFile) {
+        const resolved = node_path_1.default.resolve(node_process_1.default.cwd(), argsFile);
+        const contents = node_fs_1.default.readFileSync(resolved, 'utf8');
+        return parseJsonValue(contents, '--args-file');
+    }
+    if (shouldReadStdin) {
+        const stdinValue = yield readStdin();
+        if (!stdinValue.trim())
+            return undefined;
+        return parseJsonValue(stdinValue, 'stdin');
+    }
+    return undefined;
+});
+const normalizeArguments = (value) => {
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value))
+        return value;
+    return [value];
+};
+const loadUser = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const userValue = getArgValue(argv, '--user');
+    const userFile = getArgValue(argv, '--user-file');
+    const userId = getArgValue(argv, '--user-id');
+    const userEmail = getArgValue(argv, '--user-email');
+    const userRole = getArgValue(argv, '--user-role');
+    let user;
+    if (userValue) {
+        user = parseJsonValue(userValue, '--user');
+    }
+    else if (userFile) {
+        const resolved = node_path_1.default.resolve(node_process_1.default.cwd(), userFile);
+        const contents = node_fs_1.default.readFileSync(resolved, 'utf8');
+        user = parseJsonValue(contents, '--user-file');
+    }
+    else if (userId || userEmail || userRole) {
+        user = Object.assign(Object.assign(Object.assign({}, (userId ? { id: userId } : {})), (userEmail ? { email: userEmail } : {})), (userRole ? { role: userRole } : {}));
+    }
+    if (!user)
+        return undefined;
+    if (!('typ' in user)) {
+        user.typ = 'access';
+    }
+    if (!('_id' in user) && typeof user.id === 'string') {
+        try {
+            user._id = new bson_1.ObjectId(user.id);
+        }
+        catch (_a) {
+            // Keep the user id as-is when it is not a valid ObjectId.
+        }
+    }
+    return user;
+});
+const executeLocal = (_a) => __awaiter(void 0, [_a], void 0, function* ({ basePath, projectId, port, host, mongodbUrl, jwtSecret, name, args, user }) {
+    node_process_1.default.env.FLOWERBASE_APP_PATH = basePath;
+    const { initialize } = yield Promise.resolve().then(() => __importStar(require('../index')));
+    yield initialize({
+        projectId,
+        port,
+        mongodbUrl,
+        jwtSecret,
+        host,
+        basePath
+    });
+    const app = state_1.StateManager.select('app');
+    const functionsList = state_1.StateManager.select('functions');
+    const rulesList = state_1.StateManager.select('rules');
+    const services = state_1.StateManager.select('services');
+    try {
+        const currentFunction = functionsList[name];
+        if (!currentFunction) {
+            throw new Error(`Function "${name}" does not exist`);
+        }
+        return yield (0, context_1.GenerateContext)({
+            args,
+            app,
+            rules: rulesList,
+            user,
+            currentFunction: currentFunction,
+            functionsList,
+            services,
+            runAsSystem: true,
+            request: {
+                ip: 'cli',
+                method: 'CLI',
+                url: 'cli://local',
+                host: 'cli',
+                id: 'cli',
+                hostname: 'cli'
+            }
+        });
+    }
+    finally {
+        yield app.close();
+    }
+});
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const argv = node_process_1.default.argv.slice(2);
+    const options = parseArgs(argv);
+    if (!options)
+        return;
+    if (!options.name) {
+        console.error('Missing required --name');
+        console.log(HELP_TEXT.trim());
+        node_process_1.default.exit(1);
+    }
+    const basePath = options.basePath ? node_path_1.default.resolve(options.basePath) : node_process_1.default.cwd();
+    if (!options.mongodbUrl) {
+        throw new Error('Missing --mongodb-url (or MONGODB_URL)');
+    }
+    if (!options.jwtSecret) {
+        throw new Error('Missing --jwt-secret (or JWT_SECRET)');
+    }
+    const argsInput = yield loadArgs(argv);
+    const args = normalizeArguments(argsInput);
+    const user = yield loadUser(argv);
+    const projectId = options.appId || node_path_1.default.basename(basePath);
+    const result = yield executeLocal({
+        basePath,
+        projectId,
+        port: options.port,
+        host: options.host,
+        mongodbUrl: options.mongodbUrl,
+        jwtSecret: options.jwtSecret,
+        name: options.name,
+        args,
+        user
+    });
+    if (typeof result === 'string') {
+        console.log(result);
+    }
+    else {
+        console.log(JSON.stringify(result));
+    }
+});
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    node_process_1.default.exit(1);
+});

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

@@ -21,10 +21,10 @@ export declare const generateContextData: ({ user, services, app, rules, current
     context: {
         request: {
             remoteIPAddress: string | undefined;
+            id?: string | undefined;
             method?: string | undefined;
             url?: string | undefined;
             host?: string | undefined;
-            id?: string | undefined;
             ips?: string[];
             hostname?: string | undefined;
             ip?: string | undefined;

package/dist/utils/initializer/registerPlugins.js

@@ -40,7 +40,7 @@ const registerPlugins = (_a) => __awaiter(void 0, [_a], void 0, function* ({ reg
         registersConfig.forEach(({ plugin, options, pluginName }) => {
             try {
                 register(plugin, options);
-                console.log('registration COMPLETED --->', pluginName);
+                // console.log('registration COMPLETED --->', pluginName)
             }
             catch (e) {
                 console.log('Registration FAILED --->', pluginName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase",
-  "version": "1.5.1-beta.3",
+  "version": "1.6.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -67,5 +67,8 @@
   },
   "exports": {
     ".": "./dist/index.js"
+  },
+  "bin": {
+    "flowerbase-function": "dist/cli/call-function.js"
   }
 }

package/src/auth/utils.ts

@@ -176,6 +176,42 @@ const resolveAppPath = () =>
  */
 export const loadAuthConfig = (): AuthConfig => {
   const authPath = path.join(resolveAppPath(), 'auth/providers.json')
+  if (!fs.existsSync(authPath)) {
+    return {
+      auth_collection: 'auth_users',
+      'api-key': {
+        name: 'api-key',
+        type: 'api-key',
+        disabled: true
+      },
+      'local-userpass': {
+        name: 'local-userpass',
+        type: 'local-userpass',
+        disabled: true,
+        config: {
+          autoConfirm: true,
+          confirmationFunctionName: '',
+          resetFunctionName: '',
+          resetPasswordUrl: '',
+          runConfirmationFunction: false,
+          runResetFunction: false
+        }
+      },
+      'custom-function': {
+        name: 'custom-function',
+        type: 'custom-function',
+        disabled: true,
+        config: {
+          authFunctionName: ''
+        }
+      },
+      'anon-user': {
+        name: 'anon-user',
+        type: 'anon-user',
+        disabled: false
+      }
+    }
+  }
   return JSON.parse(fs.readFileSync(authPath, 'utf-8'))
 }
 
@@ -185,6 +221,16 @@ export const loadAuthConfig = (): AuthConfig => {
  */
 export const loadCustomUserData = (): CustomUserDataConfig => {
   const userDataPath = path.join(resolveAppPath(), 'auth/custom_user_data.json')
+  if (!fs.existsSync(userDataPath)) {
+    return {
+      enabled: false,
+      mongo_service_name: 'mongodb-atlas',
+      database_name: process.env.DB_NAME ?? '',
+      collection_name: 'users',
+      user_id_field: 'id',
+      on_user_creation_function_name: ''
+    }
+  }
   return JSON.parse(fs.readFileSync(userDataPath, 'utf-8'))
 }
 

package/src/cli/call-function.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import 'dotenv/config'
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { ObjectId } from 'bson'
+import { Function } from '../features/functions/interface'
+import { StateManager } from '../state'
+import { GenerateContext } from '../utils/context'
+
+type CliOptions = {
+  appId?: string
+  name: string
+  basePath?: string
+  mongodbUrl?: string
+  jwtSecret?: string
+  port?: number
+  host?: string
+}
+
+const HELP_TEXT = `
+Usage:
+  flowerbase-function --app-id <id> --name <function> [options]
+
+Options:
+  --base-path <path>      Project base path (default: cwd)
+  --mongodb-url <url>     MongoDB connection string
+  --jwt-secret <secret>   JWT secret
+  --app-id <id>           App ID (optional)
+  --name <name>           Function name (required)
+  --args <json>           JSON arguments (array or single value)
+  --args-file <path>      JSON arguments file
+  --stdin                 Read JSON arguments from stdin
+  --user <json>           User payload JSON
+  --user-file <path>      User payload JSON file
+  --user-id <id>          User id shortcut
+  --user-email <email>    User email shortcut
+  --user-role <role>      User role shortcut
+  --port <number>         Server port
+  --host <string>         Server host
+  --help                  Show help
+
+Env:
+  MONGODB_URL, JWT_SECRET
+`
+
+const readStdin = async () =>
+  await new Promise<string>((resolve, reject) => {
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (chunk) => {
+      data += chunk
+    })
+    process.stdin.on('end', () => resolve(data))
+    process.stdin.on('error', reject)
+  })
+
+const getArgValue = (argv: string[], name: string) => {
+  const index = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`))
+  if (index === -1) return undefined
+  const direct = argv[index]
+  if (direct.includes('=')) {
+    return direct.split('=').slice(1).join('=')
+  }
+  return argv[index + 1]
+}
+
+const hasFlag = (argv: string[], name: string) => argv.includes(name)
+
+const parseArgs = (argv: string[]): CliOptions | null => {
+  if (hasFlag(argv, '--help') || hasFlag(argv, '-h')) {
+    console.log(HELP_TEXT.trim())
+    return null
+  }
+
+  const appId = getArgValue(argv, '--app-id')
+  const name = getArgValue(argv, '--name') || ''
+  const basePath = getArgValue(argv, '--base-path')
+  const mongodbUrl =
+    getArgValue(argv, '--mongodb-url') || process.env.MONGODB_URL
+  const jwtSecret = getArgValue(argv, '--jwt-secret') || process.env.JWT_SECRET
+  const portValue = getArgValue(argv, '--port')
+  const host = getArgValue(argv, '--host')
+  const port = portValue ? Number(portValue) : undefined
+
+  return {
+    appId,
+    name,
+    basePath,
+    mongodbUrl,
+    jwtSecret,
+    port,
+    host,
+  }
+}
+
+const parseJsonValue = (value: string, sourceLabel: string) => {
+  try {
+    return JSON.parse(value)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Invalid JSON from ${sourceLabel}: ${message}`)
+  }
+}
+
+const loadArgs = async (argv: string[]) => {
+  const argsValue = getArgValue(argv, '--args')
+  const argsFile = getArgValue(argv, '--args-file')
+  const useStdin = hasFlag(argv, '--stdin')
+  const shouldReadStdin = useStdin || (!process.stdin.isTTY && !argsValue && !argsFile)
+
+  if (argsValue) {
+    return parseJsonValue(argsValue, '--args')
+  }
+
+  if (argsFile) {
+    const resolved = path.resolve(process.cwd(), argsFile)
+    const contents = fs.readFileSync(resolved, 'utf8')
+    return parseJsonValue(contents, '--args-file')
+  }
+
+  if (shouldReadStdin) {
+    const stdinValue = await readStdin()
+    if (!stdinValue.trim()) return undefined
+    return parseJsonValue(stdinValue, 'stdin')
+  }
+
+  return undefined
+}
+
+const normalizeArguments = (value: unknown) => {
+  if (value === undefined) return []
+  if (Array.isArray(value)) return value
+  return [value]
+}
+
+const loadUser = async (argv: string[]) => {
+  const userValue = getArgValue(argv, '--user')
+  const userFile = getArgValue(argv, '--user-file')
+  const userId = getArgValue(argv, '--user-id')
+  const userEmail = getArgValue(argv, '--user-email')
+  const userRole = getArgValue(argv, '--user-role')
+
+  let user: Record<string, unknown> | undefined
+
+  if (userValue) {
+    user = parseJsonValue(userValue, '--user') as Record<string, unknown>
+  } else if (userFile) {
+    const resolved = path.resolve(process.cwd(), userFile)
+    const contents = fs.readFileSync(resolved, 'utf8')
+    user = parseJsonValue(contents, '--user-file') as Record<string, unknown>
+  } else if (userId || userEmail || userRole) {
+    user = {
+      ...(userId ? { id: userId } : {}),
+      ...(userEmail ? { email: userEmail } : {}),
+      ...(userRole ? { role: userRole } : {})
+    }
+  }
+
+  if (!user) return undefined
+
+  if (!('typ' in user)) {
+    user.typ = 'access'
+  }
+
+  if (!('_id' in user) && typeof user.id === 'string') {
+    try {
+      user._id = new ObjectId(user.id)
+    } catch {
+      // Keep the user id as-is when it is not a valid ObjectId.
+    }
+  }
+
+  return user
+}
+
+const executeLocal = async ({
+  basePath,
+  projectId,
+  port,
+  host,
+  mongodbUrl,
+  jwtSecret,
+  name,
+  args,
+  user
+}: {
+  basePath: string
+  projectId: string
+  port?: number
+  host?: string
+  mongodbUrl: string
+  jwtSecret: string
+  name: string
+  args: unknown[]
+  user?: Record<string, unknown>
+}) => {
+  process.env.FLOWERBASE_APP_PATH = basePath
+  const { initialize } = await import('../index')
+  await initialize({
+    projectId,
+    port,
+    mongodbUrl,
+    jwtSecret,
+    host,
+    basePath
+  })
+
+  const app = StateManager.select('app')
+  const functionsList = StateManager.select('functions')
+  const rulesList = StateManager.select('rules')
+  const services = StateManager.select('services')
+
+  try {
+    const currentFunction = functionsList[name]
+    if (!currentFunction) {
+      throw new Error(`Function "${name}" does not exist`)
+    }
+
+    return await GenerateContext({
+      args,
+      app,
+      rules: rulesList,
+      user,
+      currentFunction: currentFunction as Function,
+      functionsList,
+      services,
+      runAsSystem: true,
+      request: {
+        ip: 'cli',
+        method: 'CLI',
+        url: 'cli://local',
+        host: 'cli',
+        id: 'cli',
+        hostname: 'cli'
+      }
+    })
+  } finally {
+    await app.close()
+  }
+}
+
+const main = async () => {
+  const argv = process.argv.slice(2)
+  const options = parseArgs(argv)
+  if (!options) return
+
+  if (!options.name) {
+    console.error('Missing required --name')
+    console.log(HELP_TEXT.trim())
+    process.exit(1)
+  }
+
+  const basePath = options.basePath ? path.resolve(options.basePath) : process.cwd()
+  if (!options.mongodbUrl) {
+    throw new Error('Missing --mongodb-url (or MONGODB_URL)')
+  }
+  if (!options.jwtSecret) {
+    throw new Error('Missing --jwt-secret (or JWT_SECRET)')
+  }
+  const argsInput = await loadArgs(argv)
+  const args = normalizeArguments(argsInput)
+  const user = await loadUser(argv)
+  const projectId = options.appId || path.basename(basePath)
+  const result = await executeLocal({
+    basePath,
+    projectId,
+    port: options.port,
+    host: options.host,
+    mongodbUrl: options.mongodbUrl,
+    jwtSecret: options.jwtSecret,
+    name: options.name,
+    args,
+    user
+  })
+  if (typeof result === 'string') {
+    console.log(result)
+  } else {
+    console.log(JSON.stringify(result))
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error)
+  console.error(message)
+  process.exit(1)
+})

package/src/utils/initializer/registerPlugins.ts

@@ -53,7 +53,7 @@ export const registerPlugins = async ({
     registersConfig.forEach(({ plugin, options, pluginName }) => {
       try {
         register(plugin, options)
-        console.log('registration COMPLETED --->', pluginName)
+        // console.log('registration COMPLETED --->', pluginName)
       } catch (e) {
         console.log('Registration FAILED --->', pluginName)
         console.log('Error --->', e)