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 { LoaderOptions, ModuleJoinerConfig } from "@medusajs/framework/types";
import {
camelToSnakeCase,
DALUtils,
ModulesSdkUtils,
normalizeMigrationSQL,
} from "@medusajs/framework/utils";
import { DatabaseSchema } from "@medusajs/framework/mikro-orm/knex";
import { CustomFieldsModuleOptions } from "@mercurjs/types";
import { MedusaModule } from "@medusajs/framework/modules-sdk";
import { generateEntity } from "./utils/generate-entity";
function pickTableRelatedCommands(tableNames: string[], sqlCommand: string) {
const ignoreColumns = ["created_at", "updated_at", "deleted_at"];
const commands = sqlCommand.split(";");
const returnedCommands = commands
.filter((command) => {
const cmd = command.trim();
return (
cmd.length &&
cmd !== "set names 'utf8'" &&
tableNames.some((t) => cmd.includes(`"${t}"`)) &&
!ignoreColumns.some((column) => cmd.includes(`column "${column}"`))
);
})
.map((cmd) => cmd.trim());
if (returnedCommands.length > 0) {
returnedCommands.push("");
}
return returnedCommands.join(";");
}
async function syncCustomFields(
logger: LoaderOptions["logger"],
customFields: NonNullable<CustomFieldsModuleOptions["customFields"]>,
) {
const tableNames: string[] = [];
const entities = Object.entries(customFields).map(([entityName, fields]) => {
const tableName = `${camelToSnakeCase(entityName)}_custom_fields`;
tableNames.push(tableName);
const fieldDefs = Object.entries(fields ?? {}).map(([name, field]) => ({
...field,
name,
nullable: field.nullable ?? true,
defaultValue: field.defaultValue ?? null,
}));
return generateEntity(tableName, fieldDefs);
});
if (!entities.length) {
logger?.info("No custom fields configured. Skipping.");
return;
}
logger?.info("Syncing custom fields...");
const dbConfig = ModulesSdkUtils.loadDatabaseConfig("custom_fields");
const orm = await DALUtils.mikroOrmCreateConnection(dbConfig, entities, "");
try {
const generator = orm.getSchemaGenerator();
const connection = orm.em.getConnection();
const platform = orm.em.getPlatform();
const schemaName = dbConfig.schema || "public";
const dbSchema = new DatabaseSchema(platform, schemaName);
try {
await platform.getSchemaHelper?.()?.loadInformationSchema(
dbSchema,
connection,
tableNames.map((table_name) => ({
table_name,
schema_name: schemaName,
})),
);
} catch {
// Tables don't exist yet — empty schema will generate CREATE TABLE
}
const rawSql = normalizeMigrationSQL(
await generator.getUpdateSchemaSQL({
fromSchema: dbSchema,
}),
);
const sql = pickTableRelatedCommands(tableNames, rawSql);
if (sql) {
await connection.execute(sql);
logger?.info("Custom fields migrated successfully.");
} else {
logger?.info("Custom fields are up to date.");
}
} finally {
await orm.close(true);
}
}
export default async function customFieldsLoader({
logger,
options,
}: LoaderOptions) {
const { customFields = {} } = (options ?? {}) as CustomFieldsModuleOptions;
const isMigration = process.argv.some((arg) => arg.includes("db:migrate"));
if (isMigration) {
await syncCustomFields(logger, customFields);
}
MedusaModule.setCustomLink((joinerConfigs) => {
const entityJoinerConfigMap = new Map<string, ModuleJoinerConfig>();
for (const joinerConfig of joinerConfigs) {
const aliases = Array.isArray(joinerConfig.alias)
? joinerConfig.alias
: [joinerConfig.alias];
aliases.forEach((alias) => {
if (alias?.entity) {
entityJoinerConfigMap.set(alias.entity, joinerConfig);
}
});
}
const extendsConfig: {
serviceName: string;
entity: string;
fieldAlias: Record<string, { path: string; isList: boolean }>;
relationship: {
serviceName: string;
primaryKey: string;
foreignKey: string;
alias: string;
isList: boolean;
};
}[] = [];
Object.entries(customFields ?? {}).forEach(([entityName]) => {
const joinerConfig = entityJoinerConfigMap.get(entityName);
if (!joinerConfig || !joinerConfig.serviceName) {
logger?.error(`Invalid entity name: ${entityName}`);
return;
}
const snakeEntity = camelToSnakeCase(entityName);
const linkableKey = `${snakeEntity}_id`;
const relationshipAlias = `${snakeEntity}_custom_fields_link`;
extendsConfig.push({
serviceName: joinerConfig.serviceName!,
entity: entityName,
fieldAlias: {
custom_fields: {
path: relationshipAlias,
isList: false,
},
},
relationship: {
serviceName: "custom_fields",
primaryKey: linkableKey,
foreignKey: "id",
alias: relationshipAlias,
isList: false,
},
});
});
return {
isLink: true,
isReadOnlyLink: true,
extends: extendsConfig,
};
});
}