@flowerforce/flowerbase-client 0.1.1-beta.2

package/src/app.ts

@@ -0,0 +1,235 @@
+import { normalizeFunctionResponse } from './functions'
+import { requestJson } from './http'
+import { SessionManager } from './session'
+import { AppConfig, CredentialsLike, FunctionCallPayload, ProfileData, SessionData } from './types'
+import { User } from './user'
+
+const API_PREFIX = '/api/client/v2.0'
+
+type LoginResponse = {
+  access_token: string
+  refresh_token: string
+  user_id: string
+}
+
+type SessionResponse = {
+  access_token: string
+}
+
+export class App {
+  readonly id: string
+  readonly baseUrl: string
+  readonly timeout: number
+  private readonly sessionManager: SessionManager
+  currentUser: User | null = null
+  private readonly sessionBootstrapPromise: Promise<void>
+
+  emailPasswordAuth: {
+    registerUser: (input: { email: string; password: string }) => Promise<unknown>
+    sendResetPasswordEmail: (email: string) => Promise<unknown>
+    callResetPasswordFunction: (email: string, password: string, ...args: unknown[]) => Promise<unknown>
+    resetPassword: (input: { token: string; tokenId: string; password: string }) => Promise<unknown>
+  }
+
+  constructor(config: AppConfig) {
+    this.id = config.id
+    this.baseUrl = config.baseUrl.replace(/\/$/, '')
+    this.timeout = config.timeout ?? 10000
+    this.sessionManager = new SessionManager(this.id)
+
+    const session = this.sessionManager.get()
+    if (session?.userId) {
+      this.currentUser = new User(this, session.userId)
+    }
+    this.sessionBootstrapPromise = this.bootstrapSessionOnLoad()
+
+    this.emailPasswordAuth = {
+      registerUser: ({ email, password }) =>
+        this.postProvider('/local-userpass/register', { email, password }),
+      sendResetPasswordEmail: (email) =>
+        this.postProvider('/local-userpass/reset/send', { email }),
+      callResetPasswordFunction: (email, password, ...args) =>
+        this.postProvider('/local-userpass/reset/call', { email, password, arguments: args }),
+      resetPassword: ({ token, tokenId, password }) =>
+        this.postProvider('/local-userpass/reset', { token, tokenId, password })
+    }
+  }
+
+  private providerUrl(path: string) {
+    return `${this.baseUrl}${API_PREFIX}/app/${this.id}/auth/providers${path}`
+  }
+
+  private authUrl(path: string) {
+    return `${this.baseUrl}${API_PREFIX}/auth${path}`
+  }
+
+  private functionsUrl(path = '/call') {
+    return `${this.baseUrl}${API_PREFIX}/app/${this.id}/functions${path}`
+  }
+
+  private async createSession(refreshToken: string): Promise<SessionResponse> {
+    return requestJson<SessionResponse>({
+      url: this.authUrl('/session'),
+      method: 'POST',
+      bearerToken: refreshToken,
+      timeout: this.timeout
+    })
+  }
+
+  private async bootstrapSessionOnLoad(): Promise<void> {
+    const session = this.sessionManager.get()
+    if (!session || typeof localStorage === 'undefined') {
+      return
+    }
+
+    try {
+      const result = await this.createSession(session.refreshToken)
+      this.sessionManager.set({
+        ...session,
+        accessToken: result.access_token
+      })
+    } catch {
+      this.sessionManager.clear()
+      this.currentUser = null
+    }
+  }
+
+  private async ensureSessionBootstrapped() {
+    await this.sessionBootstrapPromise
+  }
+
+  private async setLoggedInUser(data: LoginResponse, profileEmail?: string) {
+    const sessionResult = await this.createSession(data.refresh_token)
+    const session: SessionData = {
+      accessToken: sessionResult.access_token,
+      refreshToken: data.refresh_token,
+      userId: data.user_id
+    }
+    this.sessionManager.set(session)
+    this.currentUser = new User(this, data.user_id)
+    if (profileEmail) {
+      this.currentUser.profile = { email: profileEmail }
+    }
+    return this.currentUser
+  }
+
+  async logIn(credentials: CredentialsLike) {
+    if (credentials.provider === 'local-userpass') {
+      const result = await this.postProvider<LoginResponse>('/local-userpass/login', {
+        username: credentials.email,
+        password: credentials.password
+      })
+      return this.setLoggedInUser(result, credentials.email)
+    }
+
+    if (credentials.provider === 'anon-user') {
+      const result = await this.postProvider<LoginResponse>('/anon-user/login', {})
+      return this.setLoggedInUser(result)
+    }
+
+    const result = await this.postProvider<LoginResponse>('/custom-function/login', credentials.payload)
+    return this.setLoggedInUser(result)
+  }
+
+  getSessionOrThrow() {
+    const session = this.sessionManager.get()
+    if (!session) {
+      throw new Error('User is not authenticated')
+    }
+    return session
+  }
+
+  async postProvider<T = unknown>(path: string, body: unknown): Promise<T> {
+    return requestJson<T>({
+      url: this.providerUrl(path),
+      method: 'POST',
+      body,
+      timeout: this.timeout
+    })
+  }
+
+  async callFunction(name: string, args: unknown[]) {
+    await this.ensureSessionBootstrapped()
+    const session = this.getSessionOrThrow()
+    const payload: FunctionCallPayload = {
+      name,
+      arguments: args
+    }
+
+    const result = await requestJson<unknown>({
+      url: this.functionsUrl('/call'),
+      method: 'POST',
+      body: payload,
+      bearerToken: session.accessToken,
+      timeout: this.timeout
+    })
+
+    return normalizeFunctionResponse(result)
+  }
+
+  async callService(name: string, args: unknown[]) {
+    await this.ensureSessionBootstrapped()
+    const session = this.getSessionOrThrow()
+    const payload: FunctionCallPayload = {
+      name,
+      service: 'mongodb-atlas',
+      arguments: args
+    }
+
+    return requestJson<unknown>({
+      url: this.functionsUrl('/call'),
+      method: 'POST',
+      body: payload,
+      bearerToken: session.accessToken,
+      timeout: this.timeout
+    })
+  }
+
+  async getProfile(): Promise<ProfileData> {
+    await this.ensureSessionBootstrapped()
+    const session = this.getSessionOrThrow()
+    return requestJson<ProfileData>({
+      url: this.authUrl('/profile'),
+      method: 'GET',
+      bearerToken: session.accessToken,
+      timeout: this.timeout
+    })
+  }
+
+  async refreshAccessToken() {
+    await this.ensureSessionBootstrapped()
+    const session = this.getSessionOrThrow()
+
+    try {
+      const result = await this.createSession(session.refreshToken)
+
+      this.sessionManager.set({
+        ...session,
+        accessToken: result.access_token
+      })
+
+      return result.access_token
+    } catch (error) {
+      this.sessionManager.clear()
+      this.currentUser = null
+      throw error
+    }
+  }
+
+  async logoutUser() {
+    const session = this.sessionManager.get()
+    try {
+      if (session) {
+        await requestJson({
+          url: this.authUrl('/session'),
+          method: 'DELETE',
+          bearerToken: session.refreshToken,
+          timeout: this.timeout
+        })
+      }
+    } finally {
+      this.sessionManager.clear()
+      this.currentUser = null
+    }
+  }
+}

package/src/bson.ts

@@ -0,0 +1,6 @@
+import { EJSON, ObjectId, BSON as RawBSON } from 'bson'
+
+const ObjectID = ObjectId
+const BSON = Object.assign({}, RawBSON, { ObjectId, ObjectID })
+
+export { BSON, EJSON, ObjectId, ObjectID }

package/src/credentials.ts

@@ -0,0 +1,24 @@
+import { CredentialsLike } from './types'
+
+export class Credentials {
+  static emailPassword(email: string, password: string): CredentialsLike {
+    return {
+      provider: 'local-userpass',
+      email,
+      password
+    }
+  }
+
+  static anonymous(): CredentialsLike {
+    return {
+      provider: 'anon-user'
+    }
+  }
+
+  static function(payload: Record<string, unknown>): CredentialsLike {
+    return {
+      provider: 'custom-function',
+      payload
+    }
+  }
+}

package/src/functions.ts

@@ -0,0 +1,32 @@
+import { EJSON } from './bson'
+
+const deserialize = <T>(value: T): T => {
+  if (!value || typeof value !== 'object') return value
+  return EJSON.deserialize(value as Record<string, unknown>) as T
+}
+
+export const normalizeFunctionResponse = (value: unknown) => {
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value)
+      return deserialize(parsed)
+    } catch {
+      return value
+    }
+  }
+
+  return deserialize(value)
+}
+
+export const createFunctionsProxy = (
+  callFunction: (name: string, args: unknown[]) => Promise<unknown>
+): Record<string, (...args: unknown[]) => Promise<unknown>> =>
+  new Proxy(
+    {},
+    {
+      get: (_, key) => {
+        if (typeof key !== 'string') return undefined
+        return (...args: unknown[]) => callFunction(key, args)
+      }
+    }
+  ) as Record<string, (...args: unknown[]) => Promise<unknown>>

package/src/http.ts

@@ -0,0 +1,92 @@
+export class FlowerbaseHttpError extends Error {
+  status: number
+  payload?: unknown
+
+  constructor(message: string, status: number, payload?: unknown) {
+    super(message)
+    this.name = 'FlowerbaseHttpError'
+    this.status = status
+    this.payload = payload
+  }
+}
+
+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) {
+      let parsedErrorMessage: string | null = null
+      if (payload && typeof payload === 'object' && 'error' in payload && typeof payload.error === 'string') {
+        try {
+          const parsed = JSON.parse(payload.error)
+          if (parsed && typeof parsed === 'object' && 'message' in parsed && typeof parsed.message === 'string') {
+            parsedErrorMessage = parsed.message
+          }
+        } catch {
+          parsedErrorMessage = null
+        }
+      }
+
+      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

@@ -0,0 +1,14 @@
+import { BSON, EJSON, ObjectId, ObjectID } from './bson'
+
+export { App } from './app'
+export { User } from './user'
+export { Credentials } from './credentials'
+export { BSON, EJSON, ObjectId, ObjectID }
+export type {
+  AppConfig,
+  CredentialsLike,
+  UserLike,
+  MongoClientLike,
+  CollectionLike,
+  WatchAsyncIterator
+} from './types'

package/src/mongo.ts

@@ -0,0 +1,63 @@
+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): 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]) } : {})
+          }
+        ])
+        return mapResult(result)
+      }
+
+      return {
+        find: (query = {}, options = {}) => callService('find', [{ query, options }]),
+        findOne: (query = {}, options = {}) => callService('findOne', [{ query, options }]),
+        insertOne: (document, options = {}) => callService('insertOne', [{ document, 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()
+          return createWatchIterator({
+            appId: app.id,
+            baseUrl: app.baseUrl,
+            accessToken: session.accessToken,
+            database,
+            collection,
+            pipeline,
+            options,
+            timeout: app.timeout
+          })
+        }
+      }
+    }
+  })
+})

package/src/session.native.ts

@@ -0,0 +1,98 @@
+import { SessionData } from './types'
+
+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 | 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 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,59 @@
+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 storage = getStorage()
+  private session: SessionData | null = null
+
+  constructor(appId: string) {
+    this.key = `flowerbase:${appId}:session`
+    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)
+  }
+}