@flowerforce/flowerbase-client 0.1.0

package/src/http.ts

@@ -0,0 +1,221 @@
+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(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 = params.statusCode
+  }
+}
+
+type RequestParams = {
+  url: string
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+  body?: unknown
+  bearerToken?: string
+  timeout?: number
+}
+
+const parseBody = async (response: Response) => {
+  const text = await response.text()
+  if (!text) return null
+
+  try {
+    return JSON.parse(text)
+  } catch {
+    return text
+  }
+}
+
+const timeoutSignal = (timeout = 10000) => {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeout)
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timer)
+  }
+}
+
+export const requestJson = async <T = unknown>({
+  url,
+  method = 'GET',
+  body,
+  bearerToken,
+  timeout
+}: RequestParams): Promise<T> => {
+  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
+    })
+
+    const payload = await parseBody(response)
+
+    if (!response.ok) {
+      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 {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value) yield value
+          }
+        } finally {
+          reader.releaseLock()
+        }
+      }
+    }
+  } finally {
+    clear()
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+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,
+  CredentialsLike,
+  UserLike,
+  MongoClientLike,
+  CollectionLike,
+  WatchAsyncIterator
+} from './types'

package/src/mongo.ts

@@ -0,0 +1,112 @@
+import type { App } from './app'
+import { EJSON } from './bson'
+import { CollectionLike, MongoClientLike } from './types'
+import { createWatchIterator } from './watch'
+
+const serialize = (value: unknown) => EJSON.serialize(value, { relaxed: false })
+const deserialize = <T>(value: T): T => {
+  if (!value || typeof value !== 'object') return value
+  return EJSON.deserialize(value as Record<string, unknown>) as T
+}
+
+const mapResult = (value: unknown) => {
+  if (typeof value === 'string') {
+    try {
+      return deserialize(JSON.parse(value))
+    } catch {
+      return value
+    }
+  }
+  return deserialize(value)
+}
+
+export const createMongoClient = (app: App, serviceName: string, userId: string): MongoClientLike => ({
+  db: (database: string) => ({
+    collection: (collection: string): CollectionLike => {
+      const callService = async (name: string, args: unknown[]) => {
+        const result = await app.callService(name, [
+          {
+            database,
+            collection,
+            ...serialize(args[0] ?? {}),
+            ...(args[1] !== undefined ? { options: serialize(args[1]) } : {})
+          }
+        ], serviceName, userId)
+        return mapResult(result)
+      }
+
+      const normalizeWatchInput = (input?: unknown) => {
+        if (typeof input === 'undefined') {
+          return { filter: undefined, ids: undefined }
+        }
+        if (Array.isArray(input)) {
+          throw new Error('watch accepts only an options object with "filter" or "ids"')
+        }
+        if (!input || typeof input !== 'object') {
+          throw new Error('watch options must be an object')
+        }
+
+        const typed = input as { ids?: unknown[]; filter?: Record<string, unknown>; [key: string]: unknown }
+        const keys = Object.keys(typed)
+        const hasOnlyAllowedKeys = keys.every((key) => key === 'ids' || key === 'filter')
+        if (!hasOnlyAllowedKeys) {
+          throw new Error('watch options support only "filter" or "ids"')
+        }
+        if (typed.ids || typed.filter) {
+          if (typed.ids && typed.filter) {
+            throw new Error('watch options cannot include both "ids" and "filter"')
+          }
+          const { ids, filter } = typed
+          if (filter && typeof filter === 'object' && '$match' in filter) {
+            throw new Error('watch filter must be a query object, not a $match stage')
+          }
+          if (ids) {
+            if (!Array.isArray(ids)) {
+              throw new Error('watch ids must be an array')
+            }
+            return { filter: undefined, ids }
+          }
+          if (filter) {
+            return { filter, ids: undefined }
+          }
+          return { filter: undefined, ids: undefined }
+        }
+        throw new Error('watch options must include "filter" or "ids"')
+      }
+
+      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 }]),
+        deleteMany: (filter, options = {}) => callService('deleteMany', [{ query: filter, options }]),
+        watch: (options) => {
+          const { filter, ids } = normalizeWatchInput(options)
+          const session = app.getSessionOrThrow(userId)
+          return createWatchIterator({
+            appId: app.id,
+            baseUrl: app.baseUrl,
+            accessToken: session.accessToken,
+            database,
+            collection,
+            filter,
+            ids,
+            timeout: app.timeout
+          })
+        }
+      }
+    }
+  })
+})

package/src/session.native.ts

@@ -0,0 +1,89 @@
+import { SessionData } from './types'
+import AsyncStorage from '@react-native-async-storage/async-storage'
+
+type StorageLike = {
+  getItem: (key: string) => Promise<string | null>
+  setItem: (key: string, value: string) => Promise<void>
+  removeItem: (key: string) => Promise<void>
+}
+
+const memoryStore = new Map<string, string>()
+
+const getAsyncStorage = (): StorageLike => AsyncStorage
+
+const parseSession = (raw: string | null): SessionData | null => {
+  if (!raw) return null
+  try {
+    return JSON.parse(raw) as SessionData
+  } catch {
+    return null
+  }
+}
+
+export class SessionManager {
+  private readonly key: string
+  private session: SessionData | null = null
+  private readonly asyncStorage = getAsyncStorage()
+  private hydrationPromise: Promise<void> | null = null
+
+  constructor(appId: string) {
+    this.key = `flowerbase:${appId}:session`
+    this.session = this.load()
+    void this.hydrateFromAsyncStorage()
+  }
+
+  private hydrateFromAsyncStorage() {
+    if (!this.asyncStorage) {
+      return Promise.resolve()
+    }
+
+    if (this.hydrationPromise) {
+      return this.hydrationPromise
+    }
+
+    this.hydrationPromise = this.asyncStorage
+      .getItem(this.key)
+      .then((raw) => {
+        const parsed = parseSession(raw)
+        if (!parsed) return
+        this.session = parsed
+        memoryStore.set(this.key, JSON.stringify(parsed))
+      })
+      .catch(() => {
+        // Ignore storage read failures and keep memory fallback.
+      })
+
+    return this.hydrationPromise
+  }
+
+  load(): SessionData | null {
+    return parseSession(memoryStore.get(this.key) ?? null)
+  }
+
+  get() {
+    return this.session
+  }
+
+  set(session: SessionData) {
+    this.session = session
+    const raw = JSON.stringify(session)
+    memoryStore.set(this.key, raw)
+
+    if (this.asyncStorage) {
+      void this.asyncStorage.setItem(this.key, raw).catch(() => {
+        // Ignore write failures and keep memory fallback.
+      })
+    }
+  }
+
+  clear() {
+    this.session = null
+    memoryStore.delete(this.key)
+
+    if (this.asyncStorage) {
+      void this.asyncStorage.removeItem(this.key).catch(() => {
+        // Ignore delete failures and keep memory fallback.
+      })
+    }
+  }
+}

package/src/session.ts

@@ -0,0 +1,114 @@
+import { SessionData } from './types'
+
+const memoryStore = new Map<string, string>()
+
+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)
+    }
+  }
+
+  return {
+    getItem: (key: string) => memoryStore.get(key) ?? null,
+    setItem: (key: string, value: string) => {
+      memoryStore.set(key, value)
+    },
+    removeItem: (key: string) => {
+      memoryStore.delete(key)
+    }
+  }
+}
+
+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()
+  }
+
+  load(): SessionData | null {
+    const raw = this.storage.getItem(this.key)
+    if (!raw) return null
+
+    try {
+      return JSON.parse(raw) as SessionData
+    } catch {
+      return null
+    }
+  }
+
+  get() {
+    return this.session
+  }
+
+  set(session: SessionData) {
+    this.session = session
+    this.storage.setItem(this.key, JSON.stringify(session))
+  }
+
+  clear() {
+    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

@@ -0,0 +1,114 @@
+export type AppConfig = {
+  id: string
+  baseUrl?: string
+  timeout?: number
+}
+
+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
+  refreshToken: string
+  userId: string
+}
+
+export type ProfileData = {
+  _id?: string
+  identities?: unknown[]
+  type?: string
+  custom_data?: Record<string, unknown>
+  data?: Record<string, unknown>
+}
+
+export type FunctionCallPayload = {
+  name: string
+  arguments: unknown[]
+  service?: string
+}
+
+export type WatchConfig = {
+  appId: string
+  baseUrl: string
+  accessToken: string
+  database: string
+  collection: string
+  filter?: Record<string, unknown>
+  ids?: unknown[]
+  timeout?: number
+}
+
+export type WatchAsyncIterator<TChange = unknown> = AsyncIterableIterator<TChange> & {
+  close: () => void
+}
+
+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>,
+    options?: Record<string, unknown>
+  ) => Promise<unknown>
+  updateMany: (
+    filter: Record<string, unknown>,
+    update: Record<string, unknown>,
+    options?: Record<string, unknown>
+  ) => Promise<unknown>
+  deleteOne: (filter: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  deleteMany: (filter: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>
+  watch: (options?: unknown) => WatchAsyncIterator<unknown>
+}
+
+export interface MongoDbLike {
+  collection: (name: string) => CollectionLike
+}
+
+export interface MongoClientLike {
+  db: (name: string) => MongoDbLike
+}
+
+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>> & {
+    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<Record<string, unknown>>
+  mongoClient: (serviceName: string) => MongoClientLike
+  addListener: (callback: () => void) => void
+  removeListener: (callback: () => void) => void
+  removeAllListeners: () => void
+}