@next-vibe/checker 1.0.11 → 1.0.12

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

@@ -0,0 +1,118 @@
+/**
+ * User Definition
+ * Defines API types for user functionality
+ * Repository-first architecture: exports TypeOutput types for repositories and routes
+ */
+
+import { dateSchema } from "next-vibe/shared/types/common.schema";
+import { z } from "zod";
+
+import type { CountryLanguage } from "@/i18n/core/config";
+
+import type { JwtPayloadType } from "./auth/types";
+import {
+  Language,
+  Theme,
+  type UserDetailLevel,
+  type UserDetailLevelValue,
+} from "./enum";
+import type { UserRoleValue } from "./user-roles/enum";
+import { userRoleResponseSchema } from "./user-roles/types";
+
+/**
+ * User Preferences Schema
+ * Defines user preferences
+ */
+export const userPreferencesSchema = z
+  .object({
+    darkMode: z.boolean().default(false),
+    language: z.string().default(Language.EN),
+    theme: z.string().default(Theme.SYSTEM),
+  })
+  .partial();
+export type UserPreferencesType = z.infer<typeof userPreferencesSchema>;
+
+/**
+ * Minimal User Schema
+ * Essential user data
+ */
+export type MinimalUserType = JwtPayloadType;
+
+/**
+ * Standard User Schema
+ * Common user data
+ */
+export const standardUserSchema = z.object({
+  id: z.uuid(),
+  leadId: z.uuid(),
+  isPublic: z.literal(false),
+  email: z.email({ message: "validationErrors.user.profile.email_invalid" }),
+  privateName: z.string(),
+  publicName: z.string(),
+  locale: z.string() as z.ZodType<CountryLanguage>, // User's locale (e.g., "en-GLOBAL", "de-DE")
+  isActive: z.boolean().nullable(),
+  emailVerified: z.boolean().nullable(),
+  requireTwoFactor: z.boolean().optional(),
+  marketingConsent: z.boolean().optional(),
+  userRoles: z.array(userRoleResponseSchema),
+  createdAt: dateSchema,
+  updatedAt: dateSchema,
+});
+export type StandardUserType = z.infer<typeof standardUserSchema>;
+
+/**
+ * Complete User Schema
+ * Full user profile data
+ */
+export const completeUserSchema = standardUserSchema.extend({
+  stripeCustomerId: z.string().nullable(),
+});
+export type CompleteUserType = z.infer<typeof completeUserSchema>;
+
+/**
+ * User detail level types
+ */
+export type UserDetailLevelType = typeof UserDetailLevelValue;
+export type ExtendedUserDetailLevel =
+  | typeof UserDetailLevel.STANDARD
+  | typeof UserDetailLevel.COMPLETE;
+
+/**
+ * User fetch options
+ */
+export interface UserFetchOptions {
+  includeInactive?: boolean;
+  roles?: readonly UserRoleValue[];
+  detailLevel?: UserDetailLevelType;
+}
+
+/**
+ * User type mapping
+ */
+export type UserType<
+  T extends UserDetailLevelType = typeof UserDetailLevel.STANDARD,
+> = T extends typeof UserDetailLevel.MINIMAL
+  ? JwtPayloadType
+  : T extends ExtendedUserDetailLevel
+    ? ExtendedUserType<T>
+    : never;
+
+/**
+ * Extended user type mapping
+ */
+export type ExtendedUserType<
+  T extends ExtendedUserDetailLevel = typeof UserDetailLevel.STANDARD,
+> = T extends typeof UserDetailLevel.STANDARD
+  ? StandardUserType
+  : T extends typeof UserDetailLevel.COMPLETE
+    ? CompleteUserType
+    : StandardUserType;
+
+/**
+ * User search options
+ */
+export interface UserSearchOptions {
+  limit?: number;
+  offset?: number;
+  roles?: UserRoleValue[keyof UserRoleValue][];
+}

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

@@ -0,0 +1,112 @@
+import { createEnumOptions } from "@/app/api/[locale]/system/unified-interface/shared/field/enum";
+
+/**
+ * User Permission Roles - Actual roles assigned to users in the database
+ * These represent what a user is allowed to do (permissions)
+ */
+export const {
+  enum: UserPermissionRole,
+  options: UserPermissionRoleOptions,
+  Value: UserPermissionRoleValue,
+} = createEnumOptions({
+  PUBLIC: "app.api.user.userRoles.enums.userRole.public",
+  CUSTOMER: "app.api.user.userRoles.enums.userRole.customer",
+  PARTNER_ADMIN: "app.api.user.userRoles.enums.userRole.partnerAdmin",
+  PARTNER_EMPLOYEE: "app.api.user.userRoles.enums.userRole.partnerEmployee",
+  ADMIN: "app.api.user.userRoles.enums.userRole.admin",
+});
+
+/**
+ * Platform Access Markers - Configuration markers for endpoint platform access
+ * These are NEVER stored in database or assigned to users
+ * They control which platforms can access an endpoint (_OFF) or bypass auth
+ */
+export const {
+  enum: PlatformMarker,
+  options: PlatformMarkerOptions,
+  Value: PlatformMarkerValue,
+} = createEnumOptions({
+  CLI_OFF: "app.api.user.userRoles.enums.userRole.cliOff",
+  CLI_AUTH_BYPASS: "app.api.user.userRoles.enums.userRole.cliAuthBypass",
+  AI_TOOL_OFF: "app.api.user.userRoles.enums.userRole.aiToolOff",
+  WEB_OFF: "app.api.user.userRoles.enums.userRole.webOff",
+  MCP_OFF: "app.api.user.userRoles.enums.userRole.mcpOff",
+  PRODUCTION_OFF: "app.api.user.userRoles.enums.userRole.productionOff",
+});
+
+/**
+ * Combined UserRole enum for backward compatibility and endpoint definitions
+ * Endpoint definitions can mix permission roles and platform markers
+ */
+export const UserRole = {
+  ...UserPermissionRole,
+  ...PlatformMarker,
+} as const;
+
+export type UserRoleValue =
+  | typeof UserPermissionRoleValue
+  | typeof PlatformMarkerValue;
+
+export const UserRoleOptions = [
+  ...UserPermissionRoleOptions,
+  ...PlatformMarkerOptions,
+];
+
+/**
+ * Type guards and filters
+ */
+
+/**
+ * Check if a role is a user permission role (can be assigned to users)
+ */
+export function isUserPermissionRole(
+  role: UserRoleValue,
+): role is typeof UserPermissionRoleValue {
+  return !isPlatformMarker(role);
+}
+
+/**
+ * Check if a role is a platform access marker (config-only, never assigned to users)
+ */
+export function isPlatformMarker(
+  role: UserRoleValue,
+): role is typeof PlatformMarkerValue {
+  return (
+    role === PlatformMarker.CLI_OFF ||
+    role === PlatformMarker.WEB_OFF ||
+    role === PlatformMarker.AI_TOOL_OFF ||
+    role === PlatformMarker.MCP_OFF ||
+    role === PlatformMarker.PRODUCTION_OFF ||
+    role === PlatformMarker.CLI_AUTH_BYPASS
+  );
+}
+
+/**
+ * Filter array to get only user permission roles
+ */
+export function filterUserPermissionRoles(
+  roles: readonly UserRoleValue[],
+): (typeof UserPermissionRoleValue)[] {
+  return roles.filter(isUserPermissionRole);
+}
+
+/**
+ * Filter array to get only platform markers
+ */
+export function filterPlatformMarkers(
+  roles: readonly UserRoleValue[],
+): (typeof PlatformMarkerValue)[] {
+  return roles.filter(isPlatformMarker);
+}
+
+/**
+ * Database enum array for Drizzle - ONLY user permission roles
+ * Platform markers should NEVER be stored in the database
+ */
+export const UserRoleDB = [
+  UserPermissionRole.PUBLIC,
+  UserPermissionRole.CUSTOMER,
+  UserPermissionRole.PARTNER_ADMIN,
+  UserPermissionRole.PARTNER_EMPLOYEE,
+  UserPermissionRole.ADMIN,
+] as const;

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

@@ -0,0 +1,85 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  errors: {
+    find_failed: "Benutzerrollen konnten nicht gefunden werden",
+    batch_find_failed: "Batch-Suche nach Benutzerrollen fehlgeschlagen",
+    not_found: "Benutzerrolle nicht gefunden",
+    lookup_failed: "Benutzerrolle konnte nicht abgerufen werden",
+    add_failed: "Rolle konnte nicht zum Benutzer hinzugefügt werden",
+    no_data_returned: "Keine Daten von der Datenbank zurückgegeben",
+    remove_failed: "Rolle konnte nicht vom Benutzer entfernt werden",
+    check_failed: "Überprüfung ob Benutzer Rolle hat fehlgeschlagen",
+    delete_failed: "Benutzerrollen konnten nicht gelöscht werden",
+    endpoint_not_created: "Benutzerrollen-Endpoint wurde noch nicht erstellt",
+  },
+  post: {
+    title: "Benutzerrollen",
+    description: "Benutzerrollen-Endpunkt",
+    form: {
+      title: "Benutzerrollen-Konfiguration",
+      description: "Benutzerrollen-Parameter konfigurieren",
+    },
+    response: {
+      title: "Antwort",
+      description: "Benutzerrollen-Antwortdaten",
+    },
+    errors: {
+      unauthorized: {
+        title: "Nicht autorisiert",
+        description: "Authentifizierung erforderlich",
+      },
+      validation: {
+        title: "Validierungsfehler",
+        description: "Ungültige Anfrageparameter",
+      },
+      server: {
+        title: "Serverfehler",
+        description: "Interner Serverfehler",
+      },
+      unknown: {
+        title: "Unbekannter Fehler",
+        description: "Ein unbekannter Fehler ist aufgetreten",
+      },
+      network: {
+        title: "Netzwerkfehler",
+        description: "Netzwerkfehler aufgetreten",
+      },
+      forbidden: {
+        title: "Verboten",
+        description: "Zugriff verboten",
+      },
+      notFound: {
+        title: "Nicht gefunden",
+        description: "Ressource nicht gefunden",
+      },
+      conflict: {
+        title: "Konflikt",
+        description: "Datenkonflikt aufgetreten",
+      },
+      database_connection_failed: {
+        title: "Datenbankverbindung fehlgeschlagen",
+        description: "Verbindung zur Datenbank fehlgeschlagen",
+      },
+    },
+    success: {
+      title: "Erfolg",
+      description: "Vorgang erfolgreich abgeschlossen",
+    },
+  },
+  enums: {
+    userRole: {
+      public: "Öffentlich",
+      customer: "Kunde",
+      partnerAdmin: "Partner-Administrator",
+      partnerEmployee: "Partner-Mitarbeiter",
+      admin: "Administrator",
+      cliOff: "CLI Deaktiviert",
+      cliAuthBypass: "CLI Auth Bypass",
+      aiToolOff: "KI-Tool Deaktiviert",
+      webOff: "Web Deaktiviert",
+      mcpOff: "MCP Deaktiviert",
+      productionOff: "Produktion Deaktiviert",
+    },
+  },
+};

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

@@ -0,0 +1,83 @@
+export const translations = {
+  errors: {
+    find_failed: "Failed to find user roles",
+    batch_find_failed: "Failed to batch find user roles",
+    not_found: "User role not found",
+    lookup_failed: "Failed to lookup user role",
+    add_failed: "Failed to add role to user",
+    no_data_returned: "No data returned from database",
+    remove_failed: "Failed to remove role from user",
+    check_failed: "Failed to check if user has role",
+    delete_failed: "Failed to delete user roles",
+    endpoint_not_created: "User roles endpoint has not been created yet",
+  },
+  post: {
+    title: "User Roles",
+    description: "User Roles endpoint",
+    form: {
+      title: "User Roles Configuration",
+      description: "Configure user roles parameters",
+    },
+    response: {
+      title: "Response",
+      description: "User Roles response data",
+    },
+    errors: {
+      unauthorized: {
+        title: "Unauthorized",
+        description: "Authentication required",
+      },
+      validation: {
+        title: "Validation Error",
+        description: "Invalid request parameters",
+      },
+      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",
+      },
+      database_connection_failed: {
+        title: "Database Connection Failed",
+        description: "Failed to connect to database",
+      },
+    },
+    success: {
+      title: "Success",
+      description: "Operation completed successfully",
+    },
+  },
+  enums: {
+    userRole: {
+      public: "Public",
+      customer: "Customer",
+      partnerAdmin: "Partner Admin",
+      partnerEmployee: "Partner Employee",
+      admin: "Admin",
+      cliOff: "CLI Disabled",
+      cliAuthBypass: "CLI Auth Bypass",
+      aiToolOff: "AI Tool Disabled",
+      webOff: "Web Disabled",
+      mcpOff: "MCP Disabled",
+      productionOff: "Production Disabled",
+    },
+  },
+};

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

@@ -0,0 +1,86 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  errors: {
+    find_failed: "Nie udało się znaleźć ról użytkownika",
+    batch_find_failed: "Nie udało się znaleźć ról użytkowników wsadowo",
+    not_found: "Rola użytkownika nie znaleziona",
+    lookup_failed: "Nie udało się pobrać roli użytkownika",
+    add_failed: "Nie udało się dodać roli do użytkownika",
+    no_data_returned: "Brak danych zwróconych z bazy danych",
+    remove_failed: "Nie udało się usunąć roli od użytkownika",
+    check_failed: "Sprawdzenie czy użytkownik ma rolę nie powiodło się",
+    delete_failed: "Nie udało się usunąć ról użytkownika",
+    endpoint_not_created:
+      "Endpoint ról użytkownika nie został jeszcze utworzony",
+  },
+  post: {
+    title: "Role użytkowników",
+    description: "Endpoint ról użytkowników",
+    form: {
+      title: "Konfiguracja ról użytkowników",
+      description: "Skonfiguruj parametry ról użytkowników",
+    },
+    response: {
+      title: "Odpowiedź",
+      description: "Dane odpowiedzi ról użytkowników",
+    },
+    errors: {
+      unauthorized: {
+        title: "Brak autoryzacji",
+        description: "Wymagana autoryzacja",
+      },
+      validation: {
+        title: "Błąd walidacji",
+        description: "Nieprawidłowe parametry żądania",
+      },
+      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",
+      },
+      database_connection_failed: {
+        title: "Błąd połączenia z bazą danych",
+        description: "Nie udało się połączyć z bazą danych",
+      },
+    },
+    success: {
+      title: "Sukces",
+      description: "Operacja zakończona pomyślnie",
+    },
+  },
+  enums: {
+    userRole: {
+      public: "Publiczny",
+      customer: "Klient",
+      partnerAdmin: "Administrator partnera",
+      partnerEmployee: "Pracownik partnera",
+      admin: "Administrator",
+      cliOff: "CLI Wyłączone",
+      cliAuthBypass: "Obejście autoryzacji CLI",
+      aiToolOff: "Narzędzie AI Wyłączone",
+      webOff: "Web Wyłączone",
+      mcpOff: "MCP Wyłączone",
+      productionOff: "Produkcja Wyłączona",
+    },
+  },
+};

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

@@ -0,0 +1,34 @@
+/**
+ * User Roles Definition
+ * Defines API types for user roles functionality
+ * Repository-first architecture: exports TypeOutput types for repositories and routes
+ */
+
+import { z } from "zod";
+
+import { UserRole } from "./enum";
+
+// Re-export for external use
+export { UserRole };
+
+// Use z.enum instead of z.enum for proper enum validation
+const userRoleTypeSchema = z.enum(UserRole);
+
+export const userRoleAdminCreateSchema = z.object({
+  role: userRoleTypeSchema,
+});
+
+export const userRoleRestaurantResponseSchema = z.object({
+  id: z.uuid(),
+  role: userRoleTypeSchema,
+  userId: z.uuid(),
+});
+export type UserRoleRestaurantResponseType = z.input<
+  typeof userRoleRestaurantResponseSchema
+>;
+
+export const userRoleResponseSchema = z.object({
+  id: z.uuid(),
+  role: userRoleTypeSchema,
+});
+export type UserRoleResponseType = z.input<typeof userRoleResponseSchema>;

package/src/app/api/i18n/de/index.ts

@@ -0,0 +1,6 @@
+import { translations as localeTranslations } from "../../[locale]/i18n/de";
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  ...localeTranslations,
+};

package/src/app/api/i18n/en/index.ts

@@ -0,0 +1,5 @@
+import { translations as localeTranslations } from "../../[locale]/i18n/en";
+
+export const translations = {
+  ...localeTranslations,
+};

package/src/app/api/i18n/pl/index.ts

@@ -0,0 +1,5 @@
+import { translations as localeTranslations } from "../../[locale]/i18n/pl";
+
+export const translations = {
+  ...localeTranslations,
+};

package/src/app/i18n/de/index.ts

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

package/src/app/i18n/en/index.ts

@@ -0,0 +1,5 @@
+import { translations as apiTranslations } from "../../api/i18n/en";
+
+export const translations = {
+  api: apiTranslations,
+};

package/src/app/i18n/pl/index.ts

@@ -0,0 +1,5 @@
+import { translations as apiTranslations } from "../../api/i18n/pl";
+
+export const translations = {
+  api: apiTranslations,
+};