@medusajs/link-modules 0.1.0-canary-20230831100806

package/dist/definitions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./inventory-level-stock-location";
+export * from "./product-variant-inventory-item";

package/dist/definitions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./inventory-level-stock-location"), exports);
+__exportStar(require("./product-variant-inventory-item"), exports);

package/dist/definitions/inventory-level-stock-location.d.ts

@@ -0,0 +1,2 @@
+import { ModuleJoinerConfig } from "@medusajs/types";
+export declare const InventoryLevelStockLocation: ModuleJoinerConfig;

package/dist/definitions/inventory-level-stock-location.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryLevelStockLocation = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+exports.InventoryLevelStockLocation = {
+    isLink: true,
+    isReadOnlyLink: true,
+    extends: [
+        {
+            serviceName: modules_sdk_1.Modules.INVENTORY,
+            relationship: {
+                serviceName: modules_sdk_1.Modules.STOCK_LOCATION,
+                primaryKey: "id",
+                foreignKey: "location_id",
+                alias: "stock_locations",
+                isList: true,
+            },
+        },
+    ],
+};

package/dist/definitions/product-variant-inventory-item.d.ts

@@ -0,0 +1,2 @@
+import { ModuleJoinerConfig } from "@medusajs/types";
+export declare const ProductVariantInventoryItem: ModuleJoinerConfig;

package/dist/definitions/product-variant-inventory-item.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductVariantInventoryItem = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const links_1 = require("../links");
+exports.ProductVariantInventoryItem = {
+    serviceName: links_1.LINKS.ProductVariantInventoryItem,
+    isLink: true,
+    databaseConfig: {
+        tableName: "product_variant_inventory_item",
+        idPrefix: "pvitem",
+        extraFields: {
+            required_quantity: {
+                type: "integer",
+                defaultValue: "1",
+            },
+        },
+    },
+    alias: [
+        {
+            name: "product_variant_inventory_item",
+        },
+        {
+            name: "product_variant_inventory_items",
+        },
+    ],
+    primaryKeys: ["id", "variant_id", "inventory_item_id"],
+    relationships: [
+        {
+            serviceName: modules_sdk_1.Modules.PRODUCT,
+            primaryKey: "id",
+            foreignKey: "variant_id",
+            alias: "variant",
+            args: {
+                methodSuffix: "Variants",
+            },
+        },
+        {
+            serviceName: modules_sdk_1.Modules.INVENTORY,
+            primaryKey: "id",
+            foreignKey: "inventory_item_id",
+            alias: "inventory",
+            deleteCascade: true,
+        },
+    ],
+    extends: [
+        {
+            serviceName: modules_sdk_1.Modules.PRODUCT,
+            relationship: {
+                serviceName: links_1.LINKS.ProductVariantInventoryItem,
+                primaryKey: "variant_id",
+                foreignKey: "id",
+                alias: "inventory_items",
+                isList: true,
+            },
+        },
+        {
+            serviceName: modules_sdk_1.Modules.INVENTORY,
+            relationship: {
+                serviceName: links_1.LINKS.ProductVariantInventoryItem,
+                primaryKey: "inventory_item_id",
+                foreignKey: "id",
+                alias: "variant_link",
+            },
+        },
+    ],
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./initialize";
+export * from "./types";
+export * from "./loaders";
+export * from "./services";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./initialize"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./loaders"), exports);
+__exportStar(require("./services"), exports);

package/dist/initialize/index.d.ts

@@ -0,0 +1,7 @@
+import { InternalModuleDeclaration } from "@medusajs/modules-sdk";
+import { ExternalModuleDeclaration, ILinkModule, LoaderOptions, ModuleJoinerConfig, ModuleServiceInitializeCustomDataLayerOptions, ModuleServiceInitializeOptions } from "@medusajs/types";
+import { InitializeModuleInjectableDependencies } from "../types";
+export declare const initialize: (options?: ModuleServiceInitializeOptions | ModuleServiceInitializeCustomDataLayerOptions | ExternalModuleDeclaration | InternalModuleDeclaration, modulesDefinition?: ModuleJoinerConfig[], injectedDependencies?: InitializeModuleInjectableDependencies) => Promise<{
+    [link: string]: ILinkModule;
+}>;
+export declare function runMigrations({ options, logger, }: Omit<LoaderOptions<ModuleServiceInitializeOptions>, "container">, modulesDefinition?: ModuleJoinerConfig[]): Promise<void>;

package/dist/initialize/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = exports.initialize = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const types_1 = require("@medusajs/types");
+const utils_1 = require("@medusajs/utils");
+const linkDefinitions = __importStar(require("../definitions"));
+const migration_1 = require("../migration");
+const utils_2 = require("../utils");
+const module_definition_1 = require("./module-definition");
+const initialize = async (options, modulesDefinition, injectedDependencies) => {
+    const allLinks = {};
+    const modulesLoadedKeys = modules_sdk_1.MedusaModule.getLoadedModules().map((mod) => Object.keys(mod)[0]);
+    const allLinksToLoad = Object.values(linkDefinitions).concat(modulesDefinition ?? []);
+    for (const linkDefinition of allLinksToLoad) {
+        const definition = JSON.parse(JSON.stringify(linkDefinition));
+        const [primary, foreign] = definition.relationships ?? [];
+        if (definition.relationships?.length !== 2 && !definition.isReadOnlyLink) {
+            throw new Error(`Link module ${definition.serviceName} can only link 2 modules.`);
+        }
+        else if (foreign?.foreignKey?.split(",").length > 1 &&
+            !definition.isReadOnlyLink) {
+            throw new Error(`Foreign key cannot be a composed key.`);
+        }
+        const serviceKey = !definition.isReadOnlyLink
+            ? (0, utils_1.lowerCaseFirst)(definition.serviceName ??
+                (0, utils_2.composeLinkName)(primary.serviceName, primary.foreignKey, foreign.serviceName, foreign.foreignKey))
+            : (0, utils_1.simpleHash)(JSON.stringify(definition.extends));
+        if (modulesLoadedKeys.includes(serviceKey)) {
+            continue;
+        }
+        else if (serviceKey in allLinks) {
+            throw new Error(`Link module ${serviceKey} already defined.`);
+        }
+        if (definition.isReadOnlyLink) {
+            const extended = [];
+            for (const extension of definition.extends ?? []) {
+                if (modulesLoadedKeys.includes(extension.serviceName) &&
+                    modulesLoadedKeys.includes(extension.relationship.serviceName)) {
+                    extended.push(extension);
+                }
+            }
+            definition.extends = extended;
+            if (extended.length === 0) {
+                continue;
+            }
+        }
+        else if (!modulesLoadedKeys.includes(primary.serviceName) ||
+            !modulesLoadedKeys.includes(foreign.serviceName)) {
+            // TODO: This should be uncommented when all modules are done
+            // continue
+        }
+        const moduleDefinition = (0, module_definition_1.getLinkModuleDefinition)(definition, primary, foreign);
+        const linkModuleDefinition = {
+            key: serviceKey,
+            registrationName: serviceKey,
+            label: serviceKey,
+            defaultModuleDeclaration: {
+                scope: types_1.MODULE_SCOPE.INTERNAL,
+                resources: injectedDependencies?.[utils_1.ContainerRegistrationKeys.PG_CONNECTION]
+                    ? types_1.MODULE_RESOURCE_TYPE.SHARED
+                    : types_1.MODULE_RESOURCE_TYPE.ISOLATED,
+            },
+        };
+        const loaded = await modules_sdk_1.MedusaModule.bootstrapLink(linkModuleDefinition, options, moduleDefinition, injectedDependencies);
+        allLinks[serviceKey] = Object.values(loaded)[0];
+    }
+    return allLinks;
+};
+exports.initialize = initialize;
+async function runMigrations({ options, logger, }, modulesDefinition) {
+    const modulesLoadedKeys = modules_sdk_1.MedusaModule.getLoadedModules().map((mod) => Object.keys(mod)[0]);
+    const allLinksToLoad = Object.values(linkDefinitions).concat(modulesDefinition ?? []);
+    const allLinks = new Set();
+    for (const definition of allLinksToLoad) {
+        if (definition.isReadOnlyLink) {
+            continue;
+        }
+        if (definition.relationships?.length !== 2) {
+            throw new Error(`Link module ${definition.serviceName} must have 2 relationships.`);
+        }
+        const [primary, foreign] = definition.relationships ?? [];
+        const serviceKey = (0, utils_1.lowerCaseFirst)(definition.serviceName ??
+            (0, utils_2.composeLinkName)(primary.serviceName, primary.foreignKey, foreign.serviceName, foreign.foreignKey));
+        if (modulesLoadedKeys.includes(serviceKey)) {
+            continue;
+        }
+        else if (allLinks.has(serviceKey)) {
+            throw new Error(`Link module ${serviceKey} already exists.`);
+        }
+        allLinks.add(serviceKey);
+        if (!modulesLoadedKeys.includes(primary.serviceName) ||
+            !modulesLoadedKeys.includes(foreign.serviceName)) {
+            // TODO: This should be uncommented when all modules are done
+            // continue
+        }
+        const migrate = (0, migration_1.getMigration)(definition, serviceKey, primary, foreign);
+        await migrate({ options, logger });
+    }
+}
+exports.runMigrations = runMigrations;

package/dist/initialize/module-definition.d.ts

@@ -0,0 +1,2 @@
+import { JoinerRelationship, ModuleExports, ModuleJoinerConfig } from "@medusajs/types";
+export declare function getLinkModuleDefinition(joinerConfig: ModuleJoinerConfig, primary: JoinerRelationship, foreign: JoinerRelationship): ModuleExports;

package/dist/initialize/module-definition.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkModuleDefinition = void 0;
+const _services_1 = require("../services");
+const loaders_1 = require("../loaders");
+function getLinkModuleDefinition(joinerConfig, primary, foreign) {
+    return {
+        service: joinerConfig.isReadOnlyLink
+            ? (0, _services_1.getReadOnlyModuleService)(joinerConfig)
+            : (0, _services_1.getModuleService)(joinerConfig),
+        loaders: (0, loaders_1.getLoaders)({
+            joinerConfig,
+            primary,
+            foreign,
+        }),
+    };
+}
+exports.getLinkModuleDefinition = getLinkModuleDefinition;

package/dist/links.d.ts

@@ -0,0 +1,3 @@
+export declare const LINKS: {
+    ProductVariantInventoryItem: string;
+};

package/dist/links.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINKS = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("./utils");
+exports.LINKS = {
+    ProductVariantInventoryItem: (0, utils_1.composeLinkName)(modules_sdk_1.Modules.PRODUCT, "variant_id", modules_sdk_1.Modules.INVENTORY, "inventory_item_id"),
+};

package/dist/loaders/connection.d.ts

@@ -0,0 +1,3 @@
+import { InternalModuleDeclaration, LoaderOptions, ModuleServiceInitializeCustomDataLayerOptions, ModuleServiceInitializeOptions } from "@medusajs/modules-sdk";
+import { EntitySchema } from "@mikro-orm/core";
+export declare function connectionLoader(entity: EntitySchema): ({ options, container, logger, }: LoaderOptions<ModuleServiceInitializeOptions | ModuleServiceInitializeCustomDataLayerOptions>, moduleDeclaration?: InternalModuleDeclaration) => Promise<void>;

package/dist/loaders/connection.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionLoader = void 0;
+const utils_1 = require("@medusajs/utils");
+function connectionLoader(entity) {
+    return async ({ options, container, logger, }, moduleDeclaration) => {
+        const pathToMigrations = __dirname + "/../migrations";
+        await utils_1.ModulesSdkUtils.mikroOrmConnectionLoader({
+            entities: [entity],
+            container,
+            options,
+            moduleDeclaration,
+            logger,
+            pathToMigrations,
+        });
+    };
+}
+exports.connectionLoader = connectionLoader;

package/dist/loaders/container.d.ts

@@ -0,0 +1,3 @@
+import { LoaderOptions } from "@medusajs/modules-sdk";
+import { InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes } from "@medusajs/types";
+export declare function containerLoader(entity: any, joinerConfig: ModuleJoinerConfig): ({ options, container, }: LoaderOptions<ModulesSdkTypes.ModuleServiceInitializeOptions | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions>, moduleDeclaration?: InternalModuleDeclaration) => Promise<void>;

package/dist/loaders/container.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerLoader = void 0;
+const _repositories_1 = require("../repositories");
+const _services_1 = require("../services");
+const awilix_1 = require("awilix");
+function containerLoader(entity, joinerConfig) {
+    return async ({ options, container, }, moduleDeclaration) => {
+        const [primary, foreign] = joinerConfig.relationships;
+        container.register({
+            joinerConfig: (0, awilix_1.asValue)(joinerConfig),
+            primaryKey: (0, awilix_1.asValue)(primary.foreignKey.split(",")),
+            foreignKey: (0, awilix_1.asValue)(foreign.foreignKey),
+            extraFields: (0, awilix_1.asValue)(Object.keys(joinerConfig.databaseConfig?.extraFields || {})),
+            linkModuleService: (0, awilix_1.asClass)((0, _services_1.getModuleService)(joinerConfig)).singleton(),
+            linkService: (0, awilix_1.asClass)(_services_1.LinkService).singleton(),
+            baseRepository: (0, awilix_1.asClass)(_repositories_1.BaseRepository).singleton(),
+            linkRepository: (0, awilix_1.asClass)((0, _repositories_1.getLinkRepository)(entity)).singleton(),
+        });
+    };
+}
+exports.containerLoader = containerLoader;

package/dist/loaders/index.d.ts

@@ -0,0 +1,6 @@
+import { JoinerRelationship, ModuleJoinerConfig, ModuleLoaderFunction } from "@medusajs/types";
+export declare function getLoaders({ joinerConfig, primary, foreign, }: {
+    joinerConfig: ModuleJoinerConfig;
+    primary: JoinerRelationship;
+    foreign: JoinerRelationship;
+}): ModuleLoaderFunction[];

package/dist/loaders/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoaders = void 0;
+const utils_1 = require("../utils");
+const connection_1 = require("./connection");
+const container_1 = require("./container");
+function getLoaders({ joinerConfig, primary, foreign, }) {
+    if (joinerConfig.isReadOnlyLink) {
+        return [];
+    }
+    const entity = (0, utils_1.generateEntity)(joinerConfig, primary, foreign);
+    return [(0, connection_1.connectionLoader)(entity), (0, container_1.containerLoader)(entity, joinerConfig)];
+}
+exports.getLoaders = getLoaders;

package/dist/migration/index.d.ts

@@ -0,0 +1,2 @@
+import { JoinerRelationship, LoaderOptions, ModuleJoinerConfig, ModuleServiceInitializeOptions } from "@medusajs/types";
+export declare function getMigration(joinerConfig: ModuleJoinerConfig, serviceName: string, primary: JoinerRelationship, foreign: JoinerRelationship): ({ options, logger, }?: Pick<LoaderOptions<ModuleServiceInitializeOptions>, "options" | "logger">) => Promise<void>;

package/dist/migration/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMigration = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("@medusajs/utils");
+function getMigration(joinerConfig, serviceName, primary, foreign) {
+    return async function runMigrations({ options, logger, } = {}) {
+        logger ?? (logger = console);
+        const dbData = utils_2.ModulesSdkUtils.loadDatabaseConfig("link_modules", options);
+        const entity = (0, utils_1.generateEntity)(joinerConfig, primary, foreign);
+        const pathToMigrations = __dirname + "/../migrations";
+        const orm = await utils_2.DALUtils.mikroOrmCreateConnection(dbData, [entity], pathToMigrations);
+        const tableName = entity.meta.collection;
+        let hasTable = false;
+        try {
+            await orm.em.getConnection().execute(`SELECT 1 FROM ${tableName} LIMIT 0`);
+            hasTable = true;
+        }
+        catch { }
+        const generator = orm.getSchemaGenerator();
+        if (hasTable) {
+            const updateSql = await generator.getUpdateSchemaSQL();
+            const entityUpdates = updateSql
+                .split(";")
+                .map((sql) => sql.trim())
+                .filter((sql) => sql.toLowerCase().includes(`alter table "${tableName.toLowerCase()}"`));
+            if (entityUpdates.length > 0) {
+                try {
+                    await generator.execute(entityUpdates.join(";"));
+                    logger.info(`Link module "${serviceName}" migration executed`);
+                }
+                catch (error) {
+                    logger.error(`Link module "${serviceName}" migration failed to run - Error: ${error}`);
+                }
+            }
+            else {
+                logger.info(`Skipping "${tableName}" migration.`);
+            }
+        }
+        else {
+            try {
+                await generator.createSchema();
+                logger.info(`Link module "${serviceName}" migration executed`);
+            }
+            catch (error) {
+                logger.error(`Link module "${serviceName}" migration failed to run - Error: ${error}`);
+            }
+        }
+        await orm.close();
+    };
+}
+exports.getMigration = getMigration;

package/dist/repositories/index.d.ts

@@ -0,0 +1,2 @@
+export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils";
+export { getLinkRepository } from "./link";

package/dist/repositories/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkRepository = exports.BaseRepository = void 0;
+var utils_1 = require("@medusajs/utils");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return utils_1.MikroOrmBaseRepository; } });
+var link_1 = require("./link");
+Object.defineProperty(exports, "getLinkRepository", { enumerable: true, get: function () { return link_1.getLinkRepository; } });

package/dist/repositories/link.d.ts

@@ -0,0 +1,32 @@
+import { Context, FindOptions, ModuleJoinerConfig } from "@medusajs/types";
+import { EntitySchema } from "@mikro-orm/core";
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+export declare function getLinkRepository(model: EntitySchema): {
+    new ({ manager, joinerConfig, }: {
+        manager: SqlEntityManager;
+        joinerConfig: ModuleJoinerConfig;
+    }): {
+        readonly manager_: SqlEntityManager;
+        readonly model_: EntitySchema;
+        readonly joinerConfig_: ModuleJoinerConfig;
+        find(findOptions?: FindOptions<unknown>, context?: Context): Promise<unknown[]>;
+        findAndCount(findOptions?: FindOptions<object>, context?: Context): Promise<[object[], number]>;
+        delete(data: any, context?: Context): Promise<void>;
+        create(data: object[], context?: Context): Promise<object[]>;
+        update(data: unknown[], context?: Context | undefined): Promise<object[]>;
+        softDelete(idsOrFilter: string[] | {
+            [x: string]: any;
+        }, { transactionManager: manager }?: Context | undefined): Promise<[object[], Record<string, unknown[]>]>;
+        restore(idsOrFilter: string[] | {
+            [x: string]: any;
+        }, { transactionManager: manager }?: Context | undefined): Promise<[object[], Record<string, unknown[]>]>;
+        getFreshManager<TManager = unknown>(): TManager;
+        getActiveManager<TManager_1 = unknown>({ transactionManager, manager }?: Context | undefined): TManager_1;
+        transaction<TManager_2 = unknown>(task: (transactionManager: TManager_2) => Promise<any>, options?: {
+            isolationLevel?: string | undefined;
+            enableNestedTransactions?: boolean | undefined;
+            transaction?: TManager_2 | undefined;
+        } | undefined): Promise<any>;
+        serialize<TOutput extends object | object[]>(data: any, options?: any): Promise<TOutput>;
+    };
+};

package/dist/repositories/link.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkRepository = void 0;
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("@medusajs/utils");
+function getLinkRepository(model) {
+    return class LinkRepository extends utils_1.MikroOrmAbstractBaseRepository {
+        constructor({ manager, joinerConfig, }) {
+            // @ts-ignore
+            super(...arguments);
+            this.manager_ = manager;
+            this.model_ = model;
+            this.joinerConfig_ = joinerConfig;
+        }
+        async find(findOptions = { where: {} }, context = {}) {
+            const manager = this.getActiveManager(context);
+            const findOptions_ = { ...findOptions };
+            findOptions_.options ?? (findOptions_.options = {});
+            Object.assign(findOptions_.options, {
+                strategy: core_1.LoadStrategy.SELECT_IN,
+            });
+            return await manager.find(this.model_, findOptions_.where, findOptions_.options);
+        }
+        async findAndCount(findOptions = { where: {} }, context = {}) {
+            const manager = this.getActiveManager(context);
+            const findOptions_ = { ...findOptions };
+            findOptions_.options ?? (findOptions_.options = {});
+            Object.assign(findOptions_.options, {
+                strategy: core_1.LoadStrategy.SELECT_IN,
+            });
+            return await manager.findAndCount(this.model_, findOptions_.where, findOptions_.options);
+        }
+        async delete(data, context = {}) {
+            const filter = {};
+            for (const key in data) {
+                filter[key] = {
+                    $in: Array.isArray(data[key]) ? data[key] : [data[key]],
+                };
+            }
+            const manager = this.getActiveManager(context);
+            await manager.nativeDelete(this.model_, data, {});
+        }
+        async create(data, context = {}) {
+            const manager = this.getActiveManager(context);
+            const links = data.map((link) => {
+                link.id = (0, utils_1.generateEntityId)(link.id, this.joinerConfig_.databaseConfig?.idPrefix ?? "link");
+                return manager.create(this.model_, link);
+            });
+            await manager.upsertMany(this.model_, links);
+            return links;
+        }
+    };
+}
+exports.getLinkRepository = getLinkRepository;

package/dist/services/dynamic-service-class.d.ts

@@ -0,0 +1,7 @@
+import { Constructor, ILinkModule, ModuleJoinerConfig } from "@medusajs/types";
+export declare function getModuleService(joinerConfig: ModuleJoinerConfig): Constructor<ILinkModule>;
+export declare function getReadOnlyModuleService(joinerConfig: ModuleJoinerConfig): {
+    new (): {
+        __joinerConfig(): ModuleJoinerConfig;
+    };
+};

package/dist/services/dynamic-service-class.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadOnlyModuleService = exports.getModuleService = void 0;
+const _services_1 = require(".");
+function getModuleService(joinerConfig) {
+    const joinerConfig_ = JSON.parse(JSON.stringify(joinerConfig));
+    delete joinerConfig_.databaseConfig;
+    return class LinkService extends _services_1.LinkModuleService {
+        __joinerConfig() {
+            return joinerConfig_;
+        }
+    };
+}
+exports.getModuleService = getModuleService;
+function getReadOnlyModuleService(joinerConfig) {
+    return class ReadOnlyLinkService {
+        __joinerConfig() {
+            return joinerConfig;
+        }
+    };
+}
+exports.getReadOnlyModuleService = getReadOnlyModuleService;

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dynamic-service-class";
+export { default as LinkService } from "./link";
+export { default as LinkModuleService } from "./link-module-service";

package/dist/services/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkModuleService = exports.LinkService = void 0;
+__exportStar(require("./dynamic-service-class"), exports);
+var link_1 = require("./link");
+Object.defineProperty(exports, "LinkService", { enumerable: true, get: function () { return __importDefault(link_1).default; } });
+var link_module_service_1 = require("./link-module-service");
+Object.defineProperty(exports, "LinkModuleService", { enumerable: true, get: function () { return __importDefault(link_module_service_1).default; } });

package/dist/services/link-module-service.d.ts

@@ -0,0 +1,33 @@
+import { Context, DAL, FindConfig, ILinkModule, InternalModuleDeclaration, ModuleJoinerConfig, RestoreReturn, SoftDeleteReturn } from "@medusajs/types";
+import { LinkService } from ".";
+type InjectedDependencies = {
+    baseRepository: DAL.RepositoryService;
+    linkService: LinkService<any>;
+    primaryKey: string | string[];
+    foreignKey: string;
+    extraFields: string[];
+};
+export default class LinkModuleService<TLink> implements ILinkModule {
+    readonly moduleDeclaration: InternalModuleDeclaration;
+    protected baseRepository_: DAL.RepositoryService;
+    protected readonly linkService_: LinkService<TLink>;
+    protected primaryKey_: string[];
+    protected foreignKey_: string;
+    protected extraFields_: string[];
+    constructor({ baseRepository, linkService, primaryKey, foreignKey, extraFields, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __joinerConfig(): ModuleJoinerConfig;
+    private buildData;
+    private isValidKeyName;
+    private validateFields;
+    retrieve(primaryKeyData: string | string[], foreignKeyData: string, sharedContext?: Context): Promise<unknown>;
+    list(filters?: Record<string, unknown>, config?: FindConfig<unknown>, sharedContext?: Context): Promise<unknown[]>;
+    listAndCount(filters?: Record<string, unknown>, config?: FindConfig<unknown>, sharedContext?: Context): Promise<[unknown[], number]>;
+    create(primaryKeyOrBulkData: string | string[] | [string | string[], string, Record<string, unknown>][], foreignKeyData?: string, extraFields?: Record<string, unknown>, sharedContext?: Context): Promise<object[]>;
+    dismiss(primaryKeyOrBulkData: string | string[] | [string | string[], string][], foreignKeyData?: string, sharedContext?: Context): Promise<object[]>;
+    delete(data: any, sharedContext?: Context): Promise<void>;
+    softDelete(data: any, { returnLinkableKeys }?: SoftDeleteReturn, sharedContext?: Context): Promise<Record<string, unknown[]> | void>;
+    protected softDelete_(data: any, sharedContext?: Context): Promise<[string[], Record<string, string[]>]>;
+    restore(data: any, { returnLinkableKeys }?: RestoreReturn, sharedContext?: Context): Promise<Record<string, unknown[]> | void>;
+    restore_(data: any, sharedContext?: Context): Promise<[string[], Record<string, string[]>]>;
+}
+export {};

package/dist/services/link-module-service.js

@@ -0,0 +1,204 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const utils_2 = require("../utils");
+class LinkModuleService {
+    constructor({ baseRepository, linkService, primaryKey, foreignKey, extraFields, }, moduleDeclaration) {
+        this.moduleDeclaration = moduleDeclaration;
+        this.baseRepository_ = baseRepository;
+        this.linkService_ = linkService;
+        this.primaryKey_ = !Array.isArray(primaryKey) ? [primaryKey] : primaryKey;
+        this.foreignKey_ = foreignKey;
+        this.extraFields_ = extraFields;
+    }
+    __joinerConfig() {
+        return {};
+    }
+    buildData(primaryKeyData, foreignKeyData, extra = {}) {
+        if (this.primaryKey_.length > 1) {
+            if (!Array.isArray(primaryKeyData) ||
+                primaryKeyData.length !== this.primaryKey_.length) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Primary key data must be an array ${this.primaryKey_.length} values`);
+            }
+        }
+        const pk = this.primaryKey_.join(",");
+        return {
+            [pk]: primaryKeyData,
+            [this.foreignKey_]: foreignKeyData,
+            ...extra,
+        };
+    }
+    isValidKeyName(name) {
+        return this.primaryKey_.concat(this.foreignKey_).includes(name);
+    }
+    validateFields(data) {
+        const keys = Object.keys(data);
+        if (!keys.every((k) => this.isValidKeyName(k))) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid field name provided. Valid field names are ${this.primaryKey_.concat(this.foreignKey_)}`);
+        }
+    }
+    async retrieve(primaryKeyData, foreignKeyData, sharedContext = {}) {
+        const filter = this.buildData(primaryKeyData, foreignKeyData);
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filter);
+        const entry = await this.linkService_.list(queryOptions, {}, sharedContext);
+        if (!entry?.length) {
+            const pk = this.primaryKey_.join(",");
+            const errMessage = `${pk}[${primaryKeyData}] and ${this.foreignKey_}[${foreignKeyData}]`;
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Entry ${errMessage} was not found`);
+        }
+        return entry[0];
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        const rows = await this.linkService_.list(filters, config, sharedContext);
+        return await this.baseRepository_.serialize(rows);
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        const [rows, count] = await this.linkService_.listAndCount(filters, config, sharedContext);
+        return [await this.baseRepository_.serialize(rows), count];
+    }
+    async create(primaryKeyOrBulkData, foreignKeyData, extraFields, sharedContext = {}) {
+        const data = [];
+        if (foreignKeyData === undefined && Array.isArray(primaryKeyOrBulkData)) {
+            for (const [primaryKey, foreignKey, extra] of primaryKeyOrBulkData) {
+                data.push(this.buildData(primaryKey, foreignKey, extra));
+            }
+        }
+        else {
+            data.push(this.buildData(primaryKeyOrBulkData, foreignKeyData, extraFields));
+        }
+        const links = await this.linkService_.create(data, sharedContext);
+        return await this.baseRepository_.serialize(links);
+    }
+    async dismiss(primaryKeyOrBulkData, foreignKeyData, sharedContext = {}) {
+        const data = [];
+        if (foreignKeyData === undefined && Array.isArray(primaryKeyOrBulkData)) {
+            for (const [primaryKey, foreignKey] of primaryKeyOrBulkData) {
+                data.push(this.buildData(primaryKey, foreignKey));
+            }
+        }
+        else {
+            data.push(this.buildData(primaryKeyOrBulkData, foreignKeyData));
+        }
+        const links = await this.linkService_.dismiss(data, sharedContext);
+        return await this.baseRepository_.serialize(links);
+    }
+    async delete(data, sharedContext = {}) {
+        this.validateFields(data);
+        await this.linkService_.delete(data, sharedContext);
+    }
+    async softDelete(data, { returnLinkableKeys } = {}, sharedContext = {}) {
+        this.validateFields(data);
+        let [, cascadedEntitiesMap] = await this.softDelete_(data, sharedContext);
+        const pk = this.primaryKey_.join(",");
+        const entityNameToLinkableKeysMap = {
+            LinkModel: [
+                { mapTo: pk, valueFrom: pk },
+                { mapTo: this.foreignKey_, valueFrom: this.foreignKey_ },
+            ],
+        };
+        let mappedCascadedEntitiesMap;
+        if (returnLinkableKeys) {
+            // Map internal table/column names to their respective external linkable keys
+            // eg: product.id = product_id, variant.id = variant_id
+            mappedCascadedEntitiesMap = (0, utils_1.mapObjectTo)(cascadedEntitiesMap, entityNameToLinkableKeysMap, {
+                pick: returnLinkableKeys,
+            });
+        }
+        return mappedCascadedEntitiesMap ? mappedCascadedEntitiesMap : void 0;
+    }
+    async softDelete_(data, sharedContext = {}) {
+        return await this.linkService_.softDelete(data, sharedContext);
+    }
+    async restore(data, { returnLinkableKeys } = {}, sharedContext = {}) {
+        this.validateFields(data);
+        let [, cascadedEntitiesMap] = await this.restore_(data, sharedContext);
+        const pk = this.primaryKey_.join(",");
+        const entityNameToLinkableKeysMap = {
+            LinkModel: [
+                { mapTo: pk, valueFrom: pk },
+                { mapTo: this.foreignKey_, valueFrom: this.foreignKey_ },
+            ],
+        };
+        let mappedCascadedEntitiesMap;
+        if (returnLinkableKeys) {
+            // Map internal table/column names to their respective external linkable keys
+            // eg: product.id = product_id, variant.id = variant_id
+            mappedCascadedEntitiesMap = (0, utils_1.mapObjectTo)(cascadedEntitiesMap, entityNameToLinkableKeysMap, {
+                pick: returnLinkableKeys,
+            });
+        }
+        return mappedCascadedEntitiesMap ? mappedCascadedEntitiesMap : void 0;
+    }
+    async restore_(data, sharedContext = {}) {
+        return await this.linkService_.restore(data, sharedContext);
+    }
+}
+exports.default = LinkModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "retrieve", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "dismiss", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "delete", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "softDelete_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkModuleService.prototype, "restore_", null);

package/dist/services/link.d.ts

@@ -0,0 +1,16 @@
+import { Context, FindConfig } from "@medusajs/types";
+type InjectedDependencies = {
+    linkRepository: any;
+};
+export default class LinkService<TEntity> {
+    protected readonly linkRepository_: any;
+    constructor({ linkRepository }: InjectedDependencies);
+    list(filters?: unknown, config?: FindConfig<unknown>, sharedContext?: Context): Promise<TEntity[]>;
+    listAndCount(filters?: {}, config?: FindConfig<unknown>, sharedContext?: Context): Promise<[TEntity[], number]>;
+    create(data: unknown[], sharedContext?: Context): Promise<TEntity[]>;
+    dismiss(data: unknown[], sharedContext?: Context): Promise<TEntity[]>;
+    delete(data: unknown, sharedContext?: Context): Promise<void>;
+    softDelete(data: any, sharedContext?: Context): Promise<[string[], Record<string, string[]>]>;
+    restore(data: any, sharedContext?: Context): Promise<[string[], Record<string, string[]>]>;
+}
+export {};

package/dist/services/link.js

@@ -0,0 +1,121 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const utils_2 = require("../utils");
+class LinkService {
+    constructor({ linkRepository }) {
+        this.linkRepository_ = linkRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return await this.linkRepository_.find(queryOptions, sharedContext);
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return await this.linkRepository_.findAndCount(queryOptions, sharedContext);
+    }
+    async create(data, sharedContext = {}) {
+        return await this.linkRepository_.create(data, {
+            transactionManager: sharedContext.transactionManager,
+        });
+    }
+    async dismiss(data, sharedContext = {}) {
+        const filter = [];
+        for (const pair of data) {
+            filter.push({
+                $and: Object.entries(pair).map(([key, value]) => ({
+                    [key]: value,
+                })),
+            });
+        }
+        const [rows] = await this.linkRepository_.softDelete({ $or: filter }, {
+            transactionManager: sharedContext.transactionManager,
+        });
+        return rows;
+    }
+    async delete(data, sharedContext = {}) {
+        await this.linkRepository_.delete(data, {
+            transactionManager: sharedContext.transactionManager,
+        });
+    }
+    async softDelete(data, sharedContext = {}) {
+        const filter = {};
+        for (const key in data) {
+            filter[key] = { $in: Array.isArray(data[key]) ? data[key] : [data[key]] };
+        }
+        return await this.linkRepository_.softDelete(filter, {
+            transactionManager: sharedContext.transactionManager,
+        });
+    }
+    async restore(data, sharedContext = {}) {
+        const filter = {};
+        for (const key in data) {
+            filter[key] = { $in: Array.isArray(data[key]) ? data[key] : [data[key]] };
+        }
+        return await this.linkRepository_.restore(data, {
+            transactionManager: sharedContext.transactionManager,
+        });
+    }
+}
+exports.default = LinkService;
+__decorate([
+    (0, utils_1.InjectManager)("linkRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("linkRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "linkRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "linkRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "dismiss", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "linkRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "delete", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "linkRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "softDelete", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "linkRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], LinkService.prototype, "restore", null);

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from "@medusajs/types";
+export type InitializeModuleInjectableDependencies = {
+    logger?: Logger;
+};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/compose-link-name.d.ts

@@ -0,0 +1,2 @@
+export declare const composeLinkName: (...args: any[]) => string;
+export declare const composeTableName: (...args: any[]) => string;

package/dist/utils/compose-link-name.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeTableName = exports.composeLinkName = void 0;
+const utils_1 = require("@medusajs/utils");
+const composeLinkName = (...args) => {
+    return (0, utils_1.lowerCaseFirst)((0, utils_1.toPascalCase)((0, exports.composeTableName)(...args.concat("link"))));
+};
+exports.composeLinkName = composeLinkName;
+const composeTableName = (...args) => {
+    return args.map((name) => name.replace(/(_id|Service)$/gi, "")).join("_");
+};
+exports.composeTableName = composeTableName;

package/dist/utils/generate-entity.d.ts

@@ -0,0 +1,3 @@
+import { JoinerRelationship, ModuleJoinerConfig } from "@medusajs/types";
+import { EntitySchema } from "@mikro-orm/core";
+export declare function generateEntity(joinerConfig: ModuleJoinerConfig, primary: JoinerRelationship, foreign: JoinerRelationship): EntitySchema<any, never>;

package/dist/utils/generate-entity.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEntity = void 0;
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const compose_link_name_1 = require("./compose-link-name");
+function getClass(...properties) {
+    return class LinkModel {
+        constructor(...values) {
+            properties.forEach((name, idx) => {
+                this[name] = values[idx];
+            });
+        }
+    };
+}
+function generateEntity(joinerConfig, primary, foreign) {
+    const fieldNames = primary.foreignKey.split(",").concat(foreign.foreignKey);
+    const tableName = joinerConfig.databaseConfig?.tableName ??
+        (0, compose_link_name_1.composeTableName)(primary.serviceName, primary.foreignKey, foreign.serviceName, foreign.foreignKey);
+    const fields = fieldNames.reduce((acc, curr) => {
+        acc[curr] = {
+            type: "string",
+            nullable: false,
+            primary: true,
+        };
+        return acc;
+    }, {});
+    const extraFields = joinerConfig.databaseConfig?.extraFields ?? {};
+    for (const column in extraFields) {
+        fieldNames.push(column);
+        fields[column] = {
+            type: extraFields[column].type,
+            nullable: !!extraFields[column].nullable,
+            defaultRaw: extraFields[column].defaultValue,
+            ...(extraFields[column].options ?? {}),
+        };
+    }
+    const hashTableName = (0, utils_1.simpleHash)(tableName);
+    return new core_1.EntitySchema({
+        class: getClass(...fieldNames.concat("created_at", "updated_at", "deleted_at")),
+        tableName,
+        properties: {
+            id: {
+                type: "string",
+                nullable: false,
+            },
+            ...fields,
+            created_at: {
+                type: "Date",
+                nullable: false,
+                defaultRaw: "CURRENT_TIMESTAMP",
+            },
+            updated_at: {
+                type: "Date",
+                nullable: false,
+                defaultRaw: "CURRENT_TIMESTAMP",
+            },
+            deleted_at: { type: "Date", nullable: true },
+        },
+        filters: {
+            [utils_1.SoftDeletableFilterKey]: utils_1.mikroOrmSoftDeletableFilterOptions,
+        },
+        indexes: [
+            {
+                properties: ["id"],
+                name: "IDX_id_" + hashTableName,
+            },
+            {
+                properties: primary.foreignKey.split(","),
+                name: "IDX_" +
+                    primary.foreignKey.split(",").join("_") +
+                    "_" +
+                    hashTableName,
+            },
+            {
+                properties: foreign.foreignKey,
+                name: "IDX_" + foreign.foreignKey + "_" + hashTableName,
+            },
+            {
+                properties: ["deleted_at"],
+                name: "IDX_deleted_at_" + hashTableName,
+            },
+        ],
+    });
+}
+exports.generateEntity = generateEntity;

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./compose-link-name";
+export * from "./generate-entity";
+export declare function shouldForceTransaction(target: any): boolean;
+export declare function doNotForceTransaction(): boolean;

package/dist/utils/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doNotForceTransaction = exports.shouldForceTransaction = void 0;
+const types_1 = require("@medusajs/types");
+__exportStar(require("./compose-link-name"), exports);
+__exportStar(require("./generate-entity"), exports);
+function shouldForceTransaction(target) {
+    return target.moduleDeclaration?.resources === types_1.MODULE_RESOURCE_TYPE.ISOLATED;
+}
+exports.shouldForceTransaction = shouldForceTransaction;
+function doNotForceTransaction() {
+    return false;
+}
+exports.doNotForceTransaction = doNotForceTransaction;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@medusajs/link-modules",
+  "version": "0.1.0-canary-20230831100806",
+  "description": "Medusa Default Link Modules Package and Definitions",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/link-modules"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Medusa",
+  "license": "MIT",
+  "scripts": {
+    "watch": "tsc --build --watch",
+    "watch:test": "tsc --build tsconfig.spec.json --watch",
+    "prepare": "cross-env NODE_ENV=production yarn run build",
+    "build": "rimraf dist && tsc --build && tsc-alias -p tsconfig.json",
+    "test": "jest --passWithNoTests --runInBand --bail --forceExit",
+    "test:integration": "jest --passWithNoTests"
+  },
+  "devDependencies": {
+    "cross-env": "^5.2.1",
+    "jest": "^29.6.3",
+    "pg-god": "^1.0.12",
+    "rimraf": "^5.0.1",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@medusajs/modules-sdk": "1.10.0-canary-20230831100806",
+    "@medusajs/types": "1.11.0-canary-20230831100806",
+    "@medusajs/utils": "1.10.0-canary-20230831100806",
+    "@mikro-orm/core": "5.7.12",
+    "@mikro-orm/postgresql": "5.7.12",
+    "awilix": "^8.0.0"
+  }
+}