.sqlx/query-0268f0c43abe34a3147f0a43f0e11bf302a3750ecadf28b1d6af62da62934f87.json

@@ -0,0 +1,27 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE\n                        cqrs_billing_line_item_query\n                    SET\n                        version = $1,\n                        product_name = $2,\n                        product_id = $3,\n                        line_item_id = $4,\n                        quantity_minor_unit = $5,\n                        quantity_minor_number = $6,\n                        quantity_major_unit = $7,\n                        quantity_major_number = $8,\n                        created_time = $9,\n                        bill_id = $10,\n                        price_per_unit_minor = $11 ,\n                        price_per_unit_major = $12,\n                        price_per_unit_currency = $13,\n                            deleted = $14;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Text",
+        "Uuid",
+        "Uuid",
+        "Text",
+        "Int4",
+        "Text",
+        "Int4",
+        "Timestamptz",
+        "Uuid",
+        "Int4",
+        "Int4",
+        "Text",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "0268f0c43abe34a3147f0a43f0e11bf302a3750ecadf28b1d6af62da62934f87"
+}

.sqlx/query-0ccd86643c13d9d7c793f362aedc2d720d9dda982a0416849bf97291fc645ea5.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_inventory_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        owner = $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_inventory_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        store_id = $4,\n                        owner = $5,\n                        deleted = $6;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,10 +9,11 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "8d62d7b612fd7f323aee586047dec9603f05782f55f72d21fc29954a65622b5d"
+  "hash": "0ccd86643c13d9d7c793f362aedc2d720d9dda982a0416849bf97291fc645ea5"
 }

.sqlx/query-14d111d7453b89f2346966a9fdd725d269ef36288ed5e7fe1f7ad452deaab0e6.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_inventory_category_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        store_id = $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_inventory_category_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        category_id = $4,\n                        store_id = $5,\n                        deleted = $6;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,10 +9,11 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "c9bee14e15dae80b7af9b0fdca43a97b964024252bed2d0caeebee175acd55d9"
+  "hash": "14d111d7453b89f2346966a9fdd725d269ef36288ed5e7fe1f7ad452deaab0e6"
 }

.sqlx/query-3811531518316435c32223582f9de6bdfefc19839129577407a1e4071f5c49f6.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_billing_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        owner = $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_billing_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        store_id = $4,\n                        owner = $5,\n                        deleted = $6;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,10 +9,11 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "d7decc8f70fc4f12d7a1db5009d2190bb9746000067d53990eb7cd646ff5d252"
+  "hash": "3811531518316435c32223582f9de6bdfefc19839129577407a1e4071f5c49f6"
 }

.sqlx/query-3d45cb28b61bac689d137c7415fcd620552e1390a443f4c8907b344a8526ff07.json

@@ -1,28 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "INSERT INTO cqrs_ordering_product_query (\n                        version,\n                        name,\n                        description,\n                        image,\n                        product_id,\n                        category_id,\n                        price_major,\n                        price_minor,\n                        price_currency,\n                        sku_able,\n                        quantity_minor_unit,\n                        quantity_minor_number,\n                        quantity_major_unit,\n                        quantity_major_number,\n\n                        deleted\n                    ) VALUES (\n                        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15\n                    );",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Int8",
-        "Text",
-        "Text",
-        "Text",
-        "Uuid",
-        "Uuid",
-        "Int4",
-        "Int4",
-        "Text",
-        "Bool",
-        "Text",
-        "Int4",
-        "Text",
-        "Int4",
-        "Bool"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "3d45cb28b61bac689d137c7415fcd620552e1390a443f4c8907b344a8526ff07"
-}

.sqlx/query-4b7100e5c7442066dbb4ea7c9733e038af635766f0be61a86ca7084b34a2109d.json

@@ -1,17 +1,18 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_kot_query\n                    SET\n                        version = $1,\n                        order_id = $2,\n                        created_time = $3,\n                        deleted = $4;",
+  "query": "UPDATE\n                        cqrs_ordering_kot_query\n                    SET\n                        version = $1,\n                        order_id = $2,\n                        kot_id = $3,\n                        created_time = $4,\n                        deleted = $5;",
   "describe": {
     "columns": [],
     "parameters": {
       "Left": [
         "Int8",
         "Uuid",
+        "Uuid",
         "Timestamptz",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "97c136fd927b9a153a6093da6594e5fc2837b3943b8bbcbade97920a99019c86"
+  "hash": "4b7100e5c7442066dbb4ea7c9733e038af635766f0be61a86ca7084b34a2109d"
 }

.sqlx/query-9645865fd899d0bb983bb9da43567e172b2c49855971ee58692bed595d347228.json

@@ -1,28 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "SELECT \n                product_id, version\n             FROM\n                cqrs_ordering_product_query\n            WHERE\n                product_id = $1;",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "product_id",
-        "type_info": "Uuid"
-      },
-      {
-        "ordinal": 1,
-        "name": "version",
-        "type_info": "Int8"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Uuid"
-      ]
-    },
-    "nullable": [
-      false,
-      false
-    ]
-  },
-  "hash": "9645865fd899d0bb983bb9da43567e172b2c49855971ee58692bed595d347228"
-}

.sqlx/query-995cca627c711a87b30723c6ceefd3fcdd1fc63bdcd95f8a974823089652aa51.json

@@ -1,26 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_billing_line_item_query\n                    SET\n                        version = $1,\n                        product_name = $2,\n                        product_id = $3,\n                        quantity_minor_unit = $4,\n                        quantity_minor_number = $5,\n                        quantity_major_unit = $6,\n                        quantity_major_number = $7,\n                        created_time = $8,\n                        bill_id = $9,\n                        price_per_unit_minor = $10 ,\n                        price_per_unit_major = $11,\n                        price_per_unit_currency = $12,\n                            deleted = $13;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Int8",
-        "Text",
-        "Uuid",
-        "Text",
-        "Int4",
-        "Text",
-        "Int4",
-        "Timestamptz",
-        "Uuid",
-        "Int4",
-        "Int4",
-        "Text",
-        "Bool"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "995cca627c711a87b30723c6ceefd3fcdd1fc63bdcd95f8a974823089652aa51"
-}

.sqlx/query-a342003149f2991ef0280d008f18e664c96299edfd9a11d08487e4db10a10e8b.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "INSERT INTO cqrs_ordering_order_query (\n                        version,\n                        customer_name,\n                        order_id,\n                        created_time,\n                        store_id,\n                        deleted\n\n                    ) VALUES (\n                        $1, $2, $3, $4, $5, $6\n                    );",
+  "query": "INSERT INTO cqrs_ordering_order_query (\n                        version,\n                        customer_name,\n                        order_id,\n                        created_time,\n                        deleted\n\n                    ) VALUES (\n                        $1, $2, $3, $4, $5\n                    );",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,11 +9,10 @@
         "Text",
         "Uuid",
         "Timestamptz",
-        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "7e2e91418e136fc5091b27c5f61158cca61e4853bee64e5afc44679e685cd744"
+  "hash": "a342003149f2991ef0280d008f18e664c96299edfd9a11d08487e4db10a10e8b"
 }

.sqlx/query-a3fa1c6271b85d23d70116363f19144190120c13752364bc3b78a92a08bd9157.json

@@ -1,27 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_product_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        image = $4,\n                        category_id = $5,\n                        price_major = $6,\n                        price_minor = $7,\n                        price_currency = $8,\n                        sku_able = $9,\n                        quantity_minor_unit = $10,\n                        quantity_minor_number = $11,\n                        quantity_major_unit = $12,\n                        quantity_major_number = $13,\n                        deleted = $14;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Int8",
-        "Text",
-        "Text",
-        "Text",
-        "Uuid",
-        "Int4",
-        "Int4",
-        "Text",
-        "Bool",
-        "Text",
-        "Int4",
-        "Text",
-        "Int4",
-        "Bool"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "a3fa1c6271b85d23d70116363f19144190120c13752364bc3b78a92a08bd9157"
-}

.sqlx/query-b335fc519289a42c707855b620a35433d3f8bd1e798772c05fc156494c036ef5.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_billing_bill_query\n                    SET\n                        version = $1,\n\n                        created_time = $2,\n                        store_id = $3,\n                        token_number = $4,\n                        total_price_major = $5,\n                        total_price_minor = $6,\n                        total_price_currency = $7,\n                        deleted = $8;",
+  "query": "UPDATE\n                        cqrs_billing_bill_query\n                    SET\n                        version = $1,\n\n                        created_time = $2,\n                        store_id = $3,\n                        bill_id = $4,\n                        token_number = $5,\n                        total_price_major = $6,\n                        total_price_minor = $7,\n                        total_price_currency = $8,\n\n                        deleted = $9;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -8,6 +8,7 @@
         "Int8",
         "Timestamptz",
         "Uuid",
+        "Uuid",
         "Int4",
         "Int4",
         "Int4",
@@ -17,5 +18,5 @@
     },
     "nullable": []
   },
-  "hash": "c30f49bb293ca6e184c5110bdfe1108b23bdf71dd904bdd5287155161138565d"
+  "hash": "b335fc519289a42c707855b620a35433d3f8bd1e798772c05fc156494c036ef5"
 }

.sqlx/query-bc7d17aab113d0519c53e5f612116a6e72bb0007a298cdba17f45f4b8bed5f56.json

@@ -1,18 +1,18 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_order_query\n                    SET\n                        version = $1,\n                        customer_name = $2,\n                        created_time = $3,\n                        store_id=  $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_ordering_order_query\n                    SET\n                        version = $1,\n                        customer_name = $2,\n                        order_id = $3,\n                        created_time = $4,\n                        deleted = $5;",
   "describe": {
     "columns": [],
     "parameters": {
       "Left": [
         "Int8",
         "Text",
-        "Timestamptz",
         "Uuid",
+        "Timestamptz",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "876ca2c177175439a1604a2d5aeec785e41473116ceda238a8089bcb33588e3d"
+  "hash": "bc7d17aab113d0519c53e5f612116a6e72bb0007a298cdba17f45f4b8bed5f56"
 }

.sqlx/query-c348d55dd91acb0d4697c433f61866b288fec93971bf9ab41faec21680e50f71.json

@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE\n                        cqrs_ordering_line_item_query\n                    SET\n                        version = $1,\n                        product_name = $2,\n                        product_id = $3,\n                        line_item_id = $4,\n                        quantity_minor_unit = $5,\n                        quantity_minor_number = $6,\n                        quantity_major_unit = $7,\n                        quantity_major_number = $8,\n                        created_time = $9,\n                        kot_id = $10,\n                        deleted = $11;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Text",
+        "Uuid",
+        "Uuid",
+        "Text",
+        "Int4",
+        "Text",
+        "Int4",
+        "Timestamptz",
+        "Uuid",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "c348d55dd91acb0d4697c433f61866b288fec93971bf9ab41faec21680e50f71"
+}

.sqlx/query-d0580ff6dc77150cb00186302f20460dc3be59be1f8f5588bdc3d0f4489eb613.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        owner = $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_ordering_store_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        address = $3,\n                        store_id = $4,\n                        owner = $5,\n                        deleted = $6;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,10 +9,11 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "8a7958c4f8419e1fd95b2d0c75a3bab76f5962f37e58c7dee4e5f9341dca8c0e"
+  "hash": "d0580ff6dc77150cb00186302f20460dc3be59be1f8f5588bdc3d0f4489eb613"
 }

.sqlx/query-d896f6ffb486efad5ed10a9c824656d863de0c9140054de66eef32491ace9ddb.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_category_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        store_id = $4,\n                        deleted = $5;",
+  "query": "UPDATE\n                        cqrs_ordering_category_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        category_id = $4,\n                        store_id = $5,\n                        deleted = $6;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -9,10 +9,11 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "289e6d9fe105ae9e91d947c22d0a5979786aac15b0c78359b3f634b74c4686d4"
+  "hash": "d896f6ffb486efad5ed10a9c824656d863de0c9140054de66eef32491ace9ddb"
 }

.sqlx/query-d9c625876e7d398cb48c6278e69b2eb6ad8515e68d5520013634415109309e6e.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_product_customizations_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        product_id = $3,\n                        deleted = $4;",
+  "query": "UPDATE\n                        cqrs_ordering_product_customizations_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        customization_id = $3,\n                        product_id = $4,\n                        deleted = $5;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -8,10 +8,11 @@
         "Int8",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "a5a58d14ddbfa78cca3729392faecfab30cc8b01fed9b73b9cc0813750230314"
+  "hash": "d9c625876e7d398cb48c6278e69b2eb6ad8515e68d5520013634415109309e6e"
 }

.sqlx/query-dbe1e41f04a81b2a504b9179911201ec52340d09d45041addd54eb349af82488.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "SELECT \n                customer_name,\n                order_id,\n                created_time,\n                store_id,\n                deleted\n             FROM\n                cqrs_ordering_order_query\n            WHERE\n                order_id = $1;",
+  "query": "SELECT \n                customer_name,\n                order_id,\n                created_time,\n                deleted\n             FROM\n                cqrs_ordering_order_query\n            WHERE\n                order_id = $1;",
   "describe": {
     "columns": [
       {
@@ -20,11 +20,6 @@
       },
       {
         "ordinal": 3,
-        "name": "store_id",
-        "type_info": "Uuid"
-      },
-      {
-        "ordinal": 4,
         "name": "deleted",
         "type_info": "Bool"
       }
@@ -35,12 +30,11 @@
       ]
     },
     "nullable": [
-      true,
       false,
       false,
       false,
       false
     ]
   },
-  "hash": "4f8a2294b40e4285fa6d4c7bcf648be7320f99002b9a9279981053a5062b0ed8"
+  "hash": "dbe1e41f04a81b2a504b9179911201ec52340d09d45041addd54eb349af82488"
 }

.sqlx/query-ddf0a8ae68a2f52e9ae3723d36983dfb42518b07940e620f4b45eb92b8a54a80.json

@@ -1,100 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "SELECT \n                name,\n                description,\n                image,\n                product_id,\n                category_id,\n                price_major,\n                price_minor,\n                price_currency,\n                sku_able,\n                quantity_minor_unit,\n                quantity_minor_number,\n                quantity_major_unit,\n                quantity_major_number,\n                deleted\n             FROM\n                cqrs_ordering_product_query\n            WHERE\n                product_id = $1;",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "name",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 1,
-        "name": "description",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 2,
-        "name": "image",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 3,
-        "name": "product_id",
-        "type_info": "Uuid"
-      },
-      {
-        "ordinal": 4,
-        "name": "category_id",
-        "type_info": "Uuid"
-      },
-      {
-        "ordinal": 5,
-        "name": "price_major",
-        "type_info": "Int4"
-      },
-      {
-        "ordinal": 6,
-        "name": "price_minor",
-        "type_info": "Int4"
-      },
-      {
-        "ordinal": 7,
-        "name": "price_currency",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 8,
-        "name": "sku_able",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 9,
-        "name": "quantity_minor_unit",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 10,
-        "name": "quantity_minor_number",
-        "type_info": "Int4"
-      },
-      {
-        "ordinal": 11,
-        "name": "quantity_major_unit",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 12,
-        "name": "quantity_major_number",
-        "type_info": "Int4"
-      },
-      {
-        "ordinal": 13,
-        "name": "deleted",
-        "type_info": "Bool"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Uuid"
-      ]
-    },
-    "nullable": [
-      false,
-      true,
-      true,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false
-    ]
-  },
-  "hash": "ddf0a8ae68a2f52e9ae3723d36983dfb42518b07940e620f4b45eb92b8a54a80"
-}

.sqlx/query-e2f9f291a20aac77851774ba8cd37325143a4d98e0980632f097c5885cc71094.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_inventory_product_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        image = $4,\n                        category_id = $5,\n                        price_major = $6,\n                        price_minor = $7,\n                        price_currency = $8,\n                        sku_able = $9,\n                        quantity_minor_unit = $10,\n                        quantity_minor_number = $11,\n                        quantity_major_unit = $12,\n                        quantity_major_number = $13,\n                        deleted = $14;",
+  "query": "UPDATE\n                        cqrs_inventory_product_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        description = $3,\n                        image = $4,\n                        product_id = $5,\n                        category_id = $6,\n                        price_major = $7,\n                        price_minor = $8,\n                        price_currency = $9,\n                        sku_able = $10,\n                        quantity_minor_unit = $11,\n                        quantity_minor_number = $12,\n                        quantity_major_unit = $13,\n                        quantity_major_number = $14,\n                        deleted = $15;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -10,6 +10,7 @@
         "Text",
         "Text",
         "Uuid",
+        "Uuid",
         "Int4",
         "Int4",
         "Text",
@@ -23,5 +24,5 @@
     },
     "nullable": []
   },
-  "hash": "c358d3b79d35668b3475f29f5bf6767f7209a2443fd944420baf1e1cf5c51ccb"
+  "hash": "e2f9f291a20aac77851774ba8cd37325143a4d98e0980632f097c5885cc71094"
 }

.sqlx/query-e61db066fe7e66879f8ce8ccd3da94d89c30f8f5d633004ba16a6e971e041a14.json

@@ -1,23 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_ordering_line_item_query\n                    SET\n                        version = $1,\n                        product_name = $2,\n                        product_id = $3,\n                        quantity_minor_unit = $4,\n                        quantity_minor_number = $5,\n                        quantity_major_unit = $6,\n                        quantity_major_number = $7,\n                        created_time = $8,\n                        kot_id = $9,\n                        deleted = $10;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Int8",
-        "Text",
-        "Uuid",
-        "Text",
-        "Int4",
-        "Text",
-        "Int4",
-        "Timestamptz",
-        "Uuid",
-        "Bool"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "e61db066fe7e66879f8ce8ccd3da94d89c30f8f5d633004ba16a6e971e041a14"
-}

.sqlx/query-e88a5dae732c3f8180664f306b4bb1d21f97a2f1391860eb8714a52ef4439d81.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        cqrs_inventory_product_customizations_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        product_id = $3,\n                        deleted = $4;",
+  "query": "UPDATE\n                        cqrs_inventory_product_customizations_query\n                    SET\n                        version = $1,\n                        name = $2,\n                        customization_id = $3,\n                        product_id = $4,\n                        deleted = $5;",
   "describe": {
     "columns": [],
     "parameters": {
@@ -8,10 +8,11 @@
         "Int8",
         "Text",
         "Uuid",
+        "Uuid",
         "Bool"
       ]
     },
     "nullable": []
   },
-  "hash": "d46bb69f4e2afbae01ab08beb48a67b2cade64d9ebd47f3fc6143b057671cc1b"
+  "hash": "e88a5dae732c3f8180664f306b4bb1d21f97a2f1391860eb8714a52ef4439d81"
 }

migrations/20240723132531_cqrs_ordering_order_query.sql

@@ -8,9 +8,8 @@ CREATE TABLE IF NOT EXISTS cqrs_ordering_order_query
 
     created_time timestamp with time zone DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
 	order_id UUID NOT NULL UNIQUE,
-	store_id UUID NOT NULL,
 
-    customer_name TEXT,
+    customer_name TEXT NOT NULL,
 
 	deleted BOOLEAN NOT NULL DEFAULT FALSE,
 

src/billing/adapters/output/db/postgres/bill_id_exists.rs

@@ -36,7 +36,7 @@ pub mod tests {
     //    use crate::billing::domain::add_product_command::tests::get_customizations;
     use crate::billing::domain::bill_aggregate::*;
 
-    pub async fn create_dummy_bill(bill: &Bill, db: &BillingDBPostgresAdapter) {
+    async fn create_dummy_bill(bill: &Bill, db: &BillingDBPostgresAdapter) {
         sqlx::query!(
             "INSERT INTO cqrs_billing_bill_query (
                     version,

src/billing/adapters/output/db/postgres/bill_view.rs

@@ -2,8 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use std::str::FromStr;
-
 use async_trait::async_trait;
 use cqrs_es::persist::{PersistenceError, ViewContext, ViewRepository};
 use cqrs_es::{EventEnvelope, Query, View};
@@ -13,9 +11,8 @@ use uuid::Uuid;
 
 use super::errors::*;
 use super::BillingDBPostgresAdapter;
-use crate::billing::domain::bill_aggregate::{Bill, BillBuilder};
+use crate::billing::domain::bill_aggregate::Bill;
 use crate::billing::domain::events::BillingEvent;
-use crate::types::currency::{self, Currency, PriceBuilder};
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_BILL_NON_UUID: &str = "billing_new_bill_non_uuid-asdfa";
@@ -37,36 +34,6 @@ pub struct BillView {
     deleted: bool,
 }
 
-impl From<BillView> for Bill {
-    fn from(v: BillView) -> Self {
-        let price = match (
-            v.total_price_minor,
-            v.total_price_major,
-            v.total_price_currency,
-        ) {
-            (Some(minor), Some(major), Some(currency)) => Some(
-                PriceBuilder::default()
-                    .major(major as usize)
-                    .minor(minor as usize)
-                    .currency(Currency::from_str(&currency).unwrap())
-                    .build()
-                    .unwrap(),
-            ),
-            _ => None,
-        };
-
-        BillBuilder::default()
-            .created_time(v.created_time)
-            .store_id(v.store_id)
-            .bill_id(v.bill_id)
-            .token_number(v.token_number as usize)
-            .total_price(price)
-            .deleted(v.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 impl Default for BillView {
     fn default() -> Self {
         Self {
@@ -85,45 +52,28 @@ impl Default for BillView {
     }
 }
 
-impl BillView {
-    fn merge(&mut self, bill: &Bill) {
-        self.created_time = bill.created_time().clone();
-        self.store_id = *bill.store_id();
-        self.bill_id = *bill.bill_id();
-
-        self.token_number = *bill.token_number() as i32;
-
-        self.total_price_minor = bill.total_price().as_ref().map(|t| *t.minor() as i32);
-        self.total_price_major = bill.total_price().as_ref().map(|t| *t.major() as i32);
-        self.total_price_currency = bill
-            .total_price()
-            .as_ref()
-            .map(|t| t.currency().to_string());
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
 impl View<Bill> for BillView {
     fn update(&mut self, event: &EventEnvelope<Bill>) {
-        match &event.payload {
+        if let BillingEvent::BillAdded(val) = &event.payload {
-            BillingEvent::BillAdded(val) => {
+            self.created_time = val.bill().created_time().clone();
-                self.merge(val.bill());
+            self.store_id = *val.bill().store_id();
+            self.bill_id = *val.bill().bill_id();
+
+            self.token_number = *val.bill().token_number() as i32;
+
+            self.total_price_minor = val.bill().total_price().as_ref().map(|t| *t.minor() as i32);
+            self.total_price_major = val.bill().total_price().as_ref().map(|t| *t.major() as i32);
+            self.total_price_currency = val
+                .bill()
+                .total_price()
+                .as_ref()
+                .map(|t| t.currency().to_string());
 
             self.deleted = false;
         }
-            BillingEvent::BillUpdated(e) => self.merge(e.new_bill()),
-            BillingEvent::BillTotalPriceComputed(e) => {
-                let total_price = e.total_price().clone();
-                self.total_price_minor = Some(*total_price.minor() as i32);
-                self.total_price_major = Some(*total_price.major() as i32);
-                self.total_price_currency = Some(total_price.currency().to_string());
-            }
-            BillingEvent::BillDeleted(e) => self.deleted = true,
-
-            _ => (),
-        }
     }
 }
 
@@ -258,14 +208,17 @@ impl ViewRepository<BillView, Bill> for BillingDBPostgresAdapter {
 
                         created_time = $2,
                         store_id = $3,
-                        token_number = $4,
+                        bill_id = $4,
-                        total_price_major = $5,
+                        token_number = $5,
-                        total_price_minor = $6,
+                        total_price_major = $6,
-                        total_price_currency = $7,
+                        total_price_minor = $7,
-                        deleted = $8;",
+                        total_price_currency = $8,
+
+                        deleted = $9;",
                     version,
                     view.created_time,
                     view.store_id,
+                    view.bill_id,
                     view.token_number,
                     view.total_price_major,
                     view.total_price_minor,
@@ -311,136 +264,108 @@ impl Query<Bill> for BillingDBPostgresAdapter {
     }
 }
 
-#[cfg(test)]
+// Our second query, this one will be handled with Postgres `GenericQuery`
-mod tests {
+// which will serialize and persist our view after it is updated. It also
-    use super::*;
+// provides a `load` method to deserialize the view on request.
+//pub type BillQuery = GenericQuery<BillingDBPostgresAdapter, BillView, Bill>;
+//pub type BillQuery = Query<dyn BillingDBPostgresAdapter, BillView, Bill>;
 
-    use postgres_es::PostgresCqrs;
+//#[cfg(test)]
-
+//mod tests {
-    use crate::{
+//    use super::*;
-        billing::{
+//
-            application::services::{
+//    use postgres_es::PostgresCqrs;
-                add_bill_service::AddBillServiceBuilder, update_bill_service::*,
+//
-                MockBillingServicesInterface,
+//    use crate::{
-            },
+//        db::migrate::*,
-            domain::{
+//        billing::{
-                add_bill_command::*, commands::BillingCommand, store_aggregate::Store,
+//            application::services::{
-                update_bill_command::*,
+//                add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_bill_service::AddBillServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_bill_service::tests::mock_update_bill_service, BillingServicesBuilder
-            },
+//            },
-        },
+//            domain::{
-        db::migrate::*,
+//                add_category_command::AddCategoryCommand, add_customization_command,
-        tests::bdd::*,
+//                add_product_command::tests::get_command, add_bill_command::AddBillCommand,
-        utils::uuid::tests::*,
+//                commands::BillingCommand,
-    };
+//                update_category_command::tests::get_update_category_command,
-    use std::sync::Arc;
+//                update_customization_command::tests::get_update_customization_command,
-
+//                update_product_command, update_bill_command::tests::get_update_bill_cmd,
-    #[actix_rt::test]
+//            },
-    async fn pg_query_billing_bill_view() {
+//        },
-        let settings = crate::settings::tests::get_settings().await;
+//        tests::bdd::IS_NEVER_CALLED,
-        //let settings = crate::settings::Settings::new().unwrap();
+//        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-        settings.create_db().await;
+//    };
-
+//    use std::sync::Arc;
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
+//
-        db.migrate().await;
+//    #[actix_rt::test]
-        let db = BillingDBPostgresAdapter::new(db.pool.clone());
+//    async fn pg_query() {
-
+//        let settings = crate::settings::tests::get_settings().await;
-        let simple_query = SimpleLoggingQuery {};
+//        //let settings = crate::settings::Settings::new().unwrap();
-
+//        settings.create_db().await;
-        let queries: Vec<Box<dyn Query<Bill>>> = vec![Box::new(simple_query), Box::new(db.clone())];
+//
-
+//        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        let mut mock_services = MockBillingServicesInterface::new();
+//        db.migrate().await;
-
+//        let db = BillingDBPostgresAdapter::new(db.pool.clone());
-        let store = Store::default();
+//
-        crate::billing::adapters::output::db::postgres::store_id_exists::tests::create_dummy_store_record(&store, &db).await;
+//        let simple_query = SimpleLoggingQuery {};
-
+//
-        let db2 = db.clone();
+//        let queries: Vec<Box<dyn Query<Bill>>> =
-        mock_services
+//            vec![Box::new(simple_query), Box::new(db.clone())];
-            .expect_add_bill()
+//
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//        let services = BillingServicesBuilder::default()
-            .returning(move || {
+//            .add_bill(Arc::new(
-                Arc::new(
+//                AddBillServiceBuilder::default()
-                    AddBillServiceBuilder::default()
+//                    .db_bill_id_exists(Arc::new(db.clone()))
-                        .db_bill_id_exists(Arc::new(db2.clone()))
+//                    .db_bill_name_exists(Arc::new(db.clone()))
-                        .db_next_token_id(Arc::new(db2.clone()))
+//                    .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
-                        .build()
+//                    .build()
-                        .unwrap(),
+//                    .unwrap(),
-                )
+//            ))
-            });
+//            .add_category(mock_add_category_service(
-
+//                IS_NEVER_CALLED,
-        let db2 = db.clone();
+//                AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
-        mock_services
+//            ))
-            .expect_update_bill()
+//            .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//            .add_customization(mock_add_customization_service(
-            .returning(move || {
+//                IS_NEVER_CALLED,
-                Arc::new(
+//                add_customization_command::tests::get_command(),
-                    UpdateBillServiceBuilder::default()
+//            ))
-                        .db_bill_id_exists(Arc::new(db2.clone()))
+//            .update_product(mock_update_product_service(
-                        .build()
+//                IS_NEVER_CALLED,
-                        .unwrap(),
+//                update_product_command::tests::get_command(),
-                )
+//            ))
-            });
+//            .update_customization(mock_update_customization_service(
-
+//                IS_NEVER_CALLED,
-        let (cqrs, bill_query): (
+//                get_update_customization_command(),
-            Arc<PostgresCqrs<Bill>>,
+//            ))
-            Arc<dyn ViewRepository<BillView, Bill>>,
+//            .update_category(mock_update_category_service(
-        ) = (
+//                IS_NEVER_CALLED,
-            Arc::new(postgres_es::postgres_cqrs(
+//                get_update_category_command(),
-                db.pool.clone(),
+//            ))
-                queries,
+//            .update_bill(mock_update_bill_service(
-                Arc::new(mock_services),
+//                IS_NEVER_CALLED,
-            )),
+//                get_update_bill_cmd(),
-            Arc::new(db.clone()),
+//            ))
-        );
+//            .build()
-
+//            .unwrap();
-        let cmd = AddBillCommandBuilder::default()
+//
-            .adding_by(UUID)
+//        let (cqrs, _bill_query): (
-            .bill_id(UUID)
+//            Arc<PostgresCqrs<Bill>>,
-            .store_id(*store.store_id())
+//            Arc<dyn ViewRepository<BillView, Bill>>,
-            .build()
+//        ) = (
-            .unwrap();
+//            Arc::new(postgres_es::postgres_cqrs(
-
+//                db.pool.clone(),
-        cqrs.execute(
+//                queries,
-            &cmd.bill_id().to_string(),
+//                Arc::new(services),
-            BillingCommand::AddBill(cmd.clone()),
+//            )),
-        )
+//            Arc::new(db.clone()),
-        .await
+//        );
-        .unwrap();
+//
-
+//        let rand = crate::utils::random_string::GenerateRandomString {};
-        let bill = bill_query
+//        let cmd = AddBillCommand::new(rand.get_random(10), None, UUID).unwrap();
-            .load(&(*cmd.bill_id()).to_string())
+//        cqrs.execute("", BillingCommand::AddBill(cmd.clone()))
-            .await
+//            .await
-            .unwrap()
+//            .unwrap();
-            .unwrap();
+//
-        let bill: Bill = bill.into();
+//        settings.drop_db().await;
-        assert_eq!(bill.store_id(), cmd.store_id());
+//    }
-        assert_eq!(bill.bill_id(), cmd.bill_id());
+//}
-        assert!(!bill.deleted());
-
-        let update_bill_cmd = UpdateBillCommandBuilder::default()
-            .adding_by(UUID)
-            .store_id(*store.store_id())
-            .total_price(None)
-            .old_bill(bill.clone())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.bill_id().to_string(),
-            BillingCommand::UpdateBill(update_bill_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let bill = bill_query
-            .load(&(*cmd.bill_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let bill: Bill = bill.into();
-        assert_eq!(bill.store_id(), cmd.store_id());
-        assert_eq!(bill.bill_id(), update_bill_cmd.old_bill().bill_id());
-        assert_eq!(bill.total_price(), update_bill_cmd.total_price());
-        assert!(!bill.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/billing/adapters/output/db/postgres/line_item_view.rs

@@ -134,25 +134,6 @@ impl View<LineItem> for LineItemView {
 
                 self.deleted = false;
             }
-            BillingEvent::LineItemUpdated(val) => {
-                let new = val.new_line_item();
-                self.product_name = new.product_name().into();
-                self.product_id = *new.product_id();
-                self.line_item_id = *new.line_item_id();
-
-                self.quantity_major_number = *new.quantity().major().number() as i32;
-                self.quantity_minor_number = *new.quantity().minor().number() as i32;
-                self.quantity_major_unit = new.quantity().major().unit().to_string();
-                self.quantity_minor_unit = new.quantity().minor().unit().to_string();
-
-                self.price_per_unit_major = *new.price_per_unit().major() as i32;
-                self.price_per_unit_minor = *new.price_per_unit().minor() as i32;
-                self.price_per_unit_currency = new.price_per_unit().currency().to_string();
-
-                self.created_time = new.created_time().clone();
-                self.bill_id = *new.bill_id();
-            }
-            BillingEvent::LineItemDeleted(_) => self.deleted = true,
             _ => (),
         }
     }
@@ -309,19 +290,21 @@ impl ViewRepository<LineItemView, LineItem> for BillingDBPostgresAdapter {
                         version = $1,
                         product_name = $2,
                         product_id = $3,
-                        quantity_minor_unit = $4,
+                        line_item_id = $4,
-                        quantity_minor_number = $5,
+                        quantity_minor_unit = $5,
-                        quantity_major_unit = $6,
+                        quantity_minor_number = $6,
-                        quantity_major_number = $7,
+                        quantity_major_unit = $7,
-                        created_time = $8,
+                        quantity_major_number = $8,
-                        bill_id = $9,
+                        created_time = $9,
-                        price_per_unit_minor = $10 ,
+                        bill_id = $10,
-                        price_per_unit_major = $11,
+                        price_per_unit_minor = $11 ,
-                        price_per_unit_currency = $12,
+                        price_per_unit_major = $12,
-                            deleted = $13;",
+                        price_per_unit_currency = $13,
+                            deleted = $14;",
                     version,
                     view.product_name,
                     view.product_id,
+                    view.line_item_id,
                     view.quantity_minor_unit,
                     view.quantity_minor_number,
                     view.quantity_major_unit,
@@ -362,215 +345,3 @@ impl Query<LineItem> for BillingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        billing::{
-            application::services::{
-                add_line_item_service::AddLineItemServiceBuilder, delete_line_item_service::*,
-                update_line_item_service::*, MockBillingServicesInterface,
-            },
-            domain::{
-                add_line_item_command::*, bill_aggregate::Bill, commands::BillingCommand,
-                delete_line_item_command::DeleteLineItemCommandBuilder,
-                update_line_item_command::*,
-            },
-        },
-        db::migrate::*,
-        tests::bdd::*,
-        types::quantity::*,
-        utils::{
-            random_string::GenerateRandomStringInterface,
-            uuid::{tests::UUID, *},
-        },
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_billing_line_item_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = BillingDBPostgresAdapter::new(db.pool.clone());
-
-        let queries: Vec<Box<dyn Query<LineItem>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockBillingServicesInterface::new();
-
-        let bill = Bill::default();
-        crate::billing::adapters::output::db::postgres::bill_id_exists::tests::create_dummy_bill(
-            &bill, &db,
-        )
-        .await;
-
-        let db2 = db.clone();
-        mock_services
-            .expect_add_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .db_bill_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_update_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .db_bill_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_delete_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    DeleteLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, line_item_query): (
-            Arc<PostgresCqrs<LineItem>>,
-            Arc<dyn ViewRepository<LineItemView, LineItem>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-        let uuid = GenerateUUID {};
-        let line_item_id = uuid.get_uuid();
-
-        let cmd = AddLineItemCommandBuilder::default()
-            .product_name(rand.get_random(10))
-            .adding_by(UUID)
-            .price_per_unit(Price::default())
-            .quantity(Quantity::get_quantity())
-            .product_id(UUID)
-            .bill_id(*bill.bill_id())
-            .line_item_id(line_item_id)
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            BillingCommand::AddLineItem(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let line_item: LineItem = line_item.into();
-        assert_eq!(line_item.line_item_id(), cmd.line_item_id());
-        assert_eq!(line_item.product_name(), cmd.product_name());
-        assert_eq!(line_item.product_id(), cmd.product_id());
-        assert_eq!(line_item.quantity(), cmd.quantity());
-        assert!(!line_item.deleted());
-
-        let update_line_item_cmd = UnvalidatedUpdateLineItemCommandBuilder::default()
-            .product_name(rand.get_random(10))
-            .adding_by(UUID)
-            .quantity(Quantity::get_quantity())
-            .product_id(UUID)
-            .bill_id(*bill.bill_id())
-            .old_line_item(line_item.clone())
-            .price_per_unit(Price::default())
-            .build()
-            .unwrap()
-            .validate()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            BillingCommand::UpdateLineItem(update_line_item_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let line_item: LineItem = line_item.into();
-        assert_eq!(
-            line_item.line_item_id(),
-            update_line_item_cmd.old_line_item().line_item_id()
-        );
-        assert_eq!(
-            line_item.product_name(),
-            update_line_item_cmd.product_name()
-        );
-        assert_eq!(line_item.product_id(), update_line_item_cmd.product_id());
-        assert_eq!(line_item.quantity(), update_line_item_cmd.quantity());
-        assert!(!line_item.deleted());
-
-        // delete
-        let delete_line_item_cmd = DeleteLineItemCommandBuilder::default()
-            .line_item(line_item.clone())
-            .adding_by(UUID)
-            .build()
-            .unwrap();
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            BillingCommand::DeleteLineItem(delete_line_item_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let deleted_line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let deleted_line_item: LineItem = deleted_line_item.into();
-        assert_eq!(
-            deleted_line_item.line_item_id(),
-            delete_line_item_cmd.line_item().line_item_id()
-        );
-        assert_eq!(
-            deleted_line_item.product_name(),
-            delete_line_item_cmd.line_item().product_name()
-        );
-        assert_eq!(
-            deleted_line_item.product_id(),
-            delete_line_item_cmd.line_item().product_id()
-        );
-        assert_eq!(
-            deleted_line_item.quantity(),
-            delete_line_item_cmd.line_item().quantity()
-        );
-        assert!(deleted_line_item.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/billing/adapters/output/db/postgres/store_id_exists.rs

@@ -45,7 +45,7 @@ pub mod tests {
             VALUES ($1, $2, $3, $4, $5 ,$6);",
             1,
             s.name(),
-            s.address().as_ref().map(|s| s.as_str()),
+            s.address().as_ref().unwrap(),
             s.store_id(),
             s.owner(),
             false

src/billing/adapters/output/db/postgres/store_view.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 use super::errors::*;
 use super::BillingDBPostgresAdapter;
 use crate::billing::domain::events::BillingEvent;
-use crate::billing::domain::store_aggregate::*;
+use crate::billing::domain::store_aggregate::Store;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_STORE_NON_UUID: &str = "billing_new_store_non_uuid-asdfa";
@@ -27,41 +27,18 @@ pub struct StoreView {
     deleted: bool,
 }
 
-impl From<StoreView> for Store {
-    fn from(value: StoreView) -> Self {
-        StoreBuilder::default()
-            .name(value.name)
-            .address(value.address)
-            .store_id(value.store_id)
-            .owner(value.owner)
-            .deleted(value.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
 impl View<Store> for StoreView {
     fn update(&mut self, event: &EventEnvelope<Store>) {
-        match &event.payload {
+        if let BillingEvent::StoreAdded(val) = &event.payload {
-            BillingEvent::StoreAdded(val) => {
             self.name = val.name().into();
             self.address = val.address().clone();
             self.store_id = *val.store_id();
             self.owner = *val.owner();
             self.deleted = false;
         }
-            BillingEvent::StoreUpdated(e) => {
-                let val = e.new_store();
-                self.name = val.name().into();
-                self.address = val.address().clone();
-                self.store_id = *val.store_id();
-                self.owner = *val.owner();
-            }
-            _ => (),
-        }
     }
 }
 
@@ -169,11 +146,13 @@ impl ViewRepository<StoreView, Store> for BillingDBPostgresAdapter {
                         version = $1,
                         name = $2,
                         address = $3,
-                        owner = $4,
+                        store_id = $4,
-                        deleted = $5;",
+                        owner = $5,
+                        deleted = $6;",
                     version,
                     view.name,
                     view.address,
+                    view.store_id,
                     view.owner,
                     view.deleted,
                 )
@@ -216,138 +195,108 @@ impl Query<Store> for BillingDBPostgresAdapter {
     }
 }
 
-#[cfg(test)]
+// Our second query, this one will be handled with Postgres `GenericQuery`
-mod tests {
+// which will serialize and persist our view after it is updated. It also
-    use super::*;
+// provides a `load` method to deserialize the view on request.
+//pub type StoreQuery = GenericQuery<BillingDBPostgresAdapter, StoreView, Store>;
+//pub type StoreQuery = Query<dyn BillingDBPostgresAdapter, StoreView, Store>;
 
-    use postgres_es::PostgresCqrs;
+//#[cfg(test)]
-
+//mod tests {
-    use crate::{
+//    use super::*;
-        billing::{
+//
-            application::services::{
+//    use postgres_es::PostgresCqrs;
-                add_store_service::AddStoreServiceBuilder, update_store_service::*,
+//
-                MockBillingServicesInterface,
+//    use crate::{
-            },
+//        db::migrate::*,
-            domain::add_store_command::*,
+//        billing::{
-            domain::commands::BillingCommand,
+//            application::services::{
-            domain::update_store_command::*,
+//                add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_store_service::AddStoreServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_store_service::tests::mock_update_store_service, BillingServicesBuilder
-        },
+//            },
-        db::migrate::*,
+//            domain::{
-        tests::bdd::*,
+//                add_category_command::AddCategoryCommand, add_customization_command,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
+//                add_product_command::tests::get_command, add_store_command::AddStoreCommand,
-    };
+//                commands::BillingCommand,
-    use std::sync::Arc;
+//                update_category_command::tests::get_update_category_command,
-
+//                update_customization_command::tests::get_update_customization_command,
-    #[actix_rt::test]
+//                update_product_command, update_store_command::tests::get_update_store_cmd,
-    async fn pg_query_billing_store_view() {
+//            },
-        let settings = crate::settings::tests::get_settings().await;
+//        },
-        //let settings = crate::settings::Settings::new().unwrap();
+//        tests::bdd::IS_NEVER_CALLED,
-        settings.create_db().await;
+//        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-
+//    };
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
+//    use std::sync::Arc;
-        db.migrate().await;
+//
-        let db = BillingDBPostgresAdapter::new(db.pool.clone());
+//    #[actix_rt::test]
-
+//    async fn pg_query() {
-        let simple_query = SimpleLoggingQuery {};
+//        let settings = crate::settings::tests::get_settings().await;
-
+//        //let settings = crate::settings::Settings::new().unwrap();
-        let queries: Vec<Box<dyn Query<Store>>> =
+//        settings.create_db().await;
-            vec![Box::new(simple_query), Box::new(db.clone())];
+//
-
+//        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        let mut mock_services = MockBillingServicesInterface::new();
+//        db.migrate().await;
-
+//        let db = BillingDBPostgresAdapter::new(db.pool.clone());
-        let db2 = db.clone();
+//
-        mock_services
+//        let simple_query = SimpleLoggingQuery {};
-            .expect_add_store()
+//
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//        let queries: Vec<Box<dyn Query<Store>>> =
-            .returning(move || {
+//            vec![Box::new(simple_query), Box::new(db.clone())];
-                Arc::new(
+//
-                    AddStoreServiceBuilder::default()
+//        let services = BillingServicesBuilder::default()
-                        .db_store_id_exists(Arc::new(db2.clone()))
+//            .add_store(Arc::new(
-                        .db_store_name_exists(Arc::new(db2.clone()))
+//                AddStoreServiceBuilder::default()
-                        .build()
+//                    .db_store_id_exists(Arc::new(db.clone()))
-                        .unwrap(),
+//                    .db_store_name_exists(Arc::new(db.clone()))
-                )
+//                    .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
-            });
+//                    .build()
-
+//                    .unwrap(),
-        let db2 = db.clone();
+//            ))
-        mock_services
+//            .add_category(mock_add_category_service(
-            .expect_update_store()
+//                IS_NEVER_CALLED,
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//                AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
-            .returning(move || {
+//            ))
-                Arc::new(
+//            .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
-                    UpdateStoreServiceBuilder::default()
+//            .add_customization(mock_add_customization_service(
-                        .db_store_id_exists(Arc::new(db2.clone()))
+//                IS_NEVER_CALLED,
-                        .db_store_name_exists(Arc::new(db2.clone()))
+//                add_customization_command::tests::get_command(),
-                        .build()
+//            ))
-                        .unwrap(),
+//            .update_product(mock_update_product_service(
-                )
+//                IS_NEVER_CALLED,
-            });
+//                update_product_command::tests::get_command(),
-
+//            ))
-        let (cqrs, store_query): (
+//            .update_customization(mock_update_customization_service(
-            Arc<PostgresCqrs<Store>>,
+//                IS_NEVER_CALLED,
-            Arc<dyn ViewRepository<StoreView, Store>>,
+//                get_update_customization_command(),
-        ) = (
+//            ))
-            Arc::new(postgres_es::postgres_cqrs(
+//            .update_category(mock_update_category_service(
-                db.pool.clone(),
+//                IS_NEVER_CALLED,
-                queries,
+//                get_update_category_command(),
-                Arc::new(mock_services),
+//            ))
-            )),
+//            .update_store(mock_update_store_service(
-            Arc::new(db.clone()),
+//                IS_NEVER_CALLED,
-        );
+//                get_update_store_cmd(),
-
+//            ))
-        let rand = crate::utils::random_string::GenerateRandomString {};
+//            .build()
-        let cmd = AddStoreCommandBuilder::default()
+//            .unwrap();
-            .name(rand.get_random(10))
+//
-            .address(None)
+//        let (cqrs, _store_query): (
-            .owner(UUID)
+//            Arc<PostgresCqrs<Store>>,
-            .store_id(UUID)
+//            Arc<dyn ViewRepository<StoreView, Store>>,
-            .build()
+//        ) = (
-            .unwrap();
+//            Arc::new(postgres_es::postgres_cqrs(
-        cqrs.execute(
+//                db.pool.clone(),
-            &cmd.store_id().to_string(),
+//                queries,
-            BillingCommand::AddStore(cmd.clone()),
+//                Arc::new(services),
-        )
+//            )),
-        .await
+//            Arc::new(db.clone()),
-        .unwrap();
+//        );
-
+//
-        let store = store_query
+//        let rand = crate::utils::random_string::GenerateRandomString {};
-            .load(&(*cmd.store_id()).to_string())
+//        let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap();
-            .await
+//        cqrs.execute("", BillingCommand::AddStore(cmd.clone()))
-            .unwrap()
+//            .await
-            .unwrap();
+//            .unwrap();
-        let store: Store = store.into();
+//
-        assert_eq!(store.name(), cmd.name());
+//        settings.drop_db().await;
-        assert_eq!(store.address(), cmd.address());
+//    }
-        assert_eq!(store.owner(), cmd.owner());
+//}
-        assert_eq!(store.store_id(), cmd.store_id());
-        assert!(!store.deleted());
-
-        let update_store_cmd = UpdateStoreCommand::new(
-            rand.get_random(10),
-            Some(rand.get_random(10)),
-            UUID,
-            store,
-            UUID,
-        )
-        .unwrap();
-        cqrs.execute(
-            &cmd.store_id().to_string(),
-            BillingCommand::UpdateStore(update_store_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let store = store_query
-            .load(&(*cmd.store_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let store: Store = store.into();
-        assert_eq!(store.name(), update_store_cmd.name());
-        assert_eq!(store.address(), update_store_cmd.address());
-        assert_eq!(store.owner(), update_store_cmd.owner());
-        assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
-        assert!(!store.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/billing/application/services/add_bill_service.rs

@@ -17,6 +17,7 @@ use crate::billing::{
         bill_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -30,19 +31,27 @@ pub type AddBillServiceObj = Arc<dyn AddBillUseCase>;
 pub struct AddBillService {
     db_bill_id_exists: BillIDExistsDBPortObj,
     db_next_token_id: NextTokenIDDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
 impl AddBillUseCase for AddBillService {
     async fn add_bill(&self, cmd: AddBillCommand) -> BillingResult<BillAddedEvent> {
-        if self.db_bill_id_exists.bill_id_exists(cmd.bill_id()).await? {
+        let mut bill_id = self.get_uuid.get_uuid();
-            return Err(BillingError::DuplicateBillID);
+
+        loop {
+            if self.db_bill_id_exists.bill_id_exists(&bill_id).await? {
+                bill_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let token_number = self.db_next_token_id.next_token_id(cmd.store_id()).await?;
 
         let bill = BillBuilder::default()
-            .bill_id(*cmd.bill_id())
+            .bill_id(bill_id)
             .token_number(token_number)
             .created_time(cmd.created_time().clone())
             .store_id(*cmd.store_id())
@@ -71,7 +80,7 @@ pub mod tests {
         let mut m = MockAddBillUseCase::new();
 
         let bill = BillBuilder::default()
-            .bill_id(*cmd.bill_id())
+            .bill_id(UUID)
             .token_number(1)
             .total_price(None)
             .created_time(cmd.created_time().clone())
@@ -104,6 +113,7 @@ pub mod tests {
         let s = AddBillServiceBuilder::default()
             .db_bill_id_exists(mock_bill_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_next_token_id(mock_next_token_id_db_port(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 

src/billing/application/services/add_line_item_service.rs

@@ -15,6 +15,7 @@ use crate::billing::{
     application::port::output::db::line_item_id_exists::*,
     domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -28,6 +29,7 @@ pub type AddLineItemServiceObj = Arc<dyn AddLineItemUseCase>;
 pub struct AddLineItemService {
     db_line_item_id_exists: LineItemIDExistsDBPortObj,
     db_bill_id_exists: BillIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -37,12 +39,19 @@ impl AddLineItemUseCase for AddLineItemService {
             return Err(BillingError::BillIDNotFound);
         }
 
+        let mut line_item_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_line_item_id_exists
-            .line_item_id_exists(cmd.line_item_id())
+                .line_item_id_exists(&line_item_id)
                 .await?
             {
-            return Err(BillingError::DuplicateLineItemID);
+                line_item_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let line_item = LineItemBuilder::default()
@@ -50,7 +59,7 @@ impl AddLineItemUseCase for AddLineItemService {
             .product_name(cmd.product_name().into())
             .product_id(*cmd.product_id())
             .bill_id(*cmd.bill_id())
-            .line_item_id(*cmd.line_item_id())
+            .line_item_id(line_item_id)
             .quantity(cmd.quantity().clone())
             .price_per_unit(cmd.price_per_unit().clone())
             .deleted(false)
@@ -70,7 +79,8 @@ pub mod tests {
     use super::*;
 
     use crate::billing::domain::line_item_added_event::tests::get_added_line_item_event_from_command;
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_line_item_service(
         times: Option<usize>,
@@ -97,6 +107,7 @@ pub mod tests {
         let s = AddLineItemServiceBuilder::default()
             .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_bill_id_exists(mock_bill_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -118,6 +129,7 @@ pub mod tests {
         let s = AddLineItemServiceBuilder::default()
             .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED))
             .db_bill_id_exists(mock_bill_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/billing/application/services/add_store_service.rs

@@ -12,11 +12,12 @@ use super::errors::*;
 use crate::billing::{
     application::port::output::db::{store_id_exists::*, store_name_exists::*},
     domain::{
-        add_store_command::*,
+        add_store_command::AddStoreCommand,
         store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
         store_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -30,24 +31,28 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
 pub struct AddStoreService {
     db_store_id_exists: StoreIDExistsDBPortObj,
     db_store_name_exists: StoreNameExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
 impl AddStoreUseCase for AddStoreService {
     async fn add_store(&self, cmd: AddStoreCommand) -> BillingResult<StoreAddedEvent> {
-        if self
+        let mut store_id = self.get_uuid.get_uuid();
-            .db_store_id_exists
+
-            .store_id_exists(cmd.store_id())
+        loop {
-            .await?
+            if self.db_store_id_exists.store_id_exists(&store_id).await? {
-        {
+                store_id = self.get_uuid.get_uuid();
-            return Err(BillingError::DuplicateStoreID);
+                continue;
+            } else {
+                break;
+            }
         }
 
         let store = StoreBuilder::default()
             .name(cmd.name().into())
             .address(cmd.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap();
 
@@ -59,7 +64,7 @@ impl AddStoreUseCase for AddStoreService {
             .name(store.name().into())
             .address(store.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap())
     }
@@ -82,7 +87,7 @@ pub mod tests {
             .name(cmd.name().into())
             .address(cmd.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(UUID)
             .build()
             .unwrap();
 
@@ -103,17 +108,13 @@ pub mod tests {
         let address = "bar";
         let owner = UUID;
 
-        let cmd = AddStoreCommandBuilder::default()
+        // address = None
-            .name(name.into())
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -121,7 +122,7 @@ pub mod tests {
         assert_eq!(res.name(), cmd.name());
         assert_eq!(res.address(), cmd.address());
         assert_eq!(res.owner(), cmd.owner());
-        assert_eq!(res.store_id(), cmd.store_id());
+        assert_eq!(res.store_id(), &UUID);
     }
 
     #[actix_rt::test]
@@ -130,17 +131,13 @@ pub mod tests {
         let address = "bar";
         let owner = UUID;
 
-        let cmd = AddStoreCommandBuilder::default()
+        // address = None
-            .name(name.into())
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 

src/billing/application/services/errors.rs

@@ -15,9 +15,6 @@ pub enum BillingError {
     BillIDNotFound,
     InternalError,
     DuplicateStoreName,
-    DuplicateBillID,
-    DuplicateLineItemID,
-    DuplicateStoreID,
     StoreIDNotFound,
     LineItemIDNotFound,
 }
@@ -25,12 +22,21 @@ pub enum BillingError {
 impl From<BillingDBError> for BillingError {
     fn from(value: BillingDBError) -> Self {
         match value {
-            BillingDBError::DuplicateBillID => Self::DuplicateBillID,
+            BillingDBError::DuplicateBillID => {
+                error!("DuplicateBillID");
+                Self::InternalError
+            }
             BillingDBError::DuplicateStoreName => Self::DuplicateStoreName,
-            BillingDBError::DuplicateStoreID => Self::DuplicateStoreID,
+            BillingDBError::DuplicateStoreID => {
+                error!("DuplicateStoreID");
+                Self::InternalError
+            }
             BillingDBError::StoreIDNotFound => BillingError::StoreIDNotFound,
             BillingDBError::InternalError => BillingError::InternalError,
-            BillingDBError::DuplicateLineItemID => Self::DuplicateLineItemID,
+            BillingDBError::DuplicateLineItemID => {
+                error!("DuplicateLineItemID");
+                Self::InternalError
+            }
             BillingDBError::LineItemIDNotFound => BillingError::LineItemIDNotFound,
         }
     }

src/billing/domain/add_bill_command.rs

@@ -4,10 +4,14 @@
 
 use derive_builder::Builder;
 use derive_getters::Getters;
+use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use uuid::Uuid;
 
+use crate::types::{currency::*, quantity::*};
+use crate::utils::string::empty_string_err;
+
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
@@ -17,7 +21,6 @@ pub struct AddBillCommand {
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
 
-    bill_id: Uuid,
     store_id: Uuid,
 }
 
@@ -38,7 +41,6 @@ mod tests {
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
                 .store_id(store_id)
-                .bill_id(UUID)
                 .build()
                 .unwrap()
         }
@@ -52,7 +54,6 @@ mod tests {
         let cmd = AddBillCommandBuilder::default()
             .adding_by(adding_by)
             .store_id(store_id)
-            .bill_id(UUID)
             .build()
             .unwrap();
 

src/billing/domain/add_line_item_command.rs

@@ -19,42 +19,55 @@ pub enum AddLineItemCommandError {
 }
 
 #[derive(
-    Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddLineItemCommand {
-pub struct AddLineItemCommand {
+    adding_by: Uuid,
+
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
-    #[builder(setter(custom))]
     product_name: String,
     product_id: Uuid,
     bill_id: Uuid,
-    line_item_id: Uuid,
+    quantity: Quantity,
+    price_per_unit: Price,
+}
+
+impl UnvalidatedAddLineItemCommand {
+    pub fn validate(self) -> Result<AddLineItemCommand, AddLineItemCommandError> {
+        let product_name = empty_string_err(
+            self.product_name,
+            AddLineItemCommandError::ProductNameIsEmpty,
+        )?;
+
+        if self.quantity.is_empty() {
+            return Err(AddLineItemCommandError::QuantityIsEmpty);
+        }
+
+        Ok(AddLineItemCommand {
+            created_time: self.created_time,
+            product_name,
+            product_id: self.product_id,
+            bill_id: self.bill_id,
+            quantity: self.quantity,
+            adding_by: self.adding_by,
+            price_per_unit: self.price_per_unit,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct AddLineItemCommand {
+    created_time: OffsetDateTime,
+    product_name: String,
+    product_id: Uuid,
+    bill_id: Uuid,
     quantity: Quantity,
     price_per_unit: Price,
 
     adding_by: Uuid,
 }
 
-impl AddLineItemCommandBuilder {
-    pub fn product_name(&mut self, product_name: String) -> &mut Self {
-        self.product_name = Some(product_name.trim().to_owned());
-        self
-    }
-
-    fn validate(&self) -> Result<(), String> {
-        let product_name = self.product_name.as_ref().unwrap().trim().to_owned();
-        if product_name.is_empty() {
-            return Err(AddLineItemCommandError::ProductNameIsEmpty.to_string());
-        }
-
-        if self.quantity.as_ref().unwrap().is_empty() {
-            return Err(AddLineItemCommandError::QuantityIsEmpty.to_string());
-        }
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use time::macros::datetime;
@@ -71,7 +84,7 @@ mod tests {
             let adding_by = UUID;
             let quantity = Quantity::get_quantity();
 
-            AddLineItemCommandBuilder::default()
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
@@ -79,9 +92,10 @@ mod tests {
                 .price_per_unit(Price::default())
                 .product_id(product_id)
                 .bill_id(bill_id)
-                .line_item_id(UUID)
                 .build()
                 .unwrap()
+                .validate()
+                .unwrap()
         }
     }
 
@@ -93,15 +107,16 @@ mod tests {
         let adding_by = UUID;
         let quantity = Quantity::get_quantity();
 
-        let cmd = AddLineItemCommandBuilder::default()
+        let cmd = UnvalidatedAddLineItemCommandBuilder::default()
             .product_name(product_name.into())
             .adding_by(adding_by)
             .price_per_unit(Price::default())
             .quantity(quantity.clone())
             .product_id(product_id)
             .bill_id(bill_id)
-            .line_item_id(UUID)
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
 
         assert_eq!(cmd.quantity(), &quantity);
@@ -118,16 +133,19 @@ mod tests {
         let adding_by = UUID;
         let quantity = Quantity::get_quantity();
 
-        assert!(AddLineItemCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .quantity(quantity.clone())
                 .price_per_unit(Price::default())
                 .product_id(product_id)
-            .line_item_id(UUID)
                 .bill_id(bill_id)
                 .build()
-            .is_err());
+                .unwrap()
+                .validate(),
+            Err(AddLineItemCommandError::ProductNameIsEmpty)
+        );
     }
 
     #[test]
@@ -139,7 +157,8 @@ mod tests {
         // minor = 0; major = 0;
         let quantity = Quantity::default();
 
-        assert!(AddLineItemCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .quantity(quantity.clone())
@@ -147,6 +166,9 @@ mod tests {
                 .bill_id(bill_id)
                 .price_per_unit(Price::default())
                 .build()
-            .is_err());
+                .unwrap()
+                .validate(),
+            Err(AddLineItemCommandError::QuantityIsEmpty)
+        );
     }
 }

src/billing/domain/add_store_command.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use derive_builder::Builder;
 use derive_getters::Getters;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
@@ -13,52 +12,46 @@ pub enum AddStoreCommandError {
     NameIsEmpty,
 }
 
-#[derive(
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
-)]
-#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddStoreCommand {
-    #[builder(setter(custom))]
     name: String,
-    #[builder(setter(custom))]
     address: Option<String>,
-    store_id: Uuid,
     owner: Uuid,
 }
 
-impl AddStoreCommandBuilder {
+impl AddStoreCommand {
-    pub fn address(&mut self, address: Option<String>) -> &mut Self {
+    pub fn new(
-        self.address = if let Some(address) = address {
+        name: String,
+        address: Option<String>,
+        owner: Uuid,
+    ) -> Result<Self, AddStoreCommandError> {
+        let address: Option<String> = if let Some(address) = address {
             let address = address.trim();
             if address.is_empty() {
-                Some(None)
+                None
             } else {
-                Some(Some(address.to_owned()))
+                Some(address.to_owned())
             }
         } else {
-            Some(None)
+            None
         };
-        self
-    }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
+        let name = name.trim().to_owned();
-        self.name = Some(name.trim().to_owned());
-        self
-    }
-
-    fn validate(&self) -> Result<(), String> {
-        let name = self.name.as_ref().unwrap().trim().to_owned();
         if name.is_empty() {
-            return Err(AddStoreCommandError::NameIsEmpty.to_string());
+            return Err(AddStoreCommandError::NameIsEmpty);
         }
-        Ok(())
+
+        Ok(Self {
+            name,
+            address,
+            owner,
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
-    use crate::utils::uuid::tests::*;
 
     use super::*;
 
@@ -69,41 +62,21 @@ mod tests {
         let owner = UUID;
 
         // address = None
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
-            .name(name.into())
-            .address(None)
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-        //        let cmd = AddStoreCommand::new(name.into(), None, owner, UUID).unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &None);
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // address = Some
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .name(name.into())
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-        //        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner, UUID).unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &Some(address.to_owned()));
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // AddStoreCommandError::NameIsEmpty
-
+        assert_eq!(
-        assert!(AddStoreCommandBuilder::default()
+            AddStoreCommand::new("".into(), Some(address.into()), owner),
-            .name("".into())
+            Err(AddStoreCommandError::NameIsEmpty)
-            .address(Some(address.into()))
+        )
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .is_err())
     }
 }

src/billing/domain/line_item_aggregate.rs

@@ -85,7 +85,7 @@ pub mod tests {
                 .quantity(cmd.quantity().clone())
                 .bill_id(*cmd.bill_id())
                 .price_per_unit(cmd.price_per_unit().clone())
-                .line_item_id(*cmd.line_item_id())
+                .line_item_id(UUID)
                 .build()
                 .unwrap()
         }

src/billing/domain/store_aggregate.rs

@@ -113,13 +113,7 @@ mod tests {
             .unwrap();
         let expected = BillingEvent::StoreAdded(expected);
 
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap();
-            .name(name.into())
-            .address(address.clone())
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let mut services = MockBillingServicesInterface::new();
         services

src/billing/domain/update_bill_command.rs

@@ -21,6 +21,7 @@ pub struct UpdateBillCommand {
     created_time: OffsetDateTime,
 
     store_id: Uuid,
+    token_number: usize,
     total_price: Option<Price>,
 
     old_bill: Bill,
@@ -44,6 +45,7 @@ mod tests {
                 .adding_by(adding_by)
                 .store_id(store_id)
                 .total_price(None)
+                .token_number(1)
                 .old_bill(Bill::get_bill())
                 .build()
                 .unwrap()
@@ -60,6 +62,7 @@ mod tests {
             .adding_by(adding_by)
             .store_id(store_id)
             .total_price(None)
+            .token_number(1)
             .old_bill(old_bill.clone())
             .build()
             .unwrap();

src/inventory/adapters/output/db/postgres/category_name_exists_for_store.rs

@@ -49,7 +49,7 @@ pub mod tests {
             VALUES ($1, $2, $3, $4, $5, $6);",
             1,
             c.name(),
-            c.description().as_ref().map(|s| s.as_str()),
+            c.description().as_ref().unwrap(),
             c.category_id(),
             c.store_id(),
             c.deleted().clone(),

src/inventory/adapters/output/db/postgres/category_view.rs

@@ -10,7 +10,7 @@ use uuid::Uuid;
 
 use super::errors::*;
 use super::InventoryDBPostgresAdapter;
-use crate::inventory::domain::category_aggregate::{Category, CategoryBuilder};
+use crate::inventory::domain::category_aggregate::Category;
 use crate::inventory::domain::events::InventoryEvent;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
@@ -27,19 +27,6 @@ pub struct CategoryView {
     deleted: bool,
 }
 
-impl From<CategoryView> for Category {
-    fn from(v: CategoryView) -> Self {
-        CategoryBuilder::default()
-            .name(v.name)
-            .description(v.description)
-            .category_id(v.category_id)
-            .store_id(v.store_id)
-            .deleted(v.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
@@ -52,24 +39,6 @@ impl View<Category> for CategoryView {
             self.store_id = *val.store_id();
             self.deleted = false;
         }
-        match &event.payload {
-            InventoryEvent::CategoryAdded(e) => {
-                self.name = e.name().into();
-                self.description = e.description().clone();
-                self.category_id = *e.category_id();
-                self.store_id = *e.store_id();
-                self.deleted = false;
-            }
-
-            InventoryEvent::CategoryUpdated(e) => {
-                let new_category = e.new_category();
-                self.name = new_category.name().into();
-                self.description = new_category.description().clone();
-                self.category_id = *new_category.category_id();
-                self.store_id = *new_category.store_id();
-            }
-            _ => (),
-        }
     }
 }
 
@@ -177,11 +146,13 @@ impl ViewRepository<CategoryView, Category> for InventoryDBPostgresAdapter {
                         version = $1,
                         name = $2,
                         description = $3,
-                        store_id = $4,
+                        category_id = $4,
-                        deleted = $5;",
+                        store_id = $5,
+                        deleted = $6;",
                     version,
                     view.name,
                     view.description,
+                    view.category_id,
                     view.store_id,
                     view.deleted
                 )
@@ -228,143 +199,3 @@ impl Query<Category> for InventoryDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        inventory::{
-            application::services::{
-                add_category_service::*, update_category_service::*, MockInventoryServicesInterface,
-            },
-            domain::{
-                add_category_command::*, category_aggregate::*, commands::*, events::*,
-                store_aggregate::*, update_category_command::*,
-            },
-        },
-        tests::bdd::*,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_inventory_category_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = InventoryDBPostgresAdapter::new(db.pool.clone());
-
-        let store = Store::default();
-        crate::inventory::adapters::output::db::postgres::store_id_exists::tests::create_dummy_store_record(&store, &db).await;
-
-        let queries: Vec<Box<dyn Query<Category>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockInventoryServicesInterface::new();
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_add_category()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddCategoryServiceBuilder::default()
-                        .db_store_id_exists(db2.clone())
-                        .db_category_name_exists_for_store(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_category()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateCategoryServiceBuilder::default()
-                        .db_store_id_exists(db2.clone())
-                        .db_category_name_exists_for_store(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, category_query): (
-            Arc<PostgresCqrs<Category>>,
-            Arc<dyn ViewRepository<CategoryView, Category>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-
-        let cmd = AddCategoryCommandBuilder::default()
-            .name(rand.get_random(10))
-            .description(None)
-            .store_id(*store.store_id())
-            .adding_by(UUID)
-            .category_id(UUID)
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.category_id().to_string(),
-            InventoryCommand::AddCategory(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let category = category_query
-            .load(&(*cmd.category_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let category: Category = category.into();
-        assert_eq!(category.name(), cmd.name());
-        assert_eq!(category.description(), cmd.description());
-        assert_eq!(category.category_id(), cmd.category_id());
-        assert_eq!(category.store_id(), cmd.store_id());
-        assert!(!store.deleted());
-
-        let update_category_cmd = UpdateCategoryCommand::new(
-            rand.get_random(10),
-            Some(rand.get_random(10)),
-            category,
-            UUID,
-        )
-        .unwrap();
-        cqrs.execute(
-            &cmd.category_id().to_string(),
-            InventoryCommand::UpdateCategory(update_category_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let category = category_query
-            .load(&(*cmd.category_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let category: Category = category.into();
-        assert_eq!(category.name(), update_category_cmd.name());
-        assert_eq!(category.description(), update_category_cmd.description());
-        assert_eq!(category.category_id(), cmd.category_id());
-        assert_eq!(category.store_id(), cmd.store_id());
-        assert!(!category.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/inventory/adapters/output/db/postgres/customization_view.rs

@@ -55,12 +55,6 @@ impl View<Customization> for CustomizationView {
 
                 self.deleted = false;
             }
-            InventoryEvent::CustomizationUpdated(e) => {
-                let new = e.new_customization();
-                self.name = new.name().into();
-                self.product_id = *new.product_id();
-                self.customization_id = *new.customization_id();
-            }
             _ => (),
         }
     }
@@ -187,10 +181,12 @@ impl ViewRepository<CustomizationView, Customization> for InventoryDBPostgresAda
                     SET
                         version = $1,
                         name = $2,
-                        product_id = $3,
+                        customization_id = $3,
-                        deleted = $4;",
+                        product_id = $4,
+                        deleted = $5;",
                     version,
                     view.name,
+                    view.customization_id,
                     view.product_id,
                     view.deleted,
                 )
@@ -223,145 +219,3 @@ impl Query<Customization> for InventoryDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        inventory::{
-            adapters::output::db::postgres::product_id_exists::tests::create_dummy_product_record,
-            application::services::{
-                add_customization_service::*, update_customization_service::*,
-                MockInventoryServicesInterface,
-            },
-            domain::{
-                add_customization_command::*,
-                commands::InventoryCommand,
-                product_aggregate::Product,
-                update_customization_command::{tests::get_update_customization_command, *},
-            },
-        },
-        tests::bdd::*,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_inventory_customization_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = InventoryDBPostgresAdapter::new(db.pool.clone());
-        let product = Product::default();
-        create_dummy_product_record(&product, &db).await;
-
-        //        let simple_query = super::store_view::SimpleLoggingQuery {};
-
-        let queries: Vec<Box<dyn Query<Customization>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockInventoryServicesInterface::new();
-
-        let db2 = db.clone();
-        mock_services
-            .expect_add_customization()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddCustomizationServiceBuilder::default()
-                        .db_product_id_exists(Arc::new(db2.clone()))
-                        .db_customization_id_exists(Arc::new(db2.clone()))
-                        .db_customization_name_exists_for_product(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_customization()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateCustomizationServiceBuilder::default()
-                        .db_product_id_exists(db2.clone())
-                        .db_customization_name_exists_for_product(db2.clone())
-                        .db_customization_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, custmoization_query): (
-            Arc<PostgresCqrs<Customization>>,
-            Arc<dyn ViewRepository<CustomizationView, Customization>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-
-        let cmd = AddCustomizationCommandBuilder::default()
-            .name(rand.get_random(10))
-            .product_id(product.product_id().clone())
-            .customization_id(UUID.clone())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.customization_id().to_string(),
-            InventoryCommand::AddCustomization(cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let customization = custmoization_query
-            .load(&(*cmd.customization_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let customization: Customization = customization.into();
-        assert_eq!(customization.name(), cmd.name());
-        assert_eq!(customization.customization_id(), cmd.customization_id());
-        assert_eq!(customization.product_id(), cmd.product_id());
-        assert!(!customization.deleted());
-
-        let update_customization_command = UnvalidatedUpdateCustomizationCommandBuilder::default()
-            .name(rand.get_random(10))
-            .old_customization(customization.clone())
-            .adding_by(UUID.clone())
-            .build()
-            .unwrap()
-            .validate()
-            .unwrap();
-        cqrs.execute(
-            &cmd.customization_id().to_string(),
-            InventoryCommand::UpdateCustomization(update_customization_command.clone()),
-        )
-        .await
-        .unwrap();
-        let c = custmoization_query
-            .load(&(*cmd.customization_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let c: Customization = c.into();
-        assert_eq!(c.name(), update_customization_command.name());
-        assert_eq!(
-            update_customization_command.old_customization(),
-            &customization
-        );
-        assert!(!c.deleted());
-        settings.drop_db().await;
-    }
-}

src/inventory/adapters/output/db/postgres/product_id_exists.rs

@@ -95,8 +95,8 @@ pub mod tests {
                 );",
             1,
             p.name(),
-            p.description().as_ref().map(|s| s.as_str()),
+            p.description().as_ref().unwrap(),
-            p.image().as_ref().map(|s| s.as_str()),
+            p.image().as_ref().unwrap(),
             p.product_id(),
             p.category_id(),
             p.price().major().clone() as i32,

src/inventory/adapters/output/db/postgres/product_view.rs

@@ -112,25 +112,6 @@ impl View<Product> for ProductView {
 
                 self.deleted = false;
             }
-            InventoryEvent::ProductUpdated(e) => {
-                let val = e.new_product();
-                self.name = val.name().into();
-                self.description = val.description().clone();
-                self.image = val.image().clone();
-                self.product_id = *val.product_id();
-                self.category_id = *val.category_id();
-
-                self.sku_able = *val.sku_able();
-
-                self.price_minor = *val.price().minor() as i32;
-                self.price_major = *val.price().major() as i32;
-                self.price_currency = val.price().currency().to_string();
-
-                self.quantity_major_number = *val.quantity().major().number() as i32;
-                self.quantity_minor_number = *val.quantity().minor().number() as i32;
-                self.quantity_major_unit = val.quantity().major().unit().to_string();
-                self.quantity_minor_unit = val.quantity().minor().unit().to_string();
-            }
             _ => (),
         }
     }
@@ -293,20 +274,22 @@ impl ViewRepository<ProductView, Product> for InventoryDBPostgresAdapter {
                         name = $2,
                         description = $3,
                         image = $4,
-                        category_id = $5,
+                        product_id = $5,
-                        price_major = $6,
+                        category_id = $6,
-                        price_minor = $7,
+                        price_major = $7,
-                        price_currency = $8,
+                        price_minor = $8,
-                        sku_able = $9,
+                        price_currency = $9,
-                        quantity_minor_unit = $10,
+                        sku_able = $10,
-                        quantity_minor_number = $11,
+                        quantity_minor_unit = $11,
-                        quantity_major_unit = $12,
+                        quantity_minor_number = $12,
-                        quantity_major_number = $13,
+                        quantity_major_unit = $13,
-                        deleted = $14;",
+                        quantity_major_number = $14,
+                        deleted = $15;",
                     version,
                     view.name,
                     view.description,
                     view.image,
+                    view.product_id,
                     view.category_id,
                     view.price_major,
                     view.price_minor,
@@ -347,157 +330,3 @@ impl Query<Product> for InventoryDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        inventory::{
-            application::{
-                port::output::full_text_search::add_product_to_store::*,
-                services::{
-                    add_product_service::*, update_product_service::*,
-                    MockInventoryServicesInterface,
-                },
-            },
-            domain::{
-                add_product_command::{tests::get_command, *},
-                category_aggregate::{Category, CategoryBuilder},
-                commands::*,
-                events::*,
-                product_aggregate::*,
-                store_aggregate::*,
-                update_product_command::{tests::get_command_with_product, *},
-            },
-        },
-        tests::bdd::*,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_inventory_product_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = InventoryDBPostgresAdapter::new(db.pool.clone());
-
-        let store = Store::default();
-        crate::inventory::adapters::output::db::postgres::store_id_exists::tests::create_dummy_store_record(&store, &db).await;
-        let category = CategoryBuilder::default()
-            .name("fooooo_cat".into())
-            .description(None)
-            .store_id(*store.store_id())
-            .category_id(UUID)
-            .build()
-            .unwrap();
-        crate::inventory::adapters::output::db::postgres::category_name_exists_for_store::tests::create_dummy_category_record(&category, &db).await;
-
-        let queries: Vec<Box<dyn Query<Product>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockInventoryServicesInterface::new();
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_add_product()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddProductServiceBuilder::default()
-                        .db_product_name_exists_for_category(db2.clone())
-                        .db_product_id_exists(db2.clone())
-                        .db_get_category(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .fts_add_product(mock_add_product_to_store_fts_port(IGNORE_CALL_COUNT))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_product()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateProductServiceBuilder::default()
-                        .db_category_id_exists(db2.clone())
-                        .db_product_name_exists_for_category(db2.clone())
-                        .db_product_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, product_query): (
-            Arc<PostgresCqrs<Product>>,
-            Arc<dyn ViewRepository<ProductView, Product>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-
-        let cmd = get_command();
-        cqrs.execute(
-            &cmd.product_id().to_string(),
-            InventoryCommand::AddProduct(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let product = product_query
-            .load(&(*cmd.product_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let product: Product = product.into();
-        assert_eq!(product.name(), cmd.name());
-        assert_eq!(product.description(), cmd.description());
-        assert_eq!(product.image(), cmd.image());
-        assert_eq!(product.product_id(), cmd.product_id());
-        assert_eq!(product.quantity(), cmd.quantity());
-        assert_eq!(product.sku_able(), cmd.sku_able());
-        assert_eq!(product.price(), cmd.price());
-        assert!(!store.deleted());
-
-        let update_product_cmd = get_command_with_product(product.clone());
-        cqrs.execute(
-            &cmd.product_id().to_string(),
-            InventoryCommand::UpdateProduct(update_product_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let product = product_query
-            .load(&(*cmd.product_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let product: Product = product.into();
-        assert_eq!(product.name(), update_product_cmd.name());
-        assert_eq!(product.description(), update_product_cmd.description());
-        assert_eq!(product.image(), update_product_cmd.image());
-        assert_eq!(
-            product.product_id(),
-            update_product_cmd.old_product().product_id()
-        );
-        assert_eq!(product.quantity(), update_product_cmd.quantity());
-        assert_eq!(product.sku_able(), update_product_cmd.sku_able());
-        assert_eq!(product.price(), update_product_cmd.price());
-        assert!(!store.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/inventory/adapters/output/db/postgres/store_id_exists.rs

@@ -45,7 +45,7 @@ pub mod tests {
             VALUES ($1, $2, $3, $4, $5 ,$6);",
             1,
             s.name(),
-            s.address().as_ref().map(|s| s.as_str()),
+            s.address().as_ref().unwrap(),
             s.store_id(),
             s.owner(),
             false

src/inventory/adapters/output/db/postgres/store_view.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 use super::errors::*;
 use super::InventoryDBPostgresAdapter;
 use crate::inventory::domain::events::InventoryEvent;
-use crate::inventory::domain::store_aggregate::{Store, StoreBuilder};
+use crate::inventory::domain::store_aggregate::Store;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_STORE_NON_UUID: &str = "new_store_non_uuid-asdfa";
@@ -27,41 +27,18 @@ pub struct StoreView {
     deleted: bool,
 }
 
-impl From<StoreView> for Store {
-    fn from(value: StoreView) -> Self {
-        StoreBuilder::default()
-            .name(value.name)
-            .address(value.address)
-            .store_id(value.store_id)
-            .owner(value.owner)
-            .deleted(value.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
 impl View<Store> for StoreView {
     fn update(&mut self, event: &EventEnvelope<Store>) {
-        match &event.payload {
+        if let InventoryEvent::StoreAdded(val) = &event.payload {
-            InventoryEvent::StoreAdded(val) => {
             self.name = val.name().into();
             self.address = val.address().clone();
             self.store_id = *val.store_id();
             self.owner = *val.owner();
             self.deleted = false;
         }
-            InventoryEvent::StoreUpdated(e) => {
-                let new_store = e.new_store();
-                self.name = new_store.name().clone();
-                self.address = new_store.address().clone();
-                self.store_id = *new_store.store_id();
-                self.owner = *new_store.owner();
-            }
-            _ => (),
-        }
     }
 }
 
@@ -169,11 +146,13 @@ impl ViewRepository<StoreView, Store> for InventoryDBPostgresAdapter {
                         version = $1,
                         name = $2,
                         address = $3,
-                        owner = $4,
+                        store_id = $4,
-                        deleted = $5;",
+                        owner = $5,
+                        deleted = $6;",
                     version,
                     view.name,
                     view.address,
+                    view.store_id,
                     view.owner,
                     view.deleted,
                 )
@@ -203,21 +182,12 @@ impl Query<Store> for SimpleLoggingQuery {
 
 #[async_trait]
 impl Query<Store> for InventoryDBPostgresAdapter {
-    async fn dispatch(&self, aggregate_id: &str, events: &[EventEnvelope<Store>]) {
+    async fn dispatch(&self, store_id: &str, events: &[EventEnvelope<Store>]) {
-        println!("Got store ID: {}", aggregate_id);
-
         let res = self
-            .load_with_context(&aggregate_id)
+            .load_with_context(store_id)
             .await
-            .unwrap_or_else(|_| {
+            .unwrap_or_else(|_| Some((StoreView::default(), ViewContext::new(store_id.into(), 0))));
-                println!("generating default");
-                Some((
-                    StoreView::default(),
-                    ViewContext::new(aggregate_id.into(), 0),
-                ))
-            });
         let (mut view, view_context): (StoreView, ViewContext) = res.unwrap();
-
         for event in events {
             view.update(event);
         }
@@ -225,6 +195,12 @@ impl Query<Store> for InventoryDBPostgresAdapter {
     }
 }
 
+// Our second query, this one will be handled with Postgres `GenericQuery`
+// which will serialize and persist our view after it is updated. It also
+// provides a `load` method to deserialize the view on request.
+//pub type StoreQuery = GenericQuery<InventoryDBPostgresAdapter, StoreView, Store>;
+//pub type StoreQuery = Query<dyn InventoryDBPostgresAdapter, StoreView, Store>;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -235,20 +211,31 @@ mod tests {
         db::migrate::*,
         inventory::{
             application::services::{
-                add_store_service::AddStoreServiceBuilder, update_store_service::*,
+                add_category_service::tests::mock_add_category_service,
-                MockInventoryServicesInterface,
+                add_customization_service::tests::mock_add_customization_service,
+                add_product_service::tests::mock_add_product_service,
+                add_store_service::AddStoreServiceBuilder,
+                update_category_service::tests::mock_update_category_service,
+                update_customization_service::tests::mock_update_customization_service,
+                update_product_service::tests::mock_update_product_service,
+                update_store_service::tests::mock_update_store_service, InventoryServicesBuilder,
             },
-            domain::add_store_command::*,
+            domain::{
-            domain::commands::InventoryCommand,
+                add_category_command::AddCategoryCommand, add_customization_command,
-            domain::update_store_command::*,
+                add_product_command::tests::get_command, add_store_command::AddStoreCommand,
+                commands::InventoryCommand,
+                update_category_command::tests::get_update_category_command,
+                update_customization_command::tests::get_update_customization_command,
+                update_product_command, update_store_command::tests::get_update_store_cmd,
             },
-        tests::bdd::*,
+        },
+        tests::bdd::IS_NEVER_CALLED,
         utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
     };
     use std::sync::Arc;
 
     #[actix_rt::test]
-    async fn pg_query_inventory_store_view() {
+    async fn pg_query() {
         let settings = crate::settings::tests::get_settings().await;
         //let settings = crate::settings::Settings::new().unwrap();
         settings.create_db().await;
@@ -262,101 +249,61 @@ mod tests {
         let queries: Vec<Box<dyn Query<Store>>> =
             vec![Box::new(simple_query), Box::new(db.clone())];
 
-        let mut mock_services = MockInventoryServicesInterface::new();
+        let services = InventoryServicesBuilder::default()
-
+            .add_store(Arc::new(
-        let db2 = db.clone();
-        mock_services
-            .expect_add_store()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
                 AddStoreServiceBuilder::default()
-                        .db_store_id_exists(Arc::new(db2.clone()))
+                    .db_store_id_exists(Arc::new(db.clone()))
-                        .db_store_name_exists(Arc::new(db2.clone()))
+                    .db_store_name_exists(Arc::new(db.clone()))
+                    .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
                     .build()
                     .unwrap(),
-                )
+            ))
-            });
+            .add_category(mock_add_category_service(
-
+                IS_NEVER_CALLED,
-        let db2 = db.clone();
+                AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
-        mock_services
+            ))
-            .expect_update_store()
+            .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .add_customization(mock_add_customization_service(
-            .returning(move || {
+                IS_NEVER_CALLED,
-                Arc::new(
+                add_customization_command::tests::get_command(),
-                    UpdateStoreServiceBuilder::default()
+            ))
-                        .db_store_id_exists(Arc::new(db2.clone()))
+            .update_product(mock_update_product_service(
-                        .db_store_name_exists(Arc::new(db2.clone()))
+                IS_NEVER_CALLED,
+                update_product_command::tests::get_command(),
+            ))
+            .update_customization(mock_update_customization_service(
+                IS_NEVER_CALLED,
+                get_update_customization_command(),
+            ))
+            .update_category(mock_update_category_service(
+                IS_NEVER_CALLED,
+                get_update_category_command(),
+            ))
+            .update_store(mock_update_store_service(
+                IS_NEVER_CALLED,
+                get_update_store_cmd(),
+            ))
             .build()
-                        .unwrap(),
+            .unwrap();
-                )
-            });
 
-        let (cqrs, store_query): (
+        let (cqrs, _store_query): (
             Arc<PostgresCqrs<Store>>,
             Arc<dyn ViewRepository<StoreView, Store>>,
         ) = (
             Arc::new(postgres_es::postgres_cqrs(
                 db.pool.clone(),
                 queries,
-                Arc::new(mock_services),
+                Arc::new(services),
             )),
             Arc::new(db.clone()),
         );
 
         let rand = crate::utils::random_string::GenerateRandomString {};
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap();
-            .name(rand.get_random(10))
+        cqrs.execute("", InventoryCommand::AddStore(cmd.clone()))
-            .address(None)
-            .owner(UUID)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-        cqrs.execute(
-            &cmd.store_id().to_string(),
-            InventoryCommand::AddStore(cmd.clone()),
-        )
             .await
             .unwrap();
 
-        let store = store_query
-            .load(&(*cmd.store_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let store: Store = store.into();
-        assert_eq!(store.name(), cmd.name());
-        assert_eq!(store.address(), cmd.address());
-        assert_eq!(store.owner(), cmd.owner());
-        assert_eq!(store.store_id(), cmd.store_id());
-        assert!(!store.deleted());
-
-        let update_store_cmd = UpdateStoreCommand::new(
-            rand.get_random(10),
-            Some(rand.get_random(10)),
-            UUID,
-            store,
-            UUID,
-        )
-        .unwrap();
-        cqrs.execute(
-            &cmd.store_id().to_string(),
-            InventoryCommand::UpdateStore(update_store_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let store = store_query
-            .load(&(*cmd.store_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let store: Store = store.into();
-        assert_eq!(store.name(), update_store_cmd.name());
-        assert_eq!(store.address(), update_store_cmd.address());
-        assert_eq!(store.owner(), update_store_cmd.owner());
-        assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
-        assert!(!store.deleted());
-
         settings.drop_db().await;
     }
 }

src/inventory/application/services/add_category_service.rs

@@ -14,11 +14,12 @@ use crate::inventory::{
         category_id_exists::*, category_name_exists_for_store::*, store_id_exists::*,
     },
     domain::{
-        add_category_command::*,
+        add_category_command::AddCategoryCommand,
         category_added_event::{CategoryAddedEvent, CategoryAddedEventBuilder},
         category_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -33,6 +34,7 @@ pub struct AddCategoryService {
     db_store_id_exists: StoreIDExistsDBPortObj,
     db_category_name_exists_for_store: CategoryNameExistsForStoreDBPortObj,
     db_category_id_exists: CategoryIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -46,19 +48,27 @@ impl AddCategoryUseCase for AddCategoryService {
             return Err(InventoryError::StoreIDNotFound);
         }
 
+        let mut category_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_category_id_exists
-            .category_id_exists(cmd.category_id())
+                .category_id_exists(&category_id)
                 .await?
             {
-            return Err(InventoryError::DuplicateCategoryID);
+                category_id = self.get_uuid.get_uuid();
+
+                continue;
+            } else {
+                break;
+            }
         }
 
         let category = CategoryBuilder::default()
             .name(cmd.name().into())
             .description(cmd.description().as_ref().map(|s| s.to_string()))
             .store_id(*cmd.store_id())
-            .category_id(*cmd.category_id())
+            .category_id(category_id)
             .build()
             .unwrap();
 
@@ -87,8 +97,8 @@ pub mod tests {
 
     use uuid::Uuid;
 
-    use crate::tests::bdd::*;
     use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_category_service(
         times: Option<usize>,
@@ -101,7 +111,7 @@ pub mod tests {
             .description(cmd.description().as_ref().map(|s| s.to_string()))
             .added_by_user(*cmd.adding_by())
             .store_id(*cmd.store_id())
-            .category_id(*cmd.category_id())
+            .category_id(UUID)
             .build()
             .unwrap();
 
@@ -123,13 +133,8 @@ pub mod tests {
         let user_id = UUID;
         let store_id = Uuid::new_v4();
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = None
-            .name(name.into())
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
-            .description(Some(description.into()))
-            .store_id(store_id)
-            .adding_by(user_id)
-            .category_id(UUID)
-            .build()
             .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
@@ -138,6 +143,7 @@ pub mod tests {
                 IS_CALLED_ONLY_ONCE,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -156,13 +162,8 @@ pub mod tests {
         let user_id = UUID;
         let store_id = Uuid::new_v4();
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = None
-            .name(name.into())
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
-            .description(Some(description.into()))
-            .store_id(store_id)
-            .adding_by(user_id)
-            .category_id(UUID)
-            .build()
             .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
@@ -171,6 +172,7 @@ pub mod tests {
                 IS_CALLED_ONLY_ONCE,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -187,13 +189,8 @@ pub mod tests {
         let user_id = UUID;
         let store_id = Uuid::new_v4();
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = None
-            .name(name.into())
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
-            .description(Some(description.into()))
-            .store_id(store_id)
-            .adding_by(user_id)
-            .category_id(UUID)
-            .build()
             .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
@@ -202,6 +199,7 @@ pub mod tests {
                 IS_NEVER_CALLED,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_NEVER_CALLED))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/inventory/application/services/add_customization_service.rs

@@ -24,6 +24,7 @@ use crate::inventory::{
         product_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -41,6 +42,7 @@ pub struct AddCustomizationService {
     db_product_id_exists: ProductIDExistsDBPortObj,
     db_customization_id_exists: CustomizationIDExistsDBPortObj,
     db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -57,19 +59,25 @@ impl AddCustomizationUseCase for AddCustomizationService {
             return Err(InventoryError::ProductIDNotFound);
         }
 
+        let mut customization_id = self.get_uuid.get_uuid();
+        loop {
             if self
                 .db_customization_id_exists
-            .customization_id_exists(cmd.customization_id())
+                .customization_id_exists(&customization_id)
                 .await?
             {
-            return Err(InventoryError::DuplicateCustomizationID);
+                customization_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let customization = CustomizationBuilder::default()
             .name(cmd.name().into())
             .deleted(false)
             .product_id(*cmd.product_id())
-            .customization_id(*cmd.customization_id())
+            .customization_id(customization_id)
             .build()
             .unwrap();
 
@@ -93,9 +101,11 @@ pub mod tests {
     use super::*;
 
     use customization_added_event::tests::get_customization_added_event_from_cmd;
+    use uuid::Uuid;
 
     use crate::inventory::domain::add_customization_command::tests::get_command;
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_customization_service(
         times: Option<usize>,
@@ -128,16 +138,12 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE),
             )
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
         let res = s.add_customization(cmd.clone()).await.unwrap();
         assert_eq!(res.customization().name(), cmd.name());
-        assert_eq!(res.customization().product_id(), cmd.product_id());
-        assert_eq!(
-            res.customization().customization_id(),
-            cmd.customization_id()
-        );
         //        assert_eq!(customization_added_events.len(), cmd.customizations().len());
     }
 
@@ -153,6 +159,7 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE),
             )
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -172,6 +179,7 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED),
             )
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/inventory/application/services/add_product_service.rs

@@ -23,6 +23,7 @@ use crate::inventory::{
         product_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -39,6 +40,7 @@ pub struct AddProductService {
     db_product_id_exists: ProductIDExistsDBPortObj,
     db_get_category: GetCategoryDBPortObj,
     fts_add_product: AddProductToStoreFTSPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -52,12 +54,19 @@ impl AddProductUseCase for AddProductService {
             return Err(InventoryError::CategoryIDNotFound);
         }
 
+        let mut product_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_product_id_exists
-            .product_id_exists(cmd.product_id())
+                .product_id_exists(&product_id)
                 .await?
             {
-            return Err(InventoryError::DuplicateProductID);
+                product_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let product = ProductBuilder::default()
@@ -68,7 +77,7 @@ impl AddProductUseCase for AddProductService {
             .price(cmd.price().clone())
             .category_id(*cmd.category_id())
             .quantity(cmd.quantity().clone())
-            .product_id(*cmd.product_id())
+            .product_id(product_id)
             .build()
             .unwrap();
 
@@ -110,8 +119,8 @@ pub mod tests {
     use super::*;
 
     use crate::inventory::domain::add_product_command::tests::get_command;
-    use crate::tests::bdd::*;
     use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_product_service(
         times: Option<usize>,
@@ -156,6 +165,7 @@ pub mod tests {
             .db_get_category(mock_get_category_db_port(IS_CALLED_ONLY_ONCE))
             .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -180,6 +190,7 @@ pub mod tests {
                 mock_product_name_exists_for_category_db_port_true(IS_CALLED_ONLY_ONCE),
             )
             .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .db_product_id_exists(mock_product_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
@@ -204,6 +215,7 @@ pub mod tests {
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/inventory/application/services/add_store_service.rs

@@ -12,11 +12,12 @@ use super::errors::*;
 use crate::inventory::{
     application::port::output::db::{store_id_exists::*, store_name_exists::*},
     domain::{
-        add_store_command::*,
+        add_store_command::AddStoreCommand,
         store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
         store_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -30,24 +31,28 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
 pub struct AddStoreService {
     db_store_id_exists: StoreIDExistsDBPortObj,
     db_store_name_exists: StoreNameExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
 impl AddStoreUseCase for AddStoreService {
     async fn add_store(&self, cmd: AddStoreCommand) -> InventoryResult<StoreAddedEvent> {
-        if self
+        let mut store_id = self.get_uuid.get_uuid();
-            .db_store_id_exists
+
-            .store_id_exists(cmd.store_id())
+        loop {
-            .await?
+            if self.db_store_id_exists.store_id_exists(&store_id).await? {
-        {
+                store_id = self.get_uuid.get_uuid();
-            return Err(InventoryError::DuplicateStoreID);
+                continue;
+            } else {
+                break;
+            }
         }
 
         let store = StoreBuilder::default()
             .name(cmd.name().into())
             .address(cmd.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap();
 
@@ -59,7 +64,7 @@ impl AddStoreUseCase for AddStoreService {
             .name(store.name().into())
             .address(store.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap())
     }
@@ -104,17 +109,12 @@ pub mod tests {
         let owner = UUID;
 
         // address = None
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .name(name.into())
-            .address(None)
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -132,17 +132,12 @@ pub mod tests {
         let owner = UUID;
 
         // address = None
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .name(name.into())
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 

src/inventory/application/services/errors.rs

@@ -18,10 +18,6 @@ pub enum InventoryError {
     DuplicateStoreName,
     DuplicateProductName,
     DuplicateCustomizationName,
-    DuplicateCustomizationID,
-    DuplicateStoreID,
-    DuplicateCategoryID,
-    DuplicateProductID,
     ProductIDNotFound,
     CategoryIDNotFound,
     CustomizationIDNotFound,
@@ -36,10 +32,22 @@ impl From<InventoryDBError> for InventoryError {
             InventoryDBError::DuplicateStoreName => Self::DuplicateStoreName,
             InventoryDBError::DuplicateProductName => Self::DuplicateProductName,
             InventoryDBError::DuplicateCustomizationName => Self::DuplicateCustomizationName,
-            InventoryDBError::DuplicateStoreID => Self::DuplicateStoreID,
+            InventoryDBError::DuplicateStoreID => {
-            InventoryDBError::DuplicateProductID => Self::DuplicateProductID,
+                error!("DuplicateStoreID");
-            InventoryDBError::DuplicateCategoryID => Self::DuplicateCategoryID,
+                Self::InternalError
-            InventoryDBError::DuplicateCustomizationID => Self::DuplicateCustomizationID,
+            }
+            InventoryDBError::DuplicateProductID => {
+                error!("DuplicateProductID");
+                Self::InternalError
+            }
+            InventoryDBError::DuplicateCategoryID => {
+                error!("DuplicateCategoryID");
+                Self::InternalError
+            }
+            InventoryDBError::DuplicateCustomizationID => {
+                error!("DuplicateCustomizationID");
+                Self::InternalError
+            }
             InventoryDBError::InternalError => Self::InternalError,
             InventoryDBError::ProductIDNotFound => InventoryError::ProductIDNotFound,
             InventoryDBError::CategoryIDNotFound => InventoryError::CategoryIDNotFound,

src/inventory/application/services/update_category_service.rs

@@ -15,6 +15,7 @@ use crate::inventory::{
     },
     domain::{category_aggregate::*, category_updated_event::*, update_category_command::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]

src/inventory/domain/add_category_command.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use derive_builder::Builder;
 use derive_getters::Getters;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
@@ -13,22 +12,21 @@ pub enum AddCategoryCommandError {
     NameIsEmpty,
 }
 
-#[derive(
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
-)]
-#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddCategoryCommand {
-    #[builder(setter(custom))]
     name: String,
-    #[builder(setter(custom))]
     description: Option<String>,
     store_id: Uuid,
-    category_id: Uuid,
     adding_by: Uuid,
 }
 
-impl AddCategoryCommandBuilder {
+impl AddCategoryCommand {
-    pub fn description(&mut self, description: Option<String>) -> &mut Self {
+    pub fn new(
+        name: String,
+        description: Option<String>,
+        store_id: Uuid,
+        adding_by: Uuid,
+    ) -> Result<Self, AddCategoryCommandError> {
         let description: Option<String> = if let Some(description) = description {
             let description = description.trim();
             if description.is_empty() {
@@ -39,22 +37,18 @@ impl AddCategoryCommandBuilder {
         } else {
             None
         };
-        self.description = Some(description);
-        self
-    }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
         let name = name.trim().to_owned();
-        self.name = Some(name);
+        if name.is_empty() {
-        self
+            return Err(AddCategoryCommandError::NameIsEmpty);
         }
 
-    pub fn validate(&self) -> Result<(), String> {
+        Ok(Self {
-        if self.name.as_ref().unwrap().is_empty() {
+            name,
-            return Err(AddCategoryCommandError::NameIsEmpty.to_string());
+            store_id,
-        }
+            description,
-
+            adding_by,
-        Ok(())
+        })
     }
 }
 
@@ -71,41 +65,26 @@ mod tests {
         let adding_by = UUID;
         let store_id = Uuid::new_v4();
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = None
-            .name(name.into())
+        let cmd = AddCategoryCommand::new(name.into(), None, store_id, adding_by).unwrap();
-            .description(None)
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
-            .unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &None);
         assert_eq!(cmd.adding_by(), &adding_by);
         assert_eq!(cmd.store_id(), &store_id);
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = Some
-            .name(name.into())
+        let cmd =
-            .description(Some(description.into()))
+            AddCategoryCommand::new(name.into(), Some(description.into()), store_id, adding_by)
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
                 .unwrap();
-
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &Some(description.to_owned()));
         assert_eq!(cmd.adding_by(), &adding_by);
         assert_eq!(cmd.store_id(), &store_id);
 
         // AddCategoryCommandError::NameIsEmpty
-        assert!(AddCategoryCommandBuilder::default()
+        assert_eq!(
-            .name("".into())
+            AddCategoryCommand::new("".into(), Some(description.into()), store_id, adding_by,),
-            .description(Some(description.into()))
+            Err(AddCategoryCommandError::NameIsEmpty)
-            .store_id(store_id)
+        )
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
-            .is_err())
     }
 }

src/inventory/domain/add_customization_command.rs

@@ -16,26 +16,28 @@ pub enum AddCustomizationCommandError {
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddCustomizationCommand {
-pub struct AddCustomizationCommand {
-    #[builder(setter(custom))]
     name: String,
     product_id: Uuid,
-    customization_id: Uuid,
 }
 
-impl AddCustomizationCommandBuilder {
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    pub fn name(&mut self, name: String) -> &mut Self {
+pub struct AddCustomizationCommand {
-        self.name = Some(name.trim().to_owned());
+    name: String,
-        self
+    product_id: Uuid,
 }
 
-    fn validate(&self) -> Result<(), String> {
+impl UnvalidatedAddCustomizationCommand {
-        let name = self.name.as_ref().unwrap().trim().to_owned();
+    pub fn validate(self) -> Result<AddCustomizationCommand, AddCustomizationCommandError> {
+        let name = self.name.trim().to_owned();
         if name.is_empty() {
-            return Err(AddCustomizationCommandError::NameIsEmpty.to_string());
+            return Err(AddCustomizationCommandError::NameIsEmpty);
         }
-        Ok(())
+
+        Ok(AddCustomizationCommand {
+            name,
+            product_id: self.product_id,
+        })
     }
 }
 
@@ -46,12 +48,13 @@ pub mod tests {
     use crate::utils::uuid::tests::UUID;
 
     pub fn get_command() -> AddCustomizationCommand {
-        AddCustomizationCommandBuilder::default()
+        UnvalidatedAddCustomizationCommandBuilder::default()
             .name("foo".into())
             .product_id(UUID.clone())
-            .customization_id(UUID.clone())
             .build()
             .unwrap()
+            .validate()
+            .unwrap()
     }
 
     #[test]
@@ -59,11 +62,12 @@ pub mod tests {
         let name = "foo";
         let product_id = UUID;
 
-        let cmd = AddCustomizationCommandBuilder::default()
+        let cmd = UnvalidatedAddCustomizationCommandBuilder::default()
             .name(name.into())
             .product_id(product_id.clone())
-            .customization_id(UUID.clone())
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
 
         assert_eq!(cmd.name(), name);
@@ -74,11 +78,14 @@ pub mod tests {
     fn test_cmd_name_is_empty() {
         let product_id = UUID;
 
-        assert!(AddCustomizationCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddCustomizationCommandBuilder::default()
                 .name("".into())
                 .product_id(product_id.clone())
-            .customization_id(UUID.clone())
                 .build()
-            .is_err(),);
+                .unwrap()
+                .validate(),
+            Err(AddCustomizationCommandError::NameIsEmpty)
+        );
     }
 }

src/inventory/domain/add_product_command.rs

@@ -17,17 +17,24 @@ pub enum AddProductCommandError {
 }
 
 #[derive(
-    Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddProductCommand {
-pub struct AddProductCommand {
+    name: String,
-    #[builder(setter(custom))]
+    description: Option<String>,
+    image: Option<String>,
+    category_id: Uuid,
+    sku_able: bool,
+    quantity: Quantity,
+    price: Price,
+    adding_by: Uuid,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct AddProductCommand {
     name: String,
-    #[builder(setter(custom))]
     description: Option<String>,
-    #[builder(setter(custom))]
     image: Option<String>,
-    product_id: Uuid,
     category_id: Uuid,
     sku_able: bool,
     price: Price,
@@ -35,9 +42,9 @@ pub struct AddProductCommand {
     adding_by: Uuid,
 }
 
-impl AddProductCommandBuilder {
+impl UnvalidatedAddProductCommand {
-    pub fn description(&mut self, description: Option<String>) -> &mut Self {
+    pub fn validate(self) -> Result<AddProductCommand, AddProductCommandError> {
-        let description: Option<String> = if let Some(description) = description {
+        let description: Option<String> = if let Some(description) = self.description {
             let description = description.trim();
             if description.is_empty() {
                 None
@@ -47,12 +54,8 @@ impl AddProductCommandBuilder {
         } else {
             None
         };
-        self.description = Some(description);
-        self
-    }
 
-    pub fn image(&mut self, image: Option<String>) -> &mut Self {
+        let image: Option<String> = if let Some(image) = self.image {
-        let image: Option<String> = if let Some(image) = image {
             let image = image.trim();
             if image.is_empty() {
                 None
@@ -62,22 +65,22 @@ impl AddProductCommandBuilder {
         } else {
             None
         };
-        self.image = Some(image);
+
-        self
+        let name = self.name.trim().to_owned();
+        if name.is_empty() {
+            return Err(AddProductCommandError::NameIsEmpty);
         }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
+        Ok(AddProductCommand {
-        let name = name.trim().to_owned();
+            name,
-        self.name = Some(name);
+            description,
-        self
+            image,
-    }
+            category_id: self.category_id,
-
+            sku_able: self.sku_able,
-    pub fn validate(&self) -> Result<(), String> {
+            price: self.price,
-        if self.name.as_ref().unwrap().is_empty() {
+            quantity: self.quantity,
-            return Err(AddProductCommandError::NameIsEmpty.to_string());
+            adding_by: self.adding_by,
-        }
+        })
-
-        Ok(())
     }
 }
 
@@ -90,7 +93,7 @@ pub mod tests {
     pub fn get_command() -> AddProductCommand {
         let name = "foo";
         let adding_by = UUID;
-        let category_id = UUID;
+        let category_id = Uuid::new_v4();
         let sku_able = false;
         let image = Some("image".to_string());
         let description = Some("description".to_string());
@@ -120,7 +123,7 @@ pub mod tests {
             .build()
             .unwrap();
 
-        AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(description.clone())
             .image(image.clone())
@@ -128,10 +131,11 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
-            .unwrap()
+            .unwrap();
+
+        cmd.validate().unwrap()
     }
 
     #[test]
@@ -151,7 +155,7 @@ pub mod tests {
         let quantity = Quantity::default();
 
         // description = None
-        let cmd = AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(None)
             .image(None)
@@ -159,11 +163,12 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity.clone())
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
             .unwrap();
 
+        let cmd = cmd.validate().unwrap();
+
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &None);
         assert_eq!(cmd.adding_by(), &adding_by);
@@ -191,19 +196,21 @@ pub mod tests {
 
         let quantity = Quantity::default();
 
-        let cmd = AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(description.clone())
             .image(image.clone())
             .category_id(category_id)
-            .adding_by(adding_by)
             .quantity(quantity.clone())
+            .adding_by(adding_by)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
+            //            .customizations(customizations.clone())
             .build()
             .unwrap();
 
+        let cmd = cmd.validate().unwrap();
+
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &description);
         assert_eq!(cmd.adding_by(), &adding_by);
@@ -231,8 +238,7 @@ pub mod tests {
 
         let quantity = Quantity::default();
 
-        // AddProductCommandError::NameIsEmpty
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
-        assert!(AddProductCommandBuilder::default()
             .name("".into())
             .description(description.clone())
             .image(image.clone())
@@ -240,9 +246,11 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
-            .is_err());
+            .unwrap();
+
+        // AddProductCommandError::NameIsEmpty
+        assert_eq!(cmd.validate(), Err(AddProductCommandError::NameIsEmpty))
     }
 }

src/inventory/domain/add_store_command.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use derive_builder::Builder;
 use derive_getters::Getters;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
@@ -13,52 +12,46 @@ pub enum AddStoreCommandError {
     NameIsEmpty,
 }
 
-#[derive(
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
-)]
-#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddStoreCommand {
-    #[builder(setter(custom))]
     name: String,
-    #[builder(setter(custom))]
     address: Option<String>,
-    store_id: Uuid,
     owner: Uuid,
 }
 
-impl AddStoreCommandBuilder {
+impl AddStoreCommand {
-    pub fn address(&mut self, address: Option<String>) -> &mut Self {
+    pub fn new(
-        self.address = if let Some(address) = address {
+        name: String,
+        address: Option<String>,
+        owner: Uuid,
+    ) -> Result<Self, AddStoreCommandError> {
+        let address: Option<String> = if let Some(address) = address {
             let address = address.trim();
             if address.is_empty() {
-                Some(None)
+                None
             } else {
-                Some(Some(address.to_owned()))
+                Some(address.to_owned())
             }
         } else {
-            Some(None)
+            None
         };
-        self
-    }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
+        let name = name.trim().to_owned();
-        self.name = Some(name.trim().to_owned());
-        self
-    }
-
-    fn validate(&self) -> Result<(), String> {
-        let name = self.name.as_ref().unwrap().trim().to_owned();
         if name.is_empty() {
-            return Err(AddStoreCommandError::NameIsEmpty.to_string());
+            return Err(AddStoreCommandError::NameIsEmpty);
         }
-        Ok(())
+
+        Ok(Self {
+            name,
+            address,
+            owner,
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
-    use crate::utils::uuid::tests::*;
 
     use super::*;
 
@@ -69,41 +62,21 @@ mod tests {
         let owner = UUID;
 
         // address = None
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
-            .name(name.into())
-            .address(None)
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-        //        let cmd = AddStoreCommand::new(name.into(), None, owner, UUID).unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &None);
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // address = Some
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .name(name.into())
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-        //        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner, UUID).unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &Some(address.to_owned()));
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // AddStoreCommandError::NameIsEmpty
-
+        assert_eq!(
-        assert!(AddStoreCommandBuilder::default()
+            AddStoreCommand::new("".into(), Some(address.into()), owner),
-            .name("".into())
+            Err(AddStoreCommandError::NameIsEmpty)
-            .address(Some(address.into()))
+        )
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .is_err())
     }
 }

src/inventory/domain/category_aggregate.rs

@@ -107,14 +107,8 @@ mod aggregate_tests {
         let store_id = Uuid::new_v4();
         let category_id = UUID;
 
-        let cmd = AddCategoryCommandBuilder::default()
+        let cmd =
-            .name(name.into())
+            AddCategoryCommand::new(name.into(), description.clone(), store_id, adding_by).unwrap();
-            .description(description.clone())
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(category_id)
-            .build()
-            .unwrap();
 
         let expected = CategoryAddedEventBuilder::default()
             .name(cmd.name().into())

src/inventory/domain/store_aggregate.rs

@@ -113,13 +113,7 @@ mod tests {
             .unwrap();
         let expected = InventoryEvent::StoreAdded(expected);
 
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap();
-            .name(name.into())
-            .address(address.clone())
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let mut services = MockInventoryServicesInterface::new();
         services

src/inventory/domain/update_product_command.rs

@@ -95,62 +95,13 @@ pub mod tests {
     use crate::types::quantity::*;
     use crate::utils::uuid::tests::UUID;
 
-    pub fn get_command_with_product(product: Product) -> UpdateProductCommand {
-        let name = "foobaaar";
-        let adding_by = UUID;
-        let category_id = UUID;
-        let sku_able = false;
-        let image = Some("imageeee".to_string());
-        let description = Some("descriptionnnn".to_string());
-
-        let price = PriceBuilder::default()
-            .minor(0)
-            .major(100)
-            .currency(Currency::INR)
-            .build()
-            .unwrap();
-
-        let quantity = QuantityBuilder::default()
-            .minor(
-                QuantityPartBuilder::default()
-                    .number(0)
-                    .unit(QuantityUnit::DiscreteNumber)
-                    .build()
-                    .unwrap(),
-            )
-            .major(
-                QuantityPartBuilder::default()
-                    .number(1)
-                    .unit(QuantityUnit::DiscreteNumber)
-                    .build()
-                    .unwrap(),
-            )
-            .build()
-            .unwrap();
-
-        let cmd = UnvalidatedUpdateProductCommandBuilder::default()
-            .name(name.into())
-            .description(description.clone())
-            .image(image.clone())
-            .category_id(category_id.clone())
-            .adding_by(adding_by.clone())
-            .quantity(quantity)
-            .sku_able(sku_able)
-            .price(price.clone())
-            .old_product(product)
-            .build()
-            .unwrap();
-
-        cmd.validate().unwrap()
-    }
-
     pub fn get_command() -> UpdateProductCommand {
-        let name = "foobaaar";
+        let name = "foo";
         let adding_by = UUID;
-        let category_id = UUID;
+        let category_id = Uuid::new_v4();
         let sku_able = false;
-        let image = Some("imageeee".to_string());
+        let image = Some("image".to_string());
-        let description = Some("descriptionnnn".to_string());
+        let description = Some("description".to_string());
 
         let price = PriceBuilder::default()
             .minor(0)

src/ordering/adapters/output/db/category_name_exists_for_store.rs

@@ -49,7 +49,7 @@ pub mod tests {
             VALUES ($1, $2, $3, $4, $5, $6);",
             1,
             c.name(),
-            c.description().as_ref().map(|s| s.as_str()),
+            c.description().as_ref().unwrap(),
             c.category_id(),
             c.store_id(),
             c.deleted().clone(),

src/ordering/adapters/output/db/category_view.rs

@@ -10,7 +10,7 @@ use uuid::Uuid;
 
 use super::errors::*;
 use super::OrderingDBPostgresAdapter;
-use crate::ordering::domain::category_aggregate::*;
+use crate::ordering::domain::category_aggregate::Category;
 use crate::ordering::domain::events::OrderingEvent;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
@@ -27,42 +27,18 @@ pub struct CategoryView {
     deleted: bool,
 }
 
-impl From<CategoryView> for Category {
-    fn from(v: CategoryView) -> Self {
-        CategoryBuilder::default()
-            .name(v.name)
-            .description(v.description)
-            .category_id(v.category_id)
-            .store_id(v.store_id)
-            .deleted(v.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
 impl View<Category> for CategoryView {
     fn update(&mut self, event: &EventEnvelope<Category>) {
-        match &event.payload {
+        if let OrderingEvent::CategoryAdded(val) = &event.payload {
-            OrderingEvent::CategoryAdded(val) => {
             self.name = val.name().into();
             self.description = val.description().clone();
             self.category_id = *val.category_id();
             self.store_id = *val.store_id();
             self.deleted = false;
         }
-            OrderingEvent::CategoryUpdated(e) => {
-                let val = e.new_category();
-
-                self.name = val.name().into();
-                self.description = val.description().clone();
-                self.category_id = *val.category_id();
-                self.store_id = *val.store_id();
-            }
-            _ => (),
-        }
     }
 }
 
@@ -170,11 +146,13 @@ impl ViewRepository<CategoryView, Category> for OrderingDBPostgresAdapter {
                         version = $1,
                         name = $2,
                         description = $3,
-                        store_id = $4,
+                        category_id = $4,
-                        deleted = $5;",
+                        store_id = $5,
+                        deleted = $6;",
                     version,
                     view.name,
                     view.description,
+                    view.category_id,
                     view.store_id,
                     view.deleted
                 )
@@ -221,146 +199,3 @@ impl Query<Category> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            application::services::{
-                add_category_service::*, update_category_service::*, MockOrderingServicesInterface,
-            },
-            domain::{
-                add_category_command::*, category_aggregate::*, commands::*, events::*,
-                store_aggregate::*, update_category_command::*,
-            },
-        },
-        tests::bdd::*,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_category_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-
-        let store = Store::default();
-        crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
-            &store, &db,
-        )
-        .await;
-
-        let queries: Vec<Box<dyn Query<Category>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_add_category()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddCategoryServiceBuilder::default()
-                        .db_store_id_exists(db2.clone())
-                        .db_category_name_exists_for_store(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_category()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateCategoryServiceBuilder::default()
-                        .db_store_id_exists(db2.clone())
-                        .db_category_name_exists_for_store(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, category_query): (
-            Arc<PostgresCqrs<Category>>,
-            Arc<dyn ViewRepository<CategoryView, Category>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-
-        let cmd = AddCategoryCommandBuilder::default()
-            .name(rand.get_random(10))
-            .description(None)
-            .store_id(*store.store_id())
-            .adding_by(UUID)
-            .category_id(UUID)
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.category_id().to_string(),
-            OrderingCommand::AddCategory(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let category = category_query
-            .load(&(*cmd.category_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let category: Category = category.into();
-        assert_eq!(category.name(), cmd.name());
-        assert_eq!(category.description(), cmd.description());
-        assert_eq!(category.category_id(), cmd.category_id());
-        assert_eq!(category.store_id(), cmd.store_id());
-        assert!(!store.deleted());
-
-        let update_category_cmd = UpdateCategoryCommand::new(
-            rand.get_random(10),
-            Some(rand.get_random(10)),
-            category,
-            UUID,
-        )
-        .unwrap();
-        cqrs.execute(
-            &cmd.category_id().to_string(),
-            OrderingCommand::UpdateCategory(update_category_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let category = category_query
-            .load(&(*cmd.category_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let category: Category = category.into();
-        assert_eq!(category.name(), update_category_cmd.name());
-        assert_eq!(category.description(), update_category_cmd.description());
-        assert_eq!(category.category_id(), cmd.category_id());
-        assert_eq!(category.store_id(), cmd.store_id());
-        assert!(!category.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/customization_view.rs

@@ -17,6 +17,11 @@ use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_CUSTOMIZATION_NON_UUID: &str = "ordering_new_customization_non_uuid-asdfa";
 
+//#[derive(Debug, Default, Serialize, Deserialize)]
+//struct Customizations {
+//    customizations: Vec<CustomizationView>,
+//}
+
 #[derive(Debug, Default, Serialize, Deserialize)]
 struct CustomizationView {
     name: String,
@@ -50,12 +55,6 @@ impl View<Customization> for CustomizationView {
 
                 self.deleted = false;
             }
-            OrderingEvent::CustomizationUpdated(val) => {
-                self.name = val.new_customization().name().into();
-                self.product_id = *val.new_customization().product_id();
-                self.customization_id = *val.new_customization().customization_id();
-            }
-
             _ => (),
         }
     }
@@ -182,10 +181,12 @@ impl ViewRepository<CustomizationView, Customization> for OrderingDBPostgresAdap
                     SET
                         version = $1,
                         name = $2,
-                        product_id = $3,
+                        customization_id = $3,
-                        deleted = $4;",
+                        product_id = $4,
+                        deleted = $5;",
                     version,
                     view.name,
+                    view.customization_id,
                     view.product_id,
                     view.deleted,
                 )
@@ -218,145 +219,3 @@ impl Query<Customization> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            adapters::output::db::product_id_exists::tests::create_dummy_product_record,
-            application::services::{
-                add_customization_service::*, update_customization_service::*,
-                MockOrderingServicesInterface,
-            },
-            domain::{
-                add_customization_command::*,
-                commands::OrderingCommand,
-                product_aggregate::Product,
-                update_customization_command::{tests::get_update_customization_command, *},
-            },
-        },
-        tests::bdd::*,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_customization_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-        let product = Product::default();
-        create_dummy_product_record(&product, &db).await;
-
-        //        let simple_query = super::store_view::SimpleLoggingQuery {};
-
-        let queries: Vec<Box<dyn Query<Customization>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let db2 = db.clone();
-        mock_services
-            .expect_add_customization()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddCustomizationServiceBuilder::default()
-                        .db_product_id_exists(Arc::new(db2.clone()))
-                        .db_customization_id_exists(Arc::new(db2.clone()))
-                        .db_customization_name_exists_for_product(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_customization()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateCustomizationServiceBuilder::default()
-                        .db_product_id_exists(db2.clone())
-                        .db_customization_name_exists_for_product(db2.clone())
-                        .db_customization_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, custmoization_query): (
-            Arc<PostgresCqrs<Customization>>,
-            Arc<dyn ViewRepository<CustomizationView, Customization>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-
-        let cmd = AddCustomizationCommandBuilder::default()
-            .name(rand.get_random(10))
-            .product_id(product.product_id().clone())
-            .customization_id(UUID.clone())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.customization_id().to_string(),
-            OrderingCommand::AddCustomization(cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let customization = custmoization_query
-            .load(&(*cmd.customization_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let customization: Customization = customization.into();
-        assert_eq!(customization.name(), cmd.name());
-        assert_eq!(customization.customization_id(), cmd.customization_id());
-        assert_eq!(customization.product_id(), cmd.product_id());
-        assert!(!customization.deleted());
-
-        let update_customization_command = UnvalidatedUpdateCustomizationCommandBuilder::default()
-            .name(rand.get_random(10))
-            .old_customization(customization.clone())
-            .adding_by(UUID.clone())
-            .build()
-            .unwrap()
-            .validate()
-            .unwrap();
-        cqrs.execute(
-            &cmd.customization_id().to_string(),
-            OrderingCommand::UpdateCustomization(update_customization_command.clone()),
-        )
-        .await
-        .unwrap();
-        let c = custmoization_query
-            .load(&(*cmd.customization_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let c: Customization = c.into();
-        assert_eq!(c.name(), update_customization_command.name());
-        assert_eq!(
-            update_customization_command.old_customization(),
-            &customization
-        );
-        assert!(!c.deleted());
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/kot_id_exists.rs

@@ -36,7 +36,7 @@ pub mod tests {
     //    use crate::ordering::domain::add_product_command::tests::get_customizations;
     use crate::ordering::domain::kot_aggregate::*;
 
-    pub async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) {
+    async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) {
         sqlx::query!(
             "INSERT INTO cqrs_ordering_kot_query (
                     version,

src/ordering/adapters/output/db/kot_view.rs

@@ -71,13 +71,6 @@ impl View<Kot> for KotView {
 
                 self.deleted = false;
             }
-            OrderingEvent::KotUpdated(val) => {
-                self.order_id = *val.new_kot().order_id();
-                self.kot_id = *val.new_kot().kot_id();
-
-                self.created_time = val.new_kot().created_time().clone();
-            }
-            OrderingEvent::KotDeleted(_) => self.deleted = true,
             _ => (),
         }
     }
@@ -197,10 +190,12 @@ impl ViewRepository<KotView, Kot> for OrderingDBPostgresAdapter {
                     SET
                         version = $1,
                         order_id = $2,
-                        created_time = $3,
+                        kot_id = $3,
-                        deleted = $4;",
+                        created_time = $4,
+                        deleted = $5;",
                     version,
                     view.order_id,
+                    view.kot_id,
                     view.created_time,
                     view.deleted,
                 )
@@ -228,182 +223,3 @@ impl Query<Kot> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-    use time::macros::datetime;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            application::services::{
-                add_kot_service::AddKotServiceBuilder, delete_kot_service::DeleteKotServiceBuilder,
-                update_kot_service::*, MockOrderingServicesInterface,
-            },
-            domain::{
-                add_kot_command::*, commands::OrderingCommand,
-                delete_kot_command::DeleteKotCommandBuilder, order_aggregate::Order,
-                update_kot_command::*,
-            },
-        },
-        tests::bdd::*,
-        utils::{
-            random_string::GenerateRandomStringInterface,
-            uuid::{tests::UUID, *},
-        },
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_kot_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let uuid = GenerateUUID {};
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-
-        let order = Order::default();
-        crate::ordering::adapters::output::db::order_id_exists::tests::create_dummy_order(
-            &order, &db,
-        )
-        .await;
-
-        let queries: Vec<Box<dyn Query<Kot>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let db2 = db.clone();
-        mock_services
-            .expect_add_kot()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddKotServiceBuilder::default()
-                        .db_kot_id_exists(Arc::new(db2.clone()))
-                        .db_order_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_update_kot()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateKotServiceBuilder::default()
-                        .db_kot_id_exists(Arc::new(db2.clone()))
-                        .db_order_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_delete_kot()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    DeleteKotServiceBuilder::default()
-                        .db_kot_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, kot_query): (
-            Arc<PostgresCqrs<Kot>>,
-            Arc<dyn ViewRepository<KotView, Kot>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let cmd = AddKotCommandBuilder::default()
-            .adding_by(UUID)
-            .created_time(datetime!(1970-01-01 0:00 UTC))
-            .order_id(*order.order_id())
-            .kot_id(uuid.get_uuid())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.kot_id().to_string(),
-            OrderingCommand::AddKot(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let kot = kot_query
-            .load(&(*cmd.kot_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let kot: Kot = kot.into();
-        assert_eq!(kot.order_id(), cmd.order_id());
-        assert_eq!(kot.kot_id(), cmd.kot_id());
-        assert!(!kot.deleted());
-
-        // update
-        let update_kot_cmd = UpdateKotCommandBuilder::default()
-            .adding_by(UUID)
-            .created_time(datetime!(1970-01-01 1:00 UTC))
-            .order_id(*order.order_id())
-            .old_kot(kot.clone())
-            .build()
-            .unwrap();
-        cqrs.execute(
-            &cmd.kot_id().to_string(),
-            OrderingCommand::UpdateKot(update_kot_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let kot = kot_query
-            .load(&(*cmd.kot_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let kot: Kot = kot.into();
-        assert_eq!(kot.order_id(), update_kot_cmd.order_id());
-        assert_eq!(kot.kot_id(), update_kot_cmd.old_kot().kot_id());
-        assert!(!kot.deleted());
-
-        // delete
-        let delete_kot_command = DeleteKotCommandBuilder::default()
-            .kot(kot.clone())
-            .adding_by(UUID)
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.kot_id().to_string(),
-            OrderingCommand::DeleteKot(delete_kot_command.clone()),
-        )
-        .await
-        .unwrap();
-        let kot = kot_query
-            .load(&(*cmd.kot_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let kot: Kot = kot.into();
-        assert_eq!(kot.order_id(), delete_kot_command.kot().order_id());
-        assert_eq!(kot.kot_id(), delete_kot_command.kot().kot_id());
-        assert!(kot.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/line_item_view.rs

@@ -112,21 +112,6 @@ impl View<LineItem> for LineItemView {
 
                 self.deleted = false;
             }
-            OrderingEvent::LineItemUpdated(val) => {
-                let new = val.new_line_item();
-                self.product_name = new.product_name().into();
-                self.product_id = *new.product_id();
-                self.line_item_id = *new.line_item_id();
-
-                self.quantity_major_number = *new.quantity().major().number() as i32;
-                self.quantity_minor_number = *new.quantity().minor().number() as i32;
-                self.quantity_major_unit = new.quantity().major().unit().to_string();
-                self.quantity_minor_unit = new.quantity().minor().unit().to_string();
-
-                self.created_time = new.created_time().clone();
-                self.kot_id = *new.kot_id();
-            }
-            OrderingEvent::LineItemDeleted(_) => self.deleted = true,
             _ => (),
         }
     }
@@ -271,16 +256,18 @@ impl ViewRepository<LineItemView, LineItem> for OrderingDBPostgresAdapter {
                         version = $1,
                         product_name = $2,
                         product_id = $3,
-                        quantity_minor_unit = $4,
+                        line_item_id = $4,
-                        quantity_minor_number = $5,
+                        quantity_minor_unit = $5,
-                        quantity_major_unit = $6,
+                        quantity_minor_number = $6,
-                        quantity_major_number = $7,
+                        quantity_major_unit = $7,
-                        created_time = $8,
+                        quantity_major_number = $8,
-                        kot_id = $9,
+                        created_time = $9,
-                        deleted = $10;",
+                        kot_id = $10,
+                        deleted = $11;",
                     version,
                     view.product_name,
                     view.product_id,
+                    view.line_item_id,
                     view.quantity_minor_unit,
                     view.quantity_minor_number,
                     view.quantity_major_unit,
@@ -318,211 +305,3 @@ impl Query<LineItem> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            application::services::{
-                add_line_item_service::AddLineItemServiceBuilder, delete_line_item_service::*,
-                update_line_item_service::*, MockOrderingServicesInterface,
-            },
-            domain::{
-                add_line_item_command::*, commands::OrderingCommand,
-                delete_line_item_command::DeleteLineItemCommandBuilder, kot_aggregate::Kot,
-                update_line_item_command::*,
-            },
-        },
-        tests::bdd::*,
-        types::quantity::*,
-        utils::{
-            random_string::GenerateRandomStringInterface,
-            uuid::{tests::UUID, *},
-        },
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_line_item_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-
-        let queries: Vec<Box<dyn Query<LineItem>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let kot = Kot::default();
-        crate::ordering::adapters::output::db::kot_id_exists::tests::create_dummy_kot(&kot, &db)
-            .await;
-
-        let db2 = db.clone();
-        mock_services
-            .expect_add_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .db_kot_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_update_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .db_kot_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = db.clone();
-        mock_services
-            .expect_delete_line_item()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    DeleteLineItemServiceBuilder::default()
-                        .db_line_item_id_exists(Arc::new(db2.clone()))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, line_item_query): (
-            Arc<PostgresCqrs<LineItem>>,
-            Arc<dyn ViewRepository<LineItemView, LineItem>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-        let uuid = GenerateUUID {};
-        let line_item_id = uuid.get_uuid();
-
-        let cmd = AddLineItemCommandBuilder::default()
-            .product_name(rand.get_random(10))
-            .adding_by(UUID)
-            .quantity(Quantity::get_quantity())
-            .product_id(UUID)
-            .kot_id(*kot.kot_id())
-            .line_item_id(line_item_id)
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            OrderingCommand::AddLineItem(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let line_item: LineItem = line_item.into();
-        assert_eq!(line_item.line_item_id(), cmd.line_item_id());
-        assert_eq!(line_item.product_name(), cmd.product_name());
-        assert_eq!(line_item.product_id(), cmd.product_id());
-        assert_eq!(line_item.quantity(), cmd.quantity());
-        assert!(!line_item.deleted());
-
-        let update_line_item_cmd = UnvalidatedUpdateLineItemCommandBuilder::default()
-            .product_name(rand.get_random(10))
-            .adding_by(UUID)
-            .quantity(Quantity::get_quantity())
-            .product_id(UUID)
-            .kot_id(*kot.kot_id())
-            .old_line_item(line_item.clone())
-            .build()
-            .unwrap()
-            .validate()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            OrderingCommand::UpdateLineItem(update_line_item_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let line_item: LineItem = line_item.into();
-        assert_eq!(
-            line_item.line_item_id(),
-            update_line_item_cmd.old_line_item().line_item_id()
-        );
-        assert_eq!(
-            line_item.product_name(),
-            update_line_item_cmd.product_name()
-        );
-        assert_eq!(line_item.product_id(), update_line_item_cmd.product_id());
-        assert_eq!(line_item.quantity(), update_line_item_cmd.quantity());
-        assert!(!line_item.deleted());
-
-        // delete
-        let delete_line_item_cmd = DeleteLineItemCommandBuilder::default()
-            .line_item(line_item.clone())
-            .adding_by(UUID)
-            .build()
-            .unwrap();
-        cqrs.execute(
-            &cmd.line_item_id().to_string(),
-            OrderingCommand::DeleteLineItem(delete_line_item_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let deleted_line_item = line_item_query
-            .load(&(*cmd.line_item_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let deleted_line_item: LineItem = deleted_line_item.into();
-        assert_eq!(
-            deleted_line_item.line_item_id(),
-            delete_line_item_cmd.line_item().line_item_id()
-        );
-        assert_eq!(
-            deleted_line_item.product_name(),
-            delete_line_item_cmd.line_item().product_name()
-        );
-        assert_eq!(
-            deleted_line_item.product_id(),
-            delete_line_item_cmd.line_item().product_id()
-        );
-        assert_eq!(
-            deleted_line_item.quantity(),
-            delete_line_item_cmd.line_item().quantity()
-        );
-        assert!(deleted_line_item.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/mod.rs

@@ -24,7 +24,6 @@ mod order_id_exists;
 mod order_view;
 mod product_id_exists;
 mod product_name_exists_for_category;
-mod product_view;
 mod store_id_exists;
 mod store_name_exists;
 mod store_view;

src/ordering/adapters/output/db/order_id_exists.rs

@@ -36,22 +36,20 @@ pub mod tests {
     //    use crate::ordering::domain::add_order_command::tests::get_customizations;
     use crate::ordering::domain::order_aggregate::*;
 
-    pub async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) {
+    async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) {
         sqlx::query!(
             "INSERT INTO cqrs_ordering_order_query (
                     version,
                     order_id,
-                    store_id,
                     customer_name,
                     created_time,
                     deleted
                 ) VALUES (
-                    $1, $2, $3, $4, $5, $6
+                    $1, $2, $3, $4, $5
                 );",
             1,
             order.order_id(),
-            order.store_id(),
+            order.customer_name(),
-            order.customer_name().as_ref().map(|s| s.as_str()),
             order.created_time(),
             order.deleted().clone(),
         )

src/ordering/adapters/output/db/order_view.rs

@@ -23,9 +23,8 @@ pub const NEW_ORDER_NON_UUID: &str = "new_order_non_uuid-asdfa";
 // be designed to reflect the response dto that will be returned to a user.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct OrderView {
-    customer_name: Option<String>,
+    customer_name: String,
     order_id: Uuid,
-    store_id: Uuid,
 
     created_time: OffsetDateTime,
     deleted: bool,
@@ -37,7 +36,6 @@ impl Default for OrderView {
             customer_name: Default::default(),
             order_id: Default::default(),
             created_time: OffsetDateTime::now_utc(),
-            store_id: Default::default(),
             deleted: false,
         }
     }
@@ -48,7 +46,6 @@ impl From<OrderView> for Order {
         OrderBuilder::default()
             .customer_name(v.customer_name)
             .order_id(v.order_id)
-            .store_id(v.store_id)
             .created_time(v.created_time)
             .deleted(v.deleted)
             .build()
@@ -63,22 +60,12 @@ impl View<Order> for OrderView {
     fn update(&mut self, event: &EventEnvelope<Order>) {
         match &event.payload {
             OrderingEvent::OrderAdded(val) => {
-                self.customer_name = val.order().customer_name().clone();
+                self.customer_name = val.order().customer_name().into();
                 self.order_id = *val.order().order_id();
                 self.created_time = val.order().created_time().clone();
-                self.store_id = *val.order().store_id();
 
                 self.deleted = false;
             }
-            OrderingEvent::OrderUpdated(e) => {
-                let new = e.new_order();
-                self.customer_name = new.customer_name().clone();
-                self.order_id = *new.order_id();
-                self.store_id = *new.store_id();
-                self.created_time = new.created_time().clone();
-            }
-            OrderingEvent::OrderDeleted(_) => self.deleted = true,
-
             _ => (),
         }
     }
@@ -98,7 +85,6 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
                 customer_name,
                 order_id,
                 created_time,
-                store_id,
                 deleted
              FROM
                 cqrs_ordering_order_query
@@ -128,7 +114,6 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
                 customer_name,
                 order_id,
                 created_time,
-                store_id,
                 deleted
              FROM
                 cqrs_ordering_order_query
@@ -177,17 +162,15 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
                         customer_name,
                         order_id,
                         created_time,
-                        store_id,
                         deleted
 
                     ) VALUES (
-                        $1, $2, $3, $4, $5, $6
+                        $1, $2, $3, $4, $5
                     );",
                     version,
                     view.customer_name,
                     view.order_id,
                     view.created_time,
-                    view.store_id,
                     view.deleted,
                 )
                 .execute(&self.pool)
@@ -203,13 +186,13 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
                     SET
                         version = $1,
                         customer_name = $2,
-                        created_time = $3,
+                        order_id = $3,
-                        store_id=  $4,
+                        created_time = $4,
                         deleted = $5;",
                     version,
                     view.customer_name,
+                    view.order_id,
                     view.created_time,
-                    view.store_id,
                     view.deleted,
                 )
                 .execute(&self.pool)
@@ -236,187 +219,3 @@ impl Query<Order> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-    use time::macros::datetime;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            application::services::{
-                add_order_service::*, delete_order_service::DeleteOrderServiceBuilder,
-                update_order_service::*, MockOrderingServicesInterface,
-            },
-            domain::{
-                add_order_command::*, commands::*, delete_order_command::DeleteOrderCommandBuilder,
-                events::*, order_aggregate::*, store_aggregate::*, update_order_command::*,
-            },
-        },
-        tests::bdd::*,
-        utils::{
-            random_string::GenerateRandomStringInterface,
-            uuid::{tests::UUID, *},
-        },
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_order_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-
-        let store = Store::default();
-        crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
-            &store, &db,
-        )
-        .await;
-
-        let queries: Vec<Box<dyn Query<Order>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_add_order()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddOrderServiceBuilder::default()
-                        .db_order_id_exists(db2.clone())
-                        .db_store_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_order()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateOrderServiceBuilder::default()
-                        .db_order_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_delete_order()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    DeleteOrderServiceBuilder::default()
-                        .db_order_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, order_query): (
-            Arc<PostgresCqrs<Order>>,
-            Arc<dyn ViewRepository<OrderView, Order>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let rand = crate::utils::random_string::GenerateRandomString {};
-        let uuid = GenerateUUID {};
-
-        let cmd = AddOrderCommandBuilder::default()
-            .customer_name(None)
-            .adding_by(UUID)
-            .created_time(datetime!(1970-01-01 0:00 UTC))
-            .store_id(*store.store_id())
-            .order_id(uuid.get_uuid())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.order_id().to_string(),
-            OrderingCommand::AddOrder(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let order = order_query
-            .load(&(*cmd.order_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let order: Order = order.into();
-        assert_eq!(order.customer_name(), cmd.customer_name());
-        assert_eq!(order.store_id(), cmd.store_id());
-        assert_eq!(order.order_id(), cmd.order_id());
-        assert!(!order.deleted());
-
-        // update
-        let update_order_cmd = UpdateOrderCommandBuilder::default()
-            .customer_name(Some(rand.get_random(10)))
-            .adding_by(UUID)
-            .created_time(datetime!(1970-01-01 0:00 UTC))
-            .old_order(order.clone())
-            .build()
-            .unwrap();
-
-        cqrs.execute(
-            &cmd.order_id().to_string(),
-            OrderingCommand::UpdateOrder(update_order_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let order = order_query
-            .load(&(*cmd.order_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let order: Order = order.into();
-        assert_eq!(order.customer_name(), update_order_cmd.customer_name());
-        assert_eq!(order.store_id(), update_order_cmd.old_order().store_id());
-        assert_eq!(order.order_id(), update_order_cmd.old_order().order_id());
-        assert!(!order.deleted());
-
-        let delete_order_cmd = DeleteOrderCommandBuilder::default()
-            .adding_by(UUID)
-            .order(order.clone())
-            .build()
-            .unwrap();
-        cqrs.execute(
-            &cmd.order_id().to_string(),
-            OrderingCommand::DeleteOrder(delete_order_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let order = order_query
-            .load(&(*cmd.order_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let order: Order = order.into();
-        assert_eq!(
-            order.customer_name(),
-            delete_order_cmd.order().customer_name()
-        );
-        assert_eq!(order.store_id(), delete_order_cmd.order().store_id());
-        assert_eq!(order.order_id(), delete_order_cmd.order().order_id());
-        assert!(order.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/product_id_exists.rs

@@ -95,8 +95,8 @@ pub mod tests {
                 );",
             1,
             p.name(),
-            p.description().as_ref().map(|s| s.as_str()),
+            p.description().as_ref().unwrap(),
-            p.image().as_ref().map(|s| s.as_str()),
+            p.image().as_ref().unwrap(),
             p.product_id(),
             p.category_id(),
             p.price().major().clone() as i32,

src/ordering/adapters/output/db/product_view.rs

@@ -11,14 +11,14 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use super::errors::*;
-use super::OrderingDBPostgresAdapter;
+use super::InventoryDBPostgresAdapter;
-use crate::ordering::domain::events::OrderingEvent;
+use crate::inventory::domain::events::InventoryEvent;
-use crate::ordering::domain::product_aggregate::{Product, ProductBuilder};
+use crate::inventory::domain::product_aggregate::{Product, ProductBuilder};
 use crate::types::currency::*;
 use crate::types::quantity::*;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
-pub const NEW_PRODUCT_NON_UUID: &str = "new_product_ordering_non_uuid-asdfa";
+pub const NEW_PRODUCT_NON_UUID: &str = "new_product_non_uuid-asdfa";
 
 // The view for a Product query, for a standard http application this should
 // be designed to reflect the response dto that will be returned to a user.
@@ -92,7 +92,7 @@ impl From<ProductView> for Product {
 impl View<Product> for ProductView {
     fn update(&mut self, event: &EventEnvelope<Product>) {
         match &event.payload {
-            OrderingEvent::ProductAdded(val) => {
+            InventoryEvent::ProductAdded(val) => {
                 self.name = val.name().into();
                 self.description = val.description().clone();
                 self.image = val.image().clone();
@@ -112,32 +112,13 @@ impl View<Product> for ProductView {
 
                 self.deleted = false;
             }
-            OrderingEvent::ProductUpdated(e) => {
-                let val = e.new_product();
-                self.name = val.name().into();
-                self.description = val.description().clone();
-                self.image = val.image().clone();
-                self.product_id = *val.product_id();
-                self.category_id = *val.category_id();
-
-                self.sku_able = *val.sku_able();
-
-                self.price_minor = *val.price().minor() as i32;
-                self.price_major = *val.price().major() as i32;
-                self.price_currency = val.price().currency().to_string();
-
-                self.quantity_major_number = *val.quantity().major().number() as i32;
-                self.quantity_minor_number = *val.quantity().minor().number() as i32;
-                self.quantity_major_unit = val.quantity().major().unit().to_string();
-                self.quantity_minor_unit = val.quantity().minor().unit().to_string();
-            }
             _ => (),
         }
     }
 }
 
 #[async_trait]
-impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
+impl ViewRepository<ProductView, Product> for InventoryDBPostgresAdapter {
     async fn load(&self, product_id: &str) -> Result<Option<ProductView>, PersistenceError> {
         let product_id = match parse_aggregate_id(product_id, NEW_PRODUCT_NON_UUID)? {
             Some((val, _)) => return Ok(Some(val)),
@@ -162,7 +143,7 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
                 quantity_major_number,
                 deleted
              FROM
-                cqrs_ordering_product_query
+                cqrs_inventory_product_query
             WHERE
                 product_id = $1;",
             product_id
@@ -201,7 +182,7 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
                 quantity_major_number,
                 deleted
              FROM
-                cqrs_ordering_product_query
+                cqrs_inventory_product_query
             WHERE
                 product_id = $1;",
             product_id
@@ -220,7 +201,7 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
             "SELECT 
                 product_id, version
              FROM
-                cqrs_ordering_product_query
+                cqrs_inventory_product_query
             WHERE
                 product_id = $1;",
             product_id
@@ -242,7 +223,7 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
             0 => {
                 let version = context.version + 1;
                 sqlx::query!(
-                    "INSERT INTO cqrs_ordering_product_query (
+                    "INSERT INTO cqrs_inventory_product_query (
                         version,
                         name,
                         description,
@@ -287,26 +268,28 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
                 let version = context.version + 1;
                 sqlx::query!(
                     "UPDATE
-                        cqrs_ordering_product_query
+                        cqrs_inventory_product_query
                     SET
                         version = $1,
                         name = $2,
                         description = $3,
                         image = $4,
-                        category_id = $5,
+                        product_id = $5,
-                        price_major = $6,
+                        category_id = $6,
-                        price_minor = $7,
+                        price_major = $7,
-                        price_currency = $8,
+                        price_minor = $8,
-                        sku_able = $9,
+                        price_currency = $9,
-                        quantity_minor_unit = $10,
+                        sku_able = $10,
-                        quantity_minor_number = $11,
+                        quantity_minor_unit = $11,
-                        quantity_major_unit = $12,
+                        quantity_minor_number = $12,
-                        quantity_major_number = $13,
+                        quantity_major_unit = $13,
-                        deleted = $14;",
+                        quantity_major_number = $14,
+                        deleted = $15;",
                     version,
                     view.name,
                     view.description,
                     view.image,
+                    view.product_id,
                     view.category_id,
                     view.price_major,
                     view.price_minor,
@@ -329,7 +312,7 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
 }
 
 #[async_trait]
-impl Query<Product> for OrderingDBPostgresAdapter {
+impl Query<Product> for InventoryDBPostgresAdapter {
     async fn dispatch(&self, product_id: &str, events: &[EventEnvelope<Product>]) {
         let res = self
             .load_with_context(product_id)
@@ -347,154 +330,3 @@ impl Query<Product> for OrderingDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use postgres_es::PostgresCqrs;
-
-    use crate::{
-        db::migrate::*,
-        ordering::{
-            application::{
-                port::output::full_text_search::add_product_to_store::*,
-                services::{
-                    add_product_service::*, update_product_service::*,
-                    MockOrderingServicesInterface,
-                },
-            },
-            domain::{
-                add_product_command::tests::get_command, category_aggregate::*, commands::*,
-                product_aggregate::*, store_aggregate::*,
-                update_product_command::tests::get_command_with_product,
-            },
-        },
-        tests::bdd::*,
-        utils::uuid::tests::UUID,
-    };
-    use std::sync::Arc;
-
-    #[actix_rt::test]
-    async fn pg_query_ordering_product_view() {
-        let settings = crate::settings::tests::get_settings().await;
-        //let settings = crate::settings::Settings::new().unwrap();
-        settings.create_db().await;
-
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        db.migrate().await;
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-
-        let store = Store::default();
-        crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
-            &store, &db,
-        )
-        .await;
-        let category = CategoryBuilder::default()
-            .name("fooooo_cat".into())
-            .description(None)
-            .store_id(*store.store_id())
-            .category_id(UUID)
-            .build()
-            .unwrap();
-        crate::ordering::adapters::output::db::category_name_exists_for_store::tests::create_dummy_category_record(&category, &db).await;
-
-        let queries: Vec<Box<dyn Query<Product>>> = vec![Box::new(db.clone())];
-
-        let mut mock_services = MockOrderingServicesInterface::new();
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_add_product()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    AddProductServiceBuilder::default()
-                        .db_product_name_exists_for_category(db2.clone())
-                        .db_product_id_exists(db2.clone())
-                        .db_get_category(db2.clone())
-                        .db_category_id_exists(db2.clone())
-                        .fts_add_product(mock_add_product_to_store_fts_port(IGNORE_CALL_COUNT))
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let db2 = Arc::new(db.clone());
-        mock_services
-            .expect_update_product()
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
-            .returning(move || {
-                Arc::new(
-                    UpdateProductServiceBuilder::default()
-                        .db_category_id_exists(db2.clone())
-                        .db_product_name_exists_for_category(db2.clone())
-                        .db_product_id_exists(db2.clone())
-                        .build()
-                        .unwrap(),
-                )
-            });
-
-        let (cqrs, product_query): (
-            Arc<PostgresCqrs<Product>>,
-            Arc<dyn ViewRepository<ProductView, Product>>,
-        ) = (
-            Arc::new(postgres_es::postgres_cqrs(
-                db.pool.clone(),
-                queries,
-                Arc::new(mock_services),
-            )),
-            Arc::new(db.clone()),
-        );
-
-        let cmd = get_command();
-        cqrs.execute(
-            &cmd.product_id().to_string(),
-            OrderingCommand::AddProduct(cmd.clone()),
-        )
-        .await
-        .unwrap();
-
-        let product = product_query
-            .load(&(*cmd.product_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let product: Product = product.into();
-        assert_eq!(product.name(), cmd.name());
-        assert_eq!(product.description(), cmd.description());
-        assert_eq!(product.image(), cmd.image());
-        assert_eq!(product.product_id(), cmd.product_id());
-        assert_eq!(product.quantity(), cmd.quantity());
-        assert_eq!(product.sku_able(), cmd.sku_able());
-        assert_eq!(product.price(), cmd.price());
-        assert!(!product.deleted());
-
-        let update_product_cmd = get_command_with_product(product.clone());
-        cqrs.execute(
-            &cmd.product_id().to_string(),
-            OrderingCommand::UpdateProduct(update_product_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let product = product_query
-            .load(&(*cmd.product_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let product: Product = product.into();
-        assert_eq!(product.name(), update_product_cmd.name());
-        assert_eq!(product.description(), update_product_cmd.description());
-        assert_eq!(product.image(), update_product_cmd.image());
-        assert_eq!(
-            product.product_id(),
-            update_product_cmd.old_product().product_id()
-        );
-        assert_eq!(product.quantity(), update_product_cmd.quantity());
-        assert_eq!(product.sku_able(), update_product_cmd.sku_able());
-        assert_eq!(product.price(), update_product_cmd.price());
-        assert!(!product.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/adapters/output/db/store_id_exists.rs

@@ -45,7 +45,7 @@ pub mod tests {
             VALUES ($1, $2, $3, $4, $5 ,$6);",
             1,
             s.name(),
-            s.address().as_ref().map(|s| s.as_str()),
+            s.address().as_ref().unwrap(),
             s.store_id(),
             s.owner(),
             false

src/ordering/adapters/output/db/store_view.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 use super::errors::*;
 use super::OrderingDBPostgresAdapter;
 use crate::ordering::domain::events::OrderingEvent;
-use crate::ordering::domain::store_aggregate::*;
+use crate::ordering::domain::store_aggregate::Store;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_STORE_NON_UUID: &str = "ordering_new_store_non_uuid-asdfa";
@@ -27,41 +27,18 @@ pub struct StoreView {
     deleted: bool,
 }
 
-impl From<StoreView> for Store {
-    fn from(value: StoreView) -> Self {
-        StoreBuilder::default()
-            .name(value.name)
-            .address(value.address)
-            .store_id(value.store_id)
-            .owner(value.owner)
-            .deleted(value.deleted)
-            .build()
-            .unwrap()
-    }
-}
-
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
 impl View<Store> for StoreView {
     fn update(&mut self, event: &EventEnvelope<Store>) {
-        match &event.payload {
+        if let OrderingEvent::StoreAdded(val) = &event.payload {
-            OrderingEvent::StoreAdded(val) => {
             self.name = val.name().into();
             self.address = val.address().clone();
             self.store_id = *val.store_id();
             self.owner = *val.owner();
             self.deleted = false;
         }
-            OrderingEvent::StoreUpdated(e) => {
-                let val = e.new_store();
-                self.name = val.name().into();
-                self.address = val.address().clone();
-                self.store_id = *val.store_id();
-                self.owner = *val.owner();
-            }
-            _ => (),
-        }
     }
 }
 
@@ -169,11 +146,13 @@ impl ViewRepository<StoreView, Store> for OrderingDBPostgresAdapter {
                         version = $1,
                         name = $2,
                         address = $3,
-                        owner = $4,
+                        store_id = $4,
-                        deleted = $5;",
+                        owner = $5,
+                        deleted = $6;",
                     version,
                     view.name,
                     view.address,
+                    view.store_id,
                     view.owner,
                     view.deleted,
                 )
@@ -216,138 +195,108 @@ impl Query<Store> for OrderingDBPostgresAdapter {
     }
 }
 
-#[cfg(test)]
+// Our second query, this one will be handled with Postgres `GenericQuery`
-mod tests {
+// which will serialize and persist our view after it is updated. It also
-    use super::*;
+// provides a `load` method to deserialize the view on request.
+//pub type StoreQuery = GenericQuery<OrderingDBPostgresAdapter, StoreView, Store>;
+//pub type StoreQuery = Query<dyn OrderingDBPostgresAdapter, StoreView, Store>;
 
-    use postgres_es::PostgresCqrs;
+//#[cfg(test)]
-
+//mod tests {
-    use crate::{
+//    use super::*;
-        db::migrate::*,
+//
-        ordering::{
+//    use postgres_es::PostgresCqrs;
-            application::services::{
+//
-                add_store_service::AddStoreServiceBuilder, update_store_service::*,
+//    use crate::{
-                MockOrderingServicesInterface,
+//        db::migrate::*,
-            },
+//        ordering::{
-            domain::add_store_command::*,
+//            application::services::{
-            domain::commands::OrderingCommand,
+//                add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_store_service::AddStoreServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_store_service::tests::mock_update_store_service, OrderingServicesBuilder
-            domain::update_store_command::*,
+//            },
-        },
+//            domain::{
-        tests::bdd::*,
+//                add_category_command::AddCategoryCommand, add_customization_command,
-        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
+//                add_product_command::tests::get_command, add_store_command::AddStoreCommand,
-    };
+//                commands::OrderingCommand,
-    use std::sync::Arc;
+//                update_category_command::tests::get_update_category_command,
-
+//                update_customization_command::tests::get_update_customization_command,
-    #[actix_rt::test]
+//                update_product_command, update_store_command::tests::get_update_store_cmd,
-    async fn pg_query_ordering_store_view() {
+//            },
-        let settings = crate::settings::tests::get_settings().await;
+//        },
-        //let settings = crate::settings::Settings::new().unwrap();
+//        tests::bdd::IS_NEVER_CALLED,
-        settings.create_db().await;
+//        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
-
+//    };
-        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
+//    use std::sync::Arc;
-        db.migrate().await;
+//
-        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
+//    #[actix_rt::test]
-
+//    async fn pg_query() {
-        let simple_query = SimpleLoggingQuery {};
+//        let settings = crate::settings::tests::get_settings().await;
-
+//        //let settings = crate::settings::Settings::new().unwrap();
-        let queries: Vec<Box<dyn Query<Store>>> =
+//        settings.create_db().await;
-            vec![Box::new(simple_query), Box::new(db.clone())];
+//
-
+//        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
-        let mut mock_services = MockOrderingServicesInterface::new();
+//        db.migrate().await;
-
+//        let db = OrderingDBPostgresAdapter::new(db.pool.clone());
-        let db2 = db.clone();
+//
-        mock_services
+//        let simple_query = SimpleLoggingQuery {};
-            .expect_add_store()
+//
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//        let queries: Vec<Box<dyn Query<Store>>> =
-            .returning(move || {
+//            vec![Box::new(simple_query), Box::new(db.clone())];
-                Arc::new(
+//
-                    AddStoreServiceBuilder::default()
+//        let services = OrderingServicesBuilder::default()
-                        .db_store_id_exists(Arc::new(db2.clone()))
+//            .add_store(Arc::new(
-                        .db_store_name_exists(Arc::new(db2.clone()))
+//                AddStoreServiceBuilder::default()
-                        .build()
+//                    .db_store_id_exists(Arc::new(db.clone()))
-                        .unwrap(),
+//                    .db_store_name_exists(Arc::new(db.clone()))
-                )
+//                    .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
-            });
+//                    .build()
-
+//                    .unwrap(),
-        let db2 = db.clone();
+//            ))
-        mock_services
+//            .add_category(mock_add_category_service(
-            .expect_update_store()
+//                IS_NEVER_CALLED,
-            .times(IS_CALLED_ONLY_ONCE.unwrap())
+//                AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
-            .returning(move || {
+//            ))
-                Arc::new(
+//            .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
-                    UpdateStoreServiceBuilder::default()
+//            .add_customization(mock_add_customization_service(
-                        .db_store_id_exists(Arc::new(db2.clone()))
+//                IS_NEVER_CALLED,
-                        .db_store_name_exists(Arc::new(db2.clone()))
+//                add_customization_command::tests::get_command(),
-                        .build()
+//            ))
-                        .unwrap(),
+//            .update_product(mock_update_product_service(
-                )
+//                IS_NEVER_CALLED,
-            });
+//                update_product_command::tests::get_command(),
-
+//            ))
-        let (cqrs, store_query): (
+//            .update_customization(mock_update_customization_service(
-            Arc<PostgresCqrs<Store>>,
+//                IS_NEVER_CALLED,
-            Arc<dyn ViewRepository<StoreView, Store>>,
+//                get_update_customization_command(),
-        ) = (
+//            ))
-            Arc::new(postgres_es::postgres_cqrs(
+//            .update_category(mock_update_category_service(
-                db.pool.clone(),
+//                IS_NEVER_CALLED,
-                queries,
+//                get_update_category_command(),
-                Arc::new(mock_services),
+//            ))
-            )),
+//            .update_store(mock_update_store_service(
-            Arc::new(db.clone()),
+//                IS_NEVER_CALLED,
-        );
+//                get_update_store_cmd(),
-
+//            ))
-        let rand = crate::utils::random_string::GenerateRandomString {};
+//            .build()
-        let cmd = AddStoreCommandBuilder::default()
+//            .unwrap();
-            .name(rand.get_random(10))
+//
-            .address(None)
+//        let (cqrs, _store_query): (
-            .owner(UUID)
+//            Arc<PostgresCqrs<Store>>,
-            .store_id(UUID)
+//            Arc<dyn ViewRepository<StoreView, Store>>,
-            .build()
+//        ) = (
-            .unwrap();
+//            Arc::new(postgres_es::postgres_cqrs(
-        cqrs.execute(
+//                db.pool.clone(),
-            &cmd.store_id().to_string(),
+//                queries,
-            OrderingCommand::AddStore(cmd.clone()),
+//                Arc::new(services),
-        )
+//            )),
-        .await
+//            Arc::new(db.clone()),
-        .unwrap();
+//        );
-
+//
-        let store = store_query
+//        let rand = crate::utils::random_string::GenerateRandomString {};
-            .load(&(*cmd.store_id()).to_string())
+//        let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap();
-            .await
+//        cqrs.execute("", OrderingCommand::AddStore(cmd.clone()))
-            .unwrap()
+//            .await
-            .unwrap();
+//            .unwrap();
-        let store: Store = store.into();
+//
-        assert_eq!(store.name(), cmd.name());
+//        settings.drop_db().await;
-        assert_eq!(store.address(), cmd.address());
+//    }
-        assert_eq!(store.owner(), cmd.owner());
+//}
-        assert_eq!(store.store_id(), cmd.store_id());
-        assert!(!store.deleted());
-
-        let update_store_cmd = UpdateStoreCommand::new(
-            rand.get_random(10),
-            Some(rand.get_random(10)),
-            UUID,
-            store,
-            UUID,
-        )
-        .unwrap();
-        cqrs.execute(
-            &cmd.store_id().to_string(),
-            OrderingCommand::UpdateStore(update_store_cmd.clone()),
-        )
-        .await
-        .unwrap();
-        let store = store_query
-            .load(&(*cmd.store_id()).to_string())
-            .await
-            .unwrap()
-            .unwrap();
-        let store: Store = store.into();
-        assert_eq!(store.name(), update_store_cmd.name());
-        assert_eq!(store.address(), update_store_cmd.address());
-        assert_eq!(store.owner(), update_store_cmd.owner());
-        assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
-        assert!(!store.deleted());
-
-        settings.drop_db().await;
-    }
-}

src/ordering/application/services/add_category_service.rs

@@ -19,6 +19,7 @@ use crate::ordering::{
         category_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -33,6 +34,7 @@ pub struct AddCategoryService {
     db_store_id_exists: StoreIDExistsDBPortObj,
     db_category_name_exists_for_store: CategoryNameExistsForStoreDBPortObj,
     db_category_id_exists: CategoryIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -46,19 +48,27 @@ impl AddCategoryUseCase for AddCategoryService {
             return Err(OrderingError::StoreIDNotFound);
         }
 
+        let mut category_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_category_id_exists
-            .category_id_exists(cmd.category_id())
+                .category_id_exists(&category_id)
                 .await?
             {
-            return Err(OrderingError::DuplicateCategoryID);
+                category_id = self.get_uuid.get_uuid();
+
+                continue;
+            } else {
+                break;
+            }
         }
 
         let category = CategoryBuilder::default()
             .name(cmd.name().into())
             .description(cmd.description().as_ref().map(|s| s.to_string()))
             .store_id(*cmd.store_id())
-            .category_id(*cmd.category_id())
+            .category_id(category_id)
             .build()
             .unwrap();
 
@@ -87,9 +97,8 @@ pub mod tests {
 
     use uuid::Uuid;
 
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
-
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
-    use crate::ordering::domain::add_category_command::tests::get_add_category_cmd;
 
     pub fn mock_add_category_service(
         times: Option<usize>,
@@ -102,7 +111,7 @@ pub mod tests {
             .description(cmd.description().as_ref().map(|s| s.to_string()))
             .added_by_user(*cmd.adding_by())
             .store_id(*cmd.store_id())
-            .category_id(*cmd.category_id())
+            .category_id(UUID)
             .build()
             .unwrap();
 
@@ -119,7 +128,14 @@ pub mod tests {
 
     #[actix_rt::test]
     async fn test_service_category_doesnt_exist() {
-        let cmd = get_add_category_cmd();
+        let name = "foo";
+        let description = "bar";
+        let user_id = UUID;
+        let store_id = Uuid::new_v4();
+
+        // description = None
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
+            .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
@@ -127,6 +143,7 @@ pub mod tests {
                 IS_CALLED_ONLY_ONCE,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -135,12 +152,19 @@ pub mod tests {
         assert_eq!(res.description(), cmd.description());
         assert_eq!(res.added_by_user(), cmd.adding_by());
         assert_eq!(res.store_id(), cmd.store_id());
-        assert_eq!(res.category_id(), cmd.category_id());
+        assert_eq!(res.category_id(), &UUID);
     }
 
     #[actix_rt::test]
     async fn test_service_category_name_exists_for_store() {
-        let cmd = get_add_category_cmd();
+        let name = "foo";
+        let description = "bar";
+        let user_id = UUID;
+        let store_id = Uuid::new_v4();
+
+        // description = None
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
+            .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
@@ -148,6 +172,7 @@ pub mod tests {
                 IS_CALLED_ONLY_ONCE,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -159,7 +184,14 @@ pub mod tests {
 
     #[actix_rt::test]
     async fn test_service_store_doesnt_exist() {
-        let cmd = get_add_category_cmd();
+        let name = "foo";
+        let description = "bar";
+        let user_id = UUID;
+        let store_id = Uuid::new_v4();
+
+        // description = None
+        let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
+            .unwrap();
 
         let s = AddCategoryServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
@@ -167,6 +199,7 @@ pub mod tests {
                 IS_NEVER_CALLED,
             ))
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_NEVER_CALLED))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/ordering/application/services/add_customization_service.rs

@@ -11,12 +11,20 @@ use mockall::*;
 use super::errors::*;
 use crate::ordering::{
     application::port::output::db::{
-        customization_id_exists::*, customization_name_exists_for_product::*, product_id_exists::*,
+        customization_id_exists::{self, *},
+        customization_name_exists_for_product::*,
+        product_id_exists::{self, *},
+        product_name_exists_for_category::*,
     },
     domain::{
-        add_customization_command::*, customization_added_event::*, customization_aggregate::*,
+        add_customization_command::AddCustomizationCommand,
+        customization_added_event::{self, *},
+        customization_aggregate::*,
+        product_added_event::{self, ProductAddedEvent, ProductAddedEventBuilder},
+        product_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -34,6 +42,7 @@ pub struct AddCustomizationService {
     db_product_id_exists: ProductIDExistsDBPortObj,
     db_customization_id_exists: CustomizationIDExistsDBPortObj,
     db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -50,19 +59,25 @@ impl AddCustomizationUseCase for AddCustomizationService {
             return Err(OrderingError::ProductIDNotFound);
         }
 
+        let mut customization_id = self.get_uuid.get_uuid();
+        loop {
             if self
                 .db_customization_id_exists
-            .customization_id_exists(cmd.customization_id())
+                .customization_id_exists(&customization_id)
                 .await?
             {
-            return Err(OrderingError::DuplicateCustomizationID);
+                customization_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let customization = CustomizationBuilder::default()
             .name(cmd.name().into())
             .deleted(false)
             .product_id(*cmd.product_id())
-            .customization_id(*cmd.customization_id())
+            .customization_id(customization_id)
             .build()
             .unwrap();
 
@@ -85,10 +100,12 @@ impl AddCustomizationUseCase for AddCustomizationService {
 pub mod tests {
     use super::*;
 
-    use crate::ordering::domain::{
+    use customization_added_event::tests::get_customization_added_event_from_cmd;
-        add_customization_command::tests::*, customization_added_event::tests::*,
+    use uuid::Uuid;
-    };
+
-    use crate::tests::bdd::*;
+    use crate::ordering::domain::add_customization_command::tests::get_command;
+    use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_customization_service(
         times: Option<usize>,
@@ -121,15 +138,13 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE),
             )
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
         let res = s.add_customization(cmd.clone()).await.unwrap();
         assert_eq!(res.customization().name(), cmd.name());
-        assert_eq!(
+        //        assert_eq!(customization_added_events.len(), cmd.customizations().len());
-            res.customization().customization_id(),
-            cmd.customization_id()
-        );
     }
 
     #[actix_rt::test]
@@ -144,6 +159,7 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE),
             )
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -163,6 +179,7 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED),
             )
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/ordering/application/services/add_kot_service.rs

@@ -7,6 +7,7 @@ use std::sync::Arc;
 use derive_builder::Builder;
 use mockall::predicate::*;
 use mockall::*;
+use time::OffsetDateTime;
 
 use super::errors::*;
 use crate::ordering::{
@@ -14,6 +15,7 @@ use crate::ordering::{
     application::port::output::db::order_id_exists::*,
     domain::{add_kot_command::*, kot_added_event::*, kot_aggregate::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -27,6 +29,7 @@ pub type AddKotServiceObj = Arc<dyn AddKotUseCase>;
 pub struct AddKotService {
     db_kot_id_exists: KotIDExistsDBPortObj,
     db_order_id_exists: OrderIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -40,14 +43,21 @@ impl AddKotUseCase for AddKotService {
             return Err(OrderingError::OrderIDNotFound);
         }
 
-        if self.db_kot_id_exists.kot_id_exists(cmd.kot_id()).await? {
+        let mut kot_id = self.get_uuid.get_uuid();
-            return Err(OrderingError::KotIDNotFound);
+
+        loop {
+            if self.db_kot_id_exists.kot_id_exists(&kot_id).await? {
+                kot_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let kot = KotBuilder::default()
             .created_time(cmd.created_time().clone())
             .order_id(*cmd.order_id())
-            .kot_id(*cmd.kot_id())
+            .kot_id(kot_id)
             .deleted(false)
             .build()
             .unwrap();
@@ -65,8 +75,8 @@ pub mod tests {
     use super::*;
 
     use crate::ordering::domain::kot_added_event::tests::get_added_kot_event_from_command;
-    use crate::tests::bdd::*;
     use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_kot_service(times: Option<usize>, cmd: AddKotCommand) -> AddKotServiceObj {
         let mut m = MockAddKotUseCase::new();
@@ -90,6 +100,7 @@ pub mod tests {
         let s = AddKotServiceBuilder::default()
             .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_order_id_exists(mock_order_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -107,6 +118,7 @@ pub mod tests {
         let s = AddKotServiceBuilder::default()
             .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_NEVER_CALLED))
             .db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/ordering/application/services/add_line_item_service.rs

@@ -15,6 +15,7 @@ use crate::ordering::{
     application::port::output::db::line_item_id_exists::*,
     domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -28,6 +29,7 @@ pub type AddLineItemServiceObj = Arc<dyn AddLineItemUseCase>;
 pub struct AddLineItemService {
     db_line_item_id_exists: LineItemIDExistsDBPortObj,
     db_kot_id_exists: KotIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -37,12 +39,19 @@ impl AddLineItemUseCase for AddLineItemService {
             return Err(OrderingError::KotIDNotFound);
         }
 
+        let mut line_item_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_line_item_id_exists
-            .line_item_id_exists(cmd.line_item_id())
+                .line_item_id_exists(&line_item_id)
                 .await?
             {
-            return Err(OrderingError::DuplicateLineItemID);
+                line_item_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let line_item = LineItemBuilder::default()
@@ -50,7 +59,7 @@ impl AddLineItemUseCase for AddLineItemService {
             .product_name(cmd.product_name().into())
             .product_id(*cmd.product_id())
             .kot_id(*cmd.kot_id())
-            .line_item_id(*cmd.line_item_id())
+            .line_item_id(line_item_id)
             .quantity(cmd.quantity().clone())
             .deleted(false)
             .build()
@@ -69,8 +78,8 @@ pub mod tests {
     use super::*;
 
     use crate::ordering::domain::line_item_added_event::tests::get_added_line_item_event_from_command;
-    use crate::tests::bdd::*;
     use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_line_item_service(
         times: Option<usize>,
@@ -97,6 +106,7 @@ pub mod tests {
         let s = AddLineItemServiceBuilder::default()
             .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_kot_id_exists(mock_kot_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -107,7 +117,6 @@ pub mod tests {
         assert_eq!(res.line_item().quantity(), cmd.quantity());
         assert_eq!(res.line_item().quantity(), cmd.quantity());
         assert_eq!(res.line_item().created_time(), cmd.created_time());
-        assert_eq!(res.line_item().line_item_id(), cmd.line_item_id());
         assert!(!res.line_item().deleted());
         assert_eq!(res.added_by_user(), cmd.adding_by());
     }
@@ -119,6 +128,7 @@ pub mod tests {
         let s = AddLineItemServiceBuilder::default()
             .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED))
             .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/ordering/application/services/add_order_service.rs

@@ -11,9 +11,10 @@ use time::OffsetDateTime;
 
 use super::errors::*;
 use crate::ordering::{
-    application::port::output::db::{order_id_exists::*, store_id_exists::*},
+    application::port::output::db::order_id_exists::*,
     domain::{add_order_command::*, order_added_event::*, order_aggregate::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -26,33 +27,27 @@ pub type AddOrderServiceObj = Arc<dyn AddOrderUseCase>;
 #[derive(Clone, Builder)]
 pub struct AddOrderService {
     db_order_id_exists: OrderIDExistsDBPortObj,
-    db_store_id_exists: StoreIDExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
 impl AddOrderUseCase for AddOrderService {
     async fn add_order(&self, cmd: AddOrderCommand) -> OrderingResult<OrderAddedEvent> {
-        if !self
+        let mut order_id = self.get_uuid.get_uuid();
-            .db_store_id_exists
-            .store_id_exists(cmd.store_id())
-            .await?
-        {
-            return Err(OrderingError::StoreIDNotFound);
-        }
 
-        if self
+        loop {
-            .db_order_id_exists
+            if self.db_order_id_exists.order_id_exists(&order_id).await? {
-            .order_id_exists(cmd.order_id())
+                order_id = self.get_uuid.get_uuid();
-            .await?
+                continue;
-        {
+            } else {
-            return Err(OrderingError::DuplicateOrderID);
+                break;
+            }
         }
 
         let order = OrderBuilder::default()
             .created_time(OffsetDateTime::now_utc())
-            .customer_name(cmd.customer_name().clone())
+            .customer_name(cmd.customer_name().into())
-            .order_id(*cmd.order_id())
+            .order_id(order_id)
-            .store_id(*cmd.store_id())
             .deleted(false)
             .build()
             .unwrap();
@@ -70,7 +65,8 @@ pub mod tests {
     use super::*;
 
     use crate::ordering::domain::order_added_event::tests::get_added_order_event_from_command;
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_order_service(
         times: Option<usize>,
@@ -96,7 +92,7 @@ pub mod tests {
 
         let s = AddOrderServiceBuilder::default()
             .db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
-            .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -104,23 +100,5 @@ pub mod tests {
         assert_eq!(res.order().customer_name(), cmd.customer_name());
         assert!(!res.order().deleted());
         assert_eq!(res.added_by_user(), cmd.adding_by());
-        assert_eq!(res.order().store_id(), cmd.store_id());
-        assert_eq!(res.order().order_id(), cmd.order_id());
-    }
-
-    #[actix_rt::test]
-    async fn test_service_store_id_doesnt_exist() {
-        let cmd = AddOrderCommand::get_cmd();
-
-        let s = AddOrderServiceBuilder::default()
-            .db_order_id_exists(mock_order_id_exists_db_port_false(IS_NEVER_CALLED))
-            .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
-            .build()
-            .unwrap();
-
-        assert_eq!(
-            s.add_order(cmd.clone()).await,
-            Err(OrderingError::StoreIDNotFound)
-        );
     }
 }

src/ordering/application/services/add_product_service.rs

@@ -23,6 +23,7 @@ use crate::ordering::{
         product_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -39,6 +40,7 @@ pub struct AddProductService {
     db_product_id_exists: ProductIDExistsDBPortObj,
     db_get_category: GetCategoryDBPortObj,
     fts_add_product: AddProductToStoreFTSPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -52,12 +54,19 @@ impl AddProductUseCase for AddProductService {
             return Err(OrderingError::CategoryIDNotFound);
         }
 
+        let mut product_id = self.get_uuid.get_uuid();
+
+        loop {
             if self
                 .db_product_id_exists
-            .product_id_exists(cmd.product_id())
+                .product_id_exists(&product_id)
                 .await?
             {
-            return Err(OrderingError::DuplicateProductID);
+                product_id = self.get_uuid.get_uuid();
+                continue;
+            } else {
+                break;
+            }
         }
 
         let product = ProductBuilder::default()
@@ -68,7 +77,7 @@ impl AddProductUseCase for AddProductService {
             .price(cmd.price().clone())
             .category_id(*cmd.category_id())
             .quantity(cmd.quantity().clone())
-            .product_id(*cmd.product_id())
+            .product_id(product_id)
             .build()
             .unwrap();
 
@@ -110,7 +119,8 @@ pub mod tests {
     use super::*;
 
     use crate::ordering::domain::add_product_command::tests::get_command;
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_add_product_service(
         times: Option<usize>,
@@ -125,7 +135,7 @@ pub mod tests {
                 .image(cmd.image().as_ref().map(|s| s.to_string()))
                 .sku_able(cmd.sku_able().clone())
                 .category_id(cmd.category_id().clone())
-                .product_id(*cmd.product_id())
+                .product_id(UUID.clone())
                 .price(cmd.price().clone())
                 .quantity(cmd.quantity().clone())
                 .added_by_user(cmd.adding_by().clone())
@@ -155,6 +165,7 @@ pub mod tests {
             .db_get_category(mock_get_category_db_port(IS_CALLED_ONLY_ONCE))
             .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -166,7 +177,7 @@ pub mod tests {
         assert_eq!(res.price(), cmd.price());
         assert_eq!(res.added_by_user(), cmd.adding_by());
         assert_eq!(res.category_id(), cmd.category_id());
-        assert_eq!(res.product_id(), cmd.product_id());
+        assert_eq!(res.product_id(), &UUID);
         assert_eq!(res.quantity(), cmd.quantity());
     }
 
@@ -179,6 +190,7 @@ pub mod tests {
                 mock_product_name_exists_for_category_db_port_true(IS_CALLED_ONLY_ONCE),
             )
             .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .db_product_id_exists(mock_product_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
@@ -203,6 +215,7 @@ pub mod tests {
             .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
             .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
+            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/ordering/application/services/add_store_service.rs

@@ -12,11 +12,12 @@ use super::errors::*;
 use crate::ordering::{
     application::port::output::db::{store_id_exists::*, store_name_exists::*},
     domain::{
-        add_store_command::*,
+        add_store_command::AddStoreCommand,
         store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
         store_aggregate::*,
     },
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -30,24 +31,28 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
 pub struct AddStoreService {
     db_store_id_exists: StoreIDExistsDBPortObj,
     db_store_name_exists: StoreNameExistsDBPortObj,
+    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
 impl AddStoreUseCase for AddStoreService {
     async fn add_store(&self, cmd: AddStoreCommand) -> OrderingResult<StoreAddedEvent> {
-        if self
+        let mut store_id = self.get_uuid.get_uuid();
-            .db_store_id_exists
+
-            .store_id_exists(cmd.store_id())
+        loop {
-            .await?
+            if self.db_store_id_exists.store_id_exists(&store_id).await? {
-        {
+                store_id = self.get_uuid.get_uuid();
-            return Err(OrderingError::DuplicateStoreID);
+                continue;
+            } else {
+                break;
+            }
         }
 
         let store = StoreBuilder::default()
             .name(cmd.name().into())
             .address(cmd.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap();
 
@@ -59,7 +64,7 @@ impl AddStoreUseCase for AddStoreService {
             .name(store.name().into())
             .address(store.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(store_id)
             .build()
             .unwrap())
     }
@@ -82,7 +87,7 @@ pub mod tests {
             .name(cmd.name().into())
             .address(cmd.address().as_ref().map(|s| s.to_string()))
             .owner(*cmd.owner())
-            .store_id(*cmd.store_id())
+            .store_id(UUID)
             .build()
             .unwrap();
 
@@ -103,17 +108,13 @@ pub mod tests {
         let address = "bar";
         let owner = UUID;
 
-        let cmd = AddStoreCommandBuilder::default()
+        // address = None
-            .name(name.into())
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -121,7 +122,7 @@ pub mod tests {
         assert_eq!(res.name(), cmd.name());
         assert_eq!(res.address(), cmd.address());
         assert_eq!(res.owner(), cmd.owner());
-        assert_eq!(res.store_id(), cmd.store_id());
+        assert_eq!(res.store_id(), &UUID);
     }
 
     #[actix_rt::test]
@@ -130,17 +131,13 @@ pub mod tests {
         let address = "bar";
         let owner = UUID;
 
-        let cmd = AddStoreCommandBuilder::default()
+        // address = None
-            .name(name.into())
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let s = AddStoreServiceBuilder::default()
             .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
             .db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 

src/ordering/application/services/delete_order_service.rs

@@ -42,9 +42,8 @@ impl DeleteOrderUseCase for DeleteOrderService {
 
         let deleted_order = OrderBuilder::default()
             .created_time(cmd.order().created_time().clone())
-            .customer_name(cmd.order().customer_name().clone())
+            .customer_name(cmd.order().customer_name().into())
             .order_id(*cmd.order().order_id())
-            .store_id(*cmd.order().store_id())
             .deleted(true)
             .build()
             .unwrap();

src/ordering/application/services/errors.rs

@@ -26,37 +26,52 @@ pub enum OrderingError {
     ProductIDNotFound,
     DuplicateCustomizationName,
     CustomizationIDNotFound,
-
-    DuplicateKotID,
-    DuplicateOrderID,
-    DuplicateStoreID,
-    DuplicateCustomizationID,
-    DuplicateProductID,
-    DuplicateCategoryID,
-    DuplicateLineItemID,
 }
 //
 impl From<OrderingDBError> for OrderingError {
     fn from(value: OrderingDBError) -> Self {
         match value {
-            OrderingDBError::DuplicateLineItemID => Self::DuplicateLineItemID,
+            OrderingDBError::DuplicateLineItemID => {
+                error!("DuplicateLineItemID");
+                Self::InternalError
+            }
             OrderingDBError::LineItemIDNotFound => OrderingError::LineItemIDNotFound,
-            OrderingDBError::DuplicateOrderID => Self::DuplicateOrderID,
+            OrderingDBError::DuplicateOrderID => {
+                error!("DuplicateOrderID");
+                Self::InternalError
+            }
             OrderingDBError::DuplicateStoreName => Self::DuplicateStoreName,
-            OrderingDBError::DuplicateStoreID => Self::DuplicateStoreID,
+            OrderingDBError::DuplicateStoreID => {
+                error!("DuplicateStoreID");
+                Self::InternalError
+            }
             OrderingDBError::StoreIDNotFound => OrderingError::StoreIDNotFound,
+
             OrderingDBError::OrderIDNotFound => OrderingError::OrderIDNotFound,
-            OrderingDBError::DuplicateKotID => Self::DuplicateKotID,
+
+            OrderingDBError::DuplicateKotID => {
+                error!("DuplicateKotID");
+                Self::InternalError
+            }
             OrderingDBError::KotIDNotFound => OrderingError::KotIDNotFound,
             OrderingDBError::InternalError => Self::InternalError,
             OrderingDBError::DuplicateCategoryName => Self::DuplicateCategoryName,
-            OrderingDBError::DuplicateCategoryID => Self::DuplicateCategoryID,
+            OrderingDBError::DuplicateCategoryID => {
+                error!("DuplicateCategoryID");
+                Self::InternalError
+            }
             OrderingDBError::CategoryIDNotFound => OrderingError::CategoryIDNotFound,
             OrderingDBError::DuplicateProductName => Self::DuplicateProductName,
-            OrderingDBError::DuplicateProductID => Self::DuplicateProductID,
+            OrderingDBError::DuplicateProductID => {
+                error!("DuplicateProductID");
+                Self::InternalError
+            }
             OrderingDBError::ProductIDNotFound => OrderingError::ProductIDNotFound,
             OrderingDBError::DuplicateCustomizationName => Self::DuplicateCustomizationName,
-            OrderingDBError::DuplicateCustomizationID => Self::DuplicateCustomizationID,
+            OrderingDBError::DuplicateCustomizationID => {
+                error!("DuplicateCustomizationID");
+                Self::InternalError
+            }
             OrderingDBError::CustomizationIDNotFound => OrderingError::CustomizationIDNotFound,
         }
     }

src/ordering/application/services/update_order_service.rs

@@ -7,12 +7,14 @@ use std::sync::Arc;
 use derive_builder::Builder;
 use mockall::predicate::*;
 use mockall::*;
+use time::OffsetDateTime;
 
 use super::errors::*;
 use crate::ordering::{
     application::port::output::db::order_id_exists::*,
     domain::{order_aggregate::*, order_updated_event::*, update_order_command::*},
 };
+use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -40,8 +42,7 @@ impl UpdateOrderUseCase for UpdateOrderService {
 
         let new_order = OrderBuilder::default()
             .created_time(cmd.created_time().clone())
-            .customer_name(cmd.customer_name().clone())
+            .customer_name(cmd.customer_name().into())
-            .store_id(*cmd.old_order().store_id())
             .order_id(*cmd.old_order().order_id())
             .deleted(false)
             .build()
@@ -61,8 +62,8 @@ pub mod tests {
     use super::*;
 
     use crate::ordering::domain::order_updated_event::tests::get_updated_order_event_from_command;
-    use crate::tests::bdd::*;
     use crate::utils::uuid::tests::UUID;
+    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
 
     pub fn mock_update_order_service(
         times: Option<usize>,

src/ordering/domain/add_category_command.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use derive_builder::Builder;
 use derive_getters::Getters;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
@@ -13,22 +12,21 @@ pub enum AddCategoryCommandError {
     NameIsEmpty,
 }
 
-#[derive(
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
-)]
-#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddCategoryCommand {
-    #[builder(setter(custom))]
     name: String,
-    #[builder(setter(custom))]
     description: Option<String>,
     store_id: Uuid,
-    category_id: Uuid,
     adding_by: Uuid,
 }
 
-impl AddCategoryCommandBuilder {
+impl AddCategoryCommand {
-    pub fn description(&mut self, description: Option<String>) -> &mut Self {
+    pub fn new(
+        name: String,
+        description: Option<String>,
+        store_id: Uuid,
+        adding_by: Uuid,
+    ) -> Result<Self, AddCategoryCommandError> {
         let description: Option<String> = if let Some(description) = description {
             let description = description.trim();
             if description.is_empty() {
@@ -39,46 +37,27 @@ impl AddCategoryCommandBuilder {
         } else {
             None
         };
-        self.description = Some(description);
-        self
-    }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
         let name = name.trim().to_owned();
-        self.name = Some(name);
+        if name.is_empty() {
-        self
+            return Err(AddCategoryCommandError::NameIsEmpty);
         }
 
-    pub fn validate(&self) -> Result<(), String> {
+        Ok(Self {
-        if self.name.as_ref().unwrap().is_empty() {
+            name,
-            return Err(AddCategoryCommandError::NameIsEmpty.to_string());
+            store_id,
-        }
+            description,
-
+            adding_by,
-        Ok(())
+        })
     }
 }
 
 #[cfg(test)]
-pub mod tests {
+mod tests {
     use super::*;
 
     use crate::utils::uuid::tests::UUID;
 
-    pub fn get_add_category_cmd() -> AddCategoryCommand {
-        let name = "foo";
-        let adding_by = UUID;
-        let store_id = Uuid::new_v4();
-
-        AddCategoryCommandBuilder::default()
-            .name(name.into())
-            .description(None)
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
-            .unwrap()
-    }
-
     #[test]
     fn test_cmd() {
         let name = "foo";
@@ -86,41 +65,26 @@ pub mod tests {
         let adding_by = UUID;
         let store_id = Uuid::new_v4();
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = None
-            .name(name.into())
+        let cmd = AddCategoryCommand::new(name.into(), None, store_id, adding_by).unwrap();
-            .description(None)
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
-            .unwrap();
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &None);
         assert_eq!(cmd.adding_by(), &adding_by);
         assert_eq!(cmd.store_id(), &store_id);
 
-        let cmd = AddCategoryCommandBuilder::default()
+        // description = Some
-            .name(name.into())
+        let cmd =
-            .description(Some(description.into()))
+            AddCategoryCommand::new(name.into(), Some(description.into()), store_id, adding_by)
-            .store_id(store_id)
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
                 .unwrap();
-
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &Some(description.to_owned()));
         assert_eq!(cmd.adding_by(), &adding_by);
         assert_eq!(cmd.store_id(), &store_id);
 
         // AddCategoryCommandError::NameIsEmpty
-        assert!(AddCategoryCommandBuilder::default()
+        assert_eq!(
-            .name("".into())
+            AddCategoryCommand::new("".into(), Some(description.into()), store_id, adding_by,),
-            .description(Some(description.into()))
+            Err(AddCategoryCommandError::NameIsEmpty)
-            .store_id(store_id)
+        )
-            .adding_by(adding_by)
-            .category_id(UUID)
-            .build()
-            .is_err())
     }
 }

src/ordering/domain/add_customization_command.rs

@@ -16,26 +16,28 @@ pub enum AddCustomizationCommandError {
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddCustomizationCommand {
-pub struct AddCustomizationCommand {
-    #[builder(setter(custom))]
     name: String,
     product_id: Uuid,
-    customization_id: Uuid,
 }
 
-impl AddCustomizationCommandBuilder {
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    pub fn name(&mut self, name: String) -> &mut Self {
+pub struct AddCustomizationCommand {
-        self.name = Some(name.trim().to_owned());
+    name: String,
-        self
+    product_id: Uuid,
 }
 
-    fn validate(&self) -> Result<(), String> {
+impl UnvalidatedAddCustomizationCommand {
-        let name = self.name.as_ref().unwrap().trim().to_owned();
+    pub fn validate(self) -> Result<AddCustomizationCommand, AddCustomizationCommandError> {
+        let name = self.name.trim().to_owned();
         if name.is_empty() {
-            return Err(AddCustomizationCommandError::NameIsEmpty.to_string());
+            return Err(AddCustomizationCommandError::NameIsEmpty);
         }
-        Ok(())
+
+        Ok(AddCustomizationCommand {
+            name,
+            product_id: self.product_id,
+        })
     }
 }
 
@@ -46,12 +48,13 @@ pub mod tests {
     use crate::utils::uuid::tests::UUID;
 
     pub fn get_command() -> AddCustomizationCommand {
-        AddCustomizationCommandBuilder::default()
+        UnvalidatedAddCustomizationCommandBuilder::default()
             .name("foo".into())
             .product_id(UUID.clone())
-            .customization_id(UUID.clone())
             .build()
             .unwrap()
+            .validate()
+            .unwrap()
     }
 
     #[test]
@@ -59,11 +62,12 @@ pub mod tests {
         let name = "foo";
         let product_id = UUID;
 
-        let cmd = AddCustomizationCommandBuilder::default()
+        let cmd = UnvalidatedAddCustomizationCommandBuilder::default()
             .name(name.into())
             .product_id(product_id.clone())
-            .customization_id(UUID.clone())
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
 
         assert_eq!(cmd.name(), name);
@@ -74,11 +78,14 @@ pub mod tests {
     fn test_cmd_name_is_empty() {
         let product_id = UUID;
 
-        assert!(AddCustomizationCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddCustomizationCommandBuilder::default()
                 .name("".into())
                 .product_id(product_id.clone())
-            .customization_id(UUID.clone())
                 .build()
-            .is_err(),);
+                .unwrap()
+                .validate(),
+            Err(AddCustomizationCommandError::NameIsEmpty)
+        );
     }
 }

src/ordering/domain/add_kot_command.rs

@@ -17,7 +17,6 @@ pub struct AddKotCommand {
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
     order_id: Uuid,
-    kot_id: Uuid,
 }
 
 #[cfg(test)]
@@ -37,7 +36,6 @@ mod tests {
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
                 .order_id(order_id)
-                .kot_id(UUID)
                 .build()
                 .unwrap()
         }
@@ -51,12 +49,10 @@ mod tests {
         let cmd = AddKotCommandBuilder::default()
             .adding_by(adding_by)
             .order_id(order_id)
-            .kot_id(UUID)
             .build()
             .unwrap();
 
         assert_eq!(*cmd.order_id(), order_id);
-        assert_eq!(*cmd.kot_id(), UUID);
         assert_eq!(*cmd.adding_by(), adding_by);
     }
 }

src/ordering/domain/add_line_item_command.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use uuid::Uuid;
 
-use crate::types::{currency::*, quantity::*};
+use crate::types::quantity::*;
 use crate::utils::string::empty_string_err;
 
 #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
@@ -19,41 +19,52 @@ pub enum AddLineItemCommandError {
 }
 
 #[derive(
-    Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddLineItemCommand {
-pub struct AddLineItemCommand {
+    adding_by: Uuid,
+
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
-    #[builder(setter(custom))]
     product_name: String,
     product_id: Uuid,
     kot_id: Uuid,
-    line_item_id: Uuid,
+    quantity: Quantity,
+}
+
+impl UnvalidatedAddLineItemCommand {
+    pub fn validate(self) -> Result<AddLineItemCommand, AddLineItemCommandError> {
+        let product_name = empty_string_err(
+            self.product_name,
+            AddLineItemCommandError::ProductNameIsEmpty,
+        )?;
+
+        if self.quantity.is_empty() {
+            return Err(AddLineItemCommandError::QuantityIsEmpty);
+        }
+
+        Ok(AddLineItemCommand {
+            created_time: self.created_time,
+            product_name,
+            product_id: self.product_id,
+            kot_id: self.kot_id,
+            quantity: self.quantity,
+            adding_by: self.adding_by,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct AddLineItemCommand {
+    created_time: OffsetDateTime,
+    product_name: String,
+    product_id: Uuid,
+    kot_id: Uuid,
     quantity: Quantity,
 
     adding_by: Uuid,
 }
 
-impl AddLineItemCommandBuilder {
-    pub fn product_name(&mut self, product_name: String) -> &mut Self {
-        self.product_name = Some(product_name.trim().to_owned());
-        self
-    }
-
-    fn validate(&self) -> Result<(), String> {
-        let product_name = self.product_name.as_ref().unwrap().trim().to_owned();
-        if product_name.is_empty() {
-            return Err(AddLineItemCommandError::ProductNameIsEmpty.to_string());
-        }
-
-        if self.quantity.as_ref().unwrap().is_empty() {
-            return Err(AddLineItemCommandError::QuantityIsEmpty.to_string());
-        }
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use time::macros::datetime;
@@ -70,16 +81,17 @@ mod tests {
             let adding_by = UUID;
             let quantity = Quantity::get_quantity();
 
-            AddLineItemCommandBuilder::default()
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
                 .quantity(quantity.clone())
                 .product_id(product_id)
                 .kot_id(kot_id)
-                .line_item_id(UUID)
                 .build()
                 .unwrap()
+                .validate()
+                .unwrap()
         }
     }
 
@@ -91,14 +103,15 @@ mod tests {
         let adding_by = UUID;
         let quantity = Quantity::get_quantity();
 
-        let cmd = AddLineItemCommandBuilder::default()
+        let cmd = UnvalidatedAddLineItemCommandBuilder::default()
             .product_name(product_name.into())
             .adding_by(adding_by)
             .quantity(quantity.clone())
             .product_id(product_id)
             .kot_id(kot_id)
-            .line_item_id(UUID)
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
 
         assert_eq!(cmd.quantity(), &quantity);
@@ -115,15 +128,18 @@ mod tests {
         let adding_by = UUID;
         let quantity = Quantity::get_quantity();
 
-        assert!(AddLineItemCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .quantity(quantity.clone())
                 .product_id(product_id)
-            .line_item_id(UUID)
                 .kot_id(kot_id)
                 .build()
-            .is_err());
+                .unwrap()
+                .validate(),
+            Err(AddLineItemCommandError::ProductNameIsEmpty)
+        );
     }
 
     #[test]
@@ -135,13 +151,17 @@ mod tests {
         // minor = 0; major = 0;
         let quantity = Quantity::default();
 
-        assert!(AddLineItemCommandBuilder::default()
+        assert_eq!(
+            UnvalidatedAddLineItemCommandBuilder::default()
                 .product_name(product_name.into())
                 .adding_by(adding_by)
                 .quantity(quantity.clone())
                 .product_id(product_id)
                 .kot_id(kot_id)
                 .build()
-            .is_err());
+                .unwrap()
+                .validate(),
+            Err(AddLineItemCommandError::QuantityIsEmpty)
+        );
     }
 }

src/ordering/domain/add_order_command.rs

@@ -9,6 +9,8 @@ use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use uuid::Uuid;
 
+use crate::utils::string::empty_string_err;
+
 #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AddOrderCommandError {
     CustomerNameIsEmpty,
@@ -17,31 +19,34 @@ pub enum AddOrderCommandError {
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-pub struct AddOrderCommand {
+pub struct UnvalidatedAddOrderCommand {
     adding_by: Uuid,
 
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
-    #[builder(setter(custom))]
+    customer_name: String,
-    customer_name: Option<String>,
-    store_id: Uuid,
-    order_id: Uuid,
 }
 
-impl AddOrderCommandBuilder {
+impl UnvalidatedAddOrderCommand {
-    pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
+    pub fn validate(self) -> Result<AddOrderCommand, AddOrderCommandError> {
-        self.customer_name = if let Some(customer_name) = customer_name {
+        let customer_name = empty_string_err(
-            let customer_name = customer_name.trim();
+            self.customer_name,
-            if customer_name.is_empty() {
+            AddOrderCommandError::CustomerNameIsEmpty,
-                Some(None)
+        )?;
-            } else {
+
-                Some(Some(customer_name.to_string()))
+        Ok(AddOrderCommand {
+            created_time: self.created_time,
+            customer_name,
+            adding_by: self.adding_by,
+        })
     }
-        } else {
-            Some(None)
-        };
-        self
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct AddOrderCommand {
+    created_time: OffsetDateTime,
+    customer_name: String,
+    adding_by: Uuid,
 }
 
 #[cfg(test)]
@@ -57,14 +62,14 @@ mod tests {
             let customer_name = "foo";
             let adding_by = UUID;
 
-            AddOrderCommandBuilder::default()
+            UnvalidatedAddOrderCommandBuilder::default()
-                .customer_name(Some(customer_name.into()))
+                .customer_name(customer_name.into())
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
-                .store_id(UUID)
-                .order_id(UUID)
                 .build()
                 .unwrap()
+                .validate()
+                .unwrap()
         }
     }
 
@@ -73,27 +78,31 @@ mod tests {
         let customer_name = "foo";
         let adding_by = UUID;
 
-        let _cmd = AddOrderCommandBuilder::default()
+        let cmd = UnvalidatedAddOrderCommandBuilder::default()
-            .customer_name(Some(customer_name.into()))
+            .customer_name(customer_name.into())
             .adding_by(adding_by)
-            .store_id(UUID)
-            .order_id(UUID)
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
+
+        assert_eq!(*cmd.adding_by(), adding_by);
+        assert_eq!(cmd.customer_name(), customer_name);
     }
 
     #[test]
     fn test_cmd_customer_name_empty() {
         let customer_name = "";
+        let adding_by = UUID;
 
-        let cmd = AddOrderCommandBuilder::default()
+        assert_eq!(
-            .customer_name(Some(customer_name.into()))
+            UnvalidatedAddOrderCommandBuilder::default()
-            .adding_by(UUID)
+                .customer_name(customer_name.into())
-            .store_id(UUID)
+                .adding_by(adding_by)
-            .order_id(UUID)
                 .build()
-            .unwrap();
+                .unwrap()
-
+                .validate(),
-        assert!(cmd.customer_name().is_none());
+            Err(AddOrderCommandError::CustomerNameIsEmpty)
+        );
     }
 }

src/ordering/domain/add_product_command.rs

@@ -17,17 +17,24 @@ pub enum AddProductCommandError {
 }
 
 #[derive(
-    Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-#[builder(build_fn(validate = "Self::validate"))]
+pub struct UnvalidatedAddProductCommand {
-pub struct AddProductCommand {
+    name: String,
-    #[builder(setter(custom))]
+    description: Option<String>,
+    image: Option<String>,
+    category_id: Uuid,
+    sku_able: bool,
+    quantity: Quantity,
+    price: Price,
+    adding_by: Uuid,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct AddProductCommand {
     name: String,
-    #[builder(setter(custom))]
     description: Option<String>,
-    #[builder(setter(custom))]
     image: Option<String>,
-    product_id: Uuid,
     category_id: Uuid,
     sku_able: bool,
     price: Price,
@@ -35,9 +42,9 @@ pub struct AddProductCommand {
     adding_by: Uuid,
 }
 
-impl AddProductCommandBuilder {
+impl UnvalidatedAddProductCommand {
-    pub fn description(&mut self, description: Option<String>) -> &mut Self {
+    pub fn validate(self) -> Result<AddProductCommand, AddProductCommandError> {
-        let description: Option<String> = if let Some(description) = description {
+        let description: Option<String> = if let Some(description) = self.description {
             let description = description.trim();
             if description.is_empty() {
                 None
@@ -47,12 +54,8 @@ impl AddProductCommandBuilder {
         } else {
             None
         };
-        self.description = Some(description);
-        self
-    }
 
-    pub fn image(&mut self, image: Option<String>) -> &mut Self {
+        let image: Option<String> = if let Some(image) = self.image {
-        let image: Option<String> = if let Some(image) = image {
             let image = image.trim();
             if image.is_empty() {
                 None
@@ -62,22 +65,22 @@ impl AddProductCommandBuilder {
         } else {
             None
         };
-        self.image = Some(image);
+
-        self
+        let name = self.name.trim().to_owned();
+        if name.is_empty() {
+            return Err(AddProductCommandError::NameIsEmpty);
         }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
+        Ok(AddProductCommand {
-        let name = name.trim().to_owned();
+            name,
-        self.name = Some(name);
+            description,
-        self
+            image,
-    }
+            category_id: self.category_id,
-
+            sku_able: self.sku_able,
-    pub fn validate(&self) -> Result<(), String> {
+            price: self.price,
-        if self.name.as_ref().unwrap().is_empty() {
+            quantity: self.quantity,
-            return Err(AddProductCommandError::NameIsEmpty.to_string());
+            adding_by: self.adding_by,
-        }
+        })
-
-        Ok(())
     }
 }
 
@@ -90,7 +93,7 @@ pub mod tests {
     pub fn get_command() -> AddProductCommand {
         let name = "foo";
         let adding_by = UUID;
-        let category_id = UUID;
+        let category_id = Uuid::new_v4();
         let sku_able = false;
         let image = Some("image".to_string());
         let description = Some("description".to_string());
@@ -120,7 +123,7 @@ pub mod tests {
             .build()
             .unwrap();
 
-        AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(description.clone())
             .image(image.clone())
@@ -128,10 +131,11 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
-            .unwrap()
+            .unwrap();
+
+        cmd.validate().unwrap()
     }
 
     #[test]
@@ -151,7 +155,7 @@ pub mod tests {
         let quantity = Quantity::default();
 
         // description = None
-        let cmd = AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(None)
             .image(None)
@@ -159,11 +163,12 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity.clone())
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
             .unwrap();
 
+        let cmd = cmd.validate().unwrap();
+
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &None);
         assert_eq!(cmd.adding_by(), &adding_by);
@@ -191,19 +196,21 @@ pub mod tests {
 
         let quantity = Quantity::default();
 
-        let cmd = AddProductCommandBuilder::default()
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
             .name(name.into())
             .description(description.clone())
             .image(image.clone())
             .category_id(category_id)
-            .adding_by(adding_by)
             .quantity(quantity.clone())
+            .adding_by(adding_by)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
+            //            .customizations(customizations.clone())
             .build()
             .unwrap();
 
+        let cmd = cmd.validate().unwrap();
+
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.description(), &description);
         assert_eq!(cmd.adding_by(), &adding_by);
@@ -231,8 +238,7 @@ pub mod tests {
 
         let quantity = Quantity::default();
 
-        // AddProductCommandError::NameIsEmpty
+        let cmd = UnvalidatedAddProductCommandBuilder::default()
-        assert!(AddProductCommandBuilder::default()
             .name("".into())
             .description(description.clone())
             .image(image.clone())
@@ -240,9 +246,11 @@ pub mod tests {
             .adding_by(adding_by)
             .quantity(quantity)
             .sku_able(sku_able)
-            .product_id(UUID)
             .price(price.clone())
             .build()
-            .is_err());
+            .unwrap();
+
+        // AddProductCommandError::NameIsEmpty
+        assert_eq!(cmd.validate(), Err(AddProductCommandError::NameIsEmpty))
     }
 }

src/ordering/domain/add_store_command.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use derive_builder::Builder;
 use derive_getters::Getters;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
@@ -13,52 +12,46 @@ pub enum AddStoreCommandError {
     NameIsEmpty,
 }
 
-#[derive(
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
-    Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
-)]
-#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddStoreCommand {
-    #[builder(setter(custom))]
     name: String,
-    #[builder(setter(custom))]
     address: Option<String>,
-    store_id: Uuid,
     owner: Uuid,
 }
 
-impl AddStoreCommandBuilder {
+impl AddStoreCommand {
-    pub fn address(&mut self, address: Option<String>) -> &mut Self {
+    pub fn new(
-        self.address = if let Some(address) = address {
+        name: String,
+        address: Option<String>,
+        owner: Uuid,
+    ) -> Result<Self, AddStoreCommandError> {
+        let address: Option<String> = if let Some(address) = address {
             let address = address.trim();
             if address.is_empty() {
-                Some(None)
+                None
             } else {
-                Some(Some(address.to_owned()))
+                Some(address.to_owned())
             }
         } else {
-            Some(None)
+            None
         };
-        self
-    }
 
-    pub fn name(&mut self, name: String) -> &mut Self {
+        let name = name.trim().to_owned();
-        self.name = Some(name.trim().to_owned());
-        self
-    }
-
-    fn validate(&self) -> Result<(), String> {
-        let name = self.name.as_ref().unwrap().trim().to_owned();
         if name.is_empty() {
-            return Err(AddStoreCommandError::NameIsEmpty.to_string());
+            return Err(AddStoreCommandError::NameIsEmpty);
         }
-        Ok(())
+
+        Ok(Self {
+            name,
+            address,
+            owner,
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::UUID;
-    use crate::utils::uuid::tests::*;
 
     use super::*;
 
@@ -69,41 +62,21 @@ mod tests {
         let owner = UUID;
 
         // address = None
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
-            .name(name.into())
-            .address(None)
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &None);
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // address = Some
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
-            .name(name.into())
-            .address(Some(address.into()))
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
-
         assert_eq!(cmd.name(), name);
         assert_eq!(cmd.address(), &Some(address.to_owned()));
         assert_eq!(cmd.owner(), &owner);
-        assert_eq!(*cmd.store_id(), UUID);
 
         // AddStoreCommandError::NameIsEmpty
-
+        assert_eq!(
-        assert!(AddStoreCommandBuilder::default()
+            AddStoreCommand::new("".into(), Some(address.into()), owner),
-            .name("".into())
+            Err(AddStoreCommandError::NameIsEmpty)
-            .address(Some(address.into()))
+        )
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .is_err())
     }
 }

src/ordering/domain/category_aggregate.rs

@@ -81,8 +81,8 @@ mod aggregate_tests {
     use std::sync::Arc;
 
     use cqrs_es::test::TestFramework;
-    use tests::get_add_category_cmd;
     use update_category_service::tests::mock_update_category_service;
+    use uuid::Uuid;
 
     use super::*;
     use crate::ordering::{
@@ -95,19 +95,27 @@ mod aggregate_tests {
         },
     };
     use crate::tests::bdd::*;
+    use crate::utils::uuid::tests::*;
 
     type CategoryTestFramework = TestFramework<Category>;
 
     #[test]
     fn test_create_category() {
-        let cmd = get_add_category_cmd();
+        let name = "category_name";
+        let description = Some("category_description".to_string());
+        let adding_by = UUID;
+        let store_id = Uuid::new_v4();
+        let category_id = UUID;
+
+        let cmd =
+            AddCategoryCommand::new(name.into(), description.clone(), store_id, adding_by).unwrap();
 
         let expected = CategoryAddedEventBuilder::default()
             .name(cmd.name().into())
             .description(cmd.description().as_ref().map(|s| s.to_string()))
             .added_by_user(*cmd.adding_by())
             .store_id(*cmd.store_id())
-            .category_id(*cmd.category_id())
+            .category_id(category_id)
             .build()
             .unwrap();
         let expected = OrderingEvent::CategoryAdded(expected);

src/ordering/domain/kot_added_event.rs

@@ -20,18 +20,12 @@ pub struct KotAddedEvent {
 
 #[cfg(test)]
 pub mod tests {
-    use crate::ordering::domain::{add_kot_command::AddKotCommand, kot_aggregate::*};
+    use crate::ordering::domain::add_kot_command::AddKotCommand;
 
     use super::*;
 
     pub fn get_added_kot_event_from_command(cmd: &AddKotCommand) -> KotAddedEvent {
-        let kot = KotBuilder::default()
+        let kot = Kot::get_kot();
-            .created_time(cmd.created_time().clone())
-            .order_id(*cmd.order_id())
-            .kot_id(*cmd.kot_id())
-            .deleted(false)
-            .build()
-            .unwrap();
 
         KotAddedEventBuilder::default()
             .added_by_user(cmd.adding_by().clone())

src/ordering/domain/order_aggregate.rs

@@ -21,11 +21,11 @@ use crate::ordering::{
 pub struct Order {
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
-    store_id: Uuid,
+    //    kot_ids: Vec<Kot>,
     order_id: Uuid,
     #[builder(default = "false")]
     deleted: bool,
-    customer_name: Option<String>,
+    customer_name: String,
 }
 
 impl Default for Order {
@@ -33,9 +33,8 @@ impl Default for Order {
         Self {
             created_time: OffsetDateTime::now_utc(),
             order_id: Default::default(),
-            store_id: Default::default(),
             deleted: false,
-            customer_name: None,
+            customer_name: Default::default(),
         }
     }
 }
@@ -52,9 +51,8 @@ mod tests {
 
             OrderBuilder::default()
                 .created_time(cmd.created_time().clone())
-                .customer_name(Some("test_product".into()))
+                .customer_name("test_product".into())
-                .order_id(*cmd.order_id())
+                .order_id(UUID)
-                .store_id(*cmd.store_id())
                 .build()
                 .unwrap()
         }

src/ordering/domain/order_deleted_event.rs

@@ -27,9 +27,8 @@ pub mod tests {
     pub fn get_deleted_order_event_from_command(cmd: &DeleteOrderCommand) -> OrderDeletedEvent {
         let deleted_order = OrderBuilder::default()
             .created_time(cmd.order().created_time().clone())
-            .customer_name(cmd.order().customer_name().clone())
+            .customer_name(cmd.order().customer_name().into())
             .order_id(*cmd.order().order_id())
-            .store_id(*cmd.order().store_id())
             .deleted(true)
             .build()
             .unwrap();

src/ordering/domain/order_updated_event.rs

@@ -28,9 +28,8 @@ pub mod tests {
     pub fn get_updated_order_event_from_command(cmd: &UpdateOrderCommand) -> OrderUpdatedEvent {
         let new_order = OrderBuilder::default()
             .created_time(cmd.created_time().clone())
-            .customer_name(cmd.customer_name().clone())
+            .customer_name(cmd.customer_name().into())
             .order_id(*cmd.old_order().order_id())
-            .store_id(*cmd.old_order().store_id())
             .build()
             .unwrap();
 

src/ordering/domain/store_aggregate.rs

@@ -113,13 +113,7 @@ mod tests {
             .unwrap();
         let expected = OrderingEvent::StoreAdded(expected);
 
-        let cmd = AddStoreCommandBuilder::default()
+        let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap();
-            .name(name.into())
-            .address(address.clone())
-            .owner(owner)
-            .store_id(UUID)
-            .build()
-            .unwrap();
 
         let mut services = MockOrderingServicesInterface::new();
         services

src/ordering/domain/update_order_command.rs

@@ -10,6 +10,7 @@ use time::OffsetDateTime;
 use uuid::Uuid;
 
 use super::order_aggregate::*;
+use crate::utils::string::empty_string_err;
 
 #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum UpdateOrderCommandError {
@@ -19,31 +20,37 @@ pub enum UpdateOrderCommandError {
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-pub struct UpdateOrderCommand {
+pub struct UnvalidatedUpdateOrderCommand {
     adding_by: Uuid,
 
     #[builder(default = "OffsetDateTime::now_utc()")]
     created_time: OffsetDateTime,
-    #[builder(setter(custom))]
+    customer_name: String,
-    customer_name: Option<String>,
-
     old_order: Order,
 }
 
-impl UpdateOrderCommandBuilder {
+impl UnvalidatedUpdateOrderCommand {
-    pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
+    pub fn validate(self) -> Result<UpdateOrderCommand, UpdateOrderCommandError> {
-        self.customer_name = if let Some(customer_name) = customer_name {
+        let customer_name = empty_string_err(
-            let customer_name = customer_name.trim();
+            self.customer_name,
-            if customer_name.is_empty() {
+            UpdateOrderCommandError::CustomerNameIsEmpty,
-                Some(None)
+        )?;
-            } else {
+
-                Some(Some(customer_name.to_string()))
+        Ok(UpdateOrderCommand {
+            created_time: self.created_time,
+            customer_name,
+            adding_by: self.adding_by,
+            old_order: self.old_order,
+        })
     }
-        } else {
-            Some(None)
-        };
-        self
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+pub struct UpdateOrderCommand {
+    created_time: OffsetDateTime,
+    customer_name: String,
+    adding_by: Uuid,
+    old_order: Order,
 }
 
 #[cfg(test)]
@@ -59,13 +66,15 @@ mod tests {
             let customer_name = "foo-new-name";
             let adding_by = UUID;
 
-            UpdateOrderCommandBuilder::default()
+            UnvalidatedUpdateOrderCommandBuilder::default()
-                .customer_name(Some(customer_name.into()))
+                .customer_name(customer_name.into())
                 .adding_by(adding_by)
                 .created_time(datetime!(1970-01-01 0:00 UTC))
                 .old_order(Order::default())
                 .build()
                 .unwrap()
+                .validate()
+                .unwrap()
         }
     }
 
@@ -75,15 +84,17 @@ mod tests {
         let adding_by = UUID;
         let old_order = Order::default();
 
-        let cmd = UpdateOrderCommandBuilder::default()
+        let cmd = UnvalidatedUpdateOrderCommandBuilder::default()
-            .customer_name(Some(customer_name.into()))
+            .customer_name(customer_name.into())
             .adding_by(adding_by)
             .old_order(old_order.clone())
             .build()
+            .unwrap()
+            .validate()
             .unwrap();
 
         assert_eq!(*cmd.adding_by(), adding_by);
-        assert_eq!(cmd.customer_name().as_ref().unwrap(), customer_name);
+        assert_eq!(cmd.customer_name(), customer_name);
         assert_eq!(cmd.old_order(), &old_order);
     }
 
@@ -92,13 +103,15 @@ mod tests {
         let customer_name = "";
         let adding_by = UUID;
 
-        let cmd = UpdateOrderCommandBuilder::default()
+        assert_eq!(
-            .customer_name(Some(customer_name.into()))
+            UnvalidatedUpdateOrderCommandBuilder::default()
+                .customer_name(customer_name.into())
                 .adding_by(adding_by)
                 .old_order(Order::default())
                 .build()
-            .unwrap();
+                .unwrap()
-
+                .validate(),
-        assert!(cmd.customer_name().is_none());
+            Err(UpdateOrderCommandError::CustomerNameIsEmpty)
+        );
     }
 }

src/ordering/domain/update_product_command.rs

@@ -95,55 +95,6 @@ pub mod tests {
     use crate::types::quantity::*;
     use crate::utils::uuid::tests::UUID;
 
-    pub fn get_command_with_product(product: Product) -> UpdateProductCommand {
-        let name = "foobaaar";
-        let adding_by = UUID;
-        let category_id = UUID;
-        let sku_able = false;
-        let image = Some("imageeee".to_string());
-        let description = Some("descriptionnnn".to_string());
-
-        let price = PriceBuilder::default()
-            .minor(0)
-            .major(100)
-            .currency(Currency::INR)
-            .build()
-            .unwrap();
-
-        let quantity = QuantityBuilder::default()
-            .minor(
-                QuantityPartBuilder::default()
-                    .number(0)
-                    .unit(QuantityUnit::DiscreteNumber)
-                    .build()
-                    .unwrap(),
-            )
-            .major(
-                QuantityPartBuilder::default()
-                    .number(1)
-                    .unit(QuantityUnit::DiscreteNumber)
-                    .build()
-                    .unwrap(),
-            )
-            .build()
-            .unwrap();
-
-        let cmd = UnvalidatedUpdateProductCommandBuilder::default()
-            .name(name.into())
-            .description(description.clone())
-            .image(image.clone())
-            .category_id(category_id.clone())
-            .adding_by(adding_by.clone())
-            .quantity(quantity)
-            .sku_able(sku_able)
-            .price(price.clone())
-            .old_product(product)
-            .build()
-            .unwrap();
-
-        cmd.validate().unwrap()
-    }
-
     pub fn get_command() -> UpdateProductCommand {
         let name = "foo";
         let adding_by = UUID;

src/settings/mod.rs

@@ -158,7 +158,6 @@ pub mod tests {
         let mut db_url = Url::parse(&settings.database.url).unwrap();
         db_url.set_path(&GenerateRandomString.get_random(12));
         settings.database.url = db_url.to_string();
-        println!("Test database URL: {}", settings.database.url);
         settings.database.pool = 1;
 
         settings