@flowerforce/flowerbase-client 0.1.1-beta.2 → 0.1.1-beta.3

package/dist/user.js

@@ -5,26 +5,115 @@ const functions_1 = require("./functions");
 const mongo_1 = require("./mongo");
 class User {
     constructor(app, id) {
+        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.functions = (0, functions_1.createFunctionsProxy)((name, args) => this.app.callFunction(name, args, this.id), (name, args) => this.app.callFunctionStreaming(name, args, this.id));
+    }
+    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 ?? [];
+    }
+    get customData() {
+        const payload = this.decodeAccessTokenPayload();
+        if (!payload)
+            return {};
+        const fromUserData = '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
+                    : {};
+        return fromUserData;
+    }
+    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();
+        await this.app.logoutUser(this.id);
+    }
+    async callFunction(name, ...args) {
+        return this.app.callFunction(name, args, this.id);
     }
     async refreshAccessToken() {
-        return this.app.refreshAccessToken();
+        return this.app.refreshAccessToken(this.id);
     }
     async refreshCustomData() {
-        const profile = await this.app.getProfile();
+        const profile = await this.app.getProfile(this.id);
         this.profile = profile.data;
+        this.notifyListeners();
         return profile.custom_data || {};
     }
     mongoClient(serviceName) {
-        if (serviceName !== 'mongodb-atlas') {
-            throw new Error(`Unsupported service "${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.
+            }
         }
-        return (0, mongo_1.createMongoClient)(this.app);
     }
 }
 exports.User = User;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase-client",
-  "version": "0.1.1-beta.2",
+  "version": "0.1.1-beta.3",
   "description": "Client for Flowerbase",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,5 +26,16 @@
   },
   "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/src/__tests__/auth.test.ts

@@ -91,6 +91,26 @@ describe('flowerbase-client auth', () => {
     )
   })
 
+  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,
@@ -126,6 +146,35 @@ describe('flowerbase-client auth', () => {
     )
   })
 
+  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(

package/src/__tests__/compat.test.ts

@@ -3,10 +3,20 @@ 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)
+  })
 })

package/src/__tests__/functions.test.ts

@@ -1,8 +1,18 @@
 import { App } from '../app'
 import { Credentials } from '../credentials'
+import { FlowerbaseHttpError } from '../http'
 
 describe('flowerbase-client functions', () => {
   const originalFetch = global.fetch
+  const streamFromChunks = (chunks: string[]) =>
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(new TextEncoder().encode(chunk))
+        }
+        controller.close()
+      }
+    })
 
   afterEach(() => {
     global.fetch = originalFetch
@@ -73,4 +83,207 @@ describe('flowerbase-client functions', () => {
 
     await expect(app.currentUser!.functions.explode()).rejects.toThrow('boom')
   })
+
+  it('supports functions.callFunction compatibility helper', 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' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ result: 7 })
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    const result = await app.currentUser!.functions.callFunction('sum', 3, 4)
+    expect(result).toEqual({ result: 7 })
+  })
+
+  it('supports functions.callFunctionStreaming', 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' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        body: streamFromChunks(['a', 'b'])
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    const stream = await app.currentUser!.functions.callFunctionStreaming('streamData')
+    const received: string[] = []
+    for await (const chunk of stream) {
+      received.push(new TextDecoder().decode(chunk))
+    }
+
+    expect(received).toEqual(['a', 'b'])
+  })
+
+  it('executes user-bound functions with that user session', async () => {
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'login-a1', refresh_token: 'refresh-1', user_id: 'user-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'login-a2', refresh_token: 'refresh-2', user_id: 'user-2' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-2' })
+      })
+      .mockResolvedValue({
+        ok: true,
+        text: async () => JSON.stringify({ ok: true })
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    const user1 = await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+    await app.logIn(Credentials.anonymous())
+
+    await user1.functions.sum(1, 2)
+    const request = (global.fetch as jest.Mock).mock.calls[4][1]
+    expect(request.headers.Authorization).toBe('Bearer access-1')
+  })
+
+  it('retries streaming call when initial request returns 401', async () => {
+    const streamFromChunks = (chunks: string[]) =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(new TextEncoder().encode(chunk))
+          }
+          controller.close()
+        }
+      })
+
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'login-a1', refresh_token: 'refresh-1', user_id: 'user-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        text: async () => JSON.stringify({ error: 'Unauthorized', error_code: 'InvalidSession' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-2' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        body: streamFromChunks(['x', 'y'])
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    const stream = await app.currentUser!.functions.callFunctionStreaming('streamData')
+    const received: string[] = []
+    for await (const chunk of stream) {
+      received.push(new TextDecoder().decode(chunk))
+    }
+
+    expect(received).toEqual(['x', 'y'])
+    expect((global.fetch as jest.Mock).mock.calls[3][0]).toBe('http://localhost:3000/api/client/v2.0/auth/session')
+  })
+
+  it('retries streaming call when stream fails with 401 during iteration', async () => {
+    const streamWithAuthError = () =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('a'))
+          controller.error(
+            new FlowerbaseHttpError({
+              method: 'POST',
+              url: 'http://localhost:3000/api/client/v2.0/app/my-app/functions/call',
+              statusCode: 401,
+              statusText: 'Unauthorized',
+              error: 'Expired token'
+            })
+          )
+        }
+      })
+
+    const streamFromChunks = (chunks: string[]) =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(new TextEncoder().encode(chunk))
+          }
+          controller.close()
+        }
+      })
+
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'login-a1', refresh_token: 'refresh-1', user_id: 'user-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-1' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        body: streamWithAuthError()
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({ access_token: 'access-2' })
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        body: streamFromChunks(['b'])
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    const stream = await app.currentUser!.functions.callFunctionStreaming('streamData')
+    const received: string[] = []
+    for await (const chunk of stream) {
+      received.push(new TextDecoder().decode(chunk))
+    }
+
+    expect(received).toContain('b')
+  })
 })

package/src/__tests__/mongo.test.ts

@@ -45,4 +45,39 @@ describe('flowerbase-client mongo service wrapper', () => {
     expect(parsed.service).toBe('mongodb-atlas')
     expect(parsed.name).toBe('findOne')
   })
+
+  it('supports extended CRUD operations and custom service name', async () => {
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => JSON.stringify({
+          access_token: 'access',
+          refresh_token: 'refresh',
+          user_id: 'user-1'
+        })
+      })
+      .mockResolvedValue({
+        ok: true,
+        text: async () => JSON.stringify({ ok: true })
+      }) as unknown as typeof fetch
+
+    const app = new App({ id: 'my-app', baseUrl: 'http://localhost:3000' })
+    await app.logIn(Credentials.emailPassword('john@doe.com', 'secret123'))
+
+    const collection = app.currentUser!.mongoClient('my-service').db('testdb').collection('todos')
+
+    await collection.findOneAndUpdate({ done: false }, { $set: { done: true } })
+    await collection.findOneAndReplace({ done: true }, { done: true, title: 'done' })
+    await collection.findOneAndDelete({ done: true })
+    await collection.aggregate([{ $match: { done: true } }])
+    await collection.count({ done: true })
+    await collection.insertMany([{ title: 'A' }, { title: 'B' }])
+    await collection.deleteMany({ done: true })
+
+    const calls = (global.fetch as jest.Mock).mock.calls
+    const lastBody = JSON.parse(calls[calls.length - 1][1].body)
+    expect(lastBody.service).toBe('my-service')
+    expect(lastBody.name).toBe('deleteMany')
+  })
 })