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

package/src/components/Api/GraphQL_Stitcher.res

@@ -73,11 +73,12 @@ let decode = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentParts => {
           let field = obj->Dict.get("field")->Option.flatMap(JSON.Decode.string)
           let mutations = switch obj->Dict.get("mutations") {
           | Some(JSON.Array(ms)) =>
-            ms->Array.filterMap(m =>
-              switch m {
-              | JSON.String(s) => Some(s)
-              | _ => None
-              }
+            ms->Array.filterMap(
+              m =>
+                switch m {
+                | JSON.String(s) => Some(s)
+                | _ => None
+                },
             )
           | _ => []
           }
@@ -169,9 +170,7 @@ let relayBaseTypes = [
   `enum SortOrder {\n  ASC\n  DESC\n}`,
 ]
 
-let relayBaseQueries = [
-  `  node(id: ID!): Node`,
-]
+let relayBaseQueries = [`  node(id: ID!): Node`]
 
 /**
 Assemble fragments into a complete GraphQL SDL string.
@@ -293,8 +292,8 @@ let assembleSdl = (
       : None
 
   let sdlParts =
-    [Some(typesSdl), Some(queriesSdl), Some(mutationsSdl), subscriptionsSdl]->Array.filterMap(
-      x => x,
+    [Some(typesSdl), Some(queriesSdl), Some(mutationsSdl), subscriptionsSdl]->Array.filterMap(x =>
+      x
     )
   sdlParts->Array.join("\n\n")
 }

package/src/components/Api/MCP_SchemaGenerator.res

@@ -28,8 +28,7 @@ let buildDescriptionSuffix = (
   ~entry: ReventlessInfra.Api.mutationSchemaEntry,
 ): string => {
   let viewsSuffix = switch entry.linkedViews {
-  | Some(views) if views->Array.length > 0 =>
-    ` Affects views: ${views->Array.join(", ")}.`
+  | Some(views) if views->Array.length > 0 => ` Affects views: ${views->Array.join(", ")}.`
   | _ => ""
   }
   let consistencySuffix = switch entry.consistencyRead {
@@ -41,10 +40,9 @@ let buildDescriptionSuffix = (
 
 /** Generate MCP tool definitions from mutation entries.
     Each command variant becomes a separate tool. */
-let generateTools = (
-  ~pluginName: string,
-  ~mutationEntries: array<mutationSchemaEntry>,
-): array<mcpToolDefinition> => {
+let generateTools = (~pluginName: string, ~mutationEntries: array<mutationSchemaEntry>): array<
+  mcpToolDefinition,
+> => {
   let tools: array<mcpToolDefinition> = []
 
   mutationEntries->Array.forEach(entry => {
@@ -87,8 +85,7 @@ let generateTools = (
                 obj->Dict.set("required", JSON.Encode.array(arr))
               | None => ()
               }
-            | None =>
-              obj->Dict.set("required", JSON.Encode.array([JSON.Encode.string("id")]))
+            | None => obj->Dict.set("required", JSON.Encode.array([JSON.Encode.string("id")]))
             }
             JSON.Encode.object(obj)
           | None => inputSchema
@@ -124,10 +121,9 @@ let generateTools = (
 
 /** Generate MCP resource definitions from query entries.
     Each query entry becomes one or two resources (single + list). */
-let generateResources = (
-  ~pluginName: string,
-  ~queryEntries: array<querySchemaEntry>,
-): array<mcpResourceDefinition> => {
+let generateResources = (~pluginName: string, ~queryEntries: array<querySchemaEntry>): array<
+  mcpResourceDefinition,
+> => {
   let resources: array<mcpResourceDefinition> = []
 
   queryEntries->Array.forEach(entry => {

package/src/components/Api/OwnerScopeDiagnostics.res

@@ -43,8 +43,7 @@ let warnIfNoElevatedGroups = (~comp: string, ~view: string, ~ownerField: option<
         `${view}: "${field}" is declared @owner, but no elevated groups are configured. ` ++
         "Every caller — administrators included — will see only their own rows. " ++
         "Call OwnerScope.setElevatedGroups([...]) before components are built, or set " ++
-        "REVENTLESS_ELEVATED_GROUPS — the environment is what reaches a deployment's " ++
-        "separate function runtimes, which a call in the deploy program does not.",
+        "REVENTLESS_ELEVATED_GROUPS — the environment is what reaches a deployment's " ++ "separate function runtimes, which a call in the deploy program does not.",
       )
     }
   | _ => ()

package/src/components/Api/QueryDbListQuery.res

@@ -66,10 +66,14 @@ let buildConnection = (
   ~cursorValueOf: JSON.t => string,
 ): JSON.t => {
   let edges =
-    pageItems->Array.map(item => Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))}))
+    pageItems->Array.map(item =>
+      Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))})
+    )
   let startCursor = pageItems->Array.get(0)->Option.map(item => encodeCursor(cursorValueOf(item)))
   let endCursor =
-    pageItems->Array.get(pageItems->Array.length - 1)->Option.map(item => encodeCursor(cursorValueOf(item)))
+    pageItems
+    ->Array.get(pageItems->Array.length - 1)
+    ->Option.map(item => encodeCursor(cursorValueOf(item)))
   Obj.magic({
     "edges": edges,
     "pageInfo": {
@@ -130,7 +134,7 @@ let run = (
   let perFieldChecks: array<JSON.t => bool> = capability.filterFields->Array.flatMap(f => {
     let checks: array<JSON.t => bool> = []
     switch filterDict->Dict.get(f.name ++ "Eq") {
-    | Some(v) when v != JSON.Encode.null =>
+    | Some(v) if v != JSON.Encode.null =>
       let expected = switch v->JSON.Decode.string {
       | Some(s) => s
       | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr("")
@@ -142,16 +146,18 @@ let run = (
     }
     if f.range {
       switch filterDict->Dict.get(f.name ++ "From") {
-      | Some(v) when v != JSON.Encode.null =>
+      | Some(v) if v != JSON.Encode.null =>
         let from =
           v
           ->JSON.Decode.string
           ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
-        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v >= from))
+        checks->Array.push(item =>
+          getFieldString(item, f.name)->Option.mapOr(false, v => v >= from)
+        )
       | _ => ()
       }
       switch filterDict->Dict.get(f.name ++ "To") {
-      | Some(v) when v != JSON.Encode.null =>
+      | Some(v) if v != JSON.Encode.null =>
         let to_ =
           v
           ->JSON.Decode.string
@@ -207,6 +213,7 @@ let run = (
           item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(scope.field)),
         )
       )
+
     | None => true
     }
     passSearch && passPrefix && passIds && passPerField && passOwner && passRetired

package/src/components/Api/SchemaType.res

@@ -1,40 +1,44 @@
 type rec schemaType =
   | ScalarString
   | ScalarNumber
-  | /** A number the schema says is whole. sury carries the fact on the number's
+  /** A number the schema says is whole. sury carries the fact on the number's
         `format`, and it was being dropped here — so every `int` in the domain
         reached the SDL as `Float` and JSON Schema as `"number"`, and a quantity
         was a field a client could legally send `2.5` in. */
-  ScalarInt
+  | ScalarInt
   | ScalarBoolean
   | ScalarBigInt
   | EntityId
   | DateTime
-  | /** A calendar day, with no instant in it. A shape of its own rather than a
+  /** A calendar day, with no instant in it. A shape of its own rather than a
         plain string so `format: "date"` reaches the JSON Schema — but, unlike
         `DateTime`, it is not excluded from the generic semantic wrapper below,
         so it carries `x-reventless-semantic` as well. `DateTime`'s exclusion
         exists because its bare-`format` output predates the marker and is a
         published contract; a new semantic has no such history. */
-  CalendarDate
+  | CalendarDate
   | Nullable(schemaType)
   | ArrayOf(schemaType)
   | ObjectRef(string, dict<schemaType>)
   | Enum(string, array<string>)
-  | /** A field whose type carries a semantic the IR has no dedicated shape for.
+  /** A field whose type carries a semantic the IR has no dedicated shape for.
         Wraps the shape the value actually has, so every consumer that only cares
         about shape unwraps and is otherwise unaffected. `DateTime` and `EntityId`
         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 variant used as a field: the union's name, and one arm per constructor
+  | 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
         every consumer that can already render an object renders an arm.
 
         Only a *named* union reaches this case — see `Reventless.TaggedUnion`,
         which owns the name and the arm rules both. */
-  TaggedUnion(string, array<(string, schemaType)>)
+  | TaggedUnion(string, array<(string, schemaType)>)
   | Unknown
 
 let isTagged = Reventless.DcbTag.isTagged
@@ -82,6 +86,21 @@ 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
@@ -135,9 +154,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
         | _ => ScalarString
         }
       }
-      let itemType = (isIdsFieldName(fieldName) || isIdFieldName(fieldName)) && itemType == ScalarString
-        ? EntityId
-        : itemType
+      let itemType =
+        (isIdsFieldName(fieldName) || isIdFieldName(fieldName)) && itemType == ScalarString
+          ? EntityId
+          : itemType
       ArrayOf(itemType)
     | Object({properties}) =>
       let nestedName =
@@ -149,7 +169,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
       ->Dict.toArray
       ->Array.forEach(((propName, propSchema)) => {
         if propName !== "TAG" {
-          fields->Dict.set(propName, fromSury(~parentName=nestedName, ~fieldName=propName, propSchema))
+          fields->Dict.set(
+            propName,
+            fromSury(~parentName=nestedName, ~fieldName=propName, propSchema),
+          )
         }
       })
       if fields->Dict.keysToArray->Array.length == 0 {
@@ -166,13 +189,7 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
       )
       let isOptional = nonNullVariants->Array.length < anyOf->Array.length
       if nonNullVariants->Array.length == 1 {
-        Nullable(
-          fromSury(
-            ~parentName,
-            ~fieldName,
-            nonNullVariants->Array.getUnsafe(0),
-          ),
-        )
+        Nullable(fromSury(~parentName, ~fieldName, nonNullVariants->Array.getUnsafe(0)))
       } else {
         let constValues = nonNullVariants->Array.filterMap(v =>
           switch v {
@@ -180,7 +197,10 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
           | _ => None
           }
         )
-        if constValues->Array.length == nonNullVariants->Array.length && constValues->Array.length > 0 {
+        if (
+          constValues->Array.length == nonNullVariants->Array.length &&
+            constValues->Array.length > 0
+        ) {
           let enumName =
             parentName ++
             fieldName->String.charAt(0)->String.toUpperCase ++

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

@@ -13,10 +13,10 @@ let jsonObject = (entries: array<(string, JSON.t)>): JSON.t =>
 // An absent plugin means "the declaring plugin's own", which the key's absence
 // says exactly. Writing an empty string instead would make "mine" and "unnamed"
 // indistinguishable to every reader.
-let withOptionalPlugin = (
-  entries: array<(string, JSON.t)>,
-  plugin: option<string>,
-): array<(string, JSON.t)> =>
+let withOptionalPlugin = (entries: array<(string, JSON.t)>, plugin: option<string>): array<(
+  string,
+  JSON.t,
+)> =>
   switch plugin {
   | Some(p) => entries->Array.concat([("plugin", JSON.Encode.string(p))])
   | None => entries
@@ -47,8 +47,7 @@ let mergeAnnotations = (
     }
     switch spec.indexes->Array.find(((field, _)) => field === fieldName) {
     | Some((_, indexName)) =>
-      let value =
-        indexName === "" ? JSON.Encode.bool(true) : JSON.Encode.string(indexName)
+      let value = indexName === "" ? JSON.Encode.bool(true) : JSON.Encode.string(indexName)
       obj->Dict.set("x-reventless-index", value)
     | None => ()
     }
@@ -141,10 +140,9 @@ let mergeAnnotations = (
       // the keys above follow: false is what every record said before the opt-in
       // existed, and writing it would put a key on every retirement to say
       // nothing changed.
-      let entries =
-        r.namedWhenRetired
-          ? Array.concat(entries, [("namedWhenRetired", JSON.Encode.bool(true))])
-          : entries
+      let entries = r.namedWhenRetired
+        ? Array.concat(entries, [("namedWhenRetired", JSON.Encode.bool(true))])
+        : entries
       obj->Dict.set("x-reventless-retired", JSON.Encode.object(Dict.fromArray(entries)))
     | _ => ()
     }
@@ -234,6 +232,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
@@ -419,6 +426,7 @@ and objectRefToJsonSchema = (
     | None => withAnnotations
     }
     props->Dict.set(fieldName, withAnnotations)
+
     // Optional two ways, because neither source answers alone. `optional` is
     // read off the sury schema and is the only thing that can speak for a
     // reference or a tagged field, which classify as `EntityId` before their

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/src/components/AutomationSlice/AutomationSlice.res

@@ -5,9 +5,9 @@ type outputs = ReventlessInfra.AutomationSlice.outputs
 type operations = ReventlessInfra.AutomationSlice.operations
 type component = Component.t<t, outputs, operations>
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.AutomationSlice.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.AutomationSlice.resolvedOutputs,
+> =>
   (
     outputs.resources->Adapter.resourcesToInterop,
     outputs.queryDb.resources->Adapter.resourcesToInterop,
@@ -15,7 +15,7 @@ let toResolvedOutputs = (
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((resources, queryDbResources)) => {
     let resolved: ReventlessInterop.AutomationSlice.resolvedOutputs = {
-      resources: resources,
+      resources,
       queryDb: {resources: queryDbResources},
     }
     resolved