Composição de Guardas em Pattern Matching de JavaScript: Dominando Lógica Condicional Complexa para Equipas Globais

            function processUserAction(user, event, systemConfig) {
  if (user && user.isAuthenticated) {
    if (user.roles.includes('admin') || user.permissions.canEdit) {
      if (event.type === 'UPDATE_ITEM' && event.payload && event.payload.itemId) {
        if (systemConfig.isMaintenanceMode && user.roles.includes('super_admin')) {
          // Permitir que super administradores ignorem a manutenção para atualizações
          console.log(`Admin ${user.id} updated item ${event.payload.itemId} during maintenance.`);
          return updateItem(event.payload.itemId, event.payload.data);
        } else if (!systemConfig.isMaintenanceMode) {
          console.log(`User ${user.id} updated item ${event.payload.itemId}.`);
          return updateItem(event.payload.itemId, event.payload.data);
        } else {
          console.warn('Cannot update item: System in maintenance mode.');
          return { status: 'error', message: 'Maintenance mode active' };
        }
      } else if (event.type === 'VIEW_DASHBOARD' && user.permissions.canViewDashboard) {
        console.log(`User ${user.id} viewed dashboard.`);
        return getDashboardData(user.id);
      } else {
        console.warn('Unknown or unauthorized event type for this user.');
        return { status: 'error', message: 'Invalid event' };
      }
    } else {
      console.warn('User does not have sufficient permissions.');
      return { status: 'error', message: 'Insufficient permissions' };
    }
  } else {
    console.warn('Unauthorized access: User not authenticated.');
    return { status: 'error', message: 'Authentication required' };
  }
}

            

              
                Copy
              
            
          

            const value = /* alguns dados */; 

const result = switch (value) {
  case pattern1 => expression1,
  case pattern2 => expression2,
  // ...
  default => defaultExpression,
};

            

              
                Copy
              
            
          

            const event = { type: 'USER_LOGIN', payload: { userId: 'abc' } };

const handlerResult = switch (event) {
  case { type: 'USER_LOGIN', payload: { userId } } => `User ${userId} logged in.`,
  case { type: 'USER_LOGOUT', payload: { userId } } => `User ${userId} logged out.`,
  case { type: 'ERROR', payload: { message } } => `Error: ${message}.`,
  default => 'Unknown event type.'
};

console.log(handlerResult); // Output: "User abc logged in."

            

              
                Copy
              
            
          

            const result = switch (value) {
  case pattern if conditionExpression => expression,
  // ...
};

            

              
                Copy
              
            
          

            const user = { id: 'admin1', name: 'Alice', role: 'admin', isActive: true, age: 30 };
const event = { type: 'EDIT_SETTINGS', targetId: 'config1' };

const processingResult = switch ([user, event]) {
  case [{ role: 'admin', isActive: true, age }, { type: 'EDIT_SETTINGS', targetId }] if age > 18 => {
    console.log(`Admin ${user.name} (${user.id}) aged ${age} is editing settings for ${targetId}.`);
    // Executar lógica de edição de configurações específica do administrador
    return { status: 'success', action: 'EDIT_SETTINGS', entity: targetId };
  },
  case [{ role: 'user' }, { type: 'VIEW_PROFILE', targetId }] => {
    console.log(`User ${user.name} (${user.id}) is viewing profile for ${targetId}.`);
    // Executar lógica de visualização de perfil específica do utilizador
    return { status: 'success', action: 'VIEW_PROFILE', entity: targetId };
  },
  default => {
    console.warn('No matching pattern or guard condition met.');
    return { status: 'failure', message: 'Action not authorized or recognized' };
  }
};

console.log(processingResult);

// Exemplo 2: Administrador inativo
const inactiveUser = { id: 'admin2', name: 'Bob', role: 'admin', isActive: false, age: 45 };
const inactiveResult = switch ([inactiveUser, event]) {
  case [{ role: 'admin', isActive: true, age }, { type: 'EDIT_SETTINGS', targetId }] if age > 18 => {
    console.log(`Admin ${inactiveUser.name} (${inactiveUser.id}) aged ${age} is editing settings for ${targetId}.`);
    return { status: 'success', action: 'EDIT_SETTINGS', entity: targetId };
  },
  default => {
    console.warn('No matching pattern or guard condition met for inactive admin.');
    return { status: 'failure', message: 'Action not authorized or recognized' };
  }
};

console.log(inactiveResult); // Irá para o default porque isActive é falso

            

              
                Copy
              
            
          

            const order = { 
  id: 'ORD-001', 
  status: 'PENDING', 
  payment: { type: 'CREDIT_CARD', status: 'PAID' }, 
  items: [{ productId: 'P001', quantity: 1 }], 
  shippingAddress: '123 Global St.' 
};
const inventoryService = { 
  check: (id) => id === 'P001' ? { available: 5 } : { available: 0 },
  reserve: (id, qty) => console.log(`Reserved ${qty} of ${id}`), 
  dispatch: (orderId) => console.log(`Dispatched order ${orderId}`)
};
const fraudDetectionService = { 
  isFraudulent: (order) => false 
}; // Assume que não há fraude para este exemplo

function processOrder(order, services) {
  return switch (order) {
    // Caso 1: Encomenda PENDENTE, pagamento PAGO, e inventário disponível (guarda complexa)
    case { 
      status: 'PENDING',
      payment: { type: paymentType, status: 'PAID' },
      items: [{ productId, quantity }],
      id: orderId
    } 
    if (paymentType === 'CREDIT_CARD' && services.inventoryService.check(productId).available >= quantity && !services.fraudDetectionService.isFraudulent(order)) => {
      services.inventoryService.reserve(productId, quantity);
      // Simular despacho
      services.inventoryService.dispatch(orderId);
      console.log(`Order ${orderId} processed and dispatched via ${paymentType}.`);
      return { status: 'SUCCESS', message: 'Order dispatched.' };
    },

    // Caso 2: Encomenda PENDENTE, pagamento PENDENTE, requer revisão manual
    case { status: 'PENDING', payment: { status: 'PENDING' } } => {
      console.log(`Order ${order.id} is pending payment. Requires manual review.`);
      return { status: 'PENDING_PAYMENT', message: 'Payment authorization required.' };
    },

    // Caso 3: Encomenda PENDENTE, mas inventário insuficiente (sub-caso específico)
    case { 
      status: 'PENDING',
      items: [{ productId, quantity }],
      id: orderId
    } if (services.inventoryService.check(productId).available < quantity) => {
      console.warn(`Order ${orderId} failed: Insufficient inventory for product ${productId}.`);
      return { status: 'FAILED', message: 'Insufficient inventory.' };
    },

    // Caso 4: Encomenda já CANCELADA ou FALHADA
    case { status: orderStatus } if (orderStatus === 'CANCELLED' || orderStatus === 'FAILED') => {
      console.log(`Order ${order.id} is already ${orderStatus}. No action taken.`);
      return { status: 'NO_ACTION', message: `Order already ${orderStatus}.` };
    },

    // Padrão para todos os outros casos
    default => {
      console.warn(`Could not process order ${order.id} due to unhandled state.`);
      return { status: 'UNKNOWN_FAILURE', message: 'Unhandled order state.' };
    }
  };
}

// Casos de teste:
console.log('\n--- Test Case 1: Successful Order ---');
const result1 = processOrder(order, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result1, null, 2));

console.log('\n--- Test Case 2: Insufficient Inventory ---');
const order2 = { ...order, items: [{ productId: 'P001', quantity: 10 }] }; // Apenas 5 disponíveis
const result2 = processOrder(order2, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result2, null, 2));

console.log('\n--- Test Case 3: Pending Payment ---');
const order3 = { ...order, payment: { type: 'BANK_TRANSFER', status: 'PENDING' } };
const result3 = processOrder(order3, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result3, null, 2));

console.log('\n--- Test Case 4: Cancelled Order ---');
const order4 = { ...order, status: 'CANCELLED' };
const result4 = processOrder(order4, { inventoryService, fraudDetectionService });
console.log(JSON.stringify(result4, null, 2));

            

              
                Copy
              
            
          

            const currentUser = { id: 'usr-456', role: 'editor', permissions: ['edit:article', 'view:analytics'], region: 'EU' };
const actionRequest = { type: 'UPDATE_ARTICLE', articleId: 'art-007', payload: { title: 'New Title' }, region: 'EU' };
const systemStatus = { maintenanceMode: false, readOnlyMode: false, geoRestrictions: { 'US': ['edit:article'] } };

// Função auxiliar para verificar permissões globais (poderia ser mais sofisticada)
const hasPermission = (user, perm) => user.permissions.includes(perm);

function authorizeAction(user, action, status) {
  return switch ([user, action]) {
    // Prioridade 1: Super admin pode fazer tudo, mesmo em modo de manutenção, se a ação for para a sua região
    case [{ role: 'super_admin', region: userRegion }, { region: actionRegion }] 
    if (userRegion === actionRegion) => {
      console.log(`SUPER ADMIN ${user.id} authorized for action ${action.type} in region ${userRegion}.`);
      return { authorized: true, reason: 'Super Admin privileges.' };
    },

    // Prioridade 2: Admin pode realizar ações específicas se não estiver em modo de apenas leitura, e para a sua região
    case [{ role: 'admin', region: userRegion }, { type: actionType, region: actionRegion }] 
    if (userRegion === actionRegion && !status.readOnlyMode && (actionType === 'PUBLISH_ARTICLE' || actionType === 'MANAGE_USERS')) => {
      console.log(`ADMIN ${user.id} authorized for ${actionType} in region ${userRegion}.`);
      return { authorized: true, reason: 'Admin role.' };
    },

    // Prioridade 3: Utilizador com permissão específica para o tipo de ação e região, não em manutenção/apenas leitura
    case [{ permissions, region: userRegion }, { type: actionType, region: actionRegion }] 
    if (userRegion === actionRegion && hasPermission(user, `edit:${actionType.toLowerCase().replace('_article', '')}`) && !status.maintenanceMode && !status.readOnlyMode) => {
      console.log(`USER ${user.id} authorized for ${actionType} in region ${userRegion} via permission.`);
      return { authorized: true, reason: 'Specific permission granted.' };
    },

    // Prioridade 4: Se o sistema estiver em modo de manutenção, negar todas as ações que não sejam de super admin
    case _ if status.maintenanceMode => {
      console.warn('Action denied: System is in maintenance mode.');
      return { authorized: false, reason: 'System in maintenance mode.' };
    },

    // Prioridade 5: Se o modo de apenas leitura estiver ativo, negar ações que modificam dados
    case [{ role }, { type }] if (status.readOnlyMode && (type.startsWith('UPDATE_') || type.startsWith('CREATE_') || type.startsWith('DELETE_'))) => {
      console.warn(`Action denied: Read-only mode active. Cannot ${type}.`);
      return { authorized: false, reason: 'System in read-only mode.' };
    },

    // Padrão: Negar se nenhuma outra autorização específica corresponder
    default => {
      console.warn(`Action ${action.type} denied for ${user.id}. No matching authorization rule.`);
      return { authorized: false, reason: 'No matching authorization rule.' };
    }
  };
}

// Casos de Teste:
console.log('\n--- Test Case 1: Editor updates article in same region ---');
let authResult1 = authorizeAction(currentUser, actionRequest, systemStatus);
console.log(JSON.stringify(authResult1, null, 2));

console.log('\n--- Test Case 2: Editor attempts update in different region (denied) ---');
let actionRequest2 = { ...actionRequest, region: 'US' };
let authResult2 = authorizeAction(currentUser, actionRequest2, systemStatus);
console.log(JSON.stringify(authResult2, null, 2));

console.log('\n--- Test Case 3: Admin attempts to publish in maintenance mode (denied by later guard) ---');
let adminUser = { id: 'adm-001', role: 'admin', permissions: ['publish:article'], region: 'EU' };
let publishAction = { type: 'PUBLISH_ARTICLE', articleId: 'art-008', region: 'EU' };
let maintenanceStatus = { ...systemStatus, maintenanceMode: true };
let authResult3 = authorizeAction(adminUser, publishAction, maintenanceStatus);
console.log(JSON.stringify(authResult3, null, 2)); // Deve ser negado pela guarda do modo de manutenção

console.log('\n--- Test Case 4: Super Admin in maintenance mode ---');
let superAdminUser = { id: 'sa-001', role: 'super_admin', permissions: [], region: 'EU' };
let authResult4 = authorizeAction(superAdminUser, publishAction, maintenanceStatus);
console.log(JSON.stringify(authResult4, null, 2)); // Deve ser autorizado

            

              
                Copy
              
            
          

            const featureFlags = { 
  'enableAdvancedReporting': true, 
  'enablePremiumSupport': false, 
  'allowBetaFeatures': true 
};

const userProfile = { 
  id: 'jane-d', 
  subscription: 'premium', 
  region: 'APAC', 
  lastLogin: new Date('2023-10-26T10:00:00Z') 
};

const action = { type: 'GENERATE_REPORT', reportType: 'FINANCIAL' };

// Funções auxiliares para condições de guarda complexas
const isPremiumUser = (user) => user.subscription === 'premium';
const isFeatureEnabled = (flagName) => featureFlags[flagName] === true;
const isRegionalAccessAllowed = (userRegion, actionRegion) => userRegion === actionRegion; // Simplificado
const isTimeOfDayValid = (hour) => hour >= 9 && hour <= 17; // 9h às 17h, hora local

function handleUserAction(user, userAction) {
  const currentHour = new Date().getUTCHours(); // Exemplo: Usando a hora UTC

  return switch ([user, userAction]) {
    // Caso 1: Utilizador premium a gerar relatório financeiro, feature ativada, dentro do horário válido, na região permitida
    case [userObj, { type: 'GENERATE_REPORT', reportType: 'FINANCIAL' }] 
    if (isPremiumUser(userObj) && isFeatureEnabled('enableAdvancedReporting') && isTimeOfDayValid(currentHour) && isRegionalAccessAllowed(userObj.region, 'APAC')) => {
      console.log(`Premium user ${userObj.id} generating FINANCIAL report.`);
      return { status: 'SUCCESS', message: 'Financial report initiated.' };
    },

    // Caso 2: Qualquer utilizador a ver um relatório básico (feature não necessária), na região permitida
    case [userObj, { type: 'VIEW_REPORT', reportType: 'BASIC' }] 
    if (isRegionalAccessAllowed(userObj.region, 'GLOBAL')) => { // Assumindo que os relatórios básicos são globais
      console.log(`User ${userObj.id} viewing BASIC report.`);
      return { status: 'SUCCESS', message: 'Basic report displayed.' };
    },

    // Caso 3: Utilizador tenta suporte premium, mas a feature está desativada
    case [userObj, { type: 'REQUEST_SUPPORT', supportLevel: 'PREMIUM' }] 
    if (!isFeatureEnabled('enablePremiumSupport')) => {
      console.warn(`User ${userObj.id} requested PREMIUM support, but feature is disabled.`);
      return { status: 'FAILED', message: 'Premium support not available.' };
    },

    // Caso 4: Negação geral se a ação for fora do horário válido
    case _ if !isTimeOfDayValid(currentHour) => {
      console.warn('Action denied: Outside operational hours.');
      return { status: 'FAILED', message: 'Service not available at this time.' };
    },

    default => {
      console.warn(`Action ${userAction.type} denied for user ${user.id}.`);
      return { status: 'FAILED', message: 'Action not authorized or recognized.' };
    }
  };
}

// Casos de teste:
console.log('\n--- Test Case 1: Premium user generating report (should pass if within time) ---');
const result_report = handleUserAction(userProfile, action);
console.log(JSON.stringify(result_report, null, 2));

console.log('\n--- Test Case 2: Attempting disabled premium support ---');
const result_support = handleUserAction(userProfile, { type: 'REQUEST_SUPPORT', supportLevel: 'PREMIUM' });
console.log(JSON.stringify(result_support, null, 2));

// Simular a mudança da hora atual para testar a lógica baseada no tempo
const originalGetUTCHours = Date.prototype.getUTCHours;
Date.prototype.getUTCHours = () => 20; // Definir para 20:00 UTC para teste
console.log('\n--- Test Case 3: Action outside valid time window (simulated) ---');
const result_late = handleUserAction(userProfile, action);
console.log(JSON.stringify(result_late, null, 2));
Date.prototype.getUTCHours = originalGetUTCHours; // Restaurar o comportamento original

            

              
                Copy
              
            
          

            if (user && user.isAuthenticated) {
  if (user.roles.includes('admin') || user.permissions.canEdit) {
    if (event.type === 'UPDATE_ITEM' && event.payload && event.payload.itemId) {
      // ... mais condições
    }
  }
}

            

              
                Copy
              
            
          

            function processUserActionWithPatternMatching(user, event, systemConfig) {
  return switch ([user, event]) {
    // Admin/Editor a atualizar um item (guarda complexa)
    case [ { isAuthenticated: true, roles, permissions }, 
           { type: 'UPDATE_ITEM', payload: { itemId, data } } ]
    if ((roles.includes('admin') || permissions.canEdit) && 
        (!systemConfig.isMaintenanceMode || (systemConfig.isMaintenanceMode && roles.includes('super_admin')))) => {
      console.log(`User ${user.id} updated item ${itemId}.`);
      return updateItem(itemId, data);
    },

    // Utilizador a ver o dashboard
    case [ { isAuthenticated: true, permissions }, 
           { type: 'VIEW_DASHBOARD' } ]
    if (permissions.canViewDashboard) => {
      console.log(`User ${user.id} viewed dashboard.`);
      return getDashboardData(user.id);
    },

    // Negar se não estiver autenticado (implícito, pois este é o único caso que o exige explicitamente)
    case [ { isAuthenticated: false }, _ ] => {
        console.warn('Unauthorized access: User not authenticated.');
        return { status: 'error', message: 'Authentication required' };
    },

    // Outras negações específicas / padrões
    default => {
      console.warn('Unknown or unauthorized event type for this user.');
      return { status: 'error', message: 'Invalid event' };
    }
  };
}

            

              
                Copy