effect-app 4.0.0-beta.33 → 4.0.0-beta.331

package/src/Model/Repository/validation.ts

@@ -0,0 +1,38 @@
+import * as S from "../../Schema.ts"
+import { NonNegativeInt } from "../../Schema.ts"
+
+/**
+ * Represents a single validation error when decoding a repository item.
+ * Contains full context for debugging: the stored data and the decode error.
+ */
+export class ValidationError extends S.Opaque<ValidationError>()(S.Struct({
+  /** the id of the item that failed validation */
+  id: S.Unknown,
+  /**
+   * the data as returned by the store: `defaultValues` merged, `jitM` applied
+   * to the raw JSON document, and JSON decoded to the Encoded shape
+   */
+  rawData: S.Unknown,
+  /**
+   * @deprecated identical to {@link rawData}. `jitM` now runs inside the store,
+   * before the JSON→Encoded decode, so the repository never sees the document
+   * as it was before the migration.
+   */
+  jitMResult: S.Unknown,
+  /** the S.SchemaError from schema decode */
+  error: S.Unknown
+})) {}
+
+/**
+ * Result of validating a sample of repository items.
+ */
+export class ValidationResult extends S.Opaque<ValidationResult>()(S.Struct({
+  /** total number of items in the repository */
+  total: NonNegativeInt,
+  /** number of items that were sampled for validation */
+  sampled: NonNegativeInt,
+  /** number of items that passed validation */
+  valid: NonNegativeInt,
+  /** list of validation errors with full context */
+  errors: S.Array(ValidationError)
+})) {}

package/src/Model/Repository.ts

@@ -0,0 +1,7 @@
+export { repositoryDependency } from "./Repository/dependency.ts"
+export * from "./Repository/ext.ts"
+export * from "./Repository/legacy.ts"
+export { makeRepo } from "./Repository/makeRepo.ts"
+export * from "./Repository/Registry.ts"
+export * from "./Repository/service.ts"
+export * from "./Repository/validation.ts"

package/src/Model/dsl.ts

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { NonEmptyReadonlyArray } from "../Array.ts"
+import { toNonEmptyArray } from "../Array.ts"
+import * as Effect from "../Effect.ts"
+import { type FixEnv, get, logMany, type Pure, type PureEnvEnv, type PureLogT, set } from "../Pure.ts"
+
+export interface PureDSL<S, S2, W> {
+  get: Pure<never, S, S, never, never, S>
+  set: (s: S2) => Pure<never, S2, S2, never, never, void>
+  log: (...w: W[]) => PureLogT<W>
+}
+
+export const AnyPureDSL: PureDSL<any, any, any> = {
+  get: get(),
+  set: set as any,
+  log: (...evt: any[]) => logMany(evt)
+}
+
+const anyDSL = makeDSL<any, any, any>()
+
+export type AllDSL<T, Evt> =
+  & (<R, A, E, S1 extends T, S2 extends T>(
+    pure: (dsl: PureDSL<S1[], S2[], Evt>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>)
+  & AllDSLExt<T, Evt>
+
+export interface AllDSLExt<T, Evt> {
+  modify: <R, E, A, S1 extends T, S2 extends T>(
+    pure: (items: readonly S1[], dsl: PureDSL<readonly S1[], readonly S2[], Evt>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+  update: <R, E, S1 extends T, S2 extends T>(
+    pure: (items: readonly S1[], log: (...evt: Evt[]) => PureLogT<Evt>) => Effect.Effect<readonly S2[], E, R>
+  ) => Effect.Effect<readonly S2[], E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+  updateWith: <S1 extends T, S2 extends T>(
+    upd: (item: readonly S1[]) => readonly S2[]
+  ) => Effect.Effect<readonly S2[], never, PureEnvEnv<Evt, readonly S1[], readonly S2[]>>
+}
+
+export function makeAllDSL<T, Evt>() {
+  const dsl: AllDSL<T, Evt> = anyDSL
+  return dsl
+}
+
+export type OneDSL<T, Evt> =
+  & (<R, A, E, S1 extends T, S2 extends T>(
+    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>>)
+  & OneDSLExt<T, Evt>
+
+export interface OneDSLExt<T, Evt> {
+  modify: <R, E, A, S1 extends T, S2 extends T>(
+    pure: (items: S1, dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1, S2> | PureEnvEnv<Evt, S1, S1>>
+  update: <R, E, S1 extends T, S2 extends T>(
+    pure: (items: S1, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect.Effect<S2, E, R>
+  ) => Effect.Effect<S2, E, FixEnv<R, Evt, S1, S2>>
+  updateWith: <S1 extends T, S2 extends T>(
+    upd: (item: S1) => S2
+  ) => Effect.Effect<S2, never, PureEnvEnv<Evt, S1, S2>>
+}
+
+export function makeOneDSL<T, Evt>(): OneDSL<T, Evt> {
+  return anyDSL
+}
+
+export function makeDSL<S1, S2, Evt>() {
+  const dsl: PureDSL<S1, S2, Evt> = AnyPureDSL
+
+  function modify<
+    R,
+    E,
+    A
+  >(
+    pure: (
+      items: S1,
+      dsl: PureDSL<S1, S2, Evt>
+    ) => Effect.Effect<A, E, R>
+  ): Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>> {
+    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl))) as any
+  }
+
+  function update<
+    R,
+    E
+  >(
+    pure: (
+      items: S1,
+      log: (...evt: Evt[]) => PureLogT<Evt>
+    ) => Effect.Effect<S2, E, R>
+  ): Effect.Effect<S2, E, FixEnv<R, Evt, S1, S2>> {
+    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl.log).pipe(Effect.tap(dsl.set)))) as any
+  }
+
+  function withDSL<
+    R,
+    A,
+    E
+  >(
+    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
+  ): Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>> {
+    return pure(AnyPureDSL) as any
+  }
+
+  function updateWith(upd: (item: S1) => S2) {
+    return update((_: S1) => Effect.sync(() => upd(_)))
+  }
+
+  return Object.assign(
+    withDSL,
+    {
+      modify,
+      update,
+      updateWith
+    }
+  )
+}
+
+export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
+
+export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>) {
+  return (items: Iterable<T>) => Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
+}
+
+export function ifAny_<T, R, E, A>(
+  items: Iterable<T>,
+  fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>
+) {
+  return Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
+}

package/src/Model/filter/filterApi.ts

@@ -0,0 +1,78 @@
+import { type RelationDirection } from "../query.ts"
+
+export type InOps =
+  | "in"
+  | "notIn"
+
+export type OtherOps =
+  | "endsWith"
+  | "startsWith"
+  | "notEndsWith"
+  | "notStartsWith"
+  | "contains"
+  | "notContains"
+  | "includes"
+  | "notIncludes"
+  | "includes-any"
+  | "notIncludes-any"
+  | "includes-all"
+  | "notIncludes-all"
+  | "hasKey"
+  | "notHasKey"
+  | "hasValue"
+  | "notHasValue"
+  | "hasKeyValue"
+  | "notHasKeyValue"
+  | "hasKey-any"
+  | "notHasKey-any"
+  | "hasKey-all"
+  | "notHasKey-all"
+  | "hasValue-any"
+  | "notHasValue-any"
+  | "hasValue-all"
+  | "notHasValue-all"
+  | "hasKeyValue-any"
+  | "notHasKeyValue-any"
+  | "hasKeyValue-all"
+  | "notHasKeyValue-all"
+  | "eq"
+  | "neq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+
+export type Ops = OtherOps | InOps
+
+export type FilterScopes = {
+  t: "or-scope"
+  result: readonly FilterResult[]
+  relation: RelationDirection
+} | {
+  t: "and-scope"
+  result: readonly FilterResult[]
+  relation: RelationDirection
+} | {
+  t: "where-scope"
+  result: readonly FilterResult[]
+  relation: RelationDirection
+}
+
+export type FilterR = {
+  op: Ops
+
+  path: string
+  value: unknown
+}
+
+export type FilterResult =
+  | {
+    t: "where"
+  } & FilterR
+  | {
+    t: "or"
+  } & FilterR
+  | {
+    t: "and"
+  } & FilterR
+  | FilterScopes

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

@@ -0,0 +1,47 @@
+import type { FieldValues, InternalFieldName } from "./fields.ts"
+import type { BrowserNativeObject, IsAny, LiteralUnion, Merge } from "./utils.ts"
+import type { RegisterOptions, ValidateResult } from "./validator.ts"
+
+export type Message = string
+
+export type MultipleFieldErrors =
+  & {
+    [K in keyof RegisterOptions]?: ValidateResult
+  }
+  & {
+    [key: string]: ValidateResult
+  }
+
+export type FieldError = {
+  type: LiteralUnion<keyof RegisterOptions, string>
+  root?: FieldError
+  // ref?: Ref
+  types?: MultipleFieldErrors
+  message?: Message
+}
+
+export type ErrorOption = {
+  message?: Message
+  type?: LiteralUnion<keyof RegisterOptions, string>
+  types?: MultipleFieldErrors
+}
+
+export type DeepRequired<T> = T extends BrowserNativeObject | Blob ? T
+  : {
+    [K in keyof T]-?: NonNullable<DeepRequired<T[K]>>
+  }
+
+export type FieldErrorsImpl<T extends FieldValues = FieldValues> = {
+  [K in keyof T]?: T[K] extends BrowserNativeObject | Blob ? FieldError
+    : T[K] extends object ? Merge<FieldError, FieldErrorsImpl<T[K]>>
+    : FieldError
+}
+
+export type FieldErrors<T extends FieldValues = FieldValues> = Partial<
+  FieldValues extends IsAny<FieldValues> ? any
+    : FieldErrorsImpl<DeepRequired<T>>
+>
+
+export type InternalFieldErrors = Partial<
+  Record<InternalFieldName, FieldError>
+>

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

@@ -0,0 +1,50 @@
+import type { IsFlatObject } from "./utils.ts"
+import type { RegisterOptions } from "./validator.ts"
+
+export type InternalFieldName = string
+
+export type FieldName<TFieldValues extends FieldValues> = IsFlatObject<TFieldValues> extends true
+  ? Extract<keyof TFieldValues, string>
+  : string
+
+// export type CustomElement<TFieldValues extends FieldValues> = {
+//   name: FieldName<TFieldValues>
+//   type?: string
+//   value?: any
+//   disabled?: boolean
+//   checked?: boolean
+//   options?: HTMLOptionsCollection
+//   files?: FileList | null
+//   focus?: Noop
+// }
+
+export type FieldValue<TFieldValues extends FieldValues> = TFieldValues[InternalFieldName]
+
+export type FieldValues = Record<string, any>
+
+export type NativeFieldValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | unknown[]
+
+// export type FieldElement<TFieldValues extends FieldValues = FieldValues> =
+//   | HTMLInputElement
+//   | HTMLSelectElement
+//   | HTMLTextAreaElement
+//   | CustomElement<TFieldValues>
+
+// export type Ref = FieldElement
+
+export type Field = {
+  _f: {
+    // ref: Ref
+    name: InternalFieldName
+    // refs?: HTMLInputElement[]
+    mount?: boolean
+  } & RegisterOptions
+}
+
+export type FieldRefs = Partial<Record<InternalFieldName, Field>>