@xyo-network/payload-builder 2.88.3 → 2.89.0-rc.10

package/src/Builder.ts

@@ -1,58 +1,120 @@
-import { assertEx } from '@xylabs/assert'
+import { Hash } from '@xylabs/hex'
 import { AnyObject } from '@xylabs/object'
-import { deepOmitUnderscoreFields, PayloadHasher, removeEmptyFields } from '@xyo-network/hash'
-import { Payload } from '@xyo-network/payload-model'
+import { PayloadHasher } from '@xyo-network/hash'
+import { Payload, PayloadWithMeta, WithMeta } from '@xyo-network/payload-model'
 
-export interface PayloadBuilderOptions {
-  schema: string
-}
+import { PayloadBuilderBase } from './BuilderBase'
+import { PayloadBuilderOptions } from './Options'
+
+export class PayloadBuilder<
+  T extends Payload = Payload<AnyObject>,
+  O extends PayloadBuilderOptions<T> = PayloadBuilderOptions<T>,
+> extends PayloadBuilderBase<T, O> {
+  static async build<T extends Payload>(payload: T) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { schema, $hash, $meta, ...fields } = payload as WithMeta<T>
+    const builder = new PayloadBuilder<T>({ fields: fields as T, meta: $meta, schema: payload.schema })
+    return await builder.build()
+  }
+
+  static async dataHash<T extends Payload>(payload: T): Promise<Hash> {
+    return (await this.build(payload)).$hash
+  }
+
+  static async dataHashPairs<T extends Payload>(payloads: T[]): Promise<[WithMeta<T>, Hash][]> {
+    return await Promise.all(
+      payloads.map(async (payload) => {
+        const built = await PayloadBuilder.build(payload)
+        return [built, built.$hash]
+      }),
+    )
+  }
+
+  static async dataHashes(payloads: undefined): Promise<undefined>
+  static async dataHashes<T extends Payload>(payloads: T[]): Promise<Hash[]>
+  static async dataHashes<T extends Payload>(payloads?: T[]): Promise<Hash[] | undefined> {
+    return payloads
+      ? await Promise.all(
+          payloads.map(async (payload) => {
+            const built = await PayloadBuilder.build(payload)
+            return built.$hash
+          }),
+        )
+      : undefined
+  }
+
+  static async filterExclude<T extends Payload>(payloads: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
+    return await PayloadHasher.filterExcludeByHash(await this.filterExcludeByDataHash(payloads, hash), hash)
+  }
+
+  static async filterExcludeByDataHash<T extends Payload>(payloads: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
+    const hashes = Array.isArray(hash) ? hash : [hash]
+    return (await this.dataHashPairs(payloads)).filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0])
+  }
 
-export class PayloadBuilder<T extends Payload = Payload<AnyObject>> {
-  private _$meta?: AnyObject
-  private _client = 'js'
-  private _fields: Partial<T> = {}
-  private _schema: string
-  private _timestamp = Date.now()
+  static async filterIncludeByDataHash<T extends Payload>(payloads: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
+    const hashes = Array.isArray(hash) ? hash : [hash]
+    return (await this.dataHashPairs(payloads)).filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0])
+  }
 
-  constructor({ schema }: PayloadBuilderOptions) {
-    this._schema = schema
+  static async findByDataHash<T extends Payload>(payloads: T[] = [], hash: Hash): Promise<T | undefined> {
+    return (await this.dataHashPairs(payloads)).find(([_, objHash]) => objHash === hash)?.[0]
   }
 
-  get externalMeta() {
-    const _hash = PayloadHasher.hashAsync(this.hashableFields)
-    return { _client: this._client, _hash, _timestamp: this._timestamp }
+  static async hash<T extends Payload>(payload: T): Promise<Hash> {
+    return await PayloadHasher.hash(payload)
   }
 
-  get schema() {
-    this._schema = this._schema ?? this._fields['schema']
-    return this._schema
+  /**
+   * Creates an array of payload/hash tuples based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload/hash tuples
+   */
+  static async hashPairs<T extends Payload>(payloads: T[]): Promise<[WithMeta<T>, Hash][]> {
+    return await Promise.all(
+      payloads.map<Promise<[WithMeta<T>, Hash]>>(async (payload) => {
+        const built = await PayloadBuilder.build(payload)
+        return [built, await PayloadBuilder.hash(built)]
+      }),
+    )
   }
 
-  $meta(fields?: AnyObject) {
-    this._$meta = fields
-    return this
+  static async hashes(payloads: undefined): Promise<undefined>
+  static async hashes<T extends Payload>(payloads: T[]): Promise<Hash[]>
+  static async hashes<T extends Payload>(payloads?: T[]): Promise<Hash[] | undefined> {
+    return await PayloadHasher.hashes(payloads)
   }
 
-  async build(withExternalMeta = false) {
-    let hashableFields = this.hashableFields()
-    if (this._$meta) {
-      const $hash = await PayloadHasher.hashAsync(hashableFields)
-      hashableFields = { ...hashableFields, $hash, $meta: this._$meta }
+  static async toDataHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>> {
+    const result: Record<Hash, T> = {}
+    for (const pair of await this.dataHashPairs(objs)) {
+      result[pair[1]] = pair[0]
     }
-    return withExternalMeta ? { ...hashableFields, ...this.externalMeta } : hashableFields
+    return result
   }
 
-  fields(fields?: Partial<T>) {
-    if (fields) {
-      this._fields = { ...this._fields, ...removeEmptyFields(fields) }
+  /**
+   * Creates an object map of payload hashes to payloads based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns A map of hashes to payloads
+   */
+  static async toHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>> {
+    const result: Record<Hash, T> = {}
+    for (const pair of await this.hashPairs(objs)) {
+      result[pair[1]] = pair[0]
     }
-    return this
+    return result
   }
 
-  hashableFields() {
-    return {
-      ...removeEmptyFields(deepOmitUnderscoreFields(this._fields)),
-      schema: assertEx(this.schema, 'Payload: Missing Schema'),
-    } as T
+  async build(): Promise<WithMeta<T>> {
+    const dataHashableFields = await this.dataHashableFields()
+    const $hash = await PayloadBuilder.hash(dataHashableFields)
+    const hashableFields: PayloadWithMeta = { ...dataHashableFields, $hash }
+
+    //only add $meta if it exists and has at least one field
+    if (this._$meta && Object.keys(this._$meta).length > 0) {
+      hashableFields['$meta'] = this._$meta
+    }
+    return hashableFields as WithMeta<T>
   }
 }

package/src/BuilderBase.ts

@@ -0,0 +1,57 @@
+import { assertEx } from '@xylabs/assert'
+import { AnyObject, JsonObject } from '@xylabs/object'
+import { Promisable } from '@xylabs/promise'
+import { deepOmitPrefixedFields, removeEmptyFields } from '@xyo-network/hash'
+import { Payload, Schema, WithMeta } from '@xyo-network/payload-model'
+
+import { PayloadBuilderOptions } from './Options'
+
+export class PayloadBuilderBase<T extends Payload = Payload<AnyObject>, O extends PayloadBuilderOptions<T> = PayloadBuilderOptions<T>> {
+  protected _$meta?: JsonObject
+  protected _fields?: Omit<T, 'schema' | '$hash' | '$meta'>
+  protected _schema: Schema
+
+  constructor(readonly options: O) {
+    const { schema, fields, meta } = options
+    this._schema = schema
+    this._fields = fields
+    this._$meta = meta
+  }
+
+  $meta(meta?: JsonObject) {
+    this._$meta = meta ?? (this._fields as WithMeta<T>).$meta
+    return this
+  }
+
+  async dataHashableFields(): Promise<T> {
+    return deepOmitPrefixedFields(await this.hashableFields(), '$')
+  }
+
+  //we do not require sending in $hash since it will be generated anyway
+  fields(fields: Omit<WithMeta<T>, '$hash' | 'schema'> & Partial<Pick<WithMeta<T>, '$hash' | 'schema'>>) {
+    if (fields) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { $meta, $hash, schema, ...fieldsOnly } = fields as WithMeta<T>
+      if ($meta) {
+        this.$meta($meta)
+      }
+      if (schema) {
+        this.schema(schema)
+      }
+      this._fields = { ...this._fields, ...removeEmptyFields(fieldsOnly) }
+    }
+    return this
+  }
+
+  hashableFields(): Promisable<T> {
+    const schema = assertEx(this._schema, 'Payload: Missing Schema')
+    return {
+      ...removeEmptyFields(deepOmitPrefixedFields(this._fields ?? {}, '_')),
+      schema,
+    } as T
+  }
+
+  schema(value: Schema) {
+    this._schema = value
+  }
+}

package/src/Options.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@xylabs/logger'
+import { JsonObject } from '@xylabs/object'
+import { Schema } from '@xyo-network/payload-model'
+
+export interface PayloadBuilderOptions<T> {
+  readonly fields?: Omit<T, 'schema' | '$hash' | '$meta'>
+  readonly logger?: Logger
+  readonly meta?: JsonObject
+  readonly schema: Schema
+}

package/src/index.ts

@@ -1 +1,3 @@
 export * from './Builder'
+export * from './BuilderBase'
+export * from './Options'