@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

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

@@ -0,0 +1,106 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { createContext, ReactNode, useContext, useState } from "react";
+import { SharedProvider } from "../../../contexts";
+import { JsonApiHydratedDataInterface, Modules, rehydrate } from "../../../core";
+import { usePageUrlGenerator } from "../../../hooks";
+import { BreadcrumbItemData } from "../../../interfaces";
+import { Action } from "../../../permissions";
+import { UserDeleter, UserEditor, UserReactivator, UserResentInvitationEmail } from "../components/forms";
+import { UserInterface } from "../data";
+import { useCurrentUserContext } from "./CurrentUserContext";
+
+interface UserContextType {
+  user: UserInterface | undefined;
+  setUser: (value: UserInterface | undefined) => void;
+}
+
+const UserContext = createContext<UserContextType | undefined>(undefined);
+
+type UserProviderProps = {
+  children: ReactNode;
+  dehydratedUser?: JsonApiHydratedDataInterface;
+};
+
+export const UserProvider = ({ children, dehydratedUser }: UserProviderProps) => {
+  const generateUrl = usePageUrlGenerator();
+  const { hasPermissionToModule } = useCurrentUserContext<UserInterface>();
+  const t = useTranslations();
+
+  const [user, setUser] = useState<UserInterface | undefined>(
+    dehydratedUser ? rehydrate<UserInterface>(Modules.User, dehydratedUser) : undefined,
+  );
+
+  const breadcrumb = () => {
+    const response: BreadcrumbItemData[] = [];
+
+    if (hasPermissionToModule({ module: Modules.User, action: Action.Update })) {
+      response.push({
+        name: t(`generic.settings`),
+        href: generateUrl({ page: `/settings` }),
+      });
+
+      response.push({
+        name: t(`types.users`, { count: 2 }),
+        href: generateUrl({ page: `/settings`, id: Modules.User.pageUrl }),
+      });
+    }
+
+    if (user)
+      response.push({
+        name: `${user.name}${user.isDeleted ? ` (${t(`foundations.user.deleted`)})` : ""}`,
+        href: generateUrl({ page: Modules.User, id: user.id }),
+      });
+
+    return response;
+  };
+
+  const title = () => {
+    const response: any = {
+      type: t(`types.users`, { count: user ? 1 : 2 }),
+    };
+
+    const functions: ReactNode[] = [];
+
+    if (user) {
+      response.element = `${user.name}${user.isDeleted ? ` (${t(`foundations.user.deleted`)})` : ""}`;
+
+      if (user.isDeleted) {
+        functions.push(<UserReactivator key={`UserReactivator`} user={user} propagateChanges={setUser} />);
+      } else {
+        if (!user.isActivated)
+          functions.push(<UserResentInvitationEmail key={`UserResentInvitationEmail`} user={user} />);
+
+        functions.push(<UserDeleter key={`UserDeleter`} user={user} />);
+      }
+
+      functions.push(<UserEditor key={`UserEditor`} user={user} propagateChanges={setUser} />);
+    }
+
+    if (functions.length > 0) response.functions = functions;
+
+    return response;
+  };
+
+  return (
+    <SharedProvider value={{ breadcrumbs: breadcrumb(), title: title() }}>
+      <UserContext.Provider
+        value={{
+          user: user,
+          setUser: setUser,
+        }}
+      >
+        {children}
+      </UserContext.Provider>
+    </SharedProvider>
+  );
+};
+
+export const useUserContext = (): UserContextType => {
+  const context = useContext(UserContext);
+  if (context === undefined) {
+    throw new Error("useUserContext must be used within a UserProvider");
+  }
+  return context;
+};

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

@@ -0,0 +1,2 @@
+export * from "./CurrentUserContext";
+export * from "./UserContext";

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

@@ -0,0 +1,4 @@
+export * from "./user";
+export * from "./user.fields";
+export * from "./user.interface";
+export * from "./user.service";

package/src/features/user/data/user.fields.ts

@@ -0,0 +1,8 @@
+export enum UserFields {
+  userId = "userId",
+  name = "name",
+  email = "email",
+  relevance = "relevance",
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

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

@@ -0,0 +1,41 @@
+import { CompanyInterface } from "../../company/data/company.interface";
+import { ModuleInterface } from "../../module/data/module.interface";
+import { RoleInterface } from "../../role/data/role.interface";
+import { ApiDataInterface } from "../../../core";
+
+export type UserInput = {
+  id: string;
+  email?: string | undefined | null;
+  name?: string;
+  title?: string;
+  bio?: string;
+  password?: string | undefined;
+  roleIds?: string[];
+  sendInvitationEmail?: boolean;
+  companyId?: string;
+  adminCreated?: boolean;
+  avatar?: string;
+  phone?: string;
+  rate?: number;
+};
+
+export interface UserInterface extends ApiDataInterface {
+  get email(): string;
+  get name(): string;
+  get title(): string;
+  get bio(): string;
+  get avatar(): string | undefined;
+  get avatarUrl(): string | undefined;
+  get phone(): string | undefined;
+  get rate(): number | undefined;
+
+  get isActivated(): boolean;
+  get isDeleted(): boolean;
+  get lastLogin(): Date | undefined;
+
+  get relevance(): number | undefined;
+
+  get roles(): RoleInterface[];
+  get company(): CompanyInterface | undefined;
+  get modules(): ModuleInterface[];
+}

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

@@ -0,0 +1,246 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { UserInput, UserInterface } from "./user.interface";
+
+export class UserService extends AbstractService {
+  static async findFullUser(): Promise<UserInterface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: "me", childEndpoint: "full" });
+
+    return this.callApi<UserInterface>({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  static async findById(params: { userId: string }): Promise<UserInterface> {
+    return this.callApi<UserInterface>({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate(),
+    });
+  }
+
+  static async findByEmail(params: { email: string }): Promise<UserInterface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: "email", childEndpoint: params.email });
+
+    return this.callApi<UserInterface>({ type: Modules.User, method: HttpMethod.GET, endpoint: endpoint.generate() });
+  }
+
+  static async findMany(params: {
+    roleId?: string;
+    search?: string;
+    fetchAll?: boolean;
+    includeDeleted?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User });
+
+    if (params.roleId) endpoint.addAdditionalParam("roleId", params.roleId);
+
+    if (params.includeDeleted) endpoint.addAdditionalParam("includeDeleted", "true");
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findManyByContentIds(params: {
+    contentIds: string[];
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User });
+
+    endpoint.addAdditionalParam("contentIds", params.contentIds.map((id) => id).join(","));
+    endpoint.addAdditionalParam("includeDeleted", "true");
+    endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findRelevant(params: { id: string; next?: NextRef; prev?: PreviousRef }): Promise<UserInterface[]> {
+    const endpoint: EndpointCreator = new EndpointCreator({
+      endpoint: Modules.Content,
+      id: params.id,
+      childEndpoint: "user-relevance",
+    });
+
+    if (Modules.User.inclusions?.lists?.fields) endpoint.limitToFields(Modules.User.inclusions.lists.fields);
+    if (Modules.User.inclusions?.lists?.types) endpoint.limitToType(Modules.User.inclusions.lists.types);
+
+    return this.callApi<UserInterface[]>({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findManyForAmin(params: {
+    companyId?: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    if (!params.companyId) return [];
+
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Company,
+      id: params.companyId,
+      childEndpoint: Modules.User,
+    });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.prev,
+    });
+  }
+
+  static async findAllUsers(params: {
+    companyId: string;
+    search?: string;
+    limitToRoles?: string[];
+    isDeleted?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Company,
+      id: params.companyId,
+      childEndpoint: Modules.User,
+    });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (params.isDeleted) endpoint.addAdditionalParam("isDeleted", "true");
+    if (params.limitToRoles && params.limitToRoles.length > 0)
+      endpoint.addAdditionalParam("limitToRoles", params.limitToRoles.join(","));
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllUsersByRole(params: {
+    roleId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Role, id: params.roleId, childEndpoint: Modules.User });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllUsersNotInRole(params: {
+    roleId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<UserInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Role,
+      id: params.roleId,
+      childEndpoint: Modules.User,
+    }).addAdditionalParam("notInRole", "true");
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async create(params: UserInput): Promise<UserInterface> {
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.User }).generate(),
+      companyId: params.companyId,
+      input: params,
+    });
+  }
+
+  static async reactivate(params: { userId: string }): Promise<UserInterface> {
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.PATCH,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate(),
+    });
+  }
+
+  static async sendInvitation(params: { userId: string; companyId?: string }): Promise<void> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.User,
+      id: params.userId,
+      childEndpoint: "send-invitation-email",
+    });
+
+    if (params.companyId) endpoint.addAdditionalParam("companyId", params.companyId);
+
+    this.callApi({
+      type: Modules.User,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  static async update(params: UserInput): Promise<UserInterface> {
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.id }).generate(),
+      companyId: params.companyId,
+      input: params,
+    });
+  }
+
+  static async patchRate(params: UserInput): Promise<UserInterface> {
+    return this.callApi({
+      type: Modules.User,
+      method: HttpMethod.PATCH,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.id, childEndpoint: "rates" }).generate(),
+      companyId: params.companyId,
+      input: params,
+    });
+  }
+
+  static async delete(params: { userId: string; companyId: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.User,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate(),
+      companyId: params.companyId,
+    });
+  }
+}

package/src/features/user/data/user.ts

@@ -0,0 +1,162 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { CompanyInterface } from "../../company";
+import { ModuleInterface } from "../../module";
+import { RoleInterface } from "../../role";
+import { SearchResultInterface } from "../../search";
+import { UserInput, UserInterface } from "./user.interface";
+
+export class User extends AbstractApiData implements UserInterface, SearchResultInterface {
+  private _name?: string;
+  private _email?: string;
+  private _title?: string;
+  private _bio?: string;
+  private _avatar?: string;
+  private _avatarUrl?: string;
+  private _phone?: string;
+  private _rate?: number;
+
+  private _isActivated?: boolean;
+  private _isDeleted?: boolean;
+  private _lastLogin?: Date;
+
+  private _relevance?: number;
+
+  private _roles: RoleInterface[] = [];
+  private _company?: CompanyInterface;
+  private _modules: ModuleInterface[] = [];
+
+  get searchResult(): string {
+    return this._name ?? "";
+  }
+
+  get name(): string {
+    return this._name ?? "";
+  }
+
+  get email(): string {
+    return this._email ?? "";
+  }
+
+  get title(): string {
+    return this._title ?? "";
+  }
+
+  get bio(): string {
+    return this._bio ?? "";
+  }
+
+  get avatar(): string | undefined {
+    return this._avatar;
+  }
+
+  get avatarUrl(): string | undefined {
+    return this._avatarUrl;
+  }
+
+  get phone(): string | undefined {
+    return this._phone;
+  }
+
+  get rate(): number | undefined {
+    return this._rate;
+  }
+
+  get relevance(): number | undefined {
+    return this._relevance;
+  }
+
+  get isActivated(): boolean {
+    return this._isActivated ?? false;
+  }
+
+  get isDeleted(): boolean {
+    return this._isDeleted ?? false;
+  }
+
+  get lastLogin(): Date | undefined {
+    return this._lastLogin;
+  }
+
+  get roles(): RoleInterface[] {
+    return this._roles;
+  }
+
+  get company(): CompanyInterface | undefined {
+    return this._company;
+  }
+
+  get modules(): ModuleInterface[] {
+    return this._modules;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._email = data.jsonApi.attributes.email;
+    this._title = data.jsonApi.attributes.title;
+    this._bio = data.jsonApi.attributes.bio;
+    this._phone = data.jsonApi.attributes.phone;
+    this._rate = data.jsonApi.attributes.rate;
+
+    this._avatar = data.jsonApi.attributes.avatar;
+    this._avatarUrl = data.jsonApi.attributes.avatarUrl;
+
+    this._isActivated = data.jsonApi.meta.isActive;
+    this._isDeleted = data.jsonApi.meta.isDeleted;
+    this._lastLogin = data.jsonApi.meta.lastLogin ? new Date(data.jsonApi.meta.lastLogin) : undefined;
+
+    this._relevance = data.jsonApi.meta.relevance;
+
+    this._roles = this._readIncluded(data, "roles", Modules.Role) as RoleInterface[];
+    this._company = this._readIncluded(data, "company", Modules.Company) as CompanyInterface;
+    this._modules = this._readIncluded(data, "modules", Modules.Module) as ModuleInterface[];
+
+    return this;
+  }
+
+  createJsonApi(data: UserInput) {
+    const response: any = {
+      data: {
+        type: Modules.User.name,
+        id: data.id,
+        attributes: {
+          name: data.name,
+        },
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.email !== undefined) response.data.attributes.email = data.email;
+    if (data.title !== undefined) response.data.attributes.title = data.title;
+    if (data.bio !== undefined) response.data.attributes.bio = data.bio;
+    if (data.phone !== undefined) response.data.attributes.phone = data.phone;
+    if (data.password !== undefined) response.data.attributes.password = data.password;
+    if (data.sendInvitationEmail) response.data.attributes.sendInvitationEmail = true;
+    if (data.adminCreated) response.data.attributes.adminCreated = true;
+    if (data.avatar) response.data.attributes.avatar = data.avatar;
+    if (data.rate !== undefined) response.data.attributes.rate = data.rate;
+
+    if (data.roleIds) {
+      response.data.relationships.roles = {
+        data: data.roleIds.map((roleId) => ({
+          type: Modules.Role.name,
+          id: roleId,
+        })),
+      };
+    }
+
+    if (data.companyId) {
+      response.data.relationships.company = {
+        data: {
+          type: Modules.Company.name,
+          id: data.companyId,
+        },
+      };
+    }
+
+    return response;
+  }
+}

package/src/features/user/hooks/index.ts

@@ -0,0 +1,2 @@
+export * from "./useUserSearch";
+export * from "./useUserTableStructure";

package/src/features/user/hooks/useUserSearch.ts

@@ -0,0 +1,53 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useDebounce } from "../../../hooks/useDebounce";
+import { UserInterface, UserService } from "../data";
+
+export const useUserSearch = () => {
+  const [users, setUsers] = useState<UserInterface[]>([]);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const searchQueryRef = useRef("");
+
+  const loadUsers = useCallback(
+    async (search: string) => {
+      try {
+        if (search === searchQueryRef.current && users.length > 0) return;
+        setIsLoading(true);
+        searchQueryRef.current = search;
+        const fetchedUsers = await UserService.findMany({ search, fetchAll: true });
+        setUsers(fetchedUsers);
+      } catch (error) {
+        console.error("Failed to load users:", error);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [users.length],
+  );
+
+  const debouncedLoadUsers = useDebounce(loadUsers, 500);
+
+  useEffect(() => {
+    if (searchQuery !== searchQueryRef.current) {
+      setIsLoading(true);
+      debouncedLoadUsers(searchQuery);
+    }
+  }, [searchQuery, debouncedLoadUsers]);
+
+  const clearSearch = () => {
+    setSearchQuery("");
+    searchQueryRef.current = "";
+  };
+
+  return {
+    users,
+    searchQuery,
+    setSearchQuery,
+    isLoading,
+    loadUsers,
+    clearSearch,
+    searchQueryRef,
+  };
+};