@effect-app/infra 2.16.6 → 2.16.8

package/test/query.test.ts

@@ -36,9 +36,10 @@ const q = make<Something.Encoded>()
     ),
     order("displayName"),
     page({ take: 10 }),
+    // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
     project(
       S.transformToOrFail(
-        S.Struct({ id: S.StringId, displayName: S.String }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+        S.Struct(Struct.pick(Something.fields, "id", "displayName")),
         S.Struct(Struct.pick(Something.fields, "id", "displayName")),
         (_) => Effect.andThen(SomeService, _)
       )
@@ -84,7 +85,12 @@ it("works", () => {
   const interpreted = toFilter(q)
   console.log("interpreted", inspect(interpreted, undefined, 25))
 
-  const processed = memFilter(interpreted)(items.map((_) => S.encodeSync(Something)(_)))
+  const processed = memFilter(interpreted)(items.map((_) =>
+    S.encodeUnknownSync(S.Struct({
+      ...Something.omit("displayName"),
+      displayName: S.Literal("Verona", "Riley")
+    }))(_)
+  ))
 
   expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
 })
@@ -114,7 +120,6 @@ it("works with repo", () =>
       yield* somethingRepo.saveAndPublish(items)
 
       const q1 = yield* somethingRepo.query(() => q)
-      // same as above, but with the `flow` helper
       const q2 = yield* somethingRepo
         .query(
           where("displayName", "Verona"),
@@ -124,9 +129,10 @@ it("works with repo", () =>
           ),
           order("displayName"),
           page({ take: 10 }),
+          // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
           project(
             S.transformToOrFail(
-              S.Struct({ displayName: S.String }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+              S.Struct(Struct.pick(Something.fields, "displayName")),
               S.Struct(Struct.pick(Something.fields, "displayName")),
               (_) => Effect.andThen(SomeService, _)
             )
@@ -156,10 +162,13 @@ it("collect", () =>
           .query(
             where("displayName", "Riley"), // TODO: work with To type translation, so Date?
             // one,
+            // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
             project(
               S.transformTo(
-                // TODO: sample case with narrowing down a union?
-                S.encodedSchema(S.Struct(Struct.pick(Something.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                S.encodedSchema(S.Struct({
+                  ...Struct.pick(Something.fields, "n"),
+                  displayName: S.String
+                })),
                 S.typeSchema(S.Option(S.String)),
                 (_) =>
                   _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
@@ -172,26 +181,39 @@ it("collect", () =>
       )
         .toEqual(["Riley-2020-01-01T00:00:00.000Z"])
 
-      expect(
-        yield* somethingRepo
-          .query(
-            where("union._tag", "string"),
-            one,
-            project(
-              S.transformTo(
-                // TODO: sample case with narrowing down a union?
-                S.encodedSchema(S.Struct(Struct.pick(Something.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-                S.typeSchema(S.Option(S.String)),
-                (_) =>
-                  _.union._tag === "string"
-                    ? Option.some(_.union.value)
-                    : Option.none()
-              ),
-              "collect"
-            )
-          )
+      const queryRes = make<Something.Encoded>().pipe(
+        where("union._tag", "string"),
+        one
       )
-        .toEqual("hi")
+
+      expectTypeOf(queryRes).toEqualTypeOf<
+        QueryEnd<{
+          readonly id: string
+          readonly displayName: string
+          readonly n: string
+          readonly union: {
+            readonly _tag: "string"
+            readonly value: string
+          }
+        }, "one">
+      >()
+
+      const fromRepo = yield* somethingRepo.query(
+        where("union._tag", "string"),
+        one,
+        project(
+          S.Struct({
+            union: S.Struct({
+              _tag: S.Literal("string"),
+              value: S.String
+            })
+          })
+        )
+      )
+      const value = fromRepo.union.value
+
+      expectTypeOf(value).toEqualTypeOf<string>()
+      expect(value).toEqual("hi")
     })
     .pipe(Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())), Effect.runPromise))
 
@@ -229,8 +251,11 @@ it(
     Effect
       .gen(function*() {
         const repo = yield* makeRepo("test", TestUnion, {})
-        const result = (yield* repo.query(where("id", "123"), and("_tag", "animal"))) satisfies readonly Animal[]
-        const result2 = (yield* repo.query(where("_tag", "animal"))) satisfies readonly Animal[]
+        const result = yield* repo.query(where("id", "123"), and("_tag", "animal"))
+        const result2 = yield* repo.query(where("_tag", "animal"))
+
+        expectTypeOf(result).toEqualTypeOf<readonly Animal[]>()
+        expectTypeOf(result2).toEqualTypeOf<readonly Animal[]>()
 
         expect(result).toEqual([])
         expect(result2).toEqual([])
@@ -263,19 +288,34 @@ it(
           d: S.Unknown
         }) {}
 
+        // const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
         type Union = AA | BB | CC | DD
 
         const query1 = make<Union>().pipe(
           where("id", "bla"),
           and("_tag", "AA")
         )
-        expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
+        expectTypeOf(query1).toEqualTypeOf<
+          QueryWhere<Union, AA>
+        >()
 
         const query2 = make<Union>().pipe(
           where("_tag", "AA")
         )
         expectTypeOf(query2).toEqualTypeOf<QueryWhere<Union, AA>>()
 
+        const query2a = make<Union>().pipe(
+          where("c", "something")
+        )
+        expectTypeOf(query2a).toEqualTypeOf<
+          QueryWhere<Union, {
+            readonly id: string
+            readonly _tag: "CC"
+            readonly c: {} // from unknown to {} because "something" means that it's not null or undefined
+          }>
+        >()
+
         const query3 = make<Union>().pipe(
           where("_tag", "AA"),
           or(
@@ -283,7 +323,12 @@ it(
             and("_tag", "BB")
           )
         )
-        expectTypeOf(query3).toEqualTypeOf<QueryWhere<Union, AA | BB>>()
+        expectTypeOf(query3).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | BB
+          >
+        >()
 
         const query3b = make<Union>().pipe(
           where("_tag", "AA"),
@@ -329,7 +374,12 @@ it(
             and("_tag", "neq", "BB")
           )
         )
-        expectTypeOf(query7).toEqualTypeOf<QueryWhere<Union, AA | CC | DD>>()
+        expectTypeOf(query7).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | CC | DD
+          >
+        >()
 
         const query8 = make<Union>().pipe(
           where("_tag", "neq", "AA"),
@@ -348,7 +398,12 @@ it(
             )
           )
         )
-        expectTypeOf(query9).toEqualTypeOf<QueryWhere<Union, AA | BB | CC>>()
+        expectTypeOf(query9).toEqualTypeOf<
+          QueryWhere<
+            Union,
+            AA | BB | CC
+          >
+        >()
 
         const query10 = make<Union>().pipe(
           where("id", "AA"),
@@ -361,7 +416,14 @@ it(
           page({ take: 10 }),
           count
         )
-        expectTypeOf(query10).toEqualTypeOf<QueryProjection<AA | BB, S.NonNegativeInt, never, "count">>()
+        expectTypeOf(query10).toEqualTypeOf<
+          QueryProjection<
+            AA | BB,
+            S.NonNegativeInt,
+            never,
+            "count"
+          >
+        >()
 
         const query11 = make<Union>().pipe(
           where("id", "AA"),
@@ -374,11 +436,16 @@ it(
           page({ take: 10 }),
           one
         )
-        expectTypeOf(query11).toEqualTypeOf<QueryEnd<AA | BB, "one">>()
+        expectTypeOf(query11).toEqualTypeOf<
+          QueryEnd<
+            AA | BB,
+            "one"
+          >
+        >()
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.runPromise)
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -408,14 +475,20 @@ it(
 
         type Union = AA | BB | CC | DD
 
+        const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
         const query1 = make<Union>().pipe(
           where("id", "AA")
         )
         expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
 
+        const res = yield* repo.query(() => query1)
+
+        expectTypeOf(res).toEqualTypeOf<readonly AA[]>()
+
         expect([]).toEqual([])
       })
-      .pipe(Effect.runPromise)
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -437,7 +510,16 @@ it(
           {}
         )
 
-        const result = yield* repo.query(where("id", "123"), project(schema))
+        const outputSchema = S.Struct({
+          id: S.Literal("123"),
+          createdAt: S
+            .optional(S.Date)
+            .pipe(
+              S.withDefaults({ constructor: () => new Date(), decoding: () => new Date() })
+            )
+        })
+
+        const result = yield* repo.query(where("id", "123"), project(outputSchema))
 
         expect(result).toEqual([])
       })
@@ -473,3 +555,270 @@ it(
       })
       .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
+
+it(
+  "remove null 1",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          literals: S.Union(S.Literal("a", "b", "c"), S.Null)
+        })
+
+        type Schema = typeof schema.Type
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {}
+        )
+
+        const expected = make<Schema>().pipe(
+          where("literals", "neq", null)
+        )
+        expectTypeOf(expected).toEqualTypeOf<
+          QueryWhere<Schema, {
+            readonly id: string
+            readonly literals: "a" | "b" | "c"
+          }>
+        >()
+
+        const result = yield* repo.query(
+          where("literals", "neq", null)
+        )
+
+        expectTypeOf(result).toEqualTypeOf<
+          readonly {
+            readonly id: string
+            readonly literals: "a" | "b" | "c"
+          }[]
+        >()
+
+        expect(result).toEqual([])
+      })
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)
+
+it(
+  "remove null 2",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          literals: S.Union(S.String, S.Null)
+        })
+
+        type Schema = typeof schema.Type
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {}
+        )
+
+        const expected = make<Schema>().pipe(
+          where("literals", "ciao")
+        )
+        expectTypeOf(expected).toEqualTypeOf<
+          QueryWhere<Schema, {
+            readonly id: string
+            readonly literals: string
+          }>
+        >()
+
+        const result = yield* repo.query(
+          where("literals", "neq", null)
+        )
+
+        expectTypeOf(result).toEqualTypeOf<
+          readonly {
+            readonly id: string
+            readonly literals: string
+          }[]
+        >()
+
+        expect(result).toEqual([])
+      })
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)
+
+it("remove null from one constituent of a tagged union", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.Literal("AA"),
+        a: S.String
+      }) {}
+
+      class BB extends S.Class<BB>()({
+        id: S.Literal("BB"),
+        b: S.NullOr(S.Number)
+      }) {}
+
+      type Union = AA | BB
+
+      const repo = yield* makeRepo("test", S.Union(AA, BB), {})
+
+      const query1 = make<Union>().pipe(
+        where("id", "AA"),
+        or(
+          where("b", "neq", null)
+        )
+      )
+
+      expectTypeOf(query1).toEqualTypeOf<
+        QueryWhere<
+          Union,
+          AA | {
+            readonly id: "BB"
+            readonly b: number
+          }
+        >
+      >()
+
+      const resQuer1 = yield* repo.query(() => query1)
+
+      expectTypeOf(resQuer1).toEqualTypeOf<
+        readonly ({
+          readonly id: "AA"
+          readonly a: string
+        } | {
+          readonly id: "BB"
+          readonly b: number
+        })[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine 3", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.Literal("AA"),
+        a: S.Unknown
+      }) {}
+
+      class BB extends S.Class<BB>()({
+        id: S.Literal("BB"),
+        b: S.Unknown
+      }) {}
+
+      class CC extends S.Class<CC>()({
+        id: S.Literal("CC"),
+        c: S.Unknown
+      }) {}
+
+      class DD extends S.Class<DD>()({
+        id: S.Literal("DD"),
+        d: S.Unknown
+      }) {}
+
+      type Union = AA | BB | CC | DD
+
+      const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+
+      const query1 = make<Union>().pipe(
+        where("id", "AA")
+      )
+
+      expectTypeOf(query1).toEqualTypeOf<QueryWhere<Union, AA>>()
+
+      const resQuer1 = yield* repo.query(where("id", "AA"))
+      expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("my test", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.Class<AA>()({
+        id: S.String,
+        as: S.Array(S.String)
+      }) {}
+
+      const repo = yield* makeRepo("test", AA, {})
+
+      const resQuer1 = yield* repo.query(
+        where("id", "in", ["id1", "id2"]),
+        and(`as.-1`, "startsWith", "a")
+      )
+      expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("refine inner without imposing a projection", () =>
+  Effect
+    .gen(function*() {
+      class AA extends S.TaggedClass<AA>()("AA", {
+        a: S.Unknown
+      }) {}
+
+      class BB extends S.TaggedClass<BB>()("BB", {
+        b: S.Unknown
+      }) {}
+
+      class Data extends S.Class<Data>()({
+        id: S.String,
+        union: S.Union(AA, BB)
+      }) {}
+
+      const repo = yield* makeRepo("data", Data, {})
+
+      const query1 = make<Data>().pipe(
+        where("union._tag", "AA"),
+        // I can refine the overall output by providing a proper projection
+        // that mimics the internal refinement of the encoding type
+        project(S.Struct({ union: AA }))
+      )
+      expectTypeOf(query1).toEqualTypeOf<
+        QueryProjection<
+          {
+            readonly id: string
+            readonly union: AA
+          },
+          {
+            readonly union: AA
+          },
+          never,
+          "many"
+        >
+      >()
+
+      const query2 = make<Data>().pipe(
+        where("union._tag", "AA"),
+        // But if I wanna the whole Data as output ignoring the inner refinement
+        // I wanna be able to do so
+        project(S.Struct(Data.pick("union")))
+      )
+
+      expectTypeOf(query2).toEqualTypeOf<
+        QueryProjection<
+          {
+            readonly id: string
+            readonly union: AA
+          },
+          {
+            readonly union: AA | BB
+          },
+          never,
+          "many"
+        >
+      >()
+
+      const resQuer1 = yield* repo.query(() => query1)
+      expectTypeOf(resQuer1).toEqualTypeOf<
+        readonly {
+          readonly union: AA
+        }[]
+      >()
+
+      const resQuer2 = yield* repo.query(() => query2)
+      expectTypeOf(resQuer2).toEqualTypeOf<
+        readonly {
+          readonly union: AA | BB
+        }[]
+      >()
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))