@xyo-network/payload 2.21.11

package/src/SchemaNameValidator.ts

@@ -0,0 +1,128 @@
+import { domainExists } from '@xyo-network/core'
+
+/**
+ * Validates a XYO schema structure and existence
+ */
+export class XyoSchemaNameValidator {
+  public schema?: string
+  constructor(schema?: string) {
+    this.schema = schema
+  }
+
+  private _parts?: string[]
+
+  /**
+   * The schema converted into a string array split on '.'
+   *
+   * @returns string[]
+   */
+  get parts() {
+    this._parts = this._parts ?? this.schema?.split('.')
+    return this._parts
+  }
+
+  /**
+   * Levels in the schema
+   *
+   * @returns number
+   */
+  get levels(): number | undefined {
+    return this.parts?.length
+  }
+
+  /**
+   * Checks whether the schema is all lowercase
+   *
+   * @returns boolean
+   */
+  get isLowercase(): boolean {
+    return this.schema === this.schema?.toLowerCase()
+  }
+
+  /**
+   *
+   * 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('.')
+  }
+
+  private _rootDomain?: string
+
+  /**
+   * 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
+  }
+
+  /**
+   * Checks if the root domain validates via DNS resolution
+   *
+   * @returns boolean
+   */
+  public async rootDomainExists() {
+    return await domainExists(this.rootDomain)
+  }
+
+  /**
+   * Determines how many levels of the schema's reverse domain
+   * pass DNS resolution
+   *
+   * @returns number (0 if none exist)
+   */
+  public async domainExistanceDepth() {
+    const levels = this.levels ?? 0
+    let level = 0
+    while (level < levels) {
+      if (!(await domainExists(this.domainLevel(level)))) {
+        break
+      }
+      level += 1
+    }
+    return level
+  }
+
+  /**
+   * 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
+  }
+
+  /**
+   * 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
+  }
+}
+
+/** @deprectated use XyoSchemaNameValidator instead */
+export class SchemaValidator extends XyoSchemaNameValidator {}
+
+/** @deprectated use XyoSchemaNameValidator instead */
+export class XyoSchemaValidator extends XyoSchemaNameValidator {}

package/src/Test/index.ts

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

package/src/Test/testPayload.ts

@@ -0,0 +1,19 @@
+import { WithAdditional } from '@xyo-network/core'
+
+import { XyoPayloadWithMeta } from '../models'
+
+const testSchema = 'network.xyo.test'
+const testPayload: WithAdditional<XyoPayloadWithMeta> = {
+  _archive: 'test',
+  _hash: '20e14207f952a09f767ff614a648546c037fe524ace0bfe55db31f818aff1f1c',
+  _timestamp: 1609459255555,
+  numberField: 1,
+  objectField: {
+    numberField: 1,
+    stringField: 'stringValue',
+  },
+  schema: testSchema,
+  stringField: 'stringValue',
+}
+
+export { testPayload, testSchema }

package/src/Validator/BodyValidator.spec.ts

@@ -0,0 +1,11 @@
+import { dumpErrors } from '@xyo-network/core'
+
+import { testPayload } from '../Test'
+import { XyoPayloadBodyValidator } from './BodyValidator'
+
+test('all', () => {
+  const validator = new XyoPayloadBodyValidator(testPayload)
+  const errors = validator.validate()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})

package/src/Validator/BodyValidator.ts

@@ -0,0 +1,28 @@
+import { XyoValidator } from '@xyo-network/core'
+
+import { XyoPayload } from '../models'
+import { XyoSchemaNameValidator } from '../SchemaNameValidator'
+
+export class XyoPayloadBodyValidator<T extends XyoPayload = XyoPayload> extends XyoValidator<T> {
+  private _schemaValidator?: XyoSchemaNameValidator
+  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/MetaValidator.spec.ts

@@ -0,0 +1,11 @@
+import { dumpErrors } from '@xyo-network/core'
+
+import { testPayload } from '../Test'
+import { XyoPayloadMetaValidator } from './MetaValidator'
+
+test('all', () => {
+  const validator = new XyoPayloadMetaValidator(testPayload)
+  const errors = validator.validate()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})

package/src/Validator/MetaValidator.ts

@@ -0,0 +1,34 @@
+import { XyoHasher, XyoValidator } from '@xyo-network/core'
+
+import { XyoPayloadMeta } from '../models'
+
+const MIN_ALLOWED_TIMESTAMP = 1609459200000
+const MAX_ALLOWED_TIMESTAMP = 4102444800000
+
+class XyoPayloadMetaValidator<T extends XyoPayloadMeta = XyoPayloadMeta> extends XyoValidator<T> {
+  public hash() {
+    const errors: Error[] = []
+    const wrapper = new XyoHasher(this.obj)
+
+    const bodyHash = wrapper.hash
+    if (bodyHash !== this.obj._hash) errors.push(new Error(`Body hash mismatch: [calculated: ${bodyHash}] [found: ${this.obj._hash}]`))
+    return errors
+  }
+
+  public timestamp() {
+    const errors: Error[] = []
+    const { _timestamp } = this.obj
+    if (_timestamp === undefined) errors.push(new Error('Missing _timestamp'))
+    else if (_timestamp < MIN_ALLOWED_TIMESTAMP) errors.push(new Error('_timestamp is before year 2021'))
+    else if (_timestamp > MAX_ALLOWED_TIMESTAMP) errors.push(new Error('_timestamp is after year 2100'))
+    return errors
+  }
+
+  public validate() {
+    const errors: Error[] = []
+    errors.push(...this.hash(), ...this.timestamp())
+    return errors
+  }
+}
+
+export { XyoPayloadMetaValidator }

package/src/Validator/Validator.spec.ts

@@ -0,0 +1,63 @@
+import { dumpErrors } from '@xyo-network/core'
+
+import { XyoPayloadWithMeta } from '../models'
+import { XyoPayloadValidator } from './Validator'
+
+const testPayloadNoSchema: XyoPayloadWithMeta = {
+  _hash: '44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a',
+  _timestamp: 1609459255555,
+} as XyoPayloadWithMeta
+const testPayloadMixedCase: XyoPayloadWithMeta = {
+  _hash: '9a67116e05c33135f6ba23768f9a3fbbba155297ee1bb0a7e21d91fdc3835769',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo.testMixedCaseSchema',
+} as XyoPayloadWithMeta
+const testPayloadTooFewLevels: XyoPayloadWithMeta = {
+  _hash: '95206b26e3173deaac5e3f5d4510d50112b6348d3a2128b1eb6fe3ca66957628',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo',
+} as XyoPayloadWithMeta
+const testPayloadDoesNotExist: XyoPayloadWithMeta = {
+  _hash: '360b4ce36862ef2a20dd572d69283a86d351b2b4a9cd4f61ae6f7a320be81dbf',
+  _timestamp: 1609459255555,
+  schema: 'network.dfd-sf-sf-s.blahblah',
+} as XyoPayloadWithMeta
+const testPayloadValid: XyoPayloadWithMeta = {
+  _hash: '4b5958c6d16b26d6790e33f5be45578728b0ea36e40a0d1b9c9164822341cac1',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo.test',
+} as XyoPayloadWithMeta
+
+test('all [missing schema]', () => {
+  const validator = new XyoPayloadValidator(testPayloadNoSchema)
+  const errors = validator.validate()
+  expect(errors.length).toBe(1)
+})
+
+test('all [mixed case]', () => {
+  const validator = new XyoPayloadValidator(testPayloadMixedCase)
+  const errors = validator.validate()
+  expect(errors.length).toBe(1)
+})
+
+test('all [too few levels]', () => {
+  const validator = new XyoPayloadValidator(testPayloadTooFewLevels)
+  const errors = validator.validate()
+  expect(errors.length).toBe(1)
+})
+
+test('all [does not exist]', () => {
+  const validator = new XyoPayloadValidator(testPayloadDoesNotExist)
+  const errors = validator.validate()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})
+
+test('all [valid]', () => {
+  const validator = new XyoPayloadValidator(testPayloadValid)
+
+  let errors: Error[] = []
+  errors = validator.validate()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})

package/src/Validator/Validator.ts

@@ -0,0 +1,21 @@
+import { XyoValidator } from '@xyo-network/core'
+
+import { XyoPayloadWithMeta } from '../models'
+import { XyoPayloadBodyValidator } from './BodyValidator'
+import { XyoPayloadMetaValidator } from './MetaValidator'
+
+export class XyoPayloadValidator<T extends XyoPayloadWithMeta = XyoPayloadWithMeta> extends XyoValidator<T> {
+  public body: XyoPayloadBodyValidator
+  public meta: XyoPayloadMetaValidator
+  constructor(payload: T) {
+    super(payload)
+    this.body = new XyoPayloadBodyValidator(payload)
+    this.meta = new XyoPayloadMetaValidator(payload)
+  }
+
+  public validate() {
+    const errors: Error[] = []
+    errors.push(...this.body.validate())
+    return errors
+  }
+}

package/src/Validator/index.ts

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

package/src/Wrapper/Validator.ts

@@ -0,0 +1,17 @@
+import { XyoValidator } from '@xyo-network/core'
+
+import { XyoPayloadWithMeta } from '../models'
+import { XyoPayloadValidator } from '../Validator'
+import { XyoPayloadWrapper } from './Wrapper'
+
+export class XyoPayloadWrapperValidator<T extends XyoPayloadWrapper<XyoPayloadWithMeta> = XyoPayloadWrapper<XyoPayloadWithMeta>> extends XyoValidator<T> {
+  public get payload() {
+    return new XyoPayloadValidator(this.obj.body)
+  }
+
+  public validate() {
+    const errors: Error[] = []
+    errors.push(...this.payload.validate())
+    return errors
+  }
+}

package/src/Wrapper/Wrapper.ts

@@ -0,0 +1,25 @@
+import { deepOmitUnderscoreFields, deepPickUnderscoreFields, XyoDataLike, XyoHasher } from '@xyo-network/core'
+
+import { Huri } from '../Huri'
+import { XyoPayload } from '../models'
+
+export class XyoPayloadWrapper<T extends XyoPayload> extends XyoHasher<T> {
+  public get payload() {
+    return this.obj
+  }
+
+  public get body() {
+    return deepOmitUnderscoreFields<T>(this.obj)
+  }
+
+  public get meta() {
+    return deepPickUnderscoreFields<T>(this.obj)
+  }
+
+  public static async load(address: XyoDataLike | Huri) {
+    const payload = await new Huri(address).fetch()
+    if (payload) {
+      return new XyoPayloadWrapper(payload)
+    }
+  }
+}

package/src/Wrapper/index.ts

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

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './Builder'
+export * from './Huri'
+export * from './isXyoPayloadOfSchemaType'
+export * from './models'
+export * from './Query'
+export * from './Schema'
+export * from './SchemaNameValidator'
+export * from './Validator'
+export * from './Wrapper'

package/src/isXyoPayloadOfSchemaType.ts

@@ -0,0 +1,8 @@
+import { XyoPayload } from './models'
+import { XyoSchemaPayload } from './Schema'
+
+export const isXyoPayloadOfSchemaType = <T extends XyoPayload>(schema: string) => {
+  return (x: XyoPayload): x is T => x.schema === schema
+}
+
+export const isXyoSchemaPayload = isXyoPayloadOfSchemaType<XyoSchemaPayload>('network.xyo.schema')

package/src/models/Base.ts

@@ -0,0 +1,6 @@
+export interface XyoPayloadBase {
+  schema: string
+  previousHash?: string
+  sources?: string[]
+  timestamp?: number
+}

package/src/models/Meta.ts

@@ -0,0 +1,28 @@
+import { XyoPayloadBase } from './Base'
+import { XyoPayload } from './XyoPayload'
+
+export interface XyoPayloadMetaBase {
+  _hash: string
+  _observeDuration?: number
+  _archive: string
+  _client?: string
+  _reportedHash?: string
+  _timestamp: number
+  _sources?: XyoPayload[]
+  _user_agent?: string
+  _schemaValid?: boolean
+}
+
+export interface XyoQueryPayloadMetaBase extends XyoPayloadMetaBase {
+  _queryId: string
+}
+
+export type XyoPayloadMeta<T = unknown> = T & XyoPayloadMetaBase
+export type XyoPartialPayloadMeta<T = unknown> = T & Partial<XyoPayloadMetaBase>
+export type XyoPayloadWithMeta<T = unknown> = T & XyoPayloadMetaBase & XyoPayloadBase
+export type XyoPayloadWithPartialMeta<T = unknown> = T & Partial<XyoPayloadMetaBase> & XyoPayloadBase
+
+export type XyoQueryPayloadMeta<T = unknown> = T & XyoQueryPayloadMetaBase
+export type XyoQueryPartialPayloadMeta<T = unknown> = T & Partial<XyoQueryPayloadMetaBase>
+export type XyoQueryPayloadWithMeta<T = unknown> = T & XyoQueryPayloadMetaBase & XyoPayloadBase
+export type XyoQueryPayloadWithPartialMeta<T = unknown> = T & Partial<XyoQueryPayloadMetaBase> & XyoPayloadBase

package/src/models/XyoPayload.ts

@@ -0,0 +1,3 @@
+import { XyoPayloadBase } from './Base'
+
+export type XyoPayload<T extends object = object> = T & XyoPayloadBase

package/src/models/index.ts

@@ -0,0 +1,3 @@
+export * from './Base'
+export * from './Meta'
+export * from './XyoPayload'