@flowerforce/flowerbase-client 0.1.1-beta.2

package/src/__tests__/auth.test.ts

@@ -0,0 +1,164 @@
+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('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('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,12 @@
+import * as Flowerbase from '../index'
+
+describe('flowerbase-client compatibility surface', () => {
+  it('exposes Realm-like symbols', () => {
+    expect(typeof Flowerbase.App).toBe('function')
+    expect(typeof Flowerbase.Credentials.emailPassword).toBe('function')
+    expect(typeof Flowerbase.Credentials.anonymous).toBe('function')
+    expect(typeof Flowerbase.Credentials.function).toBe('function')
+    expect(typeof Flowerbase.BSON.ObjectId).toBe('function')
+    expect(Flowerbase.ObjectID).toBe(Flowerbase.ObjectId)
+  })
+})

package/src/__tests__/functions.test.ts

@@ -0,0 +1,76 @@
+import { App } from '../app'
+import { Credentials } from '../credentials'
+
+describe('flowerbase-client functions', () => {
+  const originalFetch = global.fetch
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  it('calls dynamic function proxies', 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: 42 })
+      }) 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.sum(40, 2)
+    expect(result).toEqual({ result: 42 })
+
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      3,
+      'http://localhost:3000/api/client/v2.0/app/my-app/functions/call',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer access' })
+      })
+    )
+  })
+
+  it('throws function execution errors', 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: false,
+        status: 400,
+        text: async () => JSON.stringify({
+          error: '{"message":"boom","name":"Error"}',
+          error_code: 'FunctionExecutionError'
+        })
+      }) 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'))
+
+    await expect(app.currentUser!.functions.explode()).rejects.toThrow('boom')
+  })
+})

package/src/__tests__/mongo.test.ts

@@ -0,0 +1,48 @@
+import { ObjectId } from 'bson'
+import { App } from '../app'
+import { Credentials } from '../credentials'
+
+describe('flowerbase-client mongo service wrapper', () => {
+  const originalFetch = global.fetch
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  it('maps CRUD calls to mongodb-atlas service payload', 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('mongodb-atlas').db('testdb').collection('todos')
+
+    await collection.find({ done: false })
+    await collection.findOne({ done: false })
+    await collection.insertOne({ title: 'new task' })
+    await collection.updateOne({ _id: new ObjectId('507f1f77bcf86cd799439011') }, { $set: { done: true } })
+    await collection.updateMany({ done: false }, { $set: { done: true } })
+    await collection.deleteOne({ done: true })
+
+    expect((global.fetch as jest.Mock).mock.calls).toHaveLength(8)
+    const [url, request] = (global.fetch as jest.Mock).mock.calls[3]
+    expect(url).toBe('http://localhost:3000/api/client/v2.0/app/my-app/functions/call')
+    expect(request.method).toBe('POST')
+    const parsed = JSON.parse(request.body)
+    expect(parsed.service).toBe('mongodb-atlas')
+    expect(parsed.name).toBe('findOne')
+  })
+})

package/src/__tests__/session.test.ts

@@ -0,0 +1,103 @@
+import { App } from '../app'
+import { Credentials } from '../credentials'
+
+describe('flowerbase-client session', () => {
+  const originalFetch = global.fetch
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  it('refreshes access token', 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({ access_token: 'access-2' })
+      }) 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 token = await app.currentUser!.refreshAccessToken()
+    expect(token).toBe('access-2')
+    expect(global.fetch).toHaveBeenLastCalledWith(
+      'http://localhost:3000/api/client/v2.0/auth/session',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer refresh' })
+      })
+    )
+  })
+
+  it('clears session when refresh fails', 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: false,
+        status: 401,
+        text: async () => JSON.stringify({ message: 'Invalid refresh token provided' })
+      }) 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'))
+
+    await expect(app.currentUser!.refreshAccessToken()).rejects.toThrow('Invalid refresh token provided')
+    expect(app.currentUser).toBeNull()
+  })
+
+  it('revokes session on logout', 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({ status: 'ok' })
+      }) 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'))
+    await app.currentUser!.logOut()
+
+    expect(global.fetch).toHaveBeenLastCalledWith(
+      'http://localhost:3000/api/client/v2.0/auth/session',
+      expect.objectContaining({ method: 'DELETE' })
+    )
+    expect(app.currentUser).toBeNull()
+  })
+})

package/src/__tests__/watch.test.ts

@@ -0,0 +1,138 @@
+import { App } from '../app'
+import { Credentials } from '../credentials'
+
+const streamFromLines = (lines: string[]) => {
+  const encoded = lines.map((line) => `${line}\n`).join('')
+  const bytes = new TextEncoder().encode(encoded)
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(bytes)
+      controller.close()
+    }
+  })
+}
+
+describe('flowerbase-client watch', () => {
+  const originalFetch = global.fetch
+
+  afterEach(() => {
+    jest.useRealTimers()
+    global.fetch = originalFetch
+  })
+
+  it('receives SSE events through watch iterator', 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: streamFromLines(['data: {"operationType":"insert","fullDocument":{"title":"A"}}', ''])
+      }) 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 iterator = app.currentUser!
+      .mongoClient('mongodb-atlas')
+      .db('testdb')
+      .collection('todos')
+      .watch()
+
+    const first = await iterator.next()
+    expect(first.done).toBe(false)
+    expect(first.value).toEqual({ operationType: 'insert', fullDocument: { title: 'A' } })
+
+    iterator.close()
+
+    const [url, request] = (global.fetch as jest.Mock).mock.calls[2]
+    expect(url).toContain('/functions/call?baas_request=')
+    expect(request.headers.Authorization).toBe('Bearer access')
+  })
+
+  it('closes iterator on return', 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' })
+      })
+      .mockResolvedValue({
+        ok: true,
+        body: streamFromLines([])
+      }) 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 iterator = app.currentUser!
+      .mongoClient('mongodb-atlas')
+      .db('testdb')
+      .collection('todos')
+      .watch()
+
+    iterator.close()
+    const result = await iterator.next()
+    expect(result.done).toBe(true)
+  })
+
+  it('reconnects with backoff after network errors', async () => {
+    jest.useFakeTimers()
+    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' })
+      })
+      .mockRejectedValueOnce(new Error('network'))
+      .mockResolvedValueOnce({
+        ok: true,
+        body: streamFromLines(['data: {"operationType":"update"}', ''])
+      }) 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 iterator = app.currentUser!
+      .mongoClient('mongodb-atlas')
+      .db('testdb')
+      .collection('todos')
+      .watch()
+
+    await jest.advanceTimersByTimeAsync(250)
+    const result = await iterator.next()
+
+    expect(result.done).toBe(false)
+    expect(result.value).toEqual({ operationType: 'update' })
+    expect((global.fetch as jest.Mock).mock.calls.length).toBeGreaterThanOrEqual(4)
+
+    iterator.close()
+  })
+})