@carlonicora/nextjs-jsonapi 6.29.1 → 6.31.0

package/src/features/auth/data/__tests__/auth.oauth-completion.spec.ts

@@ -0,0 +1,44 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { Modules } from "../../../../core";
+import { ApiRequestDataTypeInterface } from "../../../../core/interfaces/ApiRequestDataTypeInterface";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { Auth } from "../auth";
+
+// Auth.createJsonApi() reads Modules.Auth.name through the real ModuleRegistry,
+// so it must be registered (same pattern as auth.spec.ts).
+const registerIfAbsent = (key: string, module: ApiRequestDataTypeInterface) => {
+  try {
+    ModuleRegistry.get(key as any);
+  } catch {
+    ModuleRegistry.register(key, module);
+  }
+};
+
+beforeAll(() => {
+  registerIfAbsent("Auth", { name: "auth", model: Auth } as any);
+  registerIfAbsent("User", { name: "users", model: class {} } as any);
+});
+
+describe("Auth.createJsonApi() for the OAuth completion", () => {
+  it("an OAuth completion body carries the pending id and the given consent", () => {
+    const body = new Auth().createJsonApi({
+      id: "p1",
+      termsAcceptedAt: "2026-11-09T00:00:00.000Z",
+      marketingConsent: false,
+    });
+
+    expect(body).toEqual({
+      data: {
+        type: Modules.Auth.name,
+        id: "p1",
+        attributes: { termsAcceptedAt: "2026-11-09T00:00:00.000Z", marketingConsent: false },
+      },
+    });
+  });
+
+  it("an invite completion sends no consent attributes", () => {
+    const body = new Auth().createJsonApi({ id: "p1" });
+
+    expect(body).toEqual({ data: { type: Modules.Auth.name, id: "p1", attributes: {} } });
+  });
+});

package/src/features/auth/data/__tests__/pending-registration.spec.ts

@@ -16,6 +16,7 @@ describe("PendingRegistration.rehydrate()", () => {
       provider: "discord",
       hasPass: true,
       emailInUse: true,
+      hasInvite: true,
     });
 
     expect(pending.id).toBe("pending-1");
@@ -25,6 +26,7 @@ describe("PendingRegistration.rehydrate()", () => {
     expect(pending.provider).toBe("discord");
     expect(pending.hasPass).toBe(true);
     expect(pending.emailInUse).toBe(true);
+    expect(pending.hasInvite).toBe(true);
   });
 
   it("leaves avatar undefined and defaults hasPass/emailInUse to false when absent", () => {
@@ -34,4 +36,10 @@ describe("PendingRegistration.rehydrate()", () => {
     expect(pending.hasPass).toBe(false);
     expect(pending.emailInUse).toBe(false);
   });
+
+  it("PendingRegistration rehydrates hasInvite with a false default", () => {
+    expect(hydrate({ name: "Aria", email: "aria@example.com", provider: "google" }).hasInvite).toBe(false);
+    expect(hydrate({ name: "Aria", hasInvite: null }).hasInvite).toBe(false);
+    expect(hydrate({ name: "Aria", hasInvite: true }).hasInvite).toBe(true);
+  });
 });

package/src/features/auth/data/auth.service.ts

@@ -195,24 +195,30 @@ export class AuthService extends AbstractService {
     });
   }
 
+  /**
+   * Completes an OAuth sign-up waiting for consent. A sign-up with a usable
+   * waitlist invite sends no consent: the server copies it from the waitlist.
+   * Throws an Error with message `"<status>:<message>"` on failure.
+   */
   static async completeOAuthRegistration(params: {
     pendingId: string;
-    termsAcceptedAt: string;
-    marketingConsent: boolean;
-    marketingConsentAt: string | null;
+    termsAcceptedAt?: string;
+    marketingConsent?: boolean;
+    marketingConsentAt?: string | null;
   }): Promise<{ code: string }> {
-    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "oauth", childEndpoint: "complete" });
-
-    const response: ApiResponseInterface = await JsonApiPost({
-      classKey: Modules.Auth,
-      endpoint: endpoint.generate(),
-      body: params,
-      overridesJsonApiCreation: true,
-      language: "en",
+    const input: AuthInput = {
+      id: params.pendingId,
+      termsAcceptedAt: params.termsAcceptedAt,
+      marketingConsent: params.marketingConsent,
+      marketingConsentAt: params.marketingConsentAt,
+    };
+
+    return this.callApi<{ code: string }>({
+      type: Modules.Auth,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "oauth", childEndpoint: "complete" }).generate(),
+      input: input,
+      suppressGlobalError: true,
     });
-
-    if (!response.ok) throw new Error(response.error);
-
-    return response.data as unknown as { code: string };
   }
 }

package/src/features/auth/data/pending-registration.interface.ts

@@ -7,4 +7,5 @@ export interface PendingRegistrationInterface extends ApiDataInterface {
   get provider(): string;
   get hasPass(): boolean;
   get emailInUse(): boolean;
+  get hasInvite(): boolean;
 }

package/src/features/auth/data/pending-registration.ts

@@ -8,6 +8,7 @@ export class PendingRegistration extends AbstractApiData implements PendingRegis
   private _provider?: string;
   private _hasPass?: boolean;
   private _emailInUse?: boolean;
+  private _hasInvite?: boolean;
 
   get name(): string {
     return this._name ?? "";
@@ -33,6 +34,10 @@ export class PendingRegistration extends AbstractApiData implements PendingRegis
     return this._emailInUse ?? false;
   }
 
+  get hasInvite(): boolean {
+    return this._hasInvite ?? false;
+  }
+
   rehydrate(data: JsonApiHydratedDataInterface): this {
     super.rehydrate(data);
     this._name = data.jsonApi.attributes.name;
@@ -41,6 +46,7 @@ export class PendingRegistration extends AbstractApiData implements PendingRegis
     this._provider = data.jsonApi.attributes.provider;
     this._hasPass = data.jsonApi.attributes.hasPass ?? false;
     this._emailInUse = data.jsonApi.attributes.emailInUse ?? false;
+    this._hasInvite = data.jsonApi.attributes.hasInvite ?? false;
     return this;
   }
 

package/src/features/auth/hooks/__tests__/useCompleteLogin.spec.tsx

@@ -0,0 +1,85 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AuthComponent } from "../../enums";
+import { useCompleteLogin } from "../useCompleteLogin";
+
+const mocks = vi.hoisted(() => ({
+  setUser: vi.fn(),
+  setComponentType: vi.fn(),
+  setPendingTwoFactor: vi.fn(),
+  i18nRouter: { replace: vi.fn(), push: vi.fn() },
+  nativeRouter: { replace: vi.fn(), push: vi.fn() },
+  search: { value: "" },
+}));
+
+vi.mock(
+  "../../../user/contexts",
+  () => new Proxy({ useCurrentUserContext: () => ({ setUser: mocks.setUser }) }, { has: () => true }),
+);
+
+vi.mock(
+  "../../contexts",
+  () =>
+    new Proxy(
+      {
+        useAuthContext: () => ({
+          setComponentType: mocks.setComponentType,
+          setPendingTwoFactor: mocks.setPendingTwoFactor,
+        }),
+      },
+      { has: () => true },
+    ),
+);
+
+vi.mock(
+  "../../../../hooks",
+  () =>
+    new Proxy(
+      {
+        usePageUrlGenerator:
+          () =>
+          ({ page }: { page: string }) =>
+            page,
+        useI18nRouter: () => mocks.i18nRouter,
+      },
+      { has: () => true },
+    ),
+);
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => mocks.nativeRouter,
+  useSearchParams: () => new URLSearchParams(mocks.search.value),
+}));
+
+describe("useCompleteLogin", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.search.value = "";
+  });
+
+  it("a user response sets the user and goes home", () => {
+    const { result } = renderHook(() => useCompleteLogin());
+    const user = { id: "u1" } as any;
+    result.current(user);
+    expect(mocks.setUser).toHaveBeenCalledWith(user);
+    expect(mocks.i18nRouter.replace).toHaveBeenCalledWith("/");
+    expect(mocks.nativeRouter.replace).not.toHaveBeenCalled();
+  });
+
+  it("a callbackUrl wins over home", () => {
+    mocks.search.value = "callbackUrl=/it/campaigns";
+    const { result } = renderHook(() => useCompleteLogin());
+    result.current({ id: "u1" } as any);
+    expect(mocks.nativeRouter.replace).toHaveBeenCalledWith("/it/campaigns");
+    expect(mocks.i18nRouter.replace).not.toHaveBeenCalled();
+  });
+
+  it("a two-factor challenge opens the challenge", () => {
+    const { result } = renderHook(() => useCompleteLogin());
+    const challenge = { pendingToken: "p" } as any;
+    result.current(challenge);
+    expect(mocks.setPendingTwoFactor).toHaveBeenCalledWith(challenge);
+    expect(mocks.setComponentType).toHaveBeenCalledWith(AuthComponent.TwoFactorChallenge);
+    expect(mocks.setUser).not.toHaveBeenCalled();
+  });
+});

package/src/features/auth/hooks/useCompleteLogin.ts

@@ -0,0 +1,47 @@
+"use client";
+
+import { useRouter, useSearchParams } from "next/navigation";
+import { useCallback } from "react";
+import { useI18nRouter, usePageUrlGenerator } from "../../../hooks";
+import { UserInterface } from "../../user";
+import { useCurrentUserContext } from "../../user/contexts";
+import { useAuthContext } from "../contexts";
+import { TwoFactorChallengeInterface } from "../data/two-factor-challenge.interface";
+import { AuthComponent } from "../enums";
+
+/**
+ * Post-login handling shared by Login and the invite sign-up in Register:
+ * opens the two-factor challenge when one is pending, otherwise stores the
+ * user and redirects to the callback URL or home.
+ */
+export function useCompleteLogin(): (response: UserInterface | TwoFactorChallengeInterface) => void {
+  const { setUser } = useCurrentUserContext<UserInterface>();
+  const { setComponentType, setPendingTwoFactor } = useAuthContext();
+  const generateUrl = usePageUrlGenerator();
+  const i18nRouter = useI18nRouter();
+  const nativeRouter = useRouter(); // For URLs that already include locale
+  const searchParams = useSearchParams();
+  const callbackUrl = searchParams.get("callbackUrl");
+
+  return useCallback(
+    (response: UserInterface | TwoFactorChallengeInterface) => {
+      // Check if 2FA is required (response is TwoFactorChallengeInterface)
+      if ("pendingToken" in response) {
+        setPendingTwoFactor(response as TwoFactorChallengeInterface);
+        setComponentType(AuthComponent.TwoFactorChallenge);
+        return;
+      }
+
+      setUser(response as UserInterface);
+
+      // Use native router for callbackUrl since it already includes the locale prefix
+      // Use i18n router for normal navigation which adds locale automatically
+      if (callbackUrl) {
+        nativeRouter.replace(callbackUrl);
+      } else {
+        i18nRouter.replace(generateUrl({ page: `/` }));
+      }
+    },
+    [setUser, setComponentType, setPendingTwoFactor, generateUrl, i18nRouter, nativeRouter, callbackUrl],
+  );
+}

package/src/login/__tests__/config.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { configureLogin, isCompanyNameRequired } from "../index";
+
+describe("login config — requireCompanyName", () => {
+  it("isCompanyNameRequired defaults to true", () => {
+    configureLogin({});
+    expect(isCompanyNameRequired()).toBe(true);
+  });
+
+  it("requireCompanyName false hides the company field", () => {
+    configureLogin({ requireCompanyName: false });
+    expect(isCompanyNameRequired()).toBe(false);
+  });
+
+  it("a later configureLogin without the option restores the default", () => {
+    configureLogin({ requireCompanyName: false });
+    expect(isCompanyNameRequired()).toBe(false);
+    configureLogin({});
+    expect(isCompanyNameRequired()).toBe(true);
+  });
+});

package/src/login/config.ts

@@ -3,6 +3,7 @@ let _useGoogleAuth: boolean = false;
 let _useInternalAuth: boolean = true;
 let _allowRegistration: boolean = true;
 let _registrationMode: "open" | "closed" | "waitlist" = "open";
+let _requireCompanyName: boolean = true;
 
 export type RegistrationMode = "open" | "closed" | "waitlist";
 
@@ -12,6 +13,8 @@ export interface LoginConfig {
   useInternalAuth?: boolean;
   allowRegistration?: boolean;
   registrationMode?: RegistrationMode;
+  /** Show and require the company name on sign-up. Default `true`. */
+  requireCompanyName?: boolean;
 }
 
 export function configureLogin(params: LoginConfig): void {
@@ -20,6 +23,7 @@ export function configureLogin(params: LoginConfig): void {
   _useInternalAuth = params.useInternalAuth ?? true;
   _allowRegistration = params.allowRegistration ?? true;
   _registrationMode = params.registrationMode ?? "open";
+  _requireCompanyName = params.requireCompanyName ?? true;
 }
 
 export function isDiscordAuthEnabled(): boolean {
@@ -41,3 +45,7 @@ export function isRegistrationAllowed(): boolean {
 export function getRegistrationMode(): RegistrationMode {
   return _registrationMode;
 }
+
+export function isCompanyNameRequired(): boolean {
+  return _requireCompanyName;
+}

package/src/login/index.ts

@@ -1,5 +1,6 @@
 export {
   configureLogin,
+  isCompanyNameRequired,
   isDiscordAuthEnabled,
   isGoogleAuthEnabled,
   isInternalAuthEnabled,