@effect-app/infra 2.16.6 → 2.16.8

package/examples/query.ts

@@ -1,7 +1,8 @@
-import { Effect, Layer, ManagedRuntime, S } from "effect-app"
+import { Effect, Layer, ManagedRuntime, S, Schema } from "effect-app"
 import { makeRepo } from "../src/Model.js"
-import { and, one, or, order, page, project, where } from "../src/Model/query.js"
+import { and, make, one, or, order, page, project, QueryWhere, where } from "../src/Model/query.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
+import { expectTypeOf } from "@effect/vitest"
 
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
@@ -51,7 +52,8 @@ const items = [
 class SomethingRepo extends Effect.Service<SomethingRepo>()("SomethingRepo", {
   effect: Effect.gen(function*() {
     return yield* makeRepo("Union", Union, {})
-  })
+  }),
+  dependencies: [MemoryStoreLive]
 }) {
   static readonly Test = Layer
     .effect(
@@ -96,3 +98,33 @@ const program = Effect.gen(function*() {
 
 const rt = ManagedRuntime.make(SomethingRepo.Test)
 rt.runFork(program)
+
+const test1 = make<Union.Encoded>().pipe(
+  where("union._tag", "string"),
+)
+
+expectTypeOf(test1).toEqualTypeOf<QueryWhere<Union.Encoded, {
+    readonly _tag: "Something";
+    readonly id: string;
+    readonly displayName: string;
+    readonly n: string;
+    readonly union: {
+        readonly _tag: "string";
+        readonly value: string;
+    };
+}>>()
+
+const testneq1 = make<Union.Encoded>().pipe(
+  where("union._tag", "neq", "string"),
+)
+
+expectTypeOf(testneq1).toEqualTypeOf<QueryWhere<Union.Encoded, {
+    readonly _tag: "Something";
+    readonly id: string;
+    readonly displayName: string;
+    readonly n: string;
+    readonly union: {
+        readonly _tag: "number";
+        readonly value: number;
+    };
+}>>()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.16.6",
+  "version": "2.16.8",
   "license": "MIT",
   "type": "module",
   "dependencies": {

package/src/Model/Repository/service.ts

@@ -2,7 +2,7 @@
 import type { Effect, Option, PubSub, S } from "effect-app"
 import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
 import type { NonNegativeInt } from "effect-app/Schema/numbers"
-import type { FieldValues } from "../filter/types.js"
+import type { FieldValues, ResolveFirstLevel } from "../filter/types.js"
 import type { QAll, Query, QueryProjection } from "../query.js"
 import type { Mapped } from "./legacy.js"
 
@@ -42,7 +42,7 @@ export interface Repository<
     >(
       q: (
         initial: Query<Encoded>
-      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      ) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -61,7 +61,7 @@ export interface Repository<
       ) => $A,
       q2: (
         _: $A
-      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      ) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -82,7 +82,7 @@ export interface Repository<
       q2: (_: $A) => $B,
       q3: (
         _: $B
-      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      ) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -105,7 +105,7 @@ export interface Repository<
       q3: (_: $B) => $C,
       q4: (
         _: $C
-      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      ) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -130,7 +130,7 @@ export interface Repository<
       q4: (_: $C) => $D,
       q5: (
         _: $D
-      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      ) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -155,7 +155,7 @@ export interface Repository<
       q3: (_: $B) => $C,
       q4: (_: $C) => $D,
       q5: (_: $D) => $E,
-      q6: (_: $E) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      q6: (_: $E) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -182,7 +182,7 @@ export interface Repository<
       q4: (_: $C) => $D,
       q5: (_: $D) => $E,
       q6: (_: $E) => $F,
-      q7: (_: $F) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      q7: (_: $F) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -211,7 +211,7 @@ export interface Repository<
       q5: (_: $D) => $E,
       q6: (_: $E) => $F,
       q7: (_: $F) => $G,
-      q8: (_: $G) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      q8: (_: $G) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -242,7 +242,7 @@ export interface Repository<
       q6: (_: $E) => $F,
       q7: (_: $F) => $G,
       q8: (_: $G) => $H,
-      q9: (_: $H) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      q9: (_: $H) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -275,7 +275,7 @@ export interface Repository<
       q7: (_: $F) => $G,
       q8: (_: $G) => $H,
       q9: (_: $H) => $I,
-      q10: (_: $I) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
+      q10: (_: $I) => QueryProjection<From extends Encoded ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
@@ -510,7 +510,27 @@ export interface Repository<
   readonly mapped: Mapped<Encoded>
 }
 
-export type RefineTHelper<T, EncodedRefined> = EncodedRefined extends { _tag: any }
-  ? T extends { _tag: any } ? Extract<T, { _tag: EncodedRefined["_tag"] }>
+type NullableRefined<T, EncodedRefined> = {
+  // EncodedRefined may be a union, so if you just keyof you'll get just common keys
+  // p.s. NullableRefined is homomorphic in T so it distributes itself over T
+  [k in keyof T]: [null] extends [T[k]] ? [null] extends Extract<EncodedRefined, { [j in k]: any }>[k] ? T[k]
+    : Exclude<T[k], null>
+    : T[k]
+}
+
+type ExtractTagged<T, EncodedRefined> = EncodedRefined extends { _tag: string }
+  ? T extends { _tag: string } ? Extract<T, { _tag: EncodedRefined["_tag"] }>
+  : T
+  : T
+
+type ExtractIded<T, EncodedRefined> = EncodedRefined extends { id: string }
+  ? T extends { id: string } ? Extract<T, { id: EncodedRefined["id"] }>
   : T
   : T
+
+export type RefineTHelper<T, EncodedRefined> = ResolveFirstLevel<
+  NullableRefined<
+    ExtractIded<ExtractTagged<T, EncodedRefined>, EncodedRefined>,
+    EncodedRefined
+  >
+>

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

@@ -1,5 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expectTypeOf } from "@effect/vitest"
 import type { FieldValues } from "../fields.js"
-import type { BrowserNativeObject, Primitive } from "../utils.js"
+import type { BrowserNativeObject, Equals, IsLiteral, IsNever, Primitive } from "../utils.js"
 
 import type { ArrayKey, IsTuple, TupleKeys } from "./common.js"
 
@@ -33,39 +35,6 @@ export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true
  */
 export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
 
-/**
- * Helper type for recursively constructing paths through a type.
- * See {@link ArrayPath}
- */
-type ArrayPathImpl<K extends string | number, V> = V extends
-  | Primitive
-  | BrowserNativeObject ? never
-  : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? never
-    : `${K}` | `${K}.${ArrayPath<V>}`
-  : `${K}.${ArrayPath<V>}`
-
-/**
- * Type which eagerly collects all paths through a type which point to an array
- * type.
- * @typeParam T - type which should be introspected
- * @example
- * ```
- * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
- * ```
- */
-export type ArrayPath<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-      [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K]>
-    }[TupleKeys<T>]
-  : ArrayPathImpl<ArrayKey, V>
-  : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K]>
-  }[keyof T]
-
-/**
- * See {@link ArrayPath}
- */
-export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>
-
 /**
  * Type to evaluate the type which the given path points to.
  * @typeParam T - deeply nested type which is indexed by the path
@@ -76,17 +45,28 @@ export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldV
  * PathValue<[number, string], '1'> = string
  * ```
  */
-export type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any
-  ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R>
-      : never
-    : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>>
-      : never
-    : never
-  : P extends keyof T ? T[P]
-  : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V
+/* dprint-ignore-start */
+export type PathValue<T, P extends Path<T>> =
+  T extends any
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? PathValue<T[K], R>
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? PathValue<V, R & Path<V>>
+            : never
+          : never
+      : P extends keyof T
+        ? T[P]
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? V
+            : never
+          : never
     : never
-  : never
-  : never
+/* dprint-ignore-end */
 
 /**
  * See {@link PathValue}
@@ -96,13 +76,165 @@ export type FieldPathValue<
   TFieldPath extends FieldPath<TFieldValues>
 > = PathValue<TFieldValues, TFieldPath>
 
-/**
- * See {@link PathValue}
- */
-export type FieldArrayPathValue<
+/* dprint-ignore-start */
+export type SetPathValue<T, P extends Path<T>, X> =
+  T extends any
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? { [_ in keyof T]: _ extends K ? SetPathValue<T[K], R, X> : T[_] }
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? { [_ in keyof T]: SetPathValue<V, R & Path<V>, X> }
+            : never
+          : never
+      : P extends keyof T
+        ? { [_ in keyof T]: _ extends P ? X : T[_] }
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<any>
+            ? { [_ in keyof T]: X }
+            : never
+          : never
+    : never
+/* dprint-ignore-end */
+
+export type SetFieldPathValue<
   TFieldValues extends FieldValues,
-  TFieldArrayPath extends FieldArrayPath<TFieldValues>
-> = PathValue<TFieldValues, TFieldArrayPath>
+  TFieldPath extends FieldPath<TFieldValues>,
+  X
+> = SetPathValue<TFieldValues, TFieldPath, X>
+
+/* dprint-ignore-start */
+export type RefinePathValue<T, P extends Path<T>, X extends string | number | boolean | null | bigint, Exclde extends boolean = false> =
+  T extends any
+    // recursive cases
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? { [_ in keyof T]: _ extends K ? RefinePathValue<T[K], R, X, Exclde> : T[_] }
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? { [_ in keyof T]: RefinePathValue<V, R & Path<V>, X, Exclde> }
+            : never
+          : never
+      // base cases
+      : P extends keyof T
+        ? X extends T[P]
+          ? ({ [_ in keyof T]: _ extends P
+              ? Equals<
+                  Exclde,
+                  true,
+                  Exclude<T[_], X>,
+                  IsLiteral<T[_], X, Equals<X, null, null, NonNullable<T[_]>>>
+                >
+              : T[_]
+            }) extends infer $T
+              ? Equals<IsNever<$T[P & keyof $T]>, true, never, $T>
+              : never
+          : Equals<Exclde, true, T, never>
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? X extends V
+              ? { [_ in keyof T]: Equals<
+                  Exclde,
+                  true,
+                  Exclude<T[_], X>,
+                  IsLiteral<T[_], X, Equals<X, null, null, NonNullable<T[_]>>>
+                > }
+              : never
+            : never
+          : never
+    : never
+/* dprint-ignore-end */
+
+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>
+
+export namespace RefinePathValueTests {
+  type test1 = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1">
+  expectTypeOf<test1>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
+
+  type test2 = RefineFieldPathValue<{ b: "tag1"; v1: string } | { b: "tag2"; v2: number }, "b", "tag1">
+  expectTypeOf<test2>().toEqualTypeOf<{ b: "tag1"; v1: string }>()
+
+  type test3 = RefineFieldPathValue<{ b: "tag1" | "tag2" }, "b", "tag1">
+  expectTypeOf<test3>().toEqualTypeOf<{ b: "tag1" }>()
+
+  type test4 = RefineFieldPathValue<{ b: ("tag1" | "tag2")[] }, `b.${number}`, "tag1">
+  expectTypeOf<test4>().toEqualTypeOf<{ b: "tag1"[] }>()
+
+  type test5 = RefineFieldPathValue<{ b: "tag1"; v1: unknown } | { b: "tag2"; v2: unknown }, "b", "tag1">
+  expectTypeOf<test5>().toEqualTypeOf<{ b: "tag1"; v1: unknown }>()
+
+  type test6 = RefineFieldPathValue<
+    { a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } } | { something: "else " },
+    "a.b",
+    "tag2"
+  >
+  expectTypeOf<test6>().toEqualTypeOf<{ a: { b: "tag2"; v2: number } }>()
+
+  type test7 = RefineFieldPathValue<{ b: string | null }, "b", "tag1">
+  expectTypeOf<test7>().toEqualTypeOf<{ b: string }>()
+
+  type test8 = RefineFieldPathValue<{ b: string | null }, "b", null>
+  expectTypeOf<test8>().toEqualTypeOf<{ b: null }>()
+
+  type test1E = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1", true>
+  expectTypeOf<test1E>().toEqualTypeOf<{ a: { b: "tag2"; v2: number } }>()
+
+  type test2E = RefineFieldPathValue<{ b: "tag1"; v1: string } | { b: "tag2"; v2: number }, "b", "tag2", true>
+  expectTypeOf<test2E>().toEqualTypeOf<{ b: "tag1"; v1: string }>()
+
+  type test3E = RefineFieldPathValue<{ b: "tag1" | "tag2" | null }, "b", null, true>
+  expectTypeOf<test3E>().toEqualTypeOf<{ b: "tag1" | "tag2" }>()
+
+  type test4E = RefineFieldPathValue<{ b: ("tag1" | "tag2")[] }, `b.${number}`, "tag1", true>
+  expectTypeOf<test4E>().toEqualTypeOf<{ b: "tag2"[] }>()
+
+  type test5E = RefineFieldPathValue<{ b: "tag1"; v1: unknown } | { b: "tag2"; v2: unknown }, "b", "tag1", true>
+  expectTypeOf<test5E>().toEqualTypeOf<{ b: "tag2"; v2: unknown }>()
+
+  type test6E = RefineFieldPathValue<
+    { a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } } | { something: "else " },
+    "a.b",
+    "tag2",
+    true
+  >
+  expectTypeOf<test6E>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
+}
+
+export namespace SetFieldPathValueTests {
+  type test1 = SetFieldPathValue<{ foo: { bar: string[] } }, `foo.bar`, boolean>
+  expectTypeOf<test1>().toEqualTypeOf<{ foo: { bar: boolean } }>()
+
+  type test1a = SetFieldPathValue<{ foo: { bar: string[]; baz: 12 } }, `foo.bar`, boolean>
+  expectTypeOf<test1a>().toEqualTypeOf<{ foo: { bar: boolean; baz: 12 } }>()
+
+  type test2 = SetFieldPathValue<{ foo: { bar: string[] } }, `foo.bar.${number}`, boolean>
+  expectTypeOf<test2>().toEqualTypeOf<{ foo: { bar: boolean[] } }>()
+
+  type test2a = SetFieldPathValue<{ foo: { bar: readonly string[]; baz: 3 }; ban: 123 }, `foo.bar.${number}`, boolean>
+  expectTypeOf<test2a>().toEqualTypeOf<{ foo: { bar: readonly boolean[]; baz: 3 }; ban: 123 }>()
+
+  type test2b = SetFieldPathValue<
+    { foo: { bar: readonly { a: 1; b: 2 }[]; baz: 3 }; ban: 123 },
+    `foo.bar.${number}.b`,
+    "b"
+  >
+  expectTypeOf<test2b>().toEqualTypeOf<{ foo: { bar: readonly { a: 1; b: "b" }[]; baz: 3 }; ban: 123 }>()
+
+  type test3 = SetFieldPathValue<{ foo: ["a", "b"] }, `foo.0`, boolean>
+  expectTypeOf<test3>().toEqualTypeOf<{ foo: [boolean, "b"] }>()
+
+  type test3a = SetFieldPathValue<{ foo: [{ a: 123 }, "b"] }, `foo.0.a`, boolean>
+  expectTypeOf<test3a>().toEqualTypeOf<{ foo: [{ a: boolean }, "b"] }>()
+}
 
 /**
  * Type to evaluate the type which the given paths point to.

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

@@ -1,14 +1,4 @@
 /** Re-export public API */
 
 export type { PathString } from "./common.js"
-export type {
-  ArrayPath,
-  FieldArrayPath,
-  FieldArrayPathValue,
-  FieldPath,
-  FieldPathByValue,
-  FieldPathValue,
-  FieldPathValues,
-  Path,
-  PathValue
-} from "./eager.js"
+export type { FieldPath, FieldPathByValue, FieldPathValue, FieldPathValues, Path, PathValue } from "./eager.js"

package/src/Model/filter/types/utils.ts

@@ -104,3 +104,25 @@ export type Merge<A, B> = {
     : K extends keyof B ? B[K]
     : never
 }
+
+export type Resolve<T> =
+  & {
+    [K in keyof T]: Resolve<T[K]>
+  }
+  & unknown
+
+export type ResolveFirstLevel<T> =
+  & {
+    [K in keyof T]: T[K]
+  }
+  & unknown
+
+export type Cast<T, U> = T extends U ? T : U
+
+export type IsLiteral<T, True, False> = string extends T ? False : number extends T ? False : True
+
+export type Extends<T, U, True, False> = T extends U ? True : False
+
+export type IsEqual<T, U> = (<_>() => _ extends T ? 1 : 2) extends (<_>() => _ extends U ? 1 : 2) ? true : false
+
+export type Equals<T, U, True, False> = IsEqual<T, U> extends true ? True : False