@sentio/sdk 4.1.0-rc.2 → 4.1.0

package/src/testing/index.ts

@@ -1,5 +1,14 @@
 export { TestProcessorServer } from './test-processor-server.js'
-export { MetricValueToNumber, firstCounterValue, firstGaugeValue } from './metric-utils.js'
+export {
+  MetricValueToNumber,
+  firstCounterValue,
+  firstGaugeValue,
+  countersOf,
+  gaugesOf,
+  eventsOf,
+  eventField,
+  eventFieldValue
+} from './metric-utils.js'
 
 export { loadTestProvidersFromEnv } from './test-provider.js' // TODO make the interface more standard and then export
 

package/src/testing/metric-utils.ts

@@ -1,4 +1,5 @@
-import type { MetricValue, ProcessResult } from '@sentio/protos'
+import type { MetricValue, ProcessResult, RichStruct, RichValue, TimeseriesResult } from '@sentio/protos'
+import { TimeseriesResult_TimeseriesType } from '@sentio/protos'
 import { Numberish, BigDecimal } from '../core/index.js'
 import { bytesToBigInt } from '../utils/conversion.js'
 
@@ -24,26 +25,139 @@ export function MetricValueToNumber(v: MetricValue | undefined): Numberish | und
   }
 }
 
-export function firstCounterValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
-  if (!result) {
+// The legacy gauges/counters/events fields were dropped in v4; metrics and events
+// now travel exclusively as TimeseriesResult entries tagged by type. These helpers
+// recover the per-type views (and values) that tests used to read off the legacy
+// fields. The metric value lives at data.fields.value (see core/numberish.ts
+// toTimeSeriesData); event payload fields are flattened into data.fields.
+function RichValueToNumber(v: RichValue | undefined): Numberish | undefined {
+  if (v === undefined) {
     return undefined
   }
-  for (const counter of result.counters) {
-    if (counter.metadata?.name === name) {
-      return MetricValueToNumber(counter.metricValue)
+  switch (v.value.case) {
+    case 'floatValue':
+      return v.value.value
+    case 'bigintValue': {
+      let intValue = bytesToBigInt(v.value.value.data)
+      if (v.value.value.negative) {
+        intValue = -intValue
+      }
+      return intValue
     }
+    case 'bigdecimalValue': {
+      const bd = v.value.value
+      if (bd.value === undefined) {
+        return undefined
+      }
+      let intValue = bytesToBigInt(bd.value.data)
+      if (bd.value.negative) {
+        intValue = -intValue
+      }
+      return new BigDecimal(`${intValue}e${bd.exp}`)
+    }
+    default:
+      return undefined
   }
-  return undefined
 }
 
-export function firstGaugeValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
-  if (!result) {
+function timeseriesOf(result: ProcessResult | undefined, type: TimeseriesResult_TimeseriesType): TimeseriesResult[] {
+  return result?.timeseriesResult.filter((t) => t.type === type) ?? []
+}
+
+export function countersOf(result: ProcessResult | undefined): TimeseriesResult[] {
+  return timeseriesOf(result, TimeseriesResult_TimeseriesType.COUNTER)
+}
+
+export function gaugesOf(result: ProcessResult | undefined): TimeseriesResult[] {
+  return timeseriesOf(result, TimeseriesResult_TimeseriesType.GAUGE)
+}
+
+export function eventsOf(result: ProcessResult | undefined): TimeseriesResult[] {
+  return timeseriesOf(result, TimeseriesResult_TimeseriesType.EVENT)
+}
+
+// Read a string field off a TimeseriesResult's data struct (e.g. an event's
+// `message` or a flattened payload attribute). Returns undefined if absent or
+// not a string.
+export function eventField(ts: TimeseriesResult | undefined, key: string): string | undefined {
+  const v = ts?.data?.fields?.[key]?.value
+  return v?.case === 'stringValue' ? v.value : undefined
+}
+
+// Convert a RichValue back to a plain JS value (inverse of core/normalization.ts
+// normalizeToRichValue), so event payload fields — including nested structs — can
+// be asserted with deep equality.
+function richValueToJs(v: RichValue | undefined): unknown {
+  if (v === undefined) {
     return undefined
   }
-  for (const gauge of result.gauges) {
-    if (gauge.metadata?.name === name) {
-      return MetricValueToNumber(gauge.metricValue)
+  switch (v.value.case) {
+    case 'nullValue':
+      return null
+    case 'stringValue':
+    case 'boolValue':
+    case 'floatValue':
+      return v.value.value
+    case 'bigintValue': {
+      let n = bytesToBigInt(v.value.value.data)
+      if (v.value.value.negative) {
+        n = -n
+      }
+      return n
+    }
+    case 'bigdecimalValue': {
+      const bd = v.value.value
+      if (bd.value === undefined) {
+        return undefined
+      }
+      let n = bytesToBigInt(bd.value.data)
+      if (bd.value.negative) {
+        n = -n
+      }
+      return new BigDecimal(`${n}e${bd.exp}`)
+    }
+    case 'structValue':
+      return richStructToJs(v.value.value)
+    case 'listValue':
+      return v.value.value.values.map(richValueToJs)
+    default:
+      return undefined
+  }
+}
+
+function richStructToJs(s: RichStruct | undefined): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  if (s) {
+    for (const [k, v] of Object.entries(s.fields)) {
+      out[k] = richValueToJs(v)
+    }
+  }
+  return out
+}
+
+// Read an arbitrary event payload field off a TimeseriesResult's data struct as a
+// plain JS value (strings, bigints, nested objects, ...).
+export function eventFieldValue(ts: TimeseriesResult | undefined, key: string): unknown {
+  return richValueToJs(ts?.data?.fields?.[key])
+}
+
+function firstTimeseriesValue(
+  result: ProcessResult | undefined,
+  type: TimeseriesResult_TimeseriesType,
+  name: string
+): Numberish | undefined {
+  for (const ts of timeseriesOf(result, type)) {
+    if (ts.metadata?.name === name) {
+      return RichValueToNumber(ts.data?.fields?.value)
     }
   }
   return undefined
 }
+
+export function firstCounterValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
+  return firstTimeseriesValue(result, TimeseriesResult_TimeseriesType.COUNTER, name)
+}
+
+export function firstGaugeValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
+  return firstTimeseriesValue(result, TimeseriesResult_TimeseriesType.GAUGE, name)
+}

package/src/testing/test-processor-server.ts

@@ -162,6 +162,10 @@ export class TestProcessorServer {
     const subject = this.storeContext.subject
 
     return new Promise((resolve, reject) => {
+      // The V3 service streams timeseries separately as `tsRequest` batches and clears
+      // `timeseriesResult` from the final `result` message. Collect the batches here and fold
+      // them back in so test helpers can read metrics/events off `result.timeseriesResult`.
+      const collectedTimeseries: TimeseriesResult[] = []
       const subscription = subject.subscribe({
         next: (response) => {
           if (response.processId !== processId) {
@@ -173,6 +177,9 @@ export class TestProcessorServer {
               response.value.value.remove ?? false
             )
           }
+          if (response.value?.case === 'tsRequest') {
+            collectedTimeseries.push(...((response.value.value.data ?? []) as TimeseriesResult[]))
+          }
           if (response.value?.case === 'result') {
             subscription.unsubscribe()
             // The service always emits a fully-formed ProcessResult message here; use it directly.
@@ -186,6 +193,7 @@ export class TestProcessorServer {
             if (result.states?.error) {
               reject(new Error(result.states.error))
             } else {
+              result.timeseriesResult = collectedTimeseries
               resolve(result)
             }
           }

package/src/{tsdown.config.ts → tsdown.config.js}

@@ -1,3 +1,10 @@
+// NOTE: This config is intentionally plain JavaScript (not TypeScript). It is
+// copied verbatim to @sentio/sdk/dist and loaded by `sentio build` from the
+// user's node_modules. Node refuses to strip types from .ts files under
+// node_modules ("Stripping types is currently unsupported for files under
+// node_modules"), so a .ts config fails to load there. A .js config has no types
+// to strip and loads natively on every Node version and package manager. Keep it
+// .js — do not rename to .ts.
 import { defineConfig } from 'tsdown'
 
 let env
@@ -17,7 +24,7 @@ function sentioRegistrationGuard() {
       // Set the flag only (no code change) so the module is force-kept without
       // counting as a transform (avoids a spurious broken-sourcemap warning).
       handler() {
-        return { moduleSideEffects: 'no-treeshake' as const }
+        return { moduleSideEffects: 'no-treeshake' }
       }
     }
   }