@flowerforce/flowerbase-client 0.1.1-beta.0

package/src/user.ts

@@ -0,0 +1,150 @@
+import type { App } from './app'
+import { createFunctionsProxy } from './functions'
+import { createMongoClient } from './mongo'
+import { MongoClientLike, UserLike } from './types'
+
+export class User implements UserLike {
+  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>> & {
+    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.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(this.id)
+  }
+
+  async callFunction(name: string, ...args: unknown[]) {
+    return this.app.callFunction(name, args, this.id)
+  }
+
+  async refreshAccessToken() {
+    const accessToken = await this.app.refreshAccessToken(this.id)
+    this.customData = this.resolveCustomDataFromToken()
+    return accessToken
+  }
+
+  async refreshCustomData(): Promise<Record<string, unknown>> {
+    const profile = await this.app.getProfile(this.id)
+    this.profile = profile.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 {
+    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.
+      }
+    }
+  }
+}

package/src/watch.ts

@@ -0,0 +1,156 @@
+import { EJSON } from './bson'
+import { WatchAsyncIterator, WatchConfig } from './types'
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+const createWatchRequest = ({
+  database,
+  collection,
+  filter,
+  ids
+}: WatchConfig) => ({
+  name: 'watch',
+  service: 'mongodb-atlas',
+  arguments: [
+    {
+      database,
+      collection,
+      ...(filter ? { filter } : {}),
+      ...(ids ? { ids } : {})
+    }
+  ]
+})
+
+const toBase64 = (input: string) => {
+  if (typeof btoa === 'function') {
+    return btoa(input)
+  }
+  throw new Error('Base64 encoder not available in current runtime')
+}
+
+const parseSsePayload = (line: string) => {
+  if (!line.startsWith('data:')) return null
+  const raw = line.slice(5).trim()
+  if (!raw) return null
+
+  try {
+    return EJSON.deserialize(JSON.parse(raw))
+  } catch {
+    return raw
+  }
+}
+
+export const createWatchIterator = (config: WatchConfig): WatchAsyncIterator<unknown> => {
+  let closed = false
+  let activeController: AbortController | null = null
+  const queue: unknown[] = []
+  const waiters: Array<(value: IteratorResult<unknown>) => void> = []
+
+  const enqueue = (value: unknown) => {
+    const waiter = waiters.shift()
+    if (waiter) {
+      waiter({ done: false, value })
+      return
+    }
+    queue.push(value)
+  }
+
+  const close = () => {
+    if (closed) return
+    closed = true
+    activeController?.abort()
+    while (waiters.length > 0) {
+      const resolve = waiters.shift()
+      resolve?.({ done: true, value: undefined })
+    }
+  }
+
+  const run = async () => {
+    let attempts = 0
+    while (!closed) {
+      const controller = new AbortController()
+      activeController = controller
+      const request = createWatchRequest(config)
+      const encoded = toBase64(JSON.stringify(EJSON.serialize(request, { relaxed: false })))
+      const url = `${config.baseUrl}/api/client/v2.0/app/${config.appId}/functions/call?baas_request=${encodeURIComponent(encoded)}`
+
+      try {
+        const response = await fetch(url, {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${config.accessToken}`,
+            Accept: 'text/event-stream'
+          },
+          signal: controller.signal
+        })
+
+        if (!response.ok || !response.body) {
+          throw new Error(`Watch request failed (${response.status})`)
+        }
+
+        attempts = 0
+        const reader = response.body.getReader()
+        const decoder = new TextDecoder()
+        let buffer = ''
+
+        while (!closed) {
+          const { done, value } = await reader.read()
+          if (done) break
+
+          buffer += decoder.decode(value, { stream: true })
+          const lines = buffer.split('\n')
+          buffer = lines.pop() ?? ''
+
+          for (const line of lines) {
+            const parsed = parseSsePayload(line)
+            if (parsed !== null) {
+              enqueue(parsed)
+            }
+          }
+        }
+      } catch {
+        if (closed) {
+          break
+        }
+      }
+
+      if (closed) {
+        break
+      }
+
+      attempts += 1
+      const backoff = Math.min(5000, 250 * 2 ** (attempts - 1))
+      await sleep(backoff)
+    }
+  }
+
+  void run()
+
+  return {
+    [Symbol.asyncIterator]() {
+      return this
+    },
+    next() {
+      if (queue.length > 0) {
+        return Promise.resolve({ done: false, value: queue.shift() })
+      }
+
+      if (closed) {
+        return Promise.resolve({ done: true, value: undefined })
+      }
+
+      return new Promise((resolve) => {
+        waiters.push(resolve)
+      })
+    },
+    return() {
+      close()
+      return Promise.resolve({ done: true, value: undefined })
+    },
+    throw(error?: unknown) {
+      close()
+      return Promise.reject(error)
+    },
+    close
+  }
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "commonjs",
+    "target": "ES2020",
+    "declaration": true,
+    "declarationMap": true,
+    "strict": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+        "../../node_modules/*"
+      ]
+    },
+    "lib": [
+      "ES2021",
+      "DOM"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "jest.config.ts",
+    "dist"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": [
+      "node",
+      "jest"
+    ]
+  },
+  "include": [
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts"
+  ]
+}