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

package/src/components/Aggregate/Aggregate_Callback.res

@@ -69,43 +69,47 @@ module Make = (
   //
   // `~seq` is the replayed sequence number the batch decides from, carried in so
   // the line below can name the state rather than serialise it.
-  let processCommand = (~seq: int) => (
-    (state, outcomes): (Behavior.state, array<(string, cmdOutcome, Message.meta)>),
-    topicItem: CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>,
-  ) => {
-    let {reference, command: command'} = topicItem
-    let meta = command'->updateMeta
-    let id = command'.id->Spec.Id.toString
-    // Identity, not content: the folded state grows with the entity's whole
-    // history, so serialising it here makes the line's size a function of how
-    // long the system has been in use. The state at decision time is a
-    // debugger's subject, not a log's.
-    let cmdName =
-      command'.command->Message.encode(Spec.commandSchema)->Message.variantNameOfJson->LogFormat.bold
-    EffectLogger.logDebug(
-      ~comp,
-      `deciding: id=${id} seq=${seq->Int.toString} cmd=${cmdName}`,
-    )->Effect.runSync
-    switch Behavior.decide(state, command'.command) {
-    | Ok(generatedEvents) =>
-      let newState = generatedEvents->Array.reduce(state, Behavior.evolve)
-      (newState, Array.concat(outcomes, [(reference, CmdOk(generatedEvents), meta)]))
-    | Error(error) =>
-      let errorJson = error->Message.encode(Spec.errorSchema)
-      let errorCode = errorJson->Message.variantNameOfJson
-      // Strip the TAG so detail carries only the rejection payload (empty for unit errors).
-      let (_, payloadDict) = errorJson->Message.splitMessage
-      let errorDetail =
-        payloadDict->Dict.toArray->Array.length == 0
-          ? ""
-          : payloadDict->JSON.Encode.object->JSON.stringify
-      EffectLogger.logError(
+  let processCommand = (~seq: int) =>
+    (
+      (state, outcomes): (Behavior.state, array<(string, cmdOutcome, Message.meta)>),
+      topicItem: CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>,
+    ) => {
+      let {reference, command: command'} = topicItem
+      let meta = command'->updateMeta
+      let id = command'.id->Spec.Id.toString
+      // Identity, not content: the folded state grows with the entity's whole
+      // history, so serialising it here makes the line's size a function of how
+      // long the system has been in use. The state at decision time is a
+      // debugger's subject, not a log's.
+      let cmdName =
+        command'.command
+        ->Message.encode(Spec.commandSchema)
+        ->Message.variantNameOfJson
+        ->LogFormat.bold
+      EffectLogger.logDebug(
         ~comp,
-        `decide rejected: ${errorCode} ${errorDetail} id=${id}`,
+        `deciding: id=${id} seq=${seq->Int.toString} cmd=${cmdName}`,
       )->Effect.runSync
-      (state, Array.concat(outcomes, [(reference, CmdRejected({errorCode, errorDetail}), meta)]))
+      switch Behavior.decide(state, command'.command) {
+      | Ok(generatedEvents) =>
+        let newState = generatedEvents->Array.reduce(state, Behavior.evolve)
+        (newState, Array.concat(outcomes, [(reference, CmdOk(generatedEvents), meta)]))
+      | Error(error) =>
+        let errorJson = error->Message.encode(Spec.errorSchema)
+        let errorCode = errorJson->Message.variantNameOfJson
+        // Strip the TAG so detail carries only the rejection payload (empty for unit errors).
+        let (_, payloadDict) = errorJson->Message.splitMessage
+        let errorDetail =
+          payloadDict->Dict.toArray->Array.length == 0
+            ? ""
+            : payloadDict->JSON.Encode.object->JSON.stringify
+        EffectLogger.logError(
+          ~comp,
+          `decide rejected: ${errorCode} ${errorDetail} id=${id}`,
+        )->Effect.runSync
+        (state, Array.concat(outcomes, [(reference, CmdRejected({errorCode, errorDetail}), meta)]))
+      }
     }
-  }
 
   let maxConflictRetries = 3
 
@@ -125,9 +129,7 @@ module Make = (
   // the fixed capacity (a per-aggregate knob is a future refinement — see
   // docs/plans/done/aggregate-snapshotting.md).
   let replayCacheCapacity = 100
-  let replayCache: Lru.t<string, (Behavior.state, int)> = Lru.make(
-    ~capacity=replayCacheCapacity,
-  )
+  let replayCache: Lru.t<string, (Behavior.state, int)> = Lru.make(~capacity=replayCacheCapacity)
 
   let resetCache = () => replayCache->Lru.clear
 
@@ -188,8 +190,7 @@ module Make = (
     let seedEffect = switch snapshotConfig {
     | None => Effect.succeed((Behavior.initialState, 0))
     | Some(_) =>
-      Effect.promise(() => Ops.eventLog.latestSnapshot(id))
-      ->Effect.map(snapResult =>
+      Effect.promise(() => Ops.eventLog.latestSnapshot(id))->Effect.map(snapResult =>
         switch snapResult {
         | Ok(Some(snap)) if snap.EventLog.schemaHash == stateSchemaHash =>
           switch decodeState(snap.state) {
@@ -269,7 +270,11 @@ module Make = (
     | Some({interval}) if interval > 0 && newSeq / interval > oldSeq / interval =>
       switch encodeState(state) {
       | Some(stateJson) =>
-        fireSnapshotWrite(id, idStr, {EventLog.seqNr: newSeq, state: stateJson, schemaHash: stateSchemaHash})
+        fireSnapshotWrite(
+          id,
+          idStr,
+          {EventLog.seqNr: newSeq, state: stateJson, schemaHash: stateSchemaHash},
+        )
       | None =>
         EffectLogger.logWarn(
           ~comp,
@@ -342,8 +347,7 @@ module Make = (
     | None => coldReadState(id)
     }
 
-    readState
-    ->Effect.flatMap(((initialState, sequenceNr)) => {
+    readState->Effect.flatMap(((initialState, sequenceNr)) => {
       let (finalState, outcomes) =
         topicItemsForId->Array.reduce((initialState, []), processCommand(~seq=sequenceNr))
 
@@ -379,51 +383,52 @@ module Make = (
           ~detail=eventJsons,
           `produced ${eventCount} event(s): [${eventDetails}]`,
         )
-        ->Effect.flatMap(
-          _ => Effect.promise(() => Ops.eventLog.append(sequenceNr, id, generatedEvents')),
+        ->Effect.flatMap(_ =>
+          Effect.promise(() => Ops.eventLog.append(sequenceNr, id, generatedEvents'))
         )
-        ->Effect.flatMap(
-          appendResult =>
-            switch appendResult {
-            | Ok(_) =>
-              // The post-decide fold state IS the post-append replay result;
-              // cache it so the next command for this id skips the replay.
-              let newSeq = sequenceNr + generatedEvents'->Array.length
-              replayCache->Lru.put(idStr, (finalState, newSeq))
-              // Persist a snapshot if this append crossed an interval boundary
-              // (fire-and-forget — never blocks or fails the command).
-              maybeWriteSnapshot(id, idStr, ~oldSeq=sequenceNr, ~newSeq, finalState)
-              let perRef = reportFinalOutcomes(
-                outcomes,
-                ~entityId=idStr,
-                ~appendSucceeded=true,
-                ~appendedEventCount=generatedEvents'->Array.length,
-              )
-              EffectLogger.logInfo(~comp, `append: id=${idStr}`)->Effect.map(_ => Ok(perRef))
-            | Error(EventLog.Conflict) =>
-              // Another writer advanced the stream past our (possibly cached)
-              // sequenceNr — drop the entry so the retry replays cold.
-              replayCache->Lru.invalidate(idStr)
-              // Signal the outer replay+re-decide retry loop (which matches
-              // Error(_)); the string is an internal marker, no longer a
-              // cross-component substring sentinel.
-              EffectLogger.logWarn(~comp, `conflict: id=${idStr}, will retry`)->Effect.map(
-                _ => Error("conflict"),
-              )
-            | Error(EventLog.StorageFailure(msg)) =>
-              // Appends are atomic, so the read snapshot is likely still valid —
-              // but a storage error means we can't be sure what committed;
-              // drop the entry so the next attempt reads authoritative state.
-              replayCache->Lru.invalidate(idStr)
-              let perRef = reportFinalOutcomes(
-                outcomes,
-                ~entityId=idStr,
-                ~appendSucceeded=false,
-                ~appendedEventCount=0,
-                ~appendErrorDetail=msg,
-              )
-              EffectLogger.logError(~comp, `append failed: id=${idStr}: ${msg}`)->Effect.map(_ => Ok(perRef))
-            },
+        ->Effect.flatMap(appendResult =>
+          switch appendResult {
+          | Ok(_) =>
+            // The post-decide fold state IS the post-append replay result;
+            // cache it so the next command for this id skips the replay.
+            let newSeq = sequenceNr + generatedEvents'->Array.length
+            replayCache->Lru.put(idStr, (finalState, newSeq))
+            // Persist a snapshot if this append crossed an interval boundary
+            // (fire-and-forget — never blocks or fails the command).
+            maybeWriteSnapshot(id, idStr, ~oldSeq=sequenceNr, ~newSeq, finalState)
+            let perRef = reportFinalOutcomes(
+              outcomes,
+              ~entityId=idStr,
+              ~appendSucceeded=true,
+              ~appendedEventCount=generatedEvents'->Array.length,
+            )
+            EffectLogger.logInfo(~comp, `append: id=${idStr}`)->Effect.map(_ => Ok(perRef))
+          | Error(EventLog.Conflict) =>
+            // Another writer advanced the stream past our (possibly cached)
+            // sequenceNr — drop the entry so the retry replays cold.
+            replayCache->Lru.invalidate(idStr)
+            // Signal the outer replay+re-decide retry loop (which matches
+            // Error(_)); the string is an internal marker, no longer a
+            // cross-component substring sentinel.
+            EffectLogger.logWarn(~comp, `conflict: id=${idStr}, will retry`)->Effect.map(
+              _ => Error("conflict"),
+            )
+          | Error(EventLog.StorageFailure(msg)) =>
+            // Appends are atomic, so the read snapshot is likely still valid —
+            // but a storage error means we can't be sure what committed;
+            // drop the entry so the next attempt reads authoritative state.
+            replayCache->Lru.invalidate(idStr)
+            let perRef = reportFinalOutcomes(
+              outcomes,
+              ~entityId=idStr,
+              ~appendSucceeded=false,
+              ~appendedEventCount=0,
+              ~appendErrorDetail=msg,
+            )
+            EffectLogger.logError(~comp, `append failed: id=${idStr}: ${msg}`)->Effect.map(
+              _ => Ok(perRef),
+            )
+          }
         )
       }
     })

package/src/components/Api/ApiNoApiHelpers.res

@@ -10,9 +10,7 @@ let excludedByMembers = (commandSchema: S.t<unknown>): array<string> =>
   switch commandSchema {
   | AnyOf({anyOf}) =>
     anyOf->Array.filterMap(member =>
-      member->S.Metadata.get(~id=noApiVariantId)->Option.getOr(false)
-        ? variantNameOf(member)
-        : None
+      member->S.Metadata.get(~id=noApiVariantId)->Option.getOr(false) ? variantNameOf(member) : None
     )
   | _ => []
   }

package/src/components/Api/Api_Ids.res

@@ -12,7 +12,6 @@ door applies it, and so provider adapters share one definition rather than three
 Provider-neutral on purpose: the contract belongs to neither the local platform
 nor AWS.
 */
-
 @val external btoa: string => string = "btoa"
 @val external atob: string => string = "atob"
 

package/src/components/Api/Api_Naming.res

@@ -12,9 +12,15 @@ type queryNames = {
 }
 
 let pluralize = (n: string) =>
-  if RegExp.test(%re("/[^aeiou]y$/i"), n) {
+  if RegExp.test(/[^aeiou]y$/i, n) {
     n->String.slice(~start=0, ~end=String.length(n) - 1) ++ "ies"
-  } else if n->String.endsWith("s") || n->String.endsWith("x") || n->String.endsWith("z") || n->String.endsWith("ch") || n->String.endsWith("sh") {
+  } else if (
+    n->String.endsWith("s") ||
+    n->String.endsWith("x") ||
+    n->String.endsWith("z") ||
+    n->String.endsWith("ch") ||
+    n->String.endsWith("sh")
+  ) {
     n ++ "es"
   } else {
     n ++ "s"
@@ -23,7 +29,13 @@ let pluralize = (n: string) =>
 let singularize = (n: string) =>
   if n->String.endsWith("ies") {
     n->String.slice(~start=0, ~end=n->String.length - 3) ++ "y"
-  } else if n->String.endsWith("ses") || n->String.endsWith("xes") || n->String.endsWith("zes") || n->String.endsWith("ches") || n->String.endsWith("shes") {
+  } else if (
+    n->String.endsWith("ses") ||
+    n->String.endsWith("xes") ||
+    n->String.endsWith("zes") ||
+    n->String.endsWith("ches") ||
+    n->String.endsWith("shes")
+  ) {
     n->String.slice(~start=0, ~end=n->String.length - 2)
   } else if n->String.endsWith("s") {
     n->String.slice(~start=0, ~end=n->String.length - 1)
@@ -76,16 +88,17 @@ let assertSubscriptionNameFits = (~fieldName: string) => {
 // expect that shape (not aggregate-style `${plugin}_${slice}_${command}`). @noApi
 // variants are filtered out. Every emitted name is guarded against the 50-char AppSync
 // subscription cap at build time. Returns [(fieldName, constructorName)] in declaration order.
-let sliceMutationFields = (
-  ~plugin: string,
-  ~slice: string,
-  ~commandSchema: S.t<unknown>,
-): array<(string, string)> => {
+let sliceMutationFields = (~plugin: string, ~slice: string, ~commandSchema: S.t<unknown>): array<(
+  string,
+  string,
+)> => {
   let allNames = Reventless.DcbTag.extractAllVariantNames(commandSchema->Obj.magic)
   let filtered = ApiNoApiHelpers.filterNoApiVariants(allNames, commandSchema)
   switch filtered {
   | [] => []
-  | [single] => [(assertSubscriptionNameFits(~fieldName=sliceMutationField(~plugin, ~slice)), single)]
+  | [single] => [
+      (assertSubscriptionNameFits(~fieldName=sliceMutationField(~plugin, ~slice)), single),
+    ]
   | _ =>
     filtered->Array.map(ctor => (
       assertSubscriptionNameFits(~fieldName=dcbCommandMutationField(~plugin, ~command=ctor)),
@@ -115,7 +128,11 @@ let sliceMutationFieldFor = (
 // "ProductDemand" the singularize is a no-op and pluralize behaves as usual.
 let canonicalPlural = (n: string) => pluralize(singularize(n))
 
-let queryFieldNamesForReadModel = (~plugin: string, ~name: string, ~connectionSpec: bool=true): queryNames => {
+let queryFieldNamesForReadModel = (
+  ~plugin: string,
+  ~name: string,
+  ~connectionSpec: bool=true,
+): queryNames => {
   let singular = singularize(name)
   let plural = canonicalPlural(name)
   {
@@ -144,18 +161,16 @@ returning a type the plugin does not define fails the merge — and on AWS the
 target table's `dynamodb:*` grant is attached to the *declaring* plugin's API
 role, so even a schema that merged would be refused at read time.
 */
-let resolvedFieldsOfConfig = (
-  ~plugin: string,
-  config: Reventless.ReadModel.config,
-): array<ReventlessInfra.Api.resolvedFieldEntry> => {
+let resolvedFieldsOfConfig = (~plugin: string, config: Reventless.ReadModel.config): array<
+  ReventlessInfra.Api.resolvedFieldEntry,
+> => {
   let assertSamePlugin = (~pluginName: option<string>, ~tableName: string, ~fieldName: string) =>
     switch pluginName {
     | Some(p) if p != plugin =>
       JsError.throwWithMessage(
         `Field \`${fieldName}\` resolves to "${tableName}" in plugin "${p}", but cross-plugin ` ++
         `resolvers are not supported: a plugin's GraphQL document must be valid standalone, and ` ++
-        `"${p}"'s table is not readable by "${plugin}"'s API role. Query the other view directly, ` ++
-        `or project the fields you need into this one.`,
+        `"${p}"'s table is not readable by "${plugin}"'s API role. Query the other view directly, ` ++ `or project the fields you need into this one.`,
       )
     | _ => ()
     }
@@ -186,7 +201,11 @@ let resolvedFieldsOfConfig = (
   Array.concat(single, many)
 }
 
-let queryFieldNamesForStateView = (~plugin: string, ~viewName: string, ~connectionSpec: bool=true): queryNames => {
+let queryFieldNamesForStateView = (
+  ~plugin: string,
+  ~viewName: string,
+  ~connectionSpec: bool=true,
+): queryNames => {
   let entity = stripViewSuffix(viewName)
   let singular = singularize(entity)
   let plural = canonicalPlural(entity)
@@ -206,7 +225,11 @@ let queryFieldNamesForStateView = (~plugin: string, ~viewName: string, ~connecti
 // the resolver path (`GetItem` instead of `Scan`), and the `*ByIds` batch
 // resolver all line up. StateViewSlice uses `queryFieldNamesForStateView`
 // instead and keeps its own (id-free) shape.
-let queryFieldNamesForSliceQueryDb = (~plugin: string, ~queryDbName: string, ~connectionSpec: bool=true): queryNames => {
+let queryFieldNamesForSliceQueryDb = (
+  ~plugin: string,
+  ~queryDbName: string,
+  ~connectionSpec: bool=true,
+): queryNames => {
   {
     singleFieldName: `${plugin}_${queryDbName}`,
     listFieldName: `${plugin}_${canonicalPlural(queryDbName)}`,

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
@@ -234,7 +237,9 @@ let deriveObjectTypeWithNested = (
     // — for every plugin in the merge, not just this one. Refuse at build time,
     // naming both halves.
     resolvedFields->Array.forEach(({fieldName}) =>
-      if filteredFields->Dict.get(fieldName)->Option.isSome || (includeIdParam && fieldName == "id") {
+      if (
+        filteredFields->Dict.get(fieldName)->Option.isSome || (includeIdParam && fieldName == "id")
+      ) {
         JsError.throwWithMessage(
           `${typeName}.${fieldName} is declared by @resolves/@resolvesMany and is already a field of the state record. Name the resolved field something the state does not use.`,
         )
@@ -292,7 +297,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"
   }
 
@@ -300,16 +305,15 @@ let rec scalarOfSchemaType = (st: SchemaType.schemaType): string =>
 // `SchemaType.isIdFieldName`, which lowercases before testing the suffix and so
 // accepts `paid` and `valid` — harmless where it is used, but here it would
 // nominate an ordinary word as a row's key.
-let isKeyFieldName = (name: string): bool =>
-  name->String.length > 2 && name->String.endsWith("Id")
+let isKeyFieldName = (name: string): bool => name->String.length > 2 && name->String.endsWith("Id")
 
 /** What the ladder below concluded. The two ways to have no key are opposite
     mistakes, so they are kept apart rather than collapsed into `None`. */
 type keyFieldResolution =
   | Resolved({field: string, rung: string})
-  | /** Several `*Id` fields and none matching the name — usually a field
+  /** Several `*Id` fields and none matching the name — usually a field
         somebody added to a view that used to have exactly one. */
-  Ambiguous({candidates: array<string>, conventional: string})
+  | Ambiguous({candidates: array<string>, conventional: string})
   | NoCandidate
 
 /**
@@ -381,8 +385,7 @@ let keyFieldGapMessage = (resolution: keyFieldResolution): option<string> =>
       `has no row key: it declares no @id and its \`*Id\` fields ` ++
       `(${candidates->Array.join(", ")}) include no "${conventional}" for the name to ` ++
       `pick. Adding a second \`*Id\` field to a view that had one is what lands here, ` ++
-      `and it costs the view its filter and its whole orderBy in the schema. Declare ` ++
-      `@id on the field that identifies a row.`,
+      `and it costs the view its filter and its whole orderBy in the schema. Declare ` ++ `@id on the field that identifies a row.`,
     )
   }
 
@@ -494,15 +497,14 @@ let deriveConnectionFilterType = (
   ~capability: serverCapability=emptyCapability,
 ): string => {
   let baseFields = ["search: String", "searchPrefix: String", "ids: [ID!]"]
-  let perFieldFilters =
-    capability.filterFields->Array.flatMap(f => {
-      let eq = `${f.name}Eq: ${f.gqlType}`
-      if f.range {
-        [eq, `${f.name}From: ${f.gqlType}`, `${f.name}To: ${f.gqlType}`]
-      } else {
-        [eq]
-      }
-    })
+  let perFieldFilters = capability.filterFields->Array.flatMap(f => {
+    let eq = `${f.name}Eq: ${f.gqlType}`
+    if f.range {
+      [eq, `${f.name}From: ${f.gqlType}`, `${f.name}To: ${f.gqlType}`]
+    } else {
+      [eq]
+    }
+  })
   let allFields = Array.concat(baseFields, perFieldFilters)
   let body = allFields->Array.map(f => `  ${f}`)->Array.join("\n")
   `input ${filterTypeName} {\n${body}\n}`
@@ -511,10 +513,9 @@ let deriveConnectionFilterType = (
 // Emits an `enum <Type>OrderField` and `input <Type>OrderBy` pair when the
 // capability has any sort fields. Returns [] when no field is sortable so
 // the connection field doesn't reference a non-existent OrderBy type.
-let deriveConnectionOrderByType = (
-  ~singularTypeName: string,
-  ~capability: serverCapability,
-): array<string> =>
+let deriveConnectionOrderByType = (~singularTypeName: string, ~capability: serverCapability): array<
+  string,
+> =>
   if capability.sortFields->Array.length == 0 {
     []
   } else {
@@ -558,10 +559,7 @@ let deriveObjectQueryField = (
     `  ${singleFieldName}: ${typeName}`
   }
 
-let deriveListQueryField = (
-  ~listFieldName: string,
-  ~pluralTypeName: string,
-): string =>
+let deriveListQueryField = (~listFieldName: string, ~pluralTypeName: string): string =>
   `  ${listFieldName}(nextToken: String, limit: Int): ${pluralTypeName}!`
 
 // Batched-by-ids query: fetches multiple entities in a single BatchGetItem.
@@ -569,10 +567,7 @@ let deriveListQueryField = (
 // caller correlates by `id` on each returned item. Single-key tables only —
 // composite-key BatchGetItem requires both pk + sk per key entry, which is
 // out of scope for this field.
-let deriveByIdsQueryField = (
-  ~listFieldName: string,
-  ~returnTypeName: string,
-): string =>
+let deriveByIdsQueryField = (~listFieldName: string, ~returnTypeName: string): string =>
   `  ${listFieldName}ByIds(ids: [String!]!, includeRetired: Boolean): [${returnTypeName}!]!`
 
 // ── The reference door ─────────────────────────────────────────────────────
@@ -611,10 +606,8 @@ let deriveRefTypeSdl = (~returnTypeName: string): string =>
 // `retiredState` is null in two cases that do not need telling apart by a
 // consumer: a live row, and a boolean-form retirement, where the field is the
 // state and `retired: true` has already said everything there is to say.
-let deriveRefsQueryField = (
-  ~listFieldName: string,
-  ~returnTypeName: string,
-): string => `  ${listFieldName}Refs(ids: [ID!]!): [${returnTypeName}Ref!]!`
+let deriveRefsQueryField = (~listFieldName: string, ~returnTypeName: string): string =>
+  `  ${listFieldName}Refs(ids: [ID!]!): [${returnTypeName}Ref!]!`
 
 // `includeRetired` sits beside the paging arguments rather than inside `filter`,
 // and that placement is the point. `filter` is the caller's description of the
@@ -748,10 +741,7 @@ let mutationArgTypes = (~fieldName: string, variantSchema: S.t<unknown>): option
     fields
     ->Dict.toArray
     ->Array.forEach(((argName, argType)) =>
-      out->Dict.set(
-        argName,
-        fromSchemaType(~required=true, ~asInput=true, argType, [], Set.make()),
-      )
+      out->Dict.set(argName, fromSchemaType(~required=true, ~asInput=true, argType, [], Set.make()))
     )
     out
   })
@@ -771,8 +761,10 @@ let generate = (
   // `Plugin_Activate` / `Platform_Plugin_Activate` — always the last
   // underscore-separated segment (e.g. `Activate`).
   let constructorNameOf = (fieldName: string): string =>
-    fieldName->String.split("_")->Array.get(fieldName->String.split("_")->Array.length - 1)
-      ->Option.getOr(fieldName)
+    fieldName
+    ->String.split("_")
+    ->Array.get(fieldName->String.split("_")->Array.length - 1)
+    ->Option.getOr(fieldName)
 
   mutationEntries->Array.forEach(entry => {
     let schema = entry.commandSchema
@@ -800,9 +792,8 @@ let generate = (
       entry.fieldNames->Array.forEach(fieldName => {
         let cname = constructorNameOf(fieldName)
         let variantIndex = variantNames->Array.indexOf(cname)
-        let variantSchema = variantIndex >= 0
-          ? anyOf->Array.get(variantIndex)->Option.getOr(schema)
-          : schema
+        let variantSchema =
+          variantIndex >= 0 ? anyOf->Array.get(variantIndex)->Option.getOr(schema) : schema
         switch deriveMutationFieldFromObject(
           ~fieldName,
           ~collectedTypes=types,
@@ -835,8 +826,7 @@ let generate = (
           ~collectedTypes=types,
           ~seenTypes,
           schema,
-        )
-        ->Option.forEach(field => mutations->Array.push(field))
+        )->Option.forEach(field => mutations->Array.push(field))
       }
     | _ => ()
     }
@@ -981,8 +971,9 @@ let generate = (
         let edgeName = entry.returnTypeName ++ "Edge"
         seenTypes->Set.add(edgeName)
         seenTypes->Set.add(connectionTypeName)
-        deriveConnectionTypes(~singularTypeName=entry.returnTypeName)
-        ->Array.forEach(t => types->Array.push(t))
+        deriveConnectionTypes(~singularTypeName=entry.returnTypeName)->Array.forEach(t =>
+          types->Array.push(t)
+        )
       }
       let capability = deriveServerCapability(~entityName=entityNameOf(entry), entry.stateSchema)
       let connectionFilterTypeName = entry.returnTypeName ++ "Filter"
@@ -992,8 +983,10 @@ let generate = (
           deriveConnectionFilterType(~filterTypeName=connectionFilterTypeName, ~capability),
         )
       }
-      let orderByTypes =
-        deriveConnectionOrderByType(~singularTypeName=entry.returnTypeName, ~capability)
+      let orderByTypes = deriveConnectionOrderByType(
+        ~singularTypeName=entry.returnTypeName,
+        ~capability,
+      )
       let hasOrderBy = orderByTypes->Array.length > 0
       if hasOrderBy {
         let orderFieldEnumName = entry.returnTypeName ++ "OrderField"
@@ -1021,10 +1014,7 @@ let generate = (
         )
         types->Array.push(pluralType)
       }
-      let listField = deriveListQueryField(
-        ~listFieldName,
-        ~pluralTypeName=listFieldName,
-      )
+      let listField = deriveListQueryField(~listFieldName, ~pluralTypeName=listFieldName)
       queries->Array.push(listField)
     }
   })

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/GraphQL_SchemaInspector.res

@@ -19,7 +19,10 @@ let inspectScalar = (schema: S.t<'a>): string => {
 }
 
 let inspectObjectType = (~typeName: string, schema: S.t<'a>): option<string> => {
-  let types = GraphQL_FragmentGenerator.deriveObjectTypeWithNested(~typeName, schema->S.castToUnknown)
+  let types = GraphQL_FragmentGenerator.deriveObjectTypeWithNested(
+    ~typeName,
+    schema->S.castToUnknown,
+  )
   types->Array.get(types->Array.length - 1)
 }
 
@@ -103,8 +106,7 @@ let inspectFragment = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentI
   | true => `type Mutation {\n${parts.mutations->Array.join("\n")}\n}`
   | false => ""
   }
-  let sdlParts =
-    [typesSdl, queriesSdl, mutationsSdl]->Array.filter(p => p->String.length > 0)
+  let sdlParts = [typesSdl, queriesSdl, mutationsSdl]->Array.filter(p => p->String.length > 0)
   let sdlPreview = sdlParts->Array.join("\n\n")
   {types: parts.types, mutations: parts.mutations, queries: parts.queries, sdlPreview}
 }