@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/core/interfaces/ApiRequestDataTypeInterface.ts

@@ -0,0 +1,14 @@
+import { FieldSelector } from "../fields/FieldSelector";
+
+export type ApiRequestDataTypeInterface = {
+  name: string;
+  cache?: string;
+  inclusions?: Record<
+    string,
+    {
+      types?: string[];
+      fields?: FieldSelector<any>[];
+    }
+  >;
+  model: new () => any;
+};

package/src/core/interfaces/ApiResponseInterface.ts

@@ -0,0 +1,17 @@
+import { ApiDataInterface } from "./ApiDataInterface";
+
+export interface ApiResponseInterface {
+  ok: boolean;
+  response: number;
+  raw?: any;
+
+  self?: string;
+  next?: string;
+  prev?: string;
+  nextPage?: () => Promise<ApiResponseInterface>;
+  prevPage?: () => Promise<ApiResponseInterface>;
+
+  data: ApiDataInterface | ApiDataInterface[];
+
+  error: string;
+}

package/src/core/interfaces/JsonApiHydratedDataInterface.ts

@@ -0,0 +1,5 @@
+export interface JsonApiHydratedDataInterface {
+  jsonApi: any;
+  included: any[];
+  allData?: any[];
+}

package/src/core/interfaces/index.ts

@@ -0,0 +1,5 @@
+export * from "./ApiData";
+export * from "./ApiDataInterface";
+export * from "./ApiRequestDataTypeInterface";
+export * from "./ApiResponseInterface";
+export * from "./JsonApiHydratedDataInterface";

package/{dist/chunk-DO2HLAZO.js → src/core/registry/DataClassRegistry.ts}

@@ -1,48 +1,51 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+import { ApiDataInterface } from "../interfaces/ApiDataInterface";
+import { ApiRequestDataTypeInterface } from "../interfaces/ApiRequestDataTypeInterface";
 
-var _chunk7QVYU63Ejs = require('./chunk-7QVYU63E.js');
+export class DataClassRegistry {
+  private static _map = new Map<string, { new (): ApiDataInterface }>();
 
-// src/core/registry/DataClassRegistry.ts
-var DataClassRegistry = (_class = class {
-  static {
-    _chunk7QVYU63Ejs.__name.call(void 0, this, "DataClassRegistry");
-  }
-  static __initStatic() {this._map = /* @__PURE__ */ new Map()}
-  static registerObjectClass(key, classConstructor) {
+  public static registerObjectClass(
+    key: ApiRequestDataTypeInterface,
+    classConstructor: { new (): ApiDataInterface },
+  ): void {
     const classKey = key.name;
     if (!this._map.has(classKey)) {
       this._map.set(classKey, classConstructor);
     }
   }
-  static get(classKey) {
+
+  public static get(classKey: ApiRequestDataTypeInterface): {
+    new (): ApiDataInterface;
+  } {
     const response = this._map.get(classKey.name);
     if (!response) {
       throw new Error(`Class not registered for key: ${typeof classKey === "string" ? classKey : classKey.name}`);
     }
+
     return response;
   }
+
   /**
    * Bootstrap the registry with all modules.
    * This is a convenience method for apps to register all their modules at once.
    *
    * @param modules - An object with module definitions (like the app's Modules class)
    */
-  static bootstrap(modules) {
+  public static bootstrap(modules: Record<string, ApiRequestDataTypeInterface>): void {
     Object.values(modules).forEach((module) => {
       if (module && module.model) {
         this.registerObjectClass(module, module.model);
       }
     });
   }
+
   /**
    * Clear all registered classes. Useful for testing.
    */
-  static clear() {
+  public static clear(): void {
     this._map.clear();
   }
-}, _class.__initStatic(), _class);
-
-
+}
 
-exports.DataClassRegistry = DataClassRegistry;
-//# sourceMappingURL=chunk-DO2HLAZO.js.map
+// Export alias for backward compatibility
+export { DataClassRegistry as DataClass };

package/src/core/registry/ModuleRegistrar.ts

@@ -0,0 +1,43 @@
+import { ApiRequestDataTypeInterface } from "../interfaces/ApiRequestDataTypeInterface";
+import { DataClassRegistry } from "./DataClassRegistry";
+
+/**
+ * Helper class to bootstrap the registry from a Modules-style class.
+ * This supports the pattern where modules are defined as static getters.
+ */
+export class ModuleRegistrar {
+  private static _isBootstrapped = false;
+
+  /**
+   * Bootstrap the registry from a Modules class.
+   * Automatically detects static getters and registers their models.
+   *
+   * @param modulesClass - The Modules class with static getters
+   */
+  static bootstrap<T extends object>(modulesClass: T): void {
+    if (this._isBootstrapped) return;
+
+    const data = Object.getOwnPropertyNames(modulesClass)
+      .filter((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(modulesClass, key);
+        return descriptor && typeof descriptor.get === "function";
+      })
+      .map((key) => (modulesClass as any)[key] as ApiRequestDataTypeInterface);
+
+    data.forEach((item) => {
+      if (item && item.model) {
+        DataClassRegistry.registerObjectClass(item, item.model);
+      }
+    });
+
+    this._isBootstrapped = true;
+  }
+
+  /**
+   * Reset the bootstrapped state. Useful for testing.
+   */
+  static reset(): void {
+    this._isBootstrapped = false;
+    DataClassRegistry.clear();
+  }
+}

package/src/core/registry/ModuleRegistry.ts

@@ -0,0 +1,64 @@
+import { ApiRequestDataTypeInterface } from "../interfaces/ApiRequestDataTypeInterface";
+import { ModuleWithPermissions } from "../../permissions/types";
+
+// Foundation module types - defined by LIBRARY
+export interface FoundationModuleDefinitions {
+  S3: ModuleWithPermissions;
+  Auth: ModuleWithPermissions;
+  User: ModuleWithPermissions;
+  Author: ModuleWithPermissions;
+  Company: ModuleWithPermissions;
+  Role: ModuleWithPermissions;
+  Notification: ModuleWithPermissions;
+  Push: ModuleWithPermissions;
+  Feature: ModuleWithPermissions;
+  Module: ModuleWithPermissions;
+  Content: ModuleWithPermissions;
+  UserTopic: ModuleWithPermissions;
+  UserExpertise: ModuleWithPermissions;
+}
+
+// App-specific modules - apps will augment this interface ONLY
+
+export interface AppModuleDefinitions {}
+
+// Combined type for full autocompletion
+export type ModuleDefinitions = FoundationModuleDefinitions & AppModuleDefinitions;
+
+class ModuleRegistryClass {
+  private _modules: Map<string, ApiRequestDataTypeInterface> = new Map();
+
+  register<K extends string>(name: K, module: ApiRequestDataTypeInterface): void {
+    this._modules.set(name, module);
+  }
+
+  get<K extends keyof ModuleDefinitions>(name: K): ModuleDefinitions[K] {
+    const module = this._modules.get(name as string);
+    if (!module) {
+      throw new Error(`Module "${String(name)}" not registered. Call bootstrap() first.`);
+    }
+    return module as ModuleDefinitions[K];
+  }
+
+  findByName(moduleName: string): ModuleWithPermissions {
+    // Search by module's name property (e.g., "topics", "articles")
+    for (const module of this._modules.values()) {
+      if ((module as ModuleWithPermissions).name === moduleName) {
+        return module as ModuleWithPermissions;
+      }
+    }
+    throw new Error(`Module not found: ${moduleName}`);
+  }
+}
+
+export const ModuleRegistry = new ModuleRegistryClass();
+
+// Proxy object for Modules.X syntax with autocompletion
+export const Modules = new Proxy({} as ModuleDefinitions, {
+  get(_, prop: string) {
+    if (prop === "findByName") {
+      return (name: string) => ModuleRegistry.findByName(name);
+    }
+    return ModuleRegistry.get(prop as keyof ModuleDefinitions);
+  },
+}) as ModuleDefinitions & { findByName: (name: string) => ModuleWithPermissions };

package/src/core/registry/index.ts

@@ -0,0 +1,3 @@
+export * from "./DataClassRegistry";
+export * from "./ModuleRegistrar";
+export * from "./ModuleRegistry";

package/src/core/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./translateResponse";
+export * from "./rehydrate";

package/src/core/utils/rehydrate.ts

@@ -0,0 +1,24 @@
+import { ApiDataInterface } from "../interfaces/ApiDataInterface";
+import { ApiRequestDataTypeInterface } from "../interfaces/ApiRequestDataTypeInterface";
+import { JsonApiHydratedDataInterface } from "../interfaces/JsonApiHydratedDataInterface";
+import { RehydrationFactory } from "../factories/RehydrationFactory";
+
+/**
+ * Rehydrate a single dehydrated object back into its typed class instance.
+ */
+export function rehydrate<T extends ApiDataInterface>(
+  classKey: ApiRequestDataTypeInterface,
+  data: JsonApiHydratedDataInterface,
+): T {
+  return RehydrationFactory.rehydrate(classKey, data) as T;
+}
+
+/**
+ * Rehydrate a list of dehydrated objects back into typed class instances.
+ */
+export function rehydrateList<T extends ApiDataInterface>(
+  classKey: ApiRequestDataTypeInterface,
+  data: JsonApiHydratedDataInterface[],
+): T[] {
+  return RehydrationFactory.rehydrateList(classKey, data) as T[];
+}

package/src/core/utils/translateResponse.ts

@@ -0,0 +1,125 @@
+import { ApiData } from "../interfaces/ApiData";
+import { ApiDataInterface } from "../interfaces/ApiDataInterface";
+import { ApiRequestDataTypeInterface } from "../interfaces/ApiRequestDataTypeInterface";
+import { ApiResponseInterface } from "../interfaces/ApiResponseInterface";
+import { DataClassRegistry } from "../registry/DataClassRegistry";
+
+/**
+ * Translates raw JSON:API data into typed objects.
+ * Does not require API response metadata.
+ */
+export function translateData<T extends ApiDataInterface>(params: {
+  classKey: ApiRequestDataTypeInterface;
+  data: any;
+}): T | T[] {
+  const factoryClass = DataClassRegistry.get(params.classKey);
+
+  if (!factoryClass) {
+    throw new Error(
+      `Class not registered for key: ${typeof params.classKey === "string" ? params.classKey : params.classKey.name}`,
+    );
+  }
+
+  const included: any = params.data.included ?? [];
+
+  if (Array.isArray(params.data.data)) {
+    const responseData: T[] = [];
+
+    for (const data of params.data.data) {
+      const object = new factoryClass();
+      object.rehydrate({ jsonApi: data, included: included, allData: params.data.data });
+      responseData.push(object as T);
+    }
+
+    return responseData as T[];
+  } else {
+    const responseData = new factoryClass();
+    responseData.rehydrate({
+      jsonApi: params.data.data,
+      included: included,
+    });
+
+    return responseData as T;
+  }
+}
+
+/**
+ * Translates a full API response into a typed ApiResponseInterface.
+ * Includes pagination support.
+ */
+export async function translateResponse<T extends ApiDataInterface>(params: {
+  classKey: ApiRequestDataTypeInterface;
+  apiResponse: ApiData;
+  companyId?: string;
+  language: string;
+  paginationHandler?: (endpoint: string) => Promise<ApiResponseInterface>;
+}): Promise<ApiResponseInterface> {
+  const response: ApiResponseInterface = {
+    ok: true,
+    response: 0,
+    data: [],
+    error: "",
+  };
+
+  const factoryClass = DataClassRegistry.get(params.classKey);
+
+  if (!factoryClass) {
+    throw new Error(
+      `Class not registered for key: ${typeof params.classKey === "string" ? params.classKey : params.classKey.name}`,
+    );
+  }
+
+  response.ok = params.apiResponse.ok;
+  response.response = params.apiResponse.status;
+
+  if (!params.apiResponse.ok) {
+    response.error = params.apiResponse?.data?.message ?? params.apiResponse.statusText;
+    return response;
+  }
+
+  if (params.apiResponse.status === 204) return response;
+
+  response.raw = params.apiResponse.data;
+
+  try {
+    const included: any = params.apiResponse.data.included ?? [];
+
+    if (params.apiResponse.data.links) {
+      response.self = params.apiResponse.data.links.self;
+
+      if (params.apiResponse.data.links.next && params.paginationHandler) {
+        response.next = params.apiResponse.data.links.next;
+        response.nextPage = async () => params.paginationHandler!(params.apiResponse.data.links.next);
+      }
+
+      if (params.apiResponse.data.links.prev && params.paginationHandler) {
+        response.prev = params.apiResponse.data.links.prev;
+        response.prevPage = async () => params.paginationHandler!(params.apiResponse.data.links.prev);
+      }
+    }
+
+    if (Array.isArray(params.apiResponse.data.data)) {
+      const responseData: T[] = [];
+
+      for (const data of params.apiResponse.data.data) {
+        const object = new factoryClass();
+        object.rehydrate({ jsonApi: data, included: included, allData: params.apiResponse.data.data });
+        responseData.push(object as T);
+      }
+
+      response.data = responseData;
+    } else {
+      const responseData = new factoryClass();
+      responseData.rehydrate({
+        jsonApi: params.apiResponse.data.data,
+        included: included,
+      });
+
+      response.data = responseData;
+    }
+  } catch (e) {
+    console.error(e);
+  }
+
+  return response;
+}

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

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { Auth } from ".";
+
+export const AuthModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/auth",
+    name: "auth",
+    model: Auth,
+  });

package/src/features/auth/components/containers/AuthContainer.tsx

@@ -0,0 +1,32 @@
+"use client";
+
+import Image from "next/image";
+import { Card } from "../../../../shadcnui";
+import { AuthContextProvider, useAuthContext } from "../../contexts";
+import { AuthComponent } from "../../enums";
+
+type AuthContainerProps = {
+  componentType: AuthComponent;
+  params?: { code?: string };
+};
+
+export function AuthContainer({ componentType, params }: AuthContainerProps) {
+  return (
+    <AuthContextProvider initialComponentType={componentType} initialParams={params}>
+      <InnerAuthContainer />
+    </AuthContextProvider>
+  );
+}
+
+function InnerAuthContainer() {
+  const { activeComponent } = useAuthContext();
+
+  if (activeComponent === null)
+    return (
+      <div className="max-w-sm">
+        <Image src="/phlow-logo.webp" alt="Phlow" width={100} height={100} className="animate-spin-slow" priority />
+      </div>
+    );
+
+  return <Card className="w-full max-w-md">{activeComponent}</Card>;
+}

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

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

package/src/features/auth/components/details/LandingComponent.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import Image from "next/image";
+import { Button, CardDescription, CardFooter, CardHeader, CardTitle, Link } from "../../../../shadcnui";
+import { useAuthContext } from "../../contexts";
+import { AuthComponent } from "../../enums";
+
+export function LandingComponent() {
+  const t = useTranslations();
+
+  const { setComponentType } = useAuthContext();
+
+  return (
+    <>
+      <CardHeader className="mb-4" data-testid="page-pre-login-container">
+        <CardTitle className="text-primary flex flex-col items-center gap-y-8 pb-8 text-4xl">
+          <Image src="/phlow-logo.webp" alt="Phlow" width={100} height={100} priority />
+          {t(`generic.title`)}
+        </CardTitle>
+        <CardDescription className="flex w-full justify-center text-center text-sm">
+          {t(`generic.description`)}
+        </CardDescription>
+      </CardHeader>
+      <CardFooter className="mt-4 flex w-full flex-col justify-between">
+        <Link href="#" className="flex w-full justify-start" onClick={() => setComponentType(AuthComponent.Register)}>
+          <Button className="mt-4 w-full" variant={`default`}>
+            {t(`foundations.auth.buttons.register`)}
+          </Button>
+        </Link>
+        <Link href="#" className="flex w-full justify-end" onClick={() => setComponentType(AuthComponent.Login)}>
+          <Button className="mt-4 w-full" variant={`outline`} data-testid="page-login-button-initial-login">
+            {t(`foundations.auth.buttons.login`)}
+          </Button>
+        </Link>
+      </CardFooter>
+    </>
+  );
+}

package/src/features/auth/components/details/index.ts

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

package/src/features/auth/components/forms/AcceptInvitation.tsx

@@ -0,0 +1,136 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useTranslations } from "next-intl";
+import Image from "next/image";
+import { useEffect, useState } from "react";
+import { SubmitHandler, useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { errorToast, FormPassword } from "../../../../components";
+import { Button, CardContent, CardDescription, CardHeader, CardTitle, Form } from "../../../../shadcnui";
+import { useAuthContext } from "../../contexts";
+import { AuthService } from "../../data";
+import { AuthComponent } from "../../enums";
+
+export function AcceptInvitation() {
+  const { setComponentType, params, setParams } = useAuthContext();
+  const [showConfirmation, setShowConfirmation] = useState<boolean>(false);
+  const [error, setError] = useState<string | undefined>(undefined);
+  const t = useTranslations();
+
+  useEffect(() => {
+    async function validateCode(code: string) {
+      try {
+        const payload: any = {
+          code: code,
+        };
+
+        await AuthService.validateCode(payload);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : String(e));
+        errorToast({ title: t(`generic.errors.error`), error: e });
+      }
+    }
+
+    if (params && params.code) {
+      validateCode(params.code);
+    } else {
+      setError(t(`foundations.auth.errors.invalid_invitation_code`));
+    }
+  }, []);
+
+  const formSchema = z
+    .object({
+      password: z.string().min(1, {
+        message: t(`foundations.user.fields.password.error`),
+      }),
+      passwordRetype: z.string().min(1, {
+        message: t("foundations.auth.errors.password_retype_required"),
+      }),
+    })
+    .refine((data) => data.password === data.passwordRetype, {
+      message: t("foundations.auth.fields.retype_password.error_not_match"),
+      path: ["passwordRetype"],
+    });
+
+  const form = useForm<z.infer<typeof formSchema>>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      password: "",
+      passwordRetype: "",
+    },
+  });
+
+  const onSubmit: SubmitHandler<z.infer<typeof formSchema>> = async (values: z.infer<typeof formSchema>) => {
+    try {
+      if (!params?.code) return;
+
+      const payload = {
+        code: params?.code,
+        password: values.password,
+      };
+
+      await AuthService.acceptInvitation(payload);
+      setShowConfirmation(true);
+
+      toast.success(t("foundations.auth.account_activated"), {
+        description: t("foundations.auth.account_activated_description"),
+      });
+
+      setTimeout(() => {
+        setComponentType(AuthComponent.Login);
+        setParams(undefined);
+      }, 2000);
+    } catch (e) {
+      errorToast({ title: t(`generic.errors.error`), error });
+    }
+  };
+
+  return (
+    <>
+      <CardHeader>
+        <CardTitle className="text-primary flex flex-col items-center pb-10 text-4xl">
+          <Image src="/phlow-logo.webp" alt="Phlow" width={100} height={100} priority />
+          {t("foundations.auth.accept_invitation")}
+        </CardTitle>
+        <CardDescription className="text-center text-sm">
+          {error ? (
+            <>{t("foundations.auth.errors.activating_account")}</>
+          ) : (
+            <>{t("foundations.auth.select_password")}</>
+          )}
+        </CardDescription>
+      </CardHeader>
+      <CardContent>
+        {showConfirmation ? (
+          <CardDescription className="text-center text-xl">
+            {t("foundations.auth.activation_description")}
+          </CardDescription>
+        ) : error ? (
+          <CardDescription className="text-center text-xl">{error}</CardDescription>
+        ) : (
+          <Form {...form}>
+            <form onSubmit={form.handleSubmit(onSubmit)}>
+              <FormPassword
+                form={form}
+                id="password"
+                name={t(`foundations.user.fields.password.label`)}
+                placeholder={t(`foundations.user.fields.password.placeholder`)}
+              />
+              <FormPassword
+                form={form}
+                id="passwordRetype"
+                name={t("foundations.auth.fields.retype_password.label")}
+                placeholder={t(`foundations.auth.fields.retype_password.placeholder`)}
+              />
+              <Button className="mt-4 w-full" type={"submit"}>
+                {t("foundations.auth.accept_invitation")}
+              </Button>
+            </form>
+          </Form>
+        )}
+      </CardContent>
+    </>
+  );
+}