@flowerforce/flowerbase-client 0.3.0 → 0.3.1-beta.1

package/src/__tests__/mongo.test.ts

@@ -39,14 +39,14 @@ describe('flowerbase-client mongo service wrapper', () => {
 
     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(url).toBe('http://localhost:3000/api/client/v2.0/app/my-app/functions/call?col=todos-findOne')
     expect(request.method).toBe('POST')
     const parsed = JSON.parse(request.body)
     expect(parsed.service).toBe('mongodb-atlas')
     expect(parsed.name).toBe('findOne')
   })
 
-  it('supports extended CRUD operations and custom service name', async () => {
+  it('supports extended CRUD operations on mongodb-atlas', async () => {
     global.fetch = jest
       .fn()
       .mockResolvedValueOnce({
@@ -65,7 +65,7 @@ describe('flowerbase-client mongo service wrapper', () => {
     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')
+    const collection = app.currentUser!.mongoClient('mongodb-atlas').db('testdb').collection('todos')
 
     await collection.findOneAndUpdate({ done: false }, { $set: { done: true } })
     await collection.findOneAndReplace({ done: true }, { done: true, title: 'done' })
@@ -77,7 +77,7 @@ describe('flowerbase-client mongo service wrapper', () => {
 
     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.service).toBe('mongodb-atlas')
     expect(lastBody.name).toBe('deleteMany')
   })
 })

package/src/app.ts

@@ -1,8 +1,16 @@
+import { Credentials } from './credentials'
 import { normalizeFunctionResponse } from './functions'
 import { FlowerbaseHttpError, requestJson, requestStream } from './http'
 import { SessionManager } from './session'
-import { AppConfig, CredentialsLike, FunctionCallPayload, ProfileData, SessionData } from './types'
-import { Credentials } from './credentials'
+import {
+  AppConfig,
+  CredentialsLike,
+  FunctionCallPayload,
+  MongoDbServiceArguments,
+  MongoDbServiceName,
+  ProfileData,
+  SessionData
+} from './types'
 import { User } from './user'
 
 const API_PREFIX = '/api/client/v2.0'
@@ -43,7 +51,11 @@ export class App {
       passwordOrArg?: string,
       ...args: unknown[]
     ) => Promise<unknown>
-    resetPassword: (input: { token: string; tokenId: string; password: string }) => Promise<unknown>
+    resetPassword: (input: {
+      token: string
+      tokenId: string
+      password: string
+    }) => Promise<unknown>
   }
 
   constructor(idOrConfig: string | AppConfig) {
@@ -52,29 +64,8 @@ export class App {
     this.baseUrl = (config.baseUrl ?? '').replace(/\/$/, '')
     this.timeout = config.timeout ?? 10000
     this.sessionManager = new SessionManager(this.id)
-    const persistedSessionsByUser = this.sessionManager.getSessionsByUser()
-    for (const [userId, session] of Object.entries(persistedSessionsByUser)) {
-      this.sessionsByUserId.set(userId, session)
-    }
-    this.usersOrder = this.sessionManager.getUsersOrder()
-    for (const userId of this.sessionsByUserId.keys()) {
-      if (!this.usersOrder.includes(userId)) {
-        this.usersOrder.push(userId)
-      }
-    }
-    for (const userId of this.usersOrder) {
-      this.getOrCreateUser(userId)
-    }
-
-    const currentSession = this.sessionManager.get()
-    if (currentSession?.userId) {
-      this.sessionsByUserId.set(currentSession.userId, currentSession)
-      this.getOrCreateUser(currentSession.userId)
-      this.touchUser(currentSession.userId)
-      this.persistSessionsByUser()
-    } else {
-      this.setCurrentSessionFromOrder()
-    }
+    this.restorePersistedUsers()
+    this.restoreCurrentSession()
     this.sessionBootstrapPromise = this.bootstrapSessionOnLoad()
 
     this.emailPasswordAuth = {
@@ -144,19 +135,62 @@ export class App {
     }
 
     const users = Object.fromEntries(
-      [...activeUsers, ...loggedOutUsers].map((userId) => [userId, this.usersById.get(userId)!])
+      [...activeUsers, ...loggedOutUsers].map((userId) => [
+        userId,
+        this.usersById.get(userId)!
+      ])
     )
     return users
   }
 
   private persistSessionsByUser() {
-    this.sessionManager.setSessionsByUser(Object.fromEntries(this.sessionsByUserId.entries()))
+    this.sessionManager.setSessionsByUser(
+      Object.fromEntries(this.sessionsByUserId.entries())
+    )
   }
 
   private persistUsersOrder() {
     this.sessionManager.setUsersOrder(this.usersOrder)
   }
 
+  private restorePersistedUsers() {
+    const persistedSessionsByUser = this.sessionManager.getSessionsByUser()
+    for (const [userId, session] of Object.entries(persistedSessionsByUser)) {
+      this.sessionsByUserId.set(userId, session)
+    }
+
+    const persistedOrder = this.sessionManager.getUsersOrder()
+    const nextUsersOrder: string[] = []
+    for (const userId of persistedOrder) {
+      if (!nextUsersOrder.includes(userId)) {
+        nextUsersOrder.push(userId)
+      }
+    }
+    for (const userId of this.sessionsByUserId.keys()) {
+      if (!nextUsersOrder.includes(userId)) {
+        nextUsersOrder.push(userId)
+      }
+    }
+    this.usersOrder = nextUsersOrder
+
+    for (const userId of this.usersOrder) {
+      this.getOrCreateUser(userId)
+    }
+  }
+
+  private restoreCurrentSession() {
+    const currentSession = this.sessionManager.get()
+    if (currentSession?.userId) {
+      this.sessionsByUserId.set(currentSession.userId, currentSession)
+      this.getOrCreateUser(currentSession.userId)
+      this.touchUser(currentSession.userId)
+      this.persistSessionsByUser()
+      return
+    }
+
+    this.setCurrentSessionFromOrder()
+  }
+
   private touchUser(userId: string) {
     this.usersOrder = [userId, ...this.usersOrder.filter((id) => id !== userId)]
     this.persistUsersOrder()
@@ -225,8 +259,12 @@ export class App {
   }
 
   private async bootstrapSessionOnLoad(): Promise<void> {
+    await this.sessionManager.whenReady()
+    this.restorePersistedUsers()
+    this.restoreCurrentSession()
+
     const session = this.sessionManager.get()
-    if (!session || typeof localStorage === 'undefined') {
+    if (!session || !this.sessionManager.hasPersistentStorage()) {
       return
     }
 
@@ -293,17 +331,24 @@ export class App {
     }
 
     if (credentials.provider === 'custom-function') {
-      const result = await this.postProvider<LoginResponse>('/custom-function/login', credentials.payload)
+      const result = await this.postProvider<LoginResponse>(
+        '/custom-function/login',
+        credentials.payload
+      )
       return this.setLoggedInUser(result, 'custom-function')
     }
 
     if (credentials.provider === 'custom-token') {
-      const result = await this.postProvider<LoginResponse>('/custom-token/login', { token: credentials.token })
+      const result = await this.postProvider<LoginResponse>('/custom-token/login', {
+        token: credentials.token
+      })
       return this.setLoggedInUser(result, 'custom-token')
     }
 
     const unsupportedProvider: never = credentials
-    throw new Error(`Unsupported credentials provider: ${JSON.stringify(unsupportedProvider)}`)
+    throw new Error(
+      `Unsupported credentials provider: ${JSON.stringify(unsupportedProvider)}`
+    )
   }
 
   switchUser(nextUser: User) {
@@ -336,13 +381,14 @@ export class App {
   }
 
   async deleteUser(user: User) {
-    await this.requestWithAccessToken((accessToken) =>
-      requestJson({
-        url: this.authUrl('/delete'),
-        method: 'DELETE',
-        bearerToken: accessToken,
-        timeout: this.timeout
-      }),
+    await this.requestWithAccessToken(
+      (accessToken) =>
+        requestJson({
+          url: this.authUrl('/delete'),
+          method: 'DELETE',
+          bearerToken: accessToken,
+          timeout: this.timeout
+        }),
       user.id
     )
     await this.removeUser(user)
@@ -350,7 +396,9 @@ export class App {
 
   getSessionOrThrow(userId?: string) {
     const targetUserId = userId ?? this.currentUser?.id
-    const session = targetUserId ? this.sessionsByUserId.get(targetUserId) : this.sessionManager.get()
+    const session = targetUserId
+      ? this.sessionsByUserId.get(targetUserId)
+      : this.sessionManager.get()
     if (!session) {
       throw new Error('User is not authenticated')
     }
@@ -381,7 +429,10 @@ export class App {
     })
   }
 
-  private async requestWithAccessToken<T>(operation: (accessToken: string) => Promise<T>, userId?: string) {
+  private async requestWithAccessToken<T>(
+    operation: (accessToken: string) => Promise<T>,
+    userId?: string
+  ) {
     const firstSession = this.getSessionOrThrow(userId)
     try {
       return await operation(firstSession.accessToken)
@@ -402,21 +453,26 @@ export class App {
       arguments: args
     }
 
-    const result = await this.requestWithAccessToken((accessToken) =>
-      requestJson<unknown>({
-        url: this.functionsUrl('/call'),
-        method: 'POST',
-        body: payload,
-        bearerToken: accessToken,
-        timeout: this.timeout
-      }),
+    const result = await this.requestWithAccessToken(
+      (accessToken) =>
+        requestJson<unknown>({
+          url: this.functionsUrl(`/call?func=${name}`),
+          method: 'POST',
+          body: payload,
+          bearerToken: accessToken,
+          timeout: this.timeout
+        }),
       userId
     )
 
     return normalizeFunctionResponse(result)
   }
 
-  async callFunctionStreaming(name: string, args: unknown[], userId?: string): Promise<AsyncIterable<Uint8Array>> {
+  async callFunctionStreaming(
+    name: string,
+    args: unknown[],
+    userId?: string
+  ): Promise<AsyncIterable<Uint8Array>> {
     await this.ensureSessionBootstrapped()
     const payload: FunctionCallPayload = {
       name,
@@ -443,7 +499,11 @@ export class App {
               timeout
             })
           } catch (error) {
-            if (!didRefresh && error instanceof FlowerbaseHttpError && error.status === 401) {
+            if (
+              !didRefresh &&
+              error instanceof FlowerbaseHttpError &&
+              error.status === 401
+            ) {
               await refreshSession()
               didRefresh = true
               continue
@@ -457,7 +517,11 @@ export class App {
             }
             return
           } catch (error) {
-            if (!didRefresh && error instanceof FlowerbaseHttpError && error.status === 401) {
+            if (
+              !didRefresh &&
+              error instanceof FlowerbaseHttpError &&
+              error.status === 401
+            ) {
               await refreshSession()
               didRefresh = true
               continue
@@ -469,7 +533,12 @@ export class App {
     }
   }
 
-  async callService(name: string, args: unknown[], service = 'mongodb-atlas', userId?: string) {
+  async callService(
+    name: string,
+    args: MongoDbServiceArguments,
+    service: MongoDbServiceName = 'mongodb-atlas',
+    userId?: string
+  ) {
     await this.ensureSessionBootstrapped()
     const payload: FunctionCallPayload = {
       name,
@@ -477,27 +546,29 @@ export class App {
       arguments: args
     }
 
-    return this.requestWithAccessToken((accessToken) =>
-      requestJson<unknown>({
-        url: this.functionsUrl('/call'),
-        method: 'POST',
-        body: payload,
-        bearerToken: accessToken,
-        timeout: this.timeout
-      }),
+    return this.requestWithAccessToken(
+      (accessToken) =>
+        requestJson<unknown>({
+          url: this.functionsUrl(`/call?col=${args[0].collection}-${name}`),
+          method: 'POST',
+          body: payload,
+          bearerToken: accessToken,
+          timeout: this.timeout
+        }),
       userId
     )
   }
 
   async getProfile(userId?: string): Promise<ProfileData> {
     await this.ensureSessionBootstrapped()
-    const profile = await this.requestWithAccessToken((accessToken) =>
-      requestJson<ProfileData>({
-        url: this.authUrl('/profile'),
-        method: 'GET',
-        bearerToken: accessToken,
-        timeout: this.timeout
-      }),
+    const profile = await this.requestWithAccessToken(
+      (accessToken) =>
+        requestJson<ProfileData>({
+          url: this.authUrl('/profile'),
+          method: 'GET',
+          bearerToken: accessToken,
+          timeout: this.timeout
+        }),
       userId
     )
     const session = this.getSessionOrThrow(userId)

package/src/mongo.ts

@@ -1,6 +1,6 @@
 import type { App } from './app'
 import { EJSON } from './bson'
-import { CollectionLike, MongoClientLike } from './types'
+import { CollectionLike, MongoClientLike, MongoDbServiceName } from './types'
 import { createWatchIterator } from './watch'
 
 const serialize = (value: unknown) => EJSON.serialize(value, { relaxed: false })
@@ -20,7 +20,7 @@ const mapResult = (value: unknown) => {
   return deserialize(value)
 }
 
-export const createMongoClient = (app: App, serviceName: string, userId: string): MongoClientLike => ({
+export const createMongoClient = (app: App, serviceName: MongoDbServiceName, userId: string): MongoClientLike => ({
   db: (database: string) => ({
     collection: (collection: string): CollectionLike => {
       const callService = async (name: string, args: unknown[]) => {

package/src/session.ts

@@ -1,24 +1,48 @@
+import { createStorage } from './storage'
 import { SessionData } from './types'
 
-const memoryStore = new Map<string, string>()
+const parseSession = (raw: string | null): SessionData | null => {
+  if (!raw) return null
 
-const getStorage = () => {
-  if (typeof localStorage !== 'undefined') {
-    return {
-      getItem: (key: string) => localStorage.getItem(key),
-      setItem: (key: string, value: string) => localStorage.setItem(key, value),
-      removeItem: (key: string) => localStorage.removeItem(key)
-    }
+  try {
+    return JSON.parse(raw) as SessionData
+  } catch {
+    return null
+  }
+}
+
+const parseUsersOrder = (raw: string | null) => {
+  if (!raw) return []
+
+  try {
+    const parsed = JSON.parse(raw)
+    if (!Array.isArray(parsed)) return []
+    return parsed.filter((item): item is string => typeof item === 'string')
+  } catch {
+    return []
   }
+}
 
-  return {
-    getItem: (key: string) => memoryStore.get(key) ?? null,
-    setItem: (key: string, value: string) => {
-      memoryStore.set(key, value)
-    },
-    removeItem: (key: string) => {
-      memoryStore.delete(key)
+const parseSessionsByUser = (raw: string | null) => {
+  if (!raw) return {} as Record<string, SessionData>
+
+  try {
+    const parsed = JSON.parse(raw) as Record<string, SessionData>
+    const normalized: Record<string, SessionData> = {}
+    for (const [userId, session] of Object.entries(parsed)) {
+      if (
+        session &&
+        typeof session === 'object' &&
+        typeof session.accessToken === 'string' &&
+        typeof session.refreshToken === 'string' &&
+        typeof session.userId === 'string'
+      ) {
+        normalized[userId] = session
+      }
     }
+    return normalized
+  } catch {
+    return {} as Record<string, SessionData>
   }
 }
 
@@ -26,25 +50,35 @@ export class SessionManager {
   private readonly key: string
   private readonly usersKey: string
   private readonly sessionsKey: string
-  private readonly storage = getStorage()
+  private readonly storage = createStorage()
+  private readonly hydrationPromise: Promise<void>
   private session: SessionData | null = null
+  private usersOrder: string[] = []
+  private sessionsByUser: Record<string, SessionData> = {}
 
   constructor(appId: string) {
     this.key = `flowerbase:${appId}:session`
     this.usersKey = `flowerbase:${appId}:users`
     this.sessionsKey = `flowerbase:${appId}:sessions`
-    this.session = this.load()
+    this.session = parseSession(this.storage.getItem(this.key))
+    this.usersOrder = parseUsersOrder(this.storage.getItem(this.usersKey))
+    this.sessionsByUser = parseSessionsByUser(this.storage.getItem(this.sessionsKey))
+    this.hydrationPromise = this.hydrate()
   }
 
-  load(): SessionData | null {
-    const raw = this.storage.getItem(this.key)
-    if (!raw) return null
+  private async hydrate() {
+    const hydrated = await this.storage.hydrate([this.key, this.usersKey, this.sessionsKey])
+    this.session = parseSession(hydrated[this.key] ?? null)
+    this.usersOrder = parseUsersOrder(hydrated[this.usersKey] ?? null)
+    this.sessionsByUser = parseSessionsByUser(hydrated[this.sessionsKey] ?? null)
+  }
 
-    try {
-      return JSON.parse(raw) as SessionData
-    } catch {
-      return null
-    }
+  whenReady() {
+    return this.hydrationPromise
+  }
+
+  hasPersistentStorage() {
+    return this.storage.isPersistent
   }
 
   get() {
@@ -62,18 +96,11 @@ export class SessionManager {
   }
 
   getUsersOrder() {
-    const raw = this.storage.getItem(this.usersKey)
-    if (!raw) return []
-    try {
-      const parsed = JSON.parse(raw)
-      if (!Array.isArray(parsed)) return []
-      return parsed.filter((item): item is string => typeof item === 'string')
-    } catch {
-      return []
-    }
+    return [...this.usersOrder]
   }
 
   setUsersOrder(order: string[]) {
+    this.usersOrder = [...order]
     if (order.length === 0) {
       this.storage.removeItem(this.usersKey)
       return
@@ -82,29 +109,11 @@ export class SessionManager {
   }
 
   getSessionsByUser() {
-    const raw = this.storage.getItem(this.sessionsKey)
-    if (!raw) return {} as Record<string, SessionData>
-    try {
-      const parsed = JSON.parse(raw) as Record<string, SessionData>
-      const normalized: Record<string, SessionData> = {}
-      for (const [userId, session] of Object.entries(parsed)) {
-        if (
-          session &&
-          typeof session === 'object' &&
-          typeof session.accessToken === 'string' &&
-          typeof session.refreshToken === 'string' &&
-          typeof session.userId === 'string'
-        ) {
-          normalized[userId] = session
-        }
-      }
-      return normalized
-    } catch {
-      return {} as Record<string, SessionData>
-    }
+    return { ...this.sessionsByUser }
   }
 
   setSessionsByUser(sessionsByUser: Record<string, SessionData>) {
+    this.sessionsByUser = { ...sessionsByUser }
     if (Object.keys(sessionsByUser).length === 0) {
       this.storage.removeItem(this.sessionsKey)
       return

package/src/storage.native.ts

@@ -0,0 +1,49 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+
+type StorageSnapshot = Record<string, string | null>
+
+export type PersistedStorage = {
+  isPersistent: boolean
+  getItem: (key: string) => string | null
+  setItem: (key: string, value: string) => void
+  removeItem: (key: string) => void
+  hydrate: (keys: string[]) => Promise<StorageSnapshot>
+}
+
+const memoryStore = new Map<string, string>()
+
+const getSnapshot = (keys: string[]): StorageSnapshot =>
+  Object.fromEntries(keys.map((key) => [key, memoryStore.get(key) ?? null]))
+
+export const createStorage = (): PersistedStorage => ({
+  isPersistent: true,
+  getItem: (key) => memoryStore.get(key) ?? null,
+  setItem: (key, value) => {
+    memoryStore.set(key, value)
+    void AsyncStorage.setItem(key, value).catch(() => {
+      // Ignore write failures and keep the in-memory cache alive.
+    })
+  },
+  removeItem: (key) => {
+    memoryStore.delete(key)
+    void AsyncStorage.removeItem(key).catch(() => {
+      // Ignore delete failures and keep the in-memory cache alive.
+    })
+  },
+  async hydrate(keys) {
+    try {
+      const entries = await AsyncStorage.multiGet(keys)
+      for (const [key, value] of entries) {
+        if (value === null) {
+          memoryStore.delete(key)
+          continue
+        }
+        memoryStore.set(key, value)
+      }
+    } catch {
+      // Ignore storage read failures and keep the in-memory cache alive.
+    }
+
+    return getSnapshot(keys)
+  }
+})

package/src/storage.ts

@@ -0,0 +1,57 @@
+type StorageSnapshot = Record<string, string | null>
+
+export type PersistedStorage = {
+  isPersistent: boolean
+  getItem: (key: string) => string | null
+  setItem: (key: string, value: string) => void
+  removeItem: (key: string) => void
+  hydrate: (keys: string[]) => Promise<StorageSnapshot>
+}
+
+const memoryStore = new Map<string, string>()
+
+const getStorage = () => {
+  const browserStorage = globalThis.localStorage
+  if (
+    browserStorage &&
+    typeof browserStorage.getItem === 'function' &&
+    typeof browserStorage.setItem === 'function' &&
+    typeof browserStorage.removeItem === 'function'
+  ) {
+    return {
+      getItem: (key: string) => browserStorage.getItem(key),
+      setItem: (key: string, value: string) => browserStorage.setItem(key, value),
+      removeItem: (key: string) => browserStorage.removeItem(key)
+    }
+  }
+
+  return {
+    getItem: (key: string) => memoryStore.get(key) ?? null,
+    setItem: (key: string, value: string) => {
+      memoryStore.set(key, value)
+    },
+    removeItem: (key: string) => {
+      memoryStore.delete(key)
+    }
+  }
+}
+
+export const createStorage = (): PersistedStorage => {
+  const browserStorage = globalThis.localStorage
+  const isPersistent =
+    !!browserStorage &&
+    typeof browserStorage.getItem === 'function' &&
+    typeof browserStorage.setItem === 'function' &&
+    typeof browserStorage.removeItem === 'function'
+  const storage = getStorage()
+
+  return {
+    isPersistent,
+    getItem: storage.getItem,
+    setItem: storage.setItem,
+    removeItem: storage.removeItem,
+    async hydrate(keys) {
+      return Object.fromEntries(keys.map((key) => [key, storage.getItem(key)]))
+    }
+  }
+}