@typed/async-data 0.2.0 → 0.3.0

package/src/AsyncData.ts

@@ -6,12 +6,22 @@
  */
 
 import type { Effect } from "effect"
-import { Cause, Data, Equal, Equivalence, Exit, Option, Unify } from "effect"
+import * as Cause from "effect/Cause"
+import * as Data from "effect/Data"
+import * as Duration from "effect/Duration"
+import * as Either from "effect/Either"
+import * as Equal from "effect/Equal"
+import * as Equivalence from "effect/Equivalence"
+import * as Exit from "effect/Exit"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
+import * as Unify from "effect/Unify"
 import * as internal from "./internal/async-data.js"
 import { FAILURE_TAG, LOADING_TAG, NO_DATA_TAG, SUCCESS_TAG } from "./internal/tag.js"
 import * as Progress from "./Progress.js"
 
+const getCurrentTimestamp = () => Date.now()
+
 /**
  * AsyncData represents a piece of data which is acquired asynchronously with loading, failure, and progress states
  * in addition to Option-like states of NoData and Success.
@@ -107,6 +117,7 @@ export class Loading extends Data.TaggedError(LOADING_TAG)<LoadingOptions> {
  * @since 1.0.0
  */
 export type LoadingOptions = {
+  readonly timestamp: number // Date.now()
   readonly progress: Option.Option<Progress.Progress>
 }
 
@@ -125,6 +136,7 @@ export const loading: {
   <E, A>(options?: OptionalPartial<LoadingOptions>): AsyncData<E, A>
 } = (options?: OptionalPartial<LoadingOptions>): Loading =>
   new Loading({
+    timestamp: options?.timestamp ?? getCurrentTimestamp(),
     progress: Option.fromNullable(options?.progress)
   })
 
@@ -142,6 +154,11 @@ export interface Failure<E> extends Effect.Effect<never, E, never> {
    */
   readonly cause: Cause.Cause<E>
 
+  /**
+   * @since 1.20.0
+   */
+  readonly timestamp: number // Date.now()
+
   /**
    * @since 1.18.0
    */
@@ -167,6 +184,7 @@ export interface Failure<E> extends Effect.Effect<never, E, never> {
  * @since 1.0.0
  */
 export type FailureOptions = {
+  readonly timestamp: number // Date.now()
   readonly refreshing: Option.Option<Loading>
 }
 
@@ -179,6 +197,7 @@ export const failCause: {
 } = <E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): Failure<E> =>
   new internal.FailureImpl(
     cause,
+    options?.timestamp ?? getCurrentTimestamp(),
     Option.fromNullable(options?.refreshing)
   )
 
@@ -196,6 +215,10 @@ export const fail: {
 export interface Success<A> extends Effect.Effect<never, never, A> {
   readonly _tag: typeof SUCCESS_TAG
   readonly value: A
+  /**
+   * @since 1.20.0
+   */
+  readonly timestamp: number // Date.now()
   readonly refreshing: Option.Option<Loading>
 
   readonly [Unify.typeSymbol]: unknown
@@ -207,6 +230,7 @@ export interface Success<A> extends Effect.Effect<never, never, A> {
  * @since 1.0.0
  */
 export type SuccessOptions = {
+  readonly timestamp: number // Date.now()
   readonly refreshing: Option.Option<Loading>
 }
 
@@ -219,6 +243,7 @@ export const success: {
 } = <A>(value: A, options?: OptionalPartial<SuccessOptions>): Success<A> =>
   new internal.SuccessImpl(
     value,
+    options?.timestamp ?? getCurrentTimestamp(),
     Option.fromNullable(options?.refreshing)
   )
 
@@ -400,6 +425,7 @@ const optionProgressEq = Option.getEquivalence(Progress.equals)
 
 const loadingEquivalence: Equivalence.Equivalence<Loading> = Equivalence.struct({
   _tag: Equivalence.string,
+  timestamp: Equivalence.number,
   progress: optionProgressEq
 })
 
@@ -408,6 +434,7 @@ const optionLoadingEq = Option.getEquivalence(loadingEquivalence)
 const failureEquivalence: Equivalence.Equivalence<Failure<any>> = Equivalence.struct({
   _tag: Equivalence.string,
   cause: Equal.equals,
+  timestamp: Equivalence.number,
   refreshing: optionLoadingEq
 })
 
@@ -415,6 +442,7 @@ const successEquivalence = <A>(valueEq: Equivalence.Equivalence<A>): Equivalence
   Equivalence.struct({
     _tag: Equivalence.string,
     value: valueEq,
+    timestamp: Equivalence.number,
     refreshing: optionLoadingEq
   })
 
@@ -432,3 +460,73 @@ export const getEquivalence =
       Success: (_, s1) => isSuccess(b) ? successEquivalence(valueEq)(s1, b) : false
     })
   }
+
+/**
+ * @since 1.0.0
+ */
+export function fromExit<E, A>(exit: Exit.Exit<E, A>): AsyncData<E, A> {
+  return Exit.match(exit, {
+    onFailure: (cause) => failCause(cause),
+    onSuccess: (value) => success(value)
+  })
+}
+
+/**
+ * @since 1.0.0
+ */
+export function fromEither<E, A>(either: Either.Either<E, A>): AsyncData<E, A> {
+  return Either.match(either, {
+    onLeft: (e) => fail(e),
+    onRight: (a) => success(a)
+  })
+}
+
+const isAsyncDataFirst = (args: IArguments) => args.length === 3 || isAsyncData(args[0])
+
+/**
+ * @since 1.0.0
+ */
+export const isExpired: {
+  (ttl: Duration.DurationInput, now?: number): <E, A>(data: AsyncData<E, A>) => boolean
+  <E, A>(data: AsyncData<E, A>, ttl: Duration.DurationInput, now?: number): boolean
+} = dual(isAsyncDataFirst, function isExpired<E, A>(
+  data: AsyncData<E, A>,
+  ttl: Duration.DurationInput,
+  now: number = getCurrentTimestamp()
+): boolean {
+  return match(data, {
+    NoData: () => true,
+    Loading: () => false,
+    Failure: (_, f) =>
+      Option.isNone(f.refreshing)
+        ? isPastTTL(f.timestamp, ttl, now)
+        : isPastTTL(f.refreshing.value.timestamp, ttl, now),
+    Success: (_, s) =>
+      Option.isNone(s.refreshing)
+        ? isPastTTL(s.timestamp, ttl, now) :
+        isPastTTL(s.refreshing.value.timestamp, ttl, now)
+  })
+})
+
+function isPastTTL(timestamp: number, ttl: Duration.DurationInput, now: number): boolean {
+  const millis = Duration.toMillis(ttl)
+
+  return now - timestamp > millis
+}
+
+/**
+ * Checks if two AsyncData are equal, disregarding the timestamps associated with them. Useful for testing
+ * without needing to manage timestamps.
+ *
+ * @since 1.0.0
+ */
+export function dataEqual<E, A>(first: AsyncData<E, A>, second: AsyncData<E, A>): boolean {
+  return match(first, {
+    NoData: () => isNoData(second),
+    Loading: (l) => isLoading(second) && Equal.equals(l.progress, second.progress),
+    Failure: (_, f1) =>
+      isFailure(second) && Equal.equals(f1.cause, second.cause) && Equal.equals(f1.refreshing, second.refreshing),
+    Success: (_, s1) =>
+      isSuccess(second) && Equal.equals(s1.value, second.value) && Equal.equals(s1.refreshing, second.refreshing)
+  })
+}

package/src/Progress.ts

@@ -2,8 +2,9 @@
  * @since 1.0.0
  */
 
-import { Equivalence, Option } from "effect"
+import * as Equivalence from "effect/Equivalence"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 
 /**
  * @since 1.0.0

package/src/Schema.ts

@@ -8,86 +8,10 @@ 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 { Cause, Chunk, Effect, FiberId, HashSet } from "effect"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 
-const fiberIdArbitrary: Arbitrary.Arbitrary<FiberId.FiberId> = (fc) =>
-  fc.oneof(
-    fc.constant(FiberId.none),
-    fc.integer().chain((i) => fc.date().map((date) => FiberId.make(i, date.getTime() / 1000)))
-  )
-
-const causeFromItems = <A>(
-  items: Array<A>,
-  join: (first: Cause.Cause<A>, second: Cause.Cause<A>) => Cause.Cause<A>
-) => {
-  if (items.length === 0) return Cause.empty
-  if (items.length === 1) return Cause.fail(items[0])
-  return items.map(Cause.fail).reduce(join)
-}
-
-const causeArbitrary = <A>(item: Arbitrary.Arbitrary<A>): Arbitrary.Arbitrary<Cause.Cause<A>> => (fc) =>
-  fc.oneof(
-    fc.constant(Cause.empty),
-    fc.anything().map(Cause.die),
-    fiberIdArbitrary(fc).map((id) => Cause.interrupt(id)),
-    fc.array(item(fc)).chain((items) =>
-      fc.integer({ min: 0, max: 1 }).map((i) => causeFromItems(items, i > 0.5 ? Cause.sequential : Cause.parallel))
-    )
-  )
-
-const causePretty = <A>(): Pretty.Pretty<Cause.Cause<A>> => Cause.pretty
-
-/**
- * @since 1.0.0
- */
-export const cause = <EI, E>(error: Schema.Schema<EI, E>): Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>> => {
-  const parseE = Schema.parse(Schema.chunkFromSelf(error))
-
-  const self: Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>> = Schema.suspend(() =>
-    Schema.declare(
-      [error],
-      Schema.struct({}),
-      () => (input, options) =>
-        Effect.gen(function*(_) {
-          if (!Cause.isCause(input)) return yield* _(ParseResult.fail(ParseResult.unexpected(input)))
-
-          let output: Cause.Cause<E> = Cause.empty
-          for (const cause of Cause.linearize<E>(input)) {
-            const parrallelCauses = Cause.linearize(cause)
-
-            if (HashSet.size(parrallelCauses) === 1) {
-              const failures = Cause.failures(cause)
-
-              output = Cause.parallel(
-                output,
-                Chunk.isEmpty(failures) ? cause : Chunk.reduce(
-                  yield* _(parseE(failures, options)),
-                  Cause.empty as Cause.Cause<E>,
-                  (cause, e) => Cause.sequential(cause, Cause.fail(e))
-                )
-              )
-            } else {
-              output = Cause.parallel(
-                output,
-                yield* _(Schema.parse(self)(cause, options))
-              )
-            }
-          }
-
-          return output
-        }),
-      {
-        [AST.IdentifierAnnotationId]: "Cause",
-        [Arbitrary.ArbitraryHookId]: causePretty,
-        [Pretty.PrettyHookId]: causeArbitrary
-      }
-    )
-  )
-
-  return self
-}
-
 const asyncDataPretty = <E, A>(
   prettyCause: Pretty.Pretty<Cause.Cause<E>>,
   prettyValue: Pretty.Pretty<A>
@@ -121,7 +45,7 @@ export const asyncData = <EI, E, AI, A>(
   value: Schema.Schema<AI, A>
 ): Schema.Schema<AsyncData.AsyncData<EI, AI>, AsyncData.AsyncData<E, A>> => {
   return Schema.declare(
-    [cause(error), value],
+    [Schema.cause(error), value],
     Schema.struct({}),
     (_, ...params) => {
       const [causeSchema, valueSchema] = params as readonly [
@@ -133,7 +57,7 @@ export const asyncData = <EI, E, AI, A>(
 
       return (input, options) => {
         return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData<EI, AI>(input)) return yield* _(ParseResult.fail(ParseResult.unexpected(input)))
+          if (!AsyncData.isAsyncData<EI, AI>(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
 
           switch (input._tag) {
             case "NoData":

package/src/internal/async-data.ts

@@ -1,7 +1,13 @@
 // Internal
 
-import { Cause, Effect, Effectable, Equal, Hash, Option, pipe, Unify } from "effect"
-import { constant } from "effect/Function"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Effectable from "effect/Effectable"
+import * as Equal from "effect/Equal"
+import { constant, pipe } from "effect/Function"
+import * as Hash from "effect/Hash"
+import * as Option from "effect/Option"
+import * as Unify from "effect/Unify"
 import { type AsyncData, type Failure, type Loading, type Success } from "../AsyncData.js"
 import { FAILURE_TAG, LOADING_TAG, NO_DATA_TAG, SUCCESS_TAG } from "./tag.js"
 
@@ -14,7 +20,7 @@ export class FailureImpl<E> extends Effectable.Class<never, E, never> implements
   [Unify.unifySymbol]!: AsyncData.Unify<this>;
   [Unify.ignoreSymbol]!: AsyncData.IgnoreList
 
-  constructor(readonly cause: Cause.Cause<E>, readonly refreshing: Option.Option<Loading>) {
+  constructor(readonly cause: Cause.Cause<E>, readonly timestamp: number, readonly refreshing: Option.Option<Loading>) {
     super()
 
     this.commit = constant(Effect.failCause(cause))
@@ -23,6 +29,7 @@ export class FailureImpl<E> extends Effectable.Class<never, E, never> implements
   [Equal.symbol] = (that: unknown) => {
     return isAsyncData(that) && that._tag === "Failure"
       && Equal.equals(this.cause, that.cause)
+      && Equal.equals(this.timestamp, that.timestamp)
       && Equal.equals(this.refreshing, that.refreshing)
   };
 
@@ -44,7 +51,7 @@ export class SuccessImpl<A> extends Effectable.Class<never, never, A> implements
   [Unify.unifySymbol]!: AsyncData.Unify<this>;
   [Unify.ignoreSymbol]!: AsyncData.IgnoreList
 
-  constructor(readonly value: A, readonly refreshing: Option.Option<Loading>) {
+  constructor(readonly value: A, readonly timestamp: number, readonly refreshing: Option.Option<Loading>) {
     super()
 
     this.commit = constant(Effect.succeed(value))
@@ -53,6 +60,7 @@ export class SuccessImpl<A> extends Effectable.Class<never, never, A> implements
   [Equal.symbol] = (that: unknown) => {
     return isAsyncData(that) && that._tag === "Success"
       && Equal.equals(this.value, that.value)
+      && Equal.equals(this.timestamp, that.timestamp)
       && Equal.equals(this.refreshing, that.refreshing)
   };