@xyo-network/api 2.20.15

package/src/Archivist/Archive/Schemas/Api.spec.ts

@@ -0,0 +1,23 @@
+import { XyoApiConfig } from '../../../models'
+import { XyoArchivistApi } from '../../Api'
+
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+}
+
+describe('XyoArchivistSchemasApi', () => {
+  describe('schema', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive('foo').schemas.config.root
+      expect(path).toBe('/archive/foo/schema/')
+    })
+  })
+  describe('recent', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive('foo').schemas.recent.config.root
+      expect(path).toBe('/archive/foo/schema/recent/')
+    })
+  })
+})

package/src/Archivist/Archive/Schemas/Api.ts

@@ -0,0 +1,16 @@
+import { XyoSchemaPayload } from '@xyo-network/core'
+
+import { XyoApiSimple } from '../../../Simple'
+
+export class XyoArchivistArchiveSchemasApi extends XyoApiSimple<XyoSchemaPayload[]> {
+  private _recent?: XyoApiSimple<XyoSchemaPayload[]>
+  public get recent(): XyoApiSimple<XyoSchemaPayload[]> {
+    this._recent =
+      this._recent ??
+      new XyoApiSimple<XyoSchemaPayload[]>({
+        ...this.config,
+        root: `${this.root}recent/`,
+      })
+    return this._recent
+  }
+}

package/src/Archivist/Archive/Schemas/index.ts

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

package/src/Archivist/Archive/Settings/Api.ts

@@ -0,0 +1,15 @@
+import { XyoApiBase } from '../../../Base'
+import { XyoArchivistArchiveSettingsKeyApi } from './Key'
+
+export class XyoArchivistArchiveSettingsApi extends XyoApiBase {
+  private _key?: XyoArchivistArchiveSettingsKeyApi
+  public get key(): XyoArchivistArchiveSettingsKeyApi {
+    this._key =
+      this._key ??
+      new XyoArchivistArchiveSettingsKeyApi({
+        ...this.config,
+        root: `${this.root}key/`,
+      })
+    return this._key
+  }
+}

package/src/Archivist/Archive/Settings/Key/Api.ts

@@ -0,0 +1,11 @@
+import { XyoArchiveKey } from '../../../../models'
+import { XyoApiSimple } from '../../../../Simple'
+
+export class XyoArchivistArchiveSettingsKeyApi extends XyoApiSimple<XyoArchiveKey[]> {
+  public key(key: string) {
+    return new XyoApiSimple<XyoArchiveKey>({
+      ...this.config,
+      root: `${this.root}${key}/`,
+    })
+  }
+}

package/src/Archivist/Archive/Settings/Key/index.ts

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

package/src/Archivist/Archive/Settings/index.ts

@@ -0,0 +1,2 @@
+export * from './Api'
+export * from './Key'

package/src/Archivist/Archive/index.ts

@@ -0,0 +1,4 @@
+export * from './Api'
+export * from './Schema'
+export * from './Schemas'
+export * from './Settings'

package/src/Archivist/Archives/Api.ts

@@ -0,0 +1,17 @@
+import { XyoArchive } from '../../models'
+import { XyoApiSimple } from '../../Simple'
+import { XyoArchivistArchiveApi } from '../Archive'
+
+export class XyoArchivistArchivesApi extends XyoApiSimple<XyoArchive[]> {
+  public archive(archive = 'temp') {
+    return new XyoArchivistArchiveApi({
+      ...this.config,
+      root: `${this.root}${archive}/`,
+    })
+  }
+
+  /** @deprecated: use archive(string) instead */
+  public select(archive = 'temp') {
+    return this.archive(archive)
+  }
+}

package/src/Archivist/Archives/index.ts

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

package/src/Archivist/Block/Api.ts

@@ -0,0 +1,18 @@
+import { XyoBoundWitness, XyoPayload } from '@xyo-network/core'
+
+import { XyoApiConfig } from '../../models'
+import { XyoApiSimple } from '../../Simple'
+import { WithArchive } from '../../WithArchive'
+import { XyoArchivistPayloadApi } from '../Payload'
+
+export class XyoArchivistArchiveBlockApi<
+  T extends XyoBoundWitness = XyoBoundWitness,
+  C extends WithArchive<XyoApiConfig> = WithArchive<XyoApiConfig>
+> extends XyoArchivistPayloadApi<T, C> {
+  public payloads(hash: string): XyoApiSimple<XyoPayload[][]> {
+    return new XyoApiSimple<XyoPayload[][]>({
+      ...this.config,
+      root: `${this.root}hash/${hash}/payloads/`,
+    })
+  }
+}

package/src/Archivist/Block/index.ts

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

package/src/Archivist/Payload/Api.spec.ts

@@ -0,0 +1,61 @@
+import { XyoAccount, XyoBoundWitnessBuilder } from '@xyo-network/core'
+import { config } from 'dotenv'
+
+import { XyoApiConfig, XyoApiError } from '../../models'
+import { XyoArchivistApi } from '../Api'
+import { getNewArchive } from '../ApiUtil.spec'
+
+config()
+
+const configData: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'https://beta.api.archivist.xyo.network',
+  onError: (error) => console.error(`Error: ${JSON.stringify(error)}`),
+  onFailure: (response) => response, //console.error(`Failure: ${response.statusText} [${response.status}] [${JSON.stringify(response.data)}]`),
+  onSuccess: (response) => response, //console.log(`Success: ${response.statusText} [${response.status}] [${JSON.stringify(response.data)}]`),
+}
+
+describe('XyoArchivistPayloadApi', () => {
+  describe('find', () => {
+    const api = new XyoArchivistApi(configData)
+    let archive = ''
+    beforeEach(async () => {
+      archive = await getNewArchive(api)
+    })
+    describe('when order is ascending', () => {
+      it('returns payloads greater than or equal to timestamp', async () => {
+        try {
+          const timestamp = Date.now()
+          const boundWitness = new XyoBoundWitnessBuilder().witness(XyoAccount.random()).build()
+          await api.archive(archive).block.post([boundWitness])
+          const response = await api.archive(archive).block.find({ order: 'asc', timestamp })
+          expect(response?.length).toBe(1)
+          const actual = response?.[0]
+          expect(actual?._timestamp).toBeTruthy()
+          expect(actual?._timestamp).toBeGreaterThan(timestamp)
+        } catch (ex) {
+          const error = ex as XyoApiError
+          console.log(JSON.stringify(error.response?.data, null, 2))
+          throw ex
+        }
+      })
+    })
+    describe('when order is descending', () => {
+      it('returns payloads less than or equal to timestamp', async () => {
+        try {
+          const boundWitness = new XyoBoundWitnessBuilder().witness(XyoAccount.random()).build()
+          await api.archive(archive).block.post([boundWitness])
+          const timestamp = Date.now()
+          const response = await api.archive(archive).block.find({ order: 'desc', timestamp })
+          expect(response?.length).toBe(1)
+          const actual = response?.[0]
+          expect(actual?._timestamp).toBeTruthy()
+          expect(actual?._timestamp).toBeLessThanOrEqual(timestamp)
+        } catch (ex) {
+          const error = ex as XyoApiError
+          console.log(JSON.stringify(error.response?.data, null, 2))
+          throw ex
+        }
+      })
+    })
+  })
+})

package/src/Archivist/Payload/Api.ts

@@ -0,0 +1,102 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { XyoPayload } from '@xyo-network/core'
+
+import { XyoApiConfig } from '../../models'
+import { XyoApiSimple } from '../../Simple'
+import { WithArchive } from '../../WithArchive'
+import { XyoArchivistArchivePayloadSchemaApi } from './Schema'
+
+export interface XyoPayloadFindFilter {
+  [key: string]: unknown
+  order?: 'desc' | 'asc'
+  timestamp?: number
+  limit?: number
+  schema?: string
+}
+
+export interface XyoPayloadStats {
+  count: number
+}
+
+export class XyoArchivistPayloadApi<T extends XyoPayload = XyoPayload, C extends WithArchive<XyoApiConfig> = WithArchive<XyoApiConfig>> extends XyoApiSimple<
+  T[],
+  T[],
+  XyoPayloadFindFilter,
+  C
+> {
+  public get schema(): XyoArchivistArchivePayloadSchemaApi {
+    return new XyoArchivistArchivePayloadSchemaApi({
+      ...this.config,
+      root: `${this.root}schema/`,
+    })
+  }
+
+  private _stats?: XyoApiSimple<XyoPayloadStats>
+  public get stats(): XyoApiSimple<XyoPayloadStats> {
+    this._stats =
+      this._stats ??
+      new XyoApiSimple<XyoPayloadStats>({
+        ...this.config,
+        root: `${this.root}stats/`,
+      })
+    return this._stats
+  }
+
+  public hash(hash: string): XyoApiSimple<XyoPayload[]> {
+    return new XyoApiSimple<XyoPayload[]>({
+      ...this.config,
+      root: `${this.root}hash/${hash}/`,
+    })
+  }
+
+  public async repair(hash: string) {
+    return await this.getEndpoint<T[]>(`hash/${hash}/repair`)
+  }
+
+  /** @deprecated use stats instead */
+  public async getStats() {
+    return await this.getEndpoint<XyoPayloadStats>('stats')
+  }
+
+  /** @deprecated use hash */
+  public async getByHash(hash: string) {
+    return await this.getEndpoint<T[]>(`hash/${hash}`)
+  }
+
+  /** @deprecated use repair */
+  public async repairByHash(hash: string) {
+    return await this.repair(hash)
+  }
+
+  /** @deprecated use find */
+  public async findBefore(timestamp: number, limit = 20) {
+    return await this.find({ limit, order: 'desc', timestamp })
+  }
+
+  /** @deprecated use findBefore */
+  public async getBefore(timestamp: number, limit = 20) {
+    return await this.find({ limit, order: 'desc', timestamp })
+  }
+
+  /** @deprecated use find */
+  public async findAfter(timestamp: number, limit = 20) {
+    return await this.find({ limit, order: 'asc', timestamp })
+  }
+
+  /** @deprecated use find */
+  public async getAfter(timestamp: number, limit = 20) {
+    return await this.find({ limit, order: 'asc', timestamp })
+  }
+
+  /** @deprecated use find */
+  public async findMostRecent(limit = 20) {
+    assertEx(limit > 0, 'min limit = 1')
+    assertEx(limit <= 100, 'max limit = 100')
+    return await this.find({ limit, order: 'desc', timestamp: 999999999999 })
+  }
+
+  /** @deprecated use find */
+  public async getMostRecent(limit = 20) {
+    return await this.find({ limit, order: 'desc', timestamp: 999999999999 })
+  }
+}

package/src/Archivist/Payload/Schema/Api.spec.ts

@@ -0,0 +1,59 @@
+import { XyoAccount, XyoBoundWitnessBuilder, XyoPayload } from '@xyo-network/core'
+
+import { XyoApiConfig } from '../../../models'
+import { XyoArchivistApi } from '../../Api'
+import { getNewArchive, getSchemaName } from '../../ApiUtil.spec'
+
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+}
+
+const payload: XyoPayload = {
+  definition: {
+    $id: '',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+  },
+  schema: getSchemaName(),
+}
+
+describe('XyoArchivistArchivePayloadSchemaApi', () => {
+  const api = new XyoArchivistApi(config)
+  let archive = ''
+  beforeAll(async () => {
+    archive = await getNewArchive(api)
+    const boundWitness = new XyoBoundWitnessBuilder({ inlinePayloads: true }).witness(XyoAccount.random()).payload(payload).build()
+    await api.archives.archive(archive).block.post([boundWitness])
+  })
+  describe('get', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive(archive).payload.schema.config.root
+      expect(path).toBe(`/archive/${archive}/payload/schema/`)
+    })
+    it('lists the schema in the archive', async () => {
+      const api = new XyoArchivistApi(config)
+      const response = await api.archive(archive).payload.schema.get()
+      expect(response).toBeTruthy()
+      expect(Array.isArray(response)).toBe(true)
+      expect(response?.length).toBe(1)
+      expect(response?.[0]).toBe(payload.schema)
+    })
+  })
+  describe('stats', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive(archive).payload.schema.stats.config.root
+      expect(path).toBe(`/archive/${archive}/payload/schema/stats/`)
+    })
+    it('lists the stats for the payloads by schema in the archive', async () => {
+      const api = new XyoArchivistApi(config)
+      const response = await api.archive(archive).payload.schema.stats.get()
+      expect(response).toBeTruthy()
+      expect(response?.counts).toBeTruthy()
+      const schemas = Object.keys(response?.counts || {})
+      expect(schemas.length).toBe(1)
+      expect(schemas?.[0]).toBe(payload.schema)
+      expect(response?.counts[payload.schema]).toBe(1)
+    })
+  })
+})

package/src/Archivist/Payload/Schema/Api.ts

@@ -0,0 +1,18 @@
+import { XyoApiSimple } from '../../../Simple'
+
+export interface XyoArchivistArchivePayloadSchemaStats {
+  counts: Record<string, number>
+}
+
+export class XyoArchivistArchivePayloadSchemaApi extends XyoApiSimple<string[]> {
+  private _stats?: XyoApiSimple<XyoArchivistArchivePayloadSchemaStats>
+  public get stats() {
+    this._stats =
+      this._stats ??
+      new XyoApiSimple<XyoArchivistArchivePayloadSchemaStats>({
+        ...this.config,
+        root: `${this.root}stats/`,
+      })
+    return this._stats
+  }
+}

package/src/Archivist/Payload/Schema/index.ts

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

package/src/Archivist/Payload/index.ts

@@ -0,0 +1,2 @@
+export * from './Api'
+export * from './Schema'

package/src/Archivist/index.ts

@@ -0,0 +1,6 @@
+export * from './Account'
+export * from './Api'
+export * from './Archive'
+export * from './Archives'
+export * from './Block'
+export * from './Payload'

package/src/Base.ts

@@ -0,0 +1,175 @@
+import { Axios, AxiosRequestConfig, AxiosRequestHeaders } from 'axios'
+import { gzip } from 'pako'
+
+import {
+  XyoApiConfig,
+  XyoApiEnvelope,
+  XyoApiError,
+  XyoApiReportable,
+  XyoApiResponse,
+  XyoApiResponseBody,
+  XyoApiResponseTuple,
+  XyoApiResponseTupleOrBody,
+  XyoApiResponseType,
+} from './models'
+
+export class XyoApiBase<C extends XyoApiConfig = XyoApiConfig> implements XyoApiReportable {
+  public readonly config: C
+  protected axios: Axios
+
+  constructor(config: C) {
+    this.config = config
+    this.axios = new Axios(this.axiosConfig())
+  }
+
+  private axiosHeaders(): AxiosRequestHeaders {
+    return {
+      ...this.headers,
+      Accept: 'application/json, text/plain, *.*',
+      'Content-Type': 'application/json',
+    }
+  }
+
+  private axiosConfig(): AxiosRequestConfig {
+    return {
+      headers: this.axiosHeaders(),
+      transformRequest: (data, headers) => {
+        const json = JSON.stringify(data)
+        if (headers && data) {
+          if (json.length > (this.config.compressionThreshold ?? 1024)) {
+            headers['Content-Encoding'] = 'gzip'
+            return gzip(JSON.stringify(data)).buffer
+          }
+        }
+        return JSON.stringify(data)
+      },
+      transformResponse: (data) => {
+        try {
+          return JSON.parse(data)
+        } catch (ex) {
+          return null
+        }
+      },
+    }
+  }
+
+  onError(error: XyoApiError, depth = 0) {
+    this.config.reportableParent?.onError?.(error, depth + 1)
+    this.config.onError?.(error, depth)
+  }
+
+  onFailure(response: XyoApiResponse, depth = 0) {
+    this.config.reportableParent?.onFailure?.(response, depth + 1)
+    this.config.onFailure?.(response, depth)
+  }
+
+  onSuccess(response: XyoApiResponse, depth = 0) {
+    this.config.reportableParent?.onSuccess?.(response, depth + 1)
+    this.config.onSuccess?.(response, depth)
+  }
+
+  protected get root() {
+    return this.config.root ?? '/'
+  }
+
+  protected get query() {
+    return this.config.query ?? ''
+  }
+
+  private resolveRoot() {
+    return `${this.config.apiDomain}${this.root}`
+  }
+
+  private static resolveResponse<T>(result?: XyoApiResponse<XyoApiEnvelope<T>>) {
+    return [result?.data?.data, result?.data, result] as XyoApiResponseTuple<T>
+  }
+
+  protected handleMonitorResponseError<T>(error: XyoApiError, trapAxiosException: boolean) {
+    if (!error.isXyoError) {
+      throw error
+    }
+
+    if (trapAxiosException) {
+      error.response ? this.onFailure(error.response) : this.onError(error)
+      if (this.config.throwFailure) {
+        throw error
+      }
+      return error.response as XyoApiResponse<XyoApiEnvelope<T>>
+    }
+  }
+
+  protected async monitorResponse<T>(closure: () => Promise<XyoApiResponse<XyoApiEnvelope<T>>>) {
+    //we use this to prevent accidental catching on exceptions in callbacks
+    let trapAxiosException = true
+    try {
+      const response = await closure()
+      trapAxiosException = false
+
+      response.status < 300 ? this.onSuccess(response) : this.onFailure(response)
+
+      return response
+    } catch (ex) {
+      this.handleMonitorResponseError(ex as XyoApiError, trapAxiosException)
+    }
+  }
+
+  protected async getEndpoint<T = unknown>(endPoint?: string): Promise<XyoApiResponseBody<T>>
+  protected async getEndpoint<T = unknown>(endPoint?: string, responseType?: 'body'): Promise<XyoApiResponseBody<T>>
+  protected async getEndpoint<T = unknown>(endPoint?: string, responseType?: 'tuple'): Promise<XyoApiResponseTuple<T>>
+  protected async getEndpoint<T = unknown>(endPoint = '', responseType?: XyoApiResponseType): Promise<XyoApiResponseTupleOrBody<T>> {
+    const response = await this.monitorResponse<T>(async () => {
+      return await this.axios.get<XyoApiEnvelope<T>, XyoApiResponse<XyoApiEnvelope<T>>>(`${this.resolveRoot()}${endPoint}${this.query}`)
+    })
+    return XyoApiBase.shapeResponse<T>(response, responseType)
+  }
+
+  protected async postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D): Promise<XyoApiResponseBody<T>>
+  protected async postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'body'): Promise<XyoApiResponseBody<T>>
+  protected async postEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'tuple'): Promise<XyoApiResponseTuple<T>>
+  protected async postEndpoint<T = unknown, D = unknown>(endPoint = '', data?: D, responseType?: XyoApiResponseType): Promise<XyoApiResponseTupleOrBody<T>> {
+    const response = await this.monitorResponse<T>(async () => {
+      return await this.axios.post<XyoApiEnvelope<T>, XyoApiResponse<XyoApiEnvelope<T>, D>, D>(`${this.resolveRoot()}${endPoint}${this.query}`, data)
+    })
+    return XyoApiBase.shapeResponse<T>(response, responseType)
+  }
+
+  protected async putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D): Promise<XyoApiResponseBody<T>>
+  protected async putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'body'): Promise<XyoApiResponseBody<T>>
+  protected async putEndpoint<T = unknown, D = unknown>(endPoint?: string, data?: D, responseType?: 'tuple'): Promise<XyoApiResponseTuple<T>>
+  protected async putEndpoint<T = unknown, D = unknown>(endPoint = '', data?: D, responseType?: XyoApiResponseType): Promise<XyoApiResponseTupleOrBody<T>> {
+    const response = await this.monitorResponse<T>(async () => {
+      return await this.axios.put<XyoApiEnvelope<T>, XyoApiResponse<XyoApiEnvelope<T>, D>, D>(`${this.resolveRoot()}${endPoint}${this.query}`, data)
+    })
+    return XyoApiBase.shapeResponse<T>(response, responseType)
+  }
+
+  protected async deleteEndpoint<T = unknown>(endPoint?: string): Promise<XyoApiResponseBody<T>>
+  protected async deleteEndpoint<T = unknown>(endPoint?: string, responseType?: 'body'): Promise<XyoApiResponseBody<T>>
+  protected async deleteEndpoint<T = unknown>(endPoint?: string, responseType?: 'tuple'): Promise<XyoApiResponseTuple<T>>
+  protected async deleteEndpoint<T = unknown>(endPoint = '', responseType?: XyoApiResponseType): Promise<XyoApiResponseTupleOrBody<T>> {
+    const response = await this.monitorResponse<T>(async () => {
+      return await this.axios.delete<XyoApiEnvelope<T>, XyoApiResponse<XyoApiEnvelope<T>>>(`${this.resolveRoot()}${endPoint}${this.query}`)
+    })
+    return XyoApiBase.shapeResponse<T>(response, responseType)
+  }
+
+  private static shapeResponse<T = unknown>(response: XyoApiResponse<XyoApiEnvelope<T>> | undefined, responseType?: XyoApiResponseType) {
+    const resolvedResponse = XyoApiBase.resolveResponse(response)
+    return responseType === 'tuple' ? resolvedResponse : resolvedResponse[0]
+  }
+
+  protected get headers(): Record<string, string> {
+    const headers: Record<string, string> = {}
+    if (this.config.jwtToken) {
+      headers.Authorization = `Bearer ${this.config.jwtToken}`
+    }
+    if (this.config.apiKey) {
+      headers['x-api-key'] = this.config.apiKey
+    }
+    return headers
+  }
+
+  public get authenticated() {
+    return !!this.config.apiKey || !!this.config.jwtToken
+  }
+}

package/src/Diviner/LocationDiviner/LocationDivinerApi.spec.ts

@@ -0,0 +1,101 @@
+import { ApiConfig } from '@xylabs/sdk-js'
+import { AxiosError } from 'axios'
+
+import { XyoApiConfig } from '../../models'
+import { XyoLocationDivinerApi } from './LocationDivinerApi'
+import { LocationHeatmapQueryCreationRequest, locationHeatmapQuerySchema, LocationTimeRangeQueryCreationRequest, locationTimeRangeQuerySchema } from './Queries'
+import { locationWitnessPayloadSchema } from './Witnesses'
+
+const config: ApiConfig = {
+  apiDomain: process.env.LOCATION_API_DOMAIN || 'http://localhost:8082',
+}
+
+const getArchiveConfig = (): XyoApiConfig => {
+  const apiDomain = process.env.API_DOMAIN || 'http://localhost:8080'
+  return { apiDomain }
+}
+
+const getDefaultStartStopTime = () => {
+  const startTime = new Date(0).toISOString()
+  const stopTime = new Date().toISOString()
+  return { startTime, stopTime }
+}
+
+const getLocationTimeRangeQueryCreationRequest = (): LocationTimeRangeQueryCreationRequest => {
+  const query = { schema: locationWitnessPayloadSchema, ...getDefaultStartStopTime() }
+  const sourceArchivist = { ...getArchiveConfig() }
+  const resultArchivist = { ...getArchiveConfig() }
+  return {
+    query,
+    resultArchive: 'temp',
+    resultArchivist,
+    schema: locationTimeRangeQuerySchema,
+    sourceArchive: 'temp',
+    sourceArchivist,
+  }
+}
+
+const getLocationHeatmapQueryCreationRequest = (): LocationHeatmapQueryCreationRequest => {
+  const query = { schema: locationWitnessPayloadSchema, ...getDefaultStartStopTime() }
+  const sourceArchivist = { ...getArchiveConfig() }
+  const resultArchivist = { ...getArchiveConfig() }
+  return {
+    query,
+    resultArchive: 'temp',
+    resultArchivist,
+    schema: locationHeatmapQuerySchema,
+    sourceArchive: 'temp',
+    sourceArchivist,
+  }
+}
+
+const describeSkipIfNoDiviner = process.env.LOCATION_API_DOMAIN ? describe : describe.skip
+
+describeSkipIfNoDiviner('XyoLocationDivinerApi', () => {
+  describe('constructor', () => {
+    it('returns a new XyoLocationDivinerApi', () => {
+      const api = new XyoLocationDivinerApi(config)
+      expect(api).toBeDefined()
+    })
+  })
+  describe('postLocationQuery', () => {
+    it('posts a location heatmap query', async () => {
+      const api = new XyoLocationDivinerApi(config)
+      try {
+        const locationQuery = await api.postLocationQuery(getLocationHeatmapQueryCreationRequest())
+        const response = await api.getLocationQuery(locationQuery.hash)
+        expect(response.queryHash).toBe(locationQuery.hash)
+      } catch (ex) {
+        const error = ex as AxiosError
+        console.log(JSON.stringify(error.response?.data, null, 2))
+        throw ex
+      }
+    })
+    it('posts a location time range query', async () => {
+      const api = new XyoLocationDivinerApi(config)
+      try {
+        const locationQuery = await api.postLocationQuery(getLocationTimeRangeQueryCreationRequest())
+        const response = await api.getLocationQuery(locationQuery.hash)
+        expect(response.queryHash).toBe(locationQuery.hash)
+      } catch (ex) {
+        const error = ex as AxiosError
+        console.log(JSON.stringify(error.response?.data, null, 2))
+        throw ex
+      }
+    })
+  })
+  describe('getLocationQuery', function () {
+    it('gets the status of a previously posted location query', async () => {
+      const api = new XyoLocationDivinerApi(config)
+      try {
+        const locationQuery = await api.postLocationQuery(getLocationTimeRangeQueryCreationRequest())
+        const response = await api.getLocationQuery(locationQuery.hash)
+        expect(response.queryHash).toBe(locationQuery.hash)
+      } catch (ex) {
+        const error = ex as AxiosError
+        console.log(JSON.stringify(error.response?.data, null, 2))
+        throw ex
+      }
+    })
+  })
+})