@xyo-network/http-call-witness 5.3.2 → 5.3.4

package/src/Payload/types/HttpCallHtmlResult.ts

@@ -1,13 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { HttpCallResultSchema } from '../Schema.ts'
-
-export type HttpCallHtmlResult = Payload<
-  {
-    call: Hash
-    contentType: 'text/html'
-    data: string
-  },
-  HttpCallResultSchema
->

package/src/Payload/types/HttpCallJsonResult.ts

@@ -1,25 +0,0 @@
-import type {
-  Hash, JsonArray, JsonObject,
-} from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/payload-model'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
-
-import { HttpCallResultSchema } from '../Schema.ts'
-import type { HttpCallResult } from './HttpCallResult.ts'
-
-export type HttpCallJsonResultType = JsonArray | JsonObject
-
-export type HttpCallJsonResult<T extends HttpCallJsonResultType = HttpCallJsonResultType> = Payload<
-  {
-    call: Hash
-    contentType: 'application/json'
-    data: T
-  },
-  HttpCallResultSchema
->
-
-export const isHttpCallJsonResult = <T extends HttpCallJsonResultType = HttpCallJsonResultType>(x?: unknown | null): x is HttpCallJsonResult<T> => {
-  return isPayloadOfSchemaType<HttpCallResult>(HttpCallResultSchema)(x) && (x as HttpCallJsonResult)?.contentType === 'application/json'
-}
-export const asHttpCallJsonResult = AsObjectFactory.create(isHttpCallJsonResult)

package/src/Payload/types/HttpCallXmlResult.ts

@@ -1,13 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { HttpCallResultSchema } from '../Schema.ts'
-
-export type HttpCallXmlResult = Payload<
-  {
-    call: Hash
-    contentType: 'application/xml' | 'text/xml'
-    data: string
-  },
-  HttpCallResultSchema
->

package/src/Payload/types/HttpMeta.ts

@@ -1,4 +0,0 @@
-export interface HttpMeta {
-  code?: string
-  status?: number
-}

package/src/Payload/types/HttpUriCall.ts

@@ -1,11 +0,0 @@
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { HttpCallSchema } from '../Schema.ts'
-import type { HttpCallFields } from './HttpCallFields.ts'
-
-export type HttpUriCall = Payload<
-  HttpCallFields & {
-    uri: string
-  },
-  HttpCallSchema
->

package/src/Payload/types/HttpUriTemplateCall.ts

@@ -1,12 +0,0 @@
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { HttpCallSchema } from '../Schema.ts'
-import type { HttpCallFields } from './HttpCallFields.ts'
-
-export type HttpUriTemplateCall = Payload<
-  HttpCallFields & {
-    params?: Record<string, string>
-    uriTemplate?: string
-  },
-  HttpCallSchema
->

package/src/Payload/types/MimeTypes.ts

@@ -1,13 +0,0 @@
-// TODO: Bring in from some library or package for completeness
-export type MimeTypes
-  = | 'application/json' // JSON format
-    | 'application/octet-stream' // Binary data
-    | 'application/pdf' // PDF format
-    | 'application/xhtml+xml' // XHTML format
-    | 'application/xml' // XML format
-    | 'image/gif' // GIF image format
-    | 'image/jpeg' // JPEG image format
-    | 'image/png' // PNG image format
-    | 'text/html' // HTML format
-    | 'text/plain' // Plain text format
-    | 'text/xml' // XML format (alternative)

package/src/Payload/types/Queries.ts

@@ -1 +0,0 @@
-export type Queries = Record<string, string>

package/src/Payload/types/Verb.ts

@@ -1 +0,0 @@
-export type Verb = 'get' | 'post'

package/src/Payload/types/index.ts

@@ -1,14 +0,0 @@
-export * from './HttpCall.ts'
-export * from './HttpCallBase64Result.ts'
-export * from './HttpCallErrorResult.ts'
-export * from './HttpCallFields.ts'
-export * from './HttpCallHtmlResult.ts'
-export * from './HttpCallJsonResult.ts'
-export * from './HttpCallResult.ts'
-export * from './HttpCallXmlResult.ts'
-export * from './HttpMeta.ts'
-export * from './HttpUriCall.ts'
-export * from './HttpUriTemplateCall.ts'
-export * from './MimeTypes.ts'
-export * from './Queries.ts'
-export * from './Verb.ts'

package/src/Witness/Config.ts

@@ -1,43 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
-import type { WitnessConfig } from '@xyo-network/witness-model'
-
-import type {
-  HttpCall, HttpUriCall, HttpUriTemplateCall, MimeTypes,
-} from '../Payload/index.ts'
-import { HttpCallWitnessConfigSchema } from './Schema.ts'
-
-export type HttpCallWitnessConfigBase = WitnessConfig<{
-  accept?: MimeTypes
-  headers?: Record<string, string | undefined>
-  queries?: HttpCall['queries']
-  schema: HttpCallWitnessConfigSchema
-  timeout?: number
-  verb?: HttpCall['verb']
-}>
-
-export type HttpUriCallWitnessConfig = WitnessConfig<
-  HttpCallWitnessConfigBase & {
-    uri: HttpUriCall['uri']
-  }
->
-
-export type HttpUriTemplateCallWitnessConfig = WitnessConfig<
-  HttpCallWitnessConfigBase & {
-    params?: Record<string, string>
-    uriTemplate: HttpUriTemplateCall['uriTemplate']
-  }
->
-
-export type HttpCallWitnessConfig = HttpUriCallWitnessConfig | HttpUriTemplateCallWitnessConfig | HttpCallWitnessConfigBase
-
-export const isHttpCallWitnessConfig = isPayloadOfSchemaType<HttpCallWitnessConfig>(HttpCallWitnessConfigSchema)
-export const asHttpCallWitnessConfig = AsObjectFactory.create(isHttpCallWitnessConfig)
-
-export const isHttpUriCallWitnessConfig = (value?: unknown): value is HttpUriCallWitnessConfig =>
-  isHttpCallWitnessConfig(value) && !!(value as HttpUriCallWitnessConfig).uri
-export const asHttpUriCallWitnessConfig = AsObjectFactory.create(isHttpUriCallWitnessConfig)
-
-export const isHttpUriTemplateCallWitnessConfig = (value?: unknown): value is HttpUriTemplateCallWitnessConfig =>
-  isHttpCallWitnessConfig(value) && !!(value as HttpUriTemplateCallWitnessConfig).uriTemplate
-export const asHttpUriTemplateCallWitnessConfig = AsObjectFactory.create(isHttpUriTemplateCallWitnessConfig)

package/src/Witness/Params.ts

@@ -1,10 +0,0 @@
-import type { WitnessParams } from '@xyo-network/witness-model'
-
-import type { HttpCallWitnessConfig } from './Config.ts'
-
-export interface HttpCallWitnessParams extends WitnessParams<
-  HttpCallWitnessConfig>
-{
-  headers?: Record<string, string | undefined>
-  ipfsGateway?: string
-}

package/src/Witness/Schema.ts

@@ -1,4 +0,0 @@
-import { asSchema } from '@xyo-network/payload-model'
-
-export const HttpCallWitnessConfigSchema = asSchema('network.xyo.http.call.witness.config', true)
-export type HttpCallWitnessConfigSchema = typeof HttpCallWitnessConfigSchema

package/src/Witness/Witness.ts

@@ -1,220 +0,0 @@
-/* eslint-disable max-statements */
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  assertEx, axiosJsonConfig, URL,
-} from '@xylabs/sdk-js'
-import { AbstractWitness } from '@xyo-network/abstract-witness'
-import type { Schema } from '@xyo-network/payload-model'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
-import { ObjectHasher, PayloadBuilder } from '@xyo-network/sdk-js'
-import type { AxiosError } from 'axios'
-import { Axios } from 'axios'
-import { fromByteArray } from 'base64-js'
-import fillTemplate from 'es6-dynamic-template'
-
-import { checkIpfsUrl } from '../lib/index.ts'
-import type {
-  HttpCall,
-  HttpCallBase64Result,
-  HttpCallErrorResult,
-  HttpCallJsonResult,
-  HttpCallJsonResultType,
-  HttpCallResult,
-  HttpCallXmlResult,
-  MimeTypes,
-} from '../Payload/index.ts'
-import {
-  asHttpUriCall,
-  asHttpUriTemplateCall,
-  HttpCallResultSchema,
-  HttpCallSchema,
-} from '../Payload/index.ts'
-import type { HttpCallHtmlResult } from '../Payload/types/index.ts'
-import { asHttpUriCallWitnessConfig, asHttpUriTemplateCallWitnessConfig } from './Config.ts'
-import type { HttpCallWitnessParams } from './Params.ts'
-import { HttpCallWitnessConfigSchema } from './Schema.ts'
-
-export class HttpCallWitness<TParams extends HttpCallWitnessParams = HttpCallWitnessParams> extends AbstractWitness<TParams, HttpCall, HttpCallResult> {
-  static override readonly configSchemas: Schema[] = [...super.configSchemas, HttpCallWitnessConfigSchema]
-  static override readonly defaultConfigSchema: Schema = HttpCallWitnessConfigSchema
-
-  get accept(): MimeTypes {
-    return this.config.accept ?? 'application/json'
-  }
-
-  get ipfsGateway() {
-    return this.params.ipfsGateway
-  }
-
-  get timeout() {
-    return this.config.timeout
-  }
-
-  getFullUri(call?: HttpCall): string {
-    const { uri: callUri } = asHttpUriCall(call) ?? {}
-    const {
-      uriTemplate: callUriTemplate, params: callParams, queries: callQueries,
-    } = asHttpUriTemplateCall(call) ?? {}
-    const { uri: configUri } = asHttpUriCallWitnessConfig(this.config) ?? {}
-    const {
-      uriTemplate: configUriTemplate, params: configParams, queries: configQueries,
-    } = asHttpUriTemplateCallWitnessConfig(this.config) ?? {}
-
-    const params = { ...configParams, ...callParams }
-
-    let url: URL | undefined = undefined
-
-    if (callUri) {
-      url = new URL(callUri)
-    } else if (callUriTemplate) {
-      url = new URL(fillTemplate(callUriTemplate, params))
-    } else if (configUri) {
-      url = new URL(configUri)
-    } else if (configUriTemplate) {
-      url = new URL(fillTemplate(configUriTemplate, params))
-    }
-
-    if (url) {
-      const queries = Object.entries({ ...configQueries, ...callQueries })
-      for (let [key, value] of queries) {
-        url?.searchParams.set(key, value)
-      }
-      return url.href
-    }
-
-    throw new Error('Unable to determine uri. No uri/uriTemplate specified in either the call or config.')
-  }
-
-  getHeaders(headers?: Record<string, string | undefined>): Record<string, string | undefined> {
-    return {
-      ...this.params.headers, ...this.config.headers, ...headers,
-    }
-  }
-
-  protected override async observeHandler(inPayloads: HttpCall[] = []): Promise<HttpCallResult[]> {
-    await this.started('throw')
-    try {
-      const observations = await Promise.all(
-        inPayloads.filter(isPayloadOfSchemaType<HttpCall>(HttpCallSchema)).map(async (call) => {
-          const { verb: callVerb } = call
-          const { verb: configVerb } = this.config
-          const verb = callVerb ?? configVerb ?? 'get'
-          const uri = this.getFullUri(call)
-
-          const validatedUri = assertEx(checkIpfsUrl(uri, this.ipfsGateway), () => 'Invalid URI')
-
-          if (verb === 'get') {
-            return this.httpGet(validatedUri, (await PayloadBuilder.dataHash(call)))
-          }
-
-          const observation: HttpCallResult = {
-            call: await ObjectHasher.hash(call),
-            schema: HttpCallResultSchema,
-          }
-          return observation
-        }),
-      )
-      return observations
-    } catch (ex) {
-      const error = ex as Error
-      console.error(`Error [${this.config.name}]: ${error.message}`)
-      console.log(error.stack)
-      throw error
-    }
-  }
-
-  // eslint-disable-next-line complexity
-  private async httpGet(url: string, call: Hash, headers?: Record<string, string | undefined>): Promise<HttpCallResult> {
-    const result: HttpCallResult = {
-      call,
-      schema: HttpCallResultSchema,
-    }
-    try {
-      switch (this.accept) {
-        case 'application/json': {
-          const axios = new Axios(axiosJsonConfig({
-            headers: { ...this.getHeaders(headers), Accept: 'application/json' }, timeout: this.timeout, decompress: true,
-          }))
-          const response = await axios.get<HttpCallJsonResultType>(url)
-          if (response.status >= 200 && response.status < 300) {
-            const jsonResult = result as HttpCallJsonResult
-            jsonResult.data = response.data
-            jsonResult.contentType = 'application/json'
-          } else {
-            const errorResult = result as HttpCallErrorResult
-            errorResult.http = { status: response.status }
-          }
-          break
-        }
-        case 'application/xml':
-        case 'text/xml': {
-          const axios = new Axios({
-            headers: { ...this.getHeaders(headers), Accept: this.accept },
-            responseType: 'arraybuffer',
-            decompress: true,
-            timeout: this.timeout,
-          })
-          const response = await axios.get(url)
-          if (response.status >= 200 && response.status < 300) {
-            const xmlResult = result as HttpCallXmlResult
-            xmlResult.data = Buffer.from(response.data, 'binary').toString('utf8')
-            xmlResult.contentType = response.headers['content-type']?.toString() ?? 'application/xml'
-          } else {
-            const errorResult = result as HttpCallErrorResult
-            errorResult.http = { status: response.status }
-          }
-          break
-        }
-        case 'text/html':{
-          const axios = new Axios({
-            headers: { ...this.getHeaders(headers), Accept: this.accept },
-            responseType: 'text',
-            decompress: true,
-            timeout: this.timeout,
-          })
-          const response = await axios.get(url)
-          if (response.status >= 200 && response.status < 300) {
-            const htmlResult = result as HttpCallHtmlResult
-            htmlResult.data = response.data
-            htmlResult.contentType = response.headers['content-type']?.toString() ?? 'text/html'
-          } else {
-            const errorResult = result as HttpCallErrorResult
-            errorResult.http = { status: response.status }
-          }
-          break
-        }
-        default: {
-          const axios = new Axios({
-            headers: this.params.headers, responseType: 'arraybuffer', timeout: this.timeout, decompress: true,
-          })
-          const response = await axios.get(url)
-          if (response.status >= 200 && response.status < 300) {
-            const jsonResult = result as HttpCallBase64Result
-            jsonResult.data = fromByteArray(response.data)
-            jsonResult.contentType = response.headers['content-type']?.toString() ?? 'application/octet-stream'
-          } else {
-            const errorResult = result as HttpCallErrorResult
-            errorResult.http = { status: response.status }
-          }
-          break
-        }
-      }
-    } catch (ex) {
-      const axiosError = ex as AxiosError
-      if (axiosError.isAxiosError) {
-        if (axiosError?.response?.status !== undefined) {
-          result.http = result.http ?? {}
-          result.http.status = axiosError?.response?.status
-        }
-        if (axiosError?.code !== undefined) {
-          result.http = result.http ?? {}
-          result.http.code = axiosError?.code
-        }
-        return result
-      } else {
-        throw ex
-      }
-    }
-    return result
-  }
-}

package/src/Witness/index.ts

@@ -1,4 +0,0 @@
-export * from './Config.ts'
-export * from './Params.ts'
-export * from './Schema.ts'
-export * from './Witness.ts'

package/src/Witness/spec/opensea.nft-call.json

@@ -1,41 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "name": "ApiCall",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "public": [
-          {
-            "config": {
-              "language": "javascript",
-              "name": "HttpCallWitness",
-              "queries": {
-                "limit": 1
-              },
-              "schema": "network.xyo.http.call.witness.config",
-              "uriTemplate": "https://api.opensea.io/api/v2/chain/ethereum/account/${address}/nfts"
-            }
-          },
-          {
-            "config": {
-              "language": "javascript",
-              "name": "HttpCallSentinel",
-              "schema": "network.xyo.sentinel.config",
-              "synchronous": "true",
-              "tasks": [
-                {
-                  "input": true,
-                  "mod": "HttpCallWitness"
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './Payload/index.ts'
-export * from './Witness/index.ts'

package/src/lib/checkIpfsUrl.ts

@@ -1,43 +0,0 @@
-import { assertEx, URL } from '@xylabs/sdk-js'
-
-const allowIpfsIoRepair = true
-
-/**
- * Returns the equivalent IPFS gateway URL for the supplied URL.
- * @param urlToCheck The URL to check
- * @returns If the supplied URL is an IPFS URL, it converts the URL to the
- * equivalent IPFS gateway URL. Otherwise, returns the original URL.
- */
-export const checkIpfsUrl = (urlToCheck: string, ipfsGateway?: string): string => {
-  try {
-    const url = new URL(urlToCheck)
-    let protocol = url.protocol
-    let host = url.host
-    let path = url.pathname
-    const query = url.search
-    if (protocol === 'ipfs:') {
-      protocol = 'https:'
-      host = assertEx(ipfsGateway, () => 'No ipfsGateway provided')
-      path = url.host === 'ipfs' ? `ipfs${path}` : `ipfs/${url.host}${path}`
-      const root = `${protocol}//${host}/${path}`
-      return query?.length > 0 ? `${root}?${query}` : root
-    } else if (allowIpfsIoRepair && protocol === 'https' && host === 'ipfs.io') {
-      protocol = 'https:'
-      host = assertEx(ipfsGateway, () => 'No ipfsGateway provided')
-      const pathParts = path.split('/')
-      if (pathParts[0] === 'ipfs') {
-        pathParts.shift()
-      }
-      path = pathParts.join('/')
-      const root = `${protocol}//${host}/${path}`
-      return query?.length > 0 ? `${root}?${query}` : root
-    } else {
-      return urlToCheck
-    }
-  } catch {
-    // const error = ex as Error
-    // console.error(`${error.name}:${error.message} [${urlToCheck}]`)
-    // console.log(error.stack)
-    return urlToCheck
-  }
-}

package/src/lib/index.ts

@@ -1 +0,0 @@
-export * from './checkIpfsUrl.ts'

package/src/types.d.ts

@@ -1 +0,0 @@
-declare module 'es6-dynamic-template'