@nostrwatch/route66 0.0.1

package/src/core/Adapter.ts

@@ -0,0 +1,182 @@
+
+import { Workers } from './Workers';
+import { LocalStorageWrapper } from './LocalStorageWrapper';
+
+import type { IEvent } from '@base/interfaces';
+import type { IAdapterWorkerCommand } from '@base/interfaces/IAdapterWorkerCommand';
+import type { AdapterWorkerCommand, AdapterWorkerMessage } from './AdapterWorker';
+import { EventEmitter } from 'tseep';
+
+export interface AdapterMessage {
+  type?: string;
+  hash?: string;
+  args?: any;
+  [key: string]: any;
+}
+
+export interface IAdapter {
+  workers?: Workers;
+  worker?: Worker | SharedWorker;
+  useWorker: boolean;
+
+  newWorker(channelPort?: MessagePort): Promise<Worker | SharedWorker>;
+
+  ping(): void;
+
+  abort(): Promise<boolean>
+  shutdown(): Promise<void>
+
+  // overloads
+  onMessage(command: IAdapterWorkerCommand): void;
+  onError(error: any): void;
+  ready(): Promise<void>;
+}
+
+interface WorkerPaths {
+  workerPath: URL;
+  sharedWorkerPath: URL;
+}
+
+export abstract class Adapter {
+  readonly slug: string = 'Adapter:unset'; 
+
+  private _ls: LocalStorageWrapper;
+  private _workers?: Workers
+  private _worker?: Worker | SharedWorker;
+
+  protected _overloadWorker?: Worker | SharedWorker;
+
+  protected _ready: boolean = false;
+
+  useWorker: boolean = true;
+
+  protected emitter: EventEmitter = new EventEmitter();
+
+  handleSetupInternally: boolean = false;
+
+  constructor( worker?: Worker | SharedWorker | URL, shared?: boolean ) {
+    if (worker instanceof Worker) {
+      this.overloadWorker = worker;
+    } else if(worker instanceof URL) {
+      if(shared) {
+        this.overloadWorker = new SharedWorker(worker, { type: "module" });
+      }
+      else {
+        this.overloadWorker = new Worker(worker, { type: "module" });
+      }
+    }
+    this._ls = new LocalStorageWrapper(['route66', this.slug])
+  }
+
+  get overloadWorker(): Worker | SharedWorker | undefined {
+    return this._overloadWorker;
+  }
+
+  private set overloadWorker(worker: Worker | SharedWorker) {
+    this._overloadWorker = worker;
+  }
+
+  get localStorage(): LocalStorageWrapper {
+    return this._ls;
+  }
+
+  set workers(workers: Workers) {
+    this._workers = workers;
+    this._bindWorkerHandlers()
+  }
+
+  get workers(): Workers | undefined {
+    return this._workers;
+  }
+
+  get worker(): Worker | SharedWorker | undefined {
+    return undefined;
+  }
+
+  async healthCheck(): Promise<boolean> {
+    if(this.workers?.cache) {
+      this.ping()
+    }
+    const healthy = await this.pong();
+    return healthy;
+  }
+
+  ping(): void {
+    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' })
+    }
+  }
+
+  async pong(): Promise<boolean> {
+    return new Promise( resolve => {
+      const timeout = setTimeout(() => {
+        resolve(false)
+      }, 1000)
+      const listener = (event: MessageEvent) => {
+        const message = event.data as AdapterMessage;
+        if(message.type == 'pong') {
+          clearTimeout(timeout)
+          resolve(true)
+        }
+      }
+      this.emitter.once('pong', listener)
+    })
+  }
+
+  async shutdown(): Promise<void> {
+    if(this?.worker) {
+      if(this?.worker instanceof Worker){
+        this.worker?.terminate()
+      }
+    }
+    // this.emitter.emit('shutdown')
+  }
+
+  async newWorker(): Promise<any> {
+    if(this?.overloadWorker) {
+      return this.overloadWorker;
+    }
+    throw new Error('Method not implemented.');
+  }
+
+  async ready(): Promise<void> {
+    this._ready = true;
+    return;
+  }
+
+  get isReady(): boolean { 
+    return this._ready;
+  }
+
+  private _bindWorkerHandlers(): void {
+    this.bindWorkerHandlers()
+  }
+
+  protected _onMessage(event: MessageEvent): void {
+    const message = event.data as AdapterMessage;
+    this.onMessage(message);
+  }
+
+  protected _onError(error: any): void {
+    this.onError()
+  }
+
+  protected bindWorkerHandlers(): void {
+    console.warn('bindWorkerHandlers is not implemented by class that extends Adapter')
+  }
+  
+  //overloads
+  onMessage(message: AdapterWorkerMessage): void {} 
+  onError(): void {}
+
+  encode (json: IEvent[] | IEvent ): ArrayBuffer {
+    return Workers.encodeNostrEventArrayAsBuffer(json)
+  }
+
+  decode (arrayBuffer: ArrayBuffer): IEvent[] | IEvent {
+    return Workers.decodeNostrEventArrayFromBuffer(arrayBuffer)
+  }
+}

package/src/core/AdapterCacheWorker.ts

@@ -0,0 +1,83 @@
+import PQueue from "p-queue";
+import { AdapterWorker, AdapterWorkerResult, WorkerOptions } from "./AdapterWorker"
+import { AdapterWorkerCommand } from "./AdapterWorker";
+import type { IEvent } from "@models/Event";
+
+export interface AdapterCacheWorkerCommand extends AdapterWorkerCommand {
+  type: "setup" | "cacheEvent" | "cacheEvents" | "complete";
+}
+
+export interface AdapterCacheWorkerResult extends AdapterWorkerResult {
+  type: "events" | "event" | "eventsBuffer" | "record" ;
+}
+
+export interface IAdapterCacheWorker {
+  setup(command: AdapterCacheWorkerCommand): void;
+  addEvent(events: IEvent): Promise<void>;
+  addEvents(events: IEvent[]): Promise<void>;
+}
+
+export class AdapterCacheWorker extends AdapterWorker {
+
+  private queue: PQueue = new PQueue({concurrency: 20})
+
+  constructor( options?: WorkerOptions ){
+    super(options)
+  }
+
+  //begin: overloads
+  async setup(command: AdapterCacheWorkerCommand): Promise<void> { return void 0 }
+  async addEvent(event: IEvent): Promise<void> { return void 0 }
+  async addEvents(events: IEvent[]): Promise<void> { return void 0 }  
+  
+  async abort(): Promise<boolean> {
+    return true
+  }
+
+  async shutdown(): Promise<void> {
+    return void 0
+  }
+  
+  //end: overloads
+
+  async addToQueue( command: AdapterCacheWorkerCommand){
+    const priority = 10
+
+    this.queue.add(async () => {
+      const { result } = command
+      if(!result) return console.warn('result is not defined')
+      const event = this.decode(result)
+      if(event instanceof Array) {
+        await this.addEvents(event)
+      }
+      else {
+        await this.addEvent(event)
+      }
+    }, { priority })
+  }
+
+  async onMessage(command: AdapterCacheWorkerCommand): Promise<void>{
+    ////console.log('AdapterCacheWorker: onMessage', command)
+    const { type, result } = command
+    if(type === 'complete') return;
+    if(!result) return console.warn('result is not defined', command)
+    const event = this.decode(result)
+    if(event instanceof Array) {
+      await this.addEvents(event)
+    }
+    else {
+      await this.addEvent(event)
+    }
+  }
+
+  async onMainThreadMessage(command: AdapterCacheWorkerCommand): Promise<void> {
+    // this.onMessage(command)
+    return void 0;
+  }
+
+  async onChannelMessage(command: AdapterCacheWorkerCommand): Promise<void>  {
+    ////console.log('AdapterCacheWorker: onChannelMessage', command)
+    this.onMessage(command)
+  }
+  
+ }

package/src/core/AdapterWebsocketQueue.ts

@@ -0,0 +1,20 @@
+import { 
+  AdapterWebsocketWorkerCommand 
+} from "@base/core";
+
+import { 
+  Queue
+} from "@nostrwatch/route66/core";  
+
+const DEFAULT_CONCURRENCY = 1;
+
+export type AdapterWebsocketQueueWorker = (task: AdapterWebsocketWorkerCommand) => Promise<void>;
+
+export class AdapterWebsocketQueue extends Queue<AdapterWebsocketWorkerCommand> {
+  constructor(
+    taskWorker: AdapterWebsocketQueueWorker, 
+    concurrency: number = DEFAULT_CONCURRENCY) 
+  {
+    super(taskWorker, concurrency);
+  }
+}

package/src/core/AdapterWebsocketWorker.ts

@@ -0,0 +1,307 @@
+import { Filter } from "nostr-tools";
+import { 
+  AdapterWorkerCommand,
+  AdapterWorker, 
+  AdapterWorkerResultType, 
+  WorkerOptions 
+} from "./AdapterWorker"
+import { IEvent } from "@base/models";
+import { defaultWebsocketAdapterOptions, defaultWebsocketRequest, defaultWebsocketRequestBody, SubscribeHandlers, WebsocketAdapterFetchOptions, WebsocketAdapterOptions, WebsocketRequest, WebsocketRequestBody } from "./WebsocketAdapter";
+import { Batcher } from "./Batcher";
+
+export enum ResponseType {
+  event = 'event',
+  events = 'events',
+  complete = 'complete',
+  error = 'error',
+  unsubscribed = 'unsubscribed',
+  aborted = 'aborted',
+  terminated = 'terminated'
+}
+
+export interface AdapterWebsocketWorkerOptions {
+  connectToRelays: string[]
+}
+
+export type AdapterWebsocketWorkerCommandTypes = "subscribe" | "fetch"
+
+export interface AdapterWebsocketWorkerCommand extends AdapterWorkerCommand {
+  type: AdapterWebsocketWorkerCommandTypes
+  hash: string,
+  filters: Filter[];
+  options?: AdapterWebsocketWorkerOptions
+}
+
+interface WebsocketResponse extends WebsocketResponseHeaders {
+  args: WebsocketResponseBody
+}
+
+interface WebsocketResponseHeaders {
+  to: 'cache' | 'adapter',
+}
+
+export type WebsocketResponseBody = {
+  type: 'event' | 'events' | 'error' | 'complete' | 'unsubscribed' | 'aborted' | 'terminated',
+  result: any,
+  hash: string
+}
+
+export const defaultWebsocketResponseHeaders: WebsocketResponseHeaders = { 
+  to: 'cache'
+}
+
+export const defaultWebsocketResponseBody: WebsocketResponseBody = {
+  type: 'event',
+  result: null,
+  hash: ''
+}
+
+export const defaultWebsocketResponse: WebsocketResponse = {
+  ...defaultWebsocketResponseHeaders,
+  args: defaultWebsocketResponseBody
+}
+
+export type WebsocketAdapterResult = void | undefined | IEvent | IEvent[];
+
+export interface IAdapterWebsocketWorker {
+  setup(command: AdapterWebsocketWorkerCommand): Promise<void>;
+  subscribe( request: WebsocketRequestBody ): Promise<void>;
+  fetch( request: WebsocketRequestBody ): Promise<void>;
+  publish( request: WebsocketRequestBody ): Promise<void>;
+
+  signal: AbortSignal;
+  controller: AbortController;
+}
+
+export class AdapterWebsocketWorker extends AdapterWorker {
+  protected relays: string[] = ['wss://relaypag.es/', 'wss://relay.nostr.watch/']
+  private batchQueue: IEvent[] = []
+  private batcher: Batcher<IEvent, WebsocketRequestBody>;
+  protected _controller: AbortController = new AbortController();
+  protected _signal: AbortSignal = this._controller.signal;
+
+  constructor( options?: WorkerOptions ){
+    ////console.log ('AdapterWebsocketWorker', options)
+    super(options)
+    this.batcher = new Batcher<IEvent, WebsocketRequestBody>({
+      maxLength: 100, 
+      timeout: 2000,
+      callback: this.batchResponse.bind(this)
+    })
+  }
+
+  get signal(): AbortSignal { return this._signal }
+  get controller(): AbortController { return this._controller }
+
+  async _setup(command: AdapterWorkerCommand): Promise<void>{
+    const { options } = command
+    let connectToRelays 
+    if(options){
+      connectToRelays = options.connectToRelays
+    }
+    if( connectToRelays ){
+      this.relays = connectToRelays
+    }
+    if( !this.relays.length  ){
+      console.warn('AdapterWebsocketWorker: cannot connect to relays, length is 0')
+    }
+  }
+
+  async onMainThreadMessage(request: WebsocketRequest): Promise<void> {
+    this.onMessage(request)
+  }
+
+  async onChannelMessage(request: WebsocketRequest): Promise<void>  {
+    this.onMessage(request)
+  }
+
+  onMessage(request: WebsocketRequest = defaultWebsocketRequest){
+    const { action, args } = request
+    if(action === 'publish'){
+      return this.publish(args)
+    }
+    if(action === 'subscribe'){
+      return this.subscribe(args)
+    }
+    if(action === 'fetch'){
+      return this.fetch(args)
+    }
+    if(action === 'unsubscribe'){
+      return this.unsubscribe(args)
+    }
+    if(action === 'abort'){
+      return this._abort()
+    }
+    console.warn('AdapterWebsocketWorker: onMessage: did not match any command', request)
+  }
+
+  send(response: WebsocketResponse = defaultWebsocketResponse){
+    //console.log('send.')
+    const { to, args } = response
+    let sent = false
+    if(to === 'adapter'){
+      if(!this?.mainThread) return console.warn('AdapterWebsocketWorker: mainThread not found')
+      this.mainThread.postMessage(args)
+      sent = true
+    }
+    if(to === 'cache'){
+      if(!this.channel) return console.warn('AdapterWebsocketWorker: channel not found')
+      this.channel.postMessage(args)
+      sent = true
+    }
+    if(!sent) console.warn('AdapterWebsocketWorker: send: did not send to any destination')
+  }
+
+  async publish(request: WebsocketRequestBody = defaultWebsocketRequestBody ){
+    if(this.signal.aborted) this.abortControllerReset()
+    const success = await this._publish(request)
+    const responseType = success? ResponseType.complete : ResponseType.error
+    if(success){ 
+      this.respond(responseType, request)
+    }
+  }
+
+  async _publish(request: WebsocketRequestBody = defaultWebsocketRequestBody): Promise<boolean> {
+    throw new Error(`${this.constructor.name}:_publish() not implemented!`)
+  }
+
+  async subscribe( request: WebsocketRequestBody = defaultWebsocketRequestBody ){
+    if(this.signal.aborted) this.abortControllerReset()
+    const { options } = request
+    const { stream } = options ?? defaultWebsocketAdapterOptions;
+    let callbacks: SubscribeHandlers | undefined;
+    if(stream){
+      callbacks = this.requestCallbacks(request);
+    }
+    const result = await this._subscribe(request, callbacks)
+    if(!stream){
+      this.requestSyncResponse(request, result as IEvent[])
+    }
+    if( !options?.keepAlive ){
+      this.respond(ResponseType.complete, request)
+    }
+  }
+
+  unsubscribe(args: WebsocketRequestBody){ args }
+
+  async _subscribe(request: WebsocketRequestBody = defaultWebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean> { 
+    throw new Error(`${this.constructor.name}:_subscribe() not implemented!`)
+  }
+
+  async fetch(request: WebsocketRequestBody = defaultWebsocketRequestBody){
+    if(this.signal.aborted) this.abortControllerReset()
+    const { options, hash } = request
+    const { stream } = options ?? defaultWebsocketAdapterOptions;
+    console.log(`[Worker] fetch: hash=${hash?.slice(0,8)}, stream=${stream}, returnResults=${options?.returnResults}`);
+    let callbacks: SubscribeHandlers | undefined;
+    if(stream){
+      callbacks = this.requestCallbacks(request);
+    }
+    const result = await this._fetch(request, callbacks)
+    console.log(`[Worker] fetch: _fetch returned ${Array.isArray(result) ? result.length + ' events' : typeof result}`);
+    if(!stream){
+      this.requestSyncResponse(request, result as IEvent[])
+    }
+    this.respond(ResponseType.complete, request)
+  }
+
+  async _fetch(request: WebsocketRequestBody = defaultWebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean> {
+    throw new Error(`${this.constructor.name}:_fetch() not implemented!`)
+  }
+
+  _abort(){
+    this.batcher.abort()
+    this.abort()
+    return this.send({to: 'adapter', args: {type: ResponseType.complete, result: null, hash: 'abort'}})
+  }
+
+  //override.
+  abort(){}
+
+  abortControllerReset(){
+    this._controller = new AbortController();
+    this._signal = this._controller.signal;
+  }
+
+  respond(type: ResponseType, request: WebsocketRequestBody, result?: IEvent | IEvent[]){
+    const { hash, options } = request;
+    const { cache, returnResults } = options;
+
+    console.log(`[Worker] respond: type=${type}, hash=${hash?.slice(0,8)}, returnResults=${returnResults}, cache=${cache}`);
+
+    const response = {
+      type,
+      result,
+      hash: hash as string
+    }
+
+    if(cache === true) {
+      this.send({to: 'cache', args: response})
+    }
+    if(returnResults === true){
+      console.log(`[Worker] sending to adapter: type=${type}`);
+      this.send({to: 'adapter', args: response})
+    }
+  }
+
+  batchResponse(events: IEvent[], state?: WebsocketRequestBody, id?: string){
+    if(!state) throw new Error('AdapterWebsocketWorker: batchResponse: state is undefined')
+    this.respond(ResponseType.events, state, events)
+  }
+
+  requestCallbacks(request: WebsocketRequestBody = defaultWebsocketRequestBody): SubscribeHandlers {
+    const { options, hash } = request
+    const { batch } = options
+    const onevent = (event: unknown) => {
+      let result: IEvent | IEvent[];
+      if(typeof batch === 'number') {
+        const state = !this.batcher.hasState(hash) ? request : undefined
+        this.batcher.add(event as IEvent, hash, state)
+      }
+      else {
+        result = event as IEvent;
+        this.respond(ResponseType.event, request, event as IEvent)
+      }
+    }
+    const oneose = () => {
+      // this.respond(ResponseType.complete, request)
+    }
+    return { onevent, oneose }
+  }
+
+  requestSyncResponse(request: WebsocketRequestBody, result: IEvent[]){
+    const { hash, options } = request
+    const { cache, returnResults } = options
+    console.log(`[Worker] requestSyncResponse: hash=${hash?.slice(0,8)}, events=${result?.length ?? 0}, returnResults=${returnResults}, cache=${cache}`);
+    let args: WebsocketResponseBody = {
+      type: ResponseType.events,
+      result,
+      hash: hash as string
+    }
+    if(cache === true) {
+      this.send({to: 'cache', args})
+    }
+    if(returnResults === true){
+      console.log(`[Worker] requestSyncResponse: sending ${result?.length ?? 0} events to adapter`);
+      this.send({to: 'adapter', args})
+    }
+    //complete message.
+    args = {
+      ...defaultWebsocketResponseBody,
+      result: result.length > 0,
+      type: ResponseType.complete,
+      hash: hash as string
+    }
+    if(cache === true) {
+      this.send({to: 'cache', args})
+    }
+    // if(returnResults === true){
+      //always send complete?
+      this.send({to: 'adapter', args})
+    // }
+  }
+
+  private _getUniquePubkeys(events: IEvent[]): string[] {
+    return Array.from(new Set(events.map(event => event.pubkey)))
+  }
+ }