@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/user/auth/i18n/en/index.ts

@@ -0,0 +1,205 @@
+export const translations = {
+  authClient: {
+    errors: {
+      status_save_failed: "Failed to save authentication status",
+      status_remove_failed: "Failed to remove authentication status",
+      status_check_failed: "Failed to check authentication status",
+      token_save_failed: "Failed to save authentication token",
+      token_get_failed: "Failed to retrieve authentication token",
+      token_remove_failed: "Failed to remove authentication token",
+    },
+  },
+  debug: {
+    getAuthMinimalUserNext: {
+      start: "getAuthMinimalUserNext: - Checking authentication first",
+      result: "getAuthMinimalUserNext: getCurrentUserNext result",
+      authenticated:
+        "getAuthMinimalUserNext: User is authenticated, getting leadId",
+      returningAuth: "getAuthMinimalUserNext: Returning authenticated user",
+      notAuthenticated:
+        "getAuthMinimalUserNext: User not authenticated, returning public user",
+    },
+    signingJwt: "Signing JWT",
+    jwtSignedSuccessfully: "JWT signed successfully",
+    errorSigningJwt: "Error signing JWT",
+    verifyingJwt: "Verifying JWT",
+    invalidTokenPayload: "Invalid token payload",
+    jwtVerifiedSuccessfully: "JWT verified successfully",
+    errorVerifyingJwt: "Error verifying JWT",
+    userIdNotExistsInDb: "User ID does not exist in database",
+    sessionNotFound: "Session not found",
+    sessionExpired: "Session expired",
+    errorValidatingUserSession: "Error validating user session",
+    errorGettingUserRoles: "Error getting user roles",
+    errorCheckingUserAuth: "Error checking user authentication",
+    gettingCurrentUserFromTrpc: "Getting current user from tRPC",
+    errorGettingAuthUserForTrpc: "Error getting auth user for tRPC",
+    errorGettingUserRolesForTrpc: "Error getting user roles for tRPC",
+    authenticatingCliUserWithPayload: "Authenticating CLI user with payload",
+    errorAuthenticatingCliUserWithPayload:
+      "Error authenticating CLI user with payload",
+    creatingCliToken: "Creating CLI token",
+    errorCreatingCliToken: "Error creating CLI token",
+    validatingCliToken: "Validating CLI token",
+    errorValidatingCliToken: "Error validating CLI token",
+    gettingCurrentUserFromNextjs: "Getting current user from Next.js",
+    errorGettingAuthUserForNextjs: "Error getting auth user for Next.js",
+    settingNextjsAuthCookies: "Setting Next.js auth cookies",
+    clearingNextjsAuthCookies: "Clearing Next.js auth cookies",
+    gettingCurrentUserFromToken: "Getting current user from token",
+    errorGettingCurrentUserFromCli: "Error getting current user from CLI",
+    errorGettingAuthUserForCli: "Error getting auth user for CLI",
+    errorGettingUserRolesForCli: "Error getting user roles for CLI",
+    tokenFromAuthHeader: "Token from auth header",
+    tokenFromCookie: "Token from cookie",
+    noTokenFound: "No token found",
+    errorExtractingToken: "Error extracting token",
+    errorParsingCookies: "Error parsing cookies",
+    errorGettingCurrentUserFromTrpc: "Error getting current user from tRPC",
+  },
+  errors: {
+    token_generation_failed: "Failed to generate authentication token",
+    invalid_session: "The session is invalid or expired",
+    missing_request_context: "Request context is missing",
+    missing_locale: "Locale is missing from request",
+    unsupported_platform: "Platform is not supported",
+    session_retrieval_failed: "Failed to retrieve session",
+    missing_token: "Authentication token is missing",
+    invalid_token_signature: "Token signature is invalid",
+    jwt_payload_missing_id: "JWT payload is missing user ID",
+    cookie_set_failed: "Failed to set authentication cookie",
+    cookie_clear_failed: "Failed to clear authentication cookie",
+    publicPayloadNotSupported:
+      "Public JWT payload is not supported for CLI authentication",
+    jwt_signing_failed: "Failed to sign JWT token",
+    authentication_failed: "Authentication failed",
+    user_not_authenticated: "User is not authenticated",
+    publicUserNotAllowed: "Public user is not allowed for this endpoint",
+    validation_failed: "Validation failed",
+    failed_to_create_lead: "Failed to create lead",
+    native: {
+      unsupported:
+        "This authentication method is not supported on React Native",
+      storage_failed: "Failed to store authentication data",
+      clear_failed: "Failed to clear authentication data",
+    },
+    not_implemented_native:
+      "This feature is not yet implemented for React Native",
+    unknownError: "An unknown error occurred during authentication",
+  },
+  post: {
+    title: "Auth",
+    description: "Auth endpoint",
+    form: {
+      title: "Auth Configuration",
+      description: "Configure auth parameters",
+    },
+    response: {
+      title: "Response",
+      description: "Auth response data",
+    },
+    errors: {
+      unauthorized: {
+        title: "Unauthorized",
+        description: "Authentication required",
+      },
+      validation: {
+        title: "Validation Error",
+        description: "Invalid request parameters",
+      },
+      missing_locale: {
+        title: "Missing Locale",
+        description: "Locale parameter is required",
+      },
+      server: {
+        title: "Server Error",
+        description: "Internal server error occurred",
+      },
+      unknown: {
+        title: "Unknown Error",
+        description: "An unknown error occurred",
+      },
+      network: {
+        title: "Network Error",
+        description: "Network error occurred",
+      },
+      forbidden: {
+        title: "Forbidden",
+        description: "Access forbidden",
+      },
+      notFound: {
+        title: "Not Found",
+        description: "Resource not found",
+      },
+      conflict: {
+        title: "Conflict",
+        description: "Data conflict occurred",
+      },
+      token_generation_failed: {
+        title: "Token Generation Failed",
+        description: "Failed to generate authentication token",
+      },
+      invalid_session: {
+        title: "Invalid Session",
+        description: "The session is invalid or expired",
+      },
+      missing_request_context: {
+        title: "Missing Request Context",
+        description: "Request context is missing",
+      },
+      unsupported_platform: {
+        title: "Unsupported Platform",
+        description: "Platform is not supported",
+      },
+      session_retrieval_failed: {
+        title: "Session Retrieval Failed",
+        description: "Failed to retrieve session",
+      },
+      missing_token: {
+        title: "Missing Token",
+        description: "Authentication token is missing",
+      },
+      invalid_token_signature: {
+        title: "Invalid Token Signature",
+        description: "Token signature is invalid",
+      },
+      jwt_payload_missing_id: {
+        title: "JWT Payload Missing ID",
+        description: "JWT payload is missing user ID",
+      },
+      cookie_set_failed: {
+        title: "Cookie Set Failed",
+        description: "Failed to set authentication cookie",
+      },
+      cookie_clear_failed: {
+        title: "Cookie Clear Failed",
+        description: "Failed to clear authentication cookie",
+      },
+    },
+    success: {
+      title: "Success",
+      description: "Operation completed successfully",
+    },
+  },
+  check: {
+    get: {
+      title: "Check Authentication",
+      description: "Check current authentication status",
+      response: {
+        title: "Authentication Status",
+        description: "Current authentication state",
+        authenticated: "Authenticated",
+        tokenValid: "Token Valid",
+      },
+    },
+  },
+  enums: {
+    webSocketErrorCode: {
+      unauthorized: "Unauthorized",
+      forbidden: "Forbidden",
+      invalidToken: "Invalid Token",
+      tokenExpired: "Token Expired",
+      serverError: "Server Error",
+    },
+  },
+};

package/src/app/api/[locale]/user/auth/i18n/pl/index.ts

@@ -0,0 +1,219 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  authClient: {
+    errors: {
+      status_save_failed: "Nie udało się zapisać statusu uwierzytelniania",
+      status_remove_failed: "Nie udało się usunąć statusu uwierzytelniania",
+      status_check_failed: "Nie udało się sprawdzić statusu uwierzytelniania",
+      token_save_failed: "Nie udało się zapisać tokenu uwierzytelniania",
+      token_get_failed: "Nie udało się pobrać tokenu uwierzytelniania",
+      token_remove_failed: "Nie udało się usunąć tokenu uwierzytelniania",
+    },
+  },
+  errors: {
+    token_generation_failed:
+      "Nie udało się wygenerować tokenu uwierzytelniania",
+    invalid_session: "Sesja jest nieprawidłowa lub wygasła",
+    missing_request_context: "Kontekst żądania jest brakujący",
+    missing_locale: "Brak locale w żądaniu",
+    unsupported_platform: "Platforma nie jest obsługiwana",
+    session_retrieval_failed: "Nie udało się pobrać sesji",
+    missing_token: "Token uwierzytelniania jest brakujący",
+    invalid_token_signature: "Podpis tokenu jest nieprawidłowy",
+    jwt_payload_missing_id: "JWT payload brakuje ID użytkownika",
+    cookie_set_failed: "Nie udało się ustawić cookie uwierzytelniania",
+    cookie_clear_failed: "Nie udało się usunąć cookie uwierzytelniania",
+    publicPayloadNotSupported:
+      "Publiczny payload JWT nie jest obsługiwany dla uwierzytelniania CLI",
+    jwt_signing_failed: "Nie udało się podpisać tokenu JWT",
+    authentication_failed: "Uwierzytelnianie nie powiodło się",
+    user_not_authenticated: "Użytkownik nie jest uwierzytelniony",
+    publicUserNotAllowed:
+      "Użytkownik publiczny nie jest dozwolony dla tego endpointu",
+    validation_failed: "Walidacja nie powiodła się",
+    failed_to_create_lead: "Nie udało się utworzyć leada",
+    native: {
+      unsupported:
+        "Ta metoda uwierzytelniania nie jest obsługiwana w React Native",
+      storage_failed: "Nie udało się zapisać danych uwierzytelniania",
+      clear_failed: "Nie udało się wyczyścić danych uwierzytelniania",
+    },
+    not_implemented_native:
+      "Ta funkcja nie jest jeszcze zaimplementowana dla React Native",
+    unknownError: "Wystąpił nieznany błąd podczas uwierzytelniania",
+  },
+  post: {
+    title: "Tytuł",
+    description: "Opis endpointu",
+    form: {
+      title: "Konfiguracja",
+      description: "Skonfiguruj parametry",
+    },
+    response: {
+      title: "Odpowiedź",
+      description: "Dane odpowiedzi",
+    },
+    errors: {
+      unauthorized: {
+        title: "Brak autoryzacji",
+        description: "Wymagana autoryzacja",
+      },
+      validation: {
+        title: "Błąd walidacji",
+        description: "Nieprawidłowe parametry żądania",
+      },
+      missing_locale: {
+        title: "Brak locale",
+        description: "Parametr locale jest wymagany",
+      },
+      server: {
+        title: "Błąd serwera",
+        description: "Wystąpił wewnętrzny błąd serwera",
+      },
+      unknown: {
+        title: "Nieznany błąd",
+        description: "Wystąpił nieznany błąd",
+      },
+      network: {
+        title: "Błąd sieci",
+        description: "Wystąpił błąd sieci",
+      },
+      forbidden: {
+        title: "Zabronione",
+        description: "Dostęp zabroniony",
+      },
+      notFound: {
+        title: "Nie znaleziono",
+        description: "Zasób nie został znaleziony",
+      },
+      conflict: {
+        title: "Konflikt",
+        description: "Wystąpił konflikt danych",
+      },
+      token_generation_failed: {
+        title: "Generowanie tokenu nie powiodło się",
+        description: "Nie udało się wygenerować tokenu uwierzytelniania",
+      },
+      invalid_session: {
+        title: "Nieprawidłowa sesja",
+        description: "Sesja jest nieprawidłowa lub wygasła",
+      },
+      missing_request_context: {
+        title: "Brak kontekstu żądania",
+        description: "Kontekst żądania jest brakujący",
+      },
+      unsupported_platform: {
+        title: "Nieobsługiwana platforma",
+        description: "Platforma nie jest obsługiwana",
+      },
+      session_retrieval_failed: {
+        title: "Pobieranie sesji nie powiodło się",
+        description: "Nie udało się pobrać sesji",
+      },
+      missing_token: {
+        title: "Brak tokenu",
+        description: "Token uwierzytelniania jest brakujący",
+      },
+      invalid_token_signature: {
+        title: "Nieprawidłowy podpis tokenu",
+        description: "Podpis tokenu jest nieprawidłowy",
+      },
+      jwt_payload_missing_id: {
+        title: "Brak ID w payload JWT",
+        description: "Payload JWT nie zawiera ID użytkownika",
+      },
+      cookie_set_failed: {
+        title: "Ustawienie cookie nie powiodło się",
+        description: "Nie udało się ustawić cookie uwierzytelniania",
+      },
+      cookie_clear_failed: {
+        title: "Wyczyszczenie cookie nie powiodło się",
+        description: "Nie udało się wyczyścić cookie uwierzytelniania",
+      },
+    },
+    success: {
+      title: "Sukces",
+      description: "Operacja zakończona pomyślnie",
+    },
+  },
+  check: {
+    get: {
+      title: "Sprawdź uwierzytelnianie",
+      description: "Sprawdź aktualny status uwierzytelniania",
+      response: {
+        title: "Status uwierzytelniania",
+        description: "Aktualny stan uwierzytelniania",
+        authenticated: "Uwierzytelniony",
+        tokenValid: "Token ważny",
+      },
+    },
+  },
+  enums: {
+    webSocketErrorCode: {
+      unauthorized: "Brak autoryzacji",
+      forbidden: "Zabronione",
+      invalidToken: "Nieprawidłowy token",
+      tokenExpired: "Token wygasł",
+      serverError: "Błąd serwera",
+    },
+  },
+  debug: {
+    getAuthMinimalUserNext: {
+      start: "getAuthMinimalUserNext: - Sprawdzanie autentykacji jako pierwsze",
+      result: "getAuthMinimalUserNext: wynik getCurrentUserNext",
+      authenticated:
+        "getAuthMinimalUserNext: Użytkownik jest uwierzytelniony, pobieranie leadId",
+      returningAuth:
+        "getAuthMinimalUserNext: Zwracanie uwierzytelnionego użytkownika",
+      notAuthenticated:
+        "getAuthMinimalUserNext: Użytkownik nie uwierzytelniony, zwracanie użytkownika publicznego",
+    },
+    signingJwt: "Podpisywanie JWT",
+    jwtSignedSuccessfully: "JWT pomyślnie podpisany",
+    errorSigningJwt: "Błąd podczas podpisywania JWT",
+    verifyingJwt: "Weryfikacja JWT",
+    invalidTokenPayload: "Nieprawidłowe dane tokenu",
+    jwtVerifiedSuccessfully: "JWT pomyślnie zweryfikowany",
+    errorVerifyingJwt: "Błąd podczas weryfikacji JWT",
+    userIdNotExistsInDb: "ID użytkownika nie istnieje w bazie danych",
+    sessionNotFound: "Sesja nie została znaleziona",
+    sessionExpired: "Sesja wygasła",
+    errorValidatingUserSession: "Błąd podczas walidacji sesji użytkownika",
+    errorGettingUserRoles: "Błąd podczas pobierania ról użytkownika",
+    errorCheckingUserAuth:
+      "Błąd podczas sprawdzania uwierzytelniania użytkownika",
+    gettingCurrentUserFromTrpc: "Pobieranie bieżącego użytkownika z tRPC",
+    errorGettingAuthUserForTrpc:
+      "Błąd podczas pobierania użytkownika auth dla tRPC",
+    errorGettingUserRolesForTrpc:
+      "Błąd podczas pobierania ról użytkownika dla tRPC",
+    authenticatingCliUserWithPayload:
+      "Uwierzytelnianie użytkownika CLI z danymi",
+    errorAuthenticatingCliUserWithPayload:
+      "Błąd podczas uwierzytelniania użytkownika CLI z danymi",
+    creatingCliToken: "Tworzenie tokenu CLI",
+    errorCreatingCliToken: "Błąd podczas tworzenia tokenu CLI",
+    validatingCliToken: "Walidacja tokenu CLI",
+    errorValidatingCliToken: "Błąd podczas walidacji tokenu CLI",
+    gettingCurrentUserFromNextjs: "Pobieranie bieżącego użytkownika z Next.js",
+    errorGettingAuthUserForNextjs:
+      "Błąd podczas pobierania użytkownika auth dla Next.js",
+    settingNextjsAuthCookies: "Ustawianie cookies auth Next.js",
+    clearingNextjsAuthCookies: "Czyszczenie cookies auth Next.js",
+    gettingCurrentUserFromToken: "Pobieranie bieżącego użytkownika z tokenu",
+    errorGettingCurrentUserFromCli:
+      "Błąd podczas pobierania bieżącego użytkownika z CLI",
+    errorGettingAuthUserForCli:
+      "Błąd podczas pobierania użytkownika auth dla CLI",
+    errorGettingUserRolesForCli:
+      "Błąd podczas pobierania ról użytkownika dla CLI",
+    tokenFromAuthHeader: "Token z nagłówka auth",
+    tokenFromCookie: "Token z cookie",
+    noTokenFound: "Nie znaleziono tokenu",
+    errorExtractingToken: "Błąd podczas wyodrębniania tokenu",
+    errorParsingCookies: "Błąd podczas parsowania cookies",
+    errorGettingCurrentUserFromTrpc:
+      "Błąd podczas pobierania bieżącego użytkownika z tRPC",
+  },
+};

package/src/app/api/[locale]/user/auth/types.ts

@@ -0,0 +1,110 @@
+/**
+ * Auth Definition
+ * Defines API types for authentication endpoints
+ * Repository-first architecture: exports TypeOutput types for repositories and routes
+ */
+
+import { dateSchema } from "next-vibe/shared/types/common.schema";
+import { z } from "zod";
+
+import {
+  UserPermissionRole,
+  UserRoleDB,
+} from "@/app/api/[locale]/user/user-roles/enum";
+
+import { WebSocketErrorCode } from "./enum";
+
+/**
+ * JWT Payload Schema
+ * Defines the structure of JWT token payloads using discriminated union
+ *
+ * IMPORTANT: Roles are fetched from DB and included in JWT during token creation/refresh.
+ * Once in the JWT, roles can be trusted because the JWT is signed and cannot be tampered with.
+ * Never fetch roles from cookies - always use roles from the verified JWT payload.
+ */
+
+const publicJwtPayloadSchema = z.object({
+  isPublic: z.literal(true),
+  leadId: z.uuid(),
+  roles: z
+    .array(z.enum([UserPermissionRole.PUBLIC]))
+    .default([UserPermissionRole.PUBLIC]),
+});
+
+const privateJwtPayloadSchema = z.object({
+  id: z.uuid(),
+  // user has always a leadId
+  leadId: z.uuid(),
+  isPublic: z.literal(false),
+  // Roles are fetched from DB during login/signup and stored in JWT
+  roles: z.array(z.enum(UserRoleDB)),
+});
+
+export const jwtPayloadSchema = z.discriminatedUnion("isPublic", [
+  publicJwtPayloadSchema,
+  privateJwtPayloadSchema,
+]);
+
+export type JWTPublicPayloadType = z.infer<typeof publicJwtPayloadSchema> & {
+  id?: never;
+};
+export type JwtPrivatePayloadType = z.infer<typeof privateJwtPayloadSchema>;
+
+export type JwtPayloadType = JWTPublicPayloadType | JwtPrivatePayloadType;
+
+/**
+ * Session Schema
+ * Defines the structure of user sessions
+ */
+export const sessionSchema = z.object({
+  id: z.uuid().optional(),
+  userId: z.uuid(),
+  token: z.string(),
+  expiresAt: dateSchema,
+  createdAt: dateSchema,
+  lastUsedAt: dateSchema.optional(),
+  ipAddress: z.string().optional(),
+  userAgent: z.string().optional(),
+  isRevoked: z.boolean().default(false),
+});
+export type SessionType = z.infer<typeof sessionSchema>;
+export type NewSessionType = Omit<SessionType, "id">;
+
+/**
+ * Auth Token Schema
+ * Defines the structure of authentication tokens
+ */
+export const authTokenSchema = z.object({
+  token: z.string(),
+  expiresAt: dateSchema,
+});
+export type AuthTokenType = z.infer<typeof authTokenSchema>;
+
+/**
+ * WebSocket User Schema
+ * Defines the structure of WebSocket user data
+ */
+export const webSocketUserSchema = z.object({
+  id: z.uuid(),
+});
+export type WebSocketUserType = z.infer<typeof webSocketUserSchema>;
+
+/**
+ * WebSocket Error Code Enum
+ * Defines error codes for WebSocket authentication
+ */
+export const webSocketErrorCodeEnum = z.enum(WebSocketErrorCode);
+export type WebSocketErrorCodeType = z.infer<typeof webSocketErrorCodeEnum>;
+
+/**
+ * Auth Verification Result Schema
+ * Defines the structure of authentication verification results
+ */
+export const authVerificationResultSchema = z.object({
+  isValid: z.boolean(),
+  payload: jwtPayloadSchema.optional(),
+  error: z.string().optional(),
+});
+export type AuthVerificationResultType = z.infer<
+  typeof authVerificationResultSchema
+>;

package/src/app/api/[locale]/user/enum.ts

@@ -0,0 +1,64 @@
+/**
+ * User enums
+ * Defines the enums used in the user module
+ */
+
+import { createEnumOptions } from "@/app/api/[locale]/system/unified-interface/shared/field/enum";
+
+/**
+ * Theme enum using createEnumOptions pattern
+ */
+export const {
+  enum: Theme,
+  options: ThemeOptions,
+  Value: ThemeValue,
+} = createEnumOptions({
+  LIGHT: "app.api.user.theme.light",
+  DARK: "app.api.user.theme.dark",
+  SYSTEM: "app.api.user.theme.system",
+});
+
+/**
+ * Profile visibility enum and options
+ */
+export const {
+  enum: ProfileVisibility,
+  options: ProfileVisibilityOptions,
+  Value: ProfileVisibilityValue,
+} = createEnumOptions({
+  PUBLIC: "app.api.user.profileVisibility.public",
+  PRIVATE: "app.api.user.profileVisibility.private",
+  CONTACTS_ONLY: "app.api.user.profileVisibility.contactsOnly",
+});
+
+/**
+ * User detail level enum and options
+ */
+export const {
+  enum: UserDetailLevel,
+  options: UserDetailLevelOptions,
+  Value: UserDetailLevelValue,
+} = createEnumOptions({
+  MINIMAL: "app.api.user.userDetailLevel.minimal",
+  STANDARD: "app.api.user.userDetailLevel.standard",
+  COMPLETE: "app.api.user.userDetailLevel.complete",
+});
+
+/**
+ * Language enum for user language preferences
+ */
+export const {
+  enum: Language,
+  options: LanguageOptions,
+  Value: LanguageValue,
+} = createEnumOptions({
+  EN: "app.api.user.language.en",
+  DE: "app.api.user.language.de",
+  PL: "app.api.user.language.pl",
+});
+
+export const UserDetailLevelDB = [
+  UserDetailLevel.MINIMAL,
+  UserDetailLevel.STANDARD,
+  UserDetailLevel.COMPLETE,
+] as const;

package/src/app/api/[locale]/user/private/i18n/de/index.ts

@@ -0,0 +1,3 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {};

package/src/app/api/[locale]/user/private/i18n/en/index.ts

@@ -0,0 +1 @@
+export const translations = {};

package/src/app/api/[locale]/user/private/i18n/pl/index.ts

@@ -0,0 +1,3 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {};