@reventlessdev/reventless-spec 3.0.0-alpha.132 → 3.0.0-alpha.134

package/src/semantic/UploadableFile.res

@@ -14,7 +14,6 @@ representation, no media-type restriction on what may be uploaded. See
     })
 ```
 */
-
 type t = string
 
 external unsafe: string => t = "%identity"

package/src/semantic/UploadableImage.res

@@ -31,7 +31,6 @@ does, and only because the store is derived from it.
     })
 ```
 */
-
 /** Transparent `string`, for `StorageRef.t`'s reason: the marker refines an
     existing field rather than replacing it, so nothing stored changes. */
 type t = string

package/src/semantic/Url.res

@@ -24,7 +24,6 @@ they actually hold and render correctly on their own.
     })
 ```
 */
-
 /** The address's representation. Transparent `string`; see `Email.t`. */
 type t = string
 
@@ -56,8 +55,9 @@ let fromString = (raw: string): result<t, string> =>
       Ok(value)
     } else {
       Error(
-        `a URL field takes an http:// or https:// address, got ${Semantic.showString(raw)}. ` ++
-        `Use Email or Phone for mailto:/tel:, and a storage ref for an uploaded object.`,
+        `a URL field takes an http:// or https:// address, got ${Semantic.showString(
+            raw,
+          )}. ` ++ `Use Email or Phone for mailto:/tel:, and a storage ref for an uploaded object.`,
       )
     }
   | exception _ =>

package/src/types/Authorization.res

@@ -18,6 +18,5 @@ let isAllowed = (rule: permission, identity: Identity.t): bool =>
   | DenyAll => false
   | AllowAnonymous => true
   | AllowAuthenticated => identity.userId !== "anonymous"
-  | AllowGroups(groups) =>
-    groups->Array.some(group => identity.groups->Array.includes(group))
+  | AllowGroups(groups) => groups->Array.some(group => identity.groups->Array.includes(group))
   }

package/src/types/Handler.res

@@ -27,4 +27,3 @@ Handler for a batch of events sharing the same aggregate ID.
 Used by read model projections and extension points.
 */
 type eventsHandler<'id, 'event> = ('id, array<Message.event'<'id, 'event>>) => promise<unit>
-

package/src/types/Identity.res

@@ -1,4 +1,3 @@
-
 /** Identity provider that authenticated the user. */
 @schema
 type provider = Cognito | InMemory | Custom(string)
@@ -25,8 +24,7 @@ let anonymous: t = {
   provider: InMemory,
 }
 
-let hasGroup = (identity: t, group: string): bool =>
-  identity.groups->Array.includes(group)
+let hasGroup = (identity: t, group: string): bool => identity.groups->Array.includes(group)
 
 let getClaim = (identity: t, key: string): option<string> =>
   switch identity.claims {

package/src/types/Lifecycle.res

@@ -6,10 +6,9 @@ consumer resolves it here rather than restating it. `Trail` is the one field a
 view declares to have each state it reaches recorded with the instant it was
 reached; the projection machinery fills it, not the domain.
 */
-
-// A wire enum: a union whose non-null members are all string constants. A
+let // A wire enum: a union whose non-null members are all string constants. A
 // tagged union's members are objects, so the same test excludes it.
-let isEnumSchema = (schema: S.t<unknown>): bool =>
+isEnumSchema = (schema: S.t<unknown>): bool =>
   switch schema {
   | AnyOf({anyOf}) =>
     let members = anyOf->Array.filter(v =>
@@ -80,8 +79,7 @@ module Trail = {
   let schema = (stateSchema: S.t<'state>): S.t<t<'state>> =>
     S.array(entrySchema(stateSchema))->Semantic.mark(~id=Semantic.Id.lifecycleTrail)
 
-  let isTrail = (schema: S.t<unknown>): bool =>
-    Semantic.has(schema, ~id=Semantic.Id.lifecycleTrail)
+  let isTrail = (schema: S.t<unknown>): bool => Semantic.has(schema, ~id=Semantic.Id.lifecycleTrail)
 
   /** The trail field declared on a state record, if it declares one. */
   let fieldName = (stateSchema: S.t<unknown>): option<string> =>
@@ -101,6 +99,9 @@ module Trail = {
     | _ => []
     }
     let entry = Dict.fromArray([("state", state), ("at", JSON.Encode.string(at))])
-    stateDict->Dict.set(field, entries->Array.concat([entry->JSON.Encode.object])->JSON.Encode.array)
+    stateDict->Dict.set(
+      field,
+      entries->Array.concat([entry->JSON.Encode.object])->JSON.Encode.array,
+    )
   }
 }

package/src/types/Message.res

@@ -1,4 +1,3 @@
-
 /** Identifies the service that produced or is addressed by a message. */
 @schema
 type service = string
@@ -179,7 +178,11 @@ type commandJson = {
 //
 // `scalarFills` is an out-parameter: the walker pushes `path := value` for each scalar it
 // invented.
-let fillMissingDefaults: (S.t<'a>, JSON.t, array<string>) => JSON.t = %raw(`function(schema, json, scalarFills){
+let fillMissingDefaults: (
+  S.t<'a>,
+  JSON.t,
+  array<string>,
+) => JSON.t = %raw(`function(schema, json, scalarFills){
   function isSchema(x){ return x && typeof x === "object" && typeof x.type === "string"; }
   function firstConst(anyOf){ var m=(anyOf||[]).find(function(s){return s.const!==undefined;}); return m ? m.const : undefined; }
   // Which object-typed member of an anyOf a plain (untagged) object value belongs to.
@@ -274,8 +277,7 @@ let parseJsonTolerant = (json, schema) =>
             ->Array.length
             ->Int.toString} missing scalar field(s): ${scalarFills->Array.join(
               ", ",
-            )}. A required scalar was added to a persisted type after this message was ` ++
-          `written; the value above is fabricated, not recovered. Prefer an optional field.`,
+            )}. A required scalar was added to a persisted type after this message was ` ++ `written; the value above is fabricated, not recovered. Prefer an optional field.`,
         )
       }
       value

package/src/types/OwnerScope.res

@@ -20,7 +20,6 @@ fields this module reads are typed non-optional and are, at runtime, sometimes
 absent. Every read here goes through a nullable cast for that reason; deleting
 one restores a silent failure rather than a type error.
 */
-
 /** Whether a JS value is a primitive string — `Cognito` and `InMemory` compile to
     bare strings while `Custom(_)` compiles to an object, so this is how a modelled
     provider is told from an unmodelled one that arrived as raw JSON. */
@@ -135,8 +134,7 @@ let classify = (identity: Identity.t, ~elevated: array<string>): t => {
     switch identity.userId->asNullableString->Nullable.toOption {
     | None => Unidentified("identity carries no userId")
     | Some("") => Unidentified("identity carries an empty userId")
-    | Some(userId) if userId == Identity.anonymous.userId =>
-      Unidentified("caller is anonymous")
+    | Some(userId) if userId == Identity.anonymous.userId => Unidentified("caller is anonymous")
     | Some(userId) =>
       let groups = identity.groups->asNullableArray->Nullable.toOption->Option.getOr([])
       groups->Array.some(g => elevated->Array.includes(g))

package/src/types/Projection.res

@@ -145,8 +145,15 @@ module Mapping = {
   module Make = (
     Source: Source,
     Target: Target,
-    MappingImpl: MappingImpl with type sourceEvent := Source.event and type targetState := Target.state,
-  ): (Mapping with type targetState = Target.state and type sourceEvent = Source.event and module SourceId = Source.Id) => {
+    MappingImpl: MappingImpl
+      with type sourceEvent := Source.event
+      and type targetState := Target.state,
+  ): (
+    Mapping
+      with type targetState = Target.state
+      and type sourceEvent = Source.event
+      and module SourceId = Source.Id
+  ) => {
     module SourceId = Source.Id
     @schema
     type sourceEvent = Source.event

package/src/types/StoredEvent.res

@@ -38,9 +38,7 @@ let toStoredEventSchema = (idSchema: S.t<'id>): S.t<storedEvent<'id>> =>
   })
 
 /** Decode a `storedEvent<'id>` from JSON. */
-let decode = (json, idSchema) =>
-  json->Util_Sury.fromJson(toStoredEventSchema(idSchema))
+let decode = (json, idSchema) => json->Util_Sury.fromJson(toStoredEventSchema(idSchema))
 
 /** Encode a `storedEvent<'id>` to JSON. */
-let encode = (stored, idSchema) =>
-  stored->Util_Sury.toJson(toStoredEventSchema(idSchema))
+let encode = (stored, idSchema) => stored->Util_Sury.toJson(toStoredEventSchema(idSchema))

package/src/types/Transition.res

@@ -69,9 +69,11 @@ let allowedStates = (transition: t<'state>): option<array<'state>> =>
   switch transition {
   | Undeclared
   | Unrestricted
-  | Creates(_) => None
+  | Creates(_) =>
+    None
   | Guards(states)
-  | Moves(states, _) => Some(states)
+  | Moves(states, _) =>
+    Some(states)
   }
 
 /** The state the command's handler writes, or `None` for one that moves nothing. */
@@ -79,9 +81,11 @@ let targetState = (transition: t<'state>): option<'state> =>
   switch transition {
   | Undeclared
   | Unrestricted
-  | Guards(_) => None
+  | Guards(_) =>
+    None
   | Creates(state)
-  | Moves(_, state) => Some(state)
+  | Moves(_, state) =>
+    Some(state)
   }
 
 /** Whether the command is claimed legal in every state, as opposed to nothing

package/src/util/Util_Sury.res

@@ -11,10 +11,7 @@ let toJson: ('a, S.t<'a>) => JSON.t = (value, schema) =>
 
 // `~space` defaults to compact, matching the removed `reverseConvertToJsonStringOrThrow`.
 let toJsonString = (value: 'a, schema: S.t<'a>, ~space: int=0): string =>
-  value->S.decodeOrThrow(
-    ~from=schema,
-    ~to=space == 0 ? S.jsonString : S.jsonStringWithSpace(space),
-  )
+  value->S.decodeOrThrow(~from=schema, ~to=space == 0 ? S.jsonString : S.jsonStringWithSpace(space))
 
 let fromJson: (JSON.t, S.t<'a>) => 'a = (json, schema) => json->S.parseOrThrow(~to=schema)