effect-app 4.0.0-beta.306 → 4.0.0-beta.308

package/src/Model/query/dsl.ts

@@ -58,10 +58,36 @@ type ExtractFieldValuesRefined<T> = T extends QueryTogether<any, infer TFieldVal
   ? TFieldValuesRefined
   : never
 type KeysOfUnion<T> = T extends T ? keyof T : never
-type LiteralValue<T> = T extends { readonly literal: infer L } ? L : T
+/** Peel Schema `tag`/`Literal` brands down to the underlying literal value. */
+type LiteralValue<T> = T extends { readonly literal: infer L } ? L
+  : T extends string | number | boolean | null | bigint ? T
+  // Schema.tag<"x"> / withConstructorDefault wrappers are object brands whose
+  // nominal shape is not a PropertyKey — fall back to never so callers treat
+  // them via UnwrapTag below.
+  : never
+// Last-resort: if T is a single object brand wrapping a string literal in its
+// structure, treat non-union object tags as single-literal for same-tag duals.
+type TagKey<T> = [LiteralValue<T>] extends [never] ? (
+    string extends T ? string
+      : [T] extends [PropertyKey] ? T
+      // object brand (e.g. tag<"packing">): treat as single opaque tag token
+      : T
+  )
+  : LiteralValue<T>
+// One-directional: domain tag may be a single literal that is a member of a
+// multi-tag projection (`"picking" extends "picking"|"picked"`). Bidirectional
+// equality would reject every multi-tag flat projection.
 type ExtractTagged<From, Tag> = From extends { readonly _tag: infer FromTag }
-  ? [LiteralValue<FromTag>] extends [LiteralValue<Tag>] ? From : never
+  ? [TagKey<FromTag>] extends [TagKey<Tag>] ? From : never
   : never
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never
+/**
+ * True when `Tag` is a single tag token (string literal or opaque brand like
+ * Schema.tag<"packing">), not a union of tags and not bare `string`.
+ */
+type IsSingleLiteralTag<Tag> = string extends Tag ? false
+  : [Tag] extends [UnionToIntersection<Tag>] ? true
+  : false
 /**
  * Domain shape that may supply stored fields for projection member `I`.
  *
@@ -83,37 +109,48 @@ type ProjectableSource<I, From> = I extends { readonly _tag: infer Tag } ? (
  *   field types may be narrowed by the projection).
  *
  * Uses `keyof Source` (not `KeysOfUnion` of the whole domain union) so a field
- * owned only by some tags cannot be required on every branch.
+ * owned only by some tags cannot be required on every branch — except for a
+ * single literal tag that maps to several domain variants (same `_tag`,
+ * different payloads), where `KeysOfUnion` allows each variant's keys.
  */
 /**
  * Keys the domain may supply for projection member `I`.
- * - Tagged `I`: only keys of the matching domain state.
+ * - Single-literal tagged `I` (`_tag: "packing"`): keys of *any* same-tag
+ *   domain variant (`KeysOfUnion`) — dual packing/closed shapes stay projectable.
+ * - Multi-tag / string-tagged `I` (`_tag: "a"|"b"` or `string`): keys of the
+ *   *intersection* of matched domain members (`keyof` of the source union) so
+ *   a flat multi-tag DTO cannot claim state-only fields (e.g. `batchId` on
+ *   `initial`).
  * - Untagged `I` (plain project DTOs): keys present on *any* domain member
  *   (`KeysOfUnion`), matching historical `project()` behavior.
  */
-type ProjectableDomainKeys<I, From> = I extends { readonly _tag: any } ? keyof ProjectableSource<I, From>
+type ProjectableDomainKeys<I, From> = I extends { readonly _tag: infer Tag } ? (
+    IsSingleLiteralTag<Tag> extends true ? KeysOfUnion<ProjectableSource<I, From>>
+      : keyof ProjectableSource<I, From>
+  )
   : KeysOfUnion<From>
 
-type ProjectableEncodedMember<
-  I,
-  From,
-  ExtraKeys extends PropertyKey = never
-> = I extends FieldValues ? {
-    // Keep `I[K]` (key presence only). Requiring domain field types would reject
-    // legitimate projections that narrow nested shapes (e.g. package views).
-    [K in keyof I]-?: K extends ExtraKeys ? I[K]
-      : K extends ProjectableDomainKeys<I, From> ? I[K]
-      : never
-  }
-  : never
+/**
+ * Keys on projection member `I` that are neither computed (`ExtraKeys`) nor
+ * present on the matching domain source. Key presence only — nested field
+ * types may be narrowed by the projection, and optional domain/projection
+ * keys must not fail via `{ k?: T } extends { k: T }` (the old `-?` mapped
+ * assignability check rejected legitimate optionalKey fields like closed.batchId).
+ */
+type UnprojectableKeys<I, From, ExtraKeys extends PropertyKey> = {
+  [K in keyof I]-?: K extends ExtraKeys ? never
+    : K extends ProjectableDomainKeys<I, From> ? never
+    : K
+}[keyof I]
 
 /**
  * Distribute over tagged-union projection Encoded types. A non-distributive
- * `[I] extends [...]` check against a union only sees `keyof (A|B)` (key
- * intersection) and misses branch-only fields like cancel-only omissions.
+ * check against a union only sees `keyof (A|B)` (key intersection) and misses
+ * branch-only fields like cancel-only omissions.
  */
-type IsProjectableMember<I, From, ExtraKeys extends PropertyKey> = [I] extends
-  [ProjectableEncodedMember<I, From, ExtraKeys>] ? true : false
+type IsProjectableMember<I, From, ExtraKeys extends PropertyKey> = [I] extends [FieldValues]
+  ? ([UnprojectableKeys<I, From, ExtraKeys>] extends [never] ? true : false)
+  : false
 
 /**
  * `unknown` when every member of projection Encoded `I` is projectable from
@@ -670,7 +707,7 @@ export const relation = <
   expr: {
     field: (field: FieldPath<RelationElement<TFieldValues, P>>): ComputedProjectionMathExpression => ({
       _tag: "field",
-      field: field as string
+      field
     }),
     mul: (
       left: ComputedProjectionMathExpression,
@@ -679,33 +716,33 @@ export const relation = <
   },
   length: (): ComputedProjectionExpression<number> => ({
     _tag: "relation-length",
-    path: path as string
+    path
   }),
   count: (operation?: ComputedProjectionOperation): ComputedProjectionExpression<number> =>
     operation
       ? {
         _tag: "relation-count",
-        path: path as string,
+        path,
         operation
       }
       : {
         _tag: "relation-count",
-        path: path as string
+        path
       },
   any: (operation?: ComputedProjectionOperation): ComputedProjectionExpression<boolean> =>
     operation
       ? {
         _tag: "relation-any",
-        path: path as string,
+        path,
         operation
       }
       : {
         _tag: "relation-any",
-        path: path as string
+        path
       },
   every: (operation: ComputedProjectionOperation): ComputedProjectionExpression<boolean> => ({
     _tag: "relation-every",
-    path: path as string,
+    path,
     operation
   }),
   distinctCount: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -715,14 +752,14 @@ export const relation = <
     operation
       ? {
         _tag: "relation-distinct-count",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         operation
       }
       : {
         _tag: "relation-distinct-count",
-        path: path as string,
-        field: field as string
+        path,
+        field
       },
   sum: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
     field: F,
@@ -731,14 +768,14 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         operation
       }
       : {
         _tag: "relation-sum",
-        path: path as string,
-        field: field as string
+        path,
+        field
       },
   sumExpr: (
     expression: ComputedProjectionMathExpression,
@@ -747,13 +784,13 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr",
-        path: path as string,
+        path,
         expression,
         operation
       }
       : {
         _tag: "relation-sum-expr",
-        path: path as string,
+        path,
         expression
       },
   sumExprBy: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -766,16 +803,16 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr-by",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         operation
       }
       : {
         _tag: "relation-sum-expr-by",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string
+        unit: options.unit
       },
   sumExprNormalized: (
     expression: ComputedProjectionMathExpression,
@@ -789,18 +826,18 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr-normalized",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         toBase: options.toBase,
         factors: options.factors,
         operation
       }
       : {
         _tag: "relation-sum-expr-normalized",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         toBase: options.toBase,
         factors: options.factors
       },
@@ -811,15 +848,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: false,
         operation
       }
       : {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: false
       },
   collectDistinct: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -829,15 +866,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: true,
         operation
       }
       : {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: true
       },
   collectFields: <const F extends readonly FieldPath<RelationElement<TFieldValues, P>>[]>(
@@ -849,15 +886,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: false,
         operation
       }
       : {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: false
       },
   collectDistinctFields: <const F extends readonly FieldPath<RelationElement<TFieldValues, P>>[]>(
@@ -869,15 +906,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: true,
         operation
       }
       : {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: true
       }
 })
@@ -893,7 +930,7 @@ export const relation = <
 export const expr = {
   field: <T extends FieldValues = FieldValues>(
     field: FieldPath<T>
-  ): ComputedProjectionMathExpression => ({ _tag: "field", field: field as string }),
+  ): ComputedProjectionMathExpression => ({ _tag: "field", field }),
   mul: (
     left: ComputedProjectionMathExpression,
     right: ComputedProjectionMathExpression
@@ -1022,7 +1059,7 @@ export const projectComputed: {
   const computedProjection = typeof mapOrBuild === "function"
     ? mapOrBuild(makeComputedHelpers())
     : mapOrBuild
-  return new Project({ current, schema, mode, computed: computedProjection } as any)
+  return new Project({ current, schema, mode, computed: computedProjection })
 }
 
 /**
@@ -1040,12 +1077,12 @@ export interface AggBuilder<TFieldValues extends FieldValues> {
 }
 
 const makeAggBuilder = <TFieldValues extends FieldValues>(): AggBuilder<TFieldValues> => ({
-  field: (path) => ({ _tag: "agg-field", path: path as string }),
+  field: (path) => ({ _tag: "agg-field", path }),
   count: () => ({ _tag: "agg-count" }),
   countWhen: (operation) => ({ _tag: "agg-count-when", operation }),
-  sum: (field) => ({ _tag: "agg-sum", field: field as string }),
-  min: (field) => ({ _tag: "agg-min", field: field as string }),
-  max: (field) => ({ _tag: "agg-max", field: field as string })
+  sum: (field) => ({ _tag: "agg-sum", field }),
+  min: (field) => ({ _tag: "agg-min", field }),
+  max: (field) => ({ _tag: "agg-max", field })
 })
 
 /**

package/src/Model/query/new-kid-interpreter.ts

@@ -316,17 +316,17 @@ const interpret = <
                 case "relation-count":
                 case "relation-any":
                 case "relation-every":
-                  return [key, { _tag: e._tag, path: e.path, filter } as ComputedProjectionIrExpression]
+                  return [key, { _tag: e._tag, path: e.path, filter }]
                 case "relation-distinct-count":
                 case "relation-sum":
                   return [
                     key,
-                    { _tag: e._tag, path: e.path, field: e.field, filter } as ComputedProjectionIrExpression
+                    { _tag: e._tag, path: e.path, field: e.field, filter }
                   ]
                 case "relation-sum-expr":
                   return [
                     key,
-                    { _tag: e._tag, path: e.path, expression: e.expression, filter } as ComputedProjectionIrExpression
+                    { _tag: e._tag, path: e.path, expression: e.expression, filter }
                   ]
                 case "relation-sum-expr-by":
                   return [
@@ -337,7 +337,7 @@ const interpret = <
                       expression: e.expression,
                       unit: e.unit,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-sum-expr-normalized":
                   return [
@@ -350,7 +350,7 @@ const interpret = <
                       toBase: e.toBase,
                       factors: e.factors,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-collect":
                   return [
@@ -361,7 +361,7 @@ const interpret = <
                       field: e.field,
                       distinct: e.distinct,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-collect-fields":
                   return [
@@ -372,10 +372,10 @@ const interpret = <
                       fields: e.fields,
                       distinct: e.distinct,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-length":
-                  return [key, { _tag: e._tag, path: e.path } as ComputedProjectionIrExpression]
+                  return [key, { _tag: e._tag, path: e.path }]
               }
             })
           )

package/src/ids.ts

@@ -28,7 +28,7 @@ export const RequestId = extendM(
     function make(input: string, options?: S.MakeOptions): NonEmptyString255
     function make(input?: string, options?: S.MakeOptions): NonEmptyString255 {
       const id = input === undefined ? StringId.make() : StringId.make(input, options)
-      return id as NonEmptyString255
+      return id
     }
     return ({
       make,

package/tsconfig.json

@@ -14,7 +14,12 @@
     "isolatedModules": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "plugins": [],
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        "diagnostics": false
+      }
+    ],
     "module": "Node16",
     "lib": [
       "ES2023"