@xyo-network/payload-builder 3.6.0-rc.1 → 3.6.0-rc.11

package/src/Builder.ts

@@ -1,15 +1,66 @@
 import type { Hash } from '@xylabs/hex'
 import type { AnyObject } from '@xylabs/object'
 import { ObjectHasher } from '@xyo-network/hash'
-import type { Payload } from '@xyo-network/payload-model'
+import {
+  type Payload,
+  SequenceParser,
+  type WithHashMeta,
+  type WithoutStorageMeta,
+  type WithStorageMeta,
+} from '@xyo-network/payload-model'
 
 import { PayloadBuilderBase } from './BuilderBase.ts'
-import type { PayloadBuilderOptions } from './Options.ts'
 
 export class PayloadBuilder<
   T extends Payload = Payload<AnyObject>,
-  O extends PayloadBuilderOptions<T> = PayloadBuilderOptions<T>,
-> extends PayloadBuilderBase<T, O> {
+> extends PayloadBuilderBase<T> {
+  static async addHashMeta<T extends Payload>(payload: T): Promise<WithHashMeta<T>>
+  static async addHashMeta<T extends Payload>(payloads: T[]): Promise<WithHashMeta<T>[]>
+  static async addHashMeta<T extends Payload>(payloads: T | T[]): Promise<WithHashMeta<T>[] | WithHashMeta<T>> {
+    if (Array.isArray(payloads)) {
+      return await Promise.all(
+        payloads.map(async (payload) => {
+          return await this.addHashMeta(payload)
+        }),
+      )
+    } else {
+      const _hash = await PayloadBuilder.hash(payloads)
+      const _dataHash = await PayloadBuilder.dataHash(payloads)
+      return {
+        ...payloads,
+        _dataHash,
+        _hash,
+      }
+    }
+  }
+
+  static async addSequencedStorageMeta<T extends Payload = Payload>(payload: T): Promise<WithStorageMeta<T>> {
+    const withHashMeta = await this.addHashMeta(payload)
+    const _sequence = SequenceParser.from(Date.now(), withHashMeta._hash).localSequence
+    return {
+      ...withHashMeta,
+      _sequence,
+    }
+  }
+
+  static async addStorageMeta<T extends Payload>(payload: T): Promise<WithStorageMeta<T>>
+  static async addStorageMeta<T extends Payload>(payloads: T[]): Promise<WithStorageMeta<T>[]>
+  static async addStorageMeta<T extends Payload>(payloads: T | T[]): Promise<WithStorageMeta<T>[] | WithStorageMeta<T>> {
+    return Array.isArray(payloads)
+      ? await (async () => {
+        return await Promise.all(payloads.map(async payload => await this.addSequencedStorageMeta(
+          payload,
+        )))
+      })()
+      : this.addSequencedStorageMeta(
+          payloads,
+        )
+  }
+
+  static compareStorageMeta(a: WithStorageMeta<Payload>, b: WithStorageMeta<Payload>) {
+    return a._sequence > b._sequence ? 1 : a._sequence < b._sequence ? -1 : 0
+  }
+
   static async dataHash<T extends Payload>(payload: T): Promise<Hash> {
     return await ObjectHasher.hash(this.omitMeta(payload))
   }
@@ -72,7 +123,7 @@ export class PayloadBuilder<
 
   static hashableFields<T extends Payload>(
     payload: T,
-  ): T {
+  ): WithoutStorageMeta<T> {
     return this.omitStorageMeta(payload)
   }
 
@@ -82,6 +133,15 @@ export class PayloadBuilder<
     return await ObjectHasher.hashes(payloads)
   }
 
+  static sortByStorageMeta<T extends Payload>(payloads: WithStorageMeta<T>[], direction: -1 | 1 = 1) {
+    return payloads.sort((a, b) =>
+      a._sequence < b._sequence
+        ? -direction
+        : a._sequence > b._sequence
+          ? direction
+          : 0)
+  }
+
   static async toAllHashMap<T extends Payload>(payloads: T[]): Promise<Record<Hash, T>> {
     const result: Record<Hash, T> = {}
     for (const pair of await this.hashPairs(payloads)) {
@@ -117,6 +177,7 @@ export class PayloadBuilder<
     return {
       schema: this._schema,
       ...this._fields,
+      ...this._meta,
     } as T
   }
 }

package/src/BuilderBase.ts

@@ -1,82 +1,101 @@
 import { assertEx } from '@xylabs/assert'
-import type { AnyObject } from '@xylabs/object'
+import type { AnyObject, EmptyObject } from '@xylabs/object'
 import {
-  isJsonObject, omitBy, toJson,
+  isJsonObject, omitByPrefix, pickByPrefix, toJson,
 } from '@xylabs/object'
 import type { Promisable } from '@xylabs/promise'
 import { removeEmptyFields } from '@xyo-network/hash'
-import type { Payload, Schema } from '@xyo-network/payload-model'
+import type {
+  Payload, Schema,
+  WithOnlyClientMeta,
+  WithOptionalSchema,
+  WithoutClientMeta,
+  WithoutMeta,
+  WithoutPrivateStorageMeta,
+  WithoutSchema,
+  WithoutStorageMeta,
+} from '@xyo-network/payload-model'
 
-import { PayloadBuilder } from './Builder.ts'
 import type { PayloadBuilderOptions } from './Options.ts'
 
-export type WithOptionalSchema<T extends Payload> = Omit<T, 'schema'> & Partial<T>
-
-export type WithoutSchema<T extends WithOptionalSchema<Payload>> = Omit<T, 'schema'>
-
-export const removeMetaAndSchema = <T extends Payload>(payload: Partial<WithOptionalSchema<T>>): WithoutSchema<T> => {
-  const { ...result } = PayloadBuilder.omitMeta(payload as T) as WithOptionalSchema<T>
+export const omitSchema = <T extends WithOptionalSchema>(payload: T): WithoutSchema<T> => {
+  const result = structuredClone(payload)
   delete result.schema
-  return result as Omit<T, 'schema'>
+  return result
 }
 
-const omitByPrefixPredicate = (prefix: string) => (_: unknown, key: string) => {
-  assertEx(typeof key === 'string', () => `Invalid key type [${key}, ${typeof key}]`)
-  return key.startsWith(prefix)
-}
-
-export class PayloadBuilderBase<T extends Payload = Payload<AnyObject>, O extends PayloadBuilderOptions<T> = PayloadBuilderOptions<T>> {
-  protected _fields?: Partial<WithoutSchema<T>>
+export class PayloadBuilderBase<T extends Payload = Payload<AnyObject>> {
+  protected _fields?: WithoutMeta<WithoutSchema<T>>
+  protected _meta?: WithOnlyClientMeta<T>
   protected _schema: Schema
 
-  constructor(readonly options: O) {
-    const { schema, fields } = options
+  constructor(readonly options: PayloadBuilderOptions) {
+    const { schema } = options
     this._schema = schema
-    this._fields = removeMetaAndSchema(removeEmptyFields(structuredClone(fields ?? {})))
   }
 
   static dataHashableFields<T extends Payload>(
     schema: Schema,
     payload: WithoutSchema<T>,
 
-  ): Promisable<Payload> {
+  ): Promisable<WithoutMeta<T>> {
     const cleanFields = removeEmptyFields({ ...payload, schema })
     assertEx(
       cleanFields === undefined || isJsonObject(cleanFields),
       () => `Fields must be JsonObject: ${JSON.stringify(toJson(cleanFields), null, 2)}`,
     )
-    return this.omitMeta(cleanFields) as T
+    return this.omitMeta(cleanFields) as WithoutMeta<T>
   }
 
-  static omitClientMeta<T extends Payload>(payload: T, maxDepth = 100): T {
-    return omitBy(payload, omitByPrefixPredicate('$'), maxDepth) as T
+  static omitClientMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutClientMeta<T>
+  static omitClientMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutClientMeta<T>[]
+  static omitClientMeta<T extends EmptyObject>(payloads: T | T[], maxDepth = 100): WithoutClientMeta<T> | WithoutClientMeta<T>[] {
+    return Array.isArray(payloads)
+      ? payloads.map(payload => this.omitClientMeta(payload, maxDepth))
+      : omitByPrefix(payloads, '$', maxDepth)
   }
 
-  static omitMeta<T extends Payload>(payload: T, maxDepth = 100): T {
-    return this.omitStorageMeta(this.omitClientMeta(payload, maxDepth), maxDepth)
+  static omitMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutMeta<T>
+  static omitMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutMeta<T>[]
+  static omitMeta<T extends EmptyObject>(payloads: T | T[], maxDepth = 100): WithoutMeta<T> | WithoutMeta<T>[] {
+    return Array.isArray(payloads)
+      ? payloads.map(payload => this.omitMeta(payload, maxDepth))
+      : this.omitStorageMeta(this.omitClientMeta(payloads, maxDepth), maxDepth) as unknown as WithoutMeta<T>
   }
 
-  static omitStorageMeta<T extends Payload>(payload: T, maxDepth = 100): T {
-    return omitBy(payload, omitByPrefixPredicate('_'), maxDepth) as T
+  static omitPrivateStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutPrivateStorageMeta<T>
+  static omitPrivateStorageMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutPrivateStorageMeta<T>[]
+  static omitPrivateStorageMeta<T extends EmptyObject>(payloads: T | T[], maxDepth = 100): WithoutPrivateStorageMeta<T> | WithoutPrivateStorageMeta<T>[] {
+    return Array.isArray(payloads)
+      ? payloads.map(payload => this.omitPrivateStorageMeta(payload, maxDepth))
+      : omitByPrefix(payloads, '__', maxDepth)
+  }
+
+  static omitStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutStorageMeta<T>
+  static omitStorageMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutStorageMeta<T>[]
+  static omitStorageMeta<T extends EmptyObject>(payloads: T | T[], maxDepth = 100): WithoutStorageMeta<T> | WithoutStorageMeta<T>[] {
+    return Array.isArray(payloads)
+      ? payloads.map(payload => this.omitStorageMeta(payload, maxDepth))
+      : omitByPrefix(payloads, '_', maxDepth)
   }
 
   async dataHashableFields() {
     return await PayloadBuilderBase.dataHashableFields(
       assertEx(this._schema, () => 'Payload: Missing Schema'),
-      // TDOD: Add verification that required fields are present
-      this._fields as T,
+      // TODO: Add verification that required fields are present
+      this._fields as WithoutSchema<T>,
     )
   }
 
-  fields(fields: WithOptionalSchema<T>) {
-    if (fields) {
-      const fieldsClone = structuredClone(fields)
-      const { schema } = fieldsClone
-      if (schema) {
-        this.schema(schema)
-      }
-      this._fields = removeEmptyFields(removeMetaAndSchema<T>(fieldsClone))
-    }
+  fields(fields: WithoutMeta<WithoutSchema<T>>) {
+    // we need to do the cast here since ts seems to not like nested, yet same, generics
+    this._fields = omitSchema(PayloadBuilderBase.omitMeta(removeEmptyFields(structuredClone(fields)))) as unknown as WithoutMeta<WithoutSchema<T>>
+    return this
+  }
+
+  meta(meta: WithOnlyClientMeta<T>) {
+    // we need to do the cast here since ts seems to not like nested, yet same, generics
+    this._meta = pickByPrefix(meta, '$') as WithOnlyClientMeta<T>
     return this
   }
 

package/src/Options.ts

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