The complete open source platform to run your entire marketplace. Storefront, vendor panel, admin console, and integrations in one enterprise-grade platform you own.
TypeScript b2b-marketplacecomposable-commerceecommerceenterpriseheadless-commercemarketplacemedusamedusajsmulti-vendortypescript
import { CustomFieldsModuleOptions } from "@mercurjs/types";
import { FindConfig } from "@medusajs/framework/types";
import {
MedusaError,
compressName,
generateEntityId,
camelToSnakeCase,
} from "@medusajs/framework/utils";
import { MedusaModule } from "@medusajs/framework/modules-sdk";
export default class CustomFieldsModuleService {
protected readonly options_: CustomFieldsModuleOptions;
protected aliasToEntityMap_: Map<string, string> = new Map();
protected pgConnection_: any;
__hooks = {
onApplicationStart: async () => {
this.onApplicationStart();
},
};
constructor(container, options: CustomFieldsModuleOptions) {
this.options_ = options;
this.pgConnection_ = container.__pg_connection__;
}
async onApplicationStart(): Promise<void> {
this.buildAliasToEntityMap_();
}
protected buildAliasToEntityMap_(): void {
const joinerConfigs = MedusaModule.getAllJoinerConfigs();
const entityNames = Object.keys(this.options_.customFields ?? {});
for (const joinerConfig of joinerConfigs) {
const joinerConfigAliases = Array.isArray(joinerConfig.alias)
? joinerConfig.alias
: [joinerConfig.alias!];
for (const entityName of entityNames) {
const entityAlias = joinerConfigAliases.find(
(alias) => alias?.entity === entityName,
);
if (!entityAlias) {
continue;
}
const names = Array.isArray(entityAlias.name)
? entityAlias.name
: [entityAlias.name];
const snakeEntity = camelToSnakeCase(entityName);
for (const name of names) {
this.aliasToEntityMap_.set(name, snakeEntity);
}
}
}
}
async list(
filter: Record<string, string | string[]>,
config: FindConfig<any>,
): Promise<any[]>;
async list(
alias: string,
filters: Record<string, string | string[]>,
config: FindConfig<any>,
): Promise<any[]>;
async list(
filterOrAlias: Record<string, string | string[]> | string,
filtersOrConfig: Record<string, string | string[]> | FindConfig<any>,
maybeConfig?: FindConfig<any>,
) {
let alias: string;
let filters: Record<string, string | string[]>;
let config: FindConfig<any>;
if (typeof filterOrAlias === "string") {
alias = filterOrAlias;
filters = filtersOrConfig as Record<string, string | string[]>;
config = maybeConfig!;
} else {
const filter = filterOrAlias;
if (Object.keys(filter).length !== 1) {
throw new MedusaError(
MedusaError.Types.INVALID_ARGUMENT,
"Only single filter is allowed",
);
}
const filterKey = Object.keys(filter)[0];
alias = filterKey.split("_").slice(0, -1).join("_");
filters = filter;
config = filtersOrConfig as FindConfig<any>;
}
const snakeEntity = this.resolveAlias_(alias);
const tableName = compressName(`${snakeEntity}_custom_fields`);
const knex = this.pgConnection_;
const query = knex(tableName).whereNull("deleted_at");
for (const [filterKey, filterValue] of Object.entries(filters)) {
if (Array.isArray(filterValue)) {
query.whereIn(filterKey, filterValue);
} else {
query.where(filterKey, filterValue);
}
}
if (config.select) {
query.select(config.select as string[]);
}
return await query;
}
protected resolveAlias_(alias: string): string {
const snakeEntity = this.aliasToEntityMap_.get(alias);
if (!snakeEntity) {
throw new MedusaError(
MedusaError.Types.INVALID_ARGUMENT,
`Unknown custom fields alias: ${alias}`,
);
}
return snakeEntity;
}
async upsert(
alias: string,
data:
| { id: string;[key: string]: unknown }
| { id: string;[key: string]: unknown }[],
) {
const items = Array.isArray(data) ? data : [data];
const snakeEntity = this.resolveAlias_(alias);
const foreignKey = snakeEntity + "_id";
const tableName = compressName(`${snakeEntity}_custom_fields`);
const knex = this.pgConnection_;
const foreignKeyValues = items.map((entry) => entry.id);
const existing = await knex(tableName)
.whereIn(foreignKey, foreignKeyValues)
.whereNull("deleted_at");
const existingMap = new Map<
string,
{ id: string; fields: Record<string, unknown> }
>(
existing.map((row) => [
row[foreignKey],
row,
]),
);
const toInsert: Record<string, unknown>[] = [];
const toUpdate: { id: string; fields: Record<string, unknown> }[] = [];
for (const item of items) {
const { id, ...fields } = item;
const existingRow = existingMap.get(id);
if (existingRow) {
toUpdate.push({ id: existingRow.id as string, fields });
} else {
toInsert.push({
...fields,
[foreignKey]: id,
id: generateEntityId(undefined as any, "cf"),
});
}
}
await knex.transaction(async (trx) => {
if (toInsert.length) {
await trx(tableName).insert(toInsert);
}
for (const { id, fields } of toUpdate) {
await trx(tableName)
.where("id", id)
.update({ ...fields, updated_at: new Date() });
}
});
return items;
}
async delete(alias: string, ids: string | string[]) {
const items = Array.isArray(ids) ? ids : [ids];
const snakeEntity = this.resolveAlias_(alias);
const tableName = compressName(`${snakeEntity}_custom_fields`);
const knex = this.pgConnection_;
await knex.transaction(async (trx) => {
await trx(tableName)
.whereIn(`${snakeEntity}_id`, items)
.update({ deleted_at: new Date() });
});
}
}