Flatten trigger specs

Author: apasel422

ts/src/flexible-event/main.ts

@@ -113,12 +113,10 @@ if (options.json_file !== undefined) {
       new Config(
         source.maxEventLevelReports,
         source.attributionScopes,
-        source.triggerSpecs.flatMap((spec) =>
-          new Array<PerTriggerDataConfig>(spec.triggerData.size).fill(
-            new PerTriggerDataConfig(
-              spec.eventReportWindows.endTimes.length,
-              spec.summaryBuckets.length
-            )
+        new Array<PerTriggerDataConfig>(source.triggerData.size).fill(
+          new PerTriggerDataConfig(
+            source.eventReportWindows.endTimes.length,
+            source.maxEventLevelReports
           )
         )
       )

ts/src/header-validator/source.test.ts

@@ -1,7 +1,7 @@
 import { SourceType } from '../source-type'
 import * as vsv from '../vendor-specific-values'
 import { Maybe } from './maybe'
-import { Source, SummaryOperator, TriggerDataMatching } from './source'
+import { Source, TriggerDataMatching } from './source'
 import * as testutil from './util.test'
 import * as jsontest from './validate-json.test'
 import * as source from './validate-source'
@@ -69,17 +69,11 @@ const testCases: TestCase[] = [
       priority: 2n,
       sourceEventId: 3n,
       maxEventLevelReports: 2,
-      triggerSpecs: [
-        {
-          eventReportWindows: {
-            startTime: 0,
-            endTimes: [3601],
-          },
-          summaryBuckets: [1, 2],
-          summaryOperator: SummaryOperator.count,
-          triggerData: new Set([0, 1, 2, 3, 4, 5, 6, 7]),
-        },
-      ],
+      eventReportWindows: {
+        startTime: 0,
+        endTimes: [3601],
+      },
+      triggerData: new Set([0, 1, 2, 3, 4, 5, 6, 7]),
       triggerDataMatching: TriggerDataMatching.modulus,
       aggregatableDebugReporting: {
         budget: 1234,

ts/src/header-validator/source.ts

@@ -10,18 +10,6 @@ export type FilterData = Map<string, Set<string>>
 export type AggregationKeys = Map<string, bigint>
 export type NamedBudgets = Map<string, number>
 
-export enum SummaryOperator {
-  count = 'count',
-  value_sum = 'value_sum',
-}
-
-export type TriggerSpec = {
-  eventReportWindows: EventReportWindows
-  summaryBuckets: number[]
-  summaryOperator: SummaryOperator
-  triggerData: Set<number>
-}
-
 export type SourceAggregatableDebugReportingConfig =
   reg.AggregatableDebugReportingConfig & {
     budget: number
@@ -49,7 +37,8 @@ export type Source = reg.CommonDebug &
     maxEventLevelReports: number
     sourceEventId: bigint
 
-    triggerSpecs: TriggerSpec[]
+    eventReportWindows: EventReportWindows
+    triggerData: Set<number>
     triggerDataMatching: TriggerDataMatching
 
     eventLevelEpsilon: number

ts/src/header-validator/to-json.ts

@@ -135,23 +135,15 @@ function serializeAttributionScopes(
   }
 }
 
-type NotFullFlexSource = Partial<EventReportWindows> & {
+type NotFullFlexSource = EventReportWindows & {
   trigger_data: number[]
 }
 
 function serializeFlexSource(s: source.Source): NotFullFlexSource {
-  if (s.triggerSpecs.length === 0) {
-    return { trigger_data: [] }
-  }
-
-  if (s.triggerSpecs.length === 1) {
-    return {
-      ...serializeEventReportWindows(s.triggerSpecs[0]!.eventReportWindows),
-      ...serializeTriggerData(s.triggerSpecs[0]!.triggerData),
-    }
+  return {
+    ...serializeEventReportWindows(s.eventReportWindows),
+    ...serializeTriggerData(s.triggerData),
   }
-
-  throw new TypeError()
 }
 
 type Source = CommonDebug &
@@ -172,12 +164,7 @@ type Source = CommonDebug &
     attribution_scopes?: AttributionScopes
   }
 
-export interface Options {}
-
-export function serializeSource(
-  s: source.Source,
-  _: Readonly<Options>
-): string {
+export function serializeSource(s: source.Source): string {
   const source: Source = {
     ...serializeCommonDebug(s),
     ...serializePriority(s),
@@ -352,10 +339,7 @@ type Trigger = CommonDebug &
     attribution_scopes?: string[]
   }
 
-export function serializeTrigger(
-  t: trigger.Trigger,
-  _: Readonly<Options>
-): string {
+export function serializeTrigger(t: trigger.Trigger): string {
   const trigger: Trigger = {
     ...serializeCommonDebug(t),
     ...serializeFilterPair(t),

ts/src/header-validator/validate-source.ts

@@ -10,9 +10,7 @@ import {
   FilterData,
   Source,
   SourceAggregatableDebugReportingConfig,
-  SummaryOperator,
   TriggerDataMatching,
-  TriggerSpec,
 } from './source'
 import {
   ItemErrorAction,
@@ -336,12 +334,12 @@ function eventLevelEpsilon(j: Json, ctx: Context): Maybe<number> {
 function channelCapacity(s: Source, ctx: Context): void {
   const numStatesWords = 'number of possible output states'
 
-  const perTriggerDataConfigs = s.triggerSpecs.flatMap((spec) =>
-    Array<privacy.PerTriggerDataConfig>(spec.triggerData.size).fill(
-      new privacy.PerTriggerDataConfig(
-        spec.eventReportWindows.endTimes.length,
-        spec.summaryBuckets.length
-      )
+  const perTriggerDataConfigs = Array<privacy.PerTriggerDataConfig>(
+    s.triggerData.size
+  ).fill(
+    new privacy.PerTriggerDataConfig(
+      s.eventReportWindows.endTimes.length,
+      s.maxEventLevelReports
     )
   )
 
@@ -438,84 +436,14 @@ function fullFlexTriggerDatum(j: Json, ctx: Context): Maybe<number> {
     .filter(isInRange, ctx, 0, UINT32_MAX)
 }
 
-function triggerDataSet(
-  j: Json,
-  ctx: Context,
-  allowEmpty: boolean = false
-): Maybe<Set<number>> {
+function triggerData(j: Json, ctx: Context): Maybe<Set<number>> {
   return set(j, ctx, fullFlexTriggerDatum, {
-    minLength: allowEmpty ? 0 : 1,
+    minLength: 0,
     maxLength: constants.maxTriggerDataPerSource,
     requireDistinct: true,
   })
 }
 
-type TriggerSpecDeps = {
-  expiry: Maybe<number>
-  eventReportWindows: Maybe<EventReportWindows>
-  maxEventLevelReports: Maybe<number>
-}
-
-function makeDefaultSummaryBuckets(maxEventLevelReports: number): number[] {
-  return Array.from({ length: maxEventLevelReports }, (_, i) => i + 1)
-}
-
-function triggerSpecsFromTriggerData(
-  j: Json,
-  ctx: Context,
-  deps: TriggerSpecDeps
-): Maybe<TriggerSpec[]> {
-  return triggerDataSet(j, ctx, /*allowEmpty=*/ true).map((triggerData) => {
-    if (
-      triggerData.size === 0 ||
-      deps.eventReportWindows.value === undefined ||
-      deps.maxEventLevelReports.value === undefined
-    ) {
-      return []
-    }
-
-    return [
-      {
-        eventReportWindows: deps.eventReportWindows.value,
-        summaryBuckets: makeDefaultSummaryBuckets(
-          deps.maxEventLevelReports.value
-        ),
-        summaryOperator: SummaryOperator.count,
-        triggerData: triggerData,
-      },
-    ]
-  })
-}
-
-function defaultTriggerSpecs(
-  ctx: Context,
-  eventReportWindows: Maybe<EventReportWindows>,
-  maxEventLevelReports: Maybe<number>
-): Maybe<TriggerSpec[]> {
-  return eventReportWindows.flatMap((eventReportWindows) =>
-    maxEventLevelReports.map((maxEventLevelReports) => [
-      {
-        eventReportWindows,
-        summaryBuckets: Array.from(
-          { length: maxEventLevelReports },
-          (_, i) => i + 1
-        ),
-        summaryOperator: SummaryOperator.count,
-        triggerData: new Set(
-          Array.from(
-            {
-              length: Number(
-                constants.defaultTriggerDataCardinality[ctx.opts.sourceType]
-              ),
-            },
-            (_, i) => i
-          )
-        ),
-      },
-    ])
-  )
-}
-
 function compareNumbers(a: number, b: number): number {
   return a - b
 }
@@ -526,9 +454,7 @@ function isTriggerDataMatchingValidForSpecs(s: Source, ctx: Context): boolean {
       return true
     }
 
-    const triggerData: number[] = s.triggerSpecs
-      .flatMap((spec) => Array.from(spec.triggerData))
-      .sort(compareNumbers)
+    const triggerData: number[] = Array.from(s.triggerData).sort(compareNumbers)
 
     if (triggerData.some((triggerDatum, i) => triggerDatum !== i)) {
       ctx.error(
@@ -546,7 +472,7 @@ function warnInconsistentMaxEventLevelReportsAndTriggerSpecs(
   ctx: Context
 ): void {
   const allowsReports = s.maxEventLevelReports > 0
-  const hasSpecs = s.triggerSpecs.length > 0
+  const hasSpecs = s.triggerData.size > 0
 
   if (allowsReports && !hasSpecs) {
     ctx.warning(
@@ -567,39 +493,6 @@ function source(j: Json, ctx: Context): Maybe<Source> {
         withDefault(expiry, constants.validSourceExpiryRange[1])
       )(j, ctx)
 
-      const eventReportWindowsVal = exclusive(
-        {
-          event_report_window: (j) => eventReportWindow(j, ctx, expiryVal),
-          event_report_windows: (j) => eventReportWindows(j, ctx, expiryVal),
-        },
-        expiryVal.map(defaultEventReportWindows, ctx)
-      )(j, ctx)
-
-      const maxEventLevelReportsVal = field(
-        'max_event_level_reports',
-        maxEventLevelReports
-      )(j, ctx)
-
-      const defaultTriggerSpecsVal = defaultTriggerSpecs(
-        ctx,
-        eventReportWindowsVal,
-        maxEventLevelReportsVal
-      )
-
-      const triggerSpecsDeps = {
-        expiry: expiryVal,
-        eventReportWindows: eventReportWindowsVal,
-        maxEventLevelReports: maxEventLevelReportsVal,
-      }
-
-      const triggerSpecsVal = exclusive(
-        {
-          trigger_data: (j) =>
-            triggerSpecsFromTriggerData(j, ctx, triggerSpecsDeps),
-        },
-        defaultTriggerSpecsVal
-      )(j, ctx)
-
       return struct(j, ctx, {
         aggregatableReportWindow: field('aggregatable_report_window', (j) =>
           j === undefined ? expiryVal : singleReportWindow(j, ctx, expiryVal)
@@ -618,9 +511,35 @@ function source(j: Json, ctx: Context): Maybe<Source> {
         ),
         expiry: () => expiryVal,
         filterData: field('filter_data', withDefault(filterData, new Map())),
-        maxEventLevelReports: () => maxEventLevelReportsVal,
+        maxEventLevelReports: field(
+          'max_event_level_reports',
+          maxEventLevelReports
+        ),
         sourceEventId: field('source_event_id', withDefault(uint64, 0n)),
-        triggerSpecs: () => triggerSpecsVal,
+        eventReportWindows: exclusive(
+          {
+            event_report_window: (j) => eventReportWindow(j, ctx, expiryVal),
+            event_report_windows: (j) => eventReportWindows(j, ctx, expiryVal),
+          },
+          expiryVal.map(defaultEventReportWindows, ctx)
+        ),
+
+        triggerData: field(
+          'trigger_data',
+          withDefault(
+            triggerData,
+            new Set(
+              Array.from(
+                {
+                  length: Number(
+                    constants.defaultTriggerDataCardinality[ctx.opts.sourceType]
+                  ),
+                },
+                (_, i) => i
+              )
+            )
+          )
+        ),
         aggregatableDebugReporting: field(
           'aggregatable_debug_reporting',
           withDefault(
@@ -731,6 +650,6 @@ export function validateSource(
 export function validator(opts: Readonly<SourceOptions>): Validator<Source> {
   return {
     validate: (input) => validateSource(input, opts),
-    serialize: (value) => serializeSource(value, opts),
+    serialize: serializeSource,
   }
 }

ts/src/header-validator/validate-trigger.ts

@@ -426,6 +426,6 @@ export function validator(
 ): Validator<Trigger> {
   return {
     validate: (input) => validateTrigger(input, opts),
-    serialize: (value) => serializeTrigger(value, opts),
+    serialize: serializeTrigger,
   }
 }