feat: Payment module package setup

packages/payment/src/index.ts

@@ -0,0 +1,23 @@
+import { moduleDefinition } from "./module-definition"
+import { Modules } from "@medusajs/modules-sdk"
+import { ModulesSdkUtils } from "@medusajs/utils"
+
+import * as PaymentModels from "@models"
+
+export default moduleDefinition
+
+const migrationScriptOptions = {
+  moduleName: Modules.PAYMENT,
+  models: PaymentModels,
+  pathToMigrations: __dirname + "/migrations",
+}
+
+export const runMigrations = ModulesSdkUtils.buildMigrationScript(
+  migrationScriptOptions
+)
+export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
+  migrationScriptOptions
+)
+
+export * from "./initialize"
+export * from "./loaders"

packages/payment/src/initialize/index.ts

@@ -0,0 +1,27 @@
+import {
+  ExternalModuleDeclaration,
+  InternalModuleDeclaration,
+  MedusaModule,
+  MODULE_PACKAGE_NAMES,
+  Modules,
+} from "@medusajs/modules-sdk"
+import { IPaymentModuleService, ModulesSdkTypes } from "@medusajs/types"
+import { moduleDefinition } from "../module-definition"
+import { InitializeModuleInjectableDependencies } from "../types"
+
+export const initialize = async (
+  options?: ModulesSdkTypes.ModuleBootstrapDeclaration,
+  injectedDependencies?: InitializeModuleInjectableDependencies
+): Promise<IPaymentModuleService> => {
+  const loaded = await MedusaModule.bootstrap<IPaymentModuleService>({
+    moduleKey: Modules.PAYMENT,
+    defaultPath: MODULE_PACKAGE_NAMES[Modules.PAYMENT],
+    declaration: options as
+      | InternalModuleDeclaration
+      | ExternalModuleDeclaration,
+    injectedDependencies,
+    moduleExports: moduleDefinition,
+  })
+
+  return loaded[Modules.PAYMENT]
+}

packages/payment/src/joiner-config.ts

@@ -0,0 +1,31 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { ModuleJoinerConfig } from "@medusajs/types"
+import { MapToConfig } from "@medusajs/utils"
+import { Payment } from "@models"
+
+export const LinkableKeys = {
+  payment_id: Payment.name,
+}
+
+const entityLinkableKeysMap: MapToConfig = {}
+Object.entries(LinkableKeys).forEach(([key, value]) => {
+  entityLinkableKeysMap[value] ??= []
+  entityLinkableKeysMap[value].push({
+    mapTo: key,
+    valueFrom: key.split("_").pop()!,
+  })
+})
+
+export const entityNameToLinkableKeysMap: MapToConfig = entityLinkableKeysMap
+
+export const joinerConfig: ModuleJoinerConfig = {
+  serviceName: Modules.PAYMENT,
+  primaryKeys: ["id"],
+  linkableKeys: LinkableKeys,
+  alias: {
+    name: ["payment", "payments"],
+    args: {
+      entity: Payment.name,
+    },
+  },
+}

packages/payment/src/loaders/connection.ts

@@ -0,0 +1,34 @@
+import {
+  InternalModuleDeclaration,
+  LoaderOptions,
+  Modules,
+} from "@medusajs/modules-sdk"
+import { ModulesSdkTypes } from "@medusajs/types"
+import { ModulesSdkUtils } from "@medusajs/utils"
+import { EntitySchema } from "@mikro-orm/core"
+import * as PaymentModels from "../models"
+
+export default async (
+  {
+    options,
+    container,
+    logger,
+  }: LoaderOptions<
+    | ModulesSdkTypes.ModuleServiceInitializeOptions
+    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+  >,
+  moduleDeclaration?: InternalModuleDeclaration
+): Promise<void> => {
+  const entities = Object.values(PaymentModels) as unknown as EntitySchema[]
+  const pathToMigrations = __dirname + "/../migrations"
+
+  await ModulesSdkUtils.mikroOrmConnectionLoader({
+    moduleName: Modules.PAYMENT,
+    entities,
+    container,
+    options,
+    moduleDeclaration,
+    logger,
+    pathToMigrations,
+  })
+}

packages/payment/src/loaders/container.ts

@@ -0,0 +1,39 @@
+import { LoaderOptions } from "@medusajs/modules-sdk"
+import { ModulesSdkTypes } from "@medusajs/types"
+import { loadCustomRepositories } from "@medusajs/utils"
+import { asClass } from "awilix"
+
+import * as defaultRepositories from "@repositories"
+import * as defaultServices from "@services"
+
+export default async ({
+  container,
+  options,
+}: LoaderOptions<
+  | ModulesSdkTypes.ModuleServiceInitializeOptions
+  | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+>): Promise<void> => {
+  const customRepositories = (
+    options as ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+  )?.repositories
+
+  container.register({
+    // paymentService: asClass(defaultServices.PaymentService).singleton(),
+  })
+
+  if (customRepositories) {
+    loadCustomRepositories({
+      defaultRepositories,
+      customRepositories,
+      container,
+    })
+  } else {
+    loadDefaultRepositories({ container })
+  }
+}
+
+function loadDefaultRepositories({ container }) {
+  container.register({
+    baseRepository: asClass(defaultRepositories.BaseRepository).singleton(),
+  })
+}

packages/payment/src/loaders/index.ts

@@ -0,0 +1,2 @@
+export * from "./connection"
+export * from "./container"

packages/payment/src/models/index.ts

@@ -0,0 +1 @@
+export { default as Payment } from "./payment"

packages/payment/src/module-definition.ts

@@ -0,0 +1,14 @@
+import { ModuleExports } from "@medusajs/types"
+
+import { PaymentModuleService } from "@services"
+
+import loadConnection from "./loaders/connection"
+import loadContainer from "./loaders/container"
+
+const service = PaymentModuleService
+const loaders = [loadContainer, loadConnection] as any
+
+export const moduleDefinition: ModuleExports = {
+  service,
+  loaders,
+}

packages/payment/src/repositories/index.ts

@@ -0,0 +1 @@
+export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"

packages/payment/src/scripts/bin/run-seed.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { EOL } from "os"
+import { ModulesSdkUtils } from "@medusajs/utils"
+import { Modules } from "@medusajs/modules-sdk"
+
+import * as PaymentModels from "@models"
+
+import { createPayments } from "../seed-utils"
+
+const args = process.argv
+const path = args.pop() as string
+
+export default (async () => {
+  const { config } = await import("dotenv")
+  config()
+  if (!path) {
+    throw new Error(
+      `filePath is required.${EOL}Example: medusa-payment-seed <filePath>`
+    )
+  }
+
+  const run = ModulesSdkUtils.buildSeedScript({
+    moduleName: Modules.PAYMENT,
+    models: PaymentModels,
+    pathToMigrations: __dirname + "/../../migrations",
+    seedHandler: async ({ manager, data }) => {
+      const { paymentsData } = data
+      await createPayments(manager, paymentsData)
+    },
+  })
+  await run({ path })
+})()

packages/payment/src/scripts/seed-utils.ts

@@ -0,0 +1,8 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql"
+
+export async function createPayments(
+  manager: SqlEntityManager,
+  paymentsData: any[]
+): Promise<any[]> {
+  return []
+}

packages/payment/src/services/__tests__/index.spec.ts

@@ -0,0 +1,5 @@
+describe("Noop test", () => {
+  it("noop check", async () => {
+    expect(true).toBe(true)
+  })
+})

packages/payment/src/services/index.ts

@@ -0,0 +1 @@
+export { default as PaymentModuleService } from "./payment-module"

packages/payment/src/services/payment-module.ts

@@ -0,0 +1,29 @@
+import {
+  DAL,
+  InternalModuleDeclaration,
+  ModuleJoinerConfig,
+} from "@medusajs/types"
+
+import { Payment } from "@models"
+
+import { joinerConfig } from "../joiner-config"
+
+type InjectedDependencies = {
+  baseRepository: DAL.RepositoryService
+}
+
+// TODO: implement IPaymentModule
+export default class PaymentModule<TPayment extends Payment = Payment> {
+  protected baseRepository_: DAL.RepositoryService
+
+  constructor(
+    { baseRepository }: InjectedDependencies,
+    protected readonly moduleDeclaration: InternalModuleDeclaration
+  ) {
+    this.baseRepository_ = baseRepository
+  }
+
+  __joinerConfig(): ModuleJoinerConfig {
+    return joinerConfig
+  }
+}

packages/payment/src/types/index.ts

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