Can undefined be forcibly assigned with strict null checks enabled?

Question

Can undefined be forcibly assigned with strict null checks enabled?

Considering enabling the strictNullChecks flag for a TypeScript project I've been developing leads to numerous compiler errors. While some of these errors are relevant edge cases, many follow a specific pattern.

type BusinessObject = {
  id: string;
  name: string;
  requiredValue: number;
  // ...
}

class DataStore {
  // ...
  public addItem(item: BusinessObject): Promise<string>;
  public getItem(id: string): Promise<BusinessObject>;
}

function consumeData(store: DataStore){
  store.addItem({name:"one", requiredValue:1});
  store.getItem("two").then(item => console.log(item.id));
}

The issue arises with the 'id' property, generated by the database and therefore only "optional" when creating a new item. If I make the 'id' property mandatory (no '?'), I encounter a compiler error in the 'addItem' call. However, if I make the ID property optional, every reference to it must include a guard or non-null assertion operator (item.id!).

One workaround I've thought of is casting the argument passed to 'addItem' as any, but this disables checking on other properties of 'BusinessObject', making it an imperfect solution. A potential solution I'm looking for is akin to the non-null assertion operator, allowing me to assert that a null assignment is acceptable despite the type declaration suggesting otherwise, like so:

store.addItem({id: undefined!, name:"one", requiredValue:1});

.

I am open to better/more consistent ways of describing this issue and its resolution.

typescript

Answer 1

Answer №1

Consider having two distinct types: one to represent the object during creation and another for a saved object.

type NewCompanyObject = {
    id?: string;
    name: string;
    requiredValue: number;
    // ...
}
type CompanyObject = NewCompanyObject & {
    id: string
}

declare class Database {
    // ...
    public addRecord(record: NewCompanyObject): Promise<string>;
    public retrieveRecord(id: string): Promise<CompanyObject>;
}

function processDatabase(dataStore: Database) {
    dataStore.addRecord({ name: "alpha", requiredValue: 1 });
    dataStore.retrieveRecord("beta").then(item => console.log(item.id));
}

Answer 2

Consider having two distinct types: one to represent the object during creation and another for a saved object.

type NewCompanyObject = {
    id?: string;
    name: string;
    requiredValue: number;
    // ...
}
type CompanyObject = NewCompanyObject & {
    id: string
}

declare class Database {
    // ...
    public addRecord(record: NewCompanyObject): Promise<string>;
    public retrieveRecord(id: string): Promise<CompanyObject>;
}

function processDatabase(dataStore: Database) {
    dataStore.addRecord({ name: "alpha", requiredValue: 1 });
    dataStore.retrieveRecord("beta").then(item => console.log(item.id));
}

Answer 3

Answer №2

After some further reflection, I have discovered an operator that functions similarly to the one I previously mentioned:

repository.insert({ id: null as any, title: "example", value: 100 });

While I am still interested in exploring more sustainable solutions, such as Titian's proposal, this alternative is worth considering.

Answer 4

After some further reflection, I have discovered an operator that functions similarly to the one I previously mentioned:

repository.insert({ id: null as any, title: "example", value: 100 });

While I am still interested in exploring more sustainable solutions, such as Titian's proposal, this alternative is worth considering.

Answer 5

Answer №3

To avoid encountering the error, a simple solution would be to modify the definition of addItem as follows:

public addItem(item: Partial<BusinessObject>): Promise<string>

By implementing this change, your code will function properly. However, it renders all properties of BusinessObject optional, not just the id. This may not pose an issue if default values are specified for the other properties. In cases where sensible defaults are not available, creating two types—one with and one without the id—may be necessary.

The ideal scenario would involve something like:

public addItem(item: Omit<BusinessObject, "id">): Promise<string>

Various TypeScript proposals, such as those referenced in https://github.com/Microsoft/TypeScript/issues/12215, suggest solutions that could simplify your code in the future.

While the linked issue contains substantial information, here's a summary of what appears to offer a resolution (also refer to issue 19569):

export type Diff<T extends string, U extends string> = ({[P in T]: P} &
  {[P in U]: never} & {[x: string]: never})[T];
export type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;

type BusinessObject = {
  id: string;
  name: string;
  requiredValue: number;
  // ...
}

class DataStore {
  // ...
  public addItem(item: Omit<BusinessObject, "id">): Promise<string> {
      return Promise.resolve('foo')};
  public getItem(id: string): Promise<BusinessObject> {
      return Promise.resolve({} as any as BusinessObject);
  };
}

function consumeData(store: DataStore){
  store.addItem({name:"one", requiredValue:1});
  store.getItem("two").then(item => console.log(item.id));
}

(The dummy body code was added to addItem and getItem solely to appease the compiler; please disregard.)

Answer 6

To avoid encountering the error, a simple solution would be to modify the definition of addItem as follows:

public addItem(item: Partial<BusinessObject>): Promise<string>

By implementing this change, your code will function properly. However, it renders all properties of BusinessObject optional, not just the id. This may not pose an issue if default values are specified for the other properties. In cases where sensible defaults are not available, creating two types—one with and one without the id—may be necessary.

The ideal scenario would involve something like:

public addItem(item: Omit<BusinessObject, "id">): Promise<string>

Various TypeScript proposals, such as those referenced in https://github.com/Microsoft/TypeScript/issues/12215, suggest solutions that could simplify your code in the future.

While the linked issue contains substantial information, here's a summary of what appears to offer a resolution (also refer to issue 19569):

export type Diff<T extends string, U extends string> = ({[P in T]: P} &
  {[P in U]: never} & {[x: string]: never})[T];
export type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;

type BusinessObject = {
  id: string;
  name: string;
  requiredValue: number;
  // ...
}

class DataStore {
  // ...
  public addItem(item: Omit<BusinessObject, "id">): Promise<string> {
      return Promise.resolve('foo')};
  public getItem(id: string): Promise<BusinessObject> {
      return Promise.resolve({} as any as BusinessObject);
  };
}

function consumeData(store: DataStore){
  store.addItem({name:"one", requiredValue:1});
  store.getItem("two").then(item => console.log(item.id));
}

(The dummy body code was added to addItem and getItem solely to appease the compiler; please disregard.)

Can undefined be forcibly assigned with strict null checks enabled?

Answer №1

Answer №2

Answer №3

Similar questions

Angular 2: Converting JSON data into an array

The property 'fullName' is assumed to have type 'any' due to the missing parameter type annotation in its set accessor

The default selected item in Material Select does not function properly on the second attempt

Troubleshooting: Issues with APIGateway's Default Integration

Tips for creating an array that aligns with the keys of a type in TypeScript

Loop through the coefficients of a polynomial created from a string using JavaScript

The provided argument, which is of type 'RefObject<HTMLDivElement>', cannot be assigned to the parameter of type 'IDivPosition'

Arranging Objects by Date in TypeScript

What is the procedure for entering the output generated by genMockFromModule when creating a custom mock in Jest?

Is there a way to make a model behave like an object in loopback when typing?

Creating variables in Typescript

Typesafe-actions for defining typings of async actions reducers

Utilizing the URL path name for data retrieval in Next.js 14 - A step-by-step guide

Communication between Angular services and the issue of 'circular dependency detected' alerts

Leverage context to facilitate communication between components operating at various levels of the system

Error message: There appears to be a type error within the labelFunc of the KeyBoardDatePicker component in the Material-UI

Is ngOnDestroy executed within Angular services?

Personalized prefix for Angular and WebStorm components

Typescript issue: "The property 'webPreferences' is causing an expected type error, as declared in type 'BrowserWindowConstructorOptions'"

Using TypeScript to create a generic type that wraps around HTMLElements