4d16acf5f0
What:
- Definition of all Modules links
- `link-modules` package to manage the creation of all pre-defined link or custom ones
```typescript
import { initialize as iniInventory } from "@medusajs/inventory";
import { initialize as iniProduct } from "@medusajs/product";
import {
initialize as iniLinks,
runMigrations as migrateLinks
} from "@medusajs/link-modules";
await Promise.all([iniInventory(), iniProduct()]);
await migrateLinks(); // create tables based on previous loaded modules
await iniLinks(); // load link based on previous loaded modules
await iniLinks(undefined, [
{
serviceName: "product_custom_translation_service_link",
isLink: true,
databaseConfig: {
tableName: "product_transalations",
},
alias: [
{
name: "translations",
},
],
primaryKeys: ["id", "product_id", "translation_id"],
relationships: [
{
serviceName: Modules.PRODUCT,
primaryKey: "id",
foreignKey: "product_id",
alias: "product",
},
{
serviceName: "custom_translation_service",
primaryKey: "id",
foreignKey: "translation_id",
alias: "transalation",
deleteCascade: true,
},
],
extends: [
{
serviceName: Modules.PRODUCT,
relationship: {
serviceName: "product_custom_translation_service_link",
primaryKey: "product_id",
foreignKey: "id",
alias: "translations",
isList: true,
},
},
{
serviceName: "custom_translation_service",
relationship: {
serviceName: "product_custom_translation_service_link",
primaryKey: "product_id",
foreignKey: "id",
alias: "product_link",
},
},
],
},
]); // custom links
```
Remote Link
```typescript
import { RemoteLink, Modules } from "@medusajs/modules-sdk";
// [...] initialize modules and links
const remoteLink = new RemoteLink();
// upsert the relationship
await remoteLink.create({ // one (object) or many (array)
[Modules.PRODUCT]: {
variant_id: "var_abc",
},
[Modules.INVENTORY]: {
inventory_item_id: "iitem_abc",
},
data: { // optional additional fields
required_quantity: 5
}
});
// dismiss (doesn't cascade)
await remoteLink.dismiss({ // one (object) or many (array)
[Modules.PRODUCT]: {
variant_id: "var_abc",
},
[Modules.INVENTORY]: {
inventory_item_id: "iitem_abc",
},
});
// delete
await remoteLink.delete({
// every key is a module
[Modules.PRODUCT]: {
// every key is a linkable field
variant_id: "var_abc", // single or multiple values
},
});
// restore
await remoteLink.restore({
// every key is a module
[Modules.PRODUCT]: {
// every key is a linkable field
variant_id: "var_abc", // single or multiple values
},
});
```
Co-authored-by: Riqwan Thamir <5105988+riqwan@users.noreply.github.com>
102 lines
2.5 KiB
TypeScript
102 lines
2.5 KiB
TypeScript
import { Context, DAL, RepositoryTransformOptions } from "@medusajs/types"
|
|
import { MedusaContext } from "../decorators"
|
|
|
|
class AbstractBase<T = any> {
|
|
protected readonly manager_: any
|
|
|
|
protected constructor({ manager }) {
|
|
this.manager_ = manager
|
|
}
|
|
|
|
getActiveManager<TManager = unknown>(
|
|
@MedusaContext()
|
|
{ transactionManager, manager }: Context = {}
|
|
): TManager {
|
|
return (transactionManager ?? manager ?? this.manager_) as TManager
|
|
}
|
|
|
|
async transaction<TManager = unknown>(
|
|
task: (transactionManager: TManager) => Promise<any>,
|
|
{
|
|
transaction,
|
|
isolationLevel,
|
|
enableNestedTransactions = false,
|
|
}: {
|
|
isolationLevel?: string
|
|
enableNestedTransactions?: boolean
|
|
transaction?: TManager
|
|
} = {}
|
|
): Promise<any> {
|
|
// @ts-ignore
|
|
return await transactionWrapper.apply(this, arguments)
|
|
}
|
|
}
|
|
|
|
export abstract class AbstractBaseRepository<T = any>
|
|
extends AbstractBase
|
|
implements DAL.RepositoryService<T>
|
|
{
|
|
abstract find(options?: DAL.FindOptions<T>, context?: Context)
|
|
|
|
abstract findAndCount(
|
|
options?: DAL.FindOptions<T>,
|
|
context?: Context
|
|
): Promise<[T[], number]>
|
|
|
|
abstract create(data: unknown[], context?: Context): Promise<T[]>
|
|
|
|
abstract update(data: unknown[], context?: Context): Promise<T[]>
|
|
|
|
abstract delete(ids: string[], context?: Context): Promise<void>
|
|
|
|
abstract softDelete(
|
|
ids: string[],
|
|
context?: Context
|
|
): Promise<[T[], Record<string, unknown[]>]>
|
|
|
|
abstract restore(
|
|
ids: string[],
|
|
context?: Context
|
|
): Promise<[T[], Record<string, unknown[]>]>
|
|
|
|
abstract getFreshManager<TManager = unknown>(): TManager
|
|
|
|
abstract serialize<TOutput extends object | object[]>(
|
|
data: any,
|
|
options?: any
|
|
): Promise<TOutput>
|
|
}
|
|
|
|
export abstract class AbstractTreeRepositoryBase<T = any>
|
|
extends AbstractBase<T>
|
|
implements DAL.TreeRepositoryService<T>
|
|
{
|
|
protected constructor({ manager }) {
|
|
// @ts-ignore
|
|
super(...arguments)
|
|
}
|
|
|
|
abstract find(
|
|
options?: DAL.FindOptions<T>,
|
|
transformOptions?: RepositoryTransformOptions,
|
|
context?: Context
|
|
)
|
|
|
|
abstract findAndCount(
|
|
options?: DAL.FindOptions<T>,
|
|
transformOptions?: RepositoryTransformOptions,
|
|
context?: Context
|
|
): Promise<[T[], number]>
|
|
|
|
abstract create(data: unknown, context?: Context): Promise<T>
|
|
|
|
abstract delete(id: string, context?: Context): Promise<void>
|
|
|
|
abstract getFreshManager<TManager = unknown>(): TManager
|
|
|
|
abstract serialize<TOutput extends object | object[]>(
|
|
data: any,
|
|
options?: any
|
|
): Promise<TOutput>
|
|
}
|