@effect-app/infra 2.50.0 → 2.52.0

package/src/Model/filter/types/path/eager.ts

@@ -149,12 +149,17 @@ export type RefinePathValue<T, P extends Path<T>, X extends string | number | bo
     : never
 /* dprint-ignore-end */
 
+export type EraseNeverContainingUnionElements<T> = T extends any ? {
+  [K in keyof T]: IsNever<T[K]> extends true ? true : false
+} extends infer $NC ? true extends $NC[keyof $NC] ? never : T
+: never : never
+
 export type RefineFieldPathValue<
   TFieldValues extends FieldValues,
   TFieldPath extends FieldPath<TFieldValues>,
   X extends string | number | boolean | null | bigint,
   Exclde extends boolean = false
-> = RefinePathValue<TFieldValues, TFieldPath, X, Exclde>
+> = EraseNeverContainingUnionElements<RefinePathValue<TFieldValues, TFieldPath, X, Exclde>>
 
 export namespace RefinePathValueTests {
   type test1 = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1">
@@ -207,6 +212,22 @@ export namespace RefinePathValueTests {
     true
   >
   expectTypeOf<test6E>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
+
+  type test10 = RefineFieldPathValue<
+    | { nested: { a: string; _tag: "a" } | { b: number; _tag: "b" }; _tag: "ab" }
+    | { nested: { b: number; _tag: "b" } | { c: boolean; _tag: "c" }; _tag: "bc" },
+    "nested._tag",
+    "a",
+    false
+  >
+
+  expectTypeOf<test10>().toEqualTypeOf<{
+    nested: {
+      a: string
+      _tag: "a"
+    }
+    _tag: "ab"
+  }>()
 }
 
 export namespace SetFieldPathValueTests {

package/src/Model/query/dsl.ts

@@ -448,7 +448,7 @@ export type RefineWithLiteral<
   Exclde extends boolean = false
 > =
   // refine only if the value is a primitive
-  V extends string | number | boolean | null | bigint
+  [V] extends [string | number | boolean | null | bigint]
     ? RefineFieldPathValue<TFieldValues, TFieldName, V, Exclde>
     : TFieldValues
 /* dprint-ignore-end */

package/src/Store/index.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Redacted } from "effect-app"
+import { Effect, Layer, Redacted } from "effect-app"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
@@ -7,23 +7,27 @@ import { MemoryStoreLive } from "./Memory.js"
 import type { StorageConfig } from "./service.js"
 
 export function StoreMakerLayer(cfg: StorageConfig) {
-  const storageUrl = Redacted.value(cfg.url)
-  if (storageUrl.startsWith("mem://")) {
-    console.log("Using in memory store")
-    return MemoryStoreLive
-  }
-  if (storageUrl.startsWith("disk://")) {
-    const dir = storageUrl.replace("disk://", "")
-    console.log("Using disk store at " + dir)
-    return DiskStoreLayer(cfg, dir)
-  }
-  // if (storageUrl.startsWith("redis://")) {
-  //   console.log("Using Redis store")
-  //   return RedisStoreLayer(cfg)
-  // }
+  return Effect
+    .sync(() => {
+      const storageUrl = Redacted.value(cfg.url)
+      if (storageUrl.startsWith("mem://")) {
+        console.log("Using in memory store")
+        return MemoryStoreLive
+      }
+      if (storageUrl.startsWith("disk://")) {
+        const dir = storageUrl.replace("disk://", "")
+        console.log("Using disk store at " + dir)
+        return DiskStoreLayer(cfg, dir)
+      }
+      // if (storageUrl.startsWith("redis://")) {
+      //   console.log("Using Redis store")
+      //   return RedisStoreLayer(cfg)
+      // }
 
-  console.log("Using Cosmos DB store")
-  return CosmosStoreLayer(cfg)
+      console.log("Using Cosmos DB store")
+      return CosmosStoreLayer(cfg)
+    })
+    .pipe(Layer.unwrapEffect)
 }
 
 export * from "./service.js"

package/test/query.test.ts

@@ -928,3 +928,133 @@ it("distribution over union", () =>
       >()
     })
     .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine nested union", () =>
+  Effect
+    .gen(function*() {
+      class TestNested extends S.Class<TestNested>()({ id: S.String, nested: TestUnion }) {}
+
+      const repo = yield* makeRepo("test", TestNested, {})
+
+      const base = make<TestNested>()
+
+      const res_query = base.pipe(
+        where("nested._tag", Math.random() > 0.5 ? "animal" : "person")
+      )
+
+      expectTypeOf(res_query).toEqualTypeOf<
+        QueryWhere<TestNested, {
+          readonly id: string
+          readonly nested: {
+            readonly _tag: "person"
+            readonly id: string
+            readonly surname: string
+          } | {
+            readonly _tag: "animal"
+            readonly id: string
+            readonly surname: string
+          }
+        }, false>
+      >()
+
+      const res = yield* repo.query(
+        () => res_query
+      )
+
+      expectTypeOf(res).toEqualTypeOf<
+        readonly {
+          readonly id: string
+          readonly nested: Person | Animal
+        }[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine union with nested union", () =>
+  Effect
+    .gen(function*() {
+      class A extends S.TaggedClass<A>()("A", {
+        a: S.String
+      }) {}
+
+      class B extends S.TaggedClass<B>()("B", {
+        b: S.String
+      }) {}
+
+      class C extends S.TaggedClass<C>()("C", {
+        c: S.String
+      }) {}
+
+      class D extends S.TaggedClass<D>()("D", {
+        d: S.String
+      }) {}
+
+      class E extends S.TaggedClass<E>()("E", {
+        e: S.String
+      }) {}
+
+      class Container1 extends S.TaggedClass<Container1>()("Container1", {
+        id: S.String,
+        nested: S.Union(A, B, C)
+      }) {}
+
+      class Container2 extends S.TaggedClass<Container2>()("Container2", {
+        id: S.String,
+        nested: S.Union(B, C, D)
+      }) {}
+
+      class Container3 extends S.TaggedClass<Container3>()("Container3", {
+        id: S.String,
+        nested: S.Union(C, D, E)
+      }) {}
+
+      const Containers = S.Union(Container1, Container2, Container3)
+      type Containers = typeof Containers.Type
+
+      const repo = yield* makeRepo("containers", Containers, {})
+
+      const base = make<Containers>()
+
+      const res_query = base.pipe(
+        where("nested._tag", "D")
+      )
+
+      expectTypeOf(res_query).toEqualTypeOf<
+        QueryWhere<
+          Containers,
+          {
+            readonly id: string
+            readonly _tag: "Container2"
+            readonly nested: {
+              readonly _tag: "D"
+              readonly d: string
+            }
+          } | {
+            readonly id: string
+            readonly _tag: "Container3"
+            readonly nested: {
+              readonly _tag: "D"
+              readonly d: string
+            }
+          },
+          false
+        >
+      >()
+
+      const res = yield* repo.query(
+        () => res_query
+      )
+
+      expectTypeOf(res).toEqualTypeOf<
+        readonly ({
+          readonly _tag: "Container2"
+          readonly id: string
+          readonly nested: D
+        } | {
+          readonly _tag: "Container3"
+          readonly id: string
+          readonly nested: D
+        })[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))