@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/features/auth/config.ts

@@ -0,0 +1,57 @@
+/**
+ * Token parameters for authentication cookie management
+ */
+export interface TokenParams {
+  token?: string;
+  refreshToken?: string;
+  userId?: string;
+  companyId?: string;
+  licenseExpirationDate?: Date;
+  roles?: string[];
+  features?: string[];
+  modules?: {
+    id: string;
+    permissions: {
+      create: boolean | string;
+      read: boolean | string;
+      update: boolean | string;
+      delete: boolean | string;
+    };
+  }[];
+}
+
+/**
+ * Token handler interface for dependency injection
+ * Apps must provide implementations of these functions via configureAuth()
+ */
+export interface TokenHandler {
+  updateToken: (params: TokenParams) => Promise<void>;
+  removeToken: () => Promise<void>;
+}
+
+// Private storage for the injected token handler
+let _tokenHandler: TokenHandler | null = null;
+
+/**
+ * Configure authentication token handling
+ * Call this at app startup to provide Server Actions for cookie management
+ *
+ * @example
+ * ```typescript
+ * import { configureAuth } from "@carlonicora/nextjs-jsonapi/features";
+ * import { updateToken, removeToken } from "@/features/auth/utils/AuthCookies";
+ *
+ * configureAuth({ updateToken, removeToken });
+ * ```
+ */
+export function configureAuth(handler: TokenHandler): void {
+  _tokenHandler = handler;
+}
+
+/**
+ * Internal getter for AuthService to access the token handler
+ * @internal
+ */
+export function getTokenHandler(): TokenHandler | null {
+  return _tokenHandler;
+}

package/src/features/auth/contexts/AuthContext.tsx

@@ -0,0 +1,77 @@
+"use client";
+
+import { createContext, ReactElement, useContext, useMemo, useState } from "react";
+import {
+  AcceptInvitation,
+  ActivateAccount,
+  ForgotPassword,
+  LandingComponent,
+  Login,
+  ResetPassword,
+} from "../components";
+import Register from "../components/forms/Register";
+import { AuthComponent } from "../enums";
+
+interface AuthContextType {
+  activeComponent: ReactElement<any> | null;
+  setComponentType: (componentType: AuthComponent) => void;
+  setParams: (params?: { code?: string }) => void;
+  params?: { code?: string };
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const AuthContextProvider = ({
+  children,
+  initialComponentType,
+  initialParams,
+}: {
+  children: React.ReactNode;
+  initialComponentType?: AuthComponent;
+  initialParams?: { code?: string };
+}) => {
+  const [componentType, setComponentType] = useState<AuthComponent | undefined>(initialComponentType);
+  const [params, setParams] = useState<{ code?: string } | undefined>(initialParams);
+
+  const activeComponent = useMemo(() => {
+    if (componentType === undefined) return null;
+
+    switch (componentType) {
+      case AuthComponent.Login:
+        return <Login />;
+      case AuthComponent.Register:
+        return <Register />;
+      case AuthComponent.ForgotPassword:
+        return <ForgotPassword />;
+      case AuthComponent.ActivateAccount:
+        return <ActivateAccount />;
+      case AuthComponent.ResetPassword:
+        return <ResetPassword />;
+      case AuthComponent.AcceptInvitation:
+        return <AcceptInvitation />;
+      default:
+        return <LandingComponent />;
+    }
+  }, [componentType]);
+
+  return (
+    <AuthContext.Provider
+      value={{
+        activeComponent,
+        setComponentType,
+        setParams,
+        params,
+      }}
+    >
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+export const useAuthContext = (): AuthContextType => {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error("useAuthContext must be used within a AuthComponentProvider");
+  }
+  return context;
+};

package/src/features/auth/contexts/index.ts

@@ -0,0 +1 @@
+export * from "./AuthContext";

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

@@ -0,0 +1,31 @@
+import { ApiDataInterface } from "../../../core";
+import { UserInterface } from "../../user";
+
+export type AuthInput = {
+  id?: string;
+  email?: string | undefined | null;
+  password?: string | undefined;
+  name?: string;
+  companyName?: string;
+  partitaIva?: string;
+  codiceFiscale?: string;
+};
+
+export type AuthQuery = {
+  userId?: string;
+
+  tokenCode?: string;
+  refreshToken?: string;
+
+  login?: boolean;
+  forgot?: boolean;
+  code?: string;
+  activationCode?: string;
+  checkUsername?: string;
+};
+
+export interface AuthInterface extends ApiDataInterface {
+  get token(): string;
+  get refreshToken(): string;
+  get user(): UserInterface;
+}

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

@@ -0,0 +1,159 @@
+import { AuthInput, AuthInterface } from ".";
+import { JsonApiDelete, JsonApiGet, JsonApiPost } from "../../../";
+import {
+  AbstractService,
+  ApiResponseInterface,
+  EndpointCreator,
+  HttpMethod,
+  JsonApiHydratedDataInterface,
+  Modules,
+  rehydrate,
+} from "../../../core";
+import { UserInterface } from "../../user";
+import { getTokenHandler } from "../config";
+
+export class AuthService extends AbstractService {
+  static async login(params: { email: string; password: string; language?: string }): Promise<UserInterface> {
+    const language = params.language || "en-US";
+
+    const apiResponse: ApiResponseInterface = await JsonApiPost({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "login" }).generate(),
+      body: { email: params.email, password: params.password } as AuthInput,
+      language: language,
+    });
+
+    if (!apiResponse.ok) throw new Error(apiResponse.error);
+
+    const auth = apiResponse.data as AuthInterface;
+
+    // Use injected token handler if configured
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.updateToken({
+        token: auth.token,
+        refreshToken: auth.refreshToken,
+        userId: auth.user.id,
+        companyId: auth.user.company?.id,
+        licenseExpirationDate: auth.user.company?.licenseExpirationDate,
+        roles: auth.user.roles.map((role) => role.id),
+        features: auth.user.company?.features?.map((feature) => feature.id) ?? [],
+        modules: auth.user.modules.map((module) => ({
+          id: module.id,
+          permissions: module.permissions,
+        })),
+      });
+    }
+
+    return auth.user;
+  }
+
+  static async logout(params?: { language?: string }): Promise<void> {
+    const language = params?.language || "en-US";
+
+    await JsonApiDelete({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth }).generate(),
+      language: language,
+    });
+
+    // Use injected token handler if configured
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.removeToken();
+    }
+  }
+
+  static async initialiseForgotPassword(params: { email: string; language?: string }): Promise<void> {
+    const language = params.language || "en-US";
+
+    const response: ApiResponseInterface = await JsonApiPost({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "forgot" }).generate(),
+      body: { email: params.email } as AuthInput,
+      language: language,
+    });
+
+    if (!response.ok) {
+      throw new Error(response.error);
+    }
+  }
+
+  static async register(params: AuthInput): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "register" });
+
+    await this.callApi({
+      type: Modules.Auth,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  static async activate(params: { activationCode: string }): Promise<void> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Auth,
+      id: "activate",
+      childEndpoint: params.activationCode,
+    });
+
+    await this.callApi({ type: Modules.Auth, method: HttpMethod.POST, endpoint: endpoint.generate() });
+  }
+
+  static async validateCode(params: { code: string; language?: string }): Promise<void> {
+    const language = params.language || "en-US";
+
+    const apiResponse: ApiResponseInterface = await JsonApiGet({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "validate", childEndpoint: params.code }).generate(),
+      language: language,
+    });
+
+    if (!apiResponse.ok) throw new Error(apiResponse.error);
+  }
+
+  static async resetPassword(params: { code: string; password: string }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "reset", childEndpoint: params.code });
+
+    const input: AuthInput = { password: params.password };
+
+    await this.callApi({ type: Modules.Auth, method: HttpMethod.POST, endpoint: endpoint.generate(), input: input });
+  }
+
+  static async acceptInvitation(params: { code: string; password: string }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "invitation", childEndpoint: params.code });
+
+    const input: AuthInput = { password: params.password };
+
+    await this.callApi({ type: Modules.Auth, method: HttpMethod.POST, endpoint: endpoint.generate(), input: input });
+  }
+
+  static async findToken(params: { tokenCode: string }): Promise<AuthInterface> {
+    return await this.callApi<AuthInterface>({
+      type: Modules.Auth,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth }).addAdditionalParam("code", params.tokenCode).generate(),
+    });
+  }
+
+  static async saveToken(params: { dehydratedAuth: JsonApiHydratedDataInterface }): Promise<void> {
+    const auth: AuthInterface = rehydrate(Modules.Auth, params.dehydratedAuth) as AuthInterface;
+
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.updateToken({
+        token: auth.token,
+        refreshToken: auth.refreshToken,
+        userId: auth.user.id,
+        companyId: auth.user.company?.id,
+        licenseExpirationDate: auth.user.company?.licenseExpirationDate,
+        roles: auth.user.roles.map((role) => role.id),
+        features: auth.user.company?.features?.map((feature) => feature.id) ?? [],
+        modules: auth.user.modules.map((module) => ({
+          id: module.id,
+          permissions: module.permissions,
+        })),
+      });
+    }
+  }
+}

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

@@ -0,0 +1,54 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { UserInterface } from "../../user/data/user.interface";
+import { AuthInput, AuthInterface } from "./auth.interface";
+
+export class Auth extends AbstractApiData implements AuthInterface {
+  private _token?: string;
+  private _refreshToken?: string;
+  private _user?: UserInterface;
+
+  get token(): string {
+    if (!this._token) throw new Error("Token is not defined");
+    return this._token;
+  }
+
+  get refreshToken(): string {
+    if (!this._refreshToken) throw new Error("Refresh token is not defined");
+    return this._refreshToken;
+  }
+
+  get user(): UserInterface {
+    if (!this._user) throw new Error("User is not defined");
+    return this._user;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._token = data.jsonApi.attributes.token ?? undefined;
+    this._refreshToken = data.jsonApi.attributes.refreshToken ?? undefined;
+
+    this._user = this._readIncluded(data, "user", Modules.User) as UserInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: AuthInput) {
+    const response: any = {
+      data: {
+        type: Modules.Auth.name,
+        attributes: {},
+      },
+    };
+
+    if (data.id) response.data.id = data.id;
+    if (data.email !== undefined) response.data.attributes.email = data.email;
+    if (data.name !== undefined) response.data.attributes.name = data.name;
+    if (data.companyName !== undefined) response.data.attributes.companyName = data.companyName;
+    if (data.password !== undefined) response.data.attributes.password = data.password;
+    if (data.partitaIva !== undefined) response.data.attributes.partitaIva = data.partitaIva;
+    if (data.codiceFiscale !== undefined) response.data.attributes.codiceFiscale = data.codiceFiscale;
+
+    return response;
+  }
+}

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

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

package/src/features/auth/enums/AuthComponent.ts

@@ -0,0 +1,9 @@
+export enum AuthComponent {
+  Login,
+  ForgotPassword,
+  ResetPassword,
+  ActivateAccount,
+  AcceptInvitation,
+  Register,
+  Landing,
+}

package/src/features/auth/enums/index.ts

@@ -0,0 +1 @@
+export * from "./AuthComponent";

package/src/features/auth/index.ts

@@ -0,0 +1,4 @@
+export * from "./auth.module";
+export { configureAuth, type TokenHandler, type TokenParams } from "./config";
+export * from "./data";
+export * from "./enums";

package/src/features/auth/utils/AuthCookies.ts

@@ -0,0 +1,134 @@
+"use server";
+
+import { cookies } from "next/headers";
+import zlib from "zlib";
+
+export async function updateToken(params: {
+  token?: string;
+  refreshToken?: string;
+  userId?: string;
+  companyId?: string;
+  licenseExpirationDate?: Date;
+  roles?: string[];
+  features?: string[];
+  modules?: {
+    id: string;
+    permissions: {
+      create: boolean | string;
+      read: boolean | string;
+      update: boolean | string;
+      delete: boolean | string;
+    };
+  }[];
+}): Promise<void> {
+  const isProduction = process.env.NODE_ENV === "production";
+
+  if (params.token)
+    (await cookies()).set({
+      name: "token",
+      value: params.token,
+      httpOnly: false,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24),
+    });
+  if (params.refreshToken)
+    (await cookies()).set({
+      name: "refreshToken",
+      value: params.refreshToken,
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.userId)
+    (await cookies()).set({
+      name: "userId",
+      value: params.userId,
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.companyId)
+    (await cookies()).set({
+      name: "companyId",
+      value: params.companyId,
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.licenseExpirationDate)
+    (await cookies()).set({
+      name: "licenseExpirationDate",
+      value: params.licenseExpirationDate.toISOString(),
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.roles)
+    (await cookies()).set({
+      name: "roles",
+      value: JSON.stringify(params.roles),
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.features)
+    (await cookies()).set({
+      name: "features",
+      value: JSON.stringify(params.features),
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+
+  if (params.modules) {
+    const compressedValue = zlib.gzipSync(JSON.stringify(params.modules)).toString("base64");
+
+    (await cookies()).set({
+      name: "modules",
+      value: JSON.stringify(compressedValue),
+      httpOnly: true,
+      path: "/",
+      secure: isProduction,
+      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    });
+  }
+}
+
+export async function removeToken(): Promise<void> {
+  (await cookies()).delete({
+    name: "token",
+  });
+  (await cookies()).delete({
+    name: "refreshToken",
+  });
+  (await cookies()).delete({
+    name: "userId",
+  });
+  (await cookies()).delete({
+    name: "companyId",
+  });
+  (await cookies()).delete({
+    name: "licenseExpirationDate",
+  });
+  (await cookies()).delete({
+    name: "roles",
+  });
+  (await cookies()).delete({
+    name: "features",
+  });
+  (await cookies()).delete({
+    name: "modules",
+  });
+}

package/src/features/auth/utils/index.ts

@@ -0,0 +1 @@
+export * from "./AuthCookies";

package/src/features/company/company.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Company } from ".";
+
+export const CompanyModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/companies",
+    name: "companies",
+    model: Company,
+    moduleId: "f9e77c8f-bfd1-4fd4-80b0-e1d891ab7113",
+  });

package/src/features/company/components/containers/AdminCompanyContainer.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import { getRoleId } from "../../../../roles";
+import { UserInterface } from "../../../user";
+import { AdminUsersList } from "../../../user/components";
+import { useCurrentUserContext } from "../../../user/contexts";
+import { useCompanyContext } from "../../contexts/CompanyContext";
+import { CompanyDetails } from "../details/CompanyDetails";
+
+function AdminCompanyContainerInternal() {
+  const { company } = useCompanyContext();
+  const { hasRole } = useCurrentUserContext<UserInterface>();
+
+  if (!company || !hasRole(getRoleId().Administrator)) return null;
+
+  return (
+    <>
+      <CompanyDetails />
+      <AdminUsersList />
+    </>
+  );
+}
+
+export function AdminCompanyContainer() {
+  return <AdminCompanyContainerInternal />;
+}

package/src/features/company/components/containers/CompanyContainer.tsx

@@ -0,0 +1,17 @@
+"use client";
+
+import { UserInterface } from "../../../user";
+import { useCurrentUserContext } from "../../../user/contexts";
+import { CompanyProvider } from "../../contexts/CompanyContext";
+import { CompanyDetails } from "../details/CompanyDetails";
+
+export function CompanyContainer() {
+  const { currentUser } = useCurrentUserContext<UserInterface>();
+  if (!currentUser) return null;
+
+  return (
+    <CompanyProvider dehydratedCompany={currentUser.company}>
+      <CompanyDetails />
+    </CompanyProvider>
+  );
+}

package/src/features/company/components/containers/index.ts

@@ -0,0 +1,2 @@
+export * from "./AdminCompanyContainer";
+export * from "./CompanyContainer";

package/src/features/company/components/details/CompanyDetails.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import Image from "next/image";
+import { ContentTitle } from "../../../../components";
+import { useSharedContext } from "../../../../contexts";
+import { usePageUrlGenerator } from "../../../../hooks";
+import { useCompanyContext } from "../../contexts/CompanyContext";
+
+export function CompanyDetails() {
+  const t = useTranslations();
+  const { title } = useSharedContext();
+  const generateUrl = usePageUrlGenerator();
+
+  const { company } = useCompanyContext();
+  if (!company) return null;
+
+  return (
+    <div className="flex w-full flex-col gap-y-2">
+      <ContentTitle type={title.type} element={title.element} functions={title.functions} />
+      {company.logo && (
+        <Image src={company.logo} alt={company.name} width={150} height={150} className="mb-4 rounded-md" />
+      )}
+    </div>
+  );
+}

package/src/features/company/components/details/index.ts

@@ -0,0 +1 @@
+export * from "./CompanyDetails";