Allow number OR null as type

What is the suggested method for managing field removals on update without removing missing fields?

My standard mechanism would be to set the field to null but this doesn't appear allowed (I even tried something discussed elsewhere: @Attribute() name?: Number|null - but that has no effect).

To be clear the behaviour i'm trying to replicate is:

update those fields defined
ignore those fields not included
remove or set to null those fields defined as null

I can't pass undefined as it wont be passed through a graphql api. Ideally null would be an optional value configured for any datatype.

Anyone have any thoughts on this?
Currently the only way I can remove data with an update is to set all attributes as type any - which defeats a lot of the purpose.
The other, even less desirable option would be to load the existing object, parse through the update for null and remove those objects before updating. Which also removes a lot of the value.

I'm guessing (From other threads) the only way is to create a custom type - but im even getting stuck with that approach.

Any pointers would be appreciated.

[jeskew]

There are a few ways you can update selective attributes of an existing item without altering others. The first way would be to do what you suggest: load the existing object, change the properties that need changing, and then save the item. If the item being updated has a top-level property tagged as a @versionAttribute(), the mapper will use a conditional expression to make sure writes from multiple clients don't clobber each other.

The other option is to execute an arbitrary update expression using mapper.executeUpdateExpression. You wouldn't need to load the item being updated beforehand. If you post the object or schema, I can write a small example of how to phrase an update expression to remove a field.

That would be awesome Jonathan, Thanks!
A thing to note -
I don't know in advance what fields will be "nulled" and which will be missing, this is for an API where the end client can send any permutation of updates including setting "Age" to null (Meaning not defined vs 0 meaning they are very young).
Here is the Schema (I've cut it down a bit and kept in the idea of type|null where an item could be unset - but these get ignored):

@table("Users")
export class User {
  @hashKey({ defaultProvider: () => nanoid() }) id: string
  @attribute({
    indexKeyConfigurations: {"email-index": "HASH"}
  }) email: string
  @attribute({ defaultProvider: () => "user" }) role?: string
  @attribute() name?: string
  @attribute() company?: string
  @attribute() avatar?: string|null
  @attribute() age?: number|null
  @attribute({ defaultProvider: () => new Date() }) createdAt: Date
  @attribute({ defaultProvider: () => new Date() }) updatedAt: Date
  @attribute() emergency?: Emergency
 @attribute() token?: Token
}

export class Emergency {
  @attribute() name?: string
  @attribute() relationship?: string
  @attribute() phone?: string
  @attribute() address?: Address|null
}

export class Address {
  @attribute() street?: string
  @attribute() city?: string
  @attribute() postcode?: string
  @attribute() country?: string|null
}

[jeskew]

I can see why it would be tricky to manage updates when null is overloaded with meaning like that. If I understand correctly, age can be:

• a number, in which case the age property of the record should be updated to reflect that number,
• undefined, in which case the current value of the age property on the record should not be changed, or
• null, in which case the age property should be deleted.

I'm not sure there could be generic support for that pattern in the mapper library, since null is a valid value in DynamoDB's data model, and there would be no good way to distinguish between a call that intends to save a property with a value of null and one that intends to delete the field. If something like that were to be added, it would need to use a more structured way of declaring updates. Maybe a function that translates a JSONPatch document into an update invocation?

Given the schema for the Users table given above, if you wanted to remove a single property from a record without loading it first, you could try the following:

import { UpdateExpression } from '@aws/dynamodb-expressions';

const expression = new UpdateExpression();

// remove a top level property
expression.remove('age');

// You can remove nested properties used '.'-delimited attribute paths
expression.remove('emergency.address.country');

const updated = await mapper.executeUpdateExpression(
     updateExpression,
     {id: userId},
     User
 );

null doesn't have to be overloaded for my use case - i'm happy to set the field to null in the DB. I just need the modeller to accept either number OR null, String OR null etc and place that value in the DB. null meaning there is no value. The modeller doesn't appear to allow me to do that.

If i could create an attribute like this:

@attribute() age?: number|null

I'd be golden!

Thanks for your help!

Have updated the title to try and be more clear in my line of questioning, think it may have confused things to start with the use case.