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

package/src/BuilderBase.ts

@@ -1,98 +1,81 @@
 import { assertEx } from '@xylabs/assert'
-import type { Hash } from '@xylabs/hex'
-import type { AnyObject, JsonObject } from '@xylabs/object'
+import type { AnyObject } from '@xylabs/object'
 import {
   isJsonObject, omitBy, toJson,
 } from '@xylabs/object'
 import type { Promisable } from '@xylabs/promise'
 import { removeEmptyFields } from '@xyo-network/hash'
-import type {
-  Payload, Schema, WithMeta, WithOptionalMeta,
-} from '@xyo-network/payload-model'
+import type { Payload, Schema } 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 type WithoutMeta<T extends WithOptionalMeta<Payload>> = Omit<T, '$hash' | '$meta'>
-
-export const removeMetaAndSchema = <T extends Payload>(payload: WithOptionalSchema<WithOptionalMeta<T>>): WithoutSchema<WithoutMeta<T>> => {
-  const { ...result } = payload
-  delete result.$hash
-  delete result.$meta
+export const removeMetaAndSchema = <T extends Payload>(payload: Partial<WithOptionalSchema<T>>): WithoutSchema<T> => {
+  const { ...result } = PayloadBuilder.omitMeta(payload as T) as WithOptionalSchema<T>
   delete result.schema
   return result as Omit<T, 'schema'>
 }
 
-const omitByPredicate = (prefix: string) => (_: unknown, key: string) => {
+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 _$meta?: JsonObject
-  protected _fields?: WithoutSchema<WithoutMeta<T>>
+  protected _fields?: Partial<WithoutSchema<T>>
   protected _schema: Schema
 
   constructor(readonly options: O) {
-    const {
-      schema, fields, meta,
-    } = options
+    const { schema, fields } = options
     this._schema = schema
-    this._fields = removeEmptyFields(fields ?? {}) as WithoutSchema<WithoutMeta<T>>
-    this._$meta = meta
+    this._fields = removeMetaAndSchema(removeEmptyFields(structuredClone(fields ?? {})))
   }
 
-  static dataHashableFields<T extends Payload = Payload<AnyObject>>(
-    schema: string,
-    fields?: WithoutSchema<WithoutMeta<T>>,
-  ): Promisable<Omit<T, '$hash' | '$meta'>> {
-    const cleanFields = fields ? removeEmptyFields(fields) : undefined
+  static dataHashableFields<T extends Payload>(
+    schema: Schema,
+    payload: WithoutSchema<T>,
+
+  ): Promisable<Payload> {
+    const cleanFields = removeEmptyFields({ ...payload, schema })
     assertEx(
       cleanFields === undefined || isJsonObject(cleanFields),
       () => `Fields must be JsonObject: ${JSON.stringify(toJson(cleanFields), null, 2)}`,
     )
-    return omitBy(omitBy({ schema, ...cleanFields }, omitByPredicate('$')), omitByPredicate('_')) as unknown as T
+    return this.omitMeta(cleanFields) as T
   }
 
-  protected static metaFields(dataHash: Hash, otherMeta?: JsonObject, stamp = true): Promisable<JsonObject> {
-    const meta: JsonObject = { ...otherMeta }
-
-    if (!meta.timestamp && stamp) {
-      meta.timestamp = meta.timestamp ?? Date.now()
-    }
+  static omitClientMeta<T extends Payload>(payload: T, maxDepth = 100): T {
+    return omitBy(payload, omitByPrefixPredicate('$'), maxDepth) as T
+  }
 
-    return meta
+  static omitMeta<T extends Payload>(payload: T, maxDepth = 100): T {
+    return this.omitStorageMeta(this.omitClientMeta(payload, maxDepth), maxDepth)
   }
 
-  $meta(meta?: JsonObject) {
-    this._$meta = meta ?? (this._fields as WithMeta<T>).$meta
-    return this
+  static omitStorageMeta<T extends Payload>(payload: T, maxDepth = 100): T {
+    return omitBy(payload, omitByPrefixPredicate('_'), maxDepth) as T
   }
 
   async dataHashableFields() {
     return await PayloadBuilderBase.dataHashableFields(
       assertEx(this._schema, () => 'Payload: Missing Schema'),
-      this._fields,
+      // TDOD: Add verification that required fields are present
+      this._fields as T,
     )
   }
 
-  // we do not require sending in $hash since it will be generated anyway
-  fields(fields: WithOptionalSchema<WithOptionalMeta<T>>) {
+  fields(fields: WithOptionalSchema<T>) {
     if (fields) {
-      const {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        $meta, $hash, schema, ...fieldsOnly
-      } = fields
-      if ($meta) {
-        this.$meta($meta)
-      }
+      const fieldsClone = structuredClone(fields)
+      const { schema } = fieldsClone
       if (schema) {
         this.schema(schema)
       }
-      this._fields = removeMetaAndSchema<T>(fields)
+      this._fields = removeEmptyFields(removeMetaAndSchema<T>(fieldsClone))
     }
     return this
   }
@@ -100,8 +83,4 @@ export class PayloadBuilderBase<T extends Payload = Payload<AnyObject>, O extend
   schema(value: Schema) {
     this._schema = value
   }
-
-  protected async metaFields(dataHash: Hash, stamp = true): Promise<JsonObject> {
-    return await PayloadBuilderBase.metaFields(dataHash, this._$meta, stamp)
-  }
 }

package/src/Options.ts

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