@csbeker/medusa-product-attributes 2.2.0

package/src/api/admin/plugin/attributes/[id]/values/route.ts

@@ -0,0 +1,39 @@
+import { AdminCreateAttributeValueType, AdminGetAttributeValuesParamsType } from "../../validators";
+import { MedusaRequest, MedusaResponse, refetchEntities, refetchEntity } from "@medusajs/framework";
+
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { createAttributePossibleValuesWorkflow } from "../../../../../../workflows/attribute/workflows/create-attribute-possible-values";
+
+export const GET = async (req: MedusaRequest<AdminGetAttributeValuesParamsType>, res: MedusaResponse) => {
+    const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+
+    const { data: attributePossibleValues, metadata } = await query.graph({
+        entity: 'attribute_possible_value',
+        filters: {
+            attribute_id: req.params.id
+        },
+        ...req.queryConfig
+    })
+
+    res.status(200).json({ attributePossibleValues, count: metadata?.count, offset: metadata?.skip, limit: metadata?.take })
+}
+
+export const POST = async (req: MedusaRequest<AdminCreateAttributeValueType>, res: MedusaResponse) => {
+    const attributeId = req.params.id
+
+    const { result: [createdAttributeValue] } = await createAttributePossibleValuesWorkflow(req.scope).run({
+        input: [{
+            ...req.validatedBody,
+            attribute_id: attributeId
+        }]
+    })
+
+    const attributePossibleValue = await refetchEntity(
+        'attribute_possible_value',
+        createdAttributeValue.id,
+        req.scope,
+        req.queryConfig.fields,
+    )
+
+    return res.status(201).json({ attributePossibleValue })
+}

package/src/api/admin/plugin/attributes/middlewares.ts

@@ -0,0 +1,91 @@
+import { MiddlewareRoute, validateAndTransformBody, validateAndTransformQuery } from "@medusajs/framework";
+import { AdminCreateAttribute, AdminCreateAttributeValue, AdminGetAttributeParams, AdminGetAttributesParams, AdminGetAttributeValueParams, AdminGetAttributeValuesParams, AdminUpdateAttribute, AdminUpdateAttributeValue } from "./validators";
+import * as QueryConfig from './query-config'
+import { adminAttributesRoutePath } from "../../../utils/constants";
+
+export const adminAttributeRoutesMiddlewares: MiddlewareRoute[] = [
+    {
+        method: ['GET'],
+        matcher: adminAttributesRoutePath,
+        middlewares: [
+            validateAndTransformQuery(
+                AdminGetAttributesParams,
+                QueryConfig.listAttributeQueryConfig,
+            )
+        ]
+    },
+    {
+        method: ['POST'],
+        matcher: adminAttributesRoutePath,
+        middlewares: [
+            validateAndTransformBody(AdminCreateAttribute),
+            validateAndTransformQuery(
+                AdminGetAttributeParams,
+                QueryConfig.retrieveAttributeQueryConfig
+            )
+        ]
+    },
+    {
+        method: ['GET'],
+        matcher: `${adminAttributesRoutePath}/:id`,
+        middlewares: [
+            validateAndTransformQuery(
+                AdminGetAttributeParams,
+                QueryConfig.retrieveAttributeQueryConfig
+            )
+        ]
+    },
+    {
+        method: ['POST'],
+        matcher: `${adminAttributesRoutePath}/:id`,
+        middlewares: [
+            validateAndTransformBody(AdminUpdateAttribute),
+            validateAndTransformQuery(
+                AdminGetAttributeParams,
+                QueryConfig.retrieveAttributeQueryConfig
+            )
+        ]
+    },
+    {
+        method: ['GET'],
+        matcher: `${adminAttributesRoutePath}/:id/values`,
+        middlewares: [
+            validateAndTransformQuery(
+                AdminGetAttributeValuesParams,
+                QueryConfig.listAttributeValueQueryConfig,
+            )
+        ]
+    },
+    {
+        method: ['POST'],
+        matcher: `${adminAttributesRoutePath}/:id/values`,
+        middlewares: [
+            validateAndTransformBody(AdminCreateAttributeValue),
+            validateAndTransformQuery(
+                AdminGetAttributeValueParams,
+                QueryConfig.retrieveAttributeValueQueryConfig,
+            )
+        ]
+    },
+    {
+        method: ['GET'],
+        matcher: `${adminAttributesRoutePath}/:id/values/:valueId`,
+        middlewares: [
+            validateAndTransformQuery(
+                AdminGetAttributeValueParams,
+                QueryConfig.retrieveAttributeValueQueryConfig
+            )
+        ]
+    },
+    {
+        method: ['POST'],
+        matcher: `${adminAttributesRoutePath}/:id/values/:valueId`,
+        middlewares: [
+            validateAndTransformBody(AdminUpdateAttributeValue),
+            validateAndTransformQuery(
+                AdminGetAttributeValueParams,
+                QueryConfig.retrieveAttributeValueQueryConfig
+            )
+        ]
+    }
+]

package/src/api/admin/plugin/attributes/query-config.ts

@@ -0,0 +1,42 @@
+export const defaultAdminAttributeFields = [
+    'id',
+    'name',
+    'description',
+    'is_variant_defining',
+    'is_filterable',
+    'handle',
+    'ui_component',
+    'metadata',
+    '*possible_values',
+    'product_categories.id',
+    'product_categories.name',
+]
+
+export const retrieveAttributeQueryConfig = {
+    defaults: defaultAdminAttributeFields,
+    isList: false,
+}
+
+export const listAttributeQueryConfig = {
+    ...retrieveAttributeQueryConfig,
+    defaultLimit: 50,
+    isList: true,
+}
+
+export const defaultAdminAttributeValueFields = [
+    'id',
+    'value',
+    'rank',
+    'metadata',
+]
+
+export const retrieveAttributeValueQueryConfig = {
+    defaults: defaultAdminAttributeValueFields,
+    isList: false,
+}
+
+export const listAttributeValueQueryConfig = {
+    ...retrieveAttributeValueQueryConfig,
+    isList: true,
+    defaultLimit: 50,
+}

package/src/api/admin/plugin/attributes/route.ts

@@ -0,0 +1,33 @@
+import { MedusaRequest, MedusaResponse, refetchEntities, refetchEntity } from "@medusajs/framework";
+import { AdminCreateAttributeType, AdminGetAttributesParamsType } from "./validators";
+import { createAttributesWorkflow } from "../../../../workflows";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+
+export const GET = async (req: MedusaRequest<AdminGetAttributesParamsType>, res: MedusaResponse) => {
+    const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+    // TODO: check why, even though *product_categories is in default fields
+    // only the id is returned for each category
+    const { data: attributes, metadata } = await query.graph({
+        entity: 'attribute',
+        filters: req.filterableFields,
+        ...req.queryConfig
+    })
+    return res.status(200).json({ attributes, count: metadata?.count, offset: metadata?.skip, limit: metadata?.take })
+}
+
+export const POST = async (req: MedusaRequest<AdminCreateAttributeType>, res: MedusaResponse) => {
+    const attributeDto = req.validatedBody
+
+    const { result } = await createAttributesWorkflow(req.scope).run({
+        input: { attributes: [attributeDto] },
+    })
+
+    const attribute = await refetchEntity(
+        'attribute',
+        result[0].id,
+        req.scope,
+        req.queryConfig?.fields ?? []
+    )
+
+    res.status(201).json({ attribute })
+}

package/src/api/admin/plugin/attributes/validators.ts

@@ -0,0 +1,91 @@
+import { createFindParams, createOperatorMap, createSelectParams, WithAdditionalData } from '@medusajs/medusa/api/utils/validators'
+
+import { z } from 'zod'
+import { AttributeUIComponent } from '../../../../modules/attribute/types'
+import { applyAndAndOrOperators } from '@medusajs/medusa/api/utils/common-validators/common'
+import { GetAttributeSetsParams } from '../attribute-set/validators'
+
+export type AdminGetAttributeValueParamsType = z.infer<typeof AdminGetAttributeValueParams>
+export const AdminGetAttributeValueParams = createSelectParams()
+
+export type AdminGetAttributeValuesParamsType = z.infer<typeof AdminGetAttributeValueParams>
+export const AdminGetAttributeValuesParams = createFindParams()
+
+export type AdminGetAttributeParamsType = z.infer<typeof AdminGetAttributeParams>
+export const AdminGetAttributeParams = createSelectParams()
+
+export const GetAttributesParams = z.object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    is_variant_defining: z.boolean().optional(),
+    is_filterable: z.boolean().optional(),
+    handle: z.string().optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+    ui_component: z.nativeEnum(AttributeUIComponent).optional(),
+    sets: GetAttributeSetsParams.merge(
+        applyAndAndOrOperators(GetAttributeSetsParams)
+    ).optional()
+})
+export type AdminGetAttributesParamsType = z.infer<typeof AdminGetAttributesParams>
+export const AdminGetAttributesParams = createFindParams({
+    offset: 0,
+    limit: 50,
+})
+.merge(applyAndAndOrOperators(GetAttributesParams))
+.merge(GetAttributesParams)
+
+export type AdminCreateAttributeValueType = z.infer<typeof AdminCreateAttributeValue>
+export const AdminCreateAttributeValue = z.object({
+    value: z.string().min(1),
+    rank: z.number(),
+    metadata: z.record(z.unknown()).optional(),
+})
+
+export type AdminUpdateAttributeValueType = z.infer<typeof AdminUpdateAttributeValue>
+export const AdminUpdateAttributeValue = z.object({
+    id: z.string().optional(),
+    value: z.string().optional(),
+    rank: z.number().optional(),
+    metadata: z.record(z.unknown()).nullish(),
+})
+
+export type AdminUpdateAttributeType = z.infer<typeof AdminUpdateAttribute>
+export const AdminUpdateAttribute = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    is_variant_defining: z.boolean().optional(),
+    is_filterable: z.boolean().optional(),
+    handle: z.string().nullish(),
+    metadata: z.record(z.unknown()).nullish(),
+    ui_component: z.nativeEnum(AttributeUIComponent).optional(),
+    product_category_ids: z.array(z.string()).nullish(),
+    possible_values: z.array(AdminUpdateAttributeValue).optional()
+}).strict()
+
+export type AdminCreateAttributeType = z.infer<typeof CreateAttribute>
+export const CreateAttribute = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    ui_component: z.nativeEnum(AttributeUIComponent).default(AttributeUIComponent.SELECT),
+    is_variant_defining: z.boolean().default(true),
+    is_filterable: z.boolean().default(true),
+    handle: z.string().optional(),
+    metadata: z.record(z.unknown()).nullish(),
+    possible_values: z.array(AdminCreateAttributeValue).optional(),
+    product_category_ids: z.array(z.string()).optional()
+})
+
+export const AdminCreateAttribute = WithAdditionalData(
+    CreateAttribute,
+    (schema) => {
+      return schema.refine(
+        (data) => data.ui_component !== AttributeUIComponent.SELECT || (data.possible_values && data.possible_values.length > 0),
+        {
+            message: "Possible values are required when ui_component is SELECT",
+            path: ["possible_values"]
+        }
+    )
+    }
+  )

package/src/api/admin/plugin/route.ts

@@ -0,0 +1,8 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+) {
+  res.sendStatus(200);
+}

package/src/api/middlewares.ts

@@ -0,0 +1,10 @@
+import { defineMiddlewares } from "@medusajs/framework";
+import { adminRoutesMiddlewares } from "./admin/middlewares";
+import { storeMiddlewaresRoutes } from "./store/middlewares";
+
+export default defineMiddlewares({
+    routes: [
+        ...adminRoutesMiddlewares,
+        ...storeMiddlewaresRoutes,
+    ]
+})

package/src/api/store/middlewares.ts

@@ -0,0 +1,6 @@
+import { MiddlewareRoute } from "@medusajs/framework";
+import { storeAttributesMiddlewaresRoute } from "./plugin/attributes/middlewares";
+
+export const storeMiddlewaresRoutes: MiddlewareRoute[] = [
+    ...storeAttributesMiddlewaresRoute
+]

package/src/api/store/plugin/attributes/middlewares.ts

@@ -0,0 +1,33 @@
+import {
+  clearFiltersByKey,
+  maybeApplyLinkFilter,
+  MiddlewareRoute,
+  validateAndTransformQuery,
+} from "@medusajs/framework";
+import { storeAttributesBaseRoute } from "../../../utils/constants";
+import { StoreGetAttributesParams } from "./validators";
+import * as QueryConfig from "./query-config";
+import { storeAttributesProductsMiddlewares } from "./products/middlewares";
+import attributeProductCategory from "../../../../links/attribute-product-category";
+import { addGlobalAttributesIfNecessary } from "../../../utils/middlewares";
+
+export const storeAttributesMiddlewaresRoute: MiddlewareRoute[] = [
+  {
+    methods: ["GET"],
+    matcher: storeAttributesBaseRoute,
+    middlewares: [
+      validateAndTransformQuery(
+        StoreGetAttributesParams,
+        QueryConfig.storeListAttributesQueryConfig
+      ),
+      maybeApplyLinkFilter({
+        entryPoint: attributeProductCategory.entryPoint,
+        resourceId: 'attribute_id',
+        filterableField: 'product_category_id'
+      }),
+      addGlobalAttributesIfNecessary(),
+      clearFiltersByKey(['include_globals']),
+    ],
+  },
+  ...storeAttributesProductsMiddlewares,
+];

package/src/api/store/plugin/attributes/products/middlewares.ts

@@ -0,0 +1,73 @@
+import { applyDefaultFilters, authenticate, clearFiltersByKey, maybeApplyLinkFilter, MiddlewareRoute, validateAndTransformQuery } from "@medusajs/framework";
+import { FeatureFlag, ProductStatus, isPresent } from "@medusajs/framework/utils";
+import { StoreGetProductsParams } from "@medusajs/medusa/api/store/products/validators";
+import { filterByValidSalesChannels, normalizeDataForContext, setPricingContext, setTaxContext } from "@medusajs/medusa/api/utils/middlewares/index";
+import * as OriginalQueryConfig from "@medusajs/medusa/api/store/products/query-config"
+import { ExtendedStoreGetProductsParams } from "./validators";
+import attributeValueProduct from "../../../../../links/attribute-value-product";
+
+// TODO: Remove once https://github.com/medusajs/medusa/pull/13714 is merged and import instead
+const IndexEngineFeatureFlag = {
+  key: "index_engine",
+  default_val: false,
+  env_key: "MEDUSA_FF_INDEX_ENGINE",
+  description: "Enable Medusa to use the index engine in some part of the core",
+};
+
+export const storeAttributesProductsMiddlewares: MiddlewareRoute[] = [
+    {
+        method: ["GET"],
+        matcher: "/store/plugin/attributes/products",
+        middlewares: [
+          authenticate("customer", ["session", "bearer"], {
+            allowUnauthenticated: true,
+          }),
+          validateAndTransformQuery(
+            ExtendedStoreGetProductsParams,
+            OriginalQueryConfig.listProductQueryConfig
+          ),
+          filterByValidSalesChannels(),
+          (req, res, next) => {
+            const canUseIndex = !(
+              isPresent(req.filterableFields.tags) ||
+              isPresent(req.filterableFields.categories)
+            )
+            if (
+              FeatureFlag.isFeatureEnabled(IndexEngineFeatureFlag.key) &&
+              canUseIndex
+            ) {
+              return next()
+            }
+    
+            return maybeApplyLinkFilter({
+              entryPoint: "product_sales_channel",
+              resourceId: "product_id",
+              filterableField: "sales_channel_id",
+            })(req, res, next)
+          },
+          applyDefaultFilters({
+            status: ProductStatus.PUBLISHED,
+            // TODO: the type here seems off and the implementation does not take into account $and and $or possible filters. Might be worth re working (original type used here was StoreGetProductsParamsType)
+            categories: (filters: any, fields: string[]) => {
+              const categoryIds = filters.category_id
+              delete filters.category_id
+    
+              if (!isPresent(categoryIds)) {
+                return
+              }
+    
+              return { id: categoryIds, is_internal: false, is_active: true }
+            },
+          }),
+          maybeApplyLinkFilter({
+            entryPoint: attributeValueProduct.entryPoint,
+            filterableField: 'attribute_value_id',
+            resourceId: 'product_id'
+          }),
+          normalizeDataForContext(),
+          setPricingContext(),
+          setTaxContext(),
+          clearFiltersByKey(["region_id", "country_code", "province", "cart_id"]),
+        ],
+      },
+] 

package/src/api/store/plugin/attributes/products/query-config.ts

@@ -0,0 +1,19 @@
+import { defaultStoreProductFields } from "@medusajs/medusa/api/store/products/query-config";
+
+const defaultExtendedStoreProductFields = [
+    '*attribute_values',
+]
+
+export const retrieveProductQueryConfig = {
+    defaults: [
+        ...defaultStoreProductFields,
+        ...defaultExtendedStoreProductFields
+    ],
+    isList: false,
+} 
+
+export const listProductQueryConfig = {
+    ...retrieveProductQueryConfig,
+    isList: true,
+    defaultLimit: 50,
+}

package/src/api/store/plugin/attributes/products/route.ts

@@ -0,0 +1,68 @@
+// TODO: This is messy, but since Medusa doesn't allow to extend Core GET routes
+// params validators, the only way i see to query core routes with linked
+// custom modules entities, is to recreate route (in a custom one) middleware and
+// apply the custom params validator
+
+import { MedusaResponse } from "@medusajs/framework";
+import { HttpTypes } from "@medusajs/framework/types";
+import { isPresent, ContainerRegistrationKeys, remoteQueryObjectFromString } from "@medusajs/framework/utils";
+import { RequestWithContext, wrapProductsWithTaxPrices } from "@medusajs/medusa/api/store/products/helpers";
+import { wrapVariantsWithInventoryQuantityForSalesChannel } from "@medusajs/medusa/api/utils/middlewares/index";
+import { ExtendedStoreGetProductsParamsType } from "./validators";
+
+export const GET = async (
+  req: RequestWithContext<ExtendedStoreGetProductsParamsType>,
+  res: MedusaResponse<HttpTypes.StoreProductListResponse>
+) => {
+  return await getProducts(req as any, res);
+};
+
+async function getProducts(
+  req: RequestWithContext<HttpTypes.StoreProductListParams>,
+  res: MedusaResponse<HttpTypes.StoreProductListResponse>
+) {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY);
+  const context: object = {};
+  const withInventoryQuantity = req.queryConfig.fields.some((field) =>
+    field.includes("variants.inventory_quantity")
+  );
+
+  if (withInventoryQuantity) {
+    req.queryConfig.fields = req.queryConfig.fields.filter(
+      (field) => !field.includes("variants.inventory_quantity")
+    );
+  }
+
+  if (isPresent(req.pricingContext)) {
+    context["variants.calculated_price"] = {
+      context: req.pricingContext,
+    };
+  }
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "product",
+    variables: {
+      filters: req.filterableFields,
+      ...req.queryConfig.pagination,
+      ...context,
+    },
+    fields: req.queryConfig.fields,
+  });
+
+  const { rows: products, metadata } = await remoteQuery(queryObject);
+
+  if (withInventoryQuantity) {
+    await wrapVariantsWithInventoryQuantityForSalesChannel(
+      req,
+      products.map((product) => product.variants).flat(1)
+    );
+  }
+
+  await wrapProductsWithTaxPrices(req, products);
+  res.json({
+    products,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  });
+}

package/src/api/store/plugin/attributes/products/validators.ts

@@ -0,0 +1,55 @@
+import {
+  StoreGetProductsParamsFields,
+  StoreGetProductVariantsParamsFields,
+} from "@medusajs/medusa/api/store/products/validators";
+import {
+  applyAndAndOrOperators,
+  recursivelyNormalizeSchema,
+} from "@medusajs/medusa/api/utils/common-validators/common";
+import {
+  StoreGetProductParamsDirectFields,
+  transformProductParams,
+} from "@medusajs/medusa/api/utils/common-validators/index";
+import { createFindParams } from "@medusajs/medusa/api/utils/validators";
+import { z } from "zod";
+
+//TODO: this is messy, but since Medusa exports an effect, the only way (AFAIK) to extend the schema
+// and to keep the logic of the effects at the same time, the only way is to recreate
+// the Medusa zod object, merge with the custom one and apply the effect
+const OriginalStoreGetProductsParamsWithoutEffect = createFindParams({
+  offset: 0,
+  limit: 50,
+})
+  .merge(StoreGetProductsParamsFields)
+  .merge(
+    z
+      .object({
+        variants: z
+          .object({
+            options: z
+              .object({
+                value: z.string().optional(),
+                option_id: z.string().optional(),
+              })
+              .optional(),
+          })
+          .merge(applyAndAndOrOperators(StoreGetProductVariantsParamsFields))
+          .optional(),
+      })
+      .merge(applyAndAndOrOperators(StoreGetProductParamsDirectFields))
+      .strict()
+  );
+
+const CustomStoreGetProductsParams = z.object({
+  attribute_value_id: z.array(z.string()).optional(),
+});
+
+export type ExtendedStoreGetProductsParamsType = z.infer<
+  typeof OriginalStoreGetProductsParamsWithoutEffect
+>;
+export const ExtendedStoreGetProductsParams =
+  OriginalStoreGetProductsParamsWithoutEffect.merge(
+    CustomStoreGetProductsParams
+  )
+    // .merge(applyAndAndOrOperators(CustomStoreGetProductsParams))
+    .transform(recursivelyNormalizeSchema(transformProductParams));

package/src/api/store/plugin/attributes/query-config.ts

@@ -0,0 +1,19 @@
+export const storeDefaultAttributeFields = [
+    'id',
+    'name',
+    'description',
+    'handle',
+    'metadata',
+    '*possible_values',
+]
+
+export const retrieveStoreAttributesQueryConfig = {
+    defaults: storeDefaultAttributeFields,
+    isList: false,
+}
+
+export const storeListAttributesQueryConfig = {
+    ...retrieveStoreAttributesQueryConfig,
+    isList: true,
+    defaultLimit: 50,
+}

package/src/api/store/plugin/attributes/route.ts

@@ -0,0 +1,13 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { StoreGetAttributesParamsType } from "./validators";
+
+export const GET = async (req: MedusaRequest<StoreGetAttributesParamsType>, res: MedusaResponse) => {
+    const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+    const { data: attributes, metadata } = await query.graph({
+        entity: 'attribute',
+        ...req.queryConfig,
+        filters: req.filterableFields,
+    })
+    return res.status(200).json({ attributes, count: metadata?.count, limit: metadata?.take, offset: metadata?.skip })
+}

package/src/api/store/plugin/attributes/validators.ts

@@ -0,0 +1,14 @@
+import { createFindParams } from "@medusajs/medusa/api/utils/validators";
+import { z } from "zod";
+import { GetAttributesParams, StoreGetAttributeParamsDirectFields } from "../../../utils/common-validators";
+import { applyAndAndOrOperators } from "@medusajs/medusa/api/utils/common-validators/common";
+
+export const StoreGetAttributesParamsFields = GetAttributesParams.strict();
+
+export type StoreGetAttributesParamsType = z.infer<typeof StoreGetAttributesParams>
+export const StoreGetAttributesParams = createFindParams({
+  offset: 0,
+  limit: 50,
+})
+  .merge(StoreGetAttributesParamsFields)
+  .merge(applyAndAndOrOperators(StoreGetAttributeParamsDirectFields).strict());

package/src/api/store/plugin/route.ts

@@ -0,0 +1,8 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+) {
+  res.sendStatus(200);
+}

package/src/api/utils/common-validators.ts

@@ -0,0 +1,24 @@
+import { createOperatorMap } from '@medusajs/medusa/api/utils/validators'
+import { z } from 'zod'
+
+export const StoreGetAttributeParamsDirectFields = z.object({
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    name: z.union([z.string(), z.array(z.string())]).optional(),
+    description: z.union([z.string(), z.array(z.string())]).optional(),
+    handle: z.union([z.string(), z.array(z.string())]).optional(),
+    created_at: createOperatorMap().optional(),
+    updated_at: createOperatorMap().optional(),
+    deleted_at: createOperatorMap().optional(),
+})
+
+export const GetAttributesParams = z
+    .object({
+        product_category_id: z.union([z.string(), z.array(z.string())]).optional(),
+        include_globals: z.preprocess(
+            (val) => {
+                return val === 'true'
+            },
+            z.boolean().default(true),
+        )
+    })
+    .merge(StoreGetAttributeParamsDirectFields)

package/src/api/utils/constants.ts

@@ -0,0 +1,2 @@
+export const adminAttributesRoutePath = '/admin/plugin/attributes'
+export const storeAttributesBaseRoute = '/store/plugin/attributes'