@de./sdk 1.0.0

package/src/backend/Auth.ts

@@ -0,0 +1,201 @@
+import { API_SERVER_BASEURL } from '../baseUrl'
+import type { AuthCredentials, AuthOptions, AuthRequestOptions } from '../types/auth'
+
+const ACCESS_TOKEN_EXPIRY = 3.75 // in 3 minutes 45 seconds
+
+type AuthResponse = {
+  error: boolean
+  message: string
+  token: string
+}
+
+export default class Auth {
+  private version: number
+  private options: AuthOptions
+  protected creds: AuthCredentials
+  private refreshTimer?: NodeJS.Timeout
+  private autorefresh?: boolean
+  private onNewToken?: (token: string) => void
+  private baseURL: string
+  private isRotating: boolean = false
+  public accessToken?: string
+
+  constructor( creds: AuthCredentials, options?: AuthOptions ){
+    if( !creds ) throw new Error('Undefined Credentials. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.context ) throw new Error('Undefined Context Reference. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.remoteOrigin ) throw new Error('Undefined Remote Origin. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.cid ) throw new Error('Undefined Connector ID. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.secret ) throw new Error('Undefined Connector Secret. Check https://doc.dedot.io/sdk/auth')
+
+    this.creds = creds
+    this.options = options || { env: 'dev' }
+    
+    this.version = this.options.version || 1
+    this.baseURL = API_SERVER_BASEURL[ this.options.env || 'dev' ]
+    this.autorefresh = this.options.autorefresh || false
+    this.onNewToken = this.options.onNewToken
+  }
+
+  private async request<T>({ url, ...options }: AuthRequestOptions ): Promise<T> {
+    const rawOptions: any = {
+      method: 'GET',
+      headers: {
+        /**
+         * Default User agent for SDK request calls
+         * 
+         * NOTE: Later replace by latest SDK version
+         */
+        'origin': this.creds.remoteOrigin,
+        'de-user-agent': `De.remote/${this.version}.0`
+      }
+    }
+
+    if( this.accessToken )
+      rawOptions.headers.authorization = `Bearer ${this.accessToken}`
+
+    if( options.body ){
+      rawOptions.headers['content-type'] = 'application/json'
+      if( typeof options.body === 'object' )
+        options.body = JSON.stringify( options.body )
+    }
+
+    options = { ...rawOptions, ...options }
+
+    this.debug('Auth request', `${this.baseURL}/v${this.version}/${url.replace(/^\//, '')}`, options )
+    const response = await fetch(`${this.baseURL}/v${this.version}/${url.replace(/^\//, '')}`, options )
+    
+    return await response.json() as T
+  }
+
+  private debug( ...args: any[] ){
+    this.options?.env === 'dev' && console.debug('[Auth]', ...args )
+  }
+  private error( ...args: any[] ){
+    console.error('[Auth]', ...args )
+  }
+
+  /**
+   * Schedule next token rotation
+   */
+  private scheduleRotation(){
+    if( !this.autorefresh ) return
+
+    this.clearRotation()
+    this.refreshTimer = setTimeout( () => this.rotateToken(), ACCESS_TOKEN_EXPIRY * 60 * 1000 )
+  }
+
+  /**
+   * Clear rotation timer
+   */
+  private clearRotation(){
+    if( !this.refreshTimer ) return
+
+    clearTimeout( this.refreshTimer )
+    this.refreshTimer = undefined
+  }
+
+  async getToken(): Promise<string>{
+    const
+    options: AuthRequestOptions = {
+      url: '/access/token',
+      method: 'POST',
+      body: this.creds
+    },
+    { error, message, token } = await this.request<AuthResponse>( options )
+    if( error ) throw new Error( message )
+
+    this.accessToken = token
+    this.scheduleRotation() // Schedule auto-refresh
+    
+    return token
+  }
+
+  async rotateToken(): Promise<string> {
+    // Prevent concurrent rotation attempts
+    if( this.isRotating ){
+      this.debug('Token rotation already in progress, skipping')
+      return this.accessToken!
+    }
+
+    if( !this.accessToken )
+      throw new Error('No access token found')
+
+    this.isRotating = true
+
+    try {
+      const
+      options: AuthRequestOptions = {
+        url: '/access/token/rotate',
+        method: 'PATCH',
+        body: { secret: this.creds.secret }
+      },
+      { error, message, token } = await this.request<AuthResponse>( options )
+      if( error ) throw new Error( message )
+
+      this.accessToken = token
+
+      // Notify callback listener
+      if( typeof this.onNewToken === 'function' )
+        try { this.onNewToken( token ) }
+        catch( callbackError ){ this.error('[Auth] Error in onNewToken callback:', callbackError) }
+
+      // Schedule next rotation
+      this.scheduleRotation()
+      
+      this.debug('Token rotated successfully')
+      return token
+    }
+    catch( error: any ){
+      this.debug('Refresh access token failed:', error.message)
+      
+      try {
+        // Fallback: Get new token instead
+        const newToken = await this.getToken()
+        this.debug('Fallback to new token successful')
+        
+        // Notify callback listener about new token
+        if( this.onNewToken )
+          try { this.onNewToken( newToken ) }
+          catch( callbackError ){ this.error('Error in onNewToken callback:', callbackError) }
+        
+        return newToken
+      }
+      catch( fallbackError: any ){
+        this.error('Fallback to new token also failed:', fallbackError.message)
+        throw fallbackError
+      }
+    }
+    finally { this.isRotating = false }
+  }
+
+  /**
+   * Stop auto-refresh and clean up resources
+   */
+  stopAutoRefresh(){
+    this.debug('Stopping auto-refresh')
+    
+    this.clearRotation()
+    this.autorefresh = false
+  }
+
+  /**
+   * Start auto-refresh
+   */
+  startAutoRefresh(){
+    this.debug('Starting auto-refresh')
+    
+    this.autorefresh = true
+    this.scheduleRotation()
+  }
+
+  /**
+   * Clean up all resources
+   */
+  destroy(){
+    this.debug('Destroying Auth instance')
+    this.stopAutoRefresh()
+
+    this.accessToken = undefined
+    this.onNewToken = undefined
+  }
+}

package/src/baseUrl.ts

@@ -0,0 +1,13 @@
+
+export const ASI_SERVER_BASEURL = {
+  dev: 'http://localhost:44000',
+  prod: 'https://auth.dedot.io'
+}
+export const API_SERVER_BASEURL = {
+  dev: 'http://localhost:24800',
+  prod: 'https://api.dedot.io'
+}
+export const IOT_SERVER_BASEURL = {
+  dev: 'http://localhost:11011',
+  prod: 'https://iot.dedot.io'
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+import Utils from './utils'
+import MSI, { type MSIInterface } from './allend/MSI'
+import IoTClient, { type IoTClientOptions } from './allend/IoTClient'
+import Order from './allend/DClient/Order'
+import Event from './allend/DClient/Event'
+import Client from './allend/DClient/Client'
+import Auth from './backend/Auth'
+
+const DClient = { Client, Order, Event }
+
+export {
+  Auth,
+  MSI,
+  type MSIInterface,
+  Utils,
+  DClient,
+  IoTClient,
+  type IoTClientOptions
+}

package/src/types/access.d.ts

@@ -0,0 +1,8 @@
+export type AccessOptions = {
+  env: 'dev' | 'prod'
+  platform: 'web' | 'mobile' | 'server' | 'proxy'
+  version?: number
+  context: string
+  accessToken: string
+  remoteOrigin?: string
+}

package/src/types/auth.d.ts

@@ -0,0 +1,27 @@
+export type AuthOptions = {
+  env: 'dev' | 'prod'
+  version?: number
+  autorefresh?: boolean
+  onNewToken?: (token: string) => void
+}
+
+export type AuthCredentials = {
+  context: string
+  remoteOrigin: string
+  cid: string
+  secret: string
+}
+
+export type SocketAuthCredentials = {
+  utype: string
+  id: string
+  remoteOrigin: string
+  accessToken: string
+}
+
+export type AuthRequestOptions = {
+  url: string
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+  headers?: { [index: string]: string }
+  body?: any
+}

package/src/types/index.d.ts

@@ -0,0 +1,281 @@
+export type HTTPRequestOptions = {
+  url: string
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+  headers?: { [index: string]: string }
+  body?: any
+}
+export type HTTPResponse = {
+  error: boolean
+  message?: string
+}
+
+export type LngLat = [number, number]
+export type Coordinates = {
+  lng: number
+  lat: number
+}
+export type PickedLocation = {
+  point: {
+    x: number,
+    y: number
+  }
+  coordinates: Coordinates
+}
+export type RTLocation = Coordinates & {
+  heading?: number
+}
+export type ActivePosition = {
+  id: string
+  position: RTLocation
+  caption?: Caption
+}
+
+/**
+ * Configuration options for AnimatedPolyline
+ */
+export type AnimatedRouteNativePathType = 'dot' | 'solid'
+export type AnimatedRouteNativeMethods = 'dot:flow'
+                                          | 'dot:fade'
+                                          | 'dot:pulse'
+                                          | 'dot:directional'
+                                          | 'solid:flow'
+                                          | 'solid:fade'
+                                          | 'solid:pulse'
+                                          | 'solid:directional'
+export interface AnimatedRouteRules {
+  styles?: any;
+  speed?: number; // pixels per frame
+  fadeLength?: number; // length of fade effect in pixels
+}
+export interface AnimatedRoute {
+  key: number | null
+  currentOffset: number
+  rules: Required<AnimatedRouteRules>
+  startTime?: number;
+  polyline?: any
+  engine: any
+  path: Coordinates[]
+
+  /**
+   * Create the polyline
+   */
+  create( pathType?: AnimatedRouteNativePathType ): void;
+
+  /**
+   * Animation methods
+   */
+  apply: Record<string, () => void>;
+
+  /**
+   * Stop the current animation
+   */
+  stop(): void;
+
+  /**
+   * Remove the polyline from the map and stop animation
+   */
+  remove(): void;
+}
+export type AnimatedRouteOptions = AnimatedRouteNativeMethods | {
+  handler?: new (engine: Engine, path: Coordinates[], rules?: AnimatedRouteRules) => AnimatedRoute
+  method?: string
+  rules?: AnimatedRouteRules
+}
+
+export type Journey = {
+  routeId: string | number
+  origin?: MapWaypoint
+  destination?: MapWaypoint
+  waypoints?: MapWaypoint[]
+  options?: RouteOptions
+}
+export type ActiveDirection<RouteSpec> = {
+  routeId: string | number
+  profile: string
+  origin?: Coordinates
+  destination?: Coordinates
+  waypoints: Coordinates[]
+  route: RouteSpec | null
+}
+
+export type RouteID = string | number
+export type RoutesFitBoundsOptions = {
+	includes?: RouteID[]
+	margin?: number
+}
+export type RouteOptions = {
+  id?: string | number
+  mode?: 'default' | 'navigation'
+  profile?: 'driving-traffic' | 'driving' | 'cycling' | 'biking' | 'walking' | 'transit'
+  unit?: 'metric' | 'imperial',
+  preference?: 'TRAFFIC_AWARE' | 'TRAFFIC_UNAWARE'
+  pointless?: boolean
+  styles?: any
+  animation?: AnimatedRouteOptions
+}
+
+export type SearchPlace = {
+  name: string
+  location: Coordinates,
+  address: string
+}
+
+export type Waypoint = {
+  no: number
+  type: 'pickup' | 'dropoff'
+  description: string
+  coordinates: Coordinates
+  address?: string
+  contact: {
+    type: string
+    reference: string
+    phone?: string
+    email?: string
+  }
+}
+export type WaypointIndex = 'origin' | 'destination' | number
+export type WaypointOptions = {
+  no?: number
+  type?: 'pickup' | 'dropoff'
+  description?: string
+  coordinates?: Coordinates
+  address?: string
+  'contact.type'?: string
+  'contact.reference'?: string
+  'contact.phone'?: string
+  'contact.email'?: string
+}
+
+export type Package = {
+  waypointNo: number
+  careLevel: number
+  category: string
+  weight: number
+  note?: string
+}
+export type PackageOptions = {
+  waypointNo?: number
+  careLevel?: number
+  category?: string
+  weight?: number
+  note?: string
+}
+
+export type PaymentMode = 'cash' | 'card' | 'momo' | 'wigo'
+export type OrderService = {
+  fees: {
+    total: {
+      amount: number
+      currency: string
+    },
+    tax: number
+    discount: number
+  }
+  payment: {
+    mode: PaymentMode
+    paid: boolean
+  }
+  xpress: string
+}
+export type OrderServiceOptions = {
+  'fees.total.amount'?: number
+  'fees.total.currency'?: string
+  'fees.tax'?: string
+  'fees.discount'?: string
+  'payment.mode'?: PaymentMode
+  'payment.option'?: string
+  'payment.paid'?: boolean
+  xpress?: string
+}
+export type OrderOperator = {}
+export type OrderStage = {
+  current: string
+  status: string
+}
+
+export type Message = {
+  type: 'text' | 'location' | 'media'
+  sender: string
+  content: string
+  timestamp: string
+}
+export type Caption = {
+	duration?: number
+	unit?: string
+	label?: string
+}
+export type Peer = {
+  utype: string
+  id: string
+}
+
+export type MapOptions = {
+  element: string
+  accessToken: string
+  version?: number
+  env?: 'dev' | 'prod'
+}
+export type MapLayerStyle = 'streets' | 'outdoors' | 'light' | 'dark' | 'satellite'
+export type MapWaypoint = {
+  index?: number
+  coords: Coordinates
+  caption?: Caption
+}
+
+export type Entity = {
+  id: string
+  status: 'ACTIVE' | 'BUSY'
+  grade: '1H' | '2H' | '3H'
+  currentLocation: RTLocation
+  static?: boolean
+  type: 'moto' | 'car' | 'bike' | 'truck' | 'plane' | 'ship' | 'restaurant' | 'hotel' | 'store' | 'office' | 'warehouse'
+}
+export type EntitySpecs = {
+  id: string
+  status: 'ACTIVE' | 'BUSY'
+  grade: '1H' | '2H' | '3H'
+  currentLocation: RTLocation
+  static?: boolean
+  type: 'moto' | 'car' | 'bike' | 'truck' | 'plane' | 'ship' | 'restaurant' | 'hotel' | 'store' | 'office' | 'warehouse'
+}
+
+export interface UserLocationOptions {
+  // Base point styling options
+  borderRadius?: number
+  borderColor?: string
+  borderOpacity?: number
+  dotColor?: string
+  showInnerDot?: boolean
+  noRing?: boolean
+  
+  // User location specific options
+  showDirectionArrow?: boolean
+  arrowColor?: string
+  arrowSize?: number
+  pulseAnimation?: boolean
+  accuracyCircle?: boolean
+  accuracyColor?: string
+  accuracyOpacity?: number
+  
+  // Callbacks
+  onLocationUpdate?: ( location: RTLocation ) => void
+  onLocationError?: ( error: GeolocationPositionError ) => void
+}
+export type DragPickOptions = {
+  snapToRoad?: boolean
+  pinPoints?: boolean
+  pointOptions?: CustomPointOptions
+}
+export type DragPickContentType = 'duration' | 'distance' | 'preloader'
+export type DragPickContent = {
+  time?: number
+  unit?: 'min' | 'sec' | 'hr' | 'km' | 'mi' | 'm'
+  distance?: number
+  preloader?: boolean
+}
+export type DragPickEvent = 'dragstart' | 'dragend' | 'zoom_changed' | 'idle'
+export interface DragPickInterface {
+  enable( origin?: Coordinates ): void
+  disable(): void
+  content( type: DragPickContentType, content: DragPickContent ): void
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+
+import Stream from './stream'
+
+export default { Stream }

package/src/utils/stream.ts

@@ -0,0 +1,68 @@
+
+export type StreamDataListener = ( data: string ) => void
+
+export default class Stream {
+  private _STALED: boolean = false
+  private _CLOSED: boolean = false
+  private _fns: StreamDataListener[] = []
+  private _exitFn = (() => {})
+  private _errorFn = (( error: Error ) => {})
+  private _downStream?: Stream
+  private _upStream?: Stream
+
+  private _upstream( stream: Stream ){
+    this._upStream = stream
+    return this
+  }
+  private _backpressure( data: any ){
+    !this._CLOSED && this._fns.map( fn => fn( data ) )
+  }
+
+  sync( data: any ){
+    !this._CLOSED && this._downStream?._backpressure( data )
+  }
+
+  on( _event: 'data', fn: StreamDataListener ){
+    if( this._CLOSED ) throw new Error('Stream closed')
+
+    this._fns.push( fn )
+    return this
+  }
+
+  pipe( stream: Stream ){
+    stream._upstream( this )
+    this._downStream = stream
+    return this
+  }
+
+  error( error: Error | string  ){
+    // Throw error to self
+    this._errorFn( typeof error == 'string' ? new Error( error ) :  error )
+    // Throw error to downstream pipe
+    this._downStream?.error( error )
+    
+    return this
+  }
+
+  close(){
+    if( this._CLOSED ) return
+    this._CLOSED = true
+
+    this._fns = []
+    this._exitFn()
+
+    this._downStream?.close() // Close down streams
+    // this._upStream?.close() // Close up streams: Recursive loop call effect
+  }
+
+  isActive(){ return !this._CLOSED }
+  
+  onerror( fn: ( error: Error ) => void ){
+    this._errorFn = fn
+    return this
+  }
+  onclose( fn: () => void ){ 
+    this._exitFn = fn
+    return this
+  }
+}