@nostrwatch/route66 0.0.1

package/src/core/AdapterWorker.ts

@@ -0,0 +1,200 @@
+/// <reference lib="webworker" />
+
+import { IEvent, ISharedWorkerGlobalScope, IWorkerCommand, IWorkerGlobalScope } from "../interfaces";
+import { NostrEvent } from "nostr-tools";
+import { Workers } from "./Workers";
+import { AdapterMessage } from "./Adapter";
+
+export enum WorkerContext {
+  MainThread = 0,
+  Worker = 1,
+  DedicatedWorker = 2
+}
+
+export interface AdapterWorkerMessage extends AdapterMessage {}
+
+export interface AdapterWorkerCommand extends AdapterWorkerMessage {
+  command?: string;
+  channelPort?: MessagePort
+  mainThread?: IWorkerGlobalScope | ISharedWorkerGlobalScope;
+}
+
+export enum AdapterWorkerResultType {
+  "events" = "events",
+  "event" = "event",
+  "record" = "record",
+  "records" = "records",
+}
+
+export interface AdapterWorkerResult extends AdapterWorkerMessage {
+  result?: ArrayBuffer;
+  resultType?: AdapterWorkerResultType;
+}
+
+export interface WorkerOptions {
+  mainThread?: IWorkerGlobalScope | ISharedWorkerGlobalScope;
+  channelPort?: MessagePort;
+}
+
+export class AdapterWorker {
+
+  private _mainThread?: IWorkerGlobalScope | ISharedWorkerGlobalScope;
+  private _channelPort?: MessagePort;
+
+  constructor( options?: WorkerOptions ){
+    if(!options) return 
+    ////console.log('AdapterWorker', options)
+    this._mainThread = options?.mainThread
+    this._channelPort = options?.channelPort
+    this.setupHandlers()
+  }
+  get mainThread(): IWorkerGlobalScope | ISharedWorkerGlobalScope | undefined {
+    return this._mainThread;
+  }
+
+  set channel( port: MessagePort ){
+    this._channelPort = port
+  }
+
+  get channel(): MessagePort | undefined {
+    return this._channelPort
+  }
+
+  //overload this.
+  async setup(command: AdapterWorkerMessage): Promise<void>{
+    console.warn(`${this.constructor.name} setup() method not implemented`)
+  }
+
+  async _setup(command: AdapterWorkerMessage): Promise<void>{
+    console.warn(`${this.constructor.name}: Adapter\'s Worker _setup() method not implemented`)
+  }
+
+  async __setup(command: AdapterWorkerMessage): Promise<void>{
+    ////console.log(`${this.constructor.name}: AdapterWorker.__setup`, command)
+    const { channelPort } = command
+    if(channelPort) {
+      ////console.log(`[Worker:${this.constructor.name}] channelPort:`, channelPort)
+      this.channel = channelPort
+      this.setupChannelHandlers()
+    }
+    await this._setup(command)
+    return this.setup(command)
+  }
+
+  setupChannelHandlers(){
+    if(!this.channel) return console.warn('channel not defined')
+    this.channel.onmessage = (message: MessageEvent) => {
+      const command = message.data as AdapterWorkerMessage;
+      ////console.log(`[Worker:${this.constructor.name}] channel.onmessage`, command)
+      this.listenPingPong('channel', command)
+      this.onChannelMessage(command);
+    }
+
+    ////console.log('setupChannelHandlers', this.channel)
+    this.channel.onmessageerror = this.onMessageError
+  }
+
+  setupHandlers(){
+    ////console.log('AdapterWorker: setupHandlers()')
+    if(!this?.mainThread) return console.warn('mainThread not defined')
+    const onmessage = async (message: MessageEvent) => {
+      const command = message.data as AdapterWorkerMessage;
+      ////console.log(`[Worker:${this.constructor.name}] mainthread.onmessage`, command)
+      this.listenPingPong('mainthread', command)
+      if(command.type === 'setup'){
+        await this.__setup(command)
+        return
+      }
+      this.onMainThreadMessage(command);
+    }
+    if(this.mainThread instanceof DedicatedWorkerGlobalScope){
+      ////console.log('Running in DedicatedWorkerGlobalScope');
+      (this.mainThread as IWorkerGlobalScope).onmessage = onmessage
+    }
+    else if(this.mainThread instanceof SharedWorkerGlobalScope){
+      (this.mainThread as ISharedWorkerGlobalScope).port.onmessage = onmessage
+    }
+  }
+
+
+  command(destination: string | string[], resultType: AdapterWorkerResultType, result: any){
+    ////console.log('AdapterWebsocketWorker: command', destination, resultType, result)
+    result = this.encode(result) as ArrayBuffer
+    const message: AdapterWorkerMessage = {
+      type: 'result',
+      resultType,
+      result
+    }
+    const transferable = result as Transferable
+    if(destination.includes('toChannel')){
+      const resultTypeCap = resultType.charAt(0).toUpperCase() + resultType.slice(1)
+      message.type = resultTypeCap
+      this.postMessageChannel( message, [transferable] )
+    } 
+    if(destination.includes('toAdapter')){  
+      this.postMessageAdapter( message, [transferable] )
+    }
+  }
+
+  postMessageAdapter( command: AdapterWorkerMessage, transfer?: Transferable[] ): void {
+    if(!this?.mainThread) return console.warn(`cannot send message to mainThread: undefined`)
+    this.mainThread.postMessage( command, transfer )
+  }
+
+  postMessageChannel( command: AdapterWorkerMessage, transfer?: Transferable[]  ): void {
+    if(!this?.channel) return console.warn(`cannot send message through message channel: undefined`)
+    if(transfer) {
+      return this.channel.postMessage( command, transfer )
+    }
+    this.channel.postMessage( command )
+  }
+  // overloads
+  async onMainThreadMessage(command: AdapterWorkerMessage): Promise<void>{ return console.warn(`onMainThreadMessage not overloaded by adapter, so the following is going nowhere fast:`, command)  }
+  async onChannelMessage(command: AdapterWorkerMessage): Promise<void>{ return console.warn(`onChannelMessage not overloaded by adapter, so the following is going nowhere fast:`, command) }
+  async onMessageError(){}
+  async onError(){}
+
+  encode (json: IEvent[] | IEvent): ArrayBuffer {
+    return Workers.encodeNostrEventArrayAsBuffer(json)
+  }
+
+  decode (arrayBuffer: ArrayBuffer): IEvent[] | IEvent {
+    return Workers.decodeNostrEventArrayFromBuffer(arrayBuffer)
+  }
+
+
+  /*sanity check*/
+
+  private pingChannel(){
+    ////console.log(`[Worker:${this.constructor.name}] o/o SEND: PING -> channel`)
+    this.postMessageChannel({ type: 'ping' })
+  }
+
+  private pongMainThread(){
+    ////console.log(`[Worker:${this.constructor.name}] o/o SEND: PONG -> mainthread`)
+    this.postMessageAdapter({ type: 'pong', })
+  }
+
+  private pongChannel(){
+    ////console.log(`[Worker:${this.constructor.name}] o/o SEND: PONG -> channel`)
+    this.postMessageChannel({ type: 'pong' })
+  }
+
+  private listenPingPong(from: 'channel' | 'mainthread', command: AdapterWorkerMessage): void {
+    if(command.type === 'ping') {
+      ////console.log(`[Worker:${this.constructor.name}] o/o RECIEVE: PING <- ${from}`)
+      if(from === 'mainthread'){
+        this.pingChannel()
+        this.pongMainThread()
+      }
+      if(from === 'channel'){
+        this.pongChannel()
+      }
+      return
+    }
+    if(command.type === 'pong') {
+      ////console.log(`[Worker:${this.constructor.name}] o/o RECIEVE: PONG <- ${from}`)
+    }
+  }
+
+}

package/src/core/Base.ts

@@ -0,0 +1,212 @@
+import type { IWebsocketAdapter, SubscribeHandlers, WebsocketRequestBody } from './WebsocketAdapter';
+import type { ICacheAdapter } from './CacheAdapter';
+
+import type { RelayService as RelayServiceType } from '../services/RelayService';
+import type { MonitorService as MonitorServiceType } from '../services/MonitorService';
+
+import type { IAdaptersArgument } from '@base/interfaces/IAdaptersArgument';
+
+import type { Workers } from './Workers';
+import { StateManager } from '@base/managers/StateManager';
+import { delay } from '@nostrwatch/utils';
+import { IEvent } from '@base/interfaces';
+
+type AnyAdapter = IWebsocketAdapter | ICacheAdapter;
+
+export type Nip66Services = { 
+  monitors?: MonitorServiceType, 
+  relay?: RelayServiceType,
+} 
+ 
+export class Route66 {
+
+  public relayService?: RelayServiceType;
+  public monitorService?: MonitorServiceType;
+
+  private websocketAdapter?: IWebsocketAdapter;  
+  private cacheAdapter?: ICacheAdapter;
+
+  private _initialized: boolean = false;  
+
+  constructor(
+    private _adapters: IAdaptersArgument,
+    // private relayUrls: string[]
+  ) {
+    console.log(`Route66 Core Initialized`)
+    if(_adapters?.websocketAdapter)
+      this.useAdapter(_adapters.websocketAdapter)
+    if(_adapters?.cacheAdapter)
+      this.useAdapter(_adapters.cacheAdapter)
+  }
+
+  get adapters(): IAdaptersArgument {
+    return this._adapters;
+  }
+
+  get services(): Nip66Services {
+    return {
+      monitors: this.monitorService,
+      relay: this.relayService
+    }
+  }
+
+  get monitors(): MonitorServiceType | undefined {
+    return this.monitorService;
+  }
+
+  get relays(): RelayServiceType | undefined {
+    return this.relayService;
+  }
+
+  private set initialized(value: boolean) {
+    this._initialized = value;
+  }
+
+  get initialized(): boolean {
+    return this._initialized;
+  }
+
+  async ready(): Promise<Route66> {
+    while(!this.initialized){
+      await new Promise(resolve => setTimeout(resolve, 100))
+    }
+    return this;
+  }
+
+  on(event: string, listener: (...args: any[]) => void): void {
+    StateManager.on(event, listener);
+  }
+
+  once(event: string, listener: (...args: any[]) => void): void {
+    StateManager.once(event, listener);
+  }
+
+  off(event: string, listener: (...args: any[]) => void): void {
+    StateManager.off(event, listener);
+  }
+
+  destroy(): void {
+    StateManager.emit('destroy');
+  }
+
+  async boot(): Promise<void> {
+    this.init();
+    await this.ready();
+    // await this.monitorService?.bootstrap();
+  }
+
+  async shutdown(): Promise<void> {
+    this.destroy();
+    this.adapters?.cacheAdapter?.shutdown();
+    await this.adapters?.websocketAdapter?.shutdown();
+  }
+
+  async restart(): Promise<void> {
+    await this.shutdown();
+    await delay(1000);
+    await this.boot();
+  }
+
+  async useAdapter(adapter?: ICacheAdapter | IWebsocketAdapter): Promise<void> {
+    if(!adapter) {
+      return console.warn('No adapter provided')
+    }
+    if(typeof adapter === 'function') {
+      return console.warn('Adapter should be an instantiated CacheAdapter or WebsocketAdapter')
+    }
+    if(this.isCacheAdapter(adapter) && !this?.cacheAdapter){
+      this.cacheAdapter = adapter as ICacheAdapter
+      return
+    }
+    if(this.isWebsocketAdapter(adapter) && !this?.websocketAdapter){
+      this.websocketAdapter = adapter as IWebsocketAdapter
+      return
+    } 
+    console.warn(`Adapter not recognized: ${adapter.constructor.name} [should be instance of WebsocketAdapter or CacheAdapter]`)
+  }
+
+  isCacheAdapter(adapter: AnyAdapter): boolean {
+    return (adapter.constructor as any).type === 'CacheAdapter';
+  }
+
+  isWebsocketAdapter(adapter: AnyAdapter): boolean {
+    return (adapter.constructor as any).type === 'WebsocketAdapter';
+  }
+  
+  async init() {
+    await this.setupWorkers()
+    await this.setupServices()
+    await this.adaptersReady()
+    this.initialized = true;
+  }
+
+  async adaptersReady(){
+    if(this?.cacheAdapter)
+      await this?.cacheAdapter.ready()
+    if(this?.websocketAdapter)
+      await this?.websocketAdapter.ready()
+  }
+
+  async setupWorkers(){
+    const { Workers } = await import('./Workers')
+    const workers: Workers = new Workers(this.adapters)
+    
+    //TODO: Replace with emitter
+    while(!workers.ready){ await new Promise(resolve => setTimeout(resolve, 100)) }
+
+    ////console.log('workers ready', workers)
+    if(this?.adapters?.cacheAdapter)
+      this.adapters.cacheAdapter.workers = workers
+    if(this?.adapters?.websocketAdapter)
+      this.adapters.websocketAdapter.workers = workers
+  }
+
+  async setupServices(){
+    if(!this?.websocketAdapter || !this?.cacheAdapter) return 
+    const { cacheAdapter, websocketAdapter } = this
+    const { RelayService } = await import('../services/RelayService')
+    const { MonitorService } = await import('../services/MonitorService')
+    this.monitorService = new MonitorService({cacheAdapter, websocketAdapter} as IAdaptersArgument);
+    this.relayService = new RelayService({cacheAdapter, websocketAdapter} as IAdaptersArgument, this.monitorService);
+    await this.monitorService.ready();
+    await this.relayService.ready();
+  }
+
+  get state(): StateManager {
+    return StateManager;
+  } 
+
+  get cache(): ICacheAdapter | undefined {
+    return this.cacheAdapter;
+  }
+
+  get websocket(): IWebsocketAdapter | undefined {
+    return this.websocketAdapter;
+  }
+
+  get wsWorker(): Worker | SharedWorker | undefined {
+    return this?.websocketAdapter?.workers?.websocket;
+  }
+  get cacheWorker():  SharedWorker | Worker | undefined {
+    return this?.cacheAdapter?.workers?.cache;
+  }
+
+  ping(): void {
+    this.cacheAdapter?.ping()
+    this.websocketAdapter?.ping()
+  }
+
+  async subscribe(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean> {
+    return this.websocketAdapter?.subscribe(args, callbacks) ?? false
+  }
+
+  async fetch(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean> {
+    return this.websocketAdapter?.fetch(args, callbacks) ?? false
+  }
+
+  async REQ(filters: any): Promise<IEvent[] | undefined> {
+    return this.cacheAdapter?.REQ(filters)
+  }
+}
+
+export default Route66;

package/src/core/Batcher.ts

@@ -0,0 +1,78 @@
+type BatchCallback<T, S> = (batch: T[], state: S | undefined, id: string | undefined) => void;
+
+export interface BatchOptions<T, S> {
+  maxLength: number;
+  timeout: number;
+  callback: BatchCallback<T, S>;
+}
+
+export class Batcher<T, S> {
+  private batches: Map<string | undefined, { items: T[]; state?: S; lastBatchTime: number }> = new Map();
+  private timeoutIds: Map<string | undefined, ReturnType<typeof setTimeout>> = new Map();
+
+  constructor(private readonly options: BatchOptions<T, S>) {}
+
+  add(item: T, id?: string, state?: S): void {
+    if (!this.batches.has(id)) {
+      this.batches.set(id, { items: [], state, lastBatchTime: Date.now() });
+    }
+
+    const batch = this.batches.get(id)!;
+
+    if (state !== undefined) {
+      batch.state = state;
+    }
+
+    batch.items.push(item);
+
+    if (batch.items.length >= this.options.maxLength) {
+      this.executeBatch(id);
+    }
+
+    if (!this.timeoutIds.has(id)) {
+      this.startTimeout(id);
+    }
+  }
+
+  private executeBatch(id?: string): void {
+    const batch = this.batches.get(id);
+    if (!batch || batch.items.length === 0) return;
+
+    this.options.callback(batch.items, batch.state, id);
+
+    batch.items = [];
+    batch.lastBatchTime = Date.now();
+
+    if (this.timeoutIds.has(id)) {
+      clearTimeout(this.timeoutIds.get(id)!);
+      this.timeoutIds.delete(id);
+    }
+  }
+
+  private startTimeout(id?: string): void {
+    const batch = this.batches.get(id);
+    if (!batch) return;
+
+    const timeoutId = setTimeout(() => {
+      const now = Date.now();
+      if (now - batch.lastBatchTime >= this.options.timeout) {
+        this.executeBatch(id);
+      }
+    }, this.options.timeout);
+
+    this.timeoutIds.set(id, timeoutId);
+  }
+
+  hasState(id?: string): boolean {
+    const batch = this.batches.get(id);
+    return batch?.state !== undefined;
+  }
+
+  abort(): void {
+    for (const timeoutId of Array.from(this.timeoutIds.values())) {
+      clearTimeout(timeoutId);
+    }
+    this.batches.clear();
+    this.timeoutIds.clear();
+  }
+}

package/src/core/CacheAdapter.ts

@@ -0,0 +1,186 @@
+import { ICheck, IEvent, IMonitor, IRelay } from '@base/models';
+import { Adapter, IAdapter } from './Adapter'
+import { StateManager } from '@base/managers/StateManager';
+
+export interface GeohashOptions {
+  maxDistance?: number; 
+  minResults?: number;
+}
+
+/******
+ * 
+ * CHECK
+ *    TYPES/INTERFACES/DEFAULTS
+ * 
+ */
+
+export type GetCheckParameters = GetCheckParameters1 | GetCheckParameters2
+
+interface GetCheckParameters1 {
+  relay: string, 
+  monitorPubkey: string
+}
+
+interface GetCheckParameters2 {
+  nid: string, 
+}
+
+export interface GetChecksParameters {
+  nid?: string, 
+  relay?: string, 
+  monitorPubkey?: string
+  supportedNips?: string[],
+  isp?: string,
+  asname?: string,  
+  as?: string,
+  network?: string,
+  relayType?: string,
+  paymentRequired?: boolean,
+  authRequired?: boolean
+  
+  created_at?: number
+  rtt?: number,
+}
+
+export interface ChecksResult {
+  [key: string]: CheckResult
+}
+
+export interface CheckResult {
+  record?: ICheck,
+  check?: IEvent,
+}
+
+export type CheckResultKeys = (keyof CheckResult)[]
+
+export const defaultCheckResultKeys: CheckResultKeys = ['check']
+
+/******
+ * 
+ * MONITOR
+ *    TYPES/INTERFACES/DEFAULTS
+ * 
+ */
+
+export interface GetMonitorsParameters {
+  monitorPubkey?: string, 
+  checks?: string[],
+  geohash?: string[]
+}
+
+export interface GetMonitorParameters {
+  monitorPubkey: string 
+}
+
+export interface MonitorsResult {
+  [key: string]: MonitorResult
+}
+
+export interface MonitorResult {
+  record?: IMonitor,
+  registration?: IEvent,
+  profile?: IEvent,
+  relayList?: IEvent,  
+}
+
+export type MonitorResultKeys = (keyof MonitorResult)[]
+
+export const defaultMonitorResultKeys: MonitorResultKeys = ['profile', 'registration', 'relayList']
+
+/******
+ * 
+ * RELAY
+ *    TYPES/INTERFACES/DEFAULTS
+ * 
+ */
+
+export interface GetRelaysParameters {
+  relay?: string | string[],
+  network?: string | string[]
+  lastSeen?: number
+}
+
+export interface RelaysResult {
+  [key: string]: RelayResult
+}
+
+export interface RelayResult {
+  record?: IRelay,
+  checkRecords?: ICheck[],
+  checks?: IEvent[]
+}
+
+export type RelayResultKeys = (keyof RelayResult)[]
+
+export const defaultRelayResultKeys: RelayResultKeys = ['record']
+
+export interface ICacheAdapter extends IAdapter {
+  init?(): Promise<void>;
+  ready(): Promise<void>;
+
+  REQ(filters: any[]): Promise<IEvent[]>;
+  COUNT(filters: any[]): Promise<number>;
+  DELETE(filters: any[]): Promise<string[]>;
+  DUMP(): Promise<Uint8Array>;
+  CLOSE(subId: string): Promise<boolean>;
+  WIPE(): Promise<boolean>;
+
+  countNip11s?(): Promise<number>;
+  countUniqueNip11s?(): Promise<number>;
+  batchUpsertNip11?(relayNip11s: {relay: string, nip11: any}[]): Promise<boolean>;
+  upsertNip11?(relay: string, nip11: any): Promise<void>;
+  getNip11?(relay: any): Promise<any>;  
+
+  addEvent(event: IEvent): Promise<void>;
+  addEvents(events: IEvent[]): Promise<void>;
+  putEvent(event: IEvent): Promise<void>;
+
+  patchRelay?(relay: Partial<IRelay>): Promise<void>;
+  updateRelay?(relay: IRelay): Promise<void>;
+
+  handleSetupInternally?: boolean;
+}
+
+export class CacheAdapter extends Adapter {
+  static type = 'CacheAdapter';
+  readonly slug: string = 'CacheAdapter:unset'; 
+  protected _ready: boolean = false;
+
+  constructor(worker?: Worker | SharedWorker | URL) {  
+    super(worker)
+    // StateManager.on('destroy', () => {
+    //   if(this.worker instanceof Worker) {
+    //     this.worker?.terminate()
+    //   }
+        
+    // })
+    this.init();
+  }
+  
+  get worker(): Worker | SharedWorker | undefined {
+    return this.workers?.cache
+  }
+
+  async ready(): Promise<void> {}
+
+  async init(): Promise<void> {
+    this._ready = true;
+  }
+
+  protected bindWorkerHandlers(): void {
+    if(!this?.workers?.cache) return console.warn('[CacheAdapter] Error binding worker handlers: no worker found')
+    if(this.workers.cache instanceof Worker)
+      this.workers.cache.onmessage = this._onMessage.bind(this);
+    else if(this.workers.cache instanceof SharedWorker)
+      this.workers.cache.port.onmessage = this._onMessage.bind(this);
+    this.workers.cache.onerror = this._onError.bind(this)
+  }
+
+  ping(): void {
+    ////console.log(`[CacheAdapter:${this.constructor.name}] o/o SEND: PING -> cacheWorker`)
+    if(this.workers?.cache instanceof Worker)
+      this.workers?.cache?.postMessage({type: 'ping'})
+    else if (this.workers?.cache instanceof SharedWorker)
+      this.workers?.cache?.port.postMessage({type: 'ping'})
+  }
+}

package/src/core/Checkpoints.ts

@@ -0,0 +1,11 @@
+import { LocalStorageWrapper } from './LocalStorageWrapper';
+
+export default class {
+  private readonly prefix: string = 'checkpoint'
+  static measurement: string = 's'
+  private localStorage: LocalStorageWrapper = new LocalStorageWrapper(this.prefix)
+
+  constructor(){}
+
+  async init(){}
+}