sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Domain/ ExternalSystem.test.ts

import * as Domain from "@alchemy.run/domain";
import { describe, expect, it } from "@alchemy.run/test";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";

class RefundDeclined extends Domain.Rejection("RefundDeclined", { reason: Schema.String }) {}
class CardFrozen extends Domain.Rejection("CardFrozen") {}

class Payments extends Domain.ExternalSystem("Payments", {
  refund: {
    args: { settlementId: Schema.String, amount: Schema.Int },
    success: { refundId: Schema.String },
    error: RefundDeclined,
  },
  ping: {},
}) {}

/** An adapter whose answers the test picks, to break each side of the schema. */
const adapter = (answer: (args: { settlementId: string; amount: number }) => unknown) => {
  const seen: Array<unknown> = [];
  const layer = Payments.toLayer(
    Effect.succeed({
      refund: (args) => {
        seen.push(args);
        return answer(args) as never;
      },
      ping: () => Effect.succeed("pong" as unknown as void),
    }),
  );
  return { seen, layer };
};

const refund = (args: unknown) =>
  Effect.gen(function* () {
    const payments = yield* Payments;
    return yield* payments.refund(args as never);
  });

const defectOf = <A, E>(exit: Exit.Exit<A, E>) =>
  Exit.isFailure(exit) ? Cause.squash(exit.cause) : undefined;

describe("Domain ExternalSystem", { tags: ["unit", "local"] }, () => {
  it.effect("passes valid arguments to the adapter and returns its answer", () =>
    Effect.gen(function* () {
      const { seen, layer } = adapter(({ settlementId }) =>
        Effect.succeed({ refundId: `re_${settlementId}` }),
      );
      const result = yield* refund({ settlementId: "st_1", amount: 500 }).pipe(
        Effect.provide(layer),
      );
      expect(result).toEqual({ refundId: "re_st_1" });
      expect(seen).toEqual([{ settlementId: "st_1", amount: 500 }]);
    }),
  );

  it.effect("keeps a declared error a typed failure", () =>
    Effect.gen(function* () {
      const { layer } = adapter(() => Effect.fail(new RefundDeclined({ reason: "card-closed" })));
      const error = yield* refund({ settlementId: "st_1", amount: 500 }).pipe(
        Effect.flip,
        Effect.provide(layer),
      );
      expect(error).toEqual(new RefundDeclined({ reason: "card-closed" }));
    }),
  );

  it.effect("arguments the schema rejects die before the adapter runs", () =>
    Effect.gen(function* () {
      const { seen, layer } = adapter(() => Effect.succeed({ refundId: "re_1" }));
      const exit = yield* refund({ settlementId: "st_1", amount: 1.5 }).pipe(
        Effect.exit,
        Effect.provide(layer),
      );
      const defect = defectOf(exit);
      expect(defect).toMatchObject({
        _tag: "ExternalSystemSchemaError",
        system: "Payments",
        op: "refund",
        part: "args",
      });
      expect(String((defect as Error).message)).toMatch(
        /^Payments\.refund was called with arguments its schema rejects\n.*amount/s,
      );
      expect(seen).toEqual([]);
    }),
  );

  it.effect("a value the success schema rejects dies", () =>
    Effect.gen(function* () {
      const { layer } = adapter(() => Effect.succeed({ refundId: 42 }));
      const exit = yield* refund({ settlementId: "st_1", amount: 500 }).pipe(
        Effect.exit,
        Effect.provide(layer),
      );
      expect(defectOf(exit)).toMatchObject({ system: "Payments", op: "refund", part: "success" });
      expect(String((defectOf(exit) as Error).message)).toMatch(
        /^Payments\.refund returned a value its success schema rejects\n.*refundId/s,
      );
    }),
  );

  it.effect("an error the operation does not declare dies", () =>
    Effect.gen(function* () {
      const { layer } = adapter(() => Effect.fail(new CardFrozen()));
      const exit = yield* refund({ settlementId: "st_1", amount: 500 }).pipe(
        Effect.exit,
        Effect.provide(layer),
      );
      expect(defectOf(exit)).toMatchObject({ system: "Payments", op: "refund", part: "error" });
      expect(String((defectOf(exit) as Error).message)).toMatch(
        /^Payments\.refund failed with an error its error schema rejects\n/,
      );
    }),
  );

  it.effect("keeps every error of a declared list a typed failure", () =>
    Effect.gen(function* () {
      class Cards extends Domain.ExternalSystem("Cards", {
        charge: { args: { amount: Schema.Int }, error: [RefundDeclined, CardFrozen] },
      }) {}
      const layer = Cards.toLayer(
        Effect.succeed({
          charge: ({ amount }) =>
            amount > 100
              ? Effect.fail(new CardFrozen())
              : Effect.fail(new RefundDeclined({ reason: "low" })),
        }),
      );
      const charge = (amount: number) =>
        Effect.gen(function* () {
          const cards = yield* Cards;
          return yield* cards.charge({ amount });
        }).pipe(Effect.flip, Effect.provide(layer));
      expect(yield* charge(500)).toEqual(new CardFrozen());
      expect(yield* charge(5)).toEqual(new RefundDeclined({ reason: "low" }));
    }),
  );

  it.effect("drops fields the success schema does not declare", () =>
    Effect.gen(function* () {
      const { layer } = adapter(() => Effect.succeed({ refundId: "re_1", raw: { vendor: "x" } }));
      const result = yield* refund({ settlementId: "st_1", amount: 500 }).pipe(
        Effect.provide(layer),
      );
      expect(result).toEqual({ refundId: "re_1" });
    }),
  );

  it.effect("leaves the value of an operation without a success schema alone", () =>
    Effect.gen(function* () {
      const { layer } = adapter(() => Effect.succeed({ refundId: "re_1" }));
      const result = yield* Effect.gen(function* () {
        const payments = yield* Payments;
        return yield* payments.ping();
      }).pipe(Effect.provide(layer));
      expect(result).toBe("pong");
    }),
  );

  it.effect("validate: false skips every check", () =>
    Effect.gen(function* () {
      const layer = Payments.toLayer(
        Effect.succeed({
          refund: () => Effect.succeed({ refundId: 42 } as never),
          ping: () => Effect.void,
        }),
        { validate: false },
      );
      const result = yield* refund({ settlementId: "st_1", amount: 1.5 }).pipe(
        Effect.provide(layer),
      );
      expect(result).toEqual({ refundId: 42 });
    }),
  );

  it.effect("refuses an operation named after a static of the class", () =>
    Effect.gen(function* () {
      class Clash extends Domain.ExternalSystem("Clash", {
        // @ts-expect-error toLayer is the class's own static
        toLayer: {},
      }) {}
      const exit = yield* Effect.exit(
        Layer.build(Clash.toLayer(Effect.succeed({} as never))).pipe(Effect.scoped),
      );
      expect(defectOf(exit)).toMatchObject({
        _tag: "DefinitionError",
        reason: { _tag: "ReservedOperation", system: "Clash", operation: "toLayer" },
      });
    }),
  );
});