@effect-app/infra 4.0.0-beta.305 → 4.0.0-beta.307

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @effect-app/infra
 
+## 4.0.0-beta.307
+
+### Patch Changes
+
+- 40585ca: Keep tag-aware `ProjectableFromDomain` for `projectComputed` only; restore loose key-presence guard for `project()` so view DTOs with reshaped fields keep typechecking.
+- ad0ede6: Keep tag-aware `ProjectableGuard` on both `project()` and `projectComputed` (no loose key-only paper-over).
+
+  Hardening:
+
+  - single-literal tags allow dual same-tag domain variants (KeysOfUnion of matched members)
+  - multi-tag / string tags still require keys on every matched member
+  - optional projection/domain keys checked by key presence only (not optional-assignability)
+
+  Call sites must project domain-owned fields per tagged state.
+
+- Updated dependencies [40585ca]
+- Updated dependencies [ad0ede6]
+  - effect-app@4.0.0-beta.307
+
+## 4.0.0-beta.306
+
+### Patch Changes
+
+- 0fe925d: Tag-aware `ProjectableFromDomain` for `projectComputed`: projection Encoded fields must exist on the matching domain tagged state (or be computed). Prevents Overview.List SchemaErrors when cancel states omit workflow lock fields like `activeRequest`.
+- Updated dependencies [0fe925d]
+  - effect-app@4.0.0-beta.306
+
 ## 4.0.0-beta.305
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "4.0.0-beta.305",
+  "version": "4.0.0-beta.307",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -15,7 +15,7 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "8.4.0",
     "query-string": "^9.4.0",
-    "effect-app": "4.0.0-beta.305"
+    "effect-app": "4.0.0-beta.307"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.9.3",

package/test/query.test.ts

@@ -4,7 +4,7 @@
 import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
-import { and, computed, count, expr, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "effect-app/Model/query"
+import { and, computed, count, expr, make, one, or, order, page, project, type ProjectableFromDomain, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "effect-app/Model/query"
 import { makeRepo } from "effect-app/Model/Repository"
 import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as Option from "effect-app/Option"
@@ -662,9 +662,11 @@ it("projectComputed constrains projection schema to encoded repo fields and comp
   )
 
   make<Encoded>().pipe(
+    // @ts-expect-error missingField is neither an encoded repo field nor a computed projection
     projectComputed(S.Struct({ missingField: S.String }), computed({}))
   )
 
+  // Key presence only (not Encoded value types) — name: number is still projectable.
   make<Encoded>().pipe(
     projectComputed(
       S.Struct({ name: S.Number }),
@@ -672,6 +674,8 @@ it("projectComputed constrains projection schema to encoded repo fields and comp
     )
   )
 
+  // Computed field *value* types are not yet constrained against the expression
+  // result (only key presence). Keeping this as a documentation call site.
   make<Encoded>().pipe(
     projectComputed(
       S.Struct({ itemCount: S.String }),
@@ -737,12 +741,131 @@ it("projectComputed supports union projection schemas", () => {
   ])
 })
 
+/**
+ * MACS-SCANNER-API-KS class of bug: domain cancel omits pack/print ownership
+ * (`activeRequest`); a hand-built overview projection that still requires it on
+ * every branch must fail at the `projectComputed` call site, not in prod decode.
+ */
+it("projectComputed rejects state-owned fields required on the wrong tagged branch", () => {
+  const domain = S.Union([
+    S.Struct({
+      _tag: S.Literal("packing"),
+      id: S.String,
+      activeRequest: S.NullOr(S.String),
+      items: S.Array(S.Struct({ articleId: S.String }))
+    }),
+    S.Struct({
+      _tag: S.Literal("cancelled"),
+      id: S.String,
+      items: S.Array(S.Struct({ articleId: S.String }))
+    })
+  ])
+  type DomainEnc = S.Codec.Encoded<typeof domain>
+
+  // Good: activeRequest only on packing; cancel omits it; articleCount is computed.
+  make<DomainEnc>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("packing"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        }),
+        S.Struct({
+          _tag: S.Literal("cancelled"),
+          id: S.String,
+          articleCount: S.Number
+        })
+      ]),
+      computed({
+        articleCount: relation<DomainEnc>("items").count()
+      })
+    )
+  )
+
+  make<DomainEnc>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("packing"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        }),
+        S.Struct({
+          _tag: S.Literal("cancelled"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        })
+      ]),
+      // @ts-expect-error activeRequest is not on domain cancelled — cannot project it there
+      computed({
+        articleCount: relation<DomainEnc>("items").count()
+      })
+    )
+  )
+})
+
+it("ProjectableFromDomain distributes over tagged union Encoded", () => {
+  type DomainEnc =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null }
+    | { readonly _tag: "cancelled"; readonly id: string }
+
+  type Good =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null; readonly n: number }
+    | { readonly _tag: "cancelled"; readonly id: string; readonly n: number }
+
+  type Bad =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null }
+    | { readonly _tag: "cancelled"; readonly id: string; readonly activeRequest: string | null }
+
+  type GoodCheck = ProjectableFromDomain<Good, DomainEnc, "n">
+  type BadCheck = ProjectableFromDomain<Bad, DomainEnc>
+
+  const _good: GoodCheck = undefined as unknown
+  // @ts-expect-error cancelled branch requires activeRequest not present on domain cancelled
+  const _bad: BadCheck = undefined as unknown
+  void _good
+  void _bad
+})
+
+it("ProjectableFromDomain allows dual same-tag domain variants", () => {
+  // EasyLife packing/closed: two domain shapes share `_tag` with different fields.
+  type DomainEnc =
+    | { readonly _tag: "packing"; readonly id: string; readonly packages: readonly string[] }
+    | { readonly _tag: "packing"; readonly id: string; readonly units: readonly string[] }
+    | { readonly _tag: "initial"; readonly id: string }
+
+  type Good =
+    | { readonly _tag: "packing"; readonly id: string; readonly packages: readonly string[] }
+    | { readonly _tag: "packing"; readonly id: string; readonly units: readonly string[] }
+
+  // Flat multi-tag + state-only field must still fail (batchId not on initial).
+  type BadFlat = {
+    readonly _tag: "packing" | "initial"
+    readonly id: string
+    readonly packages: readonly string[]
+  }
+
+  type GoodCheck = ProjectableFromDomain<Good, DomainEnc>
+  type BadFlatCheck = ProjectableFromDomain<BadFlat, DomainEnc>
+
+  const _good: GoodCheck = undefined as unknown
+  // @ts-expect-error packages is not on domain initial; multi-tag flat intersection rejects it
+  const _badFlat: BadFlatCheck = undefined as unknown
+  void _good
+  void _badFlat
+})
+
 it("projection schema with computed fields fails without computed map", () => {
   const baseSchema = S.Struct({
     id: S.String,
     items: S.Array(S.Struct({ value: S.Number }))
   })
   const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    // @ts-expect-error missing computed keys are rejected; also not projectable from domain alone
     projectComputed(S.Struct({ pickedCount: S.NonNegativeInt }), computed({}))
   )
   expect(() => toFilter(query, baseSchema)).toThrowError("Missing computed projections for schema keys")