feat(region): Region create, delete, update admin endpoints (#6332)

**What**
Add `POST /admin/regions`
Add `POST /admin/regions/:id`
Add `DELETE /admin/regions/:id`

All are added for v2 using API Routes and workflows.

In follow-up PRs, I will add support for passing countries in update and create.

Update: First follow-up PR is #6372

packages/core-flows/src/index.ts

@@ -1,8 +1,10 @@
+export * from "./customer"
+export * from "./customer-group"
 export * from "./definition"
 export * from "./definitions"
 export * as Handlers from "./handlers"
-export * from "./promotion"
-export * from "./customer"
-export * from "./customer-group"
-export * from "./user"
 export * from "./invite"
+export * from "./promotion"
+export * from "./region"
+export * from "./user"
+

packages/core-flows/src/region/index.ts

@@ -0,0 +1,2 @@
+export * from "./steps"
+export * from "./workflows"

packages/core-flows/src/region/steps/create-regions.ts

@@ -0,0 +1,31 @@
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import { CreateRegionDTO, IRegionModuleService } from "@medusajs/types"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const createRegionsStepId = "create-regions"
+export const createRegionsStep = createStep(
+  createRegionsStepId,
+  async (data: CreateRegionDTO[], { container }) => {
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    const created = await service.create(data)
+
+    return new StepResponse(
+      created,
+      created.map((region) => region.id)
+    )
+  },
+  async (createdIds, { container }) => {
+    if (!createdIds?.length) {
+      return
+    }
+
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    await service.delete(createdIds)
+  }
+)

packages/core-flows/src/region/steps/delete-regions.ts

@@ -0,0 +1,28 @@
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import { IRegionModuleService } from "@medusajs/types"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const deleteRegionsStepId = "delete-regions"
+export const deleteRegionsStep = createStep(
+  deleteRegionsStepId,
+  async (ids: string[], { container }) => {
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    await service.softDelete(ids)
+
+    return new StepResponse(void 0, ids)
+  },
+  async (prevIds, { container }) => {
+    if (!prevIds?.length) {
+      return
+    }
+
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    await service.restore(prevIds)
+  }
+)

packages/core-flows/src/region/steps/index.ts

@@ -0,0 +1,3 @@
+export * from "./create-regions"
+export * from "./delete-regions"
+export * from "./update-regions"

packages/core-flows/src/region/steps/update-regions.ts

@@ -0,0 +1,54 @@
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import {
+  FilterableRegionProps,
+  IRegionModuleService,
+  UpdatableRegionFields,
+} from "@medusajs/types"
+import { getSelectsAndRelationsFromObjectArray } from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+type UpdateRegionsStepInput = {
+  selector: FilterableRegionProps
+  update: UpdatableRegionFields
+}
+
+export const updateRegionsStepId = "update-region"
+export const updateRegionsStep = createStep(
+  updateRegionsStepId,
+  async (data: UpdateRegionsStepInput, { container }) => {
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    const { selects, relations } = getSelectsAndRelationsFromObjectArray([
+      data.update,
+    ])
+
+    const prevData = await service.list(data.selector, {
+      select: selects,
+      relations,
+    })
+
+    const regions = await service.update(data.selector, data.update)
+
+    return new StepResponse(regions, prevData)
+  },
+  async (prevData, { container }) => {
+    if (!prevData?.length) {
+      return
+    }
+
+    const service = container.resolve<IRegionModuleService>(
+      ModuleRegistrationName.REGION
+    )
+
+    await service.update(
+      prevData.map((r) => ({
+        id: r.id,
+        name: r.name,
+        currency_code: r.currency_code,
+        metadata: r.metadata,
+      }))
+    )
+  }
+)

packages/core-flows/src/region/workflows/create-regions.ts

@@ -0,0 +1,13 @@
+import { CreateRegionDTO, RegionDTO } from "@medusajs/types"
+import { WorkflowData, createWorkflow } from "@medusajs/workflows-sdk"
+import { createRegionsStep } from "../steps"
+
+type WorkflowInput = { regionsData: CreateRegionDTO[] }
+
+export const createRegionsWorkflowId = "create-regions"
+export const createRegionsWorkflow = createWorkflow(
+  createRegionsWorkflowId,
+  (input: WorkflowData<WorkflowInput>): WorkflowData<RegionDTO[]> => {
+    return createRegionsStep(input.regionsData)
+  }
+)

packages/core-flows/src/region/workflows/delete-regions.ts

@@ -0,0 +1,12 @@
+import { WorkflowData, createWorkflow } from "@medusajs/workflows-sdk"
+import { deleteRegionsStep } from "../steps"
+
+type WorkflowInput = { ids: string[] }
+
+export const deleteRegionsWorkflowId = "delete-regions"
+export const deleteRegionsWorkflow = createWorkflow(
+  deleteRegionsWorkflowId,
+  (input: WorkflowData<WorkflowInput>): WorkflowData<void> => {
+    return deleteRegionsStep(input.ids)
+  }
+)

packages/core-flows/src/region/workflows/index.ts

@@ -0,0 +1,3 @@
+export * from "./create-regions"
+export * from "./delete-regions"
+export * from "./update-regions"

packages/core-flows/src/region/workflows/update-regions.ts

@@ -0,0 +1,22 @@
+import {
+  FilterableRegionProps,
+  RegionDTO,
+  UpdatableRegionFields,
+} from "@medusajs/types"
+import { WorkflowData, createWorkflow } from "@medusajs/workflows-sdk"
+import { updateRegionsStep } from "../steps"
+
+type UpdateRegionsStepInput = {
+  selector: FilterableRegionProps
+  update: UpdatableRegionFields
+}
+
+type WorkflowInput = UpdateRegionsStepInput
+
+export const updateRegionsWorkflowId = "update-regions"
+export const updateRegionsWorkflow = createWorkflow(
+  updateRegionsWorkflowId,
+  (input: WorkflowData<WorkflowInput>): WorkflowData<RegionDTO[]> => {
+    return updateRegionsStep(input)
+  }
+)

packages/medusa/src/api-v2/admin/regions/[id]/route.ts

@@ -1,3 +1,8 @@
+import {
+  deleteRegionsWorkflow,
+  updateRegionsWorkflow,
+} from "@medusajs/core-flows"
+import { UpdatableRegionFields } from "@medusajs/types"
 import { remoteQueryObjectFromString } from "@medusajs/utils"
 import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
 import { defaultAdminRegionFields } from "../query-config"
@@ -17,3 +22,38 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
   res.status(200).json({ region })
 }
+
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { result, errors } = await updateRegionsWorkflow(req.scope).run({
+    input: {
+      selector: { id: req.params.id },
+      update: req.validatedBody as UpdatableRegionFields,
+    },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({ region: result[0] })
+}
+
+export const DELETE = async (req: MedusaRequest, res: MedusaResponse) => {
+  const id = req.params.id
+
+  const { errors } = await deleteRegionsWorkflow(req.scope).run({
+    input: { ids: [id] },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({
+    id,
+    object: "region",
+    deleted: true,
+  })
+}

packages/medusa/src/api-v2/admin/regions/middlewares.ts

@@ -1,9 +1,11 @@
-import { transformQuery } from "../../../api/middlewares"
+import { transformBody, transformQuery } from "../../../api/middlewares"
 import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
 import * as QueryConfig from "./query-config"
 import {
   AdminGetRegionsParams,
   AdminGetRegionsRegionParams,
+  AdminPostRegionsRegionReq,
+  AdminPostRegionsReq,
 } from "./validators"
 
 export const adminRegionRoutesMiddlewares: MiddlewareRoute[] = [
@@ -27,4 +29,14 @@ export const adminRegionRoutesMiddlewares: MiddlewareRoute[] = [
       ),
     ],
   },
+  {
+    method: ["POST"],
+    matcher: "/admin/regions",
+    middlewares: [transformBody(AdminPostRegionsReq)],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/regions/:id",
+    middlewares: [transformBody(AdminPostRegionsRegionReq)],
+  },
 ]

packages/medusa/src/api-v2/admin/regions/query-config.ts

@@ -1,3 +1,5 @@
+export const defaultAdminRegionRelations = ["countries", "currency"]
+export const allowedAdminRegionRelations = ["countries", "currency"]
 export const defaultAdminRegionFields = [
   "id",
   "name",
@@ -18,6 +20,9 @@ export const defaultAdminRegionFields = [
 ]
 
 export const retrieveTransformQueryConfig = {
+  defaultFields: defaultAdminRegionFields,
+  defaultRelations: defaultAdminRegionRelations,
+  allowedRelations: allowedAdminRegionRelations,
   isList: false,
 }
 

packages/medusa/src/api-v2/admin/regions/route.ts

@@ -1,3 +1,5 @@
+import { createRegionsWorkflow } from "@medusajs/core-flows"
+import { CreateRegionDTO } from "@medusajs/types"
 import { remoteQueryObjectFromString } from "@medusajs/utils"
 import { MedusaRequest, MedusaResponse } from "../../../types/routing"
 import { defaultAdminRegionFields } from "./query-config"
@@ -5,16 +7,42 @@ import { defaultAdminRegionFields } from "./query-config"
 export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   const remoteQuery = req.scope.resolve("remoteQuery")
 
-  const variables = { filters: req.filterableFields }
-
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "region",
-    variables,
+    variables: {
+      filters: req.filterableFields,
+      order: req.listConfig.order,
+      skip: req.listConfig.skip,
+      take: req.listConfig.take,
+    },
     fields: defaultAdminRegionFields,
   })
 
-  // TODO: Add count, offset, limit
-  const regions = await remoteQuery(queryObject)
+  const { rows: regions, metadata } = await remoteQuery(queryObject)
 
-  res.json({ regions })
+  res.json({
+    regions,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}
+
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const input = [
+    {
+      ...(req.validatedBody as CreateRegionDTO),
+    },
+  ]
+
+  const { result, errors } = await createRegionsWorkflow(req.scope).run({
+    input: { regionsData: input },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({ region: result[0] })
 }

packages/medusa/src/api-v2/admin/regions/validators.ts

@@ -69,3 +69,21 @@ export class AdminGetRegionsParams extends extendedFindParamsMixin({
   @Type(() => AdminGetRegionsParams)
   $or?: AdminGetRegionsParams[]
 }
+
+export class AdminPostRegionsReq {
+  @IsString()
+  name: string
+
+  @IsString()
+  currency_code: string
+}
+
+export class AdminPostRegionsRegionReq {
+  @IsString()
+  @IsOptional()
+  name?: string
+
+  @IsString()
+  @IsOptional()
+  currency_code?: string
+}

packages/medusa/src/models/payment.ts

@@ -10,11 +10,11 @@ import {
 import { DbAwareColumn, resolveDbType } from "../utils/db-aware-column"
 
 import { BaseEntity } from "../interfaces/models/base-entity"
+import { generateEntityId } from "../utils/generate-entity-id"
 import { Cart } from "./cart"
 import { Currency } from "./currency"
 import { Order } from "./order"
 import { Swap } from "./swap"
-import { generateEntityId } from "../utils/generate-entity-id"
 
 @Index(["cart_id"], { where: "canceled_at IS NOT NULL" })
 @Index("UniquePaymentActive", ["cart_id"], {

packages/region/src/services/region-module.ts

@@ -2,6 +2,7 @@ import {
   Context,
   CreateRegionDTO,
   DAL,
+  FilterableRegionProps,
   InternalModuleDeclaration,
   IRegionModuleService,
   ModuleJoinerConfig,
@@ -9,11 +10,14 @@ import {
   RegionCountryDTO,
   RegionCurrencyDTO,
   RegionDTO,
+  UpdatableRegionFields,
   UpdateRegionDTO,
 } from "@medusajs/types"
 import {
   InjectManager,
   InjectTransactionManager,
+  isObject,
+  isString,
   MedusaContext,
   MedusaError,
   ModulesSdkUtils,
@@ -188,26 +192,68 @@ export default class RegionModuleService<
   }
 
   async update(
-    data: UpdateRegionDTO[],
+    selector: FilterableRegionProps,
+    data: UpdatableRegionFields,
     sharedContext?: Context
   ): Promise<RegionDTO[]>
   async update(
-    data: UpdateRegionDTO,
+    regionId: string,
+    data: UpdatableRegionFields,
     sharedContext?: Context
   ): Promise<RegionDTO>
-  @InjectTransactionManager("baseRepository_")
+  async update(data: UpdateRegionDTO[]): Promise<RegionDTO[]>
+  @InjectManager("baseRepository_")
   async update(
-    data: UpdateRegionDTO | UpdateRegionDTO[],
+    idOrSelectorOrData: string | FilterableRegionProps | UpdateRegionDTO[],
+    data?: UpdatableRegionFields,
     @MedusaContext() sharedContext: Context = {}
   ): Promise<RegionDTO | RegionDTO[]> {
-    const result = await this.regionService_.update(data, sharedContext)
+    const result = await this.update_(idOrSelectorOrData, data, sharedContext)
 
-    return await this.baseRepository_.serialize<RegionDTO[]>(
-      Array.isArray(data) ? result : result[0],
-      {
-        populate: true,
-      }
-    )
+    const regions = await this.baseRepository_.serialize<
+      RegionDTO[] | RegionDTO
+    >(result)
+
+    return isString(idOrSelectorOrData) ? regions[0] : regions
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  protected async update_(
+    idOrSelectorOrData: string | FilterableRegionProps | UpdateRegionDTO[],
+    data?: UpdatableRegionFields,
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<Region[]> {
+    let result: Region[] = []
+    if (isString(idOrSelectorOrData)) {
+      result = await this.regionService_.update(
+        [{ id: idOrSelectorOrData, ...data }],
+        sharedContext
+      )
+    }
+
+    if (Array.isArray(idOrSelectorOrData)) {
+      result = await this.regionService_.update(
+        idOrSelectorOrData,
+        sharedContext
+      )
+    }
+
+    if (isObject(idOrSelectorOrData)) {
+      let toUpdate: Partial<UpdateRegionDTO>[] = []
+      const regions = await this.regionService_.list(
+        { ...idOrSelectorOrData },
+        {},
+        sharedContext
+      )
+
+      regions.forEach((region) => {
+        toUpdate.push({ id: region.id, ...data })
+      })
+
+      result = await this.regionService_.update(toUpdate, sharedContext)
+    }
+
+    return result
   }
 
   @InjectManager("baseRepository_")

packages/types/src/region/mutations.ts

@@ -1,24 +1,22 @@
-import { RegionCurrencyDTO } from "./common"
-
 export interface CreateRegionDTO {
   name: string
   currency_code: string
-  currency?: RegionCurrencyDTO
   countries?: string[]
-  tax_code?: string
-  tax_rate?: number
-  tax_provider_id?: string
+  metadata?: Record<string, unknown>
 }
 
 export interface UpdateRegionDTO {
   id: string
   currency_code?: string
-  currency?: RegionCurrencyDTO
-  countries: string[]
+  countries?: string[]
   name?: string
-  tax_code?: string
-  tax_rate?: number
-  tax_provider_id?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface UpdatableRegionFields {
+  currency_code?: string
+  name?: string
+  metadata?: Record<string, unknown>
 }
 
 export interface AddCountryToRegionDTO {

packages/types/src/region/service.ts

@@ -10,14 +10,27 @@ import {
   RegionCurrencyDTO,
   RegionDTO,
 } from "./common"
-import { CreateRegionDTO, UpdateRegionDTO } from "./mutations"
+import {
+  CreateRegionDTO,
+  UpdatableRegionFields,
+  UpdateRegionDTO,
+} from "./mutations"
 
 export interface IRegionModuleService extends IModuleService {
   create(data: CreateRegionDTO[], sharedContext?: Context): Promise<RegionDTO[]>
   create(data: CreateRegionDTO, sharedContext?: Context): Promise<RegionDTO>
 
-  update(data: UpdateRegionDTO[], sharedContext?: Context): Promise<RegionDTO[]>
-  update(data: UpdateRegionDTO, sharedContext?: Context): Promise<RegionDTO>
+  update(data: UpdateRegionDTO[]): Promise<RegionDTO[]>
+  update(
+    selector: FilterableRegionProps,
+    data: UpdatableRegionFields,
+    sharedContext?: Context
+  ): Promise<RegionDTO[]>
+  update(
+    regionId: string,
+    data: UpdatableRegionFields,
+    sharedContext?: Context
+  ): Promise<RegionDTO>
 
   delete(ids: string[], sharedContext?: Context): Promise<void>
   delete(id: string, sharedContext?: Context): Promise<void>