@carlonicora/nextjs-jsonapi 1.0.3 → 1.0.5

package/src/server/ServerSession.ts

@@ -0,0 +1,103 @@
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import zlib from "zlib";
+import { Action, checkPermissionsFromServer, ModuleWithPermissions } from "../permissions";
+
+export class ServerSession {
+  static async isLogged() {
+    const cookieStore = await cookies();
+    const token = cookieStore.get("token");
+
+    if (!token || !token.value) return false;
+    return true;
+  }
+
+  static async isLicenseActive(): Promise<boolean> {
+    const cookieStore = await cookies();
+    const licenseExpirationDate = cookieStore.get("licenseExpirationDate")?.value;
+
+    if (!licenseExpirationDate) return false;
+
+    const now = new Date();
+    return new Date(licenseExpirationDate) > now;
+  }
+
+  static async companyId() {
+    const cookieStore = await cookies();
+    return cookieStore.get("companyId")?.value ?? "";
+  }
+
+  static async userId() {
+    const cookieStore = await cookies();
+    return cookieStore.get("userId")?.value ?? "";
+  }
+
+  static async checkPermission<M extends ModuleWithPermissions>(params: { module: M; action: Action; data?: any }) {
+    if (!(await this.hasPermissionToModule(params))) redirect(`/401`);
+  }
+
+  static async hasRole(roleId: string): Promise<boolean> {
+    const cookieStore = await cookies();
+    const roles = cookieStore.get("roles")?.value;
+
+    if (!roles || !roles.includes(roleId)) return false;
+
+    return true;
+  }
+
+  static async hasFeature(featureId: string): Promise<boolean> {
+    const cookieStore = await cookies();
+    const features = cookieStore.get("features")?.value;
+
+    if (!features || !features.includes(featureId)) return false;
+
+    return true;
+  }
+
+  static async hasPermissionToModule<M extends ModuleWithPermissions>(params: {
+    module: M;
+    action: Action;
+    data?: any;
+  }): Promise<boolean> {
+    const cookieStore = await cookies();
+
+    if (params.module.feature) {
+      const features = cookieStore.get("features")?.value;
+
+      if (features && !features.includes(params.module.feature)) return false;
+    }
+
+    const rawModules = cookieStore.get("modules")?.value;
+    if (!rawModules) return false;
+
+    const modules: {
+      id: string;
+      permissions: {
+        create: boolean | string;
+        read: boolean | string;
+        update: boolean | string;
+        delete: boolean | string;
+      };
+    }[] = JSON.parse(zlib.gunzipSync(Buffer.from(rawModules, "base64")).toString());
+
+    const selectedModule = modules.find((module) => module.id === params.module.moduleId);
+
+    return checkPermissionsFromServer({
+      module: params.module,
+      action: params.action,
+      data: params.data,
+      userId: await this.userId(),
+      selectedModule: selectedModule,
+    });
+
+    // if (!selectedModule) return false;
+
+    // if (!selectedModule.permissions[params.action]) return false;
+    // if (typeof selectedModule.permissions[params.action] === "boolean")
+    //   return selectedModule.permissions[params.action] as boolean;
+
+    // if (!params.data) return false;
+
+    // return params.data[selectedModule.permissions[params.action] as string] === this.userId;
+  }
+}

package/src/server/cache.ts

@@ -0,0 +1,28 @@
+"use server";
+
+import { revalidateTag } from "next/cache";
+
+export type CacheProfile = "seconds" | "minutes" | "hours" | "days" | "weeks" | "max" | "default";
+
+/**
+ * Revalidate a cache tag to invalidate cached data.
+ * Next.js 16+ requires a profile parameter.
+ *
+ * @param tag - The cache tag to invalidate
+ * @param profile - The cache profile (defaults to "max" for immediate invalidation)
+ */
+export async function invalidateCacheTag(tag: string, profile: CacheProfile = "max"): Promise<void> {
+  revalidateTag(tag, profile);
+}
+
+/**
+ * Revalidate multiple cache tags.
+ *
+ * @param tags - Array of cache tags to invalidate
+ * @param profile - The cache profile (defaults to "max" for immediate invalidation)
+ */
+export async function invalidateCacheTags(tags: string[], profile: CacheProfile = "max"): Promise<void> {
+  for (const tag of tags) {
+    revalidateTag(tag, profile);
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,4 @@
+export * from "./cache";
+export * from "./request";
+export * from "./ServerSession";
+export * from "./token";

package/src/server/request.ts

@@ -0,0 +1,113 @@
+"use server";
+
+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;
+  url: string;
+  token?: string;
+  cache?: string;
+  body?: any;
+  files?: { [key: string]: File | Blob } | File | Blob;
+  companyId?: string;
+  language: string;
+  additionalHeaders?: Record<string, string>;
+}
+
+/**
+ * Server-side request with Next.js caching support.
+ * Uses "use cache" directive for automatic caching.
+ */
+export async function serverRequest(params: ServerRequestParams): Promise<ApiData> {
+  "use cache";
+
+  const response: ApiData = {
+    data: undefined,
+    ok: false,
+    status: 0,
+    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) {
+    additionalHeaders["x-companyid"] = params.companyId;
+  }
+  additionalHeaders["x-language"] = params.language;
+
+  let requestBody: BodyInit | undefined = undefined;
+
+  if (params.files) {
+    const formData = new FormData();
+    if (params.body && typeof params.body === "object") {
+      for (const key in params.body) {
+        if (Object.prototype.hasOwnProperty.call(params.body, key)) {
+          formData.append(
+            key,
+            typeof params.body[key] === "object" ? JSON.stringify(params.body[key]) : params.body[key],
+          );
+        }
+      }
+    }
+
+    if (params.files instanceof Blob) {
+      formData.append("file", params.files);
+    } else if (typeof params.files === "object" && params.files !== null) {
+      for (const key in params.files) {
+        if (Object.prototype.hasOwnProperty.call(params.files, key)) {
+          formData.append(key, params.files[key]);
+        }
+      }
+    }
+
+    requestBody = formData;
+  } else if (params.body !== undefined) {
+    requestBody = JSON.stringify(params.body);
+    additionalHeaders["Content-Type"] = "application/json";
+  }
+
+  const options: RequestInit = {
+    method: params.method,
+    headers: { Accept: "application/json", ...additionalHeaders },
+  };
+
+  if (requestBody !== undefined) {
+    options.body = requestBody;
+  }
+
+  if (params.token) {
+    options.headers = { ...options.headers, Authorization: `Bearer ${params.token}` };
+  }
+
+  try {
+    const apiResponse = await fetch(params.url, options);
+
+    response.ok = apiResponse.ok;
+    response.status = apiResponse.status;
+    response.statusText = apiResponse.statusText;
+    try {
+      response.data = await apiResponse.json();
+    } catch {
+      response.data = undefined;
+    }
+  } catch {
+    response.ok = false;
+    response.status = 500;
+    response.data = undefined;
+  }
+
+  return response;
+}

package/src/server/token.ts

@@ -0,0 +1,10 @@
+"use server";
+
+/**
+ * Get the authentication token from cookies (server-side)
+ */
+export async function getServerToken(): Promise<string | undefined> {
+  const { cookies } = await import("next/headers");
+  const cookieStore = await cookies();
+  return cookieStore.get("token")?.value;
+}