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

package/src/Builder.ts

@@ -1,37 +1,26 @@
-import { assertEx } from '@xylabs/assert'
 import { Hash } from '@xylabs/hex'
-import { JsonObject } from '@xylabs/object'
-import { deepOmitPrefixedFields, PayloadHasher, removeEmptyFields } from '@xyo-network/hash'
+import { AnyObject } from '@xylabs/object'
+import { PayloadHasher } from '@xyo-network/hash'
 import { Payload, PayloadWithMeta, WithMeta } from '@xyo-network/payload-model'
 
-export interface PayloadBuilderOptions<T> {
-  fields?: Partial<T>
-  meta?: JsonObject
-  schema: string
-}
-
-export class PayloadBuilder<T extends Payload = Payload> {
-  private _$meta?: JsonObject
-  private _fields: Partial<T> = {}
-  private _schema: string
-
-  constructor({ schema, fields, meta }: PayloadBuilderOptions<T>) {
-    this._schema = schema
-    this._fields = fields ?? {}
-    this._$meta = meta
-  }
-
-  get schema() {
-    this._schema = this._schema ?? this._fields['schema']
-    return this._schema
-  }
+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) {
-    const builder = new PayloadBuilder<T>({ schema: payload.schema })
-    builder.fields(payload)
+    // 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) => {
@@ -41,27 +30,39 @@ export class PayloadBuilder<T extends Payload = Payload> {
     )
   }
 
-  static async dataHashes<T extends Payload>(payloads: T[]): Promise<Hash[]> {
-    return await Promise.all(
-      payloads.map(async (payload) => {
-        const built = await PayloadBuilder.build(payload)
-        return 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.hashPairs(payloads)).filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0])
+    return (await this.dataHashPairs(payloads)).filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0])
   }
 
-  static async filterInclude<T extends Payload>(payloads: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
+  static async filterIncludeByDataHash<T extends Payload>(payloads: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
     const hashes = Array.isArray(hash) ? hash : [hash]
-    return (await this.hashPairs(payloads)).filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0])
+    return (await this.dataHashPairs(payloads)).filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0])
+  }
+
+  static async findByDataHash<T extends Payload>(payloads: T[] = [], hash: Hash): Promise<T | undefined> {
+    return (await this.dataHashPairs(payloads)).find(([_, objHash]) => objHash === hash)?.[0]
   }
 
-  static async find<T extends Payload>(payloads: T[] = [], hash: Hash): Promise<T | undefined> {
-    return (await this.hashPairs(payloads)).find(([_, objHash]) => objHash === hash)?.[0]
+  static async hash<T extends Payload>(payload: T): Promise<Hash> {
+    return await PayloadHasher.hash(payload)
   }
 
   /**
@@ -73,11 +74,17 @@ export class PayloadBuilder<T extends Payload = Payload> {
     return await Promise.all(
       payloads.map<Promise<[WithMeta<T>, Hash]>>(async (payload) => {
         const built = await PayloadBuilder.build(payload)
-        return [built, await PayloadHasher.hashAsync(built)]
+        return [built, await PayloadBuilder.hash(built)]
       }),
     )
   }
 
+  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)
+  }
+
   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)) {
@@ -99,14 +106,9 @@ export class PayloadBuilder<T extends Payload = Payload> {
     return result
   }
 
-  $meta(fields?: JsonObject) {
-    this._$meta = fields
-    return this
-  }
-
   async build(): Promise<WithMeta<T>> {
-    const dataHashableFields = this.dataHashableFields()
-    const $hash = await PayloadHasher.hashAsync(dataHashableFields)
+    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
@@ -115,18 +117,4 @@ export class PayloadBuilder<T extends Payload = Payload> {
     }
     return hashableFields as WithMeta<T>
   }
-
-  dataHashableFields() {
-    return {
-      ...removeEmptyFields(deepOmitPrefixedFields(deepOmitPrefixedFields(this._fields, '$'), '_')),
-      schema: assertEx(this.schema, 'Payload: Missing Schema'),
-    } as T
-  }
-
-  fields(fields?: Partial<T>) {
-    if (fields) {
-      this._fields = { ...this._fields, ...removeEmptyFields(fields) }
-    }
-    return this
-  }
 }

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'