@effect-app/infra 0.7.0

package/_src/lib/filter/types/path/eager.ts

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { FieldValues } from "../fields.js"
+import type { BrowserNativeObject, Primitive } from "../utils.js"
+
+import type { ArrayKey, IsTuple, TupleKeys } from "./common.js"
+
+/**
+ * Helper type for recursively constructing paths through a type.
+ * See {@link Path}
+ */
+type PathImpl<K extends string | number, V> = V extends
+  | Primitive
+  | BrowserNativeObject ? `${K}`
+  : `${K}` | `${K}.${Path<V>}`
+
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+  [K in TupleKeys<T>]-?: PathImpl<K & string, T[K]>
+}[TupleKeys<T>]
+: PathImpl<ArrayKey, V>
+  : {
+    [K in keyof T]-?: PathImpl<K & string, T[K]>
+  }[keyof T]
+
+/**
+ * See {@link Path}
+ */
+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
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * 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
+  : never
+  : never
+  : never
+
+/**
+ * See {@link PathValue}
+ */
+export type FieldPathValue<
+  TFieldValues extends FieldValues,
+  TFieldPath extends FieldPath<TFieldValues>
+> = PathValue<TFieldValues, TFieldPath>
+
+/**
+ * See {@link PathValue}
+ */
+export type FieldArrayPathValue<
+  TFieldValues extends FieldValues,
+  TFieldArrayPath extends FieldArrayPath<TFieldValues>
+> = PathValue<TFieldValues, TFieldArrayPath>
+
+/**
+ * Type to evaluate the type which the given paths point to.
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TPath        - paths into the deeply nested field values
+ * @example
+ * ```
+ * FieldPathValues<{foo: {bar: string}}, ['foo', 'foo.bar']>
+ *   = [{bar: string}, string]
+ * ```
+ */
+export type FieldPathValues<
+  TFieldValues extends FieldValues,
+  TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]
+> =
+  & {}
+  & {
+    [K in keyof TPath]: FieldPathValue<
+      TFieldValues,
+      TPath[K] & FieldPath<TFieldValues>
+    >
+  }
+
+/**
+ * Type which eagerly collects all paths through a fieldType that matches a give type
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TValue       - the value you want to match into each type
+ * @example
+ * ```typescript
+ * FieldPathByValue<{foo: {bar: number}, baz: number, bar: string}, number>
+ *   = 'foo.bar' | 'baz'
+ * ```
+ */
+export type FieldPathByValue<TFieldValues extends FieldValues, TValue> = {
+  [Key in FieldPath<TFieldValues>]: FieldPathValue<
+    TFieldValues,
+    Key
+  > extends TValue ? Key
+    : never
+}[FieldPath<TFieldValues>]

package/_src/lib/filter/types/path/index.ts

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

package/_src/lib/filter/types/utils.ts

@@ -0,0 +1,106 @@
+declare const $NestedValue: unique symbol
+
+/**
+ * @deprecated to be removed in the next major version
+ */
+export type NestedValue<TValue extends object = object> = {
+  [$NestedValue]: never
+} & TValue
+
+/**
+ * @deprecated to be removed in the next major version
+ */
+export type UnpackNestedValue<T> = T extends NestedValue<infer U> ? U
+  : T extends Date | FileList | File | Blob ? T
+  : T extends object ? { [K in keyof T]: UnpackNestedValue<T[K]> }
+  : T
+
+/*
+Projects that React Hook Form installed don't include the DOM library need these interfaces to compile.
+React Native applications is no DOM available. The JavaScript runtime is ES6/ES2015 only.
+These definitions allow such projects to compile with only --lib ES6.
+
+Warning: all of these interfaces are empty.
+If you want type definitions for various properties, you need to add `--lib DOM` (via command line or tsconfig.json).
+*/
+
+export type Noop = () => void
+
+interface File extends Blob {
+  readonly lastModified: number
+  readonly name: string
+}
+
+interface FileList {
+  readonly length: number
+  item(index: number): File | null
+  [index: number]: File
+}
+
+export type Primitive =
+  | null
+  | undefined
+  | string
+  | number
+  | boolean
+  | symbol
+  | bigint
+
+export type BrowserNativeObject = Date | FileList | File
+
+export type EmptyObject = { [K in string | number]: never }
+
+export type NonUndefined<T> = T extends undefined ? never : T
+
+export type LiteralUnion<T extends U, U extends Primitive> =
+  | T
+  | (U & { _?: never })
+
+export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T
+  : { [K in keyof T]?: DeepPartial<T[K]> }
+
+export type DeepPartialSkipArrayKey<T> = T extends
+  | BrowserNativeObject
+  | NestedValue ? T
+  : T extends ReadonlyArray<any> ? { [K in keyof T]: DeepPartialSkipArrayKey<T[K]> }
+  : { [K in keyof T]?: DeepPartialSkipArrayKey<T[K]> }
+
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false
+
+/**
+ * Checks whether the type is never
+ * @typeParam T - type which may be never
+ * ```
+ * IsAny<never> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+export type DeepMap<T, TValue> = IsAny<T> extends true ? any
+  : T extends BrowserNativeObject | NestedValue ? TValue
+  : T extends object ? { [K in keyof T]: DeepMap<NonUndefined<T[K]>, TValue> }
+  : TValue
+
+export type IsFlatObject<T extends object> = Extract<
+  Exclude<T[keyof T], NestedValue | Date | FileList>,
+  any[] | object
+> extends never ? true
+  : false
+
+export type Merge<A, B> = {
+  [K in keyof A | keyof B]?: K extends keyof A & keyof B ? [A[K], B[K]] extends [object, object] ? Merge<A[K], B[K]>
+  : A[K] | B[K]
+    : K extends keyof A ? A[K]
+    : K extends keyof B ? B[K]
+    : never
+}

package/_src/lib/filter/types/validator.ts

@@ -0,0 +1,46 @@
+import type { Message } from "./errors.js"
+import type { FieldValues, InternalFieldName } from "./fields.js"
+import type { FieldPath, FieldPathValue } from "./path/index.js"
+
+export type ValidationValue = boolean | number | string | RegExp
+
+export type ValidationRule<
+  TValidationValue extends ValidationValue = ValidationValue
+> = TValidationValue | ValidationValueMessage<TValidationValue>
+
+export type ValidationValueMessage<
+  TValidationValue extends ValidationValue = ValidationValue
+> = {
+  value: TValidationValue
+  message: Message
+}
+
+export type ValidateResult = Message | Message[] | boolean | undefined
+
+export type Validate<TFieldValue> = (
+  value: TFieldValue
+) => ValidateResult | Promise<ValidateResult>
+
+export type RegisterOptions<
+  TFieldValues extends FieldValues = FieldValues,
+  TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
+> = Partial<{
+  required: Message | ValidationRule<boolean>
+  min: ValidationRule<number | string>
+  max: ValidationRule<number | string>
+  maxLength: ValidationRule<number>
+  minLength: ValidationRule<number>
+  pattern: ValidationRule<RegExp>
+  validate:
+    | Validate<FieldPathValue<TFieldValues, TFieldName>>
+    | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>>>
+  valueAsNumber: boolean
+  valueAsDate: boolean
+  value: FieldPathValue<TFieldValues, TFieldName>
+  setValueAs: (value: any) => any
+  shouldUnregister?: boolean
+  onChange?: (event: any) => void
+  onBlur?: (event: any) => void
+  disabled: boolean
+  deps: InternalFieldName | InternalFieldName[]
+}>

package/_src/lib/filter.ts

@@ -0,0 +1,323 @@
+import type { Where } from "../services/Store.js"
+import type { FieldValues } from "./filter/types/fields.js"
+import type { FieldPath, FieldPathValue } from "./filter/types/path/eager.js"
+
+/**
+ * the function defaults to "eq", but has additional properties for notEq, in and notIn
+ */
+export interface WhereFilter<TFieldValues extends FieldValues> extends ReturnType<typeof makeWhereFilter_<TFieldValues>> {}
+export function makeWhereFilter<TFieldValues extends FieldValues>() {
+  const f = makeWhereFilter_<TFieldValues>()
+  return f as WhereFilter<TFieldValues>
+}
+
+function makeHelpers<TFieldValues extends FieldValues>() {
+  const helpers = makeHelpers_<TFieldValues>()
+  return helpers as WhereHelpers<TFieldValues>
+}
+
+export interface WhereHelpers<TFieldValues extends FieldValues> extends ReturnType<typeof makeHelpers_<TFieldValues>> {}
+
+function makeHelpers_<TFieldValues extends FieldValues>() {
+  type Paths = FieldPath<TFieldValues>
+  type Value<TFieldName extends Paths> = FieldPathValue<TFieldValues, TFieldName>
+
+  return {
+    in<TFieldName extends Paths, V extends Value<TFieldName>>(
+      this: void,
+      path: TFieldName,
+      value: readonly V[]
+    ) {
+      return { key: path, value, t: "in" as const }
+    },
+    notIn<TFieldName extends Paths, V extends Value<TFieldName>>(
+      this: void,
+      path: TFieldName,
+      value: readonly V[]
+    ) {
+      return { key: path, value, t: "not-in" as const }
+    },
+    eq<TFieldName extends Paths, V extends Value<TFieldName>>(
+      this: void,
+      path: TFieldName,
+      value: V
+    ) {
+      return { key: path, value, t: "eq" as const }
+    },
+    notEq<TFieldName extends Paths, V extends Value<TFieldName>>(
+      this: void,
+      path: TFieldName,
+      value: V
+    ) {
+      return { key: path, value, t: "not-eq" as const }
+    }
+  } satisfies Record<string, (...args: any[]) => Where>
+}
+
+function makeWhereFilter_<TFieldValues extends FieldValues>() {
+  const helpers = makeHelpers<TFieldValues>()
+  const f = Object.assign(helpers.eq, helpers)
+  return f
+}
+
+
+
+export type WhereValue<
+  T extends "eq" | "not-eq" | "starts-with" | "ends-with" | "includes" | "contains" | "not-contains",
+  A, // extends SupportedValues,
+  V extends A = A
+> = { t: T; v: V }
+type SupportedValues = string | boolean | number | null
+
+export type WhereIn<T extends "in" | "not-in", V, Values extends readonly V[] = readonly V[]> = {
+  t: T
+  v: Values
+}
+
+/**
+ * @tsplus fluent Iterable $contains
+ */
+export function $contains<A extends SupportedValues, V extends A>(
+  _: readonly A[],
+  v: V
+): WhereValue<"contains", A, V> {
+  return $$contains(v)
+}
+
+/**
+ * @tsplus fluent Iterable $notContains
+ */
+export function $notContains<A extends SupportedValues, V extends A>(
+  _: readonly A[],
+  v: V
+): WhereValue<"not-contains", A, V> {
+  return $$notContains(v)
+}
+
+/**
+ * @tsplus fluent string $in
+ * @tsplus fluent boolean $in
+ * @tsplus fluent number $in
+ */
+export function $in<A extends SupportedValues, Values extends readonly A[]>(
+  _: A,
+  ...v: Values
+): WhereIn<"in", A, Values> {
+  return $$in(v)
+}
+
+/**
+ * @tsplus fluent string $notIn
+ * @tsplus fluent boolean $notIn
+ * @tsplus fluent number $notIn
+ */
+export function $notIn<A extends SupportedValues, Values extends readonly A[]>(
+  _: A,
+  ...v: Values
+): WhereIn<"not-in", A, Values> {
+  return $$notIn(v)
+}
+
+/**
+ * @tsplus fluent string $is
+ * @tsplus fluent boolean $is
+ * @tsplus fluent number $is
+ * @tsplus fluent Object $is
+ */
+export function $is<A, V extends A>(_: A, v: V): WhereValue<"eq", A, V> {
+  return $$is(v)
+}
+/**
+ * @tsplus fluent string $isnt
+ * @tsplus fluent boolean $isnt
+ * @tsplus fluent number $isnt
+ * @tsplus fluent Object $isnt
+ */
+export function $isnt<A, V extends A>(_: A, v: V): WhereValue<"not-eq", A, V> {
+  return $$isnt(v)
+}
+
+function $is__<V extends A, A>(v: V) {
+  return (_: A) => $is(_, v)
+}
+
+function $isnt__<V extends A, A>(v: V) {
+  return (_: A) => $isnt(_, v)
+}
+
+
+function $in__<A extends SupportedValues, Values extends readonly A[]>(
+...v: Values
+) {
+  return (_: A) => $in(_, ...v)
+}
+
+function $notIn__<A extends SupportedValues, Values extends readonly A[]>(
+  ...v: Values
+) {
+  return (_: A) => $notIn(_, ...v)
+}
+
+// function $contains__<A extends SupportedValues, V extends A>(
+//   v: V
+// ) {
+//   return (_: readonly A[]) => $contains(_, v)
+// }
+
+// function $notContains__<A extends SupportedValues, V extends A>(
+//   v: V
+// ) {
+//   return (_: readonly A[]) => $notContains(_, v)
+// }
+
+export const Filters = {
+  $is: $is__,
+  $isnt: $isnt__,
+  $in: $in__,
+  $notIn: $notIn__,
+  // $contains: $contains__,
+  // $notContains: $notContains__,
+}
+
+/**
+ * @tsplus fluent string $startsWith
+ */
+export function $startsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"starts-with", A, V> {
+  return $$startsWith(v)
+}
+
+/**
+ * @tsplus fluent string $endsWith
+ */
+export function $endsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"ends-with", A, V> {
+  return $$endsWith(v)
+}
+
+/**
+ * @tsplus fluent string $includes
+ */
+export function $includes<A extends string, V extends A>(_: A, v: V): WhereValue<"includes", A, V> {
+  return $$includes(v)
+}
+
+function $$in<L extends readonly any[]>(v: L) {
+  return { t: "in" as const, v }
+}
+
+function $$notIn<L extends readonly any[]>(v: L) {
+  return { t: "not-in" as const, v }
+}
+function $$is<A>(v: A) {
+  return { t: "eq" as const, v }
+}
+function $$isnt<A>(v: A) {
+  return { t: "not-eq" as const, v }
+}
+
+// containsAny, containsAll?
+function $$contains<A>(v: A) {
+  return { t: "contains" as const, v }
+}
+function $$notContains<A>(v: A) {
+  return { t: "not-contains" as const, v }
+}
+function $$includes<A extends string>(v: A) {
+  return { t: "includes" as const, v }
+}
+function $$startsWith<A extends string>(v: A) {
+  return { t: "starts-with" as const, v }
+}
+function $$endsWith<A extends string>(v: A) {
+  return { t: "ends-with" as const, v }
+}
+
+type ValueType<V> = {
+  t: "in" | "not-in"
+  v: readonly V[]
+} | { t: "eq" | "not-eq"; v: V }
+
+type TType<T> = T extends ValueType<any> ? T["t"] : never
+type VType<T> = T extends ValueType<any> ? T["v"] : never
+
+function f(p: string, b: any) {
+  if (typeof b === "function") b = b(undefined)
+  const obj = typeof b === "object" && b !== null
+  return makeFilter(p, obj ? b.v : b, obj ? b.t ?? "eq" : "eq");
+}
+
+function makeFilter<T extends "in" | "not-in" | "eq" | "not-eq">(path: string, value: any, t: T) {
+  return { key: path, t, value }
+}
+
+type FIL<S, K extends string, T extends "in" | "not-in" | "eq" | "not-eq", V> = {
+  key: K
+  t: T
+  value: V
+  readonly S: S
+}
+
+
+export function makeFilters<T extends FieldValues>() {
+  type Paths = FieldPath<T>
+  type Value<TFieldName extends Paths> = FieldPathValue<T, TFieldName>
+
+  function test<
+    TFieldName extends Paths,
+    A extends Value<TFieldName>,
+    Val
+  >(
+    path: TFieldName,
+    value: (v: A) => Val
+  ): FIL<T, string, TType<Val>, VType<Val>>
+  function test<
+    TFieldName extends Paths,
+    A extends Value<TFieldName>
+  >(
+    path: TFieldName,
+    value: A
+  ): FIL<T, string, "eq", A>
+  function test(p: string, v: any) {
+    return f(p, v) as any
+  }
+  return test
+}
+
+
+
+// export function makeFilter<TFieldValues extends FieldValues>() {
+//   const f = makeFilter_<TFieldValues>()
+//   return f as WhereFilterHelper<TFieldValues>
+// }
+
+// export interface WhereFilterHelper<TFieldValues extends FieldValues> extends ReturnType<typeof makeFilter_<TFieldValues>> {}
+
+// function makeFilter_<TFieldValues extends FieldValues>() {
+//   function eq<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
+//     path: TFieldName,
+//     value: V
+//   ) {
+//     return { key: path, value, t: "eq" as const }
+//   }
+//   const f = Object.assign(eq satisfies (...args: any[]) => Where, {
+//     in<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
+//       path: TFieldName,
+//       value: readonly V[]
+//     ) {
+//       return { key: path, value, t: "in" as const }
+//     },
+//     notIn<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
+//       path: TFieldName,
+//       value: readonly V[]
+//     ) {
+//       return { key: path, value, t: "not-in" as const }
+//     },
+//     eq,
+//     notEq<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
+//       path: TFieldName,
+//       value: V
+//     ) {
+//       return { key: path, value, t: "not-eq" as const }
+//     }
+//   } satisfies Record<string, (...args: any[]) => Where>)
+//   return f
+// }

package/_src/lib/instrument.ts

@@ -0,0 +1,9 @@
+/**
+ * @tsplus fluent effect/io/Effect instrument
+ */
+export function instr<R, E, A>(self: Effect<R, E, A>, name: string, properties?: Record<string, string>) {
+  return self
+    .tap(() => Effect.logDebug(`instrumented`).logAnnotate("properties", (properties || {}).$$.pretty))
+    .withSpan(name)
+  // trackMetric(name, time, properties))
+}