@mblaney/holster 2.0.1 → 2.1.0

package/ts/src/buffer.ts

@@ -5,7 +5,14 @@
 
 import SeaArray from "./array.ts"
 
-type Encoding = "utf8" | "utf-8" | "hex" | "base64" | "binary" | "latin1" | "ascii"
+type Encoding =
+  | "utf8"
+  | "utf-8"
+  | "hex"
+  | "base64"
+  | "binary"
+  | "latin1"
+  | "ascii"
 
 // Security constants
 const SECURITY_LIMITS = {
@@ -44,15 +51,18 @@ SafeBuffer.prototype = Object.create(Array.prototype)
 const validateStringInput = (input: string, _encoding: Encoding): void => {
   if (input.length > SECURITY_LIMITS.MAX_STRING_LENGTH) {
     throw new RangeError(
-      `String too large: ${input.length} > ${SECURITY_LIMITS.MAX_STRING_LENGTH}`
+      `String too large: ${input.length} > ${SECURITY_LIMITS.MAX_STRING_LENGTH}`,
     )
   }
 }
 
-const validateBufferSize = (size: number, operation = "buffer operation"): void => {
+const validateBufferSize = (
+  size: number,
+  operation = "buffer operation",
+): void => {
   if (size > SECURITY_LIMITS.MAX_BUFFER_SIZE) {
     throw new RangeError(
-      `Buffer size too large for ${operation}: ${size} > ${SECURITY_LIMITS.MAX_BUFFER_SIZE}`
+      `Buffer size too large for ${operation}: ${size} > ${SECURITY_LIMITS.MAX_BUFFER_SIZE}`,
     )
   }
 }
@@ -97,7 +107,9 @@ const encodeUtf8String = (str: string): Uint8Array => {
     validateBufferSize(bytes.length, "UTF-8 encoding")
     return bytes
   } catch (err) {
-    throw new TypeError(`Failed to encode UTF-8 string: ${(err as Error).message}`)
+    throw new TypeError(
+      `Failed to encode UTF-8 string: ${(err as Error).message}`,
+    )
   }
 }
 
@@ -110,7 +122,7 @@ const encodeBinaryString = (str: string): Uint8Array => {
     const charCode = str.charCodeAt(i)
     if (charCode > 255) {
       throw new TypeError(
-        `Invalid binary string: character at position ${i} exceeds byte range (${charCode} > 255)`
+        `Invalid binary string: character at position ${i} exceeds byte range (${charCode} > 255)`,
       )
     }
     bytes[i] = charCode
@@ -137,7 +149,9 @@ const parseBase64String = (base64String: string): Uint8Array => {
     }
     return bytes
   } catch (err) {
-    throw new TypeError(`Failed to decode base64 string: ${(err as Error).message}`)
+    throw new TypeError(
+      `Failed to decode base64 string: ${(err as Error).message}`,
+    )
   }
 }
 
@@ -164,7 +178,7 @@ const processArrayLikeInput = (input: unknown): Uint8Array => {
         !Number.isInteger(val)
       ) {
         throw new TypeError(
-          `Invalid byte value at index ${i}: ${val} (must be integer 0-255)`
+          `Invalid byte value at index ${i}: ${val} (must be integer 0-255)`,
         )
       }
     }
@@ -175,9 +189,12 @@ const processArrayLikeInput = (input: unknown): Uint8Array => {
     typeof input === "object" &&
     input !== null &&
     "byteLength" in input &&
-    typeof (input as { byteLength: unknown }).byteLength === "number"
+    typeof (input as {byteLength: unknown}).byteLength === "number"
   ) {
-    validateBufferSize((input as { byteLength: number }).byteLength, "ArrayBuffer-like processing")
+    validateBufferSize(
+      (input as {byteLength: number}).byteLength,
+      "ArrayBuffer-like processing",
+    )
     return new Uint8Array(input as ArrayBuffer)
   }
 
@@ -185,7 +202,7 @@ const processArrayLikeInput = (input: unknown): Uint8Array => {
     typeof input === "object" &&
     input !== null &&
     "length" in input &&
-    typeof (input as { length: unknown }).length === "number"
+    typeof (input as {length: unknown}).length === "number"
   ) {
     const arrayLike = input as ArrayLike<unknown>
     validateBufferSize(arrayLike.length, "array-like processing")
@@ -200,7 +217,7 @@ const processArrayLikeInput = (input: unknown): Uint8Array => {
         !Number.isInteger(val)
       ) {
         throw new TypeError(
-          `Invalid byte value at index ${i}: ${val} (must be integer 0-255)`
+          `Invalid byte value at index ${i}: ${val} (must be integer 0-255)`,
         )
       }
     }
@@ -257,7 +274,7 @@ Object.assign(SafeBuffer, {
           for (let i = 0; i < input.length; i++) {
             if (input.charCodeAt(i) > 127) {
               throw new TypeError(
-                `Invalid ASCII character at position ${i}: ${input.charCodeAt(i)} > 127`
+                `Invalid ASCII character at position ${i}: ${input.charCodeAt(i)} > 127`,
               )
             }
           }
@@ -342,7 +359,7 @@ Object.assign(SafeBuffer, {
         bytes = processArrayLikeInput(item)
       } catch (err) {
         throw new TypeError(
-          `Invalid array element at index ${i}: ${(err as Error).message}`
+          `Invalid array element at index ${i}: ${(err as Error).message}`,
         )
       }
 
@@ -362,7 +379,9 @@ Object.assign(SafeBuffer, {
 
       return SeaArray.from(result)
     } catch (err) {
-      throw new Error(`Failed to concatenate buffers: ${(err as Error).message}`)
+      throw new Error(
+        `Failed to concatenate buffers: ${(err as Error).message}`,
+      )
     }
   },
 
@@ -371,7 +390,7 @@ Object.assign(SafeBuffer, {
       obj instanceof SeaArray ||
       (obj !== null &&
         typeof obj === "object" &&
-        (obj as { constructor?: unknown }).constructor === SafeBuffer)
+        (obj as {constructor?: unknown}).constructor === SafeBuffer)
     )
   },
 
@@ -411,7 +430,7 @@ SafeBuffer.prototype.toString = function (
   this: SeaArray,
   encoding: Encoding = "utf8",
   start = 0,
-  end = this.length
+  end = this.length,
 ): string {
   if (typeof encoding !== "string") {
     throw new TypeError("Encoding must be a string")
@@ -430,12 +449,13 @@ SafeBuffer.prototype.toString = function (
       this,
       encoding as "utf8" | "hex" | "base64",
       start,
-      end
+      end,
     )
   } catch (err) {
-    throw new Error(`Failed to convert buffer to string: ${(err as Error).message}`)
+    throw new Error(
+      `Failed to convert buffer to string: ${(err as Error).message}`,
+    )
   }
 }
 
 export default SafeBuffer
-

package/ts/src/get.ts

@@ -3,9 +3,9 @@
  * Extracts nodes and properties based on lex queries
  */
 
-import { match, userPublicKey } from "./utils.ts"
-import type { Lex, Graph } from "./schemas.ts"
-import type { GraphNode } from "./schemas.ts"
+import {match, userPublicKey} from "./utils.ts"
+import type {Lex, Graph} from "./schemas.ts"
+import type {GraphNode} from "./schemas.ts"
 
 /**
  * Get data from graph based on lex query
@@ -29,7 +29,7 @@ const Get = (lex: Lex, graph: Graph, fast?: boolean): Graph | undefined => {
   if (!graph[soul]) return undefined
 
   const stateVector: Record<string, number> = {}
-  const node: GraphNode = { _: { "#": soul, ">": stateVector } }
+  const node: GraphNode = {_: {"#": soul, ">": stateVector}}
   const signatures: Record<string, string> = {}
 
   if (typeof lex["."] === "string") {
@@ -76,8 +76,7 @@ const Get = (lex: Lex, graph: Graph, fast?: boolean): Graph | undefined => {
   if (Object.keys(signatures).length > 0) {
     node._["s"] = signatures
   }
-  return { [soul]: node }
+  return {[soul]: node}
 }
 
 export default Get
-

package/ts/src/ham.ts

@@ -31,17 +31,17 @@ const Ham = (
   currentState: Timestamp,
   value: GraphValue,
   currentValue: GraphValue,
-  signed = false
+  signed = false,
 ): HamResult => {
-  if (state < currentState) return { historical: true }
+  if (state < currentState) return {historical: true}
 
-  if (state > currentState) return { incoming: true }
+  if (state > currentState) return {incoming: true}
 
   // state is equal to currentState. Old data is expected to propagate through
   // the network, but conflicting values with same signed timestamp are ignored
   // since the owner can only create one value per timestamp.
   if (signed && value !== currentValue) {
-    return { historical: true }
+    return {historical: true}
   }
 
   // Lexically compare to resolve conflict (for unsigned or matching values)
@@ -52,13 +52,13 @@ const Ham = (
       : currentValue
 
   // No update required
-  if (valueStr === currentValueStr) return { state: true }
+  if (valueStr === currentValueStr) return {state: true}
 
   // Keep the current value
-  if (valueStr < currentValueStr) return { current: true }
+  if (valueStr < currentValueStr) return {current: true}
 
   // Otherwise update using the incoming value
-  return { incoming: true }
+  return {incoming: true}
 }
 
 /**
@@ -69,7 +69,8 @@ Ham.mix = async (
   graph: Graph,
   hasNode: Set<string> | undefined,
   secure: boolean,
-  listen: ListenMap
+  listen: ListenMap,
+  maxGraphSize = MAX_GRAPH_SIZE,
 ): Promise<HamMixResult> => {
   if (!change || typeof change !== "object") {
     throw new TypeError("change must be an object")
@@ -137,7 +138,9 @@ Ham.mix = async (
             propsForTimestamp.length > 0 &&
             propsForTimestamp.every(([prop]) => {
               const graphState =
-                graph[soul] && graph[soul]!._[">"] ? graph[soul]!._[">"][prop] : 0
+                graph[soul] && graph[soul]!._[">"]
+                  ? graph[soul]!._[">"][prop]
+                  : 0
               return graphState !== undefined && graphState > asNumber
             })
 
@@ -145,7 +148,11 @@ Ham.mix = async (
             continue
           }
 
-          const isValid = await SEA.verifyTimestamp(asNumber, sig as string, pub)
+          const isValid = await SEA.verifyTimestamp(
+            asNumber,
+            sig as string,
+            pub,
+          )
           if (isValid) {
             signedTimestamps.add(asNumber)
             for (const [prop, ts] of incomingTimestamps) {
@@ -175,7 +182,7 @@ Ham.mix = async (
       const value = node[key]!
       const state = (node._ && node._[">"] ? node._[">"][key] : 0) || 0
       const currentValue = graph[soul] ? graph[soul][key] : undefined
-      const currentState = graph[soul] ? (graph[soul]._[">"][key] || 0) : 0
+      const currentState = graph[soul] ? graph[soul]._[">"][key] || 0 : 0
 
       if (alias && key !== utils.rel.is(value)) {
         console.log(`error alias ${alias}: ${key} !== ${utils.rel.is(value)}`)
@@ -190,7 +197,9 @@ Ham.mix = async (
         if (!defer[soul]) {
           const stateVector: Record<string, number> = {}
           const signatures: Record<string, string> | undefined = {}
-          defer[soul] = { _: { "#": soul, ">": stateVector, s: signatures } } as GraphNode
+          defer[soul] = {
+            _: {"#": soul, ">": stateVector, s: signatures},
+          } as GraphNode
         }
         defer[soul]![key] = value
         defer[soul]!._[">"][key] = state
@@ -200,28 +209,39 @@ Ham.mix = async (
       } else {
         const isSigned =
           validTimestamps.has(soul) && validTimestamps.get(soul)!.has(state)
-        const result = Ham(state, currentState, value, currentValue ?? null, isSigned)
+        const result = Ham(
+          state,
+          currentState,
+          value,
+          currentValue ?? null,
+          isSigned,
+        )
         if (result.incoming) {
           if (!now[soul]) {
             const stateVector1: Record<string, number> = {}
             const signatures1: Record<string, string> | undefined = {}
-            now[soul] = { _: { "#": soul, ">": stateVector1, s: signatures1 } } as GraphNode
+            now[soul] = {
+              _: {"#": soul, ">": stateVector1, s: signatures1},
+            } as GraphNode
           }
           if (!graph[soul]) {
             const stateVector2: Record<string, number> = {}
             const signatures2: Record<string, string> | undefined = {}
-            graph[soul] = { _: { "#": soul, ">": stateVector2, s: signatures2 } } as GraphNode
+            graph[soul] = {
+              _: {"#": soul, ">": stateVector2, s: signatures2},
+            } as GraphNode
           }
           graph[soul]![key] = now[soul]![key] = value
           graph[soul]!._[">"][key] = now[soul]!._[">"][key] = state
           if (node._["s"] && node._["s"][state]) {
-            graph[soul]!._["s"]![state] = now[soul]!._["s"]![state] = node._["s"][state]
+            graph[soul]!._["s"]![state] = now[soul]!._["s"]![state] =
+              node._["s"][state]
           }
 
           if (listen[soul]) {
-            listen[soul]!
-              .filter(l => utils.match(l["."], key))
-              .forEach(l => listeners.push(l.cb as () => void))
+            listen[soul]!.filter(l => utils.match(l["."], key)).forEach(l =>
+              listeners.push(l.cb as () => void),
+            )
           }
           updated = true
         }
@@ -229,30 +249,29 @@ Ham.mix = async (
     }
 
     if (updated && listen[soul]) {
-      listen[soul]!
-        .filter(l => utils.match(l["."]))
-        .forEach(l => listeners.push(l.cb as () => void))
+      listen[soul]!.filter(l => utils.match(l["."])).forEach(l =>
+        listeners.push(l.cb as () => void),
+      )
     }
   }
 
   const souls = Object.keys(graph)
-  if (souls.length > MAX_GRAPH_SIZE) {
+  if (souls.length > maxGraphSize) {
     const soulsByAge = souls
       .map(soul => {
         const states = graph[soul]!._ && graph[soul]!._[">"]
         const maxState = states ? Math.max(...Object.values(states)) : 0
-        return { soul, maxState }
+        return {soul, maxState}
       })
       .sort((a, b) => a.maxState - b.maxState)
-    const remove = soulsByAge.slice(0, souls.length - MAX_GRAPH_SIZE)
-    remove.forEach(({ soul }) => {
+    const remove = soulsByAge.slice(0, souls.length - maxGraphSize)
+    remove.forEach(({soul}) => {
       delete graph[soul]
       if (hasNode) hasNode.delete(soul)
     })
   }
 
-  return { now, defer, wait, listeners }
+  return {now, defer, wait, listeners}
 }
 
 export default Ham
-