@carlonicora/nextjs-jsonapi 0.0.1 → 1.0.4

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/index.ts

@@ -0,0 +1,4 @@
+export * from "./author.module";
+// Note: contexts are exported from @carlonicora/nextjs-jsonapi/contexts to avoid "use client" issues
+export * from "./components";
+export * from "./data";

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

@@ -0,0 +1,21 @@
+import { User } from "./data/user";
+import { createJsonApiInclusion } from "../../core";
+import { ModuleFactory } from "../../permissions";
+
+export const UserModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/users",
+    name: "users",
+    model: User,
+    moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277",
+    inclusions: {
+      lists: {
+        fields: [
+          createJsonApiInclusion("users", [`name`, `email`, `avatar`, `title`]),
+          createJsonApiInclusion("usertopics", [`level`]),
+          createJsonApiInclusion("userexpertises", [`level`]),
+          createJsonApiInclusion("topics", [`name`]),
+        ],
+      },
+    },
+  });

package/src/hooks/TableGeneratorRegistry.ts

@@ -0,0 +1,53 @@
+"use client";
+
+import { UseTableStructureHook, UseTableStructureHookParams, UseTableStructureHookReturn } from "./types";
+
+type TableGeneratorHook = UseTableStructureHook<any, any>;
+
+export class TableGeneratorRegistry {
+  private static instance: TableGeneratorRegistry;
+  private registry = new Map<string, TableGeneratorHook>();
+
+  private constructor() {}
+
+  public static getInstance(): TableGeneratorRegistry {
+    if (!TableGeneratorRegistry.instance) {
+      TableGeneratorRegistry.instance = new TableGeneratorRegistry();
+    }
+    return TableGeneratorRegistry.instance;
+  }
+
+  public register<T, U>(type: string, hook: UseTableStructureHook<T, U>): void {
+    if (!this.registry.has(type)) this.registry.set(type, hook as TableGeneratorHook);
+  }
+
+  public get<T, U>(type: string, params: UseTableStructureHookParams<T, U>): UseTableStructureHookReturn<T> {
+    const hook = this.registry.get(type);
+    if (!hook) {
+      throw new Error(
+        `Table generator for type "${type}" is not registered. Available types: ${Array.from(this.registry.keys()).join(
+          ", ",
+        )}`,
+      );
+    }
+    return hook(params);
+  }
+
+  public isRegistered(type: string): boolean {
+    return this.registry.has(type);
+  }
+
+  public getRegisteredTypes(): string[] {
+    return Array.from(this.registry.keys());
+  }
+
+  public unregister(type: string): boolean {
+    return this.registry.delete(type);
+  }
+
+  public clear(): void {
+    this.registry.clear();
+  }
+}
+
+export const tableGeneratorRegistry = TableGeneratorRegistry.getInstance();

package/src/hooks/index.ts

@@ -0,0 +1,33 @@
+export { TableGeneratorRegistry, tableGeneratorRegistry } from "./TableGeneratorRegistry";
+export type {
+  TableContent,
+  TableStructureGeneratorInterface,
+  UseTableStructureHook,
+  UseTableStructureHookParams,
+  UseTableStructureHookReturn,
+} from "./types";
+export { useUrlRewriter } from "./url.rewriter";
+export { useDataListRetriever, type DataListRetriever } from "./useDataListRetriever";
+export { useDebounce } from "./useDebounce";
+export { usePageUrlGenerator } from "./usePageUrlGenerator";
+export { registerTableGenerator, useTableGenerator } from "./useTableGenerator";
+
+// I18n hooks and configuration
+export {
+  configureI18n,
+  getI18nLink,
+  useI18nDateFnsLocale,
+  useI18nLocale,
+  useI18nRouter,
+  useI18nTranslations,
+} from "../i18n";
+export type {
+  I18nConfig,
+  I18nRouter,
+  LinkComponent,
+  UseDateFnsLocaleHook,
+  UseLocaleHook,
+  UseRouterHook,
+  UseTranslationsHook,
+} from "../i18n";
+export * from "./useCustomD3Graph";

package/src/hooks/types.ts

@@ -0,0 +1,35 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { PageUrl } from "../permissions/types";
+import { DataListRetriever } from "./useDataListRetriever";
+
+export type TableContent<T> = {
+  jsonApiData: T;
+  [key: string]: any;
+};
+
+export interface TableStructureGeneratorInterface<T, U> {
+  generateTableStructure: (params: {
+    t: (key: string) => string;
+    generateUrl: (params: { page: string | PageUrl | string; id?: string }) => string;
+    data: T[];
+    fields: Array<U>;
+    checkedIds?: string[];
+    toggleId?: (id: string) => void;
+  }) => { data: TableContent<T>[]; columns: ColumnDef<TableContent<T>>[] };
+}
+
+export type UseTableStructureHookParams<T, U> = {
+  data: T[];
+  fields: Array<U>;
+  checkedIds?: string[];
+  toggleId?: (id: string) => void;
+  dataRetriever?: DataListRetriever<T>;
+  context?: Record<string, any>;
+};
+
+export type UseTableStructureHookReturn<T> = {
+  data: TableContent<T>[];
+  columns: ColumnDef<TableContent<T>>[];
+};
+
+export type UseTableStructureHook<T, U> = (params: UseTableStructureHookParams<T, U>) => UseTableStructureHookReturn<T>;

package/src/hooks/url.rewriter.ts

@@ -0,0 +1,22 @@
+"use client";
+
+import { useLocale } from "next-intl";
+import { useCallback } from "react";
+import { ModuleWithPermissions } from "../permissions";
+import { usePageUrlGenerator } from "./usePageUrlGenerator";
+
+export function useUrlRewriter() {
+  const locale = useLocale();
+  const generateUrl = usePageUrlGenerator();
+
+  return useCallback(
+    (params: { page: ModuleWithPermissions | string; id?: string; childPage?: string }): void => {
+      window.history.replaceState(
+        null,
+        "",
+        generateUrl({ page: params.page, id: params.id, childPage: params.childPage, language: locale }),
+      );
+    },
+    [locale, generateUrl],
+  );
+}