Make sure to include a property that is indexed when typing

Question

Make sure to include a property that is indexed when typing

I am currently working on defining a type to represent a list (hash) of HTTP headers. This type is supposed to be a hash that only contains key / string pairs:

type TStringStringHash = {
    [key: string]: string
}

However, the issue I am facing is that it allows an empty object of type TStringStringHash to be created:

const foo: TStringStringHash = {}

In my implementation, having an empty object like this doesn't make sense. My intention is for an object of type TStringStringHash to have at least one indexed property:

const foo: TStringStringHash = { foo: "bar" }

After researching, I have not found a solution that directly addresses this specific issue. Most answers focus on how to assign non-indexed optional properties, but don't cover what I am looking for.

I apologize if the solution to this problem is simple, but as of now, I haven't been able to find a resolution on my own.

Thank you in advance!

typescript

Answer 1

Answer №1

Create a unique hash using a custom function that allows you to define the arguments as per your requirements:

TS Playground

type StringEntry = [key: string, value: string];
type HashEntries = [StringEntry, ...readonly StringEntry[]];

function buildCustomHash (entries: HashEntries): Record<string, string> {
  return Object.fromEntries(entries);
}

const hash1 = buildCustomHash([
  ['name', 'value'],
]);

console.log(hash1); // { name: "value" }

const hash2 = buildCustomHash([
  ['name', 'value'],
  ['name2', 'value2'],
]);

console.log(hash2); // { name: "value", name2: "value2" }

buildCustomHash(); /*
~~~~~~~~~~~~
Expected 1 argument, but received 0.(2554) */

buildCustomHash([]); /*
           ~~
Argument of type '[]' is not compatible with parameter of type '[StringEntry, ...StringEntry[]]'.
  Source has 0 element(s) but target requires 1.(2345) */

buildCustomHash([
  ['name'], /*
  ~~~~~~~~
Type '[string]' is not assignable to type 'StringEntry'.
  Source has 1 element(s) but target expects 2.(2322) */
]);

buildCustomHash([
  ['name', 'value', 'extra'], /*
  ~~~~~~~~~~~~~~~~~~~~~~~~~~
Type '[string, string, string]' does not match 'StringEntry'.
  Source contains 3 elements but only 2 are allowed in the target.(2322) */
]);

Answer 2

Create a unique hash using a custom function that allows you to define the arguments as per your requirements:

TS Playground

type StringEntry = [key: string, value: string];
type HashEntries = [StringEntry, ...readonly StringEntry[]];

function buildCustomHash (entries: HashEntries): Record<string, string> {
  return Object.fromEntries(entries);
}

const hash1 = buildCustomHash([
  ['name', 'value'],
]);

console.log(hash1); // { name: "value" }

const hash2 = buildCustomHash([
  ['name', 'value'],
  ['name2', 'value2'],
]);

console.log(hash2); // { name: "value", name2: "value2" }

buildCustomHash(); /*
~~~~~~~~~~~~
Expected 1 argument, but received 0.(2554) */

buildCustomHash([]); /*
           ~~
Argument of type '[]' is not compatible with parameter of type '[StringEntry, ...StringEntry[]]'.
  Source has 0 element(s) but target requires 1.(2345) */

buildCustomHash([
  ['name'], /*
  ~~~~~~~~
Type '[string]' is not assignable to type 'StringEntry'.
  Source has 1 element(s) but target expects 2.(2322) */
]);

buildCustomHash([
  ['name', 'value', 'extra'], /*
  ~~~~~~~~~~~~~~~~~~~~~~~~~~
Type '[string, string, string]' does not match 'StringEntry'.
  Source contains 3 elements but only 2 are allowed in the target.(2322) */
]);

Answer 3

Answer №2

Validating empty objects is a possibility:

type OnlyLiteral<Map extends Record<string, string>> =
    Record<string, string> extends Map ? never : Map

type NotEmpty<Map extends Record<string, string>> =
    keyof Map extends never ? never : Map

const mapCheck = <
    Map extends Record<string, string>
>(obj: OnlyLiteral<NotEmpty<Map>>) => {

}

const emptyObj = {}
const typedEmptyObj: Record<string, string> = {}


mapCheck({}) // expected error
mapCheck(emptyObj) // expected error
mapcheck(typedEmptyObj) //expected error

mapCheck({ a: 'a' }) // ok

Playground

All disallowed values should be negated and replaced with never.

This solution needs thorough testing and only works with literal arguments.

To delve deeper into this concept, you can read my article

Answer 4

Validating empty objects is a possibility:

type OnlyLiteral<Map extends Record<string, string>> =
    Record<string, string> extends Map ? never : Map

type NotEmpty<Map extends Record<string, string>> =
    keyof Map extends never ? never : Map

const mapCheck = <
    Map extends Record<string, string>
>(obj: OnlyLiteral<NotEmpty<Map>>) => {

}

const emptyObj = {}
const typedEmptyObj: Record<string, string> = {}


mapCheck({}) // expected error
mapCheck(emptyObj) // expected error
mapcheck(typedEmptyObj) //expected error

mapCheck({ a: 'a' }) // ok

Playground

All disallowed values should be negated and replaced with never.

This solution needs thorough testing and only works with literal arguments.

To delve deeper into this concept, you can read my article

Make sure to include a property that is indexed when typing

Answer №1

Answer №2

Similar questions

Creating anchor links with #id that function correctly in an Angular project can sometimes be challenging

Guide to transforming API Response into Custom type in Angular 5

The error message "SyntaxError: Cannot use import statement outside a module" popped up while working with discord.js, typescript, heroku

Unable to access component properties through react-redux

Differences Between JavaScript and TypeScript Classes

Rearranging items within an array in a React component

The functionality of CDK Drag Drop is not accurately adjusting the placement of images

Creating a distinct Output type in Typescript to avoid any confusion between Output arguments and Input arguments

Display a single unique value in the dropdown menu when there are duplicate options

Challenges arise when attempting to break down an API into separate components rather than consolidating it into a

Warning: The TypeScript version in use may not support all features. The current language level is set to XX in Visual Studio 2019

Embed a dynamically generated SVG into an element in Angular without triggering any security warnings

Is there a source where I can locate type definitions for Promise objects?

Having difficulty updating the value of a FieldArray with setFieldValue in Formik

Sending a POST request with parameters using HttpClient

Accurate linking to the interface while retrieving information from a specified URL

Implementing setState callback in TypeScript with React Hooks

Is there an automatic bottom padding feature?

Guide on building an npm package that seamlessly allows for installation both locally and globally (-g) using webpack and typescript

gRPC error: "unable to connect to the specified address" while running a NestJS application on Docker