@typed/async-data 0.13.1 → 1.0.0-beta.0

package/src/AsyncData.test.ts

@@ -1,89 +1,444 @@
-import { describe, expect, it } from '@effect/vitest'
-import { Cause, Effect, Exit, Schema, TestClock } from 'effect'
-import * as AsyncData from './index.js'
+// oxlint-disable require-yield
+import { assert, describe, it } from "vitest";
+import { Effect } from "effect";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as AsyncData from "./index.js";
 
-describe('AsyncData', () => {
-  describe('Effect', () => {
-    it.effect('NoData is a Failure', () =>
+describe("AsyncData", () => {
+  describe("constructors", () => {
+    it("NoData", () =>
       Effect.gen(function* () {
-        const noData = AsyncData.noData()
-        const exit = yield* Effect.exit(noData)
+        const data = AsyncData.NoData;
+        assert(AsyncData.isNoData(data));
+        assert(data._tag === "NoData");
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(exit).toEqual(Exit.fail(noData))
-      }),
-    )
+    it("loading without progress", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.loading();
+        assert(AsyncData.isLoading(data));
+        assert(data._tag === "Loading");
+        assert(data.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("loading with progress", () =>
+      Effect.gen(function* () {
+        const progress = { loaded: 50, total: 100 };
+        const data = AsyncData.loading(progress);
+        assert(AsyncData.isLoading(data));
+        assert(data.progress?.loaded === 50);
+        assert(data.progress?.total === 100);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("success without progress", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.success(42);
+        assert(AsyncData.isSuccess(data));
+        assert(data._tag === "Success");
+        assert(data.value === 42);
+        assert(data.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("success with progress", () =>
+      Effect.gen(function* () {
+        const progress = { loaded: 75, total: 100 };
+        const data = AsyncData.success(42, progress);
+        assert(AsyncData.isSuccess(data));
+        assert(data.value === 42);
+        assert(data.progress?.loaded === 75);
+        assert(data.progress?.total === 100);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("failure without progress", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const data = AsyncData.failure(cause);
+        assert(AsyncData.isFailure(data));
+        assert(data._tag === "Failure");
+        assert(data.cause === cause);
+        assert(data.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("failure with progress", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const progress = { loaded: 25 };
+        const data = AsyncData.failure(cause, progress);
+        assert(AsyncData.isFailure(data));
+        assert(data.progress?.loaded === 25);
+        assert(data.progress?.total === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("optimistic", () =>
+      Effect.gen(function* () {
+        const previous = AsyncData.success(10);
+        const data = AsyncData.optimistic(previous, 20);
+        assert(AsyncData.isOptimistic(data));
+        assert(data._tag === "Optimistic");
+        assert(data.value === 20);
+        assert(data.previous === previous);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
 
-    it.effect('Loading is a Failure', () =>
+  describe("type guards", () => {
+    it("isNoData", () =>
       Effect.gen(function* () {
-        const loading = AsyncData.loading()
-        const exit = yield* Effect.exit(loading)
+        assert(AsyncData.isNoData(AsyncData.NoData));
+        assert(!AsyncData.isNoData(AsyncData.loading()));
+        assert(!AsyncData.isNoData(AsyncData.success(1)));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(exit).toEqual(Exit.fail(loading))
-      }),
-    )
+    it("isLoading", () =>
+      Effect.gen(function* () {
+        assert(AsyncData.isLoading(AsyncData.loading()));
+        assert(!AsyncData.isLoading(AsyncData.NoData));
+        assert(!AsyncData.isLoading(AsyncData.success(1)));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-    it.effect('Failure is a Failure', () =>
+    it("isSuccess", () =>
       Effect.gen(function* () {
-        const cause = Cause.fail('test')
-        const failure = AsyncData.failure(cause)
-        const exit = yield* Effect.exit(failure)
+        assert(AsyncData.isSuccess(AsyncData.success(1)));
+        assert(!AsyncData.isSuccess(AsyncData.NoData));
+        assert(!AsyncData.isSuccess(AsyncData.loading()));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(exit).toEqual(Exit.failCause(cause))
-      }),
-    )
+    it("isFailure", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        assert(AsyncData.isFailure(AsyncData.failure(cause)));
+        assert(!AsyncData.isFailure(AsyncData.NoData));
+        assert(!AsyncData.isFailure(AsyncData.success(1)));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-    it.effect('Success is a Success', () =>
+    it("isOptimistic", () =>
       Effect.gen(function* () {
-        expect(yield* AsyncData.success(1)).toEqual(1)
-      }),
-    )
+        const previous = AsyncData.success(10);
+        const data = AsyncData.optimistic(previous, 20);
+        assert(AsyncData.isOptimistic(data));
+        assert(!AsyncData.isOptimistic(AsyncData.NoData));
+        assert(!AsyncData.isOptimistic(AsyncData.success(1)));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-    it.effect('Refreshing<Success> is a Success', () =>
+    it("isAsyncData", () =>
       Effect.gen(function* () {
-        expect(yield* AsyncData.refreshing(AsyncData.success(1))).toEqual(1)
-      }),
-    )
+        assert(AsyncData.isAsyncData(AsyncData.NoData));
+        assert(AsyncData.isAsyncData(AsyncData.loading()));
+        assert(AsyncData.isAsyncData(AsyncData.success(1)));
+        assert(AsyncData.isAsyncData(AsyncData.failure(Cause.fail("error"))));
+        assert(!AsyncData.isAsyncData(null));
+        assert(!AsyncData.isAsyncData({}));
+        assert(!AsyncData.isAsyncData({ _tag: "Invalid" }));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-    it.effect('Refreshing<Failure> is a Failure', () =>
+    it("isRefreshing", () =>
       Effect.gen(function* () {
-        const cause = Cause.fail('test')
-        const failure = AsyncData.failure(cause)
-        const exit = yield* Effect.exit(AsyncData.refreshing(failure))
+        const progress = { loaded: 50 };
+        const successWithProgress = AsyncData.success(1, progress);
+        const failureWithProgress = AsyncData.failure(Cause.fail("error"), progress);
+        assert(AsyncData.isRefreshing(successWithProgress));
+        assert(AsyncData.isRefreshing(failureWithProgress));
+        assert(!AsyncData.isRefreshing(AsyncData.success(1)));
+        assert(!AsyncData.isRefreshing(AsyncData.loading()));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(exit).toEqual(Exit.failCause(cause))
-      }),
-    )
+    it("isPending", () =>
+      Effect.gen(function* () {
+        assert(AsyncData.isPending(AsyncData.loading()));
+        const progress = { loaded: 50 };
+        assert(AsyncData.isPending(AsyncData.success(1, progress)));
+        assert(AsyncData.isPending(AsyncData.failure(Cause.fail("error"), progress)));
+        assert(!AsyncData.isPending(AsyncData.NoData));
+        assert(!AsyncData.isPending(AsyncData.success(1)));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
 
-    it.effect('Optimistic is a Success', () =>
+  describe("extractors", () => {
+    it("getSuccess", () =>
       Effect.gen(function* () {
-        expect(yield* AsyncData.optimistic(AsyncData.fail('not used'), 1)).toEqual(1)
-      }),
-    )
-  })
+        const successData = AsyncData.success(42);
+        const successOption = AsyncData.getSuccess(successData);
+        assert(Option.isSome(successOption));
+        assert(successOption.value === 42);
+        assert(Option.isNone(AsyncData.getSuccess(AsyncData.NoData)));
+        assert(Option.isNone(AsyncData.getSuccess(AsyncData.loading())));
+        const previous = AsyncData.success(10);
+        const optimistic = AsyncData.optimistic(previous, 20);
+        const optimisticOption = AsyncData.getSuccess(optimistic);
+        assert(Option.isSome(optimisticOption));
+        assert(optimisticOption.value === 20);
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-  describe('Schema + LazyRef', () => {
-    class Example extends AsyncData.AsyncData({
-      success: Schema.Number,
-      failure: Schema.String,
-    }) {}
+    it("getCause", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const failureData = AsyncData.failure(cause);
+        const causeOption = AsyncData.getCause(failureData);
+        assert(Option.isSome(causeOption));
+        assert(causeOption.value === cause);
+        assert(Option.isNone(AsyncData.getCause(AsyncData.NoData)));
+        assert(Option.isNone(AsyncData.getCause(AsyncData.loading())));
+        assert(Option.isNone(AsyncData.getCause(AsyncData.success(1))));
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-    it.scoped('keeps state', () =>
+    it("getError", () =>
       Effect.gen(function* () {
-        const example = yield* AsyncData.lazyRef(Example)
+        const error = "error";
+        const cause = Cause.fail(error);
+        const failureData = AsyncData.failure(cause);
+        const errorOption = AsyncData.getError(failureData);
+        assert(Option.isSome(errorOption));
+        assert(errorOption.value === error);
+        assert(Option.isNone(AsyncData.getError(AsyncData.NoData)));
+        assert(Option.isNone(AsyncData.getError(AsyncData.loading())));
+        assert(Option.isNone(AsyncData.getError(AsyncData.success(1))));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
 
-        // Simulate an async operation
-        yield* Effect.forkScoped(AsyncData.runEffect(example, Effect.delay(Effect.succeed(1), 500)))
+  describe("transformations", () => {
+    it("map", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.success(5);
+        const mapped = AsyncData.map(data, (n) => n * 2);
+        assert(AsyncData.isSuccess(mapped));
+        assert(mapped.value === 10);
+        const noData = AsyncData.NoData;
+        const mappedNoData = AsyncData.map(noData, (n: number) => n * 2);
+        assert(AsyncData.isNoData(mappedNoData));
+        const optimistic = AsyncData.optimistic(AsyncData.success(5), 10);
+        const mappedOptimistic = AsyncData.map(optimistic, (n) => n * 2);
+        assert(AsyncData.isOptimistic(mappedOptimistic));
+        assert(mappedOptimistic.value === 20);
+        assert(AsyncData.isSuccess(mappedOptimistic.previous));
+        assert(mappedOptimistic.previous.value === 10);
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(yield* example).toEqual(Example.noData())
+    it("map preserves progress", () =>
+      Effect.gen(function* () {
+        const progress = { loaded: 50, total: 100 };
+        const data = AsyncData.success(5, progress);
+        const mapped = AsyncData.map(data, (n) => n * 2);
+        assert(AsyncData.isSuccess(mapped));
+        assert(mapped.progress?.loaded === 50);
+        assert(mapped.progress?.total === 100);
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        yield* TestClock.adjust(1)
+    it("flatMap", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.success(5);
+        const flatMapped = AsyncData.flatMap(data, (n) => AsyncData.success(n * 2));
+        assert(AsyncData.isSuccess(flatMapped));
+        assert(flatMapped.value === 10);
+        const noData = AsyncData.NoData;
+        const flatMappedNoData = AsyncData.flatMap(noData, (n: number) => AsyncData.success(n * 2));
+        assert(AsyncData.isNoData(flatMappedNoData));
+        const optimistic = AsyncData.optimistic(AsyncData.success(5), 10);
+        const flatMappedOptimistic = AsyncData.flatMap(optimistic, (n) => AsyncData.success(n * 2));
+        assert(AsyncData.isSuccess(flatMappedOptimistic));
+        assert(flatMappedOptimistic.value === 20);
+        const optimisticToOptimistic = AsyncData.optimistic(AsyncData.success(5), 10);
+        const flatMappedOptimistic2 = AsyncData.flatMap(optimisticToOptimistic, (n, prev) =>
+          AsyncData.optimistic(prev, n * 2),
+        );
+        assert(AsyncData.isOptimistic(flatMappedOptimistic2));
+        assert(flatMappedOptimistic2.value === 20);
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(yield* example).toEqual(Example.loading())
+    it("mapError", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const data = AsyncData.failure(cause);
+        const mapped = AsyncData.mapError(data, (e) => `mapped: ${e}`);
+        assert(AsyncData.isFailure(mapped));
+        const error = Cause.findErrorOption(mapped.cause);
+        assert(Option.isSome(error));
+        assert(error.value === "mapped: error");
+        const noData = AsyncData.NoData;
+        const mappedNoData = AsyncData.mapError(noData, (e: string) => `mapped: ${e}`);
+        assert(AsyncData.isNoData(mappedNoData));
+        const optimistic = AsyncData.optimistic(AsyncData.failure(cause), 10);
+        const mappedOptimistic = AsyncData.mapError(optimistic, (e) => `mapped: ${e}`);
+        assert(AsyncData.isOptimistic(mappedOptimistic));
+        assert(AsyncData.isFailure(mappedOptimistic.previous));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("mapError preserves progress", () =>
+      Effect.gen(function* () {
+        const progress = { loaded: 50 };
+        const cause = Cause.fail("error");
+        const data = AsyncData.failure(cause, progress);
+        const mapped = AsyncData.mapError(data, (e) => `mapped: ${e}`);
+        assert(AsyncData.isFailure(mapped));
+        assert(mapped.progress?.loaded === 50);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
 
-        yield* TestClock.adjust(500)
+  describe("utilities", () => {
+    it("startLoading from NoData", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.NoData;
+        const started = AsyncData.startLoading(data);
+        assert(AsyncData.isLoading(started));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("startLoading from Success", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.success(42);
+        const progress = { loaded: 50 };
+        const started = AsyncData.startLoading(data, progress);
+        assert(AsyncData.isSuccess(started));
+        assert(started.value === 42);
+        assert(started.progress?.loaded === 50);
+      }).pipe(Effect.scoped, Effect.runPromise));
 
-        expect(yield* example).toEqual(Example.success(1))
-      }),
-    )
-  })
-})
+    it("startLoading from Failure", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const data = AsyncData.failure(cause);
+        const progress = { loaded: 50 };
+        const started = AsyncData.startLoading(data, progress);
+        assert(AsyncData.isFailure(started));
+        assert(started.cause === cause);
+        assert(started.progress?.loaded === 50);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("startLoading from Optimistic", () =>
+      Effect.gen(function* () {
+        const previous = AsyncData.success(10);
+        const data = AsyncData.optimistic(previous, 20);
+        const progress = { loaded: 50 };
+        const started = AsyncData.startLoading(data, progress);
+        assert(AsyncData.isOptimistic(started));
+        assert(started.value === 20);
+        assert(AsyncData.isSuccess(started.previous));
+        assert(started.previous.progress?.loaded === 50);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("stopLoading from Success with progress", () =>
+      Effect.gen(function* () {
+        const progress = { loaded: 50 };
+        const data = AsyncData.success(42, progress);
+        const stopped = AsyncData.stopLoading(data);
+        assert(AsyncData.isSuccess(stopped));
+        assert(stopped.value === 42);
+        assert(stopped.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("stopLoading from Failure with progress", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const progress = { loaded: 50 };
+        const data = AsyncData.failure(cause, progress);
+        const stopped = AsyncData.stopLoading(data);
+        assert(AsyncData.isFailure(stopped));
+        assert(stopped.cause === cause);
+        assert(stopped.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("stopLoading from Optimistic", () =>
+      Effect.gen(function* () {
+        const previous = AsyncData.success(10, { loaded: 50 });
+        const data = AsyncData.optimistic(previous, 20);
+        const stopped = AsyncData.stopLoading(data);
+        assert(AsyncData.isOptimistic(stopped));
+        assert(stopped.value === 20);
+        assert(AsyncData.isSuccess(stopped.previous));
+        assert(stopped.previous.progress === undefined);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("stopLoading from NoData", () =>
+      Effect.gen(function* () {
+        const data = AsyncData.NoData;
+        const stopped = AsyncData.stopLoading(data);
+        assert(AsyncData.isNoData(stopped));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("match", () =>
+      Effect.gen(function* () {
+        const noDataResult = AsyncData.match(AsyncData.NoData, {
+          NoData: () => "no-data",
+          Loading: () => "loading",
+          Failure: () => "failure",
+          Success: () => "success",
+          Optimistic: () => "optimistic",
+        });
+        assert(noDataResult === "no-data");
+
+        const loadingResult = AsyncData.match(AsyncData.loading(), {
+          NoData: () => "no-data",
+          Loading: () => "loading",
+          Failure: () => "failure",
+          Success: () => "success",
+          Optimistic: () => "optimistic",
+        });
+        assert(loadingResult === "loading");
+
+        const successResult = AsyncData.match(AsyncData.success(42), {
+          NoData: () => "no-data",
+          Loading: () => "loading",
+          Failure: () => "failure",
+          Success: (value) => `success-${value}`,
+          Optimistic: () => "optimistic",
+        });
+        assert(successResult === "success-42");
+
+        const cause = Cause.fail("error");
+        const failureResult = AsyncData.match(AsyncData.failure(cause), {
+          NoData: () => "no-data",
+          Loading: () => "loading",
+          Failure: (cause) =>
+            `failure-${Cause.findErrorOption(cause).pipe(Option.getOrElse(() => "unknown"))}`,
+          Success: () => "success",
+          Optimistic: () => "optimistic",
+        });
+        assert(failureResult === "failure-error");
+
+        const previous = AsyncData.success(10);
+        const optimisticResult = AsyncData.match(AsyncData.optimistic(previous, 20), {
+          NoData: () => "no-data",
+          Loading: () => "loading",
+          Failure: () => "failure",
+          Success: () => "success",
+          Optimistic: (value) => `optimistic-${value}`,
+        });
+        assert(optimisticResult === "optimistic-20");
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fromExit Success", () =>
+      Effect.gen(function* () {
+        const exit = Exit.succeed(42);
+        const data = AsyncData.fromExit(exit);
+        assert(AsyncData.isSuccess(data));
+        assert(data.value === 42);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fromExit Failure", () =>
+      Effect.gen(function* () {
+        const cause = Cause.fail("error");
+        const exit = Exit.failCause(cause);
+        const data = AsyncData.fromExit(exit);
+        assert(AsyncData.isFailure(data));
+        assert(data.cause === cause);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fromResult Success", () =>
+      Effect.gen(function* () {
+        const result = Result.succeed(42);
+        const data = AsyncData.fromResult(result);
+        assert(AsyncData.isSuccess(data));
+        assert(data.value === 42);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fromResult Failure", () =>
+      Effect.gen(function* () {
+        const result = Result.fail("error");
+        const data = AsyncData.fromResult(result);
+        assert(AsyncData.isFailure(data));
+        const error = Cause.findErrorOption(data.cause);
+        assert(Option.isSome(error));
+        assert(error.value === "error");
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+});