@based/functions 1.0.2 → 1.1.0

package/src/channel.ts

@@ -0,0 +1,10 @@
+import { ChannelMessageFunction } from './functions'
+
+export abstract class BasedChannel<K = any> {
+  abstract subscribe(
+    onMessage: ChannelMessageFunction<K>,
+    onError?: (err: any) => void
+  ): () => void
+
+  abstract publish(message: K): void
+}

package/src/client.ts

@@ -1,7 +1,10 @@
 import { AuthState } from './auth'
+import { BasedChannel } from './channel'
 import { Context } from './context'
 import { BasedQuery } from './query'
+import { StreamFunctionOpts } from './stream'
 
+// TODO: this is the place where we will add extra specifications
 export abstract class BasedFunctionClient {
   server: any
 
@@ -9,9 +12,18 @@ export abstract class BasedFunctionClient {
 
   abstract query(name: string, payload?: any): BasedQuery
 
-  abstract stream(name: string, stream?: any, ctx?: Context): Promise<any>
+  abstract channel(name: string, payload?: any): BasedChannel
+
+  abstract stream(
+    name: string,
+    payload: StreamFunctionOpts,
+    ctx?: Context
+  ): Promise<any>
 
   abstract sendAuthState(ctx: Context, authState: AuthState): void
 
-  abstract renewAuthState(ctx: Context): void
+  abstract renewAuthState(
+    ctx: Context,
+    authState?: AuthState
+  ): Promise<AuthState>
 }

package/src/context.ts

@@ -4,7 +4,7 @@ import { parseQuery } from '@saulx/utils'
 import { BasedFunctionClient } from './client'
 
 export type WebSocketSession = {
-  // State can be used for anyting - for us the based class instance
+  // State can be used for anything - for us the based class instance
   state?: any
   query: string
   ua: string
@@ -13,18 +13,26 @@ export type WebSocketSession = {
   method: string
   authState: AuthState
   obs: Set<number>
-  unauthorizedObs: Set<{
+  unauthorizedObs?: Set<{
     id: number
     checksum: number
     name: string
     payload: any
   }>
+  unauthorizedChannels?: Set<{
+    id: number
+    name: string
+    payload: any
+  }>
   // Optimization so we dont need to keep track of websockets outside of uws
   c?: Context<WebSocketSession>
-} & WebSocket
+  ws?: BasedWebSocket
+}
+
+export type BasedWebSocket = WebSocket<WebSocketSession>
 
 export type HttpSession = {
-  // State can be used for anyting - for us the based class instance
+  // State can be used for anything - for us the based class instance
   state?: any
   res: HttpResponse
   req: HttpRequest
@@ -50,13 +58,22 @@ export type InternalSessionObservable = {
   type: 'query'
 }
 
+export type InternalSessionChannel = {
+  id: number
+  name: string
+  type: 'channel'
+}
+
 export type InternalSessionClient = {
   client: BasedFunctionClient
   type: 'client'
 }
 
 // Internal session for internal functions
-export type InternalSession = InternalSessionClient | InternalSessionObservable
+export type InternalSession =
+  | InternalSessionClient
+  | InternalSessionObservable
+  | InternalSessionChannel
 
 // used for minimal security errors (e.g. rate limit)
 export type MinimalExternalSession = {
@@ -64,11 +81,15 @@ export type MinimalExternalSession = {
   ip: string
 }
 
-export type Session =
+export type Session = (
   | WebSocketSession
   | HttpSession
   | InternalSession
   | MinimalExternalSession
+) & {
+  /** Only available in Ws and Http contexts */
+  authState?: AuthState
+}
 
 export type Context<S extends Session = Session> = {
   session?: S
@@ -94,15 +115,22 @@ export const isWsContext = (
 
 export const isClientContext = (
   ctx: Context<Session>
-): ctx is Context<WebSocketSession> => {
-  if (ctx.session && 'authState' in ctx.session) {
+): ctx is Context<WebSocketSession | HttpSession> => {
+  if (ctx.session && (isWsSession(ctx.session) || isHttpSession(ctx.session))) {
+    return true
+  }
+  return false
+}
+
+export const isHttpSession = (session: Session): session is HttpSession => {
+  if ('res' in session) {
     return true
   }
   return false
 }
 
 export const isWsSession = (session: Session): session is WebSocketSession => {
-  if (!('res' in session) && 'ip' in session && 'id' in session) {
+  if ('send' in session) {
     return true
   }
   return false

package/src/functions.ts

@@ -1,6 +1,6 @@
 import { Context, HttpSession } from './context'
 import { BasedFunctionClient } from './client'
-import { Duplex } from 'stream'
+import { BasedDataStream } from './stream'
 
 export type ObservableUpdateFunction<K = any> = {
   (
@@ -47,10 +47,7 @@ export type StreamPayload<P = any> = {
   payload?: P
   mimeType: string
   size: number
-  stream: Duplex & {
-    size: number
-    receivedBytes: number
-  }
+  stream: BasedDataStream
   fileName?: string
   extension?: string
 }
@@ -65,11 +62,36 @@ export type BasedQueryFunction<P = any, K = any> =
       based: BasedFunctionClient,
       payload: P,
       update: ObservableUpdateFunction<K>,
-      error?: ObserveErrorListener
+      error: ObserveErrorListener
     ) => Promise<() => void>)
   | ((
       based: BasedFunctionClient,
       payload: P,
       update: ObservableUpdateFunction<K>,
-      error?: ObserveErrorListener
+      error: ObserveErrorListener
     ) => () => void)
+
+export type BasedChannelFunction<P = any, K = any> = (
+  based: BasedFunctionClient,
+  payload: P,
+  id: number,
+  update: ChannelMessageFunction<K>,
+  error: (err?: any) => void
+) => () => void
+
+export type BasedChannelPublishFunction<P = any, K = any> = (
+  based: BasedFunctionClient,
+  payload: P,
+  message: K,
+  id: number,
+  ctx: Context
+) => void
+
+export type ChannelMessageFunction<K = any> = (message: K) => void
+
+export type ChannelMessageFunctionInternal<K = any> = (
+  message: K,
+  err?: any
+) => void
+
+export type UninstallFunction = () => Promise<void>

package/src/index.ts

@@ -3,3 +3,5 @@ export * from './auth'
 export * from './client'
 export * from './functions'
 export * from './query'
+export * from './stream'
+export * from './channel'

package/src/query.ts

@@ -1,14 +1,14 @@
 import { ObservableUpdateFunction, ObserveErrorListener } from './functions'
 
-export abstract class BasedQuery {
+export abstract class BasedQuery<K = any> {
   abstract subscribe(
-    onData: ObservableUpdateFunction,
+    onData: ObservableUpdateFunction<K>,
     onError?: ObserveErrorListener
   ): () => void
 
   abstract getWhen(
-    condition: (data: any, checksum: number) => boolean
+    condition: (data: K, checksum: number) => boolean
   ): Promise<any>
 
-  abstract get(): Promise<any>
+  abstract get(): Promise<K>
 }

package/src/stream.ts

@@ -0,0 +1,95 @@
+import { Duplex, Readable } from 'stream'
+import util from 'node:util'
+
+// prob want to move this to based functions
+export class BasedDataStream extends Duplex {
+  public size: number = 0
+  public receivedBytes: number = 0
+  public progessTimer: NodeJS.Timeout
+
+  constructor(size: number) {
+    super()
+    this.size = size
+    this.emit('progress', 0)
+  }
+
+  _read() {}
+
+  _write(chunk, encoding, callback) {
+    this.receivedBytes += chunk.byteLength
+    if (this.size && this.size > 20000) {
+      if (!this.progessTimer) {
+        this.progessTimer = setTimeout(() => {
+          const progress = this.receivedBytes / this.size
+          this.emit('progress', progress)
+          this.progessTimer = null
+        }, 200)
+      }
+    }
+    this.push(Buffer.from(chunk, encoding))
+    callback()
+  }
+
+  _final() {
+    if (!this.size) {
+      this.size = this.receivedBytes
+    }
+    this.receivedBytes = this.size
+    if (this.progessTimer) {
+      clearTimeout(this.progessTimer)
+      this.progessTimer = null
+    }
+    this.emit('progress', 1)
+    this.push(null)
+  }
+
+  [util.inspect.custom]() {
+    if (this.size) {
+      const rb =
+        this.receivedBytes < 1000
+          ? Math.round(this.receivedBytes / 1024) + 'kb'
+          : Math.round(this.receivedBytes / 1024 / 1024) + 'mb'
+
+      return `[BasedStream ${~~(
+        (this.receivedBytes / this.size) *
+        100
+      )}% ${rb}]`
+    } else {
+      return `[BasedStream]`
+    }
+  }
+}
+
+// maybe make a type pkg
+export type StreamFunctionContents<F = Buffer | ArrayBuffer | string> = {
+  contents: F
+  payload?: any
+  mimeType?: string
+  fileName?: string
+}
+
+export type StreamFunctionStream =
+  | {
+      contents: Readable | Duplex
+      payload?: any
+      size: number
+      mimeType?: string
+      fileName?: string
+      extension?: string
+    }
+  | {
+      contents: BasedDataStream
+      payload?: any
+      size?: number
+      mimeType?: string
+      fileName?: string
+      extension?: string
+    }
+
+export type StreamFunctionOpts = StreamFunctionContents | StreamFunctionStream
+
+export const isStreamFunctionOpts = (
+  opts: StreamFunctionContents | StreamFunctionStream
+): opts is StreamFunctionStream => {
+  return opts.contents instanceof Duplex || opts.contents instanceof Readable
+}