Can't conditionally update custom mapped list of strings with empty value

[LucasDachman]

Describe the bug

If I have a property with a custom mapper like

@Model()
class MyModel {
 @Property({ mapper: stringArrayOrEmptyMapper })
 myList: string[]
}

export const stringArrayOrEmptyMapper: MapperForType<
 string[],
 ListAttribute<StringAttribute>
> = {
 fromDb: attributeValue =>
 attributeValue?.L?.map((item: { S: string }) => item.S) ?? [],
 toDb: propertyValue =>
 propertyValue?.length
 ? { L: propertyValue.map(item => ({ S: item })) }
 : { L: [] },
};

and I try to do a conditional transact update like:

new TransactUpdate(MyModel, PK, SK)
 .onlyIfAttribute('myList')
 .eq([])
 .updateAttribute('myList)
 .set(['liststuff'])

I get Error: expected 1 value(s) for operator =, this is not the right amount of method parameters for this operator

This works fine if the list is populated but fails when the list is empty

Expected behavior
I expect the operation to succeed if the list is empty and fail if the list is not empty. I do not expect an error

[LucasDachman]

Seems like this is due to line 310 in condition-expression-builder.ts. The validator throws if the conditional values length is falsey. Why is this needed?

function validateForOperator(operator: ConditionOperator, values?: any[]) {
 validateArity(operator, values)

 /*
 * validate values if operator supports values
 */
 if (!isFunctionOperator(operator) || (isFunctionOperator(operator) && !isNoParamFunctionOperator(operator))) {
 if (values && Array.isArray(values) && values.length) {
 validateValues(operator, values)
 } else {
 throw new Error(
 dynamicTemplate(ERR_ARITY_DEFAULT, { parameterArity: operatorParameterArity(operator), operator }),
 )
 }
 }
}

Also empty arrays are striped by the deepFilter in buildFilterExpression in condition-expression-builder.ts. Is this necessary?

export function buildFilterExpression(
 attributePath: string,
 operator: ConditionOperator,
 values: any[],
 existingValueNames: string[] | undefined,
 metadata: Metadata<any> | undefined,
): Expression {
 // metadata get rid of undefined values
 values = deepFilter(values, (value) => value !== undefined)

This is legal to DynamoDB

TransactItems: [
 {
 Update: {
 TableName: ...,
 Key: ...,
 ConditionExpression: 'myList = :emptyList',
 UpdateExpression: 'SET myList = :myList',
 ExpressionAttributeValues: {
 ':emptyList': { L: [] },
 ':myList': { L: [{ S: 'value' }] },
 },
 },
 }
]

[danielblignaut]

any progress on this issue? I'm experiencing the same problem which leads to an issue with GraphQL resolvers with nonNull lists

[LucasDachman]

I ended up just using the using the dynamodb client directly for this specific use case.

[stvngrsh]

This problem extends to all actions containing empty arrays, not just condition expressions. I can't see any reason deepFilter doesn't allow empty arrays. They are 100% valid in dynamoDB. Not sure this repo is actively maintained anymore though. Forked repo and fixed here: Fantom-App#1

[TanjaBayer]

Any changes the suggested fix will be added into this repo? Would be great 😄

[michaelwittwer]

@LucasDachman @stvngrsh @TanjaBayer A fix for this is released on the next stream -> ^8.0.0-next.7 #431 (comment)