@xyo-network/bridge-http 2.107.6 → 2.109.0

package/src/HttpBridgeFull.ts

@@ -4,16 +4,45 @@ import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
 import { Address } from '@xylabs/hex'
 import { toJsonString } from '@xylabs/object'
-import { ApiEnvelopeSuccess } from '@xyo-network/api-models'
+import {
+  asyncHandler,
+  customPoweredByHeader,
+  disableCaseSensitiveRouting,
+  disableExpressDefaultPoweredByHeader,
+  jsonBodyParser,
+  responseProfiler,
+  useRequestCounters,
+} from '@xylabs/sdk-api-express-ecs'
 import { isQueryBoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
 import { BridgeExposeOptions, BridgeParams, BridgeUnexposeOptions } from '@xyo-network/bridge-model'
+import { standardResponses } from '@xyo-network/express-node-middleware'
 import { AnyConfigSchema, creatableModule, ModuleInstance, ModuleQueryResult, resolveAddressToInstanceUp } from '@xyo-network/module-model'
 import { Payload } from '@xyo-network/payload-model'
 import express, { Application, Request, Response } from 'express'
+import { StatusCodes } from 'http-status-codes'
 
 import { HttpBridgeBase } from './HttpBridgeBase'
 import { HttpBridgeConfig } from './HttpBridgeConfig'
 
+/**
+ * The type of the path parameters for the address path.
+ */
+type AddressPathParams = {
+  address: Address
+}
+
+/**
+ * The type of the request body for the address path.
+ */
+type PostAddressRequestBody = [QueryBoundWitness, undefined | Payload[]]
+
+// TODO: This does not match the error response shape of the legacy bridge BUT it its the
+// shape this bridge is currently returning.  Massage this into the standard
+// error shape constructed via middleware.
+type ErrorResponseBody = {
+  error: string
+}
+
 export interface HttpBridgeParams extends BridgeParams<AnyConfigSchema<HttpBridgeConfig>> {}
 
 @creatableModule()
@@ -22,25 +51,13 @@ export class HttpBridge<TParams extends HttpBridgeParams> extends HttpBridgeBase
   protected _exposedModules: WeakRef<ModuleInstance>[] = []
   protected _server?: Server
 
-  get app() {
-    this._app =
-      this._app ??
-      (() => {
-        const app = express()
-        app.use(express.json())
-
-        app.post<Payload[]>('/', (req, res) => {
-          this.handlePost(req, res)
-        })
-
-        return app
-      })()
-    return this._app
+  protected get app() {
+    if (!this._app) this._app = this.initializeApp()
+    return assertEx(this._app, () => 'App not initialized')
   }
 
   async exposeChild(mod: ModuleInstance, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
     const { maxDepth = 5 } = options ?? {}
-    console.log(`exposeChild: ${mod.address} ${mod?.id} ${maxDepth}`)
     assertEx(this.config.host, () => 'Not configured as a host')
     this._exposedModules.push(new WeakRef(mod))
     const children = maxDepth > 0 ? (await mod.publicChildren?.()) ?? [] : []
@@ -58,7 +75,6 @@ export class HttpBridge<TParams extends HttpBridgeParams> extends HttpBridgeBase
   override async exposeHandler(address: Address, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
     const { required = true } = options ?? {}
     const mod = await resolveAddressToInstanceUp(this, address)
-    console.log(`exposeHandler: ${address} ${mod?.id}`)
     if (required && !mod) {
       throw new Error(`Unable to find required module: ${address}`)
     }
@@ -73,11 +89,11 @@ export class HttpBridge<TParams extends HttpBridgeParams> extends HttpBridgeBase
   }
 
   override async startHandler(): Promise<boolean> {
-    return (await super.startHandler()) && this.startHttpServer()
+    return (await super.startHandler()) && (await this.startHttpServer())
   }
 
   override async stopHandler(_timeout?: number | undefined): Promise<boolean> {
-    return (await super.stopHandler()) && this.stopHttpServer()
+    return (await super.stopHandler()) && (await this.stopHttpServer())
   }
 
   override async unexposeHandler(address: Address, options?: BridgeUnexposeOptions | undefined): Promise<ModuleInstance[]> {
@@ -100,44 +116,109 @@ export class HttpBridge<TParams extends HttpBridgeParams> extends HttpBridgeBase
 
   protected async callLocalModule(address: Address, query: QueryBoundWitness, payloads: Payload[]): Promise<ModuleQueryResult | null> {
     const mod = this._exposedModules.find((ref) => ref.deref()?.address === address)?.deref()
-    if (mod) {
-      return await mod.query(query, payloads)
+    return mod ? await mod.query(query, payloads) : null
+  }
+
+  protected async handleGet(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response) {
+    const { address } = req.params
+    try {
+      if (address == this.address) {
+        res.json(await this.stateQuery(this.account))
+      } else {
+        const mod = this._exposedModules.find((ref) => ref.deref()?.address === address)?.deref()
+        // TODO: Use standard errors middleware
+        if (mod) {
+          res.json(await mod.stateQuery(this.account))
+        } else {
+          res.status(StatusCodes.NOT_FOUND).json({ error: 'Module not found' })
+        }
+      }
+    } catch (ex) {
+      // TODO: Sanitize message
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: (ex as Error).message })
     }
-    return null
   }
 
-  protected handlePost(req: Request<Payload[]>, res: Response) {
-    const allPayloads = req.body as Payload[]
-    const query = allPayloads.find(isQueryBoundWitness) as QueryBoundWitness
-    const payloads = allPayloads.filter((payload) => !isQueryBoundWitness(payload))
-    this.callLocalModule(req.route, query, payloads)
-      .then((result) => {
+  protected async handlePost(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response) {
+    const { address } = req.params
+    const [bw, payloads = []] = Array.isArray(req.body) ? req.body : []
+    const query = isQueryBoundWitness(bw) ? bw : undefined
+    if (!query) {
+      // TODO: Use standard errors middleware
+      res.status(StatusCodes.BAD_REQUEST).json({ error: 'No query provided' })
+      return
+    }
+    try {
+      if (address == this.address) {
+        const result = await this.query(query, payloads)
+        return res.json(result)
+      } else {
+        const result = await this.callLocalModule(address, query, payloads)
+        // TODO: Use standard errors middleware
         if (result === null) {
-          res.status(404).json({ error: 'Module not found' })
+          res.status(StatusCodes.NOT_FOUND).json({ error: 'Module not found' })
         } else {
-          const envelope = {
-            data: result,
-          } as ApiEnvelopeSuccess<ModuleQueryResult>
-          res.json(envelope)
+          res.json(result)
         }
-      })
-      .catch((ex) => {
-        res.status(500).json({ error: (ex as Error).message })
-      })
+      }
+    } catch (ex) {
+      // TODO: Sanitize message
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: (ex as Error).message })
+    }
   }
 
-  protected startHttpServer() {
+  protected initializeApp() {
+    // Create the express app
+    const app = express()
+
+    // Add middleware
+    app.use(responseProfiler)
+    app.use(jsonBodyParser)
+    app.use(standardResponses)
+    disableExpressDefaultPoweredByHeader(app)
+    app.use(customPoweredByHeader)
+    disableCaseSensitiveRouting(app)
+    useRequestCounters(app)
+
+    // Add routes
+    // Redirect all requests to the root to this module's address
+    app.get('/', (_req, res) => res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${this.address}`))
+    app.post('/', (_req, res) => res.redirect(StatusCodes.TEMPORARY_REDIRECT, `/${this.address}`))
+
+    app.get<AddressPathParams, ModuleQueryResult>(
+      '/:address',
+      asyncHandler(async (req, res) => await this.handleGet(req, res)),
+    )
+    app.post<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>(
+      '/:address',
+      asyncHandler(async (req, res) => await this.handlePost(req, res)),
+    )
+    return app
+  }
+
+  protected startHttpServer(): Promise<boolean> {
     if (this.config.host) {
       assertEx(!this._server, () => 'Server already started')
       this._server = this.app.listen(this.config.host?.port ?? 3030)
     }
-    return true
+    return Promise.resolve(true)
   }
 
-  protected stopHttpServer() {
-    const server = assertEx(this._server, () => 'Server not started')
-    server.close()
-    this._server = undefined
-    return true
+  protected stopHttpServer(): Promise<boolean> {
+    if (this.config.host) {
+      return new Promise((resolve, reject) => {
+        if (this._server) {
+          this._server.close((err) => {
+            if (err) {
+              reject(err)
+            } else {
+              this._server = undefined
+              resolve(true)
+            }
+          })
+        }
+      })
+    }
+    return Promise.resolve(true)
   }
 }

package/src/HttpBridgeModuleResolver.ts

@@ -65,7 +65,7 @@ export class HttpBridgeModuleResolver<
           return
         }
       }
-      const account = Account.randomSync()
+      const account = await Account.random()
       const finalParams: HttpModuleProxyParams = {
         account,
         archiving: this.params.archiving,

package/src/ModuleProxy/ModuleProxy.ts

@@ -84,7 +84,7 @@ export class HttpModuleProxy<
       dead: this.dead,
       downResolver: this.downResolver,
       logger: this.logger,
-      module: this,
+      mod: this,
       transformers: this.moduleIdentifierTransformers,
       upResolver: this.upResolver,
     }

package/xy.config.ts

@@ -13,4 +13,5 @@ const config: XyTsupConfig = {
   },
 }
 
+// eslint-disable-next-line import/no-default-export
 export default config