@carlonicora/nextjs-jsonapi 0.0.1 → 1.0.4

package/src/features/user/components/lists/ContributorsList.tsx

@@ -0,0 +1,41 @@
+"use client";
+
+import { Modules } from "../../../../core";
+import { usePageUrlGenerator } from "../../../../hooks";
+import { Link } from "../../../../shadcnui";
+import { ContentInterface } from "../../../content";
+import { UserInterface } from "../../data";
+import { UserAvatar } from "../widgets";
+
+type ContributorsListProps = {
+  content: ContentInterface;
+};
+
+export function ContributorsList({ content }: ContributorsListProps) {
+  const generateUrl = usePageUrlGenerator();
+
+  return (
+    <div className="flex flex-row items-center">
+      <Link
+        key={content.author.id}
+        href={generateUrl({ page: Modules.User, id: content.author.id })}
+        onClick={(e) => e.stopPropagation()}
+      >
+        <UserAvatar user={content.author} className="mr-1 h-6 w-6" />
+      </Link>
+      <div className="flex flex-row-reverse justify-end -space-x-1 space-x-reverse">
+        {content.editors
+          .filter((editor: UserInterface) => editor.id !== content.author.id)
+          .map((editor: UserInterface) => (
+            <Link
+              key={editor.id}
+              href={generateUrl({ page: Modules.User, id: editor.id })}
+              onClick={(e) => e.stopPropagation()}
+            >
+              <UserAvatar user={editor} className="h-5 w-5" />
+            </Link>
+          ))}
+      </div>
+    </div>
+  );
+}

package/src/features/user/components/lists/index.ts

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

package/src/features/user/components/widgets/UserAvatar.tsx

@@ -0,0 +1,86 @@
+"use client";
+
+import { Modules } from "../../../../core";
+import { usePageUrlGenerator } from "../../../../hooks";
+import {
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Link,
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "../../../../shadcnui";
+import { cn } from "../../../../utils";
+import { UserInterface } from "../../data";
+
+type UserAvatarProps = {
+  user: UserInterface;
+  className?: string;
+  showFull?: boolean;
+  showLink?: boolean;
+};
+
+export function UserAvatar({ user, className, showFull, showLink }: UserAvatarProps) {
+  const generateUrl = usePageUrlGenerator();
+
+  const getInitial = (param?: string) => {
+    if (!param) return "";
+    return param[0].toUpperCase();
+  };
+
+  const getInitials = (name: string) => {
+    const words = name.split(" ");
+    const initials =
+      words.length > 1 ? getInitial(words[0][0]) + getInitial(words[words.length - 1][0]) : getInitial(words[0][0]);
+
+    return initials ?? "";
+  };
+
+  const getAvatar = () => {
+    return (
+      <div className="*:ring-border *:ring-1">
+        <Avatar className={`h-6 w-6 ${className}`}>
+          <AvatarImage className="object-cover" src={user?.avatar} />
+          <AvatarFallback>{getInitials(user.name)}</AvatarFallback>
+        </Avatar>
+      </div>
+    );
+  };
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        {showLink === false ? (
+          // If showLink is explicitly false, never show a link
+          showFull ? (
+            <div className={cn(`mb-2 flex w-full flex-row items-center justify-start gap-x-2 text-sm`, className)}>
+              {getAvatar()}
+              {user.name}
+            </div>
+          ) : (
+            getAvatar()
+          )
+        ) : showFull ? (
+          <Link
+            href={generateUrl({ page: Modules.User, id: user.id })}
+            className={cn(`mb-2 flex w-full flex-row items-center justify-start gap-x-2 text-sm`, className)}
+            onClick={(e) => e.stopPropagation()}
+          >
+            <div className="flex w-full flex-row items-center gap-x-2">
+              {getAvatar()}
+              {user.name}
+            </div>
+          </Link>
+        ) : showLink ? (
+          <Link href={generateUrl({ page: Modules.User, id: user.id })} className={className}>
+            {getAvatar()}
+          </Link>
+        ) : (
+          getAvatar()
+        )}
+      </TooltipTrigger>
+      <TooltipContent>{user.name}</TooltipContent>
+    </Tooltip>
+  );
+}

package/src/features/user/components/widgets/index.ts

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

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

@@ -0,0 +1,156 @@
+"use client";
+
+import { getCookie } from "cookies-next";
+import { useAtom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import { usePathname } from "next/navigation";
+import React, { createContext, useContext, useEffect } from "react";
+import { Modules, rehydrate } from "../../../core";
+import { Action, checkPermissions, ModuleWithPermissions } from "../../../permissions";
+import { getRoleId } from "../../../roles";
+import { CompanyInterface } from "../../company";
+import { FeatureInterface } from "../../feature";
+import { RoleInterface } from "../../role";
+import { UserInterface } from "../data";
+
+export interface CurrentUserContextType<T extends UserInterface = UserInterface> {
+  currentUser: T | null;
+  company: CompanyInterface | null;
+  setUser: (user?: T) => void;
+  hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
+    module: M;
+    action: Action;
+    data?: any;
+  }) => boolean;
+  hasPermissionToModules: <M extends ModuleWithPermissions>(params: {
+    modules: M[];
+    action: Action;
+    data?: any;
+  }) => boolean;
+  hasPermissionToPath: (path: string) => boolean;
+  hasAccesToFeature: (featureIdentifier: string) => boolean;
+  matchUrlToModule: (prarms?: { path: string }) => ModuleWithPermissions | undefined;
+  hasRole: (roleId: string) => boolean;
+}
+
+const userAtom = atomWithStorage("user", null);
+
+const CurrentUserContext = createContext<CurrentUserContextType | undefined>(undefined);
+
+export const CurrentUserProvider = ({ children }: { children: React.ReactNode }) => {
+  const path = usePathname();
+
+  const [dehydratedUser, setDehydratedUser] = useAtom(userAtom);
+
+  useEffect(() => {
+    const token = getCookie("token");
+    if (!token && dehydratedUser) setDehydratedUser(null);
+  }, [dehydratedUser, setDehydratedUser]);
+
+  const matchUrlToModule = (params?: { path: string }): ModuleWithPermissions | undefined => {
+    const moduleKeys = Object.getOwnPropertyNames(Modules).filter(
+      (key) => key !== "prototype" && key !== "_factory" && key !== "length" && key !== "name",
+    );
+
+    const matchedModuleKey = moduleKeys.find((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(Modules, key);
+
+      if (!descriptor?.get) return false;
+
+      const selectedModule = descriptor.get.call(Modules);
+
+      return path.toLowerCase().startsWith(selectedModule.pageUrl?.toLowerCase());
+    });
+
+    if (!matchedModuleKey) return undefined;
+
+    const descriptor = Object.getOwnPropertyDescriptor(Modules, matchedModuleKey);
+    return descriptor?.get?.call(Modules);
+  };
+
+  const currentUser = dehydratedUser ? rehydrate<UserInterface>(Modules.User, dehydratedUser) : null;
+
+  const company = currentUser?.company ?? null;
+
+  const setUser = (user?: UserInterface): void => {
+    if (user) setDehydratedUser(user.dehydrate() as any);
+    else setDehydratedUser(null);
+  };
+
+  const hasRole = (roleId: string): boolean => {
+    if (!currentUser) return false;
+
+    return !!currentUser.roles?.some((userRole: RoleInterface) => userRole.id === roleId);
+  };
+
+  const hasAccesToFeature = (featureIdentifier: string): boolean => {
+    if (hasRole(getRoleId().Administrator)) return true;
+    if (!company) return false;
+
+    return company.features.some((feature: FeatureInterface) => feature.id === featureIdentifier);
+  };
+
+  function hasPermissionToModule<M extends ModuleWithPermissions>(params: {
+    module: M;
+    action: Action;
+    data?: M extends ModuleWithPermissions ? any : never;
+  }): boolean {
+    if (!currentUser) return false;
+
+    if (!!params.module.feature && !hasAccesToFeature(params.module.feature)) return false;
+
+    return checkPermissions({ module: params.module, action: params.action, data: params.data, user: currentUser });
+  }
+
+  function hasPermissionToModules<M extends ModuleWithPermissions>(params: {
+    modules: M[];
+    action: Action;
+    data?: M extends ModuleWithPermissions ? any : never;
+  }): boolean {
+    if (!currentUser) return false;
+
+    if (!params.modules.every((module) => !module.feature || hasAccesToFeature(module.feature))) return false;
+
+    return params.modules.every((module) =>
+      checkPermissions({ module: module, action: params.action, data: params.data, user: currentUser }),
+    );
+  }
+
+  function hasPermissionToPath(path: string): boolean {
+    if (!currentUser) return false;
+    if (path === "#" || path === "/") return true;
+
+    const selectedModule = matchUrlToModule({ path: path });
+    if (!selectedModule) return true;
+
+    const response = hasPermissionToModule({ module: selectedModule, action: Action.Read });
+
+    return response;
+  }
+
+  return (
+    <CurrentUserContext.Provider
+      value={{
+        currentUser: currentUser,
+        company: company,
+        setUser: setUser,
+        hasPermissionToModule: hasPermissionToModule,
+        hasPermissionToModules: hasPermissionToModules,
+        hasPermissionToPath: hasPermissionToPath,
+        hasAccesToFeature: hasAccesToFeature,
+        matchUrlToModule: matchUrlToModule,
+        hasRole: hasRole,
+      }}
+    >
+      {children}
+    </CurrentUserContext.Provider>
+  );
+};
+
+export function useCurrentUserContext<T extends UserInterface = UserInterface>(): CurrentUserContextType<T> {
+  const context = useContext(CurrentUserContext);
+  if (context === undefined) {
+    throw new Error("useCurrentUserContext must be used within a UserProvider");
+  }
+  return context as unknown as CurrentUserContextType<T>;
+}

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

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

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,
+    });
+  }
+}