@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/features/role/contexts/RoleContext.tsx

@@ -0,0 +1,84 @@
+"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 { RoleInterface } from "../data";
+
+interface RoleContextType {
+  role: RoleInterface | undefined;
+  setRole: (value: RoleInterface | undefined) => void;
+}
+
+const RoleContext = createContext<RoleContextType | undefined>(undefined);
+
+type RoleProviderProps = {
+  children: ReactNode;
+  dehydratedRole?: JsonApiHydratedDataInterface;
+};
+
+export const RoleProvider = ({ children, dehydratedRole }: RoleProviderProps) => {
+  const generateUrl = usePageUrlGenerator();
+  const t = useTranslations();
+
+  const [role, setRole] = useState<RoleInterface | undefined>(
+    dehydratedRole ? rehydrate<RoleInterface>(Modules.Role, dehydratedRole) : undefined,
+  );
+
+  const breadcrumb = () => {
+    const response: BreadcrumbItemData[] = [];
+
+    response.push({
+      name: t(`types.roles`, { count: 2 }),
+      href: generateUrl({ page: Modules.Role }),
+    });
+
+    if (role)
+      response.push({
+        name: role.name,
+        href: generateUrl({ page: Modules.Role, id: role.id }),
+      });
+
+    return response;
+  };
+
+  const title = () => {
+    const response: any = {
+      type: t(`types.roles`, { count: role ? 1 : 2 }),
+    };
+
+    const functions: ReactNode[] = [];
+
+    if (role) {
+      response.element = role.name;
+    }
+
+    if (functions.length > 0) response.functions = functions;
+
+    return response;
+  };
+
+  return (
+    <SharedProvider value={{ breadcrumbs: breadcrumb(), title: title() }}>
+      <RoleContext.Provider
+        value={{
+          role: role,
+          setRole: setRole,
+        }}
+      >
+        {children}
+      </RoleContext.Provider>
+    </SharedProvider>
+  );
+};
+
+export const useRoleContext = (): RoleContextType => {
+  const context = useContext(RoleContext);
+  if (context === undefined) {
+    throw new Error("useRoleContext must be used within a RoleProvider");
+  }
+  return context;
+};

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

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

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

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

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

@@ -0,0 +1,8 @@
+export enum RoleFields {
+  roleId = "roleId",
+  name = "name",
+  description = "description",
+
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

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

@@ -0,0 +1,16 @@
+import { ApiDataInterface } from "../../../core";
+import { FeatureInterface } from "../../feature";
+
+export type RoleInput = {
+  id: string;
+  name: string;
+  description?: string;
+};
+
+export interface RoleInterface extends ApiDataInterface {
+  get name(): string;
+  get description(): string;
+  get isSelectable(): boolean;
+
+  get requiredFeature(): FeatureInterface | undefined;
+}

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

@@ -0,0 +1,117 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { RoleInput, RoleInterface } from "./role.interface";
+
+export class RoleService extends AbstractService {
+  static async findById(params: { roleId: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+    });
+  }
+
+  static async findAllRoles(params: { search?: string; next?: NextRef }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Role });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllRolesByUser(params: {
+    userId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: params.userId, childEndpoint: Modules.Role });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllRolesUserNotIn(params: {
+    userId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.User,
+      id: params.userId,
+      childEndpoint: Modules.Role,
+    }).addAdditionalParam("userNotIn", "true");
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async addUserToRole(params: { userId: string; roleId: string }): Promise<void> {
+    this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId,
+      }).generate(),
+    });
+  }
+
+  static async removeUserFromRole(params: { userId: string; roleId: string }): Promise<void> {
+    this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId,
+      }).generate(),
+    });
+  }
+
+  static async create(params: { roleId: string; name: string; description?: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description } as RoleInput,
+    });
+  }
+
+  static async update(params: { roleId: string; name: string; description?: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description } as RoleInput,
+    });
+  }
+
+  static async delete(params: { roleId: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+    });
+  }
+}

package/src/features/role/data/role.ts

@@ -0,0 +1,62 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { FeatureInterface } from "../../feature";
+import { RoleInput, RoleInterface } from "./role.interface";
+
+export class Role extends AbstractApiData implements RoleInterface {
+  private _name?: string;
+  private _description?: string;
+  private _isSelectable?: boolean;
+
+  private _requiredFeature?: FeatureInterface;
+
+  get name(): string {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name;
+  }
+
+  get description(): string {
+    return this._description ?? "";
+  }
+
+  get isSelectable(): boolean {
+    return this._isSelectable ?? false;
+  }
+
+  get requiredFeature(): FeatureInterface | undefined {
+    return this._requiredFeature;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name ?? undefined;
+    this._description = data.jsonApi.attributes.description ?? undefined;
+    this._isSelectable = data.jsonApi.attributes.isSelectable ?? undefined;
+
+    this._requiredFeature = this._readIncluded<FeatureInterface>(
+      data,
+      "requiredFeature",
+      Modules.Feature,
+    ) as FeatureInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: RoleInput) {
+    const response: any = {
+      data: {
+        type: Modules.Role.name,
+        id: data.id,
+        attributes: {
+          name: data.name,
+        },
+        meta: {},
+      },
+      included: [],
+    };
+
+    if (data.description !== undefined) response.data.attributes.description = data.description;
+
+    return response;
+  }
+}

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

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

package/src/features/role/hooks/useRoleTableStructure.tsx

@@ -0,0 +1,72 @@
+"use client";
+
+import { ColumnDef, Row } from "@tanstack/react-table";
+import { useTranslations } from "next-intl";
+import { useMemo } from "react";
+import { cellDate, cellId } from "../../../components";
+import { Modules } from "../../../core";
+import { TableContent, usePageUrlGenerator, UseTableStructureHook } from "../../../hooks";
+import { Link } from "../../../shadcnui";
+import { RoleFields, RoleInterface } from "../data";
+
+export const useRoleTableStructure: UseTableStructureHook<RoleInterface, RoleFields> = (params) => {
+  const t = useTranslations();
+  const generateUrl = usePageUrlGenerator();
+
+  // Memoize tableData to prevent infinite re-renders
+  const tableData = useMemo(() => {
+    return params.data.map((role: RoleInterface) => {
+      const entry: TableContent<RoleInterface> = {
+        jsonApiData: role,
+      };
+      entry[RoleFields.roleId] = role.id;
+      params.fields.forEach((field) => {
+        entry[field] = role[field as keyof RoleInterface];
+      });
+      return entry;
+    });
+  }, [params.data, params.fields]);
+
+  const fieldColumnMap: Partial<Record<RoleFields, () => any>> = {
+    [RoleFields.roleId]: () =>
+      cellId({
+        name: "roleId",
+        checkedIds: params.checkedIds,
+        toggleId: params.toggleId,
+      }),
+    [RoleFields.name]: () => ({
+      id: "name",
+      accessorKey: "name",
+      header: t(`foundations.role.fields.name.label`),
+      cell: ({ row }: { row: Row<TableContent<RoleInterface>> }) => {
+        const role = row.original.jsonApiData as RoleInterface;
+        return <Link href={generateUrl({ page: Modules.Role, id: role.id })}>{row.getValue("name")}</Link>;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [RoleFields.description]: () => ({
+      id: "description",
+      accessorKey: "description",
+      header: t(`foundations.role.fields.description.label`),
+      cell: ({ row }: { row: Row<TableContent<RoleInterface>> }) => <>{row.getValue("description")}</>,
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [RoleFields.createdAt]: () =>
+      cellDate({
+        name: "createdAt",
+        title: t(`generic.date.create`),
+      }),
+  };
+
+  // Memoize columns to prevent infinite re-renders
+  const columns = useMemo(() => {
+    return params.fields.map((field) => fieldColumnMap[field]?.()).filter((col) => col !== undefined) as ColumnDef<
+      TableContent<RoleInterface>
+    >[];
+  }, [params.fields, fieldColumnMap, t, generateUrl]);
+
+  // Memoize the return object to prevent infinite re-renders
+  return useMemo(() => ({ data: tableData, columns: columns }), [tableData, columns]);
+};

package/src/features/role/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./role.module";

package/src/features/role/role.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Role } from "./data/role";
+
+export const RoleModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/roles",
+    name: "roles",
+    model: Role,
+    moduleId: "9f6416e6-7b9b-4e1a-a99f-833191eca8a9",
+  });

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

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

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

@@ -0,0 +1,11 @@
+import { ApiDataInterface } from "../../../core";
+
+export type S3Input = {
+  key: string;
+  contentType?: string;
+};
+
+export interface S3Interface extends ApiDataInterface {
+  get url(): string;
+  get headers(): Record<string, string>;
+}

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

@@ -0,0 +1,30 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { S3Interface } from "./s3.interface";
+
+export class S3Service extends AbstractService {
+  static async getPreSignedUrl(params: { key: string; contentType: string; isPublic?: boolean }): Promise<S3Interface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3 })
+      .addAdditionalParam("key", params.key)
+      .addAdditionalParam("contentType", params.contentType);
+
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+
+    return this.callApi<S3Interface>({ type: Modules.S3, method: HttpMethod.GET, endpoint: endpoint.generate() });
+  }
+
+  static async getSignedUrl(params: { key: string; isPublic?: boolean }): Promise<S3Interface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3, id: "sign" }).addAdditionalParam("key", params.key);
+
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+
+    return this.callApi<S3Interface>({ type: Modules.S3, method: HttpMethod.GET, endpoint: endpoint.generate() });
+  }
+
+  static async deleteFile(params: { key: string }): Promise<void> {
+    this.callApi<S3Interface>({
+      type: Modules.S3,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.S3 }).addAdditionalParam("key", params.key).generate(),
+    });
+  }
+}

package/src/features/s3/data/s3.ts

@@ -0,0 +1,60 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { S3Input, S3Interface } from "./s3.interface";
+
+export class S3 extends AbstractApiData implements S3Interface {
+  private _url?: string;
+  private _storageType?: string;
+  private _contentType?: string;
+  private _blobType?: string;
+  private _acl?: string;
+
+  get url(): string {
+    if (!this._url) throw new Error("Image URL is not set.");
+    return this._url;
+  }
+
+  get headers(): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+    if (this._contentType) {
+      headers["Content-Type"] = this._contentType;
+    }
+
+    if (this._blobType) {
+      headers["x-ms-blob-type"] = this._blobType;
+    }
+
+    if (this._acl) {
+      headers["x-amz-acl"] = this._acl;
+    }
+
+    return headers;
+  }
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._url = data.jsonApi.attributes.url ?? undefined;
+    this._storageType = data.jsonApi.attributes.storageType ?? undefined;
+    this._contentType = data.jsonApi.attributes.contentType ?? undefined;
+    this._blobType = data.jsonApi.attributes.blobType ?? undefined;
+    this._acl = data.jsonApi.attributes.acl ?? undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: S3Input) {
+    const response: any = {
+      data: {
+        type: Modules.S3.name,
+        attributes: {
+          key: data.key,
+        },
+      },
+      included: [],
+    };
+
+    if (data.contentType) response.data.attributes.contentType = data.contentType;
+
+    return response;
+  }
+}

package/src/features/s3/index.ts

@@ -0,0 +1,2 @@
+export * from "./s3.module";
+export * from "./data";

package/src/features/s3/s3.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { S3 } from "./data/s3";
+
+export const S3Module = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/s3",
+    name: "s3",
+    model: S3,
+    moduleId: "db41ba46-e171-4324-8845-99353eba8568",
+  });

package/src/features/search/index.ts

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

package/src/features/search/interfaces/index.ts

@@ -0,0 +1 @@
+export * from "./search.result.interface";

package/src/features/search/interfaces/search.result.interface.ts

@@ -0,0 +1,3 @@
+export interface SearchResultInterface {
+  get searchResult(): string;
+}

package/src/features/user/author.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { User } from "./data";
+
+export const AuthorModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/authors",
+    name: "authors",
+    model: User,
+    moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277",
+  });

package/src/features/user/components/containers/UserContainer.tsx

@@ -0,0 +1,23 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { useUserContext } from "../../contexts";
+import { UserDetails } from "../details";
+
+export function UserContainer() {
+  const { user } = useUserContext();
+  if (!user) return null;
+
+  const t = useTranslations();
+
+  return (
+    <div className="flex w-full gap-x-4">
+      <div className="w-2xl flex h-[calc(100vh-theme(spacing.20))] flex-col justify-between border-r pr-4">
+        <div className="flex h-full overflow-y-auto">
+          <UserDetails user={user} />
+        </div>
+      </div>
+      <div className="flex w-full flex-col gap-y-4"></div>
+    </div>
+  );
+}

package/src/features/user/components/containers/UserIndexContainer.tsx

@@ -0,0 +1,12 @@
+"use client";
+
+import { PageContentContainer } from "../../../../components";
+import { useUserContext } from "../../contexts";
+import { UserIndexDetails } from "../details";
+
+export function UserIndexContainer() {
+  const { user } = useUserContext();
+  if (!user) return null;
+
+  return <PageContentContainer details={<UserIndexDetails />} />;
+}

package/src/features/user/components/containers/UsersListContainer.tsx

@@ -0,0 +1,36 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { CompanyUsersList, Tab, TabsContainer } from "../../../../components";
+import { Modules } from "../../../../core";
+import { Action } from "../../../../permissions";
+import { useCurrentUserContext } from "../../contexts";
+import { UserInterface } from "../../data";
+
+function UsersListContainerInternal() {
+  const { hasPermissionToModule } = useCurrentUserContext<UserInterface>();
+  const t = useTranslations();
+
+  if (!hasPermissionToModule({ module: Modules.User, action: Action.Delete })) return <CompanyUsersList />;
+
+  const tabs: Tab[] = [
+    {
+      label: t(`types.users`, { count: 2 }),
+      content: <CompanyUsersList />,
+      modules: [Modules.Company],
+      action: Action.Read,
+    },
+    {
+      label: t(`foundations.user.deleted`),
+      content: <CompanyUsersList isDeleted={true} />,
+      modules: [Modules.Company],
+      action: Action.Update,
+    },
+  ];
+
+  return <TabsContainer tabs={tabs} />;
+}
+
+export function UsersListContainer() {
+  return <UsersListContainerInternal />;
+}

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

@@ -0,0 +1,3 @@
+export * from "./UserContainer";
+export * from "./UserIndexContainer";
+export * from "./UsersListContainer";