@carlonicora/nextjs-jsonapi 6.21.0 → 6.23.0

package/src/client/JsonApiClient.ts

@@ -93,6 +93,7 @@ export async function ClientJsonApiGet(params: {
   companyId?: string;
   language: string;
   baseUrl?: string;
+  credentials?: RequestCredentials;
 }): Promise<ApiResponseInterface> {
   runClientBootstrapper();
   const token = await getClientToken();
@@ -104,6 +105,7 @@ export async function ClientJsonApiGet(params: {
     companyId: params.companyId,
     language: params.language,
     additionalHeaders: _clientConfig?.additionalHeaders,
+    credentials: params.credentials,
   });
 
   return translateResponse({
@@ -132,6 +134,7 @@ export async function ClientJsonApiPost(params: {
   language: string;
   responseType?: ApiRequestDataTypeInterface;
   baseUrl?: string;
+  credentials?: RequestCredentials;
 }): Promise<ApiResponseInterface> {
   runClientBootstrapper();
   const token = await getClientToken();
@@ -152,6 +155,7 @@ export async function ClientJsonApiPost(params: {
     companyId: params.companyId,
     language: params.language,
     additionalHeaders: _clientConfig?.additionalHeaders,
+    credentials: params.credentials,
   });
 
   return translateResponse({
@@ -171,6 +175,7 @@ export async function ClientJsonApiPut(params: {
   language: string;
   responseType?: ApiRequestDataTypeInterface;
   baseUrl?: string;
+  credentials?: RequestCredentials;
 }): Promise<ApiResponseInterface> {
   runClientBootstrapper();
   const token = await getClientToken();
@@ -191,6 +196,7 @@ export async function ClientJsonApiPut(params: {
     companyId: params.companyId,
     language: params.language,
     additionalHeaders: _clientConfig?.additionalHeaders,
+    credentials: params.credentials,
   });
 
   return translateResponse({
@@ -211,6 +217,7 @@ export async function ClientJsonApiPatch(params: {
   responseType?: ApiRequestDataTypeInterface;
   language: string;
   baseUrl?: string;
+  credentials?: RequestCredentials;
 }): Promise<ApiResponseInterface> {
   runClientBootstrapper();
   const token = await getClientToken();
@@ -231,6 +238,7 @@ export async function ClientJsonApiPatch(params: {
     companyId: params.companyId,
     language: params.language,
     additionalHeaders: _clientConfig?.additionalHeaders,
+    credentials: params.credentials,
   });
 
   return translateResponse({
@@ -248,6 +256,7 @@ export async function ClientJsonApiDelete(params: {
   language: string;
   responseType?: ApiRequestDataTypeInterface;
   baseUrl?: string;
+  credentials?: RequestCredentials;
 }): Promise<ApiResponseInterface> {
   runClientBootstrapper();
   const token = await getClientToken();
@@ -259,6 +268,7 @@ export async function ClientJsonApiDelete(params: {
     companyId: params.companyId,
     language: params.language,
     additionalHeaders: _clientConfig?.additionalHeaders,
+    credentials: params.credentials,
   });
 
   return translateResponse({

package/src/client/__tests__/request.credentials.spec.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { AbstractService, HttpMethod } from "../../core/abstracts/AbstractService";
+import { ClientAbstractService, ClientHttpMethod } from "../../core/abstracts/ClientAbstractService";
+import { ApiRequestDataTypeInterface } from "../../core/interfaces/ApiRequestDataTypeInterface";
+import { ModuleRegistry } from "../../core/registry/ModuleRegistry";
+import { DiscordConnectIntent } from "../../features/discord-connection/data/discord-connect-intent";
+import { directFetch } from "../request";
+
+const TYPE = { name: "tests" } as any;
+const ENDPOINT = "http://api.test/tests";
+// Built by a model method, as references/frontend/03-services.md allows with overridesJsonApiCreation.
+const body = () => new DiscordConnectIntent().createJsonApi({ id: "t-1", returnPath: "/" });
+
+// createJsonApi() resolves Modules.X through the real ModuleRegistry,
+// which is shared across test files in a worker: register only when absent.
+const registerIfAbsent = (key: string, module: ApiRequestDataTypeInterface) => {
+  try {
+    ModuleRegistry.get(key as any);
+  } catch {
+    ModuleRegistry.register(key, module);
+  }
+};
+
+beforeAll(() => {
+  registerIfAbsent("DiscordConnectIntent", { name: "discord-connect-intents", model: DiscordConnectIntent } as any);
+});
+
+class TestService extends AbstractService {
+  static post(credentials?: RequestCredentials) {
+    return this.callApi({
+      type: TYPE,
+      method: HttpMethod.POST,
+      endpoint: ENDPOINT,
+      input: body(),
+      overridesJsonApiCreation: true,
+      suppressGlobalError: true,
+      ...(credentials ? { credentials } : {}),
+    });
+  }
+}
+
+class TestClientService extends ClientAbstractService {
+  static post(credentials?: RequestCredentials) {
+    return this.callApi({
+      type: TYPE,
+      method: ClientHttpMethod.POST,
+      endpoint: ENDPOINT,
+      input: body(),
+      overridesJsonApiCreation: true,
+      ...(credentials ? { credentials } : {}),
+    });
+  }
+}
+
+const fetchOptions = (fetchMock: ReturnType<typeof vi.fn>): RequestInit => fetchMock.mock.calls[0][1] as RequestInit;
+
+describe("callApi credentials", () => {
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    // A 500 keeps the response path out of the test: only the fetch options matter.
+    fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({}), { status: 500 }));
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("callApi passes credentials to fetch", async () => {
+    await TestService.post("include").catch(() => undefined);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchOptions(fetchMock).credentials).toBe("include");
+  });
+
+  it("callApi without credentials leaves fetch options unchanged", async () => {
+    await TestService.post().catch(() => undefined);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(Object.keys(fetchOptions(fetchMock)).sort()).toEqual(["body", "headers", "method"]);
+  });
+
+  it("ClientAbstractService callApi passes credentials to fetch", async () => {
+    await TestClientService.post("include").catch(() => undefined);
+
+    expect(fetchOptions(fetchMock).credentials).toBe("include");
+  });
+
+  it("ClientAbstractService callApi without credentials leaves fetch options unchanged", async () => {
+    await TestClientService.post().catch(() => undefined);
+
+    expect(Object.keys(fetchOptions(fetchMock)).sort()).toEqual(["body", "headers", "method"]);
+  });
+
+  it("directFetch sets credentials only when given", async () => {
+    await directFetch({ method: "GET", url: ENDPOINT, language: "en", credentials: "include" });
+    await directFetch({ method: "GET", url: ENDPOINT, language: "en" });
+
+    expect((fetchMock.mock.calls[0][1] as RequestInit).credentials).toBe("include");
+    expect("credentials" in (fetchMock.mock.calls[1][1] as RequestInit)).toBe(false);
+  });
+});

package/src/client/request.ts

@@ -14,6 +14,11 @@ export interface DirectFetchParams {
   companyId?: string;
   language: string;
   additionalHeaders?: Record<string, string>;
+  /**
+   * Optional `fetch` credentials mode (e.g. "include" so the browser stores a cookie the API sets).
+   * Omitted => no `credentials` option is passed, unchanged behaviour.
+   */
+  credentials?: RequestCredentials;
 }
 
 /**
@@ -108,6 +113,10 @@ async function fetchFromApi(params: DirectFetchParams): Promise<ApiData> {
     options.body = requestBody;
   }
 
+  if (params.credentials) {
+    options.credentials = params.credentials;
+  }
+
   if (params.token) {
     options.headers = { ...options.headers, Authorization: `Bearer ${params.token}` };
   }

package/src/components/forms/EditorSheet.tsx

@@ -320,8 +320,8 @@ export function EditorSheet<T extends FieldValues>({
                     render={<div />}
                     nativeButton={false}
                     size="sm"
-                    variant={isLabelled ? "outline" : "ghost"}
-                    className="text-muted-foreground"
+                    variant={isLabelled ? "default" : "ghost"}
+                    className={isLabelled ? undefined : "text-muted-foreground"}
                   >
                     <PencilIcon />
                     {isLabelled && t("ui.buttons.edit")}

package/src/components/forms/__tests__/EditorSheet.spec.tsx

@@ -77,6 +77,22 @@ describe("EditorSheet", () => {
       expect(screen.getByText("Custom")).toBeTruthy();
     });
 
+    it("should render a labelled edit trigger as a primary button", () => {
+      render(<TestEditor isEdit={true} showLabel={true} />);
+      const trigger = document.querySelector('[data-help="editor.edit"]');
+      expect(trigger?.textContent).toContain("ui.buttons.edit");
+      expect(trigger?.className).toContain("bg-primary");
+      expect(trigger?.className).not.toContain("text-muted-foreground");
+    });
+
+    it("should render an unlabelled edit trigger as a muted glyph", () => {
+      render(<TestEditor isEdit={true} showLabel={false} />);
+      const trigger = document.querySelector('[data-help="editor.edit"]');
+      expect(trigger?.textContent).not.toContain("ui.buttons.edit");
+      expect(trigger?.className).not.toContain("bg-primary");
+      expect(trigger?.className).toContain("text-muted-foreground");
+    });
+
     it("should not render trigger when dialogOpen is controlled", () => {
       render(<TestEditor dialogOpen={false} />);
       expect(screen.queryByText("ui.buttons.create")).toBeNull();

package/src/core/abstracts/AbstractService.ts

@@ -143,6 +143,11 @@ export abstract class AbstractService {
      * fully backward compatible. Ignored when `endpoint` starts with "http" (passthrough).
      */
     baseUrl?: string;
+    /**
+     * Optional browser `fetch` credentials mode, e.g. "include" so the browser stores a
+     * cookie the API sets. Omitted => no `credentials` option is passed (unchanged).
+     */
+    credentials?: RequestCredentials;
   }): Promise<T> {
     // Dynamic import to avoid bundling issues
     const { JsonApiGet, JsonApiPost, JsonApiPut, JsonApiPatch, JsonApiDelete } =
@@ -168,6 +173,7 @@ export abstract class AbstractService {
           language: language,
           token: params.token,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case HttpMethod.POST:
@@ -182,6 +188,7 @@ export abstract class AbstractService {
           files: params.files,
           token: params.token,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case HttpMethod.PUT:
@@ -195,6 +202,7 @@ export abstract class AbstractService {
           files: params.files,
           token: params.token,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case HttpMethod.PATCH:
@@ -209,6 +217,7 @@ export abstract class AbstractService {
           files: params.files,
           token: params.token,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case HttpMethod.DELETE:
@@ -220,6 +229,7 @@ export abstract class AbstractService {
           responseType: params.responseType,
           token: params.token,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       default:

package/src/core/abstracts/ClientAbstractService.ts

@@ -148,6 +148,11 @@ export abstract class ClientAbstractService {
      * Omitted => existing global `NEXT_PUBLIC_API_URL` resolution, unchanged.
      */
     baseUrl?: string;
+    /**
+     * Optional browser `fetch` credentials mode, e.g. "include" so the browser stores a
+     * cookie the API sets. Omitted => no `credentials` option is passed (unchanged).
+     */
+    credentials?: RequestCredentials;
   }): Promise<T> {
     let apiResponse: ApiResponseInterface;
 
@@ -162,6 +167,7 @@ export abstract class ClientAbstractService {
           companyId: params.companyId,
           language: language,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case ClientHttpMethod.POST:
@@ -175,6 +181,7 @@ export abstract class ClientAbstractService {
           responseType: params.responseType,
           files: params.files,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case ClientHttpMethod.PUT:
@@ -187,6 +194,7 @@ export abstract class ClientAbstractService {
           responseType: params.responseType,
           files: params.files,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case ClientHttpMethod.PATCH:
@@ -200,6 +208,7 @@ export abstract class ClientAbstractService {
           responseType: params.responseType,
           files: params.files,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       case ClientHttpMethod.DELETE:
@@ -210,6 +219,7 @@ export abstract class ClientAbstractService {
           language: language,
           responseType: params.responseType,
           baseUrl: params.baseUrl,
+          credentials: params.credentials,
         });
         break;
       default:

package/src/core/index.ts

@@ -35,6 +35,9 @@ export * from "../permissions";
 export * from "../features/account-deletion/account-deletion.module";
 export * from "../features/account-deletion/data";
 export * from "../features/account-deletion/utils";
+// Discord connect (opt-in): data and modules. No components ship from the library.
+export * from "../features/discord-connection/discord-connection.module";
+export * from "../features/discord-connection/data";
 export * from "../features/auth/auth.module";
 export * from "../features/auth/totp-authenticator.module";
 export * from "../features/auth/totp-setup.module";

package/src/core/registry/ModuleRegistry.ts

@@ -109,6 +109,10 @@ export interface FoundationModuleDefinitions {
   AnalyticsPageView: ModuleWithPermissions;
   // Account deletion (opt-in: registered only by apps that enable it)
   AccountDeletion: ModuleWithPermissions;
+  // Discord connect (registered by apps that offer it)
+  DiscordConnection: ModuleWithPermissions;
+  DiscordConnectIntent: ModuleWithPermissions;
+  DiscordConnectConfirmation: ModuleWithPermissions;
   // Offline mode (opt-in: registered by apps that spread offlineModules)
   OfflineChangeSet: ModuleWithPermissions;
   RootSync: ModuleWithPermissions;

package/src/features/discord-connection/data/__tests__/DiscordConnection.spec.ts

@@ -0,0 +1,114 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ApiRequestDataTypeInterface } from "../../../../core/interfaces/ApiRequestDataTypeInterface";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { DiscordConnectConfirmation } from "../discord-connect-confirmation";
+import { DiscordConnectIntent } from "../discord-connect-intent";
+import { DiscordConnection } from "../discord-connection";
+
+// createJsonApi() resolves Modules.X through the real ModuleRegistry,
+// which is shared across test files in a worker: register only when absent.
+const registerIfAbsent = (key: string, module: ApiRequestDataTypeInterface) => {
+  try {
+    ModuleRegistry.get(key as any);
+  } catch {
+    ModuleRegistry.register(key, module);
+  }
+};
+
+beforeAll(() => {
+  registerIfAbsent("DiscordConnection", { name: "discord-connections", model: DiscordConnection } as any);
+  registerIfAbsent("DiscordConnectIntent", { name: "discord-connect-intents", model: DiscordConnectIntent } as any);
+  registerIfAbsent("DiscordConnectConfirmation", {
+    name: "discord-connect-confirmations",
+    model: DiscordConnectConfirmation,
+  } as any);
+});
+
+describe("DiscordConnection", () => {
+  it("rehydrates connected and discordName", () => {
+    const model = new DiscordConnection().rehydrate({
+      jsonApi: { type: "discord-connections", id: "u-1", attributes: { connected: true, discordName: "carlo" } },
+      included: [],
+    } as any);
+
+    expect(model.id).toBe("u-1");
+    expect(model.connected).toBe(true);
+    expect(model.discordName).toBe("carlo");
+  });
+
+  it("defaults connected to false and discordName to undefined", () => {
+    const model = new DiscordConnection().rehydrate({
+      jsonApi: { type: "discord-connections", id: "u-1", attributes: {} },
+      included: [],
+    } as any);
+
+    expect(model.connected).toBe(false);
+    expect(model.discordName).toBeUndefined();
+  });
+
+  it("DiscordConnection createJsonApi has the canonical shape", () => {
+    expect(new DiscordConnection().createJsonApi({ id: "u-1" })).toEqual({
+      data: { type: "discord-connections", id: "u-1", attributes: {}, relationships: {} },
+      included: [],
+    });
+  });
+});
+
+describe("DiscordConnectIntent", () => {
+  it("rehydrates the intent returnPath and authorizeUrl", () => {
+    const model = new DiscordConnectIntent().rehydrate({
+      jsonApi: {
+        type: "discord-connect-intents",
+        id: "i-1",
+        attributes: {
+          returnPath: "/settings",
+          authorizeUrl: "http://api.test/discord-connect-intents/i-1/authorize",
+        },
+      },
+      included: [],
+    } as any);
+
+    expect(model.returnPath).toBe("/settings");
+    expect(model.authorizeUrl).toBe("http://api.test/discord-connect-intents/i-1/authorize");
+  });
+
+  it("DiscordConnectIntent createJsonApi sends the returnPath", () => {
+    expect(new DiscordConnectIntent().createJsonApi({ id: "i-1", returnPath: "/settings" })).toEqual({
+      data: { type: "discord-connect-intents", id: "i-1", attributes: { returnPath: "/settings" }, relationships: {} },
+      included: [],
+    });
+  });
+});
+
+describe("DiscordConnectConfirmation", () => {
+  it("DiscordConnectConfirmation createJsonApi identifies the token", () => {
+    expect(new DiscordConnectConfirmation().createJsonApi({ id: "t-1" })).toEqual({
+      data: { type: "discord-connect-confirmations", id: "t-1", attributes: {}, relationships: {} },
+      included: [],
+    });
+  });
+
+  it("rehydrates result and discordName", () => {
+    const model = new DiscordConnectConfirmation().rehydrate({
+      jsonApi: {
+        type: "discord-connect-confirmations",
+        id: "t-1",
+        attributes: { result: "connected", discordName: "carlo" },
+      },
+      included: [],
+    } as any);
+
+    expect(model.result).toBe("connected");
+    expect(model.discordName).toBe("carlo");
+  });
+
+  it("defaults a missing result to failed", () => {
+    const model = new DiscordConnectConfirmation().rehydrate({
+      jsonApi: { type: "discord-connect-confirmations", id: "t-1", attributes: {} },
+      included: [],
+    } as any);
+
+    expect(model.result).toBe("failed");
+    expect(model.discordName).toBeUndefined();
+  });
+});

package/src/features/discord-connection/data/discord-connect-confirmation.interface.ts

@@ -0,0 +1,16 @@
+import { ApiDataInterface } from "../../../core";
+
+export type DiscordConnectResult = "connected" | "taken" | "already" | "failed";
+
+/**
+ * The outcome of confirming a Connect Discord return. `result` defaults to "failed".
+ */
+export interface DiscordConnectConfirmationInterface extends ApiDataInterface {
+  get result(): DiscordConnectResult;
+  get discordName(): string | undefined;
+}
+
+export type DiscordConnectConfirmationInput = {
+  /** The confirmation token from the `discordConnectConfirm` return parameter. */
+  id: string;
+};

package/src/features/discord-connection/data/discord-connect-confirmation.service.ts

@@ -0,0 +1,21 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import {
+  DiscordConnectConfirmationInput,
+  DiscordConnectConfirmationInterface,
+} from "./discord-connect-confirmation.interface";
+
+export class DiscordConnectConfirmationService extends AbstractService {
+  /**
+   * POST the confirmation token from the Discord return address. Links Discord
+   * only when the signed-in user created the intent; the result says what happened.
+   */
+  static async create(params: DiscordConnectConfirmationInput): Promise<DiscordConnectConfirmationInterface> {
+    return this.callApi<DiscordConnectConfirmationInterface>({
+      type: Modules.DiscordConnectConfirmation,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.DiscordConnectConfirmation }).generate(),
+      input: params,
+      suppressGlobalError: true,
+    });
+  }
+}

package/src/features/discord-connection/data/discord-connect-confirmation.ts

@@ -0,0 +1,46 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import {
+  DiscordConnectConfirmationInput,
+  DiscordConnectConfirmationInterface,
+  DiscordConnectResult,
+} from "./discord-connect-confirmation.interface";
+
+const RESULTS: readonly DiscordConnectResult[] = ["connected", "taken", "already", "failed"];
+
+export class DiscordConnectConfirmation extends AbstractApiData implements DiscordConnectConfirmationInterface {
+  private _result: DiscordConnectResult = "failed";
+  private _discordName?: string;
+
+  get result(): DiscordConnectResult {
+    return this._result;
+  }
+
+  get discordName(): string | undefined {
+    return this._discordName;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes ?? {};
+
+    this._result = RESULTS.includes(attributes.result) ? attributes.result : "failed";
+    this._discordName = attributes.discordName ?? undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: DiscordConnectConfirmationInput) {
+    const response: any = {
+      data: {
+        type: Modules.DiscordConnectConfirmation.name,
+        id: data.id,
+        attributes: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/discord-connection/data/discord-connect-intent.interface.ts

@@ -0,0 +1,16 @@
+import { ApiDataInterface } from "../../../core";
+
+/**
+ * A one-time Connect Discord intent. Its id is a UUID the browser generates.
+ */
+export interface DiscordConnectIntentInterface extends ApiDataInterface {
+  get returnPath(): string;
+  get authorizeUrl(): string | undefined;
+}
+
+export type DiscordConnectIntentInput = {
+  /** A UUID generated by the browser (uuid `v4()`). */
+  id: string;
+  /** Where the user lands after Discord: `/`, `/settings` or `/settings?section=<id>`. */
+  returnPath: string;
+};

package/src/features/discord-connection/data/discord-connect-intent.service.ts

@@ -0,0 +1,20 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { DiscordConnectIntentInput, DiscordConnectIntentInterface } from "./discord-connect-intent.interface";
+
+export class DiscordConnectIntentService extends AbstractService {
+  /**
+   * POST a Connect Discord intent for the signed-in user. Sent with
+   * `credentials: "include"` so the browser stores the API's HttpOnly
+   * `discord_connect` cookie that binds the intent to this browser.
+   */
+  static async create(params: DiscordConnectIntentInput): Promise<DiscordConnectIntentInterface> {
+    return this.callApi<DiscordConnectIntentInterface>({
+      type: Modules.DiscordConnectIntent,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.DiscordConnectIntent }).generate(),
+      input: params,
+      credentials: "include",
+      suppressGlobalError: true,
+    });
+  }
+}

package/src/features/discord-connection/data/discord-connect-intent.ts

@@ -0,0 +1,42 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { DiscordConnectIntentInput, DiscordConnectIntentInterface } from "./discord-connect-intent.interface";
+
+export class DiscordConnectIntent extends AbstractApiData implements DiscordConnectIntentInterface {
+  private _returnPath?: string;
+  private _authorizeUrl?: string;
+
+  get returnPath(): string {
+    return this._returnPath ?? "/";
+  }
+
+  get authorizeUrl(): string | undefined {
+    return this._authorizeUrl;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes ?? {};
+
+    this._returnPath = attributes.returnPath;
+    this._authorizeUrl = attributes.authorizeUrl ?? undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: DiscordConnectIntentInput) {
+    const response: any = {
+      data: {
+        type: Modules.DiscordConnectIntent.name,
+        id: data.id,
+        attributes: {
+          returnPath: data.returnPath,
+        },
+        relationships: {},
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/discord-connection/data/discord-connection.interface.ts

@@ -0,0 +1,10 @@
+import { ApiDataInterface } from "../../../core";
+
+/**
+ * Whether the signed-in user has a Discord account attached. Not a stored entity:
+ * the API builds it for one user; its id is that user's id.
+ */
+export interface DiscordConnectionInterface extends ApiDataInterface {
+  get connected(): boolean;
+  get discordName(): string | undefined;
+}

package/src/features/discord-connection/data/discord-connection.service.ts

@@ -0,0 +1,17 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { DiscordConnectionInterface } from "./discord-connection.interface";
+
+export class DiscordConnectionService extends AbstractService {
+  /**
+   * GET whether the user has Discord attached. `params.id` must be the signed-in
+   * user's id; any other id answers 404.
+   */
+  static async findById(params: { id: string }): Promise<DiscordConnectionInterface> {
+    return this.callApi<DiscordConnectionInterface>({
+      type: Modules.DiscordConnection,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.DiscordConnection, id: params.id }).generate(),
+      suppressGlobalError: true,
+    });
+  }
+}