asyavee/medusa-store
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

fix(medusa): Idempotency workStage used within transaction (#2358)

Browse Source
This commit is contained in:
Adrien de Peretti
2022-10-19 10:47:31 +02:00
committed by GitHub
parent 3c5e31c645
commit 9deec0fc3c
14 changed files with 567 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/medusa/src/api/routes/admin/orders/create-claim.ts
+127 -131
View File
@@ -1,4 +1,3 @@
import { ClaimReason, ClaimType } from "../../../../models"
import {
IsArray,
IsBoolean,
@@ -11,12 +10,13 @@ import {
ValidateNested,
} from "class-validator"
import { defaultAdminOrdersFields, defaultAdminOrdersRelations } from "."
import { ClaimReason, ClaimType } from "../../../../models"
import { AddressPayload } from "../../../../types/common"
import { ClaimTypeValue } from "../../../../types/claim"
import { EntityManager } from "typeorm"
import { MedusaError } from "medusa-core-utils"
import { Type } from "class-transformer"
import { MedusaError } from "medusa-core-utils"
import { EntityManager } from "typeorm"
import { ClaimTypeValue } from "../../../../types/claim"
import { AddressPayload } from "../../../../types/common"
import { validator } from "../../../../utils/validator"
/**
@@ -223,150 +223,146 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: [
"customer",
"shipping_address",
"region",
"items",
"items.tax_lines",
"discounts",
"discounts.rule",
"claims",
"claims.additional_items",
"claims.additional_items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: [
"customer",
"shipping_address",
"region",
"items",
"items.tax_lines",
"discounts",
"discounts.rule",
"claims",
"claims.additional_items",
"claims.additional_items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
})
await claimService.withTransaction(manager).create({
idempotency_key: idempotencyKey.idempotency_key,
order,
type: value.type,
shipping_address: value.shipping_address,
claim_items: value.claim_items,
return_shipping: value.return_shipping,
additional_items: value.additional_items,
shipping_methods: value.shipping_methods,
no_notification: value.no_notification,
metadata: value.metadata,
})
await claimService.withTransaction(manager).create({
idempotency_key: idempotencyKey.idempotency_key,
order,
type: value.type,
shipping_address: value.shipping_address,
claim_items: value.claim_items,
return_shipping: value.return_shipping,
additional_items: value.additional_items,
shipping_methods: value.shipping_methods,
no_notification: value.no_notification,
metadata: value.metadata,
return {
recovery_point: "claim_created",
}
})
return {
recovery_point: "claim_created",
}
})
if (error) {
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "claim_created": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let claim = await claimService.withTransaction(manager).list({
idempotency_key: idempotencyKey.idempotency_key,
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let claim = await claimService.withTransaction(manager).list({
idempotency_key: idempotencyKey.idempotency_key,
})
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.type === "refund") {
await claimService
.withTransaction(manager)
.processRefund(claim.id)
}
return {
recovery_point: "refund_handled",
}
})
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.type === "refund") {
await claimService
.withTransaction(manager)
.processRefund(claim.id)
}
return {
recovery_point: "refund_handled",
}
})
if (error) {
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "refund_handled": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: ["items", "discounts"],
})
let claim = await claimService.withTransaction(manager).list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["return_order"],
}
)
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.return_order) {
await returnService
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let order = await orderService
.withTransaction(manager)
.fulfill(claim.return_order.id)
}
.retrieve(id, {
relations: ["items", "discounts"],
})
order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultAdminOrdersFields,
relations: defaultAdminOrdersRelations,
let claim = await claimService.withTransaction(manager).list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["return_order"],
}
)
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.return_order) {
await returnService
.withTransaction(manager)
.fulfill(claim.return_order.id)
}
order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: defaultAdminOrdersFields,
relations: defaultAdminOrdersRelations,
})
return {
response_code: 200,
response_body: { order },
}
})
return {
response_code: 200,
response_body: { order },
}
})
if (error) {
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
packages/medusa/src/api/routes/admin/orders/create-swap.ts
+57 -64
View File
@@ -200,71 +200,68 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: ["refunded_total", "total"],
relations: [
"items",
"items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
})
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: ["refunded_total", "total"],
relations: [
"items",
"items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
})
const swap = await swapService
.withTransaction(manager)
.create(
order,
validated.return_items,
validated.additional_items,
validated.return_shipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: validated.no_notification,
allow_backorder: validated.allow_backorder,
}
)
const swap = await swapService
.withTransaction(manager)
.create(
order,
validated.return_items,
validated.additional_items,
validated.return_shipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: validated.no_notification,
allow_backorder: validated.allow_backorder,
}
)
await swapService
.withTransaction(manager)
.createCart(swap.id, validated.custom_shipping_options)
await swapService
.withTransaction(manager)
.createCart(swap.id, validated.custom_shipping_options)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
await returnService
.withTransaction(manager)
.fulfill(returnOrder.id)
await returnService
.withTransaction(manager)
.fulfill(returnOrder.id)
return {
recovery_point: "swap_created",
}
})
if (error) {
return {
recovery_point: "swap_created",
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "swap_created": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(
idempotencyKey.idempotency_key,
async (transactionManager: EntityManager) => {
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const swaps = await swapService
.withTransaction(transactionManager)
.list({
@@ -289,16 +286,12 @@ export default async (req, res) => {
response_code: 200,
response_body: { order },
}
}
)
if (error) {
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
packages/medusa/src/api/routes/admin/orders/request-return.ts
+95 -99
View File
@@ -175,125 +175,121 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const returnObj: ReturnObj = {
order_id: id,
idempotency_key: idempotencyKey.idempotency_key,
items: value.items,
}
if (value.return_shipping) {
returnObj.shipping_method = value.return_shipping
}
if (isDefined(value.refund) && value.refund < 0) {
returnObj.refund_amount = 0
} else {
if (value.refund && value.refund >= 0) {
returnObj.refund_amount = value.refund
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const returnObj: ReturnObj = {
order_id: id,
idempotency_key: idempotencyKey.idempotency_key,
items: value.items,
}
}
const order = await orderService
.withTransaction(manager)
.retrieve(id)
if (value.return_shipping) {
returnObj.shipping_method = value.return_shipping
}
const evaluatedNoNotification =
value.no_notification !== undefined
? value.no_notification
: order.no_notification
returnObj.no_notification = evaluatedNoNotification
if (isDefined(value.refund) && value.refund < 0) {
returnObj.refund_amount = 0
} else {
if (value.refund && value.refund >= 0) {
returnObj.refund_amount = value.refund
}
}
const createdReturn = await returnService
.withTransaction(manager)
.create(returnObj)
if (value.return_shipping) {
await returnService
const order = await orderService
.withTransaction(manager)
.fulfill(createdReturn.id)
}
.retrieve(id)
await eventBus
.withTransaction(manager)
.emit("order.return_requested", {
id,
return_id: createdReturn.id,
no_notification: evaluatedNoNotification,
})
const evaluatedNoNotification =
value.no_notification !== undefined
? value.no_notification
: order.no_notification
returnObj.no_notification = evaluatedNoNotification
return {
recovery_point: "return_requested",
}
})
const createdReturn = await returnService
.withTransaction(manager)
.create(returnObj)
if (error) {
if (value.return_shipping) {
await returnService
.withTransaction(manager)
.fulfill(createdReturn.id)
}
await eventBus
.withTransaction(manager)
.emit("order.return_requested", {
id,
return_id: createdReturn.id,
no_notification: evaluatedNoNotification,
})
return {
recovery_point: "return_requested",
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "return_requested": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let order: Order | Return = await orderService
.withTransaction(manager)
.retrieve(id, { relations: ["returns"] })
/**
* If we are ready to receive immediately, we find the newly created return
* and register it as received.
*/
if (value.receive_now) {
const returns = await returnService
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
let order: Order | Return = await orderService
.withTransaction(manager)
.list({
idempotency_key: idempotencyKey.idempotency_key,
})
.retrieve(id, { relations: ["returns"] })
if (!returns.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Return not found`
)
/**
* If we are ready to receive immediately, we find the newly created return
* and register it as received.
*/
if (value.receive_now) {
const returns = await returnService
.withTransaction(manager)
.list({
idempotency_key: idempotencyKey.idempotency_key,
})
if (!returns.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Return not found`
)
}
const returnOrder = returns[0]
order = await returnService
.withTransaction(manager)
.receive(returnOrder.id, value.items, value.refund)
}
const returnOrder = returns[0]
order = await returnService
order = await orderService
.withTransaction(manager)
.receive(returnOrder.id, value.items, value.refund)
}
.retrieve(id, {
select: defaultAdminOrdersFields,
relations: defaultAdminOrdersRelations,
})
order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: defaultAdminOrdersFields,
relations: defaultAdminOrdersRelations,
})
return {
response_code: 200,
response_body: { order },
}
})
if (error) {
return {
response_code: 200,
response_body: { order },
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
packages/medusa/src/api/routes/store/carts/calculate-taxes.ts
+10 -15
View File
@@ -73,12 +73,11 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(
idempotencyKey.idempotency_key,
async (manager: EntityManager) => {
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const cart = await cartService
.withTransaction(manager)
.retrieveWithTotals(id, {}, { force_taxes: true })
@@ -87,16 +86,12 @@ export default async (req, res) => {
response_code: 200,
response_body: { cart },
}
}
)
if (error) {
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key!
}
})
err = e
})
break
}
packages/medusa/src/api/routes/store/carts/create-payment-sessions.ts
+25 -27
View File
@@ -79,37 +79,35 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(
idempotencyKey.idempotency_key,
async (stageManager) => {
await cartService
.withTransaction(stageManager)
.setPaymentSessions(id)
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(
idempotencyKey.idempotency_key,
async (stageManager) => {
await cartService
.withTransaction(stageManager)
.setPaymentSessions(id)
const cart = await cartService
.withTransaction(stageManager)
.retrieveWithTotals(id, {
select: defaultStoreCartFields,
relations: defaultStoreCartRelations,
})
const cart = await cartService
.withTransaction(stageManager)
.retrieveWithTotals(id, {
select: defaultStoreCartFields,
relations: defaultStoreCartRelations,
})
return {
response_code: 200,
response_body: { cart },
return {
response_code: 200,
response_body: { cart },
}
}
}
)
if (error) {
)
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
packages/medusa/src/api/routes/store/returns/create-return.ts
+65 -78
View File
@@ -13,7 +13,6 @@ import { MedusaError } from "medusa-core-utils"
import { EntityManager } from "typeorm"
import EventBusService from "../../../../services/event-bus"
import IdempotencyKeyService from "../../../../services/idempotency-key"
import OrderService from "../../../../services/order"
import ReturnService from "../../../../services/return"
import { validator } from "../../../../utils/validator"
@@ -142,7 +141,6 @@ export default async (req, res) => {
res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key)
try {
const orderService: OrderService = req.scope.resolve("orderService")
const returnService: ReturnService = req.scope.resolve("returnService")
const eventBus: EventBusService = req.scope.resolve("eventBusService")
@@ -152,95 +150,84 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(returnDto.order_id, {
select: ["refunded_total", "total"],
relations: ["items"],
})
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const returnObj: any = {
order_id: returnDto.order_id,
idempotency_key: idempotencyKey.idempotency_key,
items: returnDto.items,
}
const returnObj: any = {
order_id: returnDto.order_id,
idempotency_key: idempotencyKey.idempotency_key,
items: returnDto.items,
}
if (returnDto.return_shipping) {
returnObj.shipping_method = returnDto.return_shipping
}
if (returnDto.return_shipping) {
returnObj.shipping_method = returnDto.return_shipping
}
const createdReturn = await returnService
.withTransaction(manager)
.create(returnObj)
if (returnDto.return_shipping) {
await returnService
const createdReturn = await returnService
.withTransaction(manager)
.fulfill(createdReturn.id)
}
.create(returnObj)
await eventBus
.withTransaction(manager)
.emit("order.return_requested", {
id: returnDto.order_id,
return_id: createdReturn.id,
})
if (returnDto.return_shipping) {
await returnService
.withTransaction(manager)
.fulfill(createdReturn.id)
}
return {
recovery_point: "return_requested",
}
})
await eventBus
.withTransaction(manager)
.emit("order.return_requested", {
id: returnDto.order_id,
return_id: createdReturn.id,
})
if (error) {
return {
recovery_point: "return_requested",
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "return_requested": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const returnOrders = await returnService
.withTransaction(manager)
.list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["items", "items.reason"],
}
)
if (!returnOrders.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Return not found`
)
}
const returnOrder = returnOrders[0]
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const returnOrders = await returnService
.withTransaction(manager)
.list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["items", "items.reason"],
}
)
if (!returnOrders.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Return not found`
)
}
const returnOrder = returnOrders[0]
return {
response_code: 200,
response_body: { return: returnOrder },
}
})
if (error) {
return {
response_code: 200,
response_body: { return: returnOrder },
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
packages/medusa/src/api/routes/store/swaps/create-swap.ts
+59 -66
View File
@@ -173,74 +173,71 @@ export default async (req, res) => {
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(swapDto.order_id, {
select: ["refunded_total", "total"],
relations: [
"items",
"items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
})
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(swapDto.order_id, {
select: ["refunded_total", "total"],
relations: [
"items",
"items.tax_lines",
"swaps",
"swaps.additional_items",
"swaps.additional_items.tax_lines",
],
})
let returnShipping
if (swapDto.return_shipping_option) {
returnShipping = {
option_id: swapDto.return_shipping_option,
}
}
const swap = await swapService
.withTransaction(manager)
.create(
order,
swapDto.return_items,
swapDto.additional_items,
returnShipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: true,
let returnShipping
if (swapDto.return_shipping_option) {
returnShipping = {
option_id: swapDto.return_shipping_option,
}
)
}
await swapService.withTransaction(manager).createCart(swap.id)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
const swap = await swapService
.withTransaction(manager)
.create(
order,
swapDto.return_items,
swapDto.additional_items,
returnShipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: true,
}
)
await returnService
.withTransaction(manager)
.fulfill(returnOrder.id)
await swapService.withTransaction(manager).createCart(swap.id)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
return {
recovery_point: "swap_created",
}
})
await returnService
.withTransaction(manager)
.fulfill(returnOrder.id)
if (error) {
return {
recovery_point: "swap_created",
}
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}
case "swap_created": {
await manager.transaction(async (transactionManager) => {
const { key, error } = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(
idempotencyKey.idempotency_key,
async (transactionManager: EntityManager) => {
await manager
.transaction("SERIALIZABLE", async (transactionManager) => {
idempotencyKey = await idempotencyKeyService
.withTransaction(transactionManager)
.workStage(idempotencyKey.idempotency_key, async (manager) => {
const swaps = await swapService
.withTransaction(transactionManager)
.list({
@@ -265,16 +262,12 @@ export default async (req, res) => {
response_code: 200,
response_body: { swap },
}
}
)
if (error) {
})
})
.catch((e) => {
inProgress = false
err = error
} else {
idempotencyKey = key
}
})
err = e
})
break
}