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

package/src/http.ts

@@ -1,12 +1,94 @@
-export class FlowerbaseHttpError extends Error {
-  status: number
-  payload?: unknown
+type ParsedPayloadError = {
+  message?: string
+  error?: string
+  errorCode?: string
+  link?: string
+}
+
+const parsePayloadError = (payload: unknown): ParsedPayloadError => {
+  if (!payload || typeof payload !== 'object') return {}
+
+  const message = 'message' in payload && typeof payload.message === 'string' ? payload.message : undefined
+  const error = 'error' in payload && typeof payload.error === 'string' ? payload.error : undefined
+  const errorCode =
+    'error_code' in payload && typeof payload.error_code === 'string'
+      ? payload.error_code
+      : 'errorCode' in payload && typeof payload.errorCode === 'string'
+        ? payload.errorCode
+        : undefined
+  const link = 'link' in payload && typeof payload.link === 'string' ? payload.link : undefined
+
+  if (error) {
+    try {
+      const parsed = JSON.parse(error)
+      if (parsed && typeof parsed === 'object') {
+        const nestedMessage = 'message' in parsed && typeof parsed.message === 'string' ? parsed.message : undefined
+        const nestedErrorCode =
+          'error_code' in parsed && typeof parsed.error_code === 'string'
+            ? parsed.error_code
+            : 'errorCode' in parsed && typeof parsed.errorCode === 'string'
+              ? parsed.errorCode
+              : undefined
+        return {
+          message: nestedMessage ?? message ?? error,
+          error,
+          errorCode: nestedErrorCode ?? errorCode,
+          link
+        }
+      }
+    } catch {
+      // Keep original error text if it isn't JSON.
+    }
+  }
+
+  return {
+    message: message ?? error,
+    error,
+    errorCode,
+    link
+  }
+}
+
+export class MongoDBRealmError extends Error {
+  readonly method: string
+  readonly url: string
+  readonly statusCode: number
+  readonly statusText: string
+  readonly error: string | undefined
+  readonly errorCode: string | undefined
+  readonly link: string | undefined
+  readonly payload?: unknown
 
-  constructor(message: string, status: number, payload?: unknown) {
-    super(message)
+  constructor(params: {
+    method: string
+    url: string
+    statusCode: number
+    statusText: string
+    error?: string
+    errorCode?: string
+    link?: string
+    payload?: unknown
+  }) {
+    super(params.error || `${params.statusCode} ${params.statusText}`.trim())
+    this.name = 'MongoDBRealmError'
+    this.method = params.method
+    this.url = params.url
+    this.statusCode = params.statusCode
+    this.statusText = params.statusText
+    this.error = params.error
+    this.errorCode = params.errorCode
+    this.link = params.link
+    this.payload = params.payload
+  }
+}
+
+export class FlowerbaseHttpError extends MongoDBRealmError {
+  readonly status: number
+
+  constructor(params: ConstructorParameters<typeof MongoDBRealmError>[0]) {
+    super(params)
     this.name = 'FlowerbaseHttpError'
-    this.status = status
-    this.payload = payload
+    this.status = params.statusCode
   }
 }
 
@@ -61,31 +143,78 @@ export const requestJson = async <T = unknown>({
     const payload = await parseBody(response)
 
     if (!response.ok) {
-      let parsedErrorMessage: string | null = null
-      if (payload && typeof payload === 'object' && 'error' in payload && typeof payload.error === 'string') {
+      const parsedError = parsePayloadError(payload)
+      throw new FlowerbaseHttpError({
+        method,
+        url,
+        statusCode: response.status,
+        statusText: response.statusText,
+        error: parsedError.message ?? `HTTP ${response.status}`,
+        errorCode: parsedError.errorCode,
+        link: parsedError.link,
+        payload
+      })
+    }
+
+    return payload as T
+  } finally {
+    clear()
+  }
+}
+
+export const requestStream = async ({
+  url,
+  method = 'GET',
+  body,
+  bearerToken,
+  timeout
+}: RequestParams): Promise<AsyncIterable<Uint8Array>> => {
+  const { signal, clear } = timeoutSignal(timeout)
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {})
+      },
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      signal
+    })
+
+    if (!response.ok) {
+      const payload = await parseBody(response)
+      const parsedError = parsePayloadError(payload)
+      throw new FlowerbaseHttpError({
+        method,
+        url,
+        statusCode: response.status,
+        statusText: response.statusText,
+        error: parsedError.message ?? `HTTP ${response.status}`,
+        errorCode: parsedError.errorCode,
+        link: parsedError.link,
+        payload
+      })
+    }
+
+    if (!response.body) {
+      throw new Error('Response stream body is missing')
+    }
+
+    const reader = response.body.getReader()
+    return {
+      async *[Symbol.asyncIterator]() {
         try {
-          const parsed = JSON.parse(payload.error)
-          if (parsed && typeof parsed === 'object' && 'message' in parsed && typeof parsed.message === 'string') {
-            parsedErrorMessage = parsed.message
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value) yield value
           }
-        } catch {
-          parsedErrorMessage = null
+        } finally {
+          reader.releaseLock()
         }
       }
-
-      const message =
-        parsedErrorMessage ||
-        (payload && typeof payload === 'object' && 'message' in payload && typeof payload.message === 'string'
-          ? payload.message
-          : null) ||
-        (payload && typeof payload === 'object' && 'error' in payload && typeof payload.error === 'string'
-          ? payload.error
-          : null) ||
-        `HTTP ${response.status}`
-      throw new FlowerbaseHttpError(message, response.status, payload)
     }
-
-    return payload as T
   } finally {
     clear()
   }

package/src/index.ts

@@ -3,6 +3,7 @@ import { BSON, EJSON, ObjectId, ObjectID } from './bson'
 export { App } from './app'
 export { User } from './user'
 export { Credentials } from './credentials'
+export { MongoDBRealmError } from './http'
 export { BSON, EJSON, ObjectId, ObjectID }
 export type {
   AppConfig,

package/src/mongo.ts

@@ -20,7 +20,7 @@ const mapResult = (value: unknown) => {
   return deserialize(value)
 }
 
-export const createMongoClient = (app: App): MongoClientLike => ({
+export const createMongoClient = (app: App, serviceName: string, userId: string): MongoClientLike => ({
   db: (database: string) => ({
     collection: (collection: string): CollectionLike => {
       const callService = async (name: string, args: unknown[]) => {
@@ -31,21 +31,65 @@ export const createMongoClient = (app: App): MongoClientLike => ({
             ...serialize(args[0] ?? {}),
             ...(args[1] !== undefined ? { options: serialize(args[1]) } : {})
           }
-        ])
+        ], serviceName, userId)
         return mapResult(result)
       }
 
+      const normalizeWatchInput = (input?: unknown) => {
+        if (Array.isArray(input)) {
+          return { pipeline: input, options: {} }
+        }
+        if (input && typeof input === 'object' && ('ids' in input || 'filter' in input)) {
+          const typed = input as { ids?: unknown[]; filter?: Record<string, unknown>; [key: string]: unknown }
+          if (typed.ids && typed.filter) {
+            throw new Error('watch options cannot include both "ids" and "filter"')
+          }
+          const { ids, filter, ...options } = typed
+          if (ids) {
+            return {
+              pipeline: [{ $match: { 'documentKey._id': { $in: ids } } }],
+              options
+            }
+          }
+          if (filter) {
+            return {
+              pipeline: [{ $match: filter }],
+              options
+            }
+          }
+          return { pipeline: [], options }
+        }
+        if (input && typeof input === 'object' && ('pipeline' in input || 'options' in input)) {
+          const typed = input as { pipeline?: unknown[]; options?: Record<string, unknown> }
+          return {
+            pipeline: typed.pipeline ?? [],
+            options: typed.options ?? {}
+          }
+        }
+        return { pipeline: [], options: (input as Record<string, unknown> | undefined) ?? {} }
+      }
+
       return {
         find: (query = {}, options = {}) => callService('find', [{ query, options }]),
         findOne: (query = {}, options = {}) => callService('findOne', [{ query, options }]),
+        findOneAndUpdate: (filter, update, options = {}) =>
+          callService('findOneAndUpdate', [{ filter, update, options }]),
+        findOneAndReplace: (filter, replacement, options = {}) =>
+          callService('findOneAndReplace', [{ filter, replacement, options }]),
+        findOneAndDelete: (filter, options = {}) => callService('findOneAndDelete', [{ filter, options }]),
+        aggregate: (pipeline) => callService('aggregate', [{ pipeline }]),
+        count: (query = {}, options = {}) => callService('count', [{ query, options }]),
         insertOne: (document, options = {}) => callService('insertOne', [{ document, options }]),
+        insertMany: (documents, options = {}) => callService('insertMany', [{ documents, options }]),
         updateOne: (filter, update, options = {}) =>
           callService('updateOne', [{ filter, update, options }]),
         updateMany: (filter, update, options = {}) =>
           callService('updateMany', [{ filter, update, options }]),
         deleteOne: (filter, options = {}) => callService('deleteOne', [{ query: filter, options }]),
-        watch: (pipeline = [], options = {}) => {
-          const session = app.getSessionOrThrow()
+        deleteMany: (filter, options = {}) => callService('deleteMany', [{ query: filter, options }]),
+        watch: (input) => {
+          const { pipeline, options } = normalizeWatchInput(input)
+          const session = app.getSessionOrThrow(userId)
           return createWatchIterator({
             appId: app.id,
             baseUrl: app.baseUrl,

package/src/session.native.ts

@@ -1,4 +1,5 @@
 import { SessionData } from './types'
+import AsyncStorage from '@react-native-async-storage/async-storage'
 
 type StorageLike = {
   getItem: (key: string) => Promise<string | null>
@@ -8,17 +9,7 @@ type StorageLike = {
 
 const memoryStore = new Map<string, string>()
 
-const getAsyncStorage = (): StorageLike | null => {
-  try {
-    const req = (0, eval)('require') as (name: string) => unknown
-    const asyncStorageModule = req('@react-native-async-storage/async-storage') as {
-      default?: StorageLike
-    }
-    return asyncStorageModule?.default ?? null
-  } catch {
-    return null
-  }
-}
+const getAsyncStorage = (): StorageLike => AsyncStorage
 
 const parseSession = (raw: string | null): SessionData | null => {
   if (!raw) return null

package/src/session.ts

@@ -24,11 +24,15 @@ const getStorage = () => {
 
 export class SessionManager {
   private readonly key: string
+  private readonly usersKey: string
+  private readonly sessionsKey: string
   private readonly storage = getStorage()
   private session: SessionData | null = null
 
   constructor(appId: string) {
     this.key = `flowerbase:${appId}:session`
+    this.usersKey = `flowerbase:${appId}:users`
+    this.sessionsKey = `flowerbase:${appId}:sessions`
     this.session = this.load()
   }
 
@@ -56,4 +60,55 @@ export class SessionManager {
     this.session = null
     this.storage.removeItem(this.key)
   }
+
+  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 []
+    }
+  }
+
+  setUsersOrder(order: string[]) {
+    if (order.length === 0) {
+      this.storage.removeItem(this.usersKey)
+      return
+    }
+    this.storage.setItem(this.usersKey, JSON.stringify(order))
+  }
+
+  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>
+    }
+  }
+
+  setSessionsByUser(sessionsByUser: Record<string, SessionData>) {
+    if (Object.keys(sessionsByUser).length === 0) {
+      this.storage.removeItem(this.sessionsKey)
+      return
+    }
+    this.storage.setItem(this.sessionsKey, JSON.stringify(sessionsByUser))
+  }
 }

package/src/types.ts

@@ -1,6 +1,6 @@
 export type AppConfig = {
   id: string
-  baseUrl: string
+  baseUrl?: string
   timeout?: number
 }
 
@@ -8,6 +8,7 @@ export type CredentialsLike =
   | { provider: 'local-userpass'; email: string; password: string }
   | { provider: 'anon-user' }
   | { provider: 'custom-function'; payload: Record<string, unknown> }
+  | { provider: 'custom-token'; token: string }
 
 export type SessionData = {
   accessToken: string
@@ -47,7 +48,21 @@ export type WatchAsyncIterator<TChange = unknown> = AsyncIterableIterator<TChang
 export interface CollectionLike {
   find: (query?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
   findOne: (query?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  findOneAndUpdate: (
+    filter: Record<string, unknown>,
+    update: Record<string, unknown>,
+    options?: Record<string, unknown>
+  ) => Promise<unknown>
+  findOneAndReplace: (
+    filter: Record<string, unknown>,
+    replacement: Record<string, unknown>,
+    options?: Record<string, unknown>
+  ) => Promise<unknown>
+  findOneAndDelete: (filter: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  aggregate: (pipeline: Record<string, unknown>[]) => Promise<unknown>
+  count: (filter?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
   insertOne: (document: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  insertMany: (documents: Record<string, unknown>[], options?: Record<string, unknown>) => Promise<unknown>
   updateOne: (
     filter: Record<string, unknown>,
     update: Record<string, unknown>,
@@ -59,7 +74,8 @@ export interface CollectionLike {
     options?: Record<string, unknown>
   ) => Promise<unknown>
   deleteOne: (filter: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
-  watch: (pipeline?: unknown[], options?: Record<string, unknown>) => WatchAsyncIterator<unknown>
+  deleteMany: (filter: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  watch: (options?: unknown) => WatchAsyncIterator<unknown>
 }
 
 export interface MongoDbLike {
@@ -72,13 +88,27 @@ export interface MongoClientLike {
 
 export interface UserLike {
   id: string
+  state: 'active' | 'logged-out' | 'removed'
+  isLoggedIn: boolean
+  accessToken: string | null
+  refreshToken: string | null
+  providerType: string | null
+  identities: unknown[]
+  customData: Record<string, unknown>
   profile?: {
     email?: string
     [key: string]: unknown
   }
-  functions: Record<string, (...args: unknown[]) => Promise<unknown>>
+  functions: Record<string, (...args: unknown[]) => Promise<unknown>> & {
+    callFunction: (name: string, ...args: unknown[]) => Promise<unknown>
+    callFunctionStreaming: (name: string, ...args: unknown[]) => Promise<AsyncIterable<Uint8Array>>
+  }
   logOut: () => Promise<void>
+  callFunction: (name: string, ...args: unknown[]) => Promise<unknown>
   refreshAccessToken: () => Promise<string>
-  refreshCustomData: () => Promise<ProfileData>
+  refreshCustomData: () => Promise<Record<string, unknown>>
   mongoClient: (serviceName: string) => MongoClientLike
+  addListener: (callback: () => void) => void
+  removeListener: (callback: () => void) => void
+  removeAllListeners: () => void
 }

package/src/user.ts

@@ -1,39 +1,150 @@
 import type { App } from './app'
 import { createFunctionsProxy } from './functions'
 import { createMongoClient } from './mongo'
-import { MongoClientLike, ProfileData, UserLike } from './types'
+import { MongoClientLike, UserLike } from './types'
 
 export class User implements UserLike {
-  id: string
+  readonly id: string
+  customData: Record<string, unknown> = {}
   profile?: { email?: string;[key: string]: unknown }
   private readonly app: App
+  private _providerType: string | null = null
+  private readonly listeners = new Set<() => void>()
 
-  functions: Record<string, (...args: unknown[]) => Promise<unknown>>
+  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) {
     this.app = app
     this.id = id
-    this.functions = createFunctionsProxy((name, args) => this.app.callFunction(name, args))
+    this.functions = 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 ?? []
+  }
+
+  private resolveCustomDataFromToken() {
+    const payload = this.decodeAccessTokenPayload()
+    if (!payload) return {}
+    return (
+      'user_data' in payload && payload.user_data && typeof payload.user_data === 'object'
+        ? (payload.user_data as Record<string, unknown>)
+        : 'userData' in payload && payload.userData && typeof payload.userData === 'object'
+          ? (payload.userData as Record<string, unknown>)
+          : 'custom_data' in payload && payload.custom_data && typeof payload.custom_data === 'object'
+            ? (payload.custom_data as Record<string, unknown>)
+            : {}
+    )
+  }
+
+  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: string) {
+    this._providerType = providerType
+  }
+
+  private 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: string) => {
+      if (typeof atob === 'function') return atob(input)
+      const runtimeBuffer = (globalThis as { Buffer?: { from: (data: string, encoding: string) => { toString: (enc: string) => string } } }).Buffer
+      if (runtimeBuffer) return runtimeBuffer.from(input, 'base64').toString('utf8')
+      return ''
+    }
+
+    try {
+      const decoded = decodeBase64(base64)
+      return JSON.parse(decoded) as Record<string, unknown>
+    } catch {
+      return null
+    }
   }
 
   async logOut() {
-    await this.app.logoutUser()
+    await this.app.logoutUser(this.id)
+  }
+
+  async callFunction(name: string, ...args: unknown[]) {
+    return this.app.callFunction(name, args, this.id)
   }
 
   async refreshAccessToken() {
-    return this.app.refreshAccessToken()
+    const accessToken = await this.app.refreshAccessToken(this.id)
+    this.customData = this.resolveCustomDataFromToken()
+    return accessToken
   }
 
-  async refreshCustomData(): Promise<ProfileData> {
-    const profile = await this.app.getProfile()
+  async refreshCustomData(): Promise<Record<string, unknown>> {
+    const profile = await this.app.getProfile(this.id)
     this.profile = profile.data
-    return profile.custom_data || {}
+    this.customData = (profile.custom_data && typeof profile.custom_data === 'object'
+      ? profile.custom_data
+      : this.resolveCustomDataFromToken()) as Record<string, unknown>
+    this.notifyListeners()
+    return this.customData
   }
 
   mongoClient(serviceName: string): MongoClientLike {
-    if (serviceName !== 'mongodb-atlas') {
-      throw new Error(`Unsupported service "${serviceName}"`)
+    return createMongoClient(this.app, serviceName, this.id)
+  }
+
+  addListener(callback: () => void) {
+    this.listeners.add(callback)
+  }
+
+  removeListener(callback: () => void) {
+    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 createMongoClient(this.app)
   }
 }