Best way to implement multiple Schemas in attribute (strategy pattern)

[bros4president]

Hi everyone! I'm trying to implement some sort of strategy pattern for a discount code feature in an ecommerce.

Roughly, each discount code has a resolver field, which is a string specifying the name of the function to apply at runtime to calculate the discount amount, and a params field, which gives this resolver the required parameters to run properly.

Example: there's a resolver called orderFractionOff that receives a fraction parameter to substract it from the order total price. So the discount entry in the table looks like this:

{
  "code": "SALE2021",
  "resolver": "orderFractionOff",
  "params": 
      {
        "fraction": 0.2
       }
}

My question is, how can I validate the correct params schema depending on the value of resolver. My options right now are: (1) Save params as unknown and validate independently before creation of discount code and everytime the resolver function is executed. (2) Pass multiple possible schemas at params schema definition and let Dynamoose figure it out, but we'd have to make sure each resolver has params with different names or types, which is too implicit and a risk if the number of resolvers grows too much.

I faced the same challenge implementing CQRS a while back, but the number of events was very small so we just saved unknown and carried on.

Thanks for your time :)

[fishcharlie]

I'm not sure exactly what you are talking about. So I'm going to be making a few assumptions in this answer.

You have 1 model in Dynamoose (which represents 1 table in DynamoDB). And you want to save objects that look like the example you gave, as well as objects that look like:

{
  "code": "DISCOUNT2021",
  "resolver": "orderDollarOff",
  "params": 
      {
        "amount": 1
       }
}

In this case you can take advantage of the fact that the schema property for dynamoose.model accepts an array of schemas (https://dynamoosejs.com/guide/Model#dynamoosemodeldocumentname-schema).

Therefore, you could do something like:

const Discount = dynamoose.model("Discount", [
	new dynamoose.Schema({
		"code": {
			"type": String,
			"required": true
		},
		"resolver": {
			"type": "Constant",
			"settings": {
				"value": "orderFractionOff"
			}
		},
		"params": {
			"type": Object,
			"schema": {
				"fraction": Number
			}
		}
	}),
	new dynamoose.Schema({
		"code": {
			"type": String,
			"required": true
		},
		"resolver": {
			"type": "Constant",
			"settings": {
				"value": "orderDollarOff"
			}
		},
		"params": {
			"type": Object,
			"schema": {
				"amount": Number
			}
		}
	})
]);

This will cause Dynamoose to automatically pick the best schema available based on the document you passed in.

However, this almost seems over-engineered to me. There is no reason you can't just use amount for both params. On the receiving end, you will need to add logic to check for resolver and use different attribute names for params depending on the case. That adds code and complexity, and what is the gain? I'd argue that besides it being cool and elegant, there is no gain there.

Therefore, another option would be to do something like the following:

const Discount = dynamoose.model("Discount", new dynamoose.Schema({
	"code": {
		"type": String,
		"required": true
	},
	"resolver": [{
		"type": "Constant",
		"settings": {
			"value": "orderFractionOff"
		}
	}, {
		"type": "Constant",
		"settings": {
			"value": "orderDollarOff"
		}
	}],
	"params": {
		"type": Object,
		"schema": {
			"amount": Number
		}
	}
}));

This will use a single schema, and only allow 2 values for resolver (orderFractionOff or orderDollarOff), while still keeping your params object clean and consistent, and not introducing extra complexity there.

[alexandervonwl]

Hi, @fishcharlie! Really nice that you are trying to respond to as many people as possible. I see you present in almost all threads 👍🏻

My issue is related to the topic above, passing multiple schemas (an array, as specified in the documentation) to a model.
I can notice the matching for the right schema is done by the attributes names and types. In my use case all my schemas have similar attributes names and types, "primaryKey", "sortKey" and so on, I was hoping to make dynamoose determine which schema to use based on attribute validation, ex. adding a validation for sortKey to begin with "FIRST" => FIRST SCHEMA or "SECOND" => SECOND SCHEMA, but it doesn't seem to work, it always takes the first schema in the array.

Do you have any recommendation for me here? Thanks

[fishcharlie]

@alexandervonwl Not beyond having that be an attribute stored in the item. Eventually I wanna add support for having transient properties (properties that are only used within Dynamoose and not actually stored), but that functionality doesn't currently exist.

[alexandervonwl]

Thank you for the reply, looking forward to this! Never contributed to open source but that sounds interesting 😁