@catalystsoftware/ui 1.0.0

package/components/catalyst-ui/utils/incId.tsx

@@ -0,0 +1,75 @@
+import { prisma } from "~/modules/libs/prisma";
+
+export async function IncId({ type }) {
+  // const dealerId = await IncId({ type: "Client" });
+  // Client, PO, PO Inv, Sales, WO, Unit, FinanceTradeUnit, ServiceUnit, Service, ServicePackages, Dealer
+  let oldId;
+  let newId;
+  switch (type) {
+    case "Client":
+      const lastClient = await prisma.clientfile.findFirst({
+        orderBy: { createdAt: "desc" }, // Get the last created item
+        select: { dealerId: true },
+      });
+      oldId = lastClient?.dealerId || "CLIENT_0"; // Default to "CLIENT-0" if no items exist
+      newId = incrementId(oldId, "CLIENT");
+      break;
+    case "Order":
+      const lastPAC = await prisma.accOrder.findFirst({
+        orderBy: { createdAt: "desc" },
+        select: { dealerId: true },
+      });
+      oldId = lastPAC?.dealerId || "PO_0";
+      newId = incrementId(oldId, "PO");
+      break;
+    case "Acc Inv":
+      const lastAcc = await prisma.accessories.findFirst({
+        orderBy: { createdAt: "desc" },
+        select: { dealerId: true },
+      });
+      oldId = lastAcc?.dealerId || "INV_0";
+      newId = incrementId(oldId, "INV");
+      break;
+   case "Ticket":
+      const lastTicket = await prisma.clientTickets.findFirst({
+        orderBy: { createdAt: "desc" },
+        select: { dealerId: true },
+      });
+      oldId = lastTicket?.dealerId || "TICKET_0";
+      newId = incrementId(oldId, "TICKET");
+      break;
+    case "Receipt":
+      const lastPayment = await prisma.payment.findFirst({
+        orderBy: { createdAt: "desc" },
+        select: { dealerId: true },
+      });
+      oldId = lastPayment?.dealerId || "RECEIPT_0";
+      newId = incrementId(oldId, "RECEIPT");
+      break;
+    case "User":
+      const lastUser = await prisma.user.findFirst({
+        orderBy: { createdAt: "desc" },
+        select: { dealerId: true },
+      });
+      oldId = lastUser?.dealerId || "USER_0";
+      newId = incrementId(oldId, "USER");
+      break;
+    default:
+      throw new Error("Invalid type");
+  }
+  return newId;
+}
+function incrementId(oldId, prefix) {
+  // Extract the numeric part using a regular expression
+  const numericMatch = oldId.match(/\d+/);
+
+  // If no numeric part is found, default to 0
+  const numericPart = numericMatch ? parseInt(numericMatch[0], 10) : 0;
+
+  // Increment the numeric part
+  const newNumericPart = numericPart + 1;
+
+  // Return the new ID in the format "PREFIX_{incrementedNumber}"
+  const result = prefix+"_"+newNumericPart
+  return result
+} 

package/components/catalyst-ui/utils/jwk-auth.tsx

@@ -0,0 +1,36 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+
+export function JWKAuthMiddleware() {
+  const validateJWT = useCallback(async (
+    token: string, 
+    options: JWKAuthOptions
+  ): Promise<any> => {
+    try {
+      return { valid: true, payload: { sub: 'user123' } };
+    } catch (error) {
+      return null;
+    }
+  }, []);
+
+  const requireJWTAuth = useCallback(async (
+    request: Request, 
+    options: JWKAuthOptions
+  ) => {
+    const authHeader = request.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return new Response('Unauthorized', { status: 401 });
+    }
+
+    const token = authHeader.slice(7);
+    const validation = await validateJWT(token, options);
+    
+    if (!validation) {
+      return new Response('Invalid token', { status: 401 });
+    }
+
+    return null;
+  }, [validateJWT]);
+
+  return { validateJWT, requireJWTAuth };
+}

package/components/catalyst-ui/utils/request-id.tsx

@@ -0,0 +1,14 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+export function RequestIDMiddleware() {
+  const generateRequestId = useCallback(() => {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }, []);
+
+  const addRequestId = useCallback((request: Request): string => {
+    const existingId = request.headers.get('x-request-id');
+    return existingId || generateRequestId();
+  }, [generateRequestId]);
+
+  return { addRequestId, generateRequestId };
+}

package/components/catalyst-ui/utils/secure-headers.tsx

@@ -0,0 +1,37 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+export function SecureHeadersMiddleware() {
+  const addSecurityHeaders = useCallback((
+    response: Response, 
+    options: SecurityHeaders
+  ): Response => {
+    const headers = new Headers(response.headers);
+    
+    if (options.contentTypeOptions) {
+      headers.set('X-Content-Type-Options', 'nosniff');
+    }
+    
+    if (options.frameOptions) {
+      headers.set('X-Frame-Options', options.frameOptions);
+    }
+    
+    if (options.xssProtection) {
+      headers.set('X-XSS-Protection', '1; mode=block');
+    }
+    
+    if (options.hsts) {
+      const hstsValue = `max-age=${options.hsts.maxAge}${
+        options.hsts.includeSubDomains ? '; includeSubDomains' : ''
+      }`;
+      headers.set('Strict-Transport-Security', hstsValue);
+    }
+
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }, []);
+
+  return { addSecurityHeaders };
+}

package/components/catalyst-ui/utils/server-timing.tsx

@@ -0,0 +1,23 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+
+
+export function ServerTimingMiddleware() {
+  const addServerTiming = useCallback((name: string, duration: number, description?: string) => {
+    const timing = description 
+      ? `${name};dur=${duration};desc="${description}"`
+      : `${name};dur=${duration}`;
+    
+    return (response: Response) => {
+      const existingTiming = response.headers.get('Server-Timing') || '';
+      const newTiming = existingTiming 
+        ? `${existingTiming}, ${timing}`
+        : timing;
+      
+      response.headers.set('Server-Timing', newTiming);
+      return response;
+    };
+  }, []);
+
+  return { addServerTiming };
+}

package/components/catalyst-ui/utils/utils.ts

@@ -0,0 +1,43 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export const focusInput = [
+  // base
+  'focus:ring-2',
+  // ring color
+  'focus:ring-blue-200 focus:dark:ring-blue-700/30',
+  // border color
+  'focus:border-blue-500 focus:dark:border-blue-700',
+];
+
+// Tremor focusRing [v0.0.1]
+
+export const focusRing = [
+  // base
+  'outline outline-offset-2 outline-0 focus-visible:outline-2',
+  // outline color
+  'outline-blue-500 dark:outline-blue-500',
+];
+
+// Tremor hasErrorInput [v0.0.1]
+
+export const hasErrorInput = [
+  // base
+  'ring-2',
+  // border color
+  'border-red-500 dark:border-red-700',
+  // ring color
+  'ring-red-200 dark:ring-red-700/30',
+];
+
+export const formatDate = (date: Date): string => {
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+  })
+}

package/components/catalyst-ui/utils/with-cookie.tsx

@@ -0,0 +1,43 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+export function WithCookieMiddleware() {
+  const getCookie = useCallback((request: Request, name: string): string | null => {
+    const cookieHeader = request.headers.get('cookie');
+    if (!cookieHeader) return null;
+
+    const cookies = cookieHeader.split(';').map(c => c.trim());
+    const targetCookie = cookies.find(c => c.startsWith(`${name}=`));
+    
+    return targetCookie ? targetCookie.split('=')[1] : null;
+  }, []);
+
+  const setCookie = useCallback((
+    response: Response,
+    name: string,
+    value: string,
+    options: {
+      maxAge?: number;
+      expires?: Date;
+      path?: string;
+      domain?: string;
+      secure?: boolean;
+      httpOnly?: boolean;
+      sameSite?: 'strict' | 'lax' | 'none';
+    } = {}
+  ): Response => {
+    const cookieParts = [`${name}=${value}`];
+    
+    if (options.maxAge) cookieParts.push(`Max-Age=${options.maxAge}`);
+    if (options.expires) cookieParts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options.path) cookieParts.push(`Path=${options.path}`);
+    if (options.domain) cookieParts.push(`Domain=${options.domain}`);
+    if (options.secure) cookieParts.push('Secure');
+    if (options.httpOnly) cookieParts.push('HttpOnly');
+    if (options.sameSite) cookieParts.push(`SameSite=${options.sameSite}`);
+
+    response.headers.set('Set-Cookie', cookieParts.join('; '));
+    return response;
+  }, []);
+
+  return { getCookie, setCookie };
+}