@carlonicora/nextjs-jsonapi 1.5.0 → 1.7.0

package/src/server/JsonApiServer.ts

@@ -0,0 +1,249 @@
+// Server-only utilities (NOT server actions - these cannot be called from client components)
+
+import { JsonApiDataFactory } from "../core/factories/JsonApiDataFactory";
+import { ApiRequestDataTypeInterface } from "../core/interfaces/ApiRequestDataTypeInterface";
+import { ApiResponseInterface } from "../core/interfaces/ApiResponseInterface";
+import { translateResponse } from "../core/utils/translateResponse";
+import { ModuleWithPermissions } from "../permissions/types";
+import { serverRequest } from "./request";
+import { getServerToken } from "./token";
+
+// Config storage for server contexts
+let _serverConfig: {
+  apiUrl: string;
+  appUrl?: string;
+  trackablePages?: ModuleWithPermissions[];
+  bootstrapper?: () => void;
+  additionalHeaders?: Record<string, string>;
+} | null = null;
+
+/**
+ * Configure the JSON:API server client.
+ * Call this in your Bootstrapper or server initialization.
+ */
+export function configureServerJsonApi(config: {
+  apiUrl: string;
+  appUrl?: string;
+  trackablePages?: ModuleWithPermissions[];
+  bootstrapper?: () => void;
+  additionalHeaders?: Record<string, string>;
+}): void {
+  _serverConfig = config;
+  if (config.bootstrapper) {
+    config.bootstrapper();
+  }
+}
+
+export function getServerApiUrl(): string {
+  if (_serverConfig?.apiUrl) {
+    return _serverConfig.apiUrl;
+  }
+  const envUrl = process.env.NEXT_PUBLIC_API_URL;
+  if (!envUrl) {
+    throw new Error("API URL not configured. Use configureServerJsonApi() or set NEXT_PUBLIC_API_URL environment variable.");
+  }
+  return envUrl;
+}
+
+export function getServerAppUrl(): string {
+  if (_serverConfig?.appUrl) {
+    return _serverConfig.appUrl;
+  }
+  const envUrl = process.env.NEXT_PUBLIC_ADDRESS;
+  if (!envUrl) {
+    throw new Error("App URL not configured. Use configureServerJsonApi({ appUrl }) or set NEXT_PUBLIC_ADDRESS environment variable.");
+  }
+  return envUrl.trim().replace(/\/+$/, "");
+}
+
+export function getServerTrackablePages(): ModuleWithPermissions[] {
+  return _serverConfig?.trackablePages ?? [];
+}
+
+function runServerBootstrapper(): void {
+  if (_serverConfig?.bootstrapper) {
+    _serverConfig.bootstrapper();
+  }
+}
+
+function buildServerUrl(endpoint: string): string {
+  const apiUrl = getServerApiUrl();
+  return endpoint.startsWith("http") ? endpoint : `${apiUrl}${endpoint}`;
+}
+
+export async function ServerJsonApiGet(params: {
+  classKey: ApiRequestDataTypeInterface;
+  endpoint: string;
+  companyId?: string;
+  language: string;
+}): Promise<ApiResponseInterface> {
+  runServerBootstrapper();
+  const token = await getServerToken();
+
+  const apiResponse = await serverRequest({
+    method: "GET",
+    url: buildServerUrl(params.endpoint),
+    token,
+    cache: params.classKey.cache,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _serverConfig?.additionalHeaders,
+  });
+
+  return translateResponse({
+    classKey: params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+    paginationHandler: async (endpoint: string) =>
+      ServerJsonApiGet({
+        classKey: params.classKey,
+        endpoint,
+        companyId: params.companyId,
+        language: params.language,
+      }),
+  });
+}
+
+export async function ServerJsonApiPost(params: {
+  classKey: ApiRequestDataTypeInterface;
+  endpoint: string;
+  companyId?: string;
+  body?: any;
+  overridesJsonApiCreation?: boolean;
+  files?: { [key: string]: File | Blob } | File | Blob;
+  language: string;
+  responseType?: ApiRequestDataTypeInterface;
+}): Promise<ApiResponseInterface> {
+  runServerBootstrapper();
+  const token = await getServerToken();
+
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else if (params.overridesJsonApiCreation !== true) {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+
+  const apiResponse = await serverRequest({
+    method: "POST",
+    url: buildServerUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _serverConfig?.additionalHeaders,
+  });
+
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+  });
+}
+
+export async function ServerJsonApiPut(params: {
+  classKey: ApiRequestDataTypeInterface;
+  endpoint: string;
+  companyId?: string;
+  body?: any;
+  files?: { [key: string]: File | Blob } | File | Blob;
+  language: string;
+  responseType?: ApiRequestDataTypeInterface;
+}): Promise<ApiResponseInterface> {
+  runServerBootstrapper();
+  const token = await getServerToken();
+
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+
+  const apiResponse = await serverRequest({
+    method: "PUT",
+    url: buildServerUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _serverConfig?.additionalHeaders,
+  });
+
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+  });
+}
+
+export async function ServerJsonApiPatch(params: {
+  classKey: ApiRequestDataTypeInterface;
+  endpoint: string;
+  companyId?: string;
+  body?: any;
+  files?: { [key: string]: File | Blob } | File | Blob;
+  overridesJsonApiCreation?: boolean;
+  responseType?: ApiRequestDataTypeInterface;
+  language: string;
+}): Promise<ApiResponseInterface> {
+  runServerBootstrapper();
+  const token = await getServerToken();
+
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else if (params.overridesJsonApiCreation !== true) {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+
+  const apiResponse = await serverRequest({
+    method: "PATCH",
+    url: buildServerUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _serverConfig?.additionalHeaders,
+  });
+
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+  });
+}
+
+export async function ServerJsonApiDelete(params: {
+  classKey: ApiRequestDataTypeInterface;
+  endpoint: string;
+  companyId?: string;
+  language: string;
+  responseType?: ApiRequestDataTypeInterface;
+}): Promise<ApiResponseInterface> {
+  runServerBootstrapper();
+  const token = await getServerToken();
+
+  const apiResponse = await serverRequest({
+    method: "DELETE",
+    url: buildServerUrl(params.endpoint),
+    token,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _serverConfig?.additionalHeaders,
+  });
+
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+  });
+}

package/src/server/cache.ts

@@ -1,4 +1,4 @@
-"use server";
+// Server-only utilities (NOT server actions - these cannot be called from client components)
 
 import { revalidateTag } from "next/cache";
 

package/src/server/index.ts

@@ -2,3 +2,16 @@ export * from "./cache";
 export * from "./request";
 export * from "./ServerSession";
 export * from "./token";
+export * from "./JsonApiServer";
+
+// Server-side services for use in RSC and server actions
+// Re-exported from unified services with Server prefix aliases
+export { AuthService as ServerAuthService } from "../features/auth/data/auth.service";
+export { UserService as ServerUserService } from "../features/user/data/user.service";
+export { CompanyService as ServerCompanyService } from "../features/company/data/company.service";
+export { RoleService as ServerRoleService } from "../features/role/data/role.service";
+export { ContentService as ServerContentService } from "../features/content/data/content.service";
+export { NotificationService as ServerNotificationService } from "../features/notification/data/notification.service";
+export { FeatureService as ServerFeatureService } from "../features/feature/data/feature.service";
+export { PushService as ServerPushService } from "../features/push/data/push.service";
+export { S3Service as ServerS3Service } from "../features/s3/data/s3.service";

package/src/server/request.ts

@@ -1,8 +1,6 @@
-"use server";
+// Server-only utilities (NOT server actions - these cannot be called from client components)
 
 import { ApiData } from "../core/interfaces/ApiData";
-import { cacheLife } from "next/dist/server/use-cache/cache-life";
-import { cacheTag } from "next/dist/server/use-cache/cache-tag";
 
 export interface ServerRequestParams {
   method: string;
@@ -16,13 +14,22 @@ export interface ServerRequestParams {
   additionalHeaders?: Record<string, string>;
 }
 
+// Map cache configuration names to revalidation times in seconds
+const cacheLifeToSeconds: Record<string, number> = {
+  seconds: 1,
+  minutes: 60,
+  hours: 3600,
+  days: 86400,
+  weeks: 604800,
+  max: 31536000, // 1 year
+  default: 60,
+};
+
 /**
  * Server-side request with Next.js caching support.
- * Uses "use cache" directive for automatic caching.
+ * Uses fetch's native caching options for Next.js compatibility.
  */
 export async function serverRequest(params: ServerRequestParams): Promise<ApiData> {
-  "use cache";
-
   const response: ApiData = {
     data: undefined,
     ok: false,
@@ -30,17 +37,6 @@ export async function serverRequest(params: ServerRequestParams): Promise<ApiDat
     statusText: "",
   };
 
-  // Apply caching configuration
-  if (params.cache) {
-    if (["days", "default", "hours", "max", "minutes", "seconds", "weeks"].includes(params.cache)) {
-      cacheLife(params.cache as any);
-    } else {
-      cacheTag(params.cache);
-    }
-  } else {
-    cacheLife("seconds");
-  }
-
   const additionalHeaders: Record<string, string> = { ...params.additionalHeaders };
 
   if (params.companyId) {
@@ -79,9 +75,27 @@ export async function serverRequest(params: ServerRequestParams): Promise<ApiDat
     additionalHeaders["Content-Type"] = "application/json";
   }
 
-  const options: RequestInit = {
+  // Build Next.js fetch caching options
+  const nextOptions: { revalidate?: number; tags?: string[] } = {};
+
+  if (params.cache) {
+    // Check if it's a predefined cache life name
+    if (params.cache in cacheLifeToSeconds) {
+      nextOptions.revalidate = cacheLifeToSeconds[params.cache];
+    } else {
+      // Treat as a cache tag
+      nextOptions.tags = [params.cache];
+      nextOptions.revalidate = 60; // Default revalidation time for tagged caches
+    }
+  } else {
+    // Default to short caching
+    nextOptions.revalidate = 1;
+  }
+
+  const options: RequestInit & { next?: { revalidate?: number; tags?: string[] } } = {
     method: params.method,
     headers: { Accept: "application/json", ...additionalHeaders },
+    next: nextOptions,
   };
 
   if (requestBody !== undefined) {

package/src/server/token.ts

@@ -1,4 +1,4 @@
-"use server";
+// Server-only utilities (NOT server actions - these cannot be called from client components)
 
 /**
  * Get the authentication token from cookies (server-side)

package/dist/AbstractService-BsY6W3Ej.d.mts

@@ -1,109 +0,0 @@
-import { A as ApiDataInterface, J as JsonApiHydratedDataInterface } from './ApiDataInterface-DPP8s46n.mjs';
-import { A as ApiRequestDataTypeInterface } from './types-t2PyXhDu.mjs';
-
-declare abstract class AbstractApiData implements ApiDataInterface {
-    protected _jsonApi?: any;
-    protected _included?: any[];
-    protected _id?: string;
-    protected _type?: string;
-    protected _createdAt?: Date;
-    protected _updatedAt?: Date;
-    protected _self?: string;
-    get type(): string;
-    get id(): string;
-    get self(): string | undefined;
-    get createdAt(): Date;
-    get updatedAt(): Date;
-    get included(): any[];
-    get jsonApi(): any;
-    ingestJsonApi(_data: JsonApiHydratedDataInterface): void;
-    generateApiUrl(_params?: any): string;
-    createJsonApi(_data?: any): any;
-    protected _readIncluded<T extends ApiDataInterface>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): T | T[] | undefined;
-    dehydrate(): JsonApiHydratedDataInterface;
-    rehydrate(data: JsonApiHydratedDataInterface): this;
-}
-
-declare enum HttpMethod {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    DELETE = "DELETE"
-}
-interface NextRef {
-    next?: string;
-}
-interface PreviousRef {
-    previous?: string;
-}
-interface SelfRef {
-    self?: string;
-}
-/**
- * Set a global error handler for API errors (client-side only).
- * This handler will be called instead of throwing errors.
- */
-declare function setGlobalErrorHandler(handler: (status: number, message: string) => void): void;
-/**
- * Get the current global error handler.
- */
-declare function getGlobalErrorHandler(): ((status: number, message: string) => void) | null;
-/**
- * Abstract base class for services that interact with the JSON:API.
- * Extend this class to create feature-specific services.
- */
-declare abstract class AbstractService {
-    /**
-     * Extract locale from client-side URL pathname
-     * URL structure: /{locale}/route-path (e.g., /it/accounts)
-     * Fallback chain: URL locale → navigator.language → "en"
-     */
-    private static getClientLocale;
-    static next<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        endpoint: string;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-    }): Promise<T>;
-    /**
-     * Fetch the previous page of results.
-     */
-    static previous<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        endpoint: string;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-    }): Promise<T>;
-    /**
-     * Make an API call with automatic environment detection and error handling.
-     */
-    protected static callApi<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        method: HttpMethod;
-        endpoint: string;
-        companyId?: string;
-        input?: any;
-        overridesJsonApiCreation?: boolean;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-        responseType?: ApiRequestDataTypeInterface;
-        files?: {
-            [key: string]: File | Blob;
-        } | File | Blob;
-    }): Promise<T>;
-    /**
-     * Get raw JSON:API response data without deserialization.
-     */
-    protected static getRawData(params: {
-        type: ApiRequestDataTypeInterface;
-        method: HttpMethod;
-        endpoint: string;
-        companyId?: string;
-    }): Promise<any>;
-}
-
-export { AbstractApiData as A, HttpMethod as H, type NextRef as N, type PreviousRef as P, type SelfRef as S, AbstractService as a, getGlobalErrorHandler as g, setGlobalErrorHandler as s };

package/dist/AbstractService-wLid8dB0.d.ts

@@ -1,109 +0,0 @@
-import { A as ApiDataInterface, J as JsonApiHydratedDataInterface } from './ApiDataInterface-DPP8s46n.js';
-import { A as ApiRequestDataTypeInterface } from './types-t2PyXhDu.js';
-
-declare abstract class AbstractApiData implements ApiDataInterface {
-    protected _jsonApi?: any;
-    protected _included?: any[];
-    protected _id?: string;
-    protected _type?: string;
-    protected _createdAt?: Date;
-    protected _updatedAt?: Date;
-    protected _self?: string;
-    get type(): string;
-    get id(): string;
-    get self(): string | undefined;
-    get createdAt(): Date;
-    get updatedAt(): Date;
-    get included(): any[];
-    get jsonApi(): any;
-    ingestJsonApi(_data: JsonApiHydratedDataInterface): void;
-    generateApiUrl(_params?: any): string;
-    createJsonApi(_data?: any): any;
-    protected _readIncluded<T extends ApiDataInterface>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): T | T[] | undefined;
-    dehydrate(): JsonApiHydratedDataInterface;
-    rehydrate(data: JsonApiHydratedDataInterface): this;
-}
-
-declare enum HttpMethod {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    DELETE = "DELETE"
-}
-interface NextRef {
-    next?: string;
-}
-interface PreviousRef {
-    previous?: string;
-}
-interface SelfRef {
-    self?: string;
-}
-/**
- * Set a global error handler for API errors (client-side only).
- * This handler will be called instead of throwing errors.
- */
-declare function setGlobalErrorHandler(handler: (status: number, message: string) => void): void;
-/**
- * Get the current global error handler.
- */
-declare function getGlobalErrorHandler(): ((status: number, message: string) => void) | null;
-/**
- * Abstract base class for services that interact with the JSON:API.
- * Extend this class to create feature-specific services.
- */
-declare abstract class AbstractService {
-    /**
-     * Extract locale from client-side URL pathname
-     * URL structure: /{locale}/route-path (e.g., /it/accounts)
-     * Fallback chain: URL locale → navigator.language → "en"
-     */
-    private static getClientLocale;
-    static next<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        endpoint: string;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-    }): Promise<T>;
-    /**
-     * Fetch the previous page of results.
-     */
-    static previous<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        endpoint: string;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-    }): Promise<T>;
-    /**
-     * Make an API call with automatic environment detection and error handling.
-     */
-    protected static callApi<T>(params: {
-        type: ApiRequestDataTypeInterface;
-        method: HttpMethod;
-        endpoint: string;
-        companyId?: string;
-        input?: any;
-        overridesJsonApiCreation?: boolean;
-        next?: NextRef;
-        previous?: PreviousRef;
-        self?: SelfRef;
-        responseType?: ApiRequestDataTypeInterface;
-        files?: {
-            [key: string]: File | Blob;
-        } | File | Blob;
-    }): Promise<T>;
-    /**
-     * Get raw JSON:API response data without deserialization.
-     */
-    protected static getRawData(params: {
-        type: ApiRequestDataTypeInterface;
-        method: HttpMethod;
-        endpoint: string;
-        companyId?: string;
-    }): Promise<any>;
-}
-
-export { AbstractApiData as A, HttpMethod as H, type NextRef as N, type PreviousRef as P, type SelfRef as S, AbstractService as a, getGlobalErrorHandler as g, setGlobalErrorHandler as s };

package/dist/ApiData-DPKNfY-9.d.mts

@@ -1,10 +0,0 @@
-type ApiData = {
-    data: any;
-    ok: boolean;
-    status: number;
-    statusText: string;
-    token?: string;
-    refreshToken?: string;
-};
-
-export type { ApiData as A };

package/dist/ApiData-DPKNfY-9.d.ts

@@ -1,10 +0,0 @@
-type ApiData = {
-    data: any;
-    ok: boolean;
-    status: number;
-    statusText: string;
-    token?: string;
-    refreshToken?: string;
-};
-
-export type { ApiData as A };

package/dist/ApiDataInterface-DPP8s46n.d.mts

@@ -1,21 +0,0 @@
-interface JsonApiHydratedDataInterface {
-    jsonApi: any;
-    included: any[];
-    allData?: any[];
-}
-
-interface ApiDataInterface {
-    get included(): any[];
-    get type(): string;
-    get id(): string;
-    get createdAt(): Date;
-    get updatedAt(): Date;
-    get self(): string | undefined;
-    get jsonApi(): any;
-    generateApiUrl(params?: any): string;
-    dehydrate(): JsonApiHydratedDataInterface;
-    rehydrate(data: JsonApiHydratedDataInterface): this;
-    createJsonApi(data: any): any;
-}
-
-export type { ApiDataInterface as A, JsonApiHydratedDataInterface as J };

package/dist/ApiDataInterface-DPP8s46n.d.ts

@@ -1,21 +0,0 @@
-interface JsonApiHydratedDataInterface {
-    jsonApi: any;
-    included: any[];
-    allData?: any[];
-}
-
-interface ApiDataInterface {
-    get included(): any[];
-    get type(): string;
-    get id(): string;
-    get createdAt(): Date;
-    get updatedAt(): Date;
-    get self(): string | undefined;
-    get jsonApi(): any;
-    generateApiUrl(params?: any): string;
-    dehydrate(): JsonApiHydratedDataInterface;
-    rehydrate(data: JsonApiHydratedDataInterface): this;
-    createJsonApi(data: any): any;
-}
-
-export type { ApiDataInterface as A, JsonApiHydratedDataInterface as J };