@flowerforce/flowerbase-client 0.1.1-beta.0

package/dist/user.d.ts

@@ -0,0 +1,37 @@
+import type { App } from './app';
+import { MongoClientLike, UserLike } from './types';
+export declare class User implements UserLike {
+    readonly id: string;
+    customData: Record<string, unknown>;
+    profile?: {
+        email?: string;
+        [key: string]: unknown;
+    };
+    private readonly app;
+    private _providerType;
+    private readonly listeners;
+    functions: Record<string, (...args: unknown[]) => Promise<unknown>> & {
+        callFunction: (name: string, ...args: unknown[]) => Promise<unknown>;
+        callFunctionStreaming: (name: string, ...args: unknown[]) => Promise<AsyncIterable<Uint8Array>>;
+    };
+    constructor(app: App, id: string);
+    get state(): "active" | "logged-out" | "removed";
+    get isLoggedIn(): boolean;
+    get providerType(): string | null;
+    get identities(): unknown[];
+    private resolveCustomDataFromToken;
+    get accessToken(): string | null;
+    get refreshToken(): string | null;
+    setProviderType(providerType: string): void;
+    private decodeAccessTokenPayload;
+    logOut(): Promise<void>;
+    callFunction(name: string, ...args: unknown[]): Promise<any>;
+    refreshAccessToken(): Promise<string>;
+    refreshCustomData(): Promise<Record<string, unknown>>;
+    mongoClient(serviceName: string): MongoClientLike;
+    addListener(callback: () => void): void;
+    removeListener(callback: () => void): void;
+    removeAllListeners(): void;
+    notifyListeners(): void;
+}
+//# sourceMappingURL=user.d.ts.map

package/dist/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../src/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEnD,qBAAa,IAAK,YAAW,QAAQ;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IACxC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IACnD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAK;IACzB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAElD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG;QACpE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QACpE,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;KAChG,CAAA;gBAEW,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM;IAUhC,IAAI,KAAK,wCAKR;IAED,IAAI,UAAU,YAEb;IAED,IAAI,YAAY,kBAEf;IAED,IAAI,UAAU,cAEb;IAED,OAAO,CAAC,0BAA0B;IAclC,IAAI,WAAW,kBAId;IAED,IAAI,YAAY,kBAIf;IAED,eAAe,CAAC,YAAY,EAAE,MAAM;IAIpC,OAAO,CAAC,wBAAwB;IAuB1B,MAAM;IAIN,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAI7C,kBAAkB;IAMlB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAU3D,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe;IAIjD,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI;IAIhC,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI;IAInC,kBAAkB;IAIlB,eAAe;CAShB"}

package/dist/user.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const functions_1 = require("./functions");
+const mongo_1 = require("./mongo");
+class User {
+    constructor(app, id) {
+        this.customData = {};
+        this._providerType = null;
+        this.listeners = new Set();
+        this.app = app;
+        this.id = id;
+        this.functions = (0, functions_1.createFunctionsProxy)((name, args) => this.app.callFunction(name, args, this.id), (name, args) => this.app.callFunctionStreaming(name, args, this.id));
+        this.customData = this.resolveCustomDataFromToken();
+    }
+    get state() {
+        if (!this.app.hasUser(this.id)) {
+            return 'removed';
+        }
+        return this.isLoggedIn ? 'active' : 'logged-out';
+    }
+    get isLoggedIn() {
+        return this.accessToken !== null && this.refreshToken !== null;
+    }
+    get providerType() {
+        return this._providerType;
+    }
+    get identities() {
+        return this.app.getProfileSnapshot(this.id)?.identities ?? [];
+    }
+    resolveCustomDataFromToken() {
+        const payload = this.decodeAccessTokenPayload();
+        if (!payload)
+            return {};
+        return ('user_data' in payload && payload.user_data && typeof payload.user_data === 'object'
+            ? payload.user_data
+            : 'userData' in payload && payload.userData && typeof payload.userData === 'object'
+                ? payload.userData
+                : 'custom_data' in payload && payload.custom_data && typeof payload.custom_data === 'object'
+                    ? payload.custom_data
+                    : {});
+    }
+    get accessToken() {
+        const session = this.app.getSession(this.id);
+        if (!session)
+            return null;
+        return session.accessToken;
+    }
+    get refreshToken() {
+        const session = this.app.getSession(this.id);
+        if (!session)
+            return null;
+        return session.refreshToken;
+    }
+    setProviderType(providerType) {
+        this._providerType = providerType;
+    }
+    decodeAccessTokenPayload() {
+        if (!this.accessToken)
+            return null;
+        const parts = this.accessToken.split('.');
+        if (parts.length < 2)
+            return null;
+        const base64Url = parts[1];
+        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(base64Url.length / 4) * 4, '=');
+        const decodeBase64 = (input) => {
+            if (typeof atob === 'function')
+                return atob(input);
+            const runtimeBuffer = globalThis.Buffer;
+            if (runtimeBuffer)
+                return runtimeBuffer.from(input, 'base64').toString('utf8');
+            return '';
+        };
+        try {
+            const decoded = decodeBase64(base64);
+            return JSON.parse(decoded);
+        }
+        catch {
+            return null;
+        }
+    }
+    async logOut() {
+        await this.app.logoutUser(this.id);
+    }
+    async callFunction(name, ...args) {
+        return this.app.callFunction(name, args, this.id);
+    }
+    async refreshAccessToken() {
+        const accessToken = await this.app.refreshAccessToken(this.id);
+        this.customData = this.resolveCustomDataFromToken();
+        return accessToken;
+    }
+    async refreshCustomData() {
+        const profile = await this.app.getProfile(this.id);
+        this.profile = profile.data;
+        this.customData = (profile.custom_data && typeof profile.custom_data === 'object'
+            ? profile.custom_data
+            : this.resolveCustomDataFromToken());
+        this.notifyListeners();
+        return this.customData;
+    }
+    mongoClient(serviceName) {
+        return (0, mongo_1.createMongoClient)(this.app, serviceName, this.id);
+    }
+    addListener(callback) {
+        this.listeners.add(callback);
+    }
+    removeListener(callback) {
+        this.listeners.delete(callback);
+    }
+    removeAllListeners() {
+        this.listeners.clear();
+    }
+    notifyListeners() {
+        for (const callback of Array.from(this.listeners)) {
+            try {
+                callback();
+            }
+            catch {
+                // Listener failures should not break user lifecycle operations.
+            }
+        }
+    }
+}
+exports.User = User;

package/dist/watch.d.ts

@@ -0,0 +1,3 @@
+import { WatchAsyncIterator, WatchConfig } from './types';
+export declare const createWatchIterator: (config: WatchConfig) => WatchAsyncIterator<unknown>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAyCzD,eAAO,MAAM,mBAAmB,WAAY,WAAW,KAAG,mBAAmB,OAAO,CAiHnF,CAAA"}

package/dist/watch.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchIterator = void 0;
+const bson_1 = require("./bson");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const createWatchRequest = ({ database, collection, filter, ids }) => ({
+    name: 'watch',
+    service: 'mongodb-atlas',
+    arguments: [
+        {
+            database,
+            collection,
+            ...(filter ? { filter } : {}),
+            ...(ids ? { ids } : {})
+        }
+    ]
+});
+const toBase64 = (input) => {
+    if (typeof btoa === 'function') {
+        return btoa(input);
+    }
+    throw new Error('Base64 encoder not available in current runtime');
+};
+const parseSsePayload = (line) => {
+    if (!line.startsWith('data:'))
+        return null;
+    const raw = line.slice(5).trim();
+    if (!raw)
+        return null;
+    try {
+        return bson_1.EJSON.deserialize(JSON.parse(raw));
+    }
+    catch {
+        return raw;
+    }
+};
+const createWatchIterator = (config) => {
+    let closed = false;
+    let activeController = null;
+    const queue = [];
+    const waiters = [];
+    const enqueue = (value) => {
+        const waiter = waiters.shift();
+        if (waiter) {
+            waiter({ done: false, value });
+            return;
+        }
+        queue.push(value);
+    };
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        activeController?.abort();
+        while (waiters.length > 0) {
+            const resolve = waiters.shift();
+            resolve?.({ done: true, value: undefined });
+        }
+    };
+    const run = async () => {
+        let attempts = 0;
+        while (!closed) {
+            const controller = new AbortController();
+            activeController = controller;
+            const request = createWatchRequest(config);
+            const encoded = toBase64(JSON.stringify(bson_1.EJSON.serialize(request, { relaxed: false })));
+            const url = `${config.baseUrl}/api/client/v2.0/app/${config.appId}/functions/call?baas_request=${encodeURIComponent(encoded)}`;
+            try {
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        Authorization: `Bearer ${config.accessToken}`,
+                        Accept: 'text/event-stream'
+                    },
+                    signal: controller.signal
+                });
+                if (!response.ok || !response.body) {
+                    throw new Error(`Watch request failed (${response.status})`);
+                }
+                attempts = 0;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (!closed) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const parsed = parseSsePayload(line);
+                        if (parsed !== null) {
+                            enqueue(parsed);
+                        }
+                    }
+                }
+            }
+            catch {
+                if (closed) {
+                    break;
+                }
+            }
+            if (closed) {
+                break;
+            }
+            attempts += 1;
+            const backoff = Math.min(5000, 250 * 2 ** (attempts - 1));
+            await sleep(backoff);
+        }
+    };
+    void run();
+    return {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        next() {
+            if (queue.length > 0) {
+                return Promise.resolve({ done: false, value: queue.shift() });
+            }
+            if (closed) {
+                return Promise.resolve({ done: true, value: undefined });
+            }
+            return new Promise((resolve) => {
+                waiters.push(resolve);
+            });
+        },
+        return() {
+            close();
+            return Promise.resolve({ done: true, value: undefined });
+        },
+        throw(error) {
+            close();
+            return Promise.reject(error);
+        },
+        close
+    };
+};
+exports.createWatchIterator = createWatchIterator;

package/jest.config.ts

@@ -0,0 +1,13 @@
+module.exports = {
+  preset: '../../jest.preset.js',
+  transform: {
+    '^.+\\.[tj]s$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json'
+      }
+    ]
+  },
+  testEnvironment: 'node',
+  testMatch: ['<rootDir>/src/**/*.test.ts']
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@flowerforce/flowerbase-client",
+  "version": "0.1.1-beta.0",
+  "description": "Client for Flowerbase",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flowerforce/flowerbase.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "test": "npx jest",
+    "build": "rm -rf dist/ && tsc"
+  },
+  "dependencies": {
+    "bson": "^6.10.4"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^2.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@react-native-async-storage/async-storage": "^2.2.0"
+  }
+}

package/project.json

@@ -0,0 +1,11 @@
+{
+  "name": "flowerbase-client",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/flowerbase-client/src",
+  "projectType": "library",
+  "tags": [
+    "flowerbase",
+    "client"
+  ],
+  "targets": {}
+}

package/rollup.config.js

@@ -0,0 +1,17 @@
+const { withNx } = require('@nx/rollup/with-nx')
+
+module.exports = withNx(
+  {
+    main: './src/index.ts',
+    outputPath: './dist',
+    tsConfig: './tsconfig.lib.json',
+    compiler: 'tsc',
+    format: ['cjs', 'esm'],
+    generateExportsField: true
+  },
+  {
+    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+    // e.g.
+    // output: { sourcemap: true },
+  }
+)

package/src/__tests__/auth.test.ts

@@ -0,0 +1,213 @@
+import { App } from '../app'
+import { Credentials } from '../credentials'
+
+describe('flowerbase-client auth', () => {
+  const originalFetch = global.fetch
+  const originalLocalStorage = (globalThis as typeof globalThis & { localStorage?: unknown }).localStorage
+
+  afterEach(() => {
+    global.fetch = originalFetch
+    if (typeof originalLocalStorage === 'undefined') {
+      Reflect.deleteProperty(globalThis, 'localStorage')
+    } else {
+      Object.defineProperty(globalThis, 'localStorage', {
+        configurable: true,
+        value: originalLocalStorage
+      })
+    }
+  })
+
+  it('logs in with email/password', async () => {
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({
+          access_token: 'access',
+          refresh_token: 'refresh',
+          user_id: 'user-1'
+        })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-from-session' })
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    const user = await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    expect(user.id).toBe('user-1')
+    expect(app.currentUser?.id).toBe('user-1')
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/login',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/auth/session',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer refresh' })
+      })
+    )
+  })
+
+  it('logs in with anonymous provider', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({
+        access_token: 'access',
+        refresh_token: 'refresh',
+        user_id: 'anon-1'
+      })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    const user = await app.logIn(Credentials.anonymous())
+
+    expect(user.id).toBe('anon-1')
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/anon-user/login',
+      expect.objectContaining({ method: 'POST' })
+    )
+  })
+
+  it('logs in with custom function provider', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({
+        access_token: 'access',
+        refresh_token: 'refresh',
+        user_id: 'custom-1'
+      })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    const user = await app.logIn(Credentials.function({ token: 'abc' }))
+
+    expect(user.id).toBe('custom-1')
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/custom-function/login',
+      expect.objectContaining({ method: 'POST' })
+    )
+  })
+
+  it('logs in with custom jwt provider', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({
+        access_token: 'access',
+        refresh_token: 'refresh',
+        user_id: 'jwt-1'
+      })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    const user = await app.logIn(Credentials.jwt('jwt-token'))
+
+    expect(user.id).toBe('jwt-1')
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/custom-token/login',
+      expect.objectContaining({ method: 'POST' })
+    )
+  })
+
+  it('supports register and reset endpoints', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ status: 'ok' })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+
+    await app.emailPasswordAuth.registerUser({ email: 'john@doe.com', password: 'secret123' })
+    await app.emailPasswordAuth.sendResetPasswordEmail('john@doe.com')
+    await app.emailPasswordAuth.callResetPasswordFunction('john@doe.com', 'new-secret', 'extra')
+    await app.emailPasswordAuth.resetPassword({ token: 't1', tokenId: 't2', password: 'new-secret' })
+
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      1,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/register',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      2,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/reset/send',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      3,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/reset/call',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      4,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/reset',
+      expect.objectContaining({ method: 'POST' })
+    )
+  })
+
+  it('supports email/password confirmation endpoints', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ status: 'ok' })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+
+    await app.emailPasswordAuth.confirmUser({ token: 't1', tokenId: 'tid1' })
+    await app.emailPasswordAuth.resendConfirmationEmail({ email: 'john@doe.com' })
+    await app.emailPasswordAuth.retryCustomConfirmation({ email: 'john@doe.com' })
+
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      1,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/confirm',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      2,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/confirm/send',
+      expect.objectContaining({ method: 'POST' })
+    )
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      3,
+      'http://localhost:3000/api/client/v2.0/app/my-app/auth/providers/local-userpass/confirm/call',
+      expect.objectContaining({ method: 'POST' })
+    )
+  })
+
+  it('calls session endpoint on app load when browser session exists', async () => {
+    const storage = new Map<string, string>()
+    storage.set(
+      'flowerbase:my-app:session',
+      JSON.stringify({ accessToken: 'old-access', refreshToken: 'refresh', userId: 'user-1' })
+    )
+    Object.defineProperty(globalThis, 'localStorage', {
+      configurable: true,
+      value: {
+        getItem: (key: string) => storage.get(key) ?? null,
+        setItem: (key: string, value: string) => {
+          storage.set(key, value)
+        },
+        removeItem: (key: string) => {
+          storage.delete(key)
+        }
+      }
+    })
+
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ access_token: 'fresh-access' })
+    }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.getProfile().catch(() => undefined)
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://localhost:3000/api/client/v2.0/auth/session',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer refresh' })
+      })
+    )
+  })
+})

package/src/__tests__/compat.test.ts

@@ -0,0 +1,22 @@
+import * as Flowerbase from '../index'
+
+describe('flowerbase-client compatibility surface', () => {
+  it('exposes Realm-like symbols', () => {
+    expect(typeof Flowerbase.App).toBe('function')
+    expect(typeof Flowerbase.App.getApp).toBe('function')
+    expect(Flowerbase.App.Credentials).toBe(Flowerbase.Credentials)
+    expect(typeof Flowerbase.Credentials.emailPassword).toBe('function')
+    expect(typeof Flowerbase.Credentials.anonymous).toBe('function')
+    expect(typeof Flowerbase.Credentials.function).toBe('function')
+    expect(typeof Flowerbase.Credentials.jwt).toBe('function')
+    expect(typeof Flowerbase.MongoDBRealmError).toBe('function')
+    expect(typeof Flowerbase.BSON.ObjectId).toBe('function')
+    expect(Flowerbase.ObjectID).toBe(Flowerbase.ObjectId)
+  })
+
+  it('returns singleton app for same id', () => {
+    const a1 = Flowerbase.App.getApp('singleton-app')
+    const a2 = Flowerbase.App.getApp('singleton-app')
+    expect(a1).toBe(a2)
+  })
+})