Verificações de Propriedades em Excesso do TypeScript: Fortalecendo a Segurança de Tipos de Seus Objetos

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'email' não existe no tipo 'User'.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Erro: O argumento do tipo '{ id: number; name: string; price: number; }' não é atribuível ao parâmetro do tipo 'Product'.
             // O literal de objeto só pode especificar propriedades conhecidas, e 'price' não existe no tipo 'Product'.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Esta propriedade 'retries' é uma propriedade em excesso de acordo com 'Config'
};

setupConfig(userProvidedConfig); // Sem erro!

// Embora userProvidedConfig tenha uma propriedade extra, a verificação é ignorada
// porque não é um literal de objeto sendo passado diretamente.
// O TypeScript verifica o tipo de userProvidedConfig em si.
// Se userProvidedConfig fosse declarado com o tipo Config, um erro ocorreria antes.
// No entanto, se declarado como 'any' ou um tipo mais amplo, o erro é adiado.

// Uma maneira mais precisa de mostrar o contorno:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Propriedade em excesso
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Propriedade em excesso
  };
}

setupConfig(anotherConfig as Config); // Sem erro devido à asserção de tipo e ao contorno

// A chave é que 'anotherConfig' não é um literal de objeto no ponto de atribuição para setupConfig.
// Se tivéssemos uma variável intermediária tipada como 'Config', a atribuição inicial falharia.

// Exemplo de variável intermediária:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'logging' não existe no tipo 'Config'.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Propriedade em excesso
} as Settings;

// Sem erro aqui por causa da asserção de tipo.
// Estamos dizendo ao TypeScript: "Confie em mim, este objeto está em conformidade com Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Isso causaria um erro em tempo de execução se fontSize não estivesse realmente lá.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Permite qualquer chave de string com qualquer valor
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Sem erro porque 'name' e 'version' são permitidos pela assinatura de índice.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Propriedade em excesso em relação a BaseConfig, mas esperada pelo tipo mesclado
};

// Espalhando em um novo literal de objeto que está em conformidade com ExtendedConfig
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Isso geralmente está correto porque 'finalConfig' é declarado como 'ExtendedConfig'
// e as propriedades correspondem. A verificação é sobre o tipo de 'finalConfig'.

// Vamos considerar um cenário em que *falharia*:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' é extra aqui
const data2 = { key: 'xyz', status: 'active' }; // 'status' é extra aqui

// Tentando atribuir a um tipo que não acomoda extras

// const combined: SmallConfig = {
//   ...data1, // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'value' não existe no tipo 'SmallConfig'.
//   ...data2  // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'status' não existe no tipo 'SmallConfig'.
// };

// O erro ocorre porque o literal de objeto formado pela sintaxe de espalhamento
// contém propriedades ('value', 'status') não presentes em 'SmallConfig'.

// Se criarmos uma variável intermediária com um tipo mais amplo:

const temp: any = {
  ...data1,
  ...data2
};

// Então, ao atribuir a SmallConfig, a verificação de propriedade em excesso é contornada na criação do literal inicial,
// mas a verificação de tipo na atribuição ainda pode ocorrer se o tipo de temp for inferido mais estritamente.
// No entanto, se temp for 'any', nenhuma verificação acontece até a atribuição a 'combined'.

// Vamos refinar o entendimento do espalhamento com verificações de propriedades em excesso:
// A verificação acontece quando o literal de objeto criado pela sintaxe de espalhamento é atribuído
// a uma variável ou passado para uma função que espera um tipo mais específico.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Isso falhará se SpecificShape não permitir 'extra1' ou 'extra2':
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// A razão pela qual falha é que a sintaxe de espalhamento efetivamente cria um novo literal de objeto.
// Se objA e objB tivessem chaves sobrepostas, a última prevaleceria. O compilador
// vê este literal resultante e o verifica em relação a 'SpecificShape'.

// Para fazer funcionar, você pode precisar de um passo intermediário ou um tipo mais permissivo:

const tempObj = {
  ...objA,
  ...objB
};

// Agora, se tempObj tiver propriedades que não estão em SpecificShape, a atribuição falhará:
// const mergedCorrected: SpecificShape = tempObj; // Erro: O literal de objeto só pode especificar propriedades conhecidas...

// A chave é que o compilador analisa o formato do literal de objeto que está sendo formado.
// Se esse literal contiver propriedades não definidas no tipo de destino, é um erro.

// O caso de uso típico para a sintaxe de espalhamento com verificações de propriedades em excesso:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// É aqui que a verificação de propriedade em excesso é relevante:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'lastLogin' não existe no tipo 'AdminProfile'.
// };

// O literal de objeto criado pelo espalhamento tem 'lastLogin', que não está em 'AdminProfile'.
// Para corrigir isso, 'adminData' idealmente deveria estar em conformidade com AdminProfile ou a propriedade em excesso deveria ser tratada.

// Abordagem corrigida:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// Ou, mais comumente, com um apelido de tipo e sintaxe rest:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Sem erro, pois 'email' e 'isAdmin' são capturados pela assinatura de índice em UserProfileWithMetadata.
console.log(user1.email);
console.log(user1.isAdmin);

// Outra maneira usando parâmetros rest em uma definição de tipo:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Captura todas as outras propriedades em 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails conterá quaisquer propriedades não desestruturadas explicitamente,
  // como 'salary', 'startDate', etc.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Mesmo que employeeInfo tivesse uma propriedade extra inicialmente, a verificação de propriedade em excesso
// é contornada se a assinatura da função a aceitar (por exemplo, usando uma assinatura de índice).
// Se processEmployeeData fosse tipado estritamente como 'Employee', e employeeInfo tivesse 'salary',
// um erro ocorreria SE employeeInfo fosse um literal de objeto passado diretamente.
// Mas aqui, employeeInfo é uma variável, e o tipo da função lida com os extras.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // Email opcional
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Se tentarmos adicionar uma propriedade que não está em UserProfile:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'phoneNumber' não existe no tipo 'UserProfile'.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Imagine que isso vem de uma fonte externa ou de um módulo menos estrito
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Propriedade em excesso
};

// Se você sabe que 'externalConfig' sempre terá 'id' e 'version' e quer tratá-lo como ProductConfig:
const productConfig = externalConfig as ProductConfig;

// Esta asserção contorna a verificação de propriedade em excesso em `externalConfig` em si.
// No entanto, se você passasse um literal de objeto diretamente:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Erro: O literal de objeto só pode especificar propriedades conhecidas, e 'debugMode' não existe no tipo 'ProductConfig'.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // O TypeScript sabe que 'shape' é um Circle aqui
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // O TypeScript sabe que 'shape' é um Square aqui
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Usando 'as const' para inferência de tipo literal
  radius: 10,
  color: 'red' // Propriedade em excesso
};

// Quando passado para calculateArea, a assinatura da função espera 'Shape'.
// A função em si acessará 'kind' corretamente.
// Se calculateArea estivesse esperando 'Circle' diretamente e recebesse circleData
// como um literal de objeto, 'color' seria um problema.

// Vamos ilustrar a verificação de propriedade em excesso com uma função que espera um subtipo específico:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Erro: O argumento do tipo '{ kind: "circle"; radius: number; color: string; }' não é atribuível ao parâmetro do tipo 'Circle'.
                         // O literal de objeto só pode especificar propriedades conhecidas, e 'color' não existe no tipo 'Circle'.

// Para corrigir isso, você pode desestruturar ou usar um tipo mais permissivo para circleData:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// Ou defina circleData para incluir um tipo mais amplo:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Agora funciona.

            

              
                Copy