@flowerforce/flowerbase-client 0.1.1-beta.2

package/src/types.ts

@@ -0,0 +1,84 @@
+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> }
+
+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
+  pipeline?: unknown[]
+  options?: Record<string, 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>
+  insertOne: (document: 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>
+  watch: (pipeline?: unknown[], options?: Record<string, unknown>) => WatchAsyncIterator<unknown>
+}
+
+export interface MongoDbLike {
+  collection: (name: string) => CollectionLike
+}
+
+export interface MongoClientLike {
+  db: (name: string) => MongoDbLike
+}
+
+export interface UserLike {
+  id: string
+  profile?: {
+    email?: string
+    [key: string]: unknown
+  }
+  functions: Record<string, (...args: unknown[]) => Promise<unknown>>
+  logOut: () => Promise<void>
+  refreshAccessToken: () => Promise<string>
+  refreshCustomData: () => Promise<ProfileData>
+  mongoClient: (serviceName: string) => MongoClientLike
+}

package/src/user.ts

@@ -0,0 +1,39 @@
+import type { App } from './app'
+import { createFunctionsProxy } from './functions'
+import { createMongoClient } from './mongo'
+import { MongoClientLike, ProfileData, UserLike } from './types'
+
+export class User implements UserLike {
+  id: string
+  profile?: { email?: string;[key: string]: unknown }
+  private readonly app: App
+
+  functions: Record<string, (...args: unknown[]) => Promise<unknown>>
+
+  constructor(app: App, id: string) {
+    this.app = app
+    this.id = id
+    this.functions = createFunctionsProxy((name, args) => this.app.callFunction(name, args))
+  }
+
+  async logOut() {
+    await this.app.logoutUser()
+  }
+
+  async refreshAccessToken() {
+    return this.app.refreshAccessToken()
+  }
+
+  async refreshCustomData(): Promise<ProfileData> {
+    const profile = await this.app.getProfile()
+    this.profile = profile.data
+    return profile.custom_data || {}
+  }
+
+  mongoClient(serviceName: string): MongoClientLike {
+    if (serviceName !== 'mongodb-atlas') {
+      throw new Error(`Unsupported service "${serviceName}"`)
+    }
+    return createMongoClient(this.app)
+  }
+}

package/src/watch.ts

@@ -0,0 +1,150 @@
+import { WatchAsyncIterator, WatchConfig } from './types'
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+const createWatchRequest = ({ database, collection, pipeline = [], options = {} }: WatchConfig) => ({
+  name: 'watch',
+  service: 'mongodb-atlas',
+  arguments: [
+    {
+      database,
+      collection,
+      pipeline,
+      options
+    }
+  ]
+})
+
+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 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(request))
+      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"
+  ]
+}