@typed/async-data 0.4.1 → 0.5.1

package/src/Schema.ts

@@ -5,6 +5,7 @@
 import * as Arbitrary from "@effect/schema/Arbitrary"
 import * as AST from "@effect/schema/AST"
 import * as Eq from "@effect/schema/Equivalence"
+import * as Parser from "@effect/schema/Parser"
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Pretty from "@effect/schema/Pretty"
 import * as Schema from "@effect/schema/Schema"
@@ -51,6 +52,7 @@ const ProgressSchemaJson = Schema.struct({
 })
 
 const ProgressSchema: Schema.Schema<
+  never,
   {
     readonly loaded: bigint
     readonly total: Option.Option<bigint>
@@ -67,23 +69,26 @@ const progressArbitrary: Arbitrary.Arbitrary<P.Progress> = (fc) =>
 /**
  * @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
+export const Progress: Schema.Schema<
+  never,
+  { 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
@@ -297,7 +302,7 @@ function isFailureFrom(value: unknown): value is FailureFrom<any> {
     && isCauseFrom(value.cause)
     && hasProperty(value, "timestamp")
     && typeof value.timestamp === "number"
-    && (hasProperty(value, "refreshing") ? isLoadingFrom(value.refreshing) : true)
+    && (hasProperty(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true)
 }
 
 function isSuccessFrom(value: unknown): value is SuccessFrom<any> {
@@ -306,7 +311,7 @@ function isSuccessFrom(value: unknown): value is SuccessFrom<any> {
     && hasProperty(value, "value")
     && hasProperty(value, "timestamp")
     && typeof value.timestamp === "number"
-    && (hasProperty(value, "refreshing") ? isLoadingFrom(value.refreshing) : true)
+    && (hasProperty(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true)
 }
 
 function isOptimisticFrom(value: unknown): value is OptimisticFrom<any, any> {
@@ -319,7 +324,7 @@ function isOptimisticFrom(value: unknown): value is OptimisticFrom<any, any> {
     && typeof value.timestamp === "number"
 }
 
-function isAsyncDataFrom(value: unknown): value is AsyncDataFrom<any, any> {
+function isAsyncDataFrom<E = unknown, A = unknown>(value: unknown): value is AsyncDataFrom<E, A> {
   return isNoDataFrom(value)
     || isLoadingFrom(value)
     || isFailureFrom(value)
@@ -330,33 +335,27 @@ function isAsyncDataFrom(value: unknown): value is AsyncDataFrom<any, any> {
 /**
  * @since 1.0.0
  */
-export const asyncDataFromJson = <EI, E, AI, A>(
-  error: Schema.Schema<EI, E>,
-  value: Schema.Schema<AI, A>
-): Schema.Schema<AsyncDataFrom<EI, AI>, AsyncDataFrom<E, A>> =>
-  Schema.declare(
-    [
-      Schema.cause(error),
-      value
-    ],
-    Schema.annotations({
-      [Eq.EquivalenceHookId]: () => fromEq
-    })(Schema.struct({})),
-    (isDecoding, causeSchema, valueSchema) => {
-      const parseCause = isDecoding ? Schema.decode(causeSchema) : Schema.encode(causeSchema)
-      const parseValue = isDecoding ? Schema.decode(valueSchema) : Schema.encode(valueSchema)
+export const asyncDataFromJson = <R1, EI, E, R2, AI, A>(
+  error: Schema.Schema<R1, EI, E>,
+  value: Schema.Schema<R2, AI, A>
+): Schema.Schema<R1 | R2, AsyncDataFrom<EI, AI>, AsyncDataFrom<E, A>> => {
+  return Schema.declare(
+    [Schema.cause(error, Schema.unknown), value],
+    (causeSchema, valueSchema) => {
+      const parseCause = Parser.decode(causeSchema)
+      const parseValue = Parser.decode(valueSchema)
 
       const parseAsyncData = (
-        input: any,
-        options?: AST.ParseOptions
+        input: unknown,
+        options?: AST.ParseOptions | undefined
       ): Effect.Effect<
-        never,
-        ParseResult.ParseError,
+        R1 | R2,
+        ParseResult.ParseIssue,
         AsyncDataFrom<E, A>
-      > =>
-        Effect.gen(function*(_) {
-          if (!isAsyncDataFrom(input)) {
-            return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+      > => {
+        return Effect.gen(function*(_) {
+          if (!isAsyncDataFrom<EI, AI>(input)) {
+            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(input)))
           }
 
           switch (input._tag) {
@@ -364,132 +363,115 @@ export const asyncDataFromJson = <EI, E, AI, A>(
             case "Loading":
               return input
             case "Failure": {
-              const cause = yield* _(parseCause(isDecoding ? input.cause : causeFromToCause(input.cause), options))
-              return FailureFrom(causeToCauseFrom(cause), input.timestamp, input.refreshing)
+              const cause = yield* _(parseCause(input.cause, options))
+              return FailureFrom(cause, input.timestamp, input.refreshing)
             }
             case "Success": {
               const a = yield* _(parseValue(input.value, options))
               return SuccessFrom(a, input.timestamp, input.refreshing)
             }
             case "Optimistic": {
-              const previous: AsyncDataFrom<any, any> = yield* _(parseAsyncData(input.previous, options))
+              const previous = yield* _(parseAsyncData(input.previous, options))
               const value = yield* _(parseValue(input.value, options))
+              return OptimisticFrom(value, input.timestamp, previous)
+            }
+          }
+        })
+      }
+
+      return parseAsyncData
+    },
+    (causeSchema, valueSchema) => {
+      const parseCause = Parser.encode(causeSchema)
+      const parseValue = Parser.encode(valueSchema)
+
+      const parseAsyncData = (
+        input: unknown,
+        options?: AST.ParseOptions
+      ): Effect.Effect<
+        R1 | R2,
+        ParseResult.ParseIssue,
+        AsyncDataFrom<EI, AI>
+      > => {
+        return Effect.gen(function*(_) {
+          if (!isAsyncDataFrom<E, A>(input)) {
+            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(input)))
+          }
 
+          switch (input._tag) {
+            case "NoData":
+            case "Loading":
+              return input
+            case "Failure": {
+              const cause = yield* _(parseCause(causeFromToCause(input.cause), options))
+              return FailureFrom(cause, input.timestamp, input.refreshing)
+            }
+            case "Success": {
+              const a = yield* _(parseValue(input.value, options))
+              return SuccessFrom(a, input.timestamp, input.refreshing)
+            }
+            case "Optimistic": {
+              const previous = yield* _(parseAsyncData(input.previous, options))
+              const value = yield* _(parseValue(input.value, options))
               return OptimisticFrom(value, input.timestamp, previous)
             }
           }
         })
+      }
 
       return parseAsyncData
     },
     {
-      [AST.IdentifierAnnotationId]: "AsyncDataFrom",
-      [Eq.EquivalenceHookId]: () => fromEq
+      title: "AsyncDataFrom",
+      equivalence: () => fromEq,
+      arbitrary: (causeArb, valueArb) => (fc) =>
+        asyncDataArbitrary(causeArb, valueArb)(fc).map(asyncDataToAsyncDataFrom),
+      pretty: (causePretty, valuePretty) => (from) =>
+        asyncDataPretty(causePretty, valuePretty)(asyncDataFromToAsyncData(from))
     }
   )
+}
 
 /**
  * @since 1.0.0
  */
-export const asyncData = <EI, E, AI, A>(
-  errorSchema: Schema.Schema<EI, E>,
-  valueSchema: Schema.Schema<AI, A>
-): Schema.Schema<AsyncDataFrom<EI, AI>, AsyncData.AsyncData<E, A>> => {
-  const encodeCause = Schema.encode(Schema.cause(Schema.to(errorSchema)))
-
+export const asyncData = <R1, EI, E, R2, AI, A>(
+  errorSchema: Schema.Schema<R1, EI, E>,
+  valueSchema: Schema.Schema<R2, AI, A>
+): Schema.Schema<R1 | R2, AsyncDataFrom<EI, AI>, AsyncData.AsyncData<E, A>> => {
   return asyncDataFromJson(errorSchema, valueSchema)
-    .pipe(Schema.transformOrFail(
+    .pipe(Schema.transform(
       asyncDataFromSelf(Schema.to(errorSchema), Schema.to(valueSchema)),
-      function decodeAsyncDataFrom(
-        c: AsyncDataFrom<E, A>,
-        options?: AST.ParseOptions
-      ): Effect.Effect<never, ParseResult.ParseError, AsyncData.AsyncData<E, A>> {
-        switch (c._tag) {
-          case "NoData":
-            return Effect.succeed(AsyncData.noData())
-          case "Loading":
-            return Effect.succeed(loadingFromJson(c)!)
-          case "Failure": {
-            console.log(causeFromToCause(c.cause))
-
-            return Effect.succeed(
-              AsyncData.failCause(causeFromToCause(c.cause), {
-                timestamp: c.timestamp,
-                refreshing: loadingFromJson(c.refreshing)
-              })
-            )
-          }
-          case "Success": {
-            return Effect.succeed(AsyncData.success(c.value, {
-              timestamp: c.timestamp,
-              refreshing: loadingFromJson(c.refreshing)
-            }))
-          }
-          case "Optimistic": {
-            return Effect.map(
-              decodeAsyncDataFrom(c.previous, options),
-              (previous) => AsyncData.optimistic(previous, c.value, { timestamp: c.timestamp })
-            )
-          }
-        }
-      },
-      function encodeAsyncDataFrom(
-        a: AsyncData.AsyncData<E, A>,
-        options?: AST.ParseOptions
-      ): Effect.Effect<never, ParseResult.ParseError, AsyncDataFrom<E, A>> {
-        switch (a._tag) {
-          case "NoData":
-            return Effect.succeed({ _tag: "NoData" })
-          case "Loading":
-            return Effect.succeed(loadingToJson(a))
-          case "Failure":
-            return Effect.map(
-              encodeCause(a.cause, options),
-              (cause) => FailureFrom(cause, a.timestamp, Option.getOrUndefined(Option.map(a.refreshing, loadingToJson)))
-            )
-          case "Success":
-            return Effect.succeed(
-              SuccessFrom(a.value, a.timestamp, Option.getOrUndefined(Option.map(a.refreshing, loadingToJson)))
-            )
-          case "Optimistic": {
-            return Effect.map(
-              encodeAsyncDataFrom(a.previous, options),
-              (previous) => OptimisticFrom(a.value, a.timestamp, previous)
-            )
-          }
-        }
-      }
+      asyncDataFromToAsyncData,
+      asyncDataToAsyncDataFrom
     ))
 }
 
 /**
  * @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>> => {
+export const asyncDataFromSelf = <R1, EI, E, R2, AI, A>(
+  error: Schema.Schema<R1, EI, E>,
+  value: Schema.Schema<R2, AI, A>
+): Schema.Schema<R1 | R2, AsyncData.AsyncData<EI, AI>, AsyncData.AsyncData<E, A>> => {
   return Schema.declare(
-    [Schema.cause(error), value],
-    Schema.struct({}),
-    (isDecoding, ...params) => {
-      const [causeSchema, valueSchema] = params as readonly [
-        Schema.Schema<Cause.Cause<any>, Cause.Cause<any>>,
-        Schema.Schema<any, any>
-      ]
-      const parseCause = isDecoding ? Schema.decode(causeSchema) : Schema.encode(causeSchema)
-      const parseValue = isDecoding ? Schema.decode(valueSchema) : Schema.encode(valueSchema)
+    [Schema.causeFromSelf(error), value],
+    (causeSchema, valueSchema) => {
+      const parseCause = Parser.decode(causeSchema)
+      const parseValue = Parser.decode(valueSchema)
 
       const parseAsyncData = (
         input: unknown,
         options?: AST.ParseOptions
       ): Effect.Effect<
-        never,
-        ParseResult.ParseError,
-        AsyncData.AsyncData<any, any>
+        R1 | R2,
+        ParseResult.ParseIssue,
+        AsyncData.AsyncData<E, A>
       > => {
         return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+          if (!AsyncData.isAsyncData<EI, AI>(input)) {
+            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(input)))
+          }
 
           switch (input._tag) {
             case "NoData":
@@ -498,7 +480,56 @@ export const asyncDataFromSelf = <EI, E, AI, A>(
             case "Failure": {
               const cause = yield* _(parseCause(input.cause, options))
 
-              return AsyncData.failCause(isDecoding ? cause : causeFromToCause(cause), {
+              return AsyncData.failCause(cause, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
+            }
+            case "Success": {
+              const a = yield* _(parseValue(input.value, options))
+
+              return AsyncData.success(a, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
+            }
+            case "Optimistic": {
+              const previous = yield* _(parseAsyncData(input.previous, options))
+              const value = yield* _(parseValue(input.value, options))
+
+              return AsyncData.optimistic(previous, value, {
+                timestamp: input.timestamp
+              })
+            }
+          }
+        })
+      }
+
+      return parseAsyncData
+    },
+    (causeSchema, valueSchema) => {
+      const parseCause = Parser.encode(causeSchema)
+      const parseValue = Parser.encode(valueSchema)
+
+      const parseAsyncData = (
+        input: unknown,
+        options?: AST.ParseOptions
+      ): Effect.Effect<
+        R1 | R2,
+        ParseResult.ParseIssue,
+        AsyncData.AsyncData<EI, AI>
+      > => {
+        return Effect.gen(function*(_) {
+          if (!AsyncData.isAsyncData<E, A>(input)) return yield* _(Effect.fail(ParseResult.forbidden(input)))
+
+          switch (input._tag) {
+            case "NoData":
+            case "Loading":
+              return input
+            case "Failure": {
+              const cause = yield* _(parseCause(input.cause, options))
+
+              return AsyncData.failCause(cause, {
                 timestamp: input.timestamp,
                 refreshing: Option.getOrUndefined(input.refreshing)
               })
@@ -526,10 +557,10 @@ export const asyncDataFromSelf = <EI, E, AI, A>(
       return parseAsyncData
     },
     {
-      [AST.IdentifierAnnotationId]: "AsyncData",
-      [Pretty.PrettyHookId]: asyncDataPretty,
-      [Arbitrary.ArbitraryHookId]: asyncDataArbitrary,
-      [Eq.EquivalenceHookId]: () => Equal.equals
+      title: "AsyncData",
+      pretty: asyncDataPretty,
+      arbitrary: asyncDataArbitrary,
+      equivalence: () => Equal.equals
     }
   )
 }
@@ -654,3 +685,51 @@ function fiberIdToFiberIdFrom(id: FiberId.FiberId): Schema.FiberIdFrom {
       return { _tag: "Composite", left: fiberIdToFiberIdFrom(id.left), right: fiberIdToFiberIdFrom(id.right) }
   }
 }
+
+const NO_DATA_FROM: NoDataFrom = { _tag: "NoData" } as const
+
+function asyncDataToAsyncDataFrom<E, A>(data: AsyncData.AsyncData<E, A>): AsyncDataFrom<E, A> {
+  switch (data._tag) {
+    case "NoData":
+      return NO_DATA_FROM
+    case "Loading":
+      return loadingToJson(data)
+    case "Failure":
+      return FailureFrom(
+        causeToCauseFrom(data.cause),
+        data.timestamp,
+        Option.getOrUndefined(Option.map(data.refreshing, loadingToJson))
+      )
+    case "Success":
+      return SuccessFrom(
+        data.value,
+        data.timestamp,
+        Option.getOrUndefined(Option.map(data.refreshing, loadingToJson))
+      )
+    case "Optimistic":
+      return OptimisticFrom(data.value, data.timestamp, asyncDataToAsyncDataFrom(data.previous))
+  }
+}
+
+function asyncDataFromToAsyncData<E, A>(data: AsyncDataFrom<E, A>): AsyncData.AsyncData<E, A> {
+  switch (data._tag) {
+    case "NoData":
+      return AsyncData.noData()
+    case "Loading":
+      return loadingFromJson(data)!
+    case "Failure":
+      return AsyncData.failCause(causeFromToCause(data.cause), {
+        timestamp: data.timestamp,
+        refreshing: loadingFromJson(data.refreshing)
+      })
+    case "Success":
+      return AsyncData.success(data.value, {
+        timestamp: data.timestamp,
+        refreshing: loadingFromJson(data.refreshing)
+      })
+    case "Optimistic":
+      return AsyncData.optimistic(asyncDataFromToAsyncData(data.previous), data.value, {
+        timestamp: data.timestamp
+      })
+  }
+}

package/src/internal/async-data.ts

@@ -30,12 +30,6 @@ export class FailureImpl<E> extends Effectable.Class<never, E, never> implements
 
     if (!isAsyncData(that) || that._tag !== FAILURE_TAG) return false
 
-    console.log(
-      Equal.equals(this.cause, that.cause),
-      this.timestamp === that.timestamp,
-      Equal.equals(this.refreshing, that.refreshing)
-    )
-
     return Equal.equals(this.cause, that.cause)
       && this.timestamp === that.timestamp
       && Equal.equals(this.refreshing, that.refreshing)