// Effect and effetch

import * as Schema from "effect/Schema";

export const API_BASE_URL = "https://dummyjson.com";

export const SessionUser = Schema.Struct({
  id: Schema.Finite,
  username: Schema.String,
  email: Schema.String,
  firstName: Schema.String,
});

/** The user, as Session kit's `user` option takes it. */
export const userSchema = Schema.toStandardSchemaV1(SessionUser);

export const SessionTokens = Schema.Struct({
  accessToken: Schema.String,
  refreshToken: Schema.String,
});

/** DummyJSON returns the user's fields beside the tokens. */
export const SignInResponse = Schema.Struct({
  ...SessionTokens.fields,
  ...SessionUser.fields,
});

export const ApiError = Schema.Struct({ message: Schema.String });

import * as Fetch from "@monarcode/effetch";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as HttpClient from "effect/http/HttpClient";

import { API_BASE_URL, SessionTokens } from "./backend.js";

// Not the app's API client: its session plugin waits for this refresh.
const makeRefreshClient = Fetch.make({ baseUrl: API_BASE_URL }).pipe(
  // No tracing headers, as for the API client in step 6.
  Effect.provideService(HttpClient.TracerPropagationEnabled, false),
);

/** New tokens. `null` signs out; a failure keeps the session for a retry. */
export const refreshSession = (refreshToken: string, signal: AbortSignal) =>
  Effect.runPromise(
    Effect.gen(function* () {
      const client = yield* makeRefreshClient;
      return yield* client.post("/auth/refresh", {
        body: { refreshToken },
        output: SessionTokens,
      });
    }).pipe(
      Effect.catchTag("HttpError", (error) =>
        error.status === 401 || error.status === 403
          ? Effect.succeed(null)
          : Effect.fail(error),
      ),
      Effect.provide(FetchHttpClient.layer),
    ),
    { signal },
  );

import { createAuth, webStorage } from "@monarcode/session-kit";

import { userSchema } from "./backend.js";
import { refreshSession } from "./refresh.js";

export const auth = createAuth({
  name: "app",
  user: userSchema,
  storage: webStorage(),
  refresh: ({ refreshToken, signal }) => refreshSession(refreshToken, signal),
});

declare module "@monarcode/session-kit" {
  interface Register {
    auth: typeof auth;
  }
}

import { Auth } from "@monarcode/session-kit/effect";

import { auth } from "./auth.js";

export const AuthLive = Auth.layer(auth);

import { Auth } from "@monarcode/session-kit/effect";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";

import { AuthLive } from "./layer.js";

export const greeting = Auth.sessionOption.pipe(
  Effect.map(
    Option.match({
      onNone: () => "Welcome",
      onSome: (session) => `Welcome back, ${session.user.firstName}`,
    }),
  ),
);

export const showGreeting = () =>
  Effect.runPromise(Effect.provide(greeting, AuthLive));

import * as Fetch from "@monarcode/effetch";
import { retry } from "@monarcode/effetch/plugins";
import { sessionBearer } from "@monarcode/session-kit/effetch";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as Layer from "effect/Layer";

import { API_BASE_URL, ApiError } from "./backend.js";

const make = Fetch.make({
  baseUrl: API_BASE_URL,
  defaultError: ApiError,
  plugins: [retry(), sessionBearer({ baseUrl: API_BASE_URL, optional: true })],
}).pipe(
  // Effect adds tracing headers to every request, which fail the preflight
  // of an API that doesn't allow them.
  Effect.provideService(HttpClient.TracerPropagationEnabled, false),
);

export class ApiClient extends Context.Service<
  ApiClient,
  Effect.Success<typeof make>
>()("ApiClient") {}

/** The API client, over whichever `Auth` is provided. */
export const ApiClientLive = Layer.effect(ApiClient, make);

import * as Effect from "effect/Effect";

import { ApiClient } from "./api.js";
import { SessionUser, SignInResponse } from "./backend.js";

export const currentUser = Effect.gen(function* () {
  const client = yield* ApiClient;
  return yield* client.get("/auth/me", { output: SessionUser });
});

export const login = (username: string, password: string) =>
  Effect.gen(function* () {
    const client = yield* ApiClient;
    return yield* client.post("/auth/login", {
      body: { username, password },
      output: SignInResponse,
      plugins: { sessionBearer: false },
    });
  });

import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";

import { ApiClientLive } from "./api.js";
import { AuthLive } from "./layer.js";

const AppLayer = ApiClientLive.pipe(
  Layer.provideMerge(AuthLive),
  Layer.provide(FetchHttpClient.layer),
);

/** One runtime for the app's lifetime. */
export const appRuntime = ManagedRuntime.make(AppLayer);
export type AppRuntime = typeof appRuntime;

import { Auth } from "@monarcode/session-kit/effect";
import * as Effect from "effect/Effect";

export const accountName = Auth.session.pipe(
  Effect.map((session) => session.user.firstName),
  Effect.catchTag("AuthFailure", (failure) =>
    failure.code === "UNAUTHENTICATED"
      ? Effect.succeed("Guest")
      : Effect.fail(failure),
  ),
);

import { Auth } from "@monarcode/session-kit/effect";

import { currentUser } from "./user.js";

export const reloadProfile = Auth.updateUser(currentUser);

import { Auth } from "@monarcode/session-kit/effect";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";

export const logStatus = Auth.changes.pipe(
  Stream.map((state) => state.status),
  Stream.changes,
  Stream.runForEach((status) => Effect.log(`Auth is ${status}`)),
);

import { QueryClient } from "@monarcode/effetch-query";
import { endpoints } from "@monarcode/effetch-query/effetch";
import type * as ManagedRuntime from "effect/ManagedRuntime";

import { ApiClient } from "./api.js";
import { ApiError } from "./backend.js";
import { appRuntime, type AppRuntime } from "./runtime.js";

declare module "@monarcode/effetch-query" {
  interface Register {
    readonly services: ManagedRuntime.ManagedRuntime.Services<AppRuntime>;
  }
}

export const api = endpoints(ApiClient, { defaultError: ApiError });

export const makeQueryClient = () => QueryClient.make({ runtime: appRuntime });

import type { ReactNode } from "react";

import { QueryProvider } from "@monarcode/effetch-query/react";
import { useAuth } from "@monarcode/session-kit/react";

import { makeQueryClient } from "./query.js";

export function Queries({ children }: { children: ReactNode }) {
  const account = useAuth((state) => state.sessionId ?? "signed-out");
  return (
    <QueryProvider make={makeQueryClient} resetKey={account}>
      {children}
    </QueryProvider>
  );
}

import * as Fetch from "@monarcode/effetch";
import { useMutation, useQuery } from "@monarcode/effetch-query/react";
import { useAuthClient } from "@monarcode/session-kit/react";
import * as Exit from "effect/Exit";
import * as AsyncResult from "effect/reactivity/AsyncResult";
import * as Schema from "effect/Schema";

import { SessionUser, SignInResponse } from "../backend.js";
import { api } from "../query.js";

const signInMutation = api.mutation(
  Fetch.endpoint("POST /auth/login", {
    input: Schema.Struct({ username: Schema.String, password: Schema.String }),
    output: SignInResponse,
  }),
  { plugins: { sessionBearer: false } },
);

const profileQuery = api.query(
  Fetch.endpoint("GET /auth/me", { output: SessionUser }),
);

export function SignInButton() {
  const auth = useAuthClient();
  const { result, run } = useMutation(signInMutation);

  async function signIn() {
    const exit = await run({
      // DummyJSON's documented test user.
      body: { username: "emilys", password: "emilyspass" },
    });
    // A failed request shows in `result`.
    if (Exit.isFailure(exit)) return;
    const { accessToken, refreshToken, ...user } = exit.value;
    await auth.signIn({ accessToken, refreshToken, user });
  }

  return (
    <button
      disabled={result.waiting}
      onClick={() => void signIn().catch(console.error)}
    >
      Sign in
    </button>
  );
}

export function Email() {
  const result = useQuery(profileQuery());
  return AsyncResult.match(result, {
    onInitial: () => <p>Loading…</p>,
    onFailure: () => <p>Couldn't load your profile.</p>,
    onSuccess: ({ value }) => <p>{value.email}</p>,
  });
}

import { createServerAuth } from "@monarcode/session-kit/server";

import { userSchema } from "../backend.js";
import { refreshSession } from "../refresh.js";

declare const secret: string; // from the environment

export const serverAuth = createServerAuth({
  name: "app",
  user: userSchema,
  secret,
  refresh: ({ refreshToken, signal }) => refreshSession(refreshToken, signal),
});

/** One request's session, as your framework's adapter gives it. */
export type ServerSession = ReturnType<typeof serverAuth.forRequest>;

import { Auth } from "@monarcode/session-kit/effect";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";

import { type ApiClient, ApiClientLive } from "../api.js";
import type { ServerSession } from "./auth.js";

/** Built once: what belongs to no user. */
const serverRuntime = ManagedRuntime.make(FetchHttpClient.layer);

/** Built per request: its session, and the API client that uses it. */
export const requestLayer = (session: ServerSession) =>
  ApiClientLive.pipe(Layer.provideMerge(Auth.layer(session)));

/** Runs `effect` with the request's `session`. */
export function runRequest<A, E>(
  session: ServerSession,
  effect: Effect.Effect<A, E, ApiClient | Auth>,
): Promise<A> {
  return serverRuntime.runPromise(
    Effect.provide(effect, requestLayer(session)),
  );
}

import { currentUser } from "../user.js";
import type { ServerSession } from "./auth.js";
import { runRequest } from "./run.js";

// TanStack Start: startAuth(serverAuth). React Router:
// routerAuth(serverAuth)(context). Next.js, from
// nextSession(serverAuth, { cookies, redirect }): await session.writable()
// in a Server Function, or await session.readOnly() in a Server Component.
export const profileFor = (session: ServerSession) =>
  runRequest(session, currentUser);

import { login } from "../user.js";
import type { ServerSession } from "./auth.js";
import { runRequest } from "./run.js";

export async function signIn(
  session: ServerSession,
  username: string,
  password: string,
) {
  const { accessToken, refreshToken, ...user } = await runRequest(
    session,
    login(username, password),
  );
  return session.signIn({ accessToken, refreshToken, user });
}

import { QueryClient } from "@monarcode/effetch-query";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";

import type { ServerSession } from "./auth.js";
import { requestLayer } from "./run.js";

export const queryClientFor = (session: ServerSession) =>
  QueryClient.make({
    layer: requestLayer(session).pipe(Layer.provide(FetchHttpClient.layer)),
  });