Create a Todo

import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Context from "effect/Context";
import { RefArray, RefSubject } from "@typed/fx";
import * as Domain from "./domain.js";

export class CreateTodo extends Context.Service<
  CreateTodo,
  (text: string) => Effect.Effect<Domain.Todo>
>()("CreateTodo") {
  static readonly call = (text: string) =>
    Effect.flatMap(CreateTodo, (createTodo) => createTodo(text));
}

export class TodoList extends RefSubject.Service<TodoList, Domain.TodoList>()("TodoList") {}

export class TodoText extends RefSubject.Service<TodoText, string>()("TodoText") {}

export const createTodo: Effect.Effect<
  Option.Option<Domain.Todo>,
  never,
  CreateTodo | TodoList | TodoText
> = Effect.flatMap(TodoText, (text: string) =>
  text.trim() === ""
    ? Effect.succeed(Option.none<Domain.Todo>())
    : CreateTodo.call(text).pipe(
        Effect.tap((todo) => RefArray.prepend(TodoList, todo)),
        Effect.tap(() => RefSubject.set(TodoText, "")),
        Effect.asSome,
      ),
);

import { DateTime, Effect, Exit, Layer } from "effect";
import { RefSubject } from "@typed/fx";
import { describe, expect, it } from "vitest";
import * as App from "./application.js";
import * as Domain from "./domain.js";

const timestamp = DateTime.makeUnsafe("2026-01-01T00:00:00Z");

const model = Layer.mergeAll(
  App.TodoList.make([]),
  App.TodoText.make(""),
);

describe("createTodo", () => {
  it("ignores blank drafts and commits the entered text before clearing the input", () => {
    // A blank draft must not reach the factory, even if it leaves the list unchanged.
    let calls = 0;
    const create = Layer.succeed(App.CreateTodo, (text) =>
      Effect.sync((): Domain.Todo => ({
        id: Domain.TodoId.make(`todo-${++calls}`),
        text,
        completed: false,
        timestamp,
      })),
    );

    return Effect.gen(function* () {
      yield* RefSubject.set(App.TodoText, "   ");
      yield* App.createTodo;

      expect(calls).toBe(0);
      expect(yield* App.TodoList).toEqual([]);
      expect(yield* App.TodoText).toBe("   ");

      yield* RefSubject.set(App.TodoText, "  Learn Typed  ");
      yield* App.createTodo;

      expect(calls).toBe(1);
      expect(yield* App.TodoList).toEqual([
        { id: Domain.TodoId.make("todo-1"), text: "  Learn Typed  ", completed: false, timestamp },
      ]);
      expect(yield* App.TodoText).toBe("");
    }).pipe(Effect.provide([model, create]), Effect.scoped, Effect.runPromise);
  });

  it("preserves the draft when the factory cannot create an item", () =>
    Effect.gen(function* () {
      yield* RefSubject.set(App.TodoText, "Keep this draft");

      const exit = yield* Effect.exit(App.createTodo);

      expect(Exit.isFailure(exit)).toBe(true);
      expect(yield* App.TodoList).toEqual([]);
      expect(yield* App.TodoText).toBe("Keep this draft");
    }).pipe(
      Effect.provide([
        model,
        Layer.succeed(App.CreateTodo, () => Effect.die("ID factory unavailable")),
      ]),
      Effect.scoped,
      Effect.runPromise,
    ));
});