@xyo-network/payload 2.42.13 → 2.42.15

package/src/Huri/Huri.spec.ts

@@ -1,92 +0,0 @@
-import { delay } from '@xylabs/delay'
-
-import { XyoPayload } from '../models'
-import { Huri } from './Huri'
-
-const hash = 'fb3606d71dcdd49a0aacc9d234e412684d577803c8a9ed9399a9d3776cc88e24'
-
-const valid = [
-  `https://${hash}`,
-  `https://api.archivist.xyo.network/temp/${hash}`,
-  `https://api.archivist.xyo.network/${hash}`,
-  `http://api.archivist.xyo.network/${hash}`,
-  `/api.archivist.xyo.network/${hash}`,
-  `//${hash}`,
-  `/${hash}`,
-  `${hash}`,
-]
-
-const validWithTempArchive = [
-  `https://api.archivist.xyo.network/temp/${hash}`,
-  `https://api.archivist.xyo.network/temp/${hash}`,
-  `http://api.archivist.xyo.network/temp/${hash}`,
-  `/api.archivist.xyo.network/temp/${hash}`,
-]
-
-const invalid = [`https:///api.archivist.xyo.network/${hash}`, `https://api.archivist.xyo.network//${hash}`]
-
-describe('Huri', () => {
-  describe('Valid Items', () => {
-    valid.map((item) => {
-      test(`valid [${item}]`, () => {
-        try {
-          const huri = new Huri(item)
-          expect(huri.hash).toBe(hash)
-        } catch (ex) {
-          console.error(`Valid Huri failed: [${item}]`)
-          console.error(ex)
-        }
-      })
-    })
-  })
-  describe('Valid Items w/archive', () => {
-    validWithTempArchive.map((item) => {
-      test(`valid w/archive [${item}]`, () => {
-        try {
-          const huri = new Huri(item)
-          expect(huri.hash).toBe(hash)
-          expect(huri.archive).toBe('temp')
-        } catch (ex) {
-          console.error(`Valid Huri w/archive failed: [${item}]`)
-          console.error(ex)
-        }
-      })
-    })
-  })
-  describe('Invalid Items', () => {
-    invalid.map((item) => {
-      test(`invalid [${item}]`, () => {
-        expect(() => new Huri(item)).toThrowError()
-      })
-    })
-  })
-  describe('Api Fetch', () => {
-    it('Valid Huri', async () => {
-      const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
-      const result = await huri.fetch()
-      expect(result?.schema).toBe('network.xyo.schema')
-    })
-    it('Invalid Huri', async () => {
-      const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653bad')
-      await expect(huri.fetch()).rejects.toThrow()
-    })
-  })
-  describe('Fetch Override', () => {
-    invalid.map((item) => {
-      test(`invalid [${item}]`, async () => {
-        const oldFetch = Huri.fetch
-        Huri.fetch = async <T extends XyoPayload = XyoPayload>(huri: Huri): Promise<T | undefined> => {
-          await delay(0)
-          const payload: T = {
-            schema: huri.hash,
-          } as T
-          return payload
-        }
-        const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
-        const result = await huri.fetch()
-        Huri.fetch = oldFetch
-        expect(result?.schema).toBe('18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
-      })
-    })
-  })
-})

package/src/Huri/Huri.ts

@@ -1,154 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { AddressValue } from '@xyo-network/account'
-import { DataLike } from '@xyo-network/core'
-import axios from 'axios'
-
-import { XyoPayload } from '../models'
-
-export type XyoObjectCategory = 'block' | 'payload'
-
-export type HuriFetchFunction = (huri: Huri) => Promise<XyoPayload | undefined>
-
-/* 
-  Valid Huri:
-
-  [<protocol>://][<archivist>/[<archive>/]]<hash>
-
-  defaults:
-    protocol: https
-    archivist: api.archivist.xyo.network
-*/
-
-export interface HuriOptions {
-  archivistUri?: string
-}
-
-export interface FetchedPayload<T extends XyoPayload = XyoPayload> {
-  huri?: Huri
-  payload: T
-}
-
-export class Huri<T extends XyoPayload = XyoPayload> {
-  public archive?: string
-  public archivist?: string
-  public hash: string
-  public originalHref: string
-  public protocol?: string
-
-  private isHuri = true
-
-  constructor(huri: DataLike | Huri, { archivistUri }: HuriOptions = {}) {
-    const huriString = Huri.isHuri(huri)?.href ?? typeof huri === 'string' ? (huri as string) : new AddressValue(huri as DataLike).hex
-    this.originalHref = huriString
-
-    const protocol = Huri.parseProtocol(huriString)
-    this.protocol = protocol ?? 'https'
-
-    const path = assertEx(Huri.parsePath(huriString), 'Missing path')
-    this.hash = this.parsePath(path, protocol !== undefined)
-
-    //if archivistUri sent, overwrite protocol and archivist
-    if (archivistUri) {
-      const archivistUriParts = archivistUri.split('://')
-      this.protocol = archivistUriParts[0]
-      this.archivist = archivistUriParts[1]
-    }
-
-    this.validateParse()
-  }
-
-  /*
-  The full href or the hash
-  */
-  public get href() {
-    const parts: string[] = []
-    if (this.protocol) {
-      parts.push(`${this.protocol}:/`)
-    }
-    if (this.archive) {
-      parts.push(`${this.archive}`)
-    }
-    if (this.archivist) {
-      parts.push(`${this.archivist}`)
-    }
-    parts.push(this.hash)
-    return parts.join('/')
-  }
-
-  static async fetch<T extends XyoPayload = XyoPayload>(huri: Huri): Promise<T | undefined> {
-    return (await axios.get<T>(huri.href)).data
-  }
-
-  public static isHuri(value: unknown) {
-    if (typeof value === 'object') {
-      return (value as Huri).isHuri ? (value as Huri) : undefined
-    }
-    return undefined
-  }
-
-  private static parsePath(huri: string) {
-    const protocolSplit = huri.split('//')
-    assertEx(protocolSplit.length <= 2, `Invalid format [${huri}]`)
-    if (protocolSplit.length === 1) {
-      return huri
-    }
-    if (protocolSplit.length === 2) {
-      return protocolSplit[1]
-    }
-  }
-
-  private static parseProtocol(huri: string) {
-    const protocolSplit = huri.split('//')
-    assertEx(protocolSplit.length <= 2, `Invalid second protocol [${protocolSplit[2]}]`)
-    const rawProtocol = protocolSplit.length === 2 ? protocolSplit.shift() : undefined
-    if (rawProtocol) {
-      const protocolParts = rawProtocol?.split(':')
-      assertEx(protocolParts.length === 2, `Invalid protocol format [${rawProtocol}]`)
-      assertEx(protocolParts[1].length === 0, `Invalid protocol format (post :) [${rawProtocol}]`)
-      return protocolParts.shift()
-    }
-  }
-
-  public async fetch(): Promise<T | undefined> {
-    return await Huri.fetch<T>(this)
-  }
-
-  public toString() {
-    return this.href
-  }
-
-  private parsePath(path: string, hasProtocol: boolean) {
-    const pathParts = path.split('/')
-
-    //if the protocol was found, then there is not allowed to be a leading /
-    assertEx(!(hasProtocol && pathParts[0].length === 0), 'Invalid protocol separator')
-
-    //remove leading '/' if needed
-    pathParts[0].length === 0 ? pathParts.shift() : null
-
-    //hash is assumed to be the last part
-    const hash = assertEx(pathParts.pop(), 'No hash specified')
-
-    //archivist is assumed to be the first part
-    this.archivist = pathParts.shift() ?? 'api.archivist.xyo.network'
-
-    //the archive is whatever is left
-    this.archive = pathParts.pop()
-
-    //after we pull off all the path parts, there should be nothing left
-    assertEx(pathParts.length === 0, 'Too many path parts')
-
-    return hash
-  }
-
-  private validateParse() {
-    //the archivist should not be zero length
-    assertEx(this.archivist?.length !== 0, 'Invalid archivist length')
-
-    //the archivist should not be zero length (can be undefined)
-    assertEx(this.archive?.length !== 0, 'Invalid archive length')
-
-    //the archive should not be set if the archivist is not set
-    assertEx(!(this.archive && !this.archivist), 'If specifying archive, archivist is also required')
-  }
-}

package/src/Huri/index.ts

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

package/src/SchemaNameValidator.ts

@@ -1,120 +0,0 @@
-import { domainExists } from '@xyo-network/core'
-
-/**
- * Validates a XYO schema structure and existence
- */
-export class XyoSchemaNameValidator {
-  public schema?: string
-  private _parts?: string[]
-  private _rootDomain?: string
-  constructor(schema?: string) {
-    this.schema = schema
-  }
-
-  /**
-   * Checks whether the schema is all lowercase
-   *
-   * @returns boolean
-   */
-  get isLowercase(): boolean {
-    return this.schema === this.schema?.toLowerCase()
-  }
-
-  /**
-   * Levels in the schema
-   *
-   * @returns number
-   */
-  get levels(): number | undefined {
-    return this.parts?.length
-  }
-
-  /**
-   * The schema converted into a string array split on '.'
-   *
-   * @returns string[]
-   */
-  get parts() {
-    this._parts = this._parts ?? this.schema?.split('.')
-    return this._parts
-  }
-
-  /**
-   * The rootDomain is the first two levels of the schema, in reverse order
-   * This can be used to determine who 'owns' that schema, based on domain
-   * registration
-   *
-   * @returns string
-   */
-  get rootDomain(): string | undefined {
-    this._rootDomain = this._rootDomain ?? this.domainLevel(1)
-    return this._rootDomain
-  }
-
-  /**
-   * Run all static validations
-   * @returns Error[]
-   */
-
-  public all() {
-    const errors: Error[] = []
-    if ((this.schema?.length ?? 0) === 0) errors.push(Error('schema missing'))
-    else if ((this.levels ?? 0) < 3) errors.push(Error(`schema levels < 3 [${this.levels}, ${this.schema}]`))
-    else if (!this.isLowercase) errors.push(Error(`schema not lowercase [${this.schema}]`))
-    return errors
-  }
-
-  /**
-   * Run all the validations
-   * @param checkExistance - boolean
-   * @returns Error[]
-   */
-
-  public async allDynamic() {
-    const errors: Error[] = []
-    if ((this.schema?.length ?? 0) === 0) errors.push(Error('schema missing'))
-    else if (!(await this.rootDomainExists())) errors.push(Error(`schema root domain must exist [${this.rootDomain}]`))
-    return errors
-  }
-
-  /**
-   * Determines how many levels of the schema's reverse domain
-   * pass DNS resolution
-   *
-   * @returns number (0 if none exist)
-   */
-  public async domainExistenceDepth() {
-    const levels = this.levels ?? 0
-    let level = 0
-    while (level < levels) {
-      if (!(await domainExists(this.domainLevel(level)))) {
-        break
-      }
-      level += 1
-    }
-    return level
-  }
-
-  /**
-   * Checks if the root domain validates via DNS resolution
-   *
-   * @returns boolean
-   */
-  public async rootDomainExists() {
-    return await domainExists(this.rootDomain)
-  }
-
-  /**
-   *
-   * Get a domain for the schema at a certain level
-   *
-   * @param level - Zero based level to check
-   * @returns string
-   */
-  private domainLevel(level: number): string | undefined {
-    return this.parts
-      ?.slice(0, level + 1)
-      .reverse()
-      .join('.')
-  }
-}

package/src/Test/index.ts

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

package/src/Test/testPayload.ts

@@ -1,16 +0,0 @@
-import { StringKeyObject } from '@xyo-network/core'
-
-import { XyoPayload } from '../models'
-
-const testSchema = 'network.xyo.test'
-const testPayload: XyoPayload<StringKeyObject> = {
-  numberField: 1,
-  objectField: {
-    numberField: 1,
-    stringField: 'stringValue',
-  },
-  schema: testSchema,
-  stringField: 'stringValue',
-}
-
-export { testPayload, testSchema }

package/src/Validator/Validator.spec.ts

@@ -1,52 +0,0 @@
-import { dumpErrors } from '@xyo-network/core'
-
-import { XyoPayload } from '../models'
-import { PayloadValidator } from './Validator'
-
-const testPayloadNoSchema: XyoPayload = {} as XyoPayload
-const testPayloadMixedCase: XyoPayload = {
-  schema: 'network.xyo.testMixedCaseSchema',
-} as XyoPayload
-const testPayloadTooFewLevels: XyoPayload = {
-  schema: 'network.xyo',
-} as XyoPayload
-const testPayloadDoesNotExist: XyoPayload = {
-  schema: 'network.dfd-sf-sf-s.blahblah',
-} as XyoPayload
-const testPayloadValid: XyoPayload = {
-  schema: 'network.xyo.test',
-} as XyoPayload
-
-test('all [missing schema]', () => {
-  const validator = new PayloadValidator(testPayloadNoSchema)
-  const errors = validator.validate()
-  expect(errors.length).toBe(1)
-})
-
-test('all [mixed case]', () => {
-  const validator = new PayloadValidator(testPayloadMixedCase)
-  const errors = validator.validate()
-  expect(errors.length).toBe(1)
-})
-
-test('all [too few levels]', () => {
-  const validator = new PayloadValidator(testPayloadTooFewLevels)
-  const errors = validator.validate()
-  expect(errors.length).toBe(1)
-})
-
-test('all [does not exist]', () => {
-  const validator = new PayloadValidator(testPayloadDoesNotExist)
-  const errors = validator.validate()
-  dumpErrors(errors)
-  expect(errors.length).toBe(0)
-})
-
-test('all [valid]', () => {
-  const validator = new PayloadValidator(testPayloadValid)
-
-  let errors: Error[] = []
-  errors = validator.validate()
-  dumpErrors(errors)
-  expect(errors.length).toBe(0)
-})

package/src/Validator/Validator.ts

@@ -1,33 +0,0 @@
-import { Validator, XyoValidatorBase } from '@xyo-network/core'
-
-import { XyoPayload } from '../models'
-import { XyoSchemaNameValidator } from '../SchemaNameValidator'
-
-export class PayloadValidator<T extends XyoPayload = XyoPayload> extends XyoValidatorBase<T> implements Validator<T> {
-  private _schemaValidator?: XyoSchemaNameValidator
-
-  constructor(payload: T) {
-    super(payload)
-  }
-
-  get schemaValidator() {
-    this._schemaValidator = this._schemaValidator ?? new XyoSchemaNameValidator(this.obj.schema ?? '')
-    return this._schemaValidator
-  }
-
-  public schemaName() {
-    const errors: Error[] = []
-    if (this.obj.schema === undefined) {
-      errors.push(Error('schema missing'))
-    } else {
-      errors.push(...this.schemaValidator.all())
-    }
-    return errors
-  }
-
-  public validate() {
-    const errors: Error[] = []
-    errors.push(...this.schemaName())
-    return errors
-  }
-}

package/src/Validator/index.ts

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

package/src/Wrapper/Wrapper.ts

@@ -1,69 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { DataLike, deepOmitUnderscoreFields, Hasher } from '@xyo-network/core'
-import { Promisable } from '@xyo-network/promise'
-
-import { Huri } from '../Huri'
-import { XyoPayload } from '../models'
-import { PayloadValidator } from '../Validator'
-
-export abstract class PayloadWrapperBase<TPayload extends XyoPayload = XyoPayload> extends Hasher<TPayload> {
-  public get body() {
-    return deepOmitUnderscoreFields<TPayload>(this.obj)
-  }
-
-  get errors() {
-    return new PayloadValidator(this.payload).validate()
-  }
-
-  public get payload() {
-    return assertEx(this.obj, 'Missing payload object')
-  }
-
-  public get previousHash() {
-    return null
-  }
-
-  public get schema() {
-    return this.payload.schema
-  }
-
-  //intentionally not naming this 'schema' so that the wrapper is not confused for a XyoPayload
-  public get schemaName() {
-    return assertEx(this.obj.schema, 'Missing payload schema')
-  }
-
-  get valid() {
-    return this.errors.length === 0
-  }
-
-  public static load(_address: DataLike | Huri): Promisable<PayloadWrapperBase | null> {
-    throw Error('Not implemented')
-  }
-
-  public static parse(_obj: unknown): PayloadWrapperBase {
-    throw Error('Not implemented')
-  }
-}
-
-export class PayloadWrapper<TPayload extends XyoPayload = XyoPayload> extends PayloadWrapperBase<TPayload> {
-  private isPayloadWrapper = true
-
-  public static override async load(address: DataLike | Huri) {
-    const payload = await new Huri(address).fetch()
-    return payload ? new PayloadWrapper(payload) : null
-  }
-
-  public static override parse<T extends XyoPayload = XyoPayload>(obj: unknown): PayloadWrapper<T> {
-    assertEx(!Array.isArray(obj), 'Array can not be converted to PayloadWrapper')
-    switch (typeof obj) {
-      case 'object': {
-        const castWrapper = obj as PayloadWrapper<T>
-        return assertEx(
-          castWrapper?.isPayloadWrapper ? castWrapper : (obj as XyoPayload).schema ? new PayloadWrapper(obj as T) : null,
-          'Unable to parse payload object',
-        )
-      }
-    }
-    throw Error(`Unable to parse [${typeof obj}]`)
-  }
-}

package/src/Wrapper/index.ts

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

package/src/models/PayloadFindFilter.ts

@@ -1,19 +0,0 @@
-/** @deprecated use offset as a string (hash) instead */
-export interface PayloadFindFilterTimeOffset {
-  offset?: number
-}
-
-export interface PayloadFindFilterHashOffset {
-  offset?: string
-}
-
-// eslint-disable-next-line deprecation/deprecation
-export type PayloadFindFilterOffset = PayloadFindFilterTimeOffset | PayloadFindFilterHashOffset
-
-export type PayloadFindFilter = {
-  limit?: number
-  order?: 'desc' | 'asc'
-  schema?: string | string[]
-  /** @deprecated use offset instead */
-  timestamp?: number
-} & PayloadFindFilterOffset

package/src/models/PayloadSet/PayloadSetPayload.ts

@@ -1,9 +0,0 @@
-import { XyoPayload } from '../XyoPayload'
-import { PayloadSetSchema } from './PayloadSetSchema'
-
-export interface PayloadSet {
-  optional?: Record<string, number>
-  required?: Record<string, number>
-}
-
-export type PayloadSetPayload = XyoPayload<PayloadSet, PayloadSetSchema>

package/src/models/PayloadSet/PayloadSetSchema.ts

@@ -1,2 +0,0 @@
-export type PayloadSetSchema = 'network.xyo.payload.set'
-export const PayloadSetSchema: PayloadSetSchema = 'network.xyo.payload.set'

package/src/models/PayloadSet/index.ts

@@ -1,2 +0,0 @@
-export * from './PayloadSetPayload'
-export * from './PayloadSetSchema'

package/src/models/XyoPayload.ts

@@ -1,31 +0,0 @@
-import { EmptyObject } from '@xyo-network/core'
-
-export type WithTimestamp<T extends EmptyObject = EmptyObject> = T & { timestamp: number }
-
-export type XyoPayloadSchema = 'network.xyo.payload'
-export const XyoPayloadSchema: XyoPayloadSchema = 'network.xyo.payload'
-
-export type SchemaFields = {
-  schema: string
-}
-
-export type WithSchema<T extends EmptyObject | void = void> = T extends EmptyObject ? SchemaFields & T : SchemaFields
-
-export type PayloadFields = {
-  sources?: string[]
-  timestamp?: number
-}
-
-export type WithPayload<T extends EmptyObject | void = void> = WithSchema<T extends EmptyObject ? PayloadFields & T : PayloadFields>
-
-export type XyoPayload<
-  T extends void | EmptyObject | WithSchema = void,
-  S extends string = T extends WithSchema ? T['schema'] : string,
-> = T extends WithSchema
-  ? /* Type sent is an XyoPayload */
-    WithPayload<T>
-  : T extends EmptyObject
-  ? /* Type sent is an Object */
-    WithPayload<T & { schema: S }>
-  : /* Type sent is void */
-    WithPayload<{ schema: S }>

package/src/models/index.ts

@@ -1,3 +0,0 @@
-export * from './PayloadFindFilter'
-export * from './PayloadSet'
-export * from './XyoPayload'