@reventlessdev/reventless-core 3.0.0-alpha.259 → 3.0.0-alpha.260

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.260 (2026-09-08)
+
+### Features
+
+* **spec:** a field declares the value a form opens it on ([1d541fe](https://github.com/ReventlessDev/reventless-core/commit/1d541fe497e1df2ff48b72e26a06a1b8fd3c9e06))
+
+
 # 3.0.0-alpha.259 (2026-09-08)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.259",
+  "version": "3.0.0-alpha.260",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,21 +29,21 @@
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.9",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.9",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.9",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.10",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.160",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.161",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.132"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.133"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.78"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.80"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -89,6 +89,9 @@ let rec fromSchemaType = (
   // reaches the UI through the field's JSON Schema, which is the channel that
   // can express it.
   | Semantic(_, inner) => fromSchemaType(~required, ~asInput, inner, collectedTypes, seenTypes)
+  // The SDL type is the wrapped shape's. A GraphQL default value here instead
+  // would make the field optional on the wire — a different claim.
+  | Defaulted(_, inner) => fromSchemaType(~required, ~asInput, inner, collectedTypes, seenTypes)
   // A union declares one object type per arm and a `union` naming them. Both
   // names come from the schema — see `Reventless.TaggedUnion` — so the same union
   // is the same type wherever it appears, which is what lets AppSync merge each
@@ -292,7 +295,7 @@ let rec scalarOfSchemaType = (st: SchemaType.schemaType): string =>
   | ScalarBoolean => "Boolean"
   | ScalarBigInt => "String"
   | EntityId => "ID"
-  | Semantic(_, inner) => scalarOfSchemaType(inner)
+  | Semantic(_, inner) | Defaulted(_, inner) => scalarOfSchemaType(inner)
   | _ => "String"
   }
 

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -99,6 +99,10 @@ function fromSchemaType(_required, _asInputOpt, _st, collectedTypes, seenTypes)
           _st = inner;
           _asInputOpt = asInput;
           continue;
+        case "Defaulted" :
+          _st = st._1;
+          _asInputOpt = asInput;
+          continue;
         case "TaggedUnion" :
           let name$3 = st._0;
           if (asInput) {
@@ -232,11 +236,14 @@ function scalarOfSchemaType(_st) {
           return "String";
       }
     } else {
-      if (st.TAG !== "Semantic") {
-        return "String";
+      switch (st.TAG) {
+        case "Semantic" :
+        case "Defaulted" :
+          _st = st._1;
+          continue;
+        default:
+          return "String";
       }
-      _st = st._1;
-      continue;
     }
   };
 }

package/src/components/Api/SchemaType.res

@@ -27,6 +27,10 @@ type rec schemaType =
         are *not* expressed this way: they long predate the generic marker and
         their JSON Schema `format` output is a published contract. */
   Semantic(Reventless.Semantic.t, schemaType)
+  | /** A field whose type declares the value it opens with. Wraps the shape the
+        value has, as `Semantic` does, so a consumer that cares only about shape
+        unwraps: a default changes where a form starts, never what the field is. */
+  Defaulted(JSON.t, schemaType)
   | /** A variant used as a field: the union's name, and one arm per constructor
         keyed by the `TAG` sury discriminates on. Each arm is the `ObjectRef` its
         member type is emitted from, so the arm's own name travels with it and
@@ -82,6 +86,17 @@ let canonicalName = (id: string): option<string> =>
   ->Option.map(((_, name)) => name)
 
 let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
+  // Outermost, so it wraps whatever the field turns out to be, a semantic
+  // composite included — the other order buries the marker under a shape whose
+  // consumers unwrap it.
+  let shape = withoutDefault(~parentName, ~fieldName, schema)
+  switch Reventless.FieldDefault.getFrom(schema) {
+  | Some(value) => Defaulted(value, shape)
+  | None => shape
+  }
+}
+
+and withoutDefault = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
   // Semantics the IR already has a dedicated shape for keep it: `dateTime` and
   // `reference` are read below via `isDateTime` / `getTarget`, both of which now
   // consult the generic marker, and their `format` output is a published

package/src/components/Api/SchemaType.res.mjs

@@ -9,6 +9,7 @@ import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as CalendarDate$Reventless from "@reventlessdev/reventless-spec/src/semantic/CalendarDate.res.mjs";
+import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 
 function isIdFieldName(name) {
   let lower = name.toLowerCase();
@@ -54,6 +55,20 @@ function canonicalName(id) {
 }
 
 function fromSury(parentName, fieldName, schema) {
+  let shape = withoutDefault(parentName, fieldName, schema);
+  let value = FieldDefault$Reventless.getFrom(schema);
+  if (value !== undefined) {
+    return {
+      TAG: "Defaulted",
+      _0: value,
+      _1: shape
+    };
+  } else {
+    return shape;
+  }
+}
+
+function withoutDefault(parentName, fieldName, schema) {
   let sem = Semantic$Reventless.get(schema);
   if (sem === undefined) {
     return shapeOf(parentName, fieldName, schema);
@@ -415,6 +430,7 @@ export {
   semanticCompositeNames,
   canonicalName,
   fromSury,
+  withoutDefault,
   shapeOf,
   maxReportDepth,
   collectUnclassifiedUnions,

package/src/components/Api/SuryToJsonSchema.res

@@ -234,6 +234,15 @@ let rec fromSchemaType = (~inputNames: bool=false, st: SchemaType.schemaType): J
     | _ => base
     }
     base->withSemantic(sem)
+  // JSON Schema's own keyword, not an `x-reventless-` extension: the vocabulary
+  // already has a word for this one, so any client reads it.
+  | Defaulted(value, inner) =>
+    switch fromSchemaType(~inputNames, inner)->JSON.Decode.object {
+    | Some(obj) =>
+      obj->Dict.set("default", value)
+      JSON.Encode.object(obj)
+    | None => fromSchemaType(~inputNames, inner)
+    }
   // A union has no input form — see the fragment generator, which emits `String`
   // and says so — hence no name to publish on either arm.
   // A union is `oneOf` its arms, each an object carrying the `TAG` const it is

package/src/components/Api/SuryToJsonSchema.res.mjs

@@ -170,130 +170,144 @@ function withGraphqlInput(schema, name) {
   }
 }
 
-function fromSchemaType(inputNamesOpt, st) {
-  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
-  if (typeof st !== "object") {
-    switch (st) {
-      case "ScalarNumber" :
-        return Object.fromEntries([[
-            "type",
-            "number"
-          ]]);
-      case "ScalarBoolean" :
-        return Object.fromEntries([[
-            "type",
-            "boolean"
-          ]]);
-      case "ScalarInt" :
-      case "ScalarBigInt" :
-        return Object.fromEntries([[
-            "type",
-            "integer"
-          ]]);
-      case "EntityId" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "format",
-            "uuid"
-          ]
-        ]);
-      case "DateTime" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "format",
-            "date-time"
-          ]
-        ]);
-      case "CalendarDate" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "format",
-            "date"
-          ]
-        ]);
-      case "ScalarString" :
-      case "Unknown" :
-        return Object.fromEntries([[
-            "type",
-            "string"
-          ]]);
-    }
-  } else {
-    switch (st.TAG) {
-      case "Nullable" :
-        let innerSchema = fromSchemaType(inputNames, st._0);
-        return Object.fromEntries([[
-            "oneOf",
+function fromSchemaType(_inputNamesOpt, _st) {
+  while (true) {
+    let inputNamesOpt = _inputNamesOpt;
+    let st = _st;
+    let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
+    if (typeof st !== "object") {
+      switch (st) {
+        case "ScalarNumber" :
+          return Object.fromEntries([[
+              "type",
+              "number"
+            ]]);
+        case "ScalarBoolean" :
+          return Object.fromEntries([[
+              "type",
+              "boolean"
+            ]]);
+        case "ScalarInt" :
+        case "ScalarBigInt" :
+          return Object.fromEntries([[
+              "type",
+              "integer"
+            ]]);
+        case "EntityId" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
             [
-              innerSchema,
-              Object.fromEntries([[
-                  "type",
-                  "null"
-                ]])
+              "format",
+              "uuid"
             ]
-          ]]);
-      case "ArrayOf" :
-        return Object.fromEntries([
-          [
-            "type",
-            "array"
-          ],
-          [
-            "items",
-            fromSchemaType(inputNames, st._0)
-          ]
-        ]);
-      case "ObjectRef" :
-        let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, st._1);
-        if (inputNames) {
-          return withGraphqlInput(base, st._0);
-        } else {
-          return base;
-        }
-      case "Enum" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "enum",
-            st._1.map(prim => prim)
-          ]
-        ]);
-      case "Semantic" :
-        let inner = st._1;
-        let sem = st._0;
-        let base$1 = fromSchemaType(inputNames, inner);
-        let match = SchemaType$ReventlessCore.canonicalName(sem.id);
-        let base$2 = inputNames && match !== undefined && typeof inner === "object" && inner.TAG === "ObjectRef" ? withGraphqlInput(base$1, match + "Input") : base$1;
-        return withSemantic(base$2, sem);
-      case "TaggedUnion" :
-        let members = st._1.map(param => armToJsonSchema(inputNames, param[0], param[1]));
-        return Object.fromEntries([
-          [
-            "oneOf",
-            members
-          ],
-          [
-            "x-reventless-union",
-            st._0
-          ]
-        ]);
+          ]);
+        case "DateTime" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "format",
+              "date-time"
+            ]
+          ]);
+        case "CalendarDate" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "format",
+              "date"
+            ]
+          ]);
+        case "ScalarString" :
+        case "Unknown" :
+          return Object.fromEntries([[
+              "type",
+              "string"
+            ]]);
+      }
+    } else {
+      switch (st.TAG) {
+        case "Nullable" :
+          let innerSchema = fromSchemaType(inputNames, st._0);
+          return Object.fromEntries([[
+              "oneOf",
+              [
+                innerSchema,
+                Object.fromEntries([[
+                    "type",
+                    "null"
+                  ]])
+              ]
+            ]]);
+        case "ArrayOf" :
+          return Object.fromEntries([
+            [
+              "type",
+              "array"
+            ],
+            [
+              "items",
+              fromSchemaType(inputNames, st._0)
+            ]
+          ]);
+        case "ObjectRef" :
+          let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, st._1);
+          if (inputNames) {
+            return withGraphqlInput(base, st._0);
+          } else {
+            return base;
+          }
+        case "Enum" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "enum",
+              st._1.map(prim => prim)
+            ]
+          ]);
+        case "Semantic" :
+          let inner = st._1;
+          let sem = st._0;
+          let base$1 = fromSchemaType(inputNames, inner);
+          let match = SchemaType$ReventlessCore.canonicalName(sem.id);
+          let base$2 = inputNames && match !== undefined && typeof inner === "object" && inner.TAG === "ObjectRef" ? withGraphqlInput(base$1, match + "Input") : base$1;
+          return withSemantic(base$2, sem);
+        case "Defaulted" :
+          let inner$1 = st._1;
+          let obj = Stdlib_JSON.Decode.object(fromSchemaType(inputNames, inner$1));
+          if (obj !== undefined) {
+            obj["default"] = st._0;
+            return obj;
+          }
+          _st = inner$1;
+          _inputNamesOpt = inputNames;
+          continue;
+        case "TaggedUnion" :
+          let members = st._1.map(param => armToJsonSchema(inputNames, param[0], param[1]));
+          return Object.fromEntries([
+            [
+              "oneOf",
+              members
+            ],
+            [
+              "x-reventless-union",
+              st._0
+            ]
+          ]);
+      }
     }
-  }
+  };
 }
 
 function armToJsonSchema(inputNamesOpt, tag, armType) {

package/tests/api/SuryToJsonSchemaTest.res

@@ -1356,4 +1356,60 @@ describe("SuryToJsonSchema:", () => {
     )
   })
 
+  // The value a field opens with is JSON Schema's own keyword, not an
+  // `x-reventless-` extension — and it rides on the field's schema, so it
+  // survives the one place a name-keyed annotation spec cannot reach: a record
+  // nested inside a command.
+  describe("a field declaring a default:", () => {
+    let defaultOf = (json, ~field) =>
+      getPropertyOf(json, field)->Option.flatMap(s => getProperty(s, "default"))
+
+    let json = SuryToJsonSchema.deriveObjectSchema(
+      S.schema(s =>
+        {
+          "quantity": s.matches(S.int->Reventless.FieldDefault.int(1)),
+          "shippingMethod": s.matches(S.string->Reventless.FieldDefault.string("Standard")),
+          "plain": s.matches(S.int),
+        }
+      )->S.castToUnknown,
+    )
+
+    testSync("carries it as `default`", () =>
+      expect(defaultOf(json, ~field="quantity"))->toEqual(Some(JSON.Encode.int(1)))
+    )
+
+    testSync("keeps the shape the value actually has", () =>
+      expect(
+        getPropertyOf(json, "quantity")->Option.flatMap(s => getProperty(s, "type")),
+      )->toEqual(Some(JSON.Encode.string("integer")))
+    )
+
+    testSync("carries a string default the same way", () =>
+      expect(defaultOf(json, ~field="shippingMethod"))
+      ->toEqual(Some(JSON.Encode.string("Standard")))
+    )
+
+    testSync("while a field declaring none says nothing", () =>
+      expect(defaultOf(json, ~field="plain"))->toBe(None)
+    )
+
+    // The case the whole marker exists for: a name-keyed annotation spec speaks
+    // for a record's own fields, and an order's line items are one level in.
+    testSync("and reaches a field of a nested record", () => {
+      let lineItem = S.schema(s =>
+        {
+          "productId": s.matches(S.string),
+          "quantity": s.matches(S.int->Reventless.FieldDefault.int(1)),
+        }
+      )
+      let nested = SuryToJsonSchema.deriveObjectSchema(
+        S.schema(s => {"lineItems": s.matches(S.array(lineItem))})->S.castToUnknown,
+      )
+      expect(
+        getPropertyOf(nested, "lineItems")
+        ->Option.flatMap(a => getProperty(a, "items"))
+        ->Option.flatMap(i => defaultOf(i, ~field="quantity")),
+      )->toEqual(Some(JSON.Encode.int(1)))
+    })
+  })
 })

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -20,6 +20,7 @@ import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/compon
 import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as CalendarDate$Reventless from "@reventlessdev/reventless-spec/src/semantic/CalendarDate.res.mjs";
+import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
 
@@ -1163,6 +1164,36 @@ globalThis.describe("SuryToJsonSchema:", () => {
       globalThis.expect(nestedRequired.includes("street")).toBe(true);
     });
   });
+  globalThis.describe("a field declaring a default:", () => {
+    let defaultOf = (json, field) => Stdlib_Option.flatMap(getPropertyOf(json, field), s => getProperty(s, "default"));
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, Sury.$schema(s => ({
+      quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1)),
+      shippingMethod: s.m(FieldDefault$Reventless.string(Sury.string, "Standard")),
+      plain: s.m(Sury.int)
+    })));
+    globalThis.test("carries it as `default`", () => {
+      globalThis.expect(defaultOf(json, "quantity")).toEqual(1);
+    });
+    globalThis.test("keeps the shape the value actually has", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "quantity"), s => getProperty(s, "type"))).toEqual("integer");
+    });
+    globalThis.test("carries a string default the same way", () => {
+      globalThis.expect(defaultOf(json, "shippingMethod")).toEqual("Standard");
+    });
+    globalThis.test("while a field declaring none says nothing", () => {
+      globalThis.expect(defaultOf(json, "plain")).toBe(undefined);
+    });
+    globalThis.test("and reaches a field of a nested record", () => {
+      let lineItem = Sury.$schema(s => ({
+        productId: s.m(Sury.string),
+        quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
+      }));
+      let nested = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, Sury.$schema(s => ({
+        lineItems: s.m(Sury.array(lineItem))
+      })));
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(nested, "lineItems"), a => getProperty(a, "items")), i => defaultOf(i, "quantity"))).toEqual(1);
+    });
+  });
 });
 
 export {

package/tests/plugin/PluginStructureTest.res

@@ -1458,6 +1458,25 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       )->toEqual(["contact"])
     )
 
+    // JSON Schema's own keyword rather than an `x-reventless-` one, so a client
+    // that knows nothing about Reventless reads it.
+    testSync("@default flows through the PPX to JSON Schema's `default`", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("quantity")
+        ->Option.flatMap(s => getProperty(s, "default")),
+      )->toEqual(Some(JSON.Encode.int(1)))
+    })
+
+    testSync("@default leaves the field's own shape alone", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("quantity")
+        ->Option.flatMap(s => getProperty(s, "type"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toBe(Some("integer"))
+    })
+
     testSync("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
       let metricObj =
         annotatedSchema

package/tests/plugin/PluginStructureTest.res.mjs

@@ -1555,6 +1555,12 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     globalThis.test("@sensitive reaches an event variant's payload, not only state", () => {
       globalThis.expect(Sensitive$Reventless.variantFieldNames(PsAnnotatedView$ReventlessCore.consumedEventSchema, "ItemRecorded")).toEqual(["contact"]);
     });
+    globalThis.test("@default flows through the PPX to JSON Schema's `default`", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "quantity"), s => getProperty(s, "default"))).toEqual(1);
+    });
+    globalThis.test("@default leaves the field's own shape alone", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "quantity"), s => getProperty(s, "type")), Stdlib_JSON.Decode.string)).toBe("integer");
+    });
     globalThis.test("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
       let metricObj = Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "total"), s => getProperty(s, "x-reventless-metric"));
       globalThis.expect([

package/tests/plugin/StateView/PsAnnotatedView.res

@@ -16,6 +16,7 @@ type consumedEvent =
       // On the event, not just the state: a renderer composes from an event
       // payload, so this is the case the marker has to reach.
       @sensitive contact: string,
+      @default(1) quantity: int,
     })
 
 @live(false)
@@ -27,10 +28,11 @@ type state = {
   name: string,
   @semantic("currency") @metric({aggregate: "sum", label: "Revenue"}) total: float,
   @sensitive contact: string,
+  @default(1) quantity: int,
 }
 
 let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
-  | ItemRecorded({itemId, ownerId, version, name, total, contact}) =>
-    [Set(itemId, {itemId, ownerId, version, name, total, contact})]
+  | ItemRecorded({itemId, ownerId, version, name, total, contact, quantity}) =>
+    [Set(itemId, {itemId, ownerId, version, name, total, contact, quantity})]
   }

package/tests/plugin/StateView/PsAnnotatedView.res.mjs

@@ -4,6 +4,7 @@ import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
+import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
@@ -13,7 +14,8 @@ let consumedEventSchema = Sury.$schema(s => ({
   version: s.m(Sury.string),
   name: s.m(Sury.string),
   total: s.m(Sury.float),
-  contact: s.m(Sensitive$Reventless.string)
+  contact: s.m(Sensitive$Reventless.string),
+  quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
 }));
 
 let stateSchema = Sury.$schema(s => ({
@@ -22,7 +24,8 @@ let stateSchema = Sury.$schema(s => ({
   ownerId: s.m(Sury.string),
   name: s.m(Sury.string),
   total: s.m(Sury.float),
-  contact: s.m(Sensitive$Reventless.string)
+  contact: s.m(Sensitive$Reventless.string),
+  quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
 }));
 
 function project(param) {
@@ -37,7 +40,8 @@ function project(param) {
         ownerId: event.ownerId,
         name: event.name,
         total: event.total,
-        contact: event.contact
+        contact: event.contact,
+        quantity: event.quantity
       }
     }];
 }