@carlonicora/nextjs-jsonapi 6.6.0 → 6.8.0

package/src/features/account-deletion/data/account-deletion.ts

@@ -0,0 +1,90 @@
+import { v4 } from "uuid";
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { AccountDeletionInput, AccountDeletionInterface } from "./account-deletion.interface";
+
+export class AccountDeletion extends AbstractApiData implements AccountDeletionInterface {
+  private _requestedAt?: Date;
+  private _scheduledAt?: Date;
+  private _hasDeliverableEmail: boolean = false;
+  private _hasActiveSubscription: boolean = false;
+  private _deletesCompany: boolean = false;
+  private _ownedCount: number = 0;
+  private _otherTables?: string[];
+
+  get requestedAt(): Date | undefined {
+    return this._requestedAt;
+  }
+
+  get scheduledAt(): Date | undefined {
+    return this._scheduledAt;
+  }
+
+  get hasDeliverableEmail(): boolean {
+    return this._hasDeliverableEmail;
+  }
+
+  get hasActiveSubscription(): boolean {
+    return this._hasActiveSubscription;
+  }
+
+  get deletesCompany(): boolean {
+    return this._deletesCompany;
+  }
+
+  get ownedCount(): number {
+    return this._ownedCount;
+  }
+
+  get otherTables(): string[] {
+    return this._otherTables ?? [];
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes ?? {};
+
+    this._requestedAt = attributes.requestedAt ? new Date(attributes.requestedAt) : undefined;
+    this._scheduledAt = attributes.scheduledAt ? new Date(attributes.scheduledAt) : undefined;
+    this._hasDeliverableEmail = attributes.hasDeliverableEmail === true;
+    this._hasActiveSubscription = attributes.hasActiveSubscription === true;
+    this._deletesCompany = attributes.deletesCompany === true;
+    this._ownedCount = typeof attributes.ownedCount === "number" ? attributes.ownedCount : 0;
+    this._otherTables = Array.isArray(attributes.otherTables) ? attributes.otherTables : [];
+
+    return this;
+  }
+
+  createJsonApi(data: AccountDeletionInput) {
+    const response: any = {
+      data: {
+        type: Modules.AccountDeletion.name,
+        id: data.id,
+        attributes: {
+          confirmation: data.confirmation,
+        },
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    return response;
+  }
+
+  /**
+   * Body of the public "Keep my account" call. The caller is not signed in and
+   * has no id to send: the API validates a client UUID and ignores its value.
+   */
+  createKeepJsonApi(params: { token: string }) {
+    return {
+      data: {
+        type: Modules.AccountDeletion.name,
+        id: v4(),
+        attributes: {
+          token: params.token,
+        },
+      },
+    };
+  }
+}

package/src/features/account-deletion/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./account-deletion.interface";
+export * from "./account-deletion";
+export * from "./account-deletion.service";

package/src/features/account-deletion/index.ts

@@ -0,0 +1,4 @@
+export * from "./account-deletion.module";
+export * from "./data";
+export * from "./utils";
+export * from "./components";

package/src/features/account-deletion/utils/__tests__/account-deletion-notice.spec.ts

@@ -0,0 +1,40 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { consumeAccountDeletionCancelled, markAccountDeletionCancelled } from "../account-deletion-notice";
+
+describe("account-deletion notice flag", () => {
+  beforeEach(() => {
+    window.sessionStorage.clear();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    window.sessionStorage.clear();
+  });
+
+  it("consume returns true once after mark, then false", () => {
+    expect(consumeAccountDeletionCancelled()).toBe(false);
+
+    markAccountDeletionCancelled();
+
+    expect(consumeAccountDeletionCancelled()).toBe(true);
+    expect(consumeAccountDeletionCancelled()).toBe(false);
+  });
+
+  it("survives a throwing sessionStorage", () => {
+    const throwing = {
+      getItem: () => {
+        throw new Error("blocked");
+      },
+      setItem: () => {
+        throw new Error("blocked");
+      },
+      removeItem: () => {
+        throw new Error("blocked");
+      },
+    };
+    vi.stubGlobal("sessionStorage", throwing);
+
+    expect(() => markAccountDeletionCancelled()).not.toThrow();
+    expect(consumeAccountDeletionCancelled()).toBe(false);
+  });
+});

package/src/features/account-deletion/utils/account-deletion-notice.ts

@@ -0,0 +1,27 @@
+/**
+ * One-shot flag between the login that cancelled a pending account deletion and
+ * the first page after it, which shows AccountDeletionCancelledNotice. Kept in
+ * sessionStorage so it survives the redirect (and the full reload of the
+ * Discord / Google path) but not the tab. Storage can be missing or throw
+ * (private mode, blocked site data): the notice is then simply not shown.
+ */
+export const ACCOUNT_DELETION_CANCELLED_KEY = "nja:accountDeletionCancelled";
+
+export function markAccountDeletionCancelled(): void {
+  try {
+    sessionStorage.setItem(ACCOUNT_DELETION_CANCELLED_KEY, "1");
+  } catch {
+    // Storage unavailable: no notice.
+  }
+}
+
+export function consumeAccountDeletionCancelled(): boolean {
+  try {
+    const value = sessionStorage.getItem(ACCOUNT_DELETION_CANCELLED_KEY);
+    if (value === null) return false;
+    sessionStorage.removeItem(ACCOUNT_DELETION_CANCELLED_KEY);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/features/account-deletion/utils/index.ts

@@ -0,0 +1 @@
+export * from "./account-deletion-notice";

package/src/features/auth/components/forms/Cookies.tsx

@@ -3,6 +3,7 @@
 import { useEffect, useState } from "react";
 import { JsonApiHydratedDataInterface, Modules, rehydrate } from "../../../../core";
 import { useI18nRouter } from "../../../../i18n";
+import { markAccountDeletionCancelled } from "../../../account-deletion/utils/account-deletion-notice";
 import { UserInterface } from "../../../user";
 import { useCurrentUserContext } from "../../../user/contexts";
 import { AuthInterface } from "../../data";
@@ -18,6 +19,8 @@ export function Cookies({ dehydratedAuth, page }: { dehydratedAuth: JsonApiHydra
     async function saveTokenOnServer() {
       await AuthService.saveToken({ dehydratedAuth });
       const auth: AuthInterface = rehydrate(Modules.Auth, dehydratedAuth) as AuthInterface;
+      // Discord / Google path: the flag is on the Auth document from the code exchange.
+      if (auth.deletionCancelled) markAccountDeletionCancelled();
       setUser(auth.user as UserInterface);
       setHasSaved(true);
 

package/src/features/auth/components/forms/TwoFactorChallenge.tsx

@@ -18,6 +18,7 @@ import {
   TabsList,
   TabsTrigger,
 } from "../../../../shadcnui";
+import { markAccountDeletionCancelled } from "../../../account-deletion/utils/account-deletion-notice";
 import { UserInterface } from "../../../user";
 import { useCurrentUserContext } from "../../../user/contexts";
 import { useAuthContext } from "../../contexts";
@@ -46,6 +47,7 @@ export function TwoFactorChallenge() {
   }
 
   const handleSuccess = (auth: AuthInterface) => {
+    if (auth.deletionCancelled) markAccountDeletionCancelled();
     setPendingTwoFactor(undefined);
     setUser(auth.user);
 

package/src/features/auth/data/__tests__/auth.spec.ts

@@ -0,0 +1,36 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ApiRequestDataTypeInterface } from "../../../../core/interfaces/ApiRequestDataTypeInterface";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { Auth } from "../auth";
+
+// Auth.rehydrate() resolves Modules.User through the real ModuleRegistry (the
+// argument of `_readIncluded`), so it must be registered even though these
+// fixtures carry no included user.
+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);
+});
+
+const rehydrateWith = (attributes: Record<string, any>) =>
+  new Auth().rehydrate({
+    jsonApi: { type: "auth", id: "auth-1", attributes: { token: "t", refreshToken: "r", ...attributes } },
+    included: [],
+  } as any);
+
+describe("Auth", () => {
+  describe("rehydrate", () => {
+    it("deletionCancelled true when the attribute is true, false otherwise", () => {
+      expect(rehydrateWith({ deletionCancelled: true }).deletionCancelled).toBe(true);
+      expect(rehydrateWith({ deletionCancelled: false }).deletionCancelled).toBe(false);
+      expect(rehydrateWith({}).deletionCancelled).toBe(false);
+    });
+  });
+});

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

@@ -35,4 +35,6 @@ export interface AuthInterface extends ApiDataInterface {
   get token(): string;
   get refreshToken(): string;
   get user(): UserInterface;
+  /** True on the session created by the login that cancelled a pending account deletion. */
+  get deletionCancelled(): boolean;
 }

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

@@ -9,6 +9,7 @@ import {
   rehydrate,
 } from "../../../core";
 import { JsonApiDelete, JsonApiGet, JsonApiPost } from "../../../unified";
+import { markAccountDeletionCancelled } from "../../account-deletion/utils/account-deletion-notice";
 import { UserInterface } from "../../user";
 import { getTokenHandler } from "../config";
 import { PendingRegistrationInterface } from "./pending-registration.interface";
@@ -45,6 +46,9 @@ export class AuthService extends AbstractService {
     // Normal auth response
     const auth = apiResponse.data as AuthInterface;
 
+    // Login returns only the user to Login.tsx, so the flag is read here.
+    if (auth.deletionCancelled) markAccountDeletionCancelled();
+
     // Use injected token handler if configured
     const handler = getTokenHandler();
     if (handler) {

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

@@ -6,6 +6,12 @@ export class Auth extends AbstractApiData implements AuthInterface {
   private _token?: string;
   private _refreshToken?: string;
   private _user?: UserInterface;
+  private _deletionCancelled: boolean = false;
+
+  /** True on the session created by the login that cancelled a pending account deletion. */
+  get deletionCancelled(): boolean {
+    return this._deletionCancelled;
+  }
 
   get token(): string {
     if (!this._token) throw new Error("Token is not defined");
@@ -27,6 +33,7 @@ export class Auth extends AbstractApiData implements AuthInterface {
 
     this._token = data.jsonApi.attributes.token ?? undefined;
     this._refreshToken = data.jsonApi.attributes.refreshToken ?? undefined;
+    this._deletionCancelled = data.jsonApi.attributes.deletionCancelled === true;
 
     this._user = this._readIncluded(data, "user", Modules.User) as UserInterface;
 

package/src/features/company/data/company.interface.ts

@@ -36,6 +36,13 @@ export interface CompanyInterface extends ApiDataInterface {
 
   get isActiveSubscription(): boolean;
 
+  /**
+   * When the company's trial ends, written by the server only (never sent by
+   * `createJsonApi()`). Absent for companies whose trial end was never stored;
+   * callers then derive it from `createdAt`.
+   */
+  get trialEndsAt(): Date | undefined;
+
   get monthlyCredits(): number;
   get availableMonthlyCredits(): number;
   get availableExtraCredits(): number;

package/src/features/company/data/company.spec.ts

@@ -67,3 +67,26 @@ describe("Company credit-warning fields", () => {
     expect(company.creditWarningOffer).toBeUndefined();
   });
 });
+
+describe("Company.trialEndsAt", () => {
+  it("rehydrates trialEndsAt as a Date", () => {
+    const company = new Company().rehydrate({
+      jsonApi: { attributes: { trialEndsAt: "2026-11-09T10:00:00.000Z" } },
+    } as any);
+
+    expect(company.trialEndsAt).toBeInstanceOf(Date);
+    expect(company.trialEndsAt?.toISOString()).toBe("2026-11-09T10:00:00.000Z");
+  });
+
+  it("is undefined when the attribute is absent", () => {
+    const company = new Company().rehydrate({ jsonApi: { attributes: {} } } as any);
+
+    expect(company.trialEndsAt).toBeUndefined();
+  });
+
+  it("is never sent by createJsonApi", () => {
+    const payload = new Company().createJsonApi({ id: "company_1", name: "Acme" });
+
+    expect(payload.data.attributes).not.toHaveProperty("trialEndsAt");
+  });
+});

package/src/features/company/data/company.ts

@@ -11,6 +11,7 @@ export class Company extends AbstractApiData implements CompanyInterface {
   private _configurations?: any;
 
   private _isActiveSubscription: boolean = false;
+  private _trialEndsAt?: Date;
 
   private _monthlyCredits: number = 0;
   private _availableMonthlyCredits: number = 0;
@@ -53,6 +54,10 @@ export class Company extends AbstractApiData implements CompanyInterface {
     return this._isActiveSubscription ?? false;
   }
 
+  get trialEndsAt(): Date | undefined {
+    return this._trialEndsAt;
+  }
+
   get monthlyCredits(): number {
     return this._monthlyCredits ?? 0;
   }
@@ -147,6 +152,7 @@ export class Company extends AbstractApiData implements CompanyInterface {
     this._logo = data.jsonApi.attributes.logo;
     this._logoUrl = data.jsonApi.attributes.logoUrl;
     this._isActiveSubscription = data.jsonApi.attributes.isActiveSubscription ?? false;
+    this._trialEndsAt = data.jsonApi.attributes.trialEndsAt ? new Date(data.jsonApi.attributes.trialEndsAt) : undefined;
     this._monthlyCredits = data.jsonApi.attributes.monthlyCredits ?? 0;
     this._availableMonthlyCredits = data.jsonApi.attributes.availableMonthlyCredits ?? 0;
     this._availableExtraCredits = data.jsonApi.attributes.availableExtraCredits ?? 0;

package/src/features/company/hooks/useSubscriptionStatus.spec.ts

@@ -193,4 +193,63 @@ describe("useSubscriptionStatus", () => {
     expect(after.result.current.isBlocked).toBe(true);
     expect(after.result.current.status).toBe("expired");
   });
+  describe("stored trialEndsAt", () => {
+    const NOW = new Date("2026-10-26T10:00:00.000Z");
+
+    beforeEach(() => {
+      vi.setSystemTime(NOW);
+      userMock.currentUser = { roles: [] };
+    });
+
+    it("not active, trialEndsAt in the future → trial, not blocked", () => {
+      const trialEndsAt = new Date("2026-11-05T10:00:00.000Z");
+      userMock.company = { isActiveSubscription: false, createdAt: daysAgo(60, NOW), trialEndsAt };
+
+      const { result } = renderHook(() => useSubscriptionStatus());
+
+      expect(result.current.status).toBe("trial");
+      expect(result.current.daysRemaining).toBe(10);
+      expect(result.current.isBlocked).toBe(false);
+      expect(result.current.trialEndsAt?.getTime()).toBe(trialEndsAt.getTime());
+    });
+
+    it("not active, trialEndsAt in the past → expired, blocked", () => {
+      userMock.company = {
+        isActiveSubscription: false,
+        createdAt: daysAgo(60, NOW),
+        trialEndsAt: new Date("2026-10-20T10:00:00.000Z"),
+      };
+
+      const { result } = renderHook(() => useSubscriptionStatus());
+
+      expect(result.current.status).toBe("expired");
+      expect(result.current.isBlocked).toBe(true);
+    });
+
+    it("not active, no trialEndsAt → createdAt + 14 days (unchanged)", () => {
+      const createdAt = daysAgo(4, NOW);
+      userMock.company = { isActiveSubscription: false, createdAt, trialEndsAt: undefined };
+
+      const { result } = renderHook(() => useSubscriptionStatus());
+
+      expect(result.current.status).toBe("trial");
+      expect(result.current.daysRemaining).toBe(10);
+      expect(result.current.isBlocked).toBe(false);
+      expect(result.current.trialEndsAt?.getTime()).toBe(createdAt.getTime() + 14 * DAY_MS);
+    });
+
+    it("active ignores trialEndsAt", () => {
+      userMock.company = {
+        isActiveSubscription: true,
+        createdAt: daysAgo(60, NOW),
+        trialEndsAt: new Date("2026-11-05T10:00:00.000Z"),
+      };
+
+      const { result } = renderHook(() => useSubscriptionStatus());
+
+      expect(result.current.status).toBe("active");
+      expect(result.current.trialEndsAt).toBeNull();
+      expect(result.current.isBlocked).toBe(false);
+    });
+  });
 });

package/src/features/company/hooks/useSubscriptionStatus.ts

@@ -86,8 +86,10 @@ export function useSubscriptionStatus(): TrialSubscriptionStatus {
 
     // No active subscription — but that alone is NOT a block. The trial window
     // has to have elapsed too, and this mirrors the server rule in
-    // apps/api .../campaign/entities/campaign-lock.cypher.ts. Keep the two in
-    // step: if TRIAL_DAYS changes here it must change there.
+    // apps/api/src/features/campaign/entities/campaign-lock.cypher.ts. Keep the
+    // two in step: the trial ends at the stored company.trialEndsAt when the
+    // server wrote one, otherwise at createdAt + TRIAL_DAYS. If either the
+    // fallback or TRIAL_DAYS changes here it must change there.
     //
     // Blocking on the flag alone is wrong in practice. isActiveSubscription is
     // only written true once a Stripe subscription actually reaches
@@ -100,7 +102,7 @@ export function useSubscriptionStatus(): TrialSubscriptionStatus {
     // viewer's local clock: across a DST change the window grows or shrinks by
     // an hour, and dividing that by a fixed 24h day then shows one day too many.
     const createdAt = new Date(company.createdAt);
-    const trialEndsAt = new Date(createdAt.getTime() + TRIAL_DAYS * DAY_MS);
+    const trialEndsAt = company.trialEndsAt ?? new Date(createdAt.getTime() + TRIAL_DAYS * DAY_MS);
 
     const now = new Date();
     const msRemaining = trialEndsAt.getTime() - now.getTime();

package/src/features/user/contexts/UserContext.tsx

@@ -8,6 +8,10 @@ import { usePageUrlGenerator } from "../../../hooks";
 import { BreadcrumbItemData } from "../../../interfaces";
 import { Action } from "../../../permissions";
 import { getRoleId } from "../../../roles";
+import {
+  AccountDeletionAdminTrigger,
+  isAccountDeletionEnabled,
+} from "../../account-deletion/components/AccountDeletionAdminTrigger";
 import { UserDeleter, UserEditor, UserReactivator, UserResentInvitationEmail } from "../components/forms";
 import { UserInterface } from "../data";
 import { useCurrentUserContext } from "./CurrentUserContext";
@@ -83,6 +87,10 @@ export const UserProvider = ({ children, dehydratedUser }: UserProviderProps) =>
           functions.push(<UserResentInvitationEmail key={`UserResentInvitationEmail`} user={user} />);
 
         functions.push(<UserDeleter key={`UserDeleter`} user={user} />);
+
+        // Opt-in: only apps that registered AccountDeletionModule, platform administrators only.
+        if (hasRole(getRoleId().Administrator) && isAccountDeletionEnabled())
+          functions.push(<AccountDeletionAdminTrigger key={`AccountDeletionAdminTrigger`} user={user} />);
       }
 
       functions.push(<UserEditor key={`UserEditor`} user={user} propagateChanges={setUser} />);