Implement base entities manipulation

[JesusDR01]

Hello everyone, I have been reading the Extend entity docs.

It is working amazingly, I can create fields and retrieve them.

But, what if we want to implement it using our admin?

Example:

curl --location 'http://localhost:9000/admin/products' \
--header 'Authorization: Bearer {api_token}' \
--header 'Content-Type: application/json' \
--header 'Cookie: connect.sid=s%3A-IBmbYPyz9kac3-KNbHNIThnc61RI6NA.Ng6o7Cn%2FI0fDa6waMK7813%2BM%2Bu0HtuycRVX65s5eODo' \
--data '{
    "title": "Shirt-53",
    "customAttribute": "5"
}'

The output will be:

{
    "type": "invalid_data",
    "message": "property customAttribute should not exist"
}

The explanation about this is in:

src/api/admin/product/create-product.ts

medusa/packages/medusa/src/api/routes/admin/products/create-product.ts

Line 109 in d38b324

const validated = await validator(AdminPostProductsReq, req.body)

we find

medusa/packages/medusa/src/api/routes/admin/products/create-product.ts

Lines 551 to 661 in d38b324

	export class AdminPostProductsReq {
	@IsString()
	title: string
	@IsString()
	@IsOptional()
	subtitle?: string
	@IsString()
	@IsOptional()
	description?: string
	@IsBoolean()
	is_giftcard = false
	@IsBoolean()
	discountable = true
	@IsArray()
	@IsOptional()
	images?: string[]
	@IsString()
	@IsOptional()
	thumbnail?: string
	@IsString()
	@IsOptional()
	handle?: string
	@IsOptional()
	@IsEnum(ProductStatus)
	status?: ProductStatus = ProductStatus.DRAFT
	@IsOptional()
	@Type(() => ProductTypeReq)
	@ValidateNested()
	type?: ProductTypeReq
	@IsOptional()
	@IsString()
	collection_id?: string
	@IsOptional()
	@Type(() => ProductTagReq)
	@ValidateNested({ each: true })
	@IsArray()
	tags?: ProductTagReq[]
	@FeatureFlagDecorators(SalesChannelFeatureFlag.key, [
	IsOptional(),
	Type(() => ProductSalesChannelReq),
	ValidateNested({ each: true }),
	IsArray(),
	])
	sales_channels?: ProductSalesChannelReq[]
	@IsOptional()
	@Type(() => ProductProductCategoryReq)
	@ValidateNested({ each: true })
	@IsArray()
	categories?: ProductProductCategoryReq[]
	@IsOptional()
	@Type(() => ProductOptionReq)
	@ValidateNested({ each: true })
	@IsArray()
	options?: ProductOptionReq[]
	@IsOptional()
	@Type(() => ProductVariantReq)
	@ValidateNested({ each: true })
	@IsArray()
	variants?: ProductVariantReq[]
	@IsNumber()
	@IsOptional()
	weight?: number
	@IsNumber()
	@IsOptional()
	length?: number
	@IsNumber()
	@IsOptional()
	height?: number
	@IsNumber()
	@IsOptional()
	width?: number
	@IsString()
	@IsOptional()
	hs_code?: string
	@IsString()
	@IsOptional()
	origin_country?: string
	@IsString()
	@IsOptional()
	mid_code?: string
	@IsString()
	@IsOptional()
	material?: string
	@IsObject()
	@IsOptional()
	metadata?: Record<string, unknown>
	}

Where we can't see our customAttribute (obviously)

So, the validator fails as our customAttribute doesn't exists.

Obviously, a developer could just override the /admin/products use the following code in the backend. (When implementing medusa backend in their project)

/api/index.ts

import { Router, json } from "express";

export default function (rootDirectory: string) {
    const router = Router();
    router.use(json());

    router.post("/admin/products", async (req, res) => {
        const productService = req.scope.resolve("productService");
        const created = await productService.create({
           ...req.body
         });
        res.json(created);
    });
    return router;
}

But I think this is not the best way to handle the problem.

I'm new checking medusa codebase, so I don't know how we could override the AdminPostProductsReq

Any help?

Thank you.

You can replicate the problem using this comment as a reference:

#3907 (comment)

[adevinwild]

Same here 🍿

[adrien2p]

This discussion is something that many people encounters. I ve provided a way of achieving that by following the steps here:

// src/utils/register-extended-validator.ts
import { ValidatorOptions } from 'class-validator'
import { ClassConstructor } from "@medusajs/medusa";

const extendedValidators: any = []
let isInitialized = false

export async function registerExtendedValidator<T extends ClassConstructor<any>>(classValidator: T): Promise<void> {
    extendedValidators.push(classValidator)

    if (isInitialized) {
        return
    }

    isInitialized = true

    const module = await import('@medusajs/medusa/dist/utils/validator')
    const originalValidator = module.validator
    module.validator = <T extends ClassConstructor<any> = any, V = any>(typedClass: T, plain: V, config?: ValidatorOptions): Promise<any> => {
        for (const extendedValidator of extendedValidators) {
            if (extendedValidator.name === typedClass.name) {
                typedClass = extendedValidator
                break
            }
        }
        return originalValidator(typedClass, plain, config)
    }
}

Then in a custom loader, you can register your custom extended validators. A custom validator would look like the following:

import { StoreGetProductsParams as MedusaStoreGetProductsParams } from "@medusajs/medusa";

// It is important that the class has the same name as the one you are extending so here StoreGetProductsParams
export class StoreGetProductsParams extends MedusaStoreGetProductsParams {
  @IsString()
  my_new_prop_to_accept
}

Now the end point will accept the new property.

In regards to the store domain, there is some restriction on the fields that can be return in order to prevent any security issue. In order to override this default behaviour and alter the allowed props etc you can do the following in your custom loader

export default async function () {
    const imports = (await import("@medusajs/medusa/dist/api/routes/store/products/index")) as any
    const originalValue = imports.allowedStoreProductsFields
    imports.allowedStoreProductsFields = [...imports.allowedStoreProductsFields, "title_en"]
    const originalValue = imports.defaultStoreProductsFields
    imports.defaultStoreProductsFields = [...imports.defaultStoreProductsFields, "title_en"]
}

and the above will alter the allowed fields meaning your custom property can then be returned as part of the store response.

Hope this make sense otherwise let me know

[adrien2p]

The loaders are loaded automatically, in your file, you can export a default function that accept as arguments the container and options, in the server extension the options are empty. You won't need those arguments but in any case this is the api. Don't forget to build your project which will output them in dist/loaders

[oliwerhelsen]

I tried this, but without success. Still getting the error "property customAttribute should not exist". @adrien2p can you see any obvious issue with this code

My poc code:

// src/utils/register-extended-validator.ts
import { ValidatorOptions } from 'class-validator';
import { ClassConstructor } from '@medusajs/medusa';

const extendedValidators: any = [];
let isInitialized = false;

export async function registerExtendedValidator<
    T extends ClassConstructor<any>
>(classValidator: T): Promise<void> {
    extendedValidators.push(classValidator);

    if (isInitialized) {
        return;
    }

    isInitialized = true;

    const module = await import('@medusajs/medusa/dist/utils/validator');
    const originalValidator = module.validator;
    module.validator = <T extends ClassConstructor<any> = any, V = any>(
        typedClass: T,
        plain: V,
        config?: ValidatorOptions
    ): Promise<any> => {
        for (const extendedValidator of extendedValidators) {
            if (extendedValidator.name === typedClass.name) {
                typedClass = extendedValidator;
                break;
            }
        }
        return originalValidator(typedClass, plain, config);
    };
}


//loaders/validator.ts
import { AdminPostProductsReq as MedusaAdminPostProductsReq } from '@medusajs/medusa';
import { IsString } from 'class-validator';

export default class AdminPostProductsReq extends MedusaAdminPostProductsReq {
    @IsString()
    customAttribute;
}

// models/product.ts
import { Column, Entity } from 'typeorm';
import {
    Product as MedusaProduct,
} from '@medusajs/medusa';

@Entity()
export class Product extends MedusaProduct {
    @Column()
    customAttribute: string;
}

[adrien2p]

Where are you calling registerExtendedValidator? Also, if you put a log in the util that logs the extendedValidator and typedClass name what do you get?

[adevinwild]

I tried this, but without success. Still getting the error "property customAttribute should not exist". @adrien2p can you see any obvious issue with this code

My poc code:

// src/utils/register-extended-validator.ts
import { ValidatorOptions } from 'class-validator';
import { ClassConstructor } from '@medusajs/medusa';

const extendedValidators: any = [];
let isInitialized = false;

export async function registerExtendedValidator<
    T extends ClassConstructor<any>
>(classValidator: T): Promise<void> {
    extendedValidators.push(classValidator);

    if (isInitialized) {
        return;
    }

    isInitialized = true;

    const module = await import('@medusajs/medusa/dist/utils/validator');
    const originalValidator = module.validator;
    module.validator = <T extends ClassConstructor<any> = any, V = any>(
        typedClass: T,
        plain: V,
        config?: ValidatorOptions
    ): Promise<any> => {
        for (const extendedValidator of extendedValidators) {
            if (extendedValidator.name === typedClass.name) {
                typedClass = extendedValidator;
                break;
            }
        }
        return originalValidator(typedClass, plain, config);
    };
}


//loaders/validator.ts
import { AdminPostProductsReq as MedusaAdminPostProductsReq } from '@medusajs/medusa';
import { IsString } from 'class-validator';

export default class AdminPostProductsReq extends MedusaAdminPostProductsReq {
    @IsString()
    customAttribute;
}

// models/product.ts
import { Column, Entity } from 'typeorm';
import {
    Product as MedusaProduct,
} from '@medusajs/medusa';

@Entity()
export class Product extends MedusaProduct {
    @Column()
    customAttribute: string;
}

Maybe this will help you : https://adevinwild.hashnode.dev/extend-validators-with-medusajs-18x 🙌🏼

[oliwerhelsen]

Thanks guys!
I've missed this part:

// src/loaders/index.ts
export default async function () {
    registerExtendedValidator(AdminPostProductsReq)
}

[khqnn]

I have created a new table and want this table's primary key as a foreign key in the Product table as a new column in the Product table. Can we do this? Please do have a detailed explanation.

Thanks!

[adrien2p]

Yes you can, by following how to extend an entity and the explanation I have provided above you should have eveything you need. For more details on how relations work you might want to look at the typeorm documentation as it is not related to medusa itself. What exactly do you struggle with?

[svrizkyp]

Hello guys,

I've the same issue above but i was extending the customer's attribute by adding companyName (screenshot attached), when i try to create new customer via Store API in Postman it returns :
{
"type": "invalid_data",
"message": "property companyName should not exist"
}

however when i try to get the customer's data, it works perfectly and the companyName attribute showed. So what should i do for this type of issue?

I've followed @adrien2p answer but i keep getting error like :

I've followed all the instruction given in below doc:
https://docs.medusajs.com/development/entities/extend-entity

Hope u guys can help, Thanks in advance!

[adevinwild]

Hello guys,

When i'm trying to create new customer by using Rest API, i just discovered new issue that why the custom attribute that made before must be included in the Post request body ? Can we make it as an optional field ? because it seems like the attribute has mandatory validation

Thanks

Hi,
You should check the docs of class validator : https://github.com/typestack/class-validator

[svrizkyp]

Thanks @adevinwild, i just need to add @IsOptional() Validation Decors to achieve this

[svrizkyp]

Hello guys,

I want to extend the cart attribute and its API, i've managed to extend the cart attribute and show it in the Cart API Response. But when i try to post the custom cart attribute it shows error like before ".. should not exist" I've made same validation inside the validator.js file like below

`import { StorePostCustomersReq as MedusaStorePostCustomersReq } from '@medusajs/medusa';
import { StorePostCartReq as MedusaStorePostCartReq } from '@medusajs/medusa';
import { IsString, IsOptional, IsBoolean, IsNumber } from 'class-validator';
import { registerExtendedValidator } from "../utils/register-extended-validator"

export class StorePostCustomersReq extends MedusaStorePostCustomersReq {
@IsOptional()
@IsString()
companyName: string; // In your case it should be companyName
}

export class StorePostCartReq extends MedusaStorePostCartReq {
@IsOptional()
@IsString()
customer_name: string;

@IsOptional()
@IsString()
customer_company_name: string;

@IsOptional()
@IsNumber()
ecommerce_type_id: number;

@IsOptional()
@IsBoolean()
custom_feature: boolean;

}

export default async function () {
registerExtendedValidator(StorePostCustomersReq)
registerExtendedValidator(StorePostCartReq)
}`

Can you guys help me where did i do the wrong thing?

Thanks a lot

[svrizkyp]

UPDATE FOR THE ISSUE

I've managed to solve the "...should not exist" error by extending the update cart post API in the validator.js, but now when i update the cart with custom attribute via API, the cart custom attribute value is not updated

[kevinrobert3]

@svrizkyp did you know how to update the field. On my side on creation it is null and on updating it is still null

[nguyenbinhit]

Hello everyone,

I have the same issue as mentioned above. I followed @adrien2p's answer, but something peculiar happens. When I initially run the build and log in as admin, I encounter a CORS issue. However, when I save my loader/index.ts file, everything returns to normal. This keeps happening every time I run the build.

I hope you can help. Thank you in advance!

[westwebdev]

unfortunately it doesn't work for me... validator even check the validity for extended attribute.

// src/loader/index.ts

import { registerExtendedValidator } from "src/utils/register-extended-validator";
import {AdminGetProductParams as MedusaAdminGetProductParams} from "@medusajs/medusa/dist/api/routes/admin/products/get-product"
import { IsString } from "class-validator"

class AdminGetProductParams extends MedusaAdminGetProductParams {
    @IsString()
    my_custom_attribute: string
}

export default async function () {
    registerExtendedValidator(AdminGetProductParams)
}

// src/loader/product-entity-extend.ts

export default async function () {
    const imports = (await import("@medusajs/medusa/dist/api/routes/admin/products/index")) as any;

    imports.defaultAdminProductFields = [
        ...imports.defaultAdminProductFields,
        "my_custom_attribute",
    ]
}

// src/utils/register-extended-validator.ts

import { ValidatorOptions } from 'class-validator'
import { ClassConstructor } from '@medusajs/medusa'

const extendedValidators: any = []
let isInitialized = false

export async function registerExtendedValidator< T extends ClassConstructor<any> >(classValidator: T): Promise<void> {
    extendedValidators.push(classValidator)

    if (isInitialized) {
        return
    }

    isInitialized = true

    const module = await import('@medusajs/medusa/dist/utils/validator')
    const originalValidator = module.validator
    module.validator = <T extends ClassConstructor<any> = any, V = any>(
        typedClass: T,
        plain: V,
        config?: ValidatorOptions,
    ): Promise<any> => {
        for (const extendedValidator of extendedValidators) {
            if (extendedValidator.name === typedClass.name) {
                typedClass = extendedValidator
                break
            }
        }
        return originalValidator(typedClass, plain, config)
    }
}

data is for sure in database, and displayed in raw product object on detail page

[Twiddlle]

I have a similar issue. I've extended the order entity by prop merchant_state.

I've created a custom validator src/api/index.ts:

class AdminPostOrdersOrderReq extends MedusaAdminPostOrdersOrderReq {
  @IsIn(MerchantStates)
  @IsOptional()
  merchant_state: MerchantState
}

registerOverriddenValidators(AdminPostOrdersOrderReq)

I've created an extended Entity src/models/Order along with migrations:

@Entity()
export class Order extends MedusaOrder {
  @Column({ type: 'varchar', name: 'merchant_state', nullable: true })
  merchant_state?: MerchantState
}

I've extended API routes as it is mentioned in the docs src/loaders/extend-order-fields.ts:

export default async function () {
  const storeImports = (await import('@medusajs/medusa/dist/api/routes/store/orders/index')) as any
  storeImports.allowedStoreOrdersFields = [
    ...storeImports.allowedStoreOrdersFields,
    'merchant_state',
  ]
  storeImports.defaultStoreOrdersFields = [
    ...storeImports.defaultStoreOrdersFields,
    'merchant_state',
  ]

  const adminImports = (await import('@medusajs/medusa/dist/api/routes/admin/orders/index')) as any
  adminImports.defaultAdminOrdersFields = [
    ...adminImports.defaultAdminOrdersFields,
    'merchant_state',
  ]
}

And this is my result:

• I am able to store additional field with Admin API
• I am able to retrieve additional field in Store API
• but I am unable to retrieve field from Admin API. <-- and I need this ¯\(ツ)/¯

Can anyone help me please?
cc: @adrien2p

[adrien2p]

the @medusajs/medusa/dist/api/routes/admin/orders/index does not export defaultAdminOrdersFields, it comes from @medusajs/medusa/dist/types/orders.ts. Could it be the reason ? 🤔 which version are you using?

[Twiddlle]

I am using version 1.18.0. But this solved my problem. Is it mentioned somewhere in the documentation? Because if not, it is worth mentioning.

Thank you very much for your help.

[kevinrobert3]

I have extended the defaultFields like

export default async function () { const imports = (await import( "@medusajs/medusa/dist/api/routes/store/index" )) as any; imports.defaultStoreCartFields = [ ...imports.defaultStoreCartFields, "store_id", ]; console.log(imports); }

this is for a cart. We need to add a store_id, from the store api calls.

This is the other code

import { StorePostCartReq as MedusaStorePostCartReq } from "@medusajs/medusa";
import { IsString, IsNotEmpty } from "class-validator";

export default class StorePostCartReq extends MedusaStorePostCartReq {
  @IsString()
  @IsNotEmpty()
  store_id: string;
}

and the loader

import { registerExtendedValidator } from "../utils/register-extended-validator";
import StorePostCartReq from "./cart";

// src/loaders/index.ts
export default async function () {
  registerExtendedValidator(StorePostCartReq);
}

when I create the cart the store_id is null even though it has been supplied in the POST call.

This is the CartService extended

import { Lifetime } from "awilix";
import {
  CartService as MedusaCartService,
  Cart,
  User,
} from "@medusajs/medusa";
import { CartCreateProps as MedusaCartCreateProps } from "@medusajs/medusa/dist/types/cart";

type CartCreateProps = {
  store_id?: string;
} & MedusaCartCreateProps;

class CartService extends MedusaCartService {
  static LIFE_TIME = Lifetime.SCOPED;
  protected readonly loggedInUser_: User | null;

  constructor(container, options) {
    // @ts-expect-error prefer-rest-params
    super(...arguments);

    try {
      this.loggedInUser_ = container.loggedInUser;
    } catch (e) {
      // avoid errors when backend first runs
    }
  }
  async create(data: CartCreateProps): Promise<Cart> {
    console.log(data.store_id);
    data.store_id = "store_mock_12456677788";
    console.log(data);
    return await super.create(data);
  }

note the logs

log1: undefined
log2:

{
  region_id: 'reg_01HQVXQCZVFQSVX0SMAEEJH1VQ',
  sales_channel_id: undefined,
  context: { ip: '::ffff:127.0.0.1', user_agent: 'insomnia/8.6.1' },
  store_id: 'store_mock_12456677788'
}

then to show cart is created finally
info: Processing cart.created which has 0 subscribers

But still the cart created has store_id as null, even after hardcoding the value in the extended service.

What could be the issue. Any help would be appreciated
@adrien2p

[kevinrobert3]

This also happens in CartUpdate POST /store/carts/{id}

async update(cartOrId: string | Cart, data: CartUpdateProps): Promise<Cart> {
    console.log(cartOrId);

    console.log(data);

    return await super.update(cartOrId, data);
  }

Note the two logs

log 1: cart_01HR6Q6VGEB896KHG7W
log 2: StorePostCartsCartReq { store_id: 'store_01HQVXQ6GNFA9Z85ZTSK2M55YV' }

the store id gets passed in this one but it is still not updated in database.

Actually let me put my migration and cart model

import { Column, Entity, Index } from "typeorm";

import { Cart as MedusaCart } from "@medusajs/medusa";

@Entity()
export class Cart extends MedusaCart {
  @Index()
  @Column({ nullable: true })
  store_id?: string;
}

migration done

export class AddCartStoreId1709230809 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`ALTER TABLE "cart" ADD COLUMN "store_id" VARCHAR`);
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`ALTER TABLE "cart" DROP COLUMN "store_id"`);
  }
}

Is this all a bug or what am I doing wrong

[lucaspham098]

I have solved this issue after a long time of messing around with everything I could and looking into the node modules. I'll show you what my files look like. I wanted to extend the prices (MoneyAmount entity) array within the variants array which is nested in the products. So when I POST a new product, the new custom attributes should be present in the prices array in the return and updated in the db for the MoneyAmount Entity.

Extension of MoneyAmount:

import { Column, Entity } from "typeorm"
import {
  // alias the core entity to not cause a naming conflict
  MoneyAmount as MedusaMoneyAmount,
} from "@medusajs/medusa"

enum PurchaseType {
    OneTime = "one_time",
    Recurring = "recurring"
  }

enum AggregrateUsageType{
LastDuringPeriod="last_during_period",
LastEver="last_ever",
Max="max",
Sum="sum"
}

enum IntervalType{
    Day = "day",
    Week = "week",
    Month = "month",
    Year = "year"
  }

enum UsageTypeType{
  Metered="metered",
  Licensed="licensed"
}

@Entity()
export class MoneyAmount extends MedusaMoneyAmount {
  @Column({
    type:"enum",
    enum:PurchaseType,
    default: PurchaseType.OneTime, // Set a default value if needed
    nullable:true
  })
  type: PurchaseType
 
  @Column({
    type: "jsonb",
    nullable: true,
  })
  recurring: {
    aggregate_usage: null | AggregrateUsageType;
    interval: IntervalType;
    interval_count: number;
    trial_period_days: null | number;
    usage_type: UsageTypeType;
  };
}

Migration:

import { MigrationInterface, QueryRunner,TableColumn } from "typeorm";

export class MoneyAmountExtension1709761619941 implements MigrationInterface {

    public async up(queryRunner: QueryRunner): Promise<void> {  await queryRunner.addColumn(
        "money_amount", 
        new TableColumn({
            name: "type",
            type: "enum",
            enum: ["one_time", "recurring"], 
            default: "'one_time'", 
            isNullable:true,
        })
    )

    await queryRunner.addColumn(
        "money_amount",
        new TableColumn({
            name: "recurring",
            type: "jsonb",
            isNullable: true,
        })
    )
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.dropColumn("money_amount", "type");
        await queryRunner.dropColumn("money_amount", "recurring");
    }

}

Loader file to allow return of custom attributes:

export default async function () {
    const imports = (await import(
      "@medusajs/medusa/dist/api/routes/store/products/index"
    )) as any
    imports.allowedStoreProductsFields = [
      ...imports.allowedStoreProductsFields,
      "variants__prices.type",
      "variants__prices.recurring"
    ]
    imports.defaultStoreProductsFields = [
      ...imports.defaultStoreProductsFields,
      "variants__prices.type",
      "variants__prices.recurring"
    ]
  }

Extending Repository of MoneyAmount (Notice that it actually is different form the DOCS as following the way the docs showed resulted in an error. Refer to this thread which I followed #6139):

import { MoneyAmount } from "@medusajs/medusa";
import { dataSource } from "@medusajs/medusa/dist/loaders/database";
import { MoneyAmountRepository as MedusaMoneyAmountRepository } from "@medusajs/medusa/dist/repositories/money-amount";

export const MoneyAmountRepository:any = dataSource
  .getRepository(MoneyAmount)
  // .extend({
  //  ...Object.assign(MedusaMoneyAmountRepository, {
  //     target: MoneyAmount
  //   }),
  // });
// this causes "moneyAmountRepo.deleteVariantPricesNotIn is not a function\nCannot read properties of undefined (reading 'length')" but is in DOCS

  .extend(
    Object.assign(MedusaMoneyAmountRepository, {
       target: MoneyAmount
     }),
   );

export default MoneyAmountRepository;

Overriding validators:

import { registerOverriddenValidators } from "@medusajs/medusa"
import {AdminPostProductsReq as MedusaAdminPostProductsReq} from "@medusajs/medusa/dist/api/routes/admin/products/create-product"
import{AdminPostProductsProductVariantsReq as MedusaAdminPostProductsProductVariantsReq} from "@medusajs/medusa/dist/api/routes/admin/products/create-variant"
import{ ProductVariantPricesCreateReq as MedusaProductVariantPricesCreateReq }from "@medusajs/medusa/dist/types/product-variant"
import { IsString,ValidateNested,IsArray,IsEnum,IsObject,IsOptional } from "class-validator"
import {Type} from "class-transformer"

class AdminPostProductsReq extends MedusaAdminPostProductsReq {
@Type(() => AdminPostProductsProductVariantsReq)
@ValidateNested({ each: true })
@IsArray()
variants: AdminPostProductsProductVariantsReq[];
}

class AdminPostProductsProductVariantsReq extends MedusaAdminPostProductsProductVariantsReq {
 @Type(() => ProductVariantPricesCreateReq)
 @ValidateNested({ each: true })
 @IsArray()
 prices: ProductVariantPricesCreateReq[];
}

enum PurchaseType {
 OneTime = "one_time",
 Recurring = "recurring"
}

enum AggregrateUsageType{
 LastDuringPeriod="last_during_period",
 LastEver="last_ever",
 Max="max",
 Sum="sum"
 }
 
 enum IntervalType{
     Day = "day",
     Week = "week",
     Month = "month",
     Year = "year"
   }
 
 enum UsageTypeType{
   Metered="metered",
   Licensed="licensed"
 }

class ProductVariantPricesCreateReq extends MedusaProductVariantPricesCreateReq{
@IsOptional()
 @IsEnum(PurchaseType)
 type:PurchaseType

 @IsOptional()
 @IsObject()
 recurring:{
  aggregate_usage: null | AggregrateUsageType;
  interval: IntervalType;
  interval_count: number;
  trial_period_days: null | number;
  usage_type: UsageTypeType;
 }
}

registerOverriddenValidators(AdminPostProductsReq)
// registerOverriddenValidators(AdminPostProductsProductVariantsReq)
// post request goes through without overriding AdminPostProductsProductVariantsReq

// registerOverriddenValidators(ProductVariantPricesCreateReq) 
// post request goes through without overriding ProductVariantPricesCreateReq)

Extending Product Variants Services (Creation of a product calls on product variants services):

import { ProductVariantService as MedusaProductVariantService } from "@medusajs/medusa";
import { Lifetime } from "awilix";
import MoneyAmountRepository from "src/repositories/money-amount";
import { CreateProductVariantInput as MedusaCreateProductVariantInput } from "@medusajs/medusa/dist/types/product-variant";
import { ProductVariantPrice as MedusaProductVariantPrice } from "@medusajs/medusa/dist/types/product-variant";
import ProductVariantRepository from "@medusajs/medusa/dist/repositories/product-variant";

type ProductVariantPrice={
  type?:string,
  recurring?:object
} & MedusaProductVariantPrice

type CreateProductVariantInput={
  prices:ProductVariantPrice[]
} & MedusaCreateProductVariantInput[]

class ProductVariantService extends MedusaProductVariantService {
  static LIFE_TIME = Lifetime.SCOPED;
  protected readonly moneyAmountRepository_: typeof MoneyAmountRepository;
  protected readonly productVariantRepository_: typeof ProductVariantRepository;

  constructor(container, options) {
    // @ts-expect-error prefer-rest-params
    super(...arguments);
    this.moneyAmountRepository_ = container.moneyAmountRepository;
    this.productVariantRepository_ =container.productVariantRepository
  }

  async create(productOrProductId, variants: CreateProductVariantInput): Promise<any> {

    const variantsWithExtras = variants.map(variant => {

      const pricesWithExtras = variant.prices.map((price:ProductVariantPrice) => ({
        ...price,
        type: price.type || null,
        recurring: price.recurring || null
      }));
      // console.log(pricesWithExtras)

      return {
        ...variant,
        prices: pricesWithExtras
      };
    });

    // variantsWithExtras.forEach(variant => console.log(variant));

    const createdVariants:any = await super.create(productOrProductId, variantsWithExtras);

    this.updateVariantPrices(variantsWithExtras.map(function (v:any) { 
      console.log(`this is v:`,v)
      console.log(`this is createdvariantsid`,createdVariants[0].id)
      console.log(`this is v.prices:`,v.prices)
      return ({
      variantId: createdVariants[0].id,
      prices: v.prices,
  });
}))

    return createdVariants;
  }
}

export default ProductVariantService;

This is what a successful Post request looks like:

I want to also include that I was trying to get this to work while working on Github code spaces and my files looked exactly like the ones I have shown you for a long time and it would not input the custom attribute values to the db I have supplied in the POST body, rather it would just leave it as the default values. After I used up all the hours they allowed me I had to export the changes I made in the code space to a new branch and clone the GitHub repo to VS code and work on there. I ran npm i twice because the first failed for some reason, and then instead of using region_id in my post request body I switched it to currency-code (for some reason the region_id in the POST body caused an error when sending the request). Then it worked to my amazement.

[lucaspham098]

Turns out you do not need to extend the repo or the service to have it to work. I figured out what was causing the issue. Replacing region_id to currency_code was the fix. In the docs it states for a POST request when crating a product, the prices array needs to have EITHER region_id or currency_code (having both results in a XOR error). I'm not really sure why that is the fix as the Money Amount (prices) table has columns for both currency_code and region_id. My guess is that when you create a product on the admin dashboard with both variants and prices, the data inserted in the Money Amount table has a currency_code value but the region_id value is empty. So by only having currency_code and not region_id in your request body, you follow how the admin dashboards creates data for the Money Amount table. Again this is an assumption for why region_id creates the issue and currency_code does not.