@typed/async-data 0.3.0 → 0.3.2

package/src/Schema.ts

@@ -4,60 +4,433 @@
 
 import * as Arbitrary from "@effect/schema/Arbitrary"
 import * as AST from "@effect/schema/AST"
+import * as Eq from "@effect/schema/Equivalence"
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Pretty from "@effect/schema/Pretty"
 import * as Schema from "@effect/schema/Schema"
 import * as AsyncData from "@typed/async-data/AsyncData"
+import { Equal } from "effect"
 import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import * as P from "./Progress.js"
 
-const asyncDataPretty = <E, A>(
-  prettyCause: Pretty.Pretty<Cause.Cause<E>>,
-  prettyValue: Pretty.Pretty<A>
-): Pretty.Pretty<AsyncData.AsyncData<E, A>> =>
-  AsyncData.match({
-    NoData: () => `AsyncData.NoData`,
-    Loading: () => `AsyncData.Loading`,
-    Failure: (cause, data) =>
-      `AsyncData.Failure(refreshing=${Option.isSome(data.refreshing)}, cause=${prettyCause(cause)})`,
-    Success: (value, data) =>
-      `AsyncData.Success(refreshing=${Option.isSome(data.refreshing)}, value=${prettyValue(value)})`
+const NO_DATA_PRETTY = "AsyncData.NoData"
+const LOADING_PRETTY = (loading: AsyncData.Loading) =>
+  Option.match(loading.progress, {
+    onNone: () => `AsyncData.Loading(timestamp=${loading.timestamp})`,
+    onSome: (progress) => `AsyncData.Loading(timestamp=${loading.timestamp}, progress=${P.pretty(progress)})`
   })
+const FAILURE_PRETTY = <E>(print: Pretty.Pretty<Cause.Cause<E>>) => (failure: AsyncData.Failure<E>) =>
+  Option.match(failure.refreshing, {
+    onNone: () => `AsyncData.Failure(timestamp=${failure.timestamp}, cause=${print(failure.cause)})`,
+    onSome: (loading) =>
+      `AsyncData.Failure(timestamp=${failure.timestamp}, refreshing=${LOADING_PRETTY(loading)}, cause=${
+        print(failure.cause)
+      })`
+  })
+const SUCCESS_PRETTY = <A>(print: Pretty.Pretty<A>) => (success: AsyncData.Success<A>) =>
+  Option.match(success.refreshing, {
+    onNone: () => `AsyncData.Success(timestamp=${success.timestamp}, value=${print(success.value)})`,
+    onSome: (loading) =>
+      `AsyncData.Success(timestamp=${success.timestamp}, refreshing=${LOADING_PRETTY(loading)}, value=${
+        print(success.value)
+      })`
+  })
+
+const NoDataSchemaJson = Schema.struct({
+  _tag: Schema.literal("NoData")
+})
+const NoDataSchema = Schema.instanceOf(AsyncData.NoData)
+
+/**
+ * @since 1.0.0
+ */
+export const NoData: Schema.Schema<{ readonly _tag: "NoData" }, AsyncData.NoData> = NoDataSchemaJson
+  .pipe(
+    Schema.transform(
+      NoDataSchema,
+      (): AsyncData.NoData => AsyncData.noData(),
+      (): Schema.Schema.To<typeof NoDataSchemaJson> => ({
+        _tag: "NoData"
+      })
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: NO_DATA_PRETTY,
+      [Pretty.PrettyHookId]: () => NO_DATA_PRETTY,
+      [Arbitrary.ArbitraryHookId]: (): Arbitrary.Arbitrary<AsyncData.NoData> => (fc) => fc.constant(AsyncData.noData()),
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
+  )
+
+/**
+ * @since 1.0.0
+ */
+export type NoDataFrom = Schema.Schema.From<typeof NoData>
+
+const ProgressSchemaJson = Schema.struct({
+  loaded: Schema.bigint,
+  total: Schema.optional(Schema.bigint)
+})
+type ProgressFromTo = Schema.Schema.To<typeof ProgressSchemaJson>
+
+const ProgressSchema: Schema.Schema<
+  {
+    readonly loaded: bigint
+    readonly total: Option.Option<bigint>
+  },
+  P.Progress
+> = Schema.data(Schema.struct({
+  loaded: Schema.bigintFromSelf,
+  total: Schema.optionFromSelf(Schema.bigintFromSelf)
+}))
+
+const progressArbitrary: Arbitrary.Arbitrary<P.Progress> = (fc) =>
+  fc.bigInt().chain((loaded) => fc.option(fc.bigInt({ min: loaded })).map((total) => P.make(loaded, total)))
+
+/**
+ * @since 1.0.0
+ */
+export const Progress: Schema.Schema<{ readonly loaded: string; readonly total?: string | undefined }, P.Progress> =
+  ProgressSchemaJson.pipe(
+    Schema.transform(
+      ProgressSchema,
+      (json): P.Progress => P.make(json.loaded, json.total),
+      (progress) => ({
+        loaded: progress.loaded,
+        total: Option.getOrUndefined(progress.total)
+      })
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: "Progress",
+      [Pretty.PrettyHookId]: () => "Progress",
+      [Arbitrary.ArbitraryHookId]: (): Arbitrary.Arbitrary<P.Progress> => progressArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
+  )
+
+/**
+ * @since 1.0.0
+ */
+export type ProgressFrom = Schema.Schema.From<typeof Progress>
+
+const LoadingSchemaJson = Schema.struct({
+  _tag: Schema.literal("Loading"),
+  timestamp: Schema.number,
+  progress: Schema.optional(ProgressSchemaJson)
+})
+const LoadingSchema = Schema.instanceOf(AsyncData.Loading)
+
+const loadingFromJson = (json: Schema.Schema.To<typeof LoadingSchemaJson>): AsyncData.Loading =>
+  AsyncData.loading({ timestamp: json.timestamp, progress: progressFromJson(json.progress) })
+
+const loadingToJson = (loading: AsyncData.Loading): Schema.Schema.To<typeof LoadingSchemaJson> => ({
+  _tag: "Loading",
+  timestamp: loading.timestamp,
+  progress: progressToJson(loading.progress)
+})
+
+const loadingArbitrary: Arbitrary.Arbitrary<AsyncData.Loading> = (fc) =>
+  fc.option(progressArbitrary(fc)).map((progress) =>
+    AsyncData.loading({
+      timestamp: Date.now(),
+      progress: progress || undefined
+    })
+  )
+
+/**
+ * @since 1.0.0
+ */
+export const Loading: Schema.Schema<
+  {
+    readonly _tag: "Loading"
+    readonly timestamp: number
+    readonly progress?: ProgressFrom | undefined
+  },
+  AsyncData.Loading
+> = LoadingSchemaJson
+  .pipe(
+    Schema.transform(
+      LoadingSchema,
+      loadingFromJson,
+      loadingToJson
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: "AsyncData.Loading",
+      [Pretty.PrettyHookId]: () => LOADING_PRETTY,
+      [Arbitrary.ArbitraryHookId]: () => loadingArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
+  )
+
+/**
+ * @since 1.0.0
+ */
+export type LoadingFrom = Schema.Schema.From<typeof Loading>
+
+const FailureSchemaJson = <EI, E>(cause: Schema.Schema<Schema.CauseFrom<EI>, Cause.Cause<E>>) =>
+  Schema.struct({
+    _tag: Schema.literal("Failure"),
+    cause,
+    timestamp: Schema.number,
+    refreshing: Schema.optional(LoadingSchemaJson)
+  })
+
+const FailureSchema = <EI, E>(
+  error: Schema.Schema<EI, E>
+): Schema.Schema<AsyncData.Failure<EI>, AsyncData.Failure<E>> =>
+  Schema.declare(
+    [Schema.cause(error)],
+    Schema.struct({}),
+    (isDecoding, causeSchema) => {
+      const parseCause = isDecoding ? Schema.parse(causeSchema) : Schema.encode(causeSchema)
+
+      return (input, options) => {
+        return Effect.gen(function*(_) {
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
 
-const asyncDataArbitrary = <E, A>(
-  causeArbitrary: Arbitrary.Arbitrary<Cause.Cause<E>>,
-  valueArbitrary: Arbitrary.Arbitrary<A>
-): Arbitrary.Arbitrary<AsyncData.AsyncData<E, A>> =>
+          switch (input._tag) {
+            case "Failure": {
+              const cause = yield* _(parseCause(input.cause, options))
+
+              return AsyncData.failCause(cause, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
+            }
+            default:
+              return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+          }
+        })
+      }
+    }
+  )
+
+const failureArbitrary = <E>(
+  cause: Arbitrary.Arbitrary<Cause.Cause<E>>
+): Arbitrary.Arbitrary<AsyncData.Failure<E>> =>
 (fc) =>
-  fc.oneof(
-    fc.constant(AsyncData.noData()),
-    fc.constant(AsyncData.loading()),
-    causeArbitrary(fc).map((cause) => AsyncData.failCause(cause)),
-    valueArbitrary(fc).map((a) => AsyncData.success(a))
+  fc.option(loadingArbitrary(fc)).chain((refreshing) =>
+    cause(fc).chain((cause) =>
+      fc.date().map((date) =>
+        AsyncData.failCause(cause, {
+          timestamp: date.getTime(),
+          refreshing: refreshing || undefined
+        })
+      )
+    )
   )
 
+/**
+ * @since 1.0.0
+ */
+export const Failure = <EI, E>(
+  error: Schema.Schema<EI, E>
+): Schema.Schema<
+  {
+    readonly _tag: "Failure"
+    readonly cause: Schema.CauseFrom<EI>
+    readonly timestamp: number
+    readonly refreshing?: {
+      readonly _tag: "Loading"
+      readonly timestamp: number
+      readonly progress?: { readonly loaded: string; readonly total?: string | undefined } | undefined
+    } | undefined
+  },
+  AsyncData.Failure<E>
+> =>
+  FailureSchemaJson(Schema.cause(Schema.from(error)))
+    .pipe(
+      Schema.transform(
+        FailureSchema(error),
+        (json): AsyncData.Failure<EI> =>
+          AsyncData.failCause(json.cause, {
+            timestamp: json.timestamp,
+            refreshing: json.refreshing ? loadingFromJson(json.refreshing) : undefined
+          }),
+        (failure) => ({
+          _tag: "Failure",
+          cause: failure.cause,
+          timestamp: failure.timestamp,
+          refreshing: Option.getOrUndefined(Option.map(failure.refreshing, loadingToJson))
+        } as const)
+      ),
+      Schema.annotations({
+        [AST.IdentifierAnnotationId]: "AsyncData.Failure",
+        [Pretty.PrettyHookId]: FAILURE_PRETTY,
+        [Arbitrary.ArbitraryHookId]: failureArbitrary,
+        [Eq.EquivalenceHookId]: () => Equal.equals
+      })
+    )
+
+/**
+ * @since 1.0.0
+ */
+export type FailureFrom<E> = Schema.Schema.From<ReturnType<typeof FailureSchemaJson<E, E>>>
+
+const SuccessSchemaJson = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: AI
+    readonly refreshing?: {
+      readonly timestamp: number
+      readonly _tag: "Loading"
+      readonly progress?: { readonly loaded: string; readonly total?: string | undefined } | undefined
+    } | undefined
+  },
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: A
+    readonly refreshing?: {
+      readonly timestamp: number
+      readonly _tag: "Loading"
+      readonly progress?: { readonly loaded: bigint; readonly total?: bigint | undefined } | undefined
+    } | undefined
+  }
+> =>
+  Schema.struct({
+    _tag: Schema.literal("Success"),
+    value,
+    timestamp: Schema.number,
+    refreshing: Schema.optional(LoadingSchemaJson)
+  })
+
+const SuccessSchema = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<AsyncData.Success<AI>, AsyncData.Success<A>> =>
+  Schema.declare(
+    [value],
+    Schema.struct({
+      _tag: Schema.literal("Success"),
+      timestamp: Schema.number
+    }),
+    (isDecoding, valueSchema) => {
+      const parseValue = isDecoding ? Schema.parse(valueSchema) : Schema.encode(valueSchema)
+
+      return (input, options) => {
+        return Effect.gen(function*(_) {
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+
+          switch (input._tag) {
+            case "Success": {
+              const value = yield* _(parseValue(input.value, options))
+
+              return AsyncData.success(value, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
+            }
+            default:
+              return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+          }
+        })
+      }
+    }
+  )
+
+const successArbitrary = <A>(
+  value: Arbitrary.Arbitrary<A>
+): Arbitrary.Arbitrary<AsyncData.Success<A>> =>
+(fc) =>
+  fc.option(loadingArbitrary(fc)).chain((refreshing) =>
+    value(fc).chain((a) =>
+      fc.date().map((date) =>
+        AsyncData.success(a, {
+          timestamp: date.getTime(),
+          refreshing: refreshing || undefined
+        })
+      )
+    )
+  )
+
+/**
+ * @since 1.0.0
+ */
+export const Success = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: AI
+    readonly refreshing?: LoadingFrom | undefined
+  },
+  AsyncData.Success<A>
+> =>
+  SuccessSchemaJson(Schema.from(value))
+    .pipe(
+      Schema.transform(
+        SuccessSchema(value),
+        (json): AsyncData.Success<AI> =>
+          AsyncData.success(json.value, {
+            timestamp: json.timestamp,
+            refreshing: json.refreshing ? loadingFromJson(json.refreshing) : undefined
+          }),
+        (success) => ({
+          _tag: "Success",
+          value: success.value,
+          timestamp: success.timestamp,
+          refreshing: Option.getOrUndefined(Option.map(success.refreshing, loadingToJson))
+        } as const)
+      ),
+      Schema.annotations({
+        [AST.IdentifierAnnotationId]: "AsyncData.Success",
+        [Pretty.PrettyHookId]: SUCCESS_PRETTY,
+        [Arbitrary.ArbitraryHookId]: successArbitrary,
+        [Eq.EquivalenceHookId]: () => Equal.equals
+      })
+    )
+
+/**
+ * @since 1.0.0
+ */
+export type SuccessFrom<A> = Schema.Schema.From<ReturnType<typeof SuccessSchemaJson<A, A>>>
+
+/**
+ * @since 1.0.0
+ */
+export type AsyncDataFrom<E, A> = NoDataFrom | LoadingFrom | FailureFrom<E> | SuccessFrom<A>
+
 /**
  * @since 1.0.0
  */
 export const asyncData = <EI, E, AI, A>(
   error: Schema.Schema<EI, E>,
   value: Schema.Schema<AI, A>
+): Schema.Schema<AsyncDataFrom<EI, AI>, AsyncData.AsyncData<E, A>> => {
+  return Schema.union(
+    NoData,
+    Loading,
+    Failure(error),
+    Success(value)
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export const asyncDataFromSelf = <EI, E, AI, A>(
+  error: Schema.Schema<EI, E>,
+  value: Schema.Schema<AI, A>
 ): Schema.Schema<AsyncData.AsyncData<EI, AI>, AsyncData.AsyncData<E, A>> => {
   return Schema.declare(
     [Schema.cause(error), value],
     Schema.struct({}),
-    (_, ...params) => {
+    (isDecoding, ...params) => {
       const [causeSchema, valueSchema] = params as readonly [
-        Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>>,
-        Schema.Schema<AI, A>
+        Schema.Schema<Cause.Cause<any>, Cause.Cause<any>>,
+        Schema.Schema<any, any>
       ]
-      const parseCause = Schema.parse(causeSchema)
-      const parseValue = Schema.parse(valueSchema)
+      const parseCause = isDecoding ? Schema.parse(causeSchema) : Schema.encode(causeSchema)
+      const parseValue = isDecoding ? Schema.parse(valueSchema) : Schema.encode(valueSchema)
 
       return (input, options) => {
         return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData<EI, AI>(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
 
           switch (input._tag) {
             case "NoData":
@@ -67,6 +440,7 @@ export const asyncData = <EI, E, AI, A>(
               const cause = yield* _(parseCause(input.cause, options))
 
               return AsyncData.failCause(cause, {
+                timestamp: input.timestamp,
                 refreshing: Option.getOrUndefined(input.refreshing)
               })
             }
@@ -74,6 +448,7 @@ export const asyncData = <EI, E, AI, A>(
               const a = yield* _(parseValue(input.value, options))
 
               return AsyncData.success(a, {
+                timestamp: input.timestamp,
                 refreshing: Option.getOrUndefined(input.refreshing)
               })
             }
@@ -83,8 +458,52 @@ export const asyncData = <EI, E, AI, A>(
     },
     {
       [AST.IdentifierAnnotationId]: "AsyncData",
-      [Arbitrary.ArbitraryHookId]: asyncDataPretty,
-      [Pretty.PrettyHookId]: asyncDataArbitrary
+      [Pretty.PrettyHookId]: asyncDataPretty,
+      [Arbitrary.ArbitraryHookId]: asyncDataArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
     }
   )
 }
+
+function asyncDataPretty<E, A>(
+  E: Pretty.Pretty<Cause.Cause<E>>,
+  A: Pretty.Pretty<A>
+): Pretty.Pretty<AsyncData.AsyncData<E, A>> {
+  return AsyncData.match({
+    NoData: () => NO_DATA_PRETTY,
+    Loading: LOADING_PRETTY,
+    Failure: (_, data) => FAILURE_PRETTY(E)(data),
+    Success: (_, data) => SUCCESS_PRETTY(A)(data)
+  })
+}
+
+function asyncDataArbitrary<E, A>(
+  E: Arbitrary.Arbitrary<Cause.Cause<E>>,
+  A: Arbitrary.Arbitrary<A>
+): Arbitrary.Arbitrary<AsyncData.AsyncData<E, A>> {
+  const noDataArb = Arbitrary.make(NoData)
+  const loadingArb = Arbitrary.make(Loading)
+  const failureArb = failureArbitrary(E)
+  const successArb = successArbitrary(A)
+
+  return (fc) =>
+    fc.oneof(
+      noDataArb(fc),
+      loadingArb(fc),
+      failureArb(fc),
+      successArb(fc)
+    )
+}
+
+function progressFromJson(json: ProgressFromTo | undefined): P.Progress | undefined {
+  if (json === undefined) return
+  return P.make(json.loaded, json.total)
+}
+
+function progressToJson(progres: Option.Option<P.Progress>): ProgressFromTo | undefined {
+  if (Option.isNone(progres)) return
+  return {
+    loaded: progres.value.loaded,
+    total: Option.getOrUndefined(progres.value.total)
+  }
+}