mercur-cli 0.1.2 → 0.1.5

package/mercur/backend/src/modules/README.md

@@ -0,0 +1,117 @@
+# Custom Module
+
+A module is a package of reusable functionalities. It can be integrated into your Medusa application without affecting the overall system. You can create a module as part of a plugin.
+
+> Learn more about modules in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules).
+
+To create a module:
+
+## 1. Create a Data Model
+
+A data model represents a table in the database. You create a data model in a TypeScript or JavaScript file under the `models` directory of a module.
+
+For example, create the file `src/modules/blog/models/post.ts` with the following content:
+
+```ts
+import { model } from "@medusajs/framework/utils"
+
+const Post = model.define("post", {
+  id: model.id().primaryKey(),
+  title: model.text(),
+})
+
+export default Post
+```
+
+## 2. Create a Service
+
+A module must define a service. A service is a TypeScript or JavaScript class holding methods related to a business logic or commerce functionality.
+
+For example, create the file `src/modules/blog/service.ts` with the following content:
+
+```ts
+import { MedusaService } from "@medusajs/framework/utils"
+import Post from "./models/post"
+
+class BlogModuleService extends MedusaService({
+  Post,
+}){
+}
+
+export default BlogModuleService
+```
+
+## 3. Export Module Definition
+
+A module must have an `index.ts` file in its root directory that exports its definition. The definition specifies the main service of the module.
+
+For example, create the file `src/modules/blog/index.ts` with the following content:
+
+```ts
+import BlogModuleService from "./service"
+import { Module } from "@medusajs/framework/utils"
+
+export const BLOG_MODULE = "blog"
+
+export default Module(BLOG_MODULE, {
+  service: BlogModuleService,
+})
+```
+
+## 4. Add Module to Medusa's Configurations
+
+To start using the module, add it to `medusa-config.ts`:
+
+```ts
+module.exports = defineConfig({
+  projectConfig: {
+    // ...
+  },
+  modules: [
+    {
+      resolve: "./src/modules/blog",
+    },
+  ],
+})
+```
+
+## 5. Generate and Run Migrations
+
+To generate migrations for your module, run the following command:
+
+```bash
+npx medusa db:generate blog
+```
+
+Then, to run migrations, run the following command:
+
+```bash
+npx medusa db:migrate
+```
+
+## Use Module
+
+You can use the module in customizations within the Medusa application, such as workflows and API routes.
+
+For example, to use the module in an API route:
+
+```ts
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework"
+import BlogModuleService from "../../../modules/blog/service"
+import { BLOG_MODULE } from "../../../modules/blog"
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+): Promise<void> {
+  const blogModuleService: BlogModuleService = req.scope.resolve(
+    BLOG_MODULE
+  )
+
+  const posts = await blogModuleService.listPosts()
+
+  res.json({
+    posts
+  })
+}
+```

package/mercur/backend/src/scripts/README.md

@@ -0,0 +1,63 @@
+# Custom CLI Script
+
+A custom CLI script is a function to execute through Medusa's CLI tool. This is useful when creating custom Medusa tooling to run as a CLI tool.
+
+> Learn more about custom CLI scripts in [this documentation](https://docs.medusajs.com/learn/fundamentals/custom-cli-scripts).
+
+## How to Create a Custom CLI Script?
+
+To create a custom CLI script, create a TypeScript or JavaScript file under the `src/scripts` directory. The file must default export a function.
+
+For example, create the file `src/scripts/my-script.ts` with the following content:
+
+```ts title="src/scripts/my-script.ts"
+import { 
+  ExecArgs,
+} from "@medusajs/framework/types"
+
+export default async function myScript ({
+  container
+}: ExecArgs) {
+  const productModuleService = container.resolve("product")
+
+  const [, count] = await productModuleService.listAndCountProducts()
+
+  console.log(`You have ${count} product(s)`)
+}
+```
+
+The function receives as a parameter an object having a `container` property, which is an instance of the Medusa Container. Use it to resolve resources in your Medusa application.
+
+---
+
+## How to Run Custom CLI Script?
+
+To run the custom CLI script, run the `exec` command:
+
+```bash
+npx medusa exec ./src/scripts/my-script.ts
+```
+
+---
+
+## Custom CLI Script Arguments
+
+Your script can accept arguments from the command line. Arguments are passed to the function's object parameter in the `args` property.
+
+For example:
+
+```ts
+import { ExecArgs } from "@medusajs/framework/types"
+
+export default async function myScript ({
+  args
+}: ExecArgs) {
+  console.log(`The arguments you passed: ${args}`)
+}
+```
+
+Then, pass the arguments in the `exec` command after the file path:
+
+```bash
+npx medusa exec ./src/scripts/my-script.ts arg1 arg2
+```

package/mercur/backend/src/scripts/seed/seed-functions.ts

@@ -0,0 +1,519 @@
+import { MedusaContainer } from '@medusajs/framework'
+import { ContainerRegistrationKeys, Modules } from '@medusajs/framework/utils'
+import {
+  createApiKeysWorkflow,
+  createCollectionsWorkflow,
+  createInventoryLevelsWorkflow,
+  createProductCategoriesWorkflow,
+  createProductsWorkflow,
+  createRegionsWorkflow,
+  createSalesChannelsWorkflow,
+  createServiceZonesWorkflow,
+  createShippingOptionsWorkflow,
+  createStockLocationsWorkflow,
+  createTaxRegionsWorkflow,
+  linkSalesChannelsToApiKeyWorkflow,
+  updateStoresWorkflow
+} from '@medusajs/medusa/core-flows'
+
+import { SELLER_MODULE } from '@mercurjs/b2c-core/modules/seller'
+import {
+  createConfigurationRuleWorkflow,
+  createLocationFulfillmentSetAndAssociateWithSellerWorkflow,
+  createSellerWorkflow
+} from '@mercurjs/b2c-core/workflows'
+import { createCommissionRuleWorkflow } from '@mercurjs/commission/workflows'
+import {
+  ConfigurationRuleDefaults,
+  SELLER_SHIPPING_PROFILE_LINK
+} from '@mercurjs/framework'
+
+import { productsToInsert } from './seed-products'
+
+const countries = ['be', 'de', 'dk', 'se', 'fr', 'es', 'it', 'pl', 'cz', 'nl']
+
+export async function createSalesChannel(container: MedusaContainer) {
+  const salesChannelModuleService = container.resolve(Modules.SALES_CHANNEL)
+  let [defaultSalesChannel] = await salesChannelModuleService.listSalesChannels(
+    {
+      name: 'Default Sales Channel'
+    }
+  )
+
+  if (!defaultSalesChannel) {
+    const {
+      result: [salesChannelResult]
+    } = await createSalesChannelsWorkflow(container).run({
+      input: {
+        salesChannelsData: [
+          {
+            name: 'Default Sales Channel'
+          }
+        ]
+      }
+    })
+    defaultSalesChannel = salesChannelResult
+  }
+
+  return defaultSalesChannel
+}
+
+export async function createStore(
+  container: MedusaContainer,
+  salesChannelId: string,
+  regionId: string
+) {
+  const storeModuleService = container.resolve(Modules.STORE)
+  const [store] = await storeModuleService.listStores()
+
+  if (!store) {
+    return
+  }
+
+  await updateStoresWorkflow(container).run({
+    input: {
+      selector: { id: store.id },
+      update: {
+        supported_currencies: [
+          {
+            currency_code: 'eur',
+            is_default: true
+          }
+        ],
+        default_sales_channel_id: salesChannelId,
+        default_region_id: regionId
+      }
+    }
+  })
+}
+export async function createRegions(container: MedusaContainer) {
+  const {
+    result: [region]
+  } = await createRegionsWorkflow(container).run({
+    input: {
+      regions: [
+        {
+          name: 'Europe',
+          currency_code: 'eur',
+          countries,
+          payment_providers: ['pp_system_default']
+        }
+      ]
+    }
+  })
+
+  await createTaxRegionsWorkflow(container).run({
+    input: countries.map((country_code) => ({
+      country_code
+    }))
+  })
+
+  return region
+}
+
+export async function createPublishableKey(
+  container: MedusaContainer,
+  salesChannelId: string
+) {
+  const apiKeyService = container.resolve(Modules.API_KEY)
+
+  let [key] = await apiKeyService.listApiKeys({ type: 'publishable' })
+
+  if (!key) {
+    const {
+      result: [publishableApiKeyResult]
+    } = await createApiKeysWorkflow(container).run({
+      input: {
+        api_keys: [
+          {
+            title: 'Default publishable key',
+            type: 'publishable',
+            created_by: ''
+          }
+        ]
+      }
+    })
+    key = publishableApiKeyResult
+  }
+
+  await linkSalesChannelsToApiKeyWorkflow(container).run({
+    input: {
+      id: key.id,
+      add: [salesChannelId]
+    }
+  })
+
+  return key
+}
+
+export async function createProductCategories(container: MedusaContainer) {
+  const { result } = await createProductCategoriesWorkflow(container).run({
+    input: {
+      product_categories: [
+        {
+          name: 'Sneakers',
+          is_active: true
+        },
+        {
+          name: 'Sandals',
+          is_active: true
+        },
+        {
+          name: 'Boots',
+          is_active: true
+        },
+        {
+          name: 'Sport',
+          is_active: true
+        },
+        {
+          name: 'Accessories',
+          is_active: true
+        },
+        {
+          name: 'Tops',
+          is_active: true
+        }
+      ]
+    }
+  })
+
+  return result
+}
+
+export async function createProductCollections(container: MedusaContainer) {
+  const { result } = await createCollectionsWorkflow(container).run({
+    input: {
+      collections: [
+        {
+          title: 'Luxury'
+        },
+        {
+          title: 'Vintage'
+        },
+        {
+          title: 'Casual'
+        },
+        {
+          title: 'Soho'
+        },
+        {
+          title: 'Streetwear'
+        },
+        {
+          title: 'Y2K'
+        }
+      ]
+    }
+  })
+
+  return result
+}
+
+export async function createSeller(container: MedusaContainer) {
+  const authService = container.resolve(Modules.AUTH)
+
+  const { authIdentity } = await authService.register('emailpass', {
+    body: {
+      email: 'seller@mercurjs.com',
+      password: 'secret'
+    }
+  })
+
+  const { result: seller } = await createSellerWorkflow.run({
+    container,
+    input: {
+      auth_identity_id: authIdentity?.id,
+      member: {
+        name: 'John Doe',
+        email: 'seller@mercurjs.com'
+      },
+      seller: {
+        name: 'MercurJS Store'
+      }
+    }
+  })
+
+  return seller
+}
+
+export async function createSellerStockLocation(
+  container: MedusaContainer,
+  sellerId: string,
+  salesChannelId: string
+) {
+  const link = container.resolve(ContainerRegistrationKeys.LINK)
+  const {
+    result: [stock]
+  } = await createStockLocationsWorkflow(container).run({
+    input: {
+      locations: [
+        {
+          name: `Stock Location for seller ${sellerId}`,
+          address: {
+            address_1: 'Random Strasse',
+            city: 'Berlin',
+            country_code: 'de'
+          }
+        }
+      ]
+    }
+  })
+
+  await link.create([
+    {
+      [SELLER_MODULE]: {
+        seller_id: sellerId
+      },
+      [Modules.STOCK_LOCATION]: {
+        stock_location_id: stock.id
+      }
+    },
+    {
+      [Modules.STOCK_LOCATION]: {
+        stock_location_id: stock.id
+      },
+      [Modules.FULFILLMENT]: {
+        fulfillment_provider_id: 'manual_manual'
+      }
+    },
+    {
+      [Modules.SALES_CHANNEL]: {
+        sales_channel_id: salesChannelId
+      },
+      [Modules.STOCK_LOCATION]: {
+        stock_location_id: stock.id
+      }
+    }
+  ])
+
+  await createLocationFulfillmentSetAndAssociateWithSellerWorkflow.run({
+    container,
+    input: {
+      fulfillment_set_data: {
+        name: `${sellerId} fulfillment set`,
+        type: 'shipping'
+      },
+      location_id: stock.id,
+      seller_id: sellerId
+    }
+  })
+
+  const query = container.resolve(ContainerRegistrationKeys.QUERY)
+
+  const {
+    data: [stockLocation]
+  } = await query.graph({
+    entity: 'stock_location',
+    fields: ['*', 'fulfillment_sets.*'],
+    filters: {
+      id: stock.id
+    }
+  })
+
+  return stockLocation
+}
+
+export async function createServiceZoneForFulfillmentSet(
+  container: MedusaContainer,
+  sellerId: string,
+  fulfillmentSetId: string
+) {
+  await createServiceZonesWorkflow.run({
+    container,
+    input: {
+      data: [
+        {
+          fulfillment_set_id: fulfillmentSetId,
+          name: `Europe`,
+          geo_zones: countries.map((c) => ({
+            type: 'country',
+            country_code: c
+          }))
+        }
+      ]
+    }
+  })
+
+  const fulfillmentService = container.resolve(Modules.FULFILLMENT)
+
+  const [zone] = await fulfillmentService.listServiceZones({
+    fulfillment_set: {
+      id: fulfillmentSetId
+    }
+  })
+
+  const link = container.resolve(ContainerRegistrationKeys.LINK)
+  await link.create({
+    [SELLER_MODULE]: {
+      seller_id: sellerId
+    },
+    [Modules.FULFILLMENT]: {
+      service_zone_id: zone.id
+    }
+  })
+
+  return zone
+}
+
+export async function createSellerShippingOption(
+  container: MedusaContainer,
+  sellerId: string,
+  sellerName: string,
+  regionId: string,
+  serviceZoneId: string
+) {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY)
+  const {
+    data: [shippingProfile]
+  } = await query.graph({
+    entity: SELLER_SHIPPING_PROFILE_LINK,
+    fields: ['shipping_profile_id'],
+    filters: {
+      seller_id: sellerId
+    }
+  })
+
+  const {
+    result: [shippingOption]
+  } = await createShippingOptionsWorkflow.run({
+    container,
+    input: [
+      {
+        name: `${sellerName} shipping`,
+        shipping_profile_id: shippingProfile.shipping_profile_id,
+        service_zone_id: serviceZoneId,
+        provider_id: 'manual_manual',
+        type: {
+          label: `${sellerName} shipping`,
+          code: sellerName,
+          description: 'Europe shipping'
+        },
+        rules: [
+          { value: 'true', attribute: 'enabled_in_store', operator: 'eq' },
+          { attribute: 'is_return', value: 'false', operator: 'eq' }
+        ],
+        prices: [
+          { currency_code: 'eur', amount: 10 },
+          { amount: 10, region_id: regionId }
+        ],
+        price_type: 'flat',
+        data: { id: 'manual-fulfillment' }
+      }
+    ]
+  })
+
+  const link = container.resolve(ContainerRegistrationKeys.LINK)
+  await link.create({
+    [SELLER_MODULE]: {
+      seller_id: sellerId
+    },
+    [Modules.FULFILLMENT]: {
+      shipping_option_id: shippingOption.id
+    }
+  })
+
+  return shippingOption
+}
+
+export async function createSellerProducts(
+  container: MedusaContainer,
+  sellerId: string,
+  salesChannelId: string
+) {
+  const productService = container.resolve(Modules.PRODUCT)
+  const collections = await productService.listProductCollections(
+    {},
+    { select: ['id', 'title'] }
+  )
+  const categories = await productService.listProductCategories(
+    {},
+    { select: ['id', 'name'] }
+  )
+
+  const randomCategory = () =>
+    categories[Math.floor(Math.random() * categories.length)]
+  const randomCollection = () =>
+    collections[Math.floor(Math.random() * collections.length)]
+
+  const toInsert = productsToInsert.map((p) => ({
+    ...p,
+    categories: [
+      {
+        id: randomCategory().id
+      }
+    ],
+    collection_id: randomCollection().id,
+    sales_channels: [
+      {
+        id: salesChannelId
+      }
+    ]
+  }))
+
+  const { result } = await createProductsWorkflow.run({
+    container,
+    input: {
+      products: toInsert,
+      additional_data: {
+        seller_id: sellerId
+      }
+    }
+  })
+
+  return result
+}
+
+export async function createInventoryItemStockLevels(
+  container: MedusaContainer,
+  stockLocationId: string
+) {
+  const inventoryService = container.resolve(Modules.INVENTORY)
+  const items = await inventoryService.listInventoryItems(
+    {},
+    { select: ['id'] }
+  )
+
+  const toCreate = items.map((i) => ({
+    inventory_item_id: i.id,
+    location_id: stockLocationId,
+    stocked_quantity: Math.floor(Math.random() * 50) + 1
+  }))
+
+  const { result } = await createInventoryLevelsWorkflow.run({
+    container,
+    input: {
+      inventory_levels: toCreate
+    }
+  })
+  return result
+}
+
+export async function createDefaultCommissionLevel(container: MedusaContainer) {
+  await createCommissionRuleWorkflow.run({
+    container,
+    input: {
+      name: 'default',
+      is_active: true,
+      reference: 'site',
+      reference_id: '',
+      rate: {
+        include_tax: true,
+        type: 'percentage',
+        percentage_rate: 2
+      }
+    }
+  })
+}
+
+export async function createConfigurationRules(container: MedusaContainer) {
+  for (const [ruleType, isEnabled] of ConfigurationRuleDefaults) {
+    await createConfigurationRuleWorkflow.run({
+      container,
+      input: {
+        rule_type: ruleType,
+        is_enabled: isEnabled
+      }
+    })
+  }
+}