@xyo-network/xl1-rpc 1.15.28 → 1.16.1

package/dist/node/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UnsignedHydratedTransactionSchema.spec copy.d.ts","sourceRoot":"","sources":["../../../../../../src/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.ts"],"names":[],"mappings":""}

package/src/provider/datalake/AbstractXyoDataLake.ts

@@ -1,38 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import { ObjectHasher } from '@xyo-network/hash'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-import { isAnyPayload } from '@xyo-network/payload-model'
-import {
-  type DataLakeData,
-  isHashPayload,
-  type XyoDataLake,
-} from '@xyo-network/xl1-protocol'
-
-export abstract class AbstractXyoDataLake implements XyoDataLake {
-  async fetch(hashes: Hash[], maxDepth: number = 10): Promise<DataLakeData[]> {
-    const results: DataLakeData[] = await this.get(hashes)
-    if (maxDepth > 0) {
-      const hashPayloads = results.filter(isHashPayload)
-      const otherPayloads = results.filter(item => !isHashPayload(item))
-      const found = await this.fetch(hashPayloads.map(item => item.hash), maxDepth - 1)
-      const foundHashes = await Promise.all(found.map(async item => isAnyPayload(item) ? await PayloadBuilder.hash(item) : ObjectHasher.hashBytes(item)))
-      const notFound = hashPayloads.filter(item => !foundHashes.includes(item.hash))
-      return [...otherPayloads, ...found, ...notFound]
-    }
-    return results
-  }
-
-  async trace(hash: Hash): Promise<[DataLakeData | undefined, Payload[]]> {
-    const [result] = await this.get([hash])
-    if (isHashPayload(result)) {
-      const [payload, route] = await this.trace(result.hash)
-      return [payload, [result, ...route]]
-    }
-    return [result, []]
-  }
-
-  abstract add(items: DataLakeData[]): Promise<DataLakeData[]>
-
-  abstract get(hashes: Hash[]): Promise<DataLakeData[]>
-}

package/src/provider/datalake/ArchivistXyoDataLake.ts

@@ -1,26 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { Hash } from '@xylabs/hex'
-import type { ReadWriteArchivist } from '@xyo-network/archivist-model'
-import { isAnyPayload } from '@xyo-network/payload-model'
-import { type DataLakeData } from '@xyo-network/xl1-protocol'
-
-import { AbstractXyoDataLake } from './AbstractXyoDataLake.ts'
-
-export class ArchivistXyoDataLake extends AbstractXyoDataLake {
-  private _archivist: ReadWriteArchivist
-
-  constructor(archivist: ReadWriteArchivist) {
-    super()
-    this._archivist = archivist
-  }
-
-  async add(items: DataLakeData[]): Promise<DataLakeData[]> {
-    const payloads = items.filter(isAnyPayload)
-    assertEx(payloads.length === items.length, () => 'Some items are not payloads')
-    return await this._archivist.insert(payloads)
-  }
-
-  async get(hashes: Hash[]): Promise<DataLakeData[]> {
-    return await this._archivist.get(hashes)
-  }
-}

package/src/provider/datalake/HttpXyoDataLake.ts

@@ -1,115 +0,0 @@
-import { isArrayBuffer } from '@xylabs/arraybuffer'
-import { assertEx } from '@xylabs/assert'
-import { AxiosJson } from '@xylabs/axios'
-import { exists } from '@xylabs/exists'
-import type { Hash } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import { isDefined } from '@xylabs/typeof'
-import { isAnyPayload, type Payload } from '@xyo-network/payload-model'
-import { type DataLakeData, isHashPayload } from '@xyo-network/xl1-protocol'
-import { Axios } from 'axios'
-
-import { AbstractXyoDataLake } from './AbstractXyoDataLake.ts'
-
-export class HttpXyoDataLake extends AbstractXyoDataLake {
-  private _axiosGet: Axios
-  private _axiosInsertBlob: Axios
-  private _axiosInsertJson: AxiosJson
-  private _endpoint: string
-
-  constructor(endpoint: string) {
-    super()
-    this._endpoint = endpoint
-    this._axiosInsertJson = new AxiosJson({ baseURL: endpoint })
-    this._axiosInsertBlob = new Axios({ baseURL: endpoint, headers: { 'Content-Type': 'application/octet-stream', 'Accept': 'application/octet-stream' } })
-    this._axiosGet = new Axios({ baseURL: endpoint, headers: { 'Content-Type': 'application/json', 'Accept': 'application/octet-stream, application/json' } })
-  }
-
-  get endpoint(): string {
-    return this._endpoint
-  }
-
-  async add(items: DataLakeData[]): Promise<DataLakeData[]> {
-    const results: DataLakeData[] = []
-    for (const item of items) {
-      if (isAnyPayload(item)) {
-        const result = await this.addPayload(item)
-        if (isAnyPayload(result)) {
-          results.push(result)
-        } else if (isDefined(result)) {
-          assertEx(false, () => 'Expected result to be a Payload')
-        }
-      } else if (isArrayBuffer(item)) {
-        const result = await this.addArrayBuffer(item)
-        if (isAnyPayload(result)) {
-          results.push(result)
-        } else if (isDefined(result)) {
-          assertEx(false, () => 'Expected result to be a Payload')
-        }
-      }
-    }
-    return results
-  }
-
-  async get(hashes: Hash[]): Promise<DataLakeData[]> {
-    return (await Promise.all(hashes.map(async (hash) => {
-      return await this.getOne(hash)
-    }))).filter(exists)
-  }
-
-  protected async addArrayBuffer(item: ArrayBuffer): Promise<ArrayBuffer | undefined> {
-    const result = await this._axiosInsertBlob.post('/insert', item)
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`)
-    }
-    if (!isArrayBuffer(result.data)) {
-      throw new Error('Invalid response from server (expected a ArrayBuffer)')
-    }
-
-    return result.data
-  }
-
-  protected async addPayload(item: Payload): Promise<Payload | undefined> {
-    const result = await this._axiosInsertJson.post('/insert', item)
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`)
-    }
-    if (!Array.isArray(result.data) || result.data.length !== 1) {
-      throw new Error('Invalid response from server (expected an Array of Payloads)')
-    }
-    const [response] = result.data
-    if (!isAnyPayload(response)) {
-      throw new Error('Invalid response from server (expected a Payload)')
-    }
-    return response
-  }
-
-  protected async fetchOne(hash: Hash, maxDepth: number = Number.MAX_SAFE_INTEGER): Promise<DataLakeData | undefined> {
-    if (maxDepth <= 0) {
-      return undefined
-    }
-    const result = await this.getOne(hash)
-    if (isHashPayload(result)) {
-      return await this.fetchOne(result.hash, maxDepth - 1)
-    }
-    return result
-  }
-
-  protected getOne(hash: Hash): Promisable<DataLakeData | undefined> {
-    return this._axiosGet.get(`/get/${hash}`).then((response) => {
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`Failed to get item [${response.status}]: ${response.statusText}`)
-      }
-      const contentType = response.headers['content-type']
-      if (contentType && contentType.includes('application/json')) {
-        const parsed = JSON.parse(response.data)
-        if (!isAnyPayload(parsed)) {
-          throw new Error('Invalid response from server (expected a Payload)')
-        }
-        return parsed
-      } else {
-        throw new Error(`Unexpected content type: ${contentType}`)
-      }
-    })
-  }
-}

package/src/provider/datalake/spec/HttpXyoDataLake.spec.ts

@@ -1,161 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { HashPayload } from '@xyo-network/xl1-protocol'
-import { HashSchema } from '@xyo-network/xl1-protocol'
-import {
-  beforeAll, describe, expect, it,
-} from 'vitest'
-
-import { HttpXyoDataLake } from '../HttpXyoDataLake.ts'
-
-describe.skip('HttpXyoDataLake', () => {
-  let sut: HttpXyoDataLake
-  const endpoint = 'http://localhost:8083/dataLake'
-  // const endpoint = 'https://beta.api.archivist.xyo.network/dataLake'
-  const item = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}` }).meta({ $sources: [] }).build()
-
-  beforeAll(() => {
-    sut = new HttpXyoDataLake(endpoint)
-  })
-  describe('add', () => {
-    describe('with single payload', () => {
-      it('should add', async () => {
-        const result = await sut.add([item])
-        expect(result).toBeArrayOfSize(1)
-        expect(result[0]).toEqual(expect.objectContaining(item))
-      })
-    })
-    describe('with multiple payloads', () => {
-      it('should add all', async () => {
-        const item1 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-1` }).meta({ $sources: [] }).build()
-        const item2 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-2` }).meta({ $sources: [] }).build()
-        const result = await sut.add([item1, item2])
-        expect(result).toBeArrayOfSize(2)
-        expect(result[0]).toEqual(expect.objectContaining(item1))
-        expect(result[1]).toEqual(expect.objectContaining(item2))
-      })
-    })
-  })
-  describe('get', () => {
-    describe('with single payload', () => {
-      it('should get by data hash', async () => {
-        const hash = await PayloadBuilder.dataHash(item)
-        const expected = PayloadBuilder.omitMeta(item)
-        const result = await sut.get([hash])
-        expect(result).toBeArrayOfSize(1)
-        expect(result[0]).toEqual(expect.objectContaining(expected))
-      })
-      it('should get by root hash', async () => {
-        const hash = await PayloadBuilder.hash(item)
-        const result = await sut.get([hash])
-        expect(result).toBeArrayOfSize(1)
-        expect(result[0]).toEqual(expect.objectContaining(item))
-      })
-    })
-    describe('with multiple payloads', () => {
-      it('should get all by data hash', async () => {
-        const item1 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-a` }).meta({ $sources: [] }).build()
-        const item2 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-b` }).meta({ $sources: [] }).build()
-        const hash1 = await PayloadBuilder.dataHash(item1)
-        const hash2 = await PayloadBuilder.dataHash(item2)
-
-        await sut.add([item1, item2])
-
-        const result = await sut.get([hash1, hash2])
-        expect(result).toBeArrayOfSize(2)
-        expect(result).toEqual(expect.arrayContaining([
-          expect.objectContaining(PayloadBuilder.omitMeta(item1)),
-          expect.objectContaining(PayloadBuilder.omitMeta(item2)),
-        ]))
-      })
-      it('should get all by root hash', async () => {
-        const item1 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-a` }).meta({ $sources: [] }).build()
-        const item2 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-b` }).meta({ $sources: [] }).build()
-        const hash1 = await PayloadBuilder.hash(item1)
-        const hash2 = await PayloadBuilder.hash(item2)
-
-        await sut.add([item1, item2])
-
-        const result = await sut.get([hash1, hash2])
-        expect(result).toBeArrayOfSize(2)
-        expect(result).toEqual(expect.arrayContaining([
-          expect.objectContaining(item1),
-          expect.objectContaining(item2),
-        ]))
-      })
-    })
-  })
-  describe('fetch', () => {
-    describe('with single payload', () => {
-      it('should fetch by data hash', async () => {
-        const hash = await PayloadBuilder.dataHash(item)
-        const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash }).build()
-        const hashPayloadHash = await PayloadBuilder.hash(hashPayload)
-        await sut.add([hashPayload])
-        const expected = PayloadBuilder.omitMeta(item)
-        const result = await sut.fetch([hashPayloadHash])
-        expect(result).toBeArrayOfSize(1)
-        expect(result[0]).toEqual(expect.objectContaining(expected))
-      })
-      it('should fetch by root hash', async () => {
-        const hash = await PayloadBuilder.hash(item)
-        const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash }).build()
-        const hashPayloadHash = await PayloadBuilder.hash(hashPayload)
-        await sut.add([hashPayload])
-        const expected = PayloadBuilder.omitMeta(item)
-        const result = await sut.fetch([hashPayloadHash])
-        expect(result).toBeArrayOfSize(1)
-        expect(result[0]).toEqual(expect.objectContaining(expected))
-      })
-    })
-    describe('with multiple payloads', () => {
-      it('should fetch all by root hash', async () => {
-        const item1 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-x` }).meta({ $sources: [] }).build()
-        const item2 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-y` }).meta({ $sources: [] }).build()
-        await sut.add([item1, item2])
-        const hash1 = await PayloadBuilder.hash(item1)
-        const hash2 = await PayloadBuilder.hash(item2)
-
-        const hashPayload1 = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash: hash1 }).build()
-        const hashPayload2 = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash: hash2 }).build()
-        await sut.add([hashPayload1, hashPayload2])
-        const hph1Hash = await PayloadBuilder.hash(hashPayload1)
-        const hph2Hash = await PayloadBuilder.hash(hashPayload2)
-
-        const result = await sut.fetch([hph1Hash, hph2Hash])
-        const expected1 = PayloadBuilder.omitMeta(item1)
-        const expected2 = PayloadBuilder.omitMeta(item2)
-
-        expect(result).toBeArrayOfSize(2)
-        expect(result).toEqual(expect.arrayContaining([
-          expect.objectContaining(expected1),
-          expect.objectContaining(expected2),
-        ]))
-      })
-      it('should fetch all by root hash', async () => {
-        const item1 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-x` }).meta({ $sources: [] }).build()
-        const item2 = new PayloadBuilder({ schema: 'network.xyo.id' }).fields({ salt: `${Date.now()}-y` }).meta({ $sources: [] }).build()
-        await sut.add([item1, item2])
-        const hash1 = await PayloadBuilder.hash(item1)
-        const hash2 = await PayloadBuilder.hash(item2)
-
-        const hashPayload1 = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash: hash1 }).build()
-        const hashPayload2 = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash: hash2 }).build()
-        await sut.add([hashPayload1, hashPayload2])
-        const hph1Hash = await PayloadBuilder.hash(hashPayload1)
-        const hph2Hash = await PayloadBuilder.hash(hashPayload2)
-
-        const result = await sut.fetch([hph1Hash, hph2Hash])
-        const expected1 = PayloadBuilder.omitMeta(item1)
-        const expected2 = PayloadBuilder.omitMeta(item2)
-
-        expect(result).toBeArrayOfSize(2)
-        expect(result).toEqual(expect.arrayContaining([
-          expect.objectContaining(PayloadBuilder.omitMeta(expected1)),
-          expect.objectContaining(PayloadBuilder.omitMeta(expected2)),
-        ]))
-      })
-    })
-  })
-})