chore: rename route from api-v2 to api (#7379)

* chore: rename route from api-v2 to api

* chore: change oas references

* chore: remove v2 ref

packages/medusa/src/api/admin/users/[id]/route.ts

@@ -0,0 +1,90 @@
+import { deleteUsersWorkflow, updateUsersWorkflow } from "@medusajs/core-flows"
+import { UpdateUserDTO } from "@medusajs/types"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
+
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import { AdminUpdateUserType } from "../validators"
+import { refetchUser } from "../helpers"
+
+// Get user
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const { id } = req.params
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "user",
+    variables: { id },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [user] = await remoteQuery(query)
+  if (!user) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_FOUND,
+      `User with id: ${id} was not found`
+    )
+  }
+
+  res.status(200).json({ user })
+}
+
+// update user
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminUpdateUserType>,
+  res: MedusaResponse
+) => {
+  const workflow = updateUsersWorkflow(req.scope)
+
+  const input = {
+    updates: [
+      {
+        id: req.params.id,
+        ...req.validatedBody,
+      } as UpdateUserDTO,
+    ],
+  }
+
+  const { result } = await workflow.run({ input })
+
+  const user = await refetchUser(
+    req.params.id,
+    req.scope,
+    req.remoteQueryConfig.fields
+  )
+
+  res.status(200).json({ user })
+}
+
+// delete user
+export const DELETE = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const { id } = req.params
+  const workflow = deleteUsersWorkflow(req.scope)
+
+  const { errors } = await workflow.run({
+    input: { ids: [id] },
+    throwOnError: false,
+  })
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  res.status(200).json({
+    id,
+    object: "user",
+    deleted: true,
+  })
+}

packages/medusa/src/api/admin/users/helpers.ts

@@ -0,0 +1,23 @@
+import { MedusaContainer } from "@medusajs/types"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+
+export const refetchUser = async (
+  userId: string,
+  scope: MedusaContainer,
+  fields: string[]
+) => {
+  const remoteQuery = scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "user",
+    variables: {
+      filters: { id: userId },
+    },
+    fields: fields,
+  })
+
+  const users = await remoteQuery(queryObject)
+  return users[0]
+}

packages/medusa/src/api/admin/users/me/route.ts

@@ -0,0 +1,38 @@
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../types/routing"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const id = req.auth.app_metadata.user_id
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  if (!id) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, `User ID not found`)
+  }
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "user",
+    variables: { id },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [user] = await remoteQuery(query)
+
+  if (!user) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_FOUND,
+      `User with id: ${id} was not found`
+    )
+  }
+
+  res.status(200).json({ user })
+}

packages/medusa/src/api/admin/users/middlewares.ts

@@ -0,0 +1,78 @@
+import * as QueryConfig from "./query-config"
+
+import {
+  AdminCreateUser,
+  AdminGetUserParams,
+  AdminGetUsersParams,
+  AdminUpdateUser,
+} from "./validators"
+
+import { MiddlewareRoute } from "../../../types/middlewares"
+import { authenticate } from "../../../utils/middlewares/authenticate-middleware"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+import { validateAndTransformBody } from "../../utils/validate-body"
+
+export const adminUserRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    method: ["GET"],
+    matcher: "/admin/users",
+    middlewares: [
+      authenticate("admin", ["bearer", "session"]),
+      validateAndTransformQuery(
+        AdminGetUsersParams,
+        QueryConfig.listTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/users",
+    middlewares: [
+      authenticate("admin", ["bearer", "session"], { allowUnregistered: true }),
+      validateAndTransformBody(AdminCreateUser),
+      validateAndTransformQuery(
+        AdminGetUserParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/users/:id",
+    middlewares: [
+      authenticate("admin", ["bearer", "session"]),
+      validateAndTransformQuery(
+        AdminGetUserParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/admin/users/me",
+    middlewares: [
+      authenticate("admin", ["bearer", "session"]),
+      validateAndTransformQuery(
+        AdminGetUserParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["POST"],
+    matcher: "/admin/users/:id",
+    middlewares: [
+      authenticate("admin", ["bearer", "session"]),
+      validateAndTransformBody(AdminUpdateUser),
+      validateAndTransformQuery(
+        AdminGetUserParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["DELETE"],
+    matcher: "/admin/users/:id",
+    middlewares: [authenticate("admin", ["bearer", "session"])],
+  },
+]

packages/medusa/src/api/admin/users/query-config.ts

@@ -0,0 +1,21 @@
+export const defaultAdminUserFields = [
+  "id",
+  "first_name",
+  "last_name",
+  "email",
+  "avatar_url",
+  "metadata",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+]
+
+export const retrieveTransformQueryConfig = {
+  defaults: defaultAdminUserFields,
+  isList: false,
+}
+
+export const listTransformQueryConfig = {
+  ...retrieveTransformQueryConfig,
+  isList: true,
+}

packages/medusa/src/api/admin/users/route.ts

@@ -0,0 +1,80 @@
+import { createUserAccountWorkflow } from "@medusajs/core-flows"
+import { CreateUserDTO } from "@medusajs/types"
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import jwt from "jsonwebtoken"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
+import { refetchUser } from "./helpers"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const query = remoteQueryObjectFromString({
+    entryPoint: "user",
+    variables: {
+      filters: req.filterableFields,
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: users, metadata } = await remoteQuery(query)
+  res.status(200).json({
+    users,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<CreateUserDTO>,
+  res: MedusaResponse
+) => {
+  // If `actor_id` is present, the request carries authentication for an existing user
+  if (req.auth.actor_id) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Request carries authentication for an existing user"
+    )
+  }
+
+  const input = {
+    input: {
+      userData: req.validatedBody,
+      authUserId: req.auth.auth_user_id,
+    },
+    throwOnError: false,
+  }
+
+  const { errors } = await createUserAccountWorkflow(req.scope).run(input)
+
+  if (Array.isArray(errors) && errors[0]) {
+    throw errors[0].error
+  }
+
+  const user = await refetchUser(
+    req.auth.auth_user_id,
+    req.scope,
+    req.remoteQueryConfig.fields
+  )
+
+  const { http } = req.scope.resolve(
+    ContainerRegistrationKeys.CONFIG_MODULE
+  ).projectConfig
+
+  const token = jwt.sign(user, http.jwtSecret, {
+    expiresIn: http.jwtExpiresIn,
+  })
+
+  res.status(200).json({ user, token })
+}

packages/medusa/src/api/admin/users/validators.ts

@@ -0,0 +1,40 @@
+import {
+  createFindParams,
+  createOperatorMap,
+  createSelectParams,
+} from "../../utils/validators"
+import { z } from "zod"
+
+export const AdminGetUserParams = createSelectParams()
+
+export type AdminGetUsersParamsType = z.infer<typeof AdminGetUsersParams>
+export const AdminGetUsersParams = createFindParams({
+  offset: 0,
+  limit: 50,
+}).merge(
+  z.object({
+    q: z.string().optional(),
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+    email: z.string().optional(),
+    first_name: z.string().optional(),
+    last_name: z.string().optional(),
+  })
+)
+
+export type AdminCreateUserType = z.infer<typeof AdminCreateUser>
+export const AdminCreateUser = z.object({
+  email: z.string(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  avatar_url: z.string().optional(),
+})
+
+export type AdminUpdateUserType = z.infer<typeof AdminUpdateUser>
+export const AdminUpdateUser = z.object({
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  avatar_url: z.string().optional(),
+})