@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/features/content/content.module.ts

@@ -0,0 +1,20 @@
+import { createJsonApiInclusion } from "../../core";
+import { ModuleFactory } from "../../permissions";
+import { Content } from ".";
+
+export const ContentModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/contents",
+    name: "contents",
+    model: Content,
+    inclusions: {
+      lists: {
+        fields: [
+          createJsonApiInclusion("content", [`name`, `tldr`, `abstract`, `aiStatus`, `relevance`]),
+          createJsonApiInclusion("users", [`name`, `avatar`]),
+          createJsonApiInclusion("topics", [`name`]),
+          createJsonApiInclusion("expertises", [`name`]),
+        ],
+      },
+    },
+  });

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

@@ -0,0 +1,13 @@
+export enum ContentFields {
+  contentId = "contentId",
+
+  name = "name",
+  relevance = "relevance",
+
+  authors = "authors",
+  topic = "topic",
+  expertise = "expertise",
+
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

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

@@ -0,0 +1,23 @@
+import { ApiDataInterface } from "../../../core";
+import { UserInterface } from "../../user";
+
+export type ContentInput = {
+  id: string;
+  name?: string;
+
+  authorId: string;
+  editorIds?: string[];
+};
+
+export interface ContentInterface extends ApiDataInterface {
+  get contentType(): string | undefined;
+  get name(): string;
+  get abstract(): string | undefined;
+  get tldr(): string | undefined;
+  get aiStatus(): string;
+
+  get relevance(): number | undefined;
+
+  get author(): UserInterface;
+  get editors(): UserInterface[];
+}

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

@@ -0,0 +1,75 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { ContentInterface } from "./content.interface";
+
+export class ContentService extends AbstractService {
+  static async findMany(params: {
+    contentIds?: string[];
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<ContentInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Content });
+
+    if (params.contentIds) {
+      endpoint.addAdditionalParam("contentIds", params.contentIds.join(","));
+      endpoint.addAdditionalParam("fetchAll", "true");
+    } else {
+      if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+      if (params.search) endpoint.addAdditionalParam("search", params.search);
+    }
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findRelevant(params: { id: string; next?: NextRef; prev?: PreviousRef }): Promise<ContentInterface[]> {
+    const endpoint: EndpointCreator = new EndpointCreator({
+      endpoint: Modules.Content,
+      id: params.id,
+      childEndpoint: "relevance",
+    });
+
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi<ContentInterface[]>({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findManyByAuthor(params: {
+    userId: string;
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<ContentInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Author,
+      id: params.userId,
+      childEndpoint: Modules.Content,
+    });
+
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+}

package/src/features/content/data/content.ts

@@ -0,0 +1,85 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { SearchResultInterface } from "../../search/interfaces/search.result.interface";
+import { UserInterface } from "../../user";
+import { ContentInput, ContentInterface } from "./content.interface";
+
+export class Content extends AbstractApiData implements ContentInterface, SearchResultInterface {
+  private _contentType?: string;
+
+  private _name?: string;
+  private _abstract?: string;
+  private _tldr?: string;
+  private _aiStatus?: string;
+  private _relevance?: number;
+
+  private _author?: UserInterface;
+  private _editors?: UserInterface[];
+
+  get searchResult(): string {
+    return this._name ?? "";
+  }
+
+  get contentType(): string | undefined {
+    return this._contentType;
+  }
+
+  get name(): string {
+    if (this._name === undefined) throw new Error("JsonApi error: content name is missing");
+    return this._name;
+  }
+
+  get abstract(): string | undefined {
+    return this._abstract;
+  }
+
+  get tldr(): string | undefined {
+    return this._tldr;
+  }
+
+  get aiStatus(): string {
+    return this._aiStatus ?? "";
+  }
+
+  get relevance(): number | undefined {
+    return this._relevance;
+  }
+
+  get author(): UserInterface {
+    if (this._author === undefined) throw new Error("JsonApi error: document author is missing");
+    return this._author;
+  }
+
+  get editors(): UserInterface[] {
+    return this._editors ?? [];
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._contentType = data.jsonApi.meta.contentType;
+
+    this._name = data.jsonApi.attributes.name;
+    this._abstract = data.jsonApi.attributes.abstract;
+    this._tldr = data.jsonApi.attributes.tldr;
+    this._aiStatus = data.jsonApi.meta.aiStatus;
+    this._relevance = data.jsonApi.meta.relevance;
+
+    this._author = this._readIncluded(data, "author", Modules.User) as UserInterface;
+    this._editors = this._readIncluded(data, "editors", Modules.User) as UserInterface[];
+
+    return this;
+  }
+
+  protected addContentInput(response: any, data: ContentInput) {
+    if (data.name) response.data.attributes.name = data.name;
+
+    if (data.authorId) {
+      response.data.relationships.author = {
+        data: {
+          type: Modules.User.name,
+          id: data.authorId,
+        },
+      };
+    }
+  }
+}

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

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

package/src/features/content/index.ts

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

package/src/features/feature/components/forms/FormFeatures.tsx

@@ -0,0 +1,150 @@
+"use client";
+
+import {
+  Accordion,
+  AccordionContent,
+  AccordionItem,
+  AccordionTrigger,
+  Checkbox,
+  FormLabel,
+  FormMessage,
+} from "../../../../shadcnui";
+import { ModuleInterface } from "../../../module";
+import { FeatureInterface } from "../../data";
+
+type FormFeaturesProps = {
+  form: any;
+  name?: string;
+  features: FeatureInterface[];
+  featureField?: string;
+  moduleField?: string;
+};
+
+export function FormFeatures({
+  form,
+  name,
+  features,
+  featureField = "featureIds",
+  moduleField = "moduleIds",
+}: FormFeaturesProps) {
+  const selectedFeatures: string[] = form.watch(featureField);
+  const selectedModules: string[] = form.watch(moduleField);
+
+  const toggleFeature = (feature: FeatureInterface, checked: boolean) => {
+    let newFeatureIds = [...selectedFeatures];
+    let newModuleIds = [...selectedModules];
+
+    if (checked) {
+      if (!newFeatureIds.includes(feature.id)) {
+        newFeatureIds.push(feature.id);
+      }
+      feature.modules.forEach((module) => {
+        if (!newModuleIds.includes(module.id)) {
+          newModuleIds.push(module.id);
+        }
+      });
+    } else {
+      newFeatureIds = newFeatureIds.filter((id) => id !== feature.id);
+      feature.modules.forEach((module) => {
+        newModuleIds = newModuleIds.filter((id) => id !== module.id);
+      });
+    }
+    form.setValue(featureField, newFeatureIds);
+    form.setValue(moduleField, newModuleIds);
+  };
+
+  const toggleModule = (feature: FeatureInterface, module: ModuleInterface, checked: boolean) => {
+    const modulesForFeature = feature.modules.map((m) => m.id);
+    let newModuleIds = [...selectedModules];
+
+    if (checked) {
+      if (!selectedFeatures.includes(feature.id)) {
+        newModuleIds = newModuleIds.filter((id) => !modulesForFeature.includes(id));
+        newModuleIds.push(module.id);
+        form.setValue(featureField, [...selectedFeatures, feature.id]);
+      } else {
+        if (!newModuleIds.includes(module.id)) {
+          newModuleIds.push(module.id);
+        }
+      }
+    } else {
+      newModuleIds = newModuleIds.filter((id) => id !== module.id);
+      const remaining = feature.modules.filter((m) => newModuleIds.includes(m.id));
+      if (remaining.length === 0) {
+        form.setValue(
+          featureField,
+          selectedFeatures.filter((id) => id !== feature.id),
+        );
+      }
+    }
+    form.setValue(moduleField, newModuleIds);
+  };
+
+  const isFeatureChecked = (feature: FeatureInterface) =>
+    selectedFeatures.includes(feature.id) || feature.modules.every((module) => selectedModules.includes(module.id));
+
+  return (
+    <div className="flex w-full flex-col">
+      {name && <h2 className="mb-5 font-semibold">{name}</h2>}
+      {features.map((feature) => (
+        <Accordion
+          key={feature.id}
+          type="single"
+          collapsible
+          // className={`w-full p-0 ${feature.modules.filter((module) => !module.isCore).length === 0 ? "border-t" : ""}`}
+          className={`w-full p-0`}
+        >
+          <AccordionItem value={feature.id} className="p-0">
+            <div
+              className={`flex items-center justify-between p-0 ${feature.modules.filter((module) => !module.isCore).length === 0 ? "py-4" : ""}`}
+            >
+              <div className="flex items-center" onClick={(e) => e.stopPropagation()}>
+                <Checkbox
+                  id={feature.id}
+                  checked={isFeatureChecked(feature)}
+                  onCheckedChange={(val) => {
+                    toggleFeature(feature, val === true);
+                  }}
+                />
+                <FormLabel htmlFor={feature.id} className="ml-3 cursor-pointer font-normal">
+                  {feature.name}
+                </FormLabel>
+              </div>
+              {feature.modules.filter((module) => !module.isCore).length > 0 && (
+                <AccordionTrigger asChild>
+                  <div className="w-full"></div>
+                </AccordionTrigger>
+              )}
+            </div>
+            {feature.modules.filter((module) => !module.isCore).length > 0 && (
+              <AccordionContent className="pl-6">
+                {feature.modules
+                  .filter((module) => !module.isCore)
+                  .sort((a: ModuleInterface, b: ModuleInterface) => a.name.localeCompare(b.name))
+                  .map((module: ModuleInterface) => (
+                    <div
+                      key={module.id}
+                      className="flex items-center border-t py-2"
+                      onClick={(e) => e.stopPropagation()}
+                    >
+                      <Checkbox
+                        id={module.id}
+                        checked={selectedModules.includes(module.id)}
+                        onCheckedChange={(val) => {
+                          toggleModule(feature, module, val === true);
+                        }}
+                      />
+                      <FormLabel htmlFor={module.id} className="ml-3 cursor-pointer font-normal">
+                        {module.name}
+                      </FormLabel>
+                    </div>
+                  ))}
+              </AccordionContent>
+            )}
+          </AccordionItem>
+        </Accordion>
+      ))}
+      <FormMessage />
+    </div>
+  );
+}

package/src/features/feature/components/forms/index.ts

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

package/src/features/feature/components/index.ts

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

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

@@ -0,0 +1,9 @@
+import { ApiDataInterface } from "../../../core";
+import { ModuleInterface } from "../../module";
+
+export interface FeatureInterface extends ApiDataInterface {
+  get name(): string;
+  get isProduction(): boolean;
+
+  get modules(): ModuleInterface[];
+}

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

@@ -0,0 +1,19 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { FeatureInterface } from "./feature.interface";
+
+export class FeatureService extends AbstractService {
+  static async findMany(params: { companyId?: string; search?: string; next?: NextRef }): Promise<FeatureInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Feature });
+
+    if (params.companyId) endpoint.endpoint(Modules.Company).id(params.companyId).childEndpoint(Modules.Feature);
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi<FeatureInterface[]>({
+      type: Modules.Feature,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+}

package/src/features/feature/data/feature.ts

@@ -0,0 +1,33 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { ModuleInterface } from "../../module";
+import { FeatureInterface } from "./feature.interface";
+
+export class Feature extends AbstractApiData implements FeatureInterface {
+  private _name?: string;
+  private _isProduction?: boolean;
+
+  private _modules: ModuleInterface[] = [];
+
+  get name(): string {
+    return this._name ?? "";
+  }
+
+  get isProduction(): boolean {
+    return this._isProduction == true ? true : false;
+  }
+
+  get modules(): ModuleInterface[] {
+    return this._modules;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._isProduction = data.jsonApi.attributes.isProduction ?? false;
+
+    this._modules = this._readIncluded(data, `modules`, Modules.Module) as ModuleInterface[];
+
+    return this;
+  }
+}

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

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

package/src/features/feature/feature.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Feature } from "./data/feature";
+
+export const FeatureModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/features",
+    name: "features",
+    model: Feature,
+    moduleId: "025fdd23-2803-4360-9fd9-eaa3612c2e23",
+  });

package/src/features/feature/index.ts

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

package/src/features/index.ts

@@ -0,0 +1,12 @@
+// S3 feature exports
+export * from "./auth";
+export * from "./company";
+export * from "./content";
+export * from "./feature";
+export * from "./module";
+export * from "./notification";
+export * from "./push";
+export * from "./role";
+export * from "./s3";
+export * from "./search";
+export * from "./user";

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

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

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

@@ -0,0 +1,12 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface ModuleInterface extends ApiDataInterface {
+  get name(): string;
+  get isCore(): boolean;
+  get permissions(): {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  };
+}

package/src/features/module/data/module.ts

@@ -0,0 +1,42 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { ModuleInterface } from "./module.interface";
+
+export class Module extends AbstractApiData implements ModuleInterface {
+  private _name?: string;
+  private _isCore?: boolean;
+  private _permissions?: {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  };
+
+  get name(): string {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name ?? "";
+  }
+
+  get isCore(): boolean {
+    return this._isCore ?? false;
+  }
+
+  get permissions(): {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  } {
+    if (!this._permissions) throw new Error("Permissions is not defined");
+    return this._permissions;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._isCore = data.jsonApi.attributes.isCore;
+    this._permissions = data.jsonApi.meta.permissions;
+
+    return this;
+  }
+}

package/src/features/module/index.ts

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

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

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Module } from "./data";
+
+export const ModuleModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/modules",
+    name: "modules",
+    model: Module,
+    moduleId: "25ffd868-8341-4ca7-963b-6e1c56b03b1d",
+  });

package/src/features/notification/components/common/NotificationErrorBoundary.tsx

@@ -0,0 +1,51 @@
+"use client";
+
+import React, { Component, ReactNode } from "react";
+
+interface Props {
+  children: ReactNode;
+  fallback?: ReactNode;
+}
+
+interface State {
+  hasError: boolean;
+  error?: Error;
+}
+
+export class NotificationErrorBoundary extends Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+
+  static getDerivedStateFromError(error: Error): State {
+    // Update state so the next render will show the fallback UI
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+    console.error("🚨 [NotificationErrorBoundary] Caught error:", error, errorInfo);
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return (
+        this.props.fallback || (
+          <div className="flex items-center justify-center p-4 text-center">
+            <div className="text-muted-foreground text-sm">
+              <p>Something went wrong with notifications.</p>
+              <button
+                onClick={() => this.setState({ hasError: false })}
+                className="text-primary mt-2 underline hover:no-underline"
+              >
+                Try again
+              </button>
+            </div>
+          </div>
+        )
+      );
+    }
+
+    return this.props.children;
+  }
+}

package/src/features/notification/components/common/index.ts

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

package/src/features/notification/components/containers/NotificationsListContainer.tsx

@@ -0,0 +1,44 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { Tab, TabsContainer } from "../../../../components";
+import { useNotificationContext } from "../../contexts/NotificationContext";
+import { NotificationErrorBoundary } from "../common";
+import { NotificationsList } from "../lists/NotificationsList";
+
+function NotificationsListContainerContent() {
+  const t = useTranslations();
+  const { notifications, isLoading, error } = useNotificationContext();
+
+  if (error) {
+    return (
+      <div className="flex items-center justify-center p-8 text-center">
+        <div className="text-destructive text-sm">
+          <p>Error loading notifications: {error}</p>
+          <p className="text-muted-foreground mt-2">Please try refreshing the page.</p>
+        </div>
+      </div>
+    );
+  }
+
+  const tabs: Tab[] = [
+    {
+      label: t(`foundations.notification.inbox`),
+      content: <NotificationsList archived={false} />,
+    },
+    {
+      label: t(`foundations.notification.archived`),
+      content: <NotificationsList archived={true} />,
+    },
+  ];
+
+  return <TabsContainer tabs={tabs} />;
+}
+
+export function NotificationsListContainer() {
+  return (
+    <NotificationErrorBoundary>
+      <NotificationsListContainerContent />
+    </NotificationErrorBoundary>
+  );
+}

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

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

package/src/features/notification/components/index.ts

@@ -0,0 +1,5 @@
+export * from "./common";
+export * from "./containers";
+export * from "./lists";
+export * from "./modals";
+export * from "./notifications";