mercur-cli 0.1.5 → 0.1.7

package/mercur/backend/integration-tests/http/README.md

@@ -1,29 +0,0 @@
-# Integration Tests
-
-The `medusa-test-utils` package provides utility functions to create integration tests for your API routes and workflows.
-
-For example:
-
-```ts
-import { medusaIntegrationTestRunner } from "medusa-test-utils"
-
-medusaIntegrationTestRunner({
-  testSuite: ({ api, getContainer }) => {
-    describe("Custom endpoints", () => {
-      describe("GET /store/custom", () => {
-        it("returns correct message", async () => {
-          const response = await api.get(
-            `/store/custom`
-          )
-  
-          expect(response.status).toEqual(200)
-          expect(response.data).toHaveProperty("message")
-          expect(response.data.message).toEqual("Hello, World!")
-        })
-      })
-    })
-  }
-})
-```
-
-Learn more in [this documentation](https://docs.medusajs.com/learn/debugging-and-testing/testing-tools/integration-tests).

package/mercur/backend/integration-tests/http/health.spec.ts

@@ -1,15 +0,0 @@
-import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
-jest.setTimeout(60 * 1000)
-
-medusaIntegrationTestRunner({
-  inApp: true,
-  env: {},
-  testSuite: ({ api }) => {
-    describe("Ping", () => {
-      it("ping the server health endpoint", async () => {
-        const response = await api.get('/health')
-        expect(response.status).toEqual(200)
-      })
-    })
-  },
-})

package/mercur/backend/integration-tests/setup.js

@@ -1,3 +0,0 @@
-const { MetadataStorage } = require("@mikro-orm/core")
-
-MetadataStorage.clear()

package/mercur/backend/jest.config.js

@@ -1,27 +0,0 @@
-const { loadEnv } = require("@medusajs/utils");
-loadEnv("test", process.cwd());
-
-module.exports = {
-  transform: {
-    "^.+\\.[jt]s$": [
-      "@swc/jest",
-      {
-        jsc: {
-          parser: { syntax: "typescript", decorators: true },
-        },
-      },
-    ],
-  },
-  testEnvironment: "node",
-  moduleFileExtensions: ["js", "ts", "json"],
-  modulePathIgnorePatterns: ["dist/", "<rootDir>/.medusa/"],
-  setupFiles: ["./integration-tests/setup.js"],
-};
-
-if (process.env.TEST_TYPE === "integration:http") {
-  module.exports.testMatch = ["**/integration-tests/http/*.spec.[jt]s"];
-} else if (process.env.TEST_TYPE === "integration:modules") {
-  module.exports.testMatch = ["**/src/modules/*/__tests__/**/*.[jt]s"];
-} else if (process.env.TEST_TYPE === "unit") {
-  module.exports.testMatch = ["**/src/**/__tests__/**/*.unit.spec.[jt]s"];
-}

package/mercur/backend/medusa-config.ts

@@ -1,88 +0,0 @@
-
-import { defineConfig, loadEnv } from '@medusajs/framework/utils'
-
-loadEnv(process.env.NODE_ENV || 'development', process.cwd())
-
-module.exports = defineConfig({
-  projectConfig: {
-    databaseUrl: process.env.DATABASE_URL,
-    http: {
-      storeCors: process.env.STORE_CORS!,
-      adminCors: process.env.ADMIN_CORS!,
-      // @ts-expect-error: vendorCors is not a valid config
-      vendorCors: process.env.VENDOR_CORS!,
-      authCors: process.env.AUTH_CORS!,
-      jwtSecret: process.env.JWT_SECRET || 'supersecret',
-      cookieSecret: process.env.COOKIE_SECRET || 'supersecret'
-    }
-  },
-  plugins: [
-    {
-      resolve: '@mercurjs/b2c-core',
-      options: {}
-    },
-    {
-      resolve: '@mercurjs/commission',
-      options: {}
-    },
-    {
-      resolve: '@mercurjs/algolia',
-      options: {
-        apiKey: process.env.ALGOLIA_API_KEY,
-        appId: process.env.ALGOLIA_APP_ID
-      }
-    },
-    {
-      resolve: '@mercurjs/reviews',
-      options: {}
-    },
-    {
-      resolve: '@mercurjs/requests',
-      options: {}
-    },
-    {
-      resolve: '@mercurjs/resend',
-      options: {}
-    }
-  ],
-  modules: [
-    {
-      resolve: '@medusajs/medusa/payment',
-      options: {
-        providers: [
-          {
-            resolve:
-              '@mercurjs/payment-stripe-connect/providers/stripe-connect',
-            id: 'stripe-connect',
-            options: {
-              apiKey: process.env.STRIPE_SECRET_API_KEY
-            }
-          }
-        ]
-      }
-    },
-    {
-      resolve: '@medusajs/medusa/notification',
-      options: {
-        providers: [
-          {
-            resolve: '@mercurjs/resend/providers/resend',
-            id: 'resend',
-            options: {
-              channels: ['email'],
-              api_key: process.env.RESEND_API_KEY,
-              from: process.env.RESEND_FROM_EMAIL
-            }
-          },
-          {
-            resolve: '@medusajs/medusa/notification-local',
-            id: 'local',
-            options: {
-              channels: ['feed', 'seller_feed']
-            }
-          }
-        ]
-      }
-    }
-  ]
-})

package/mercur/backend/package.json

@@ -1,65 +0,0 @@
-{
-  "name": "medusa-starter-default",
-  "version": "0.0.1",
-  "description": "A starter for Medusa projects.",
-  "author": "Medusa (https://medusajs.com)",
-  "license": "MIT",
-  "keywords": [
-    "sqlite",
-    "postgres",
-    "typescript",
-    "ecommerce",
-    "headless",
-    "medusa"
-  ],
-  "scripts": {
-    "build": "medusa build",
-    "seed": "medusa exec ./src/scripts/seed.ts",
-    "start": "medusa start",
-    "dev": "medusa develop",
-    "test:integration:http": "TEST_TYPE=integration:http NODE_OPTIONS=--experimental-vm-modules jest --silent=false --runInBand --forceExit",
-    "test:integration:modules": "TEST_TYPE=integration:modules NODE_OPTIONS=--experimental-vm-modules jest --silent=false --runInBand --forceExit",
-    "test:unit": "TEST_TYPE=unit NODE_OPTIONS=--experimental-vm-modules jest --silent --runInBand --forceExit"
-  },
-  "dependencies": {
-    "@medusajs/admin-sdk": "2.10.3",
-    "@medusajs/cli": "2.10.3",
-    "@medusajs/framework": "2.10.3",
-    "@medusajs/medusa": "2.10.3",
-    "@mercurjs/algolia": "^1.3.0",
-    "@mercurjs/b2c-core": "^1.3.0",
-    "@mercurjs/commission": "^1.3.0",
-    "@mercurjs/framework": "^1.3.0",
-    "@mercurjs/payment-stripe-connect": "^1.3.0",
-    "@mercurjs/requests": "^1.3.0",
-    "@mercurjs/resend": "^1.3.0",
-    "@mercurjs/reviews": "^1.3.0",
-    "@mikro-orm/core": "6.4.3",
-    "@mikro-orm/knex": "6.4.3",
-    "@mikro-orm/migrations": "6.4.3",
-    "@mikro-orm/postgresql": "6.4.3",
-    "awilix": "^8.0.1",
-    "pg": "^8.13.0"
-  },
-  "devDependencies": {
-    "@medusajs/test-utils": "2.10.3",
-    "@mikro-orm/cli": "6.4.3",
-    "@swc/core": "1.5.7",
-    "@swc/jest": "^0.2.36",
-    "@types/jest": "^29.5.13",
-    "@types/node": "^20.0.0",
-    "@types/react": "^18.3.2",
-    "@types/react-dom": "^18.2.25",
-    "jest": "^29.7.0",
-    "prop-types": "^15.8.1",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.2",
-    "vite": "^5.2.11",
-    "yalc": "^1.0.0-pre.53"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}

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

@@ -1,33 +0,0 @@
-# Admin Customizations
-
-You can extend the Medusa Admin to add widgets and new pages. Your customizations interact with API routes to provide merchants with custom functionalities.
-
-> Learn more about Admin Extensions in [this documentation](https://docs.medusajs.com/learn/fundamentals/admin).
-
-## Example: Create a Widget
-
-A widget is a React component that can be injected into an existing page in the admin dashboard.
-
-For example, create the file `src/admin/widgets/product-widget.tsx` with the following content:
-
-```tsx title="src/admin/widgets/product-widget.tsx"
-import { defineWidgetConfig } from "@medusajs/admin-sdk"
-
-// The widget
-const ProductWidget = () => {
-  return (
-    <div>
-      <h2>Product Widget</h2>
-    </div>
-  )
-}
-
-// The widget's configurations
-export const config = defineWidgetConfig({
-  zone: "product.details.after",
-})
-
-export default ProductWidget
-```
-
-This inserts a widget with the text “Product Widget” at the end of a product’s details page.

package/mercur/backend/src/admin/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["."]
-}

package/mercur/backend/src/admin/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

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

@@ -1,135 +0,0 @@
-# Custom API Routes
-
-An API Route is a REST API endpoint.
-
-An API Route is created in a TypeScript or JavaScript file under the `/src/api` directory of your Medusa application. The file’s name must be `route.ts` or `route.js`.
-
-> Learn more about API Routes in [this documentation](https://docs.medusajs.com/learn/fundamentals/api-routes)
-
-For example, to create a `GET` API Route at `/store/hello-world`, create the file `src/api/store/hello-world/route.ts` with the following content:
-
-```ts
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
-
-export async function GET(req: MedusaRequest, res: MedusaResponse) {
-  res.json({
-    message: "Hello world!",
-  });
-}
-```
-
-## Supported HTTP methods
-
-The file based routing supports the following HTTP methods:
-
-- GET
-- POST
-- PUT
-- PATCH
-- DELETE
-- OPTIONS
-- HEAD
-
-You can define a handler for each of these methods by exporting a function with the name of the method in the paths `route.ts` file.
-
-For example:
-
-```ts
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
-
-export async function GET(req: MedusaRequest, res: MedusaResponse) {
-  // Handle GET requests
-}
-
-export async function POST(req: MedusaRequest, res: MedusaResponse) {
-  // Handle POST requests
-}
-
-export async function PUT(req: MedusaRequest, res: MedusaResponse) {
-  // Handle PUT requests
-}
-```
-
-## Parameters
-
-To create an API route that accepts a path parameter, create a directory within the route's path whose name is of the format `[param]`.
-
-For example, if you want to define a route that takes a `productId` parameter, you can do so by creating a file called `/api/products/[productId]/route.ts`:
-
-```ts
-import type {
-  MedusaRequest,
-  MedusaResponse,
-} from "@medusajs/framework/http"
-
-export async function GET(req: MedusaRequest, res: MedusaResponse) {
-  const { productId } = req.params;
-
-  res.json({
-    message: `You're looking for product ${productId}`
-  })
-}
-```
-
-To create an API route that accepts multiple path parameters, create within the file's path multiple directories whose names are of the format `[param]`.
-
-For example, if you want to define a route that takes both a `productId` and a `variantId` parameter, you can do so by creating a file called `/api/products/[productId]/variants/[variantId]/route.ts`.
-
-## Using the container
-
-The Medusa container is available on `req.scope`. Use it to access modules' main services and other registered resources:
-
-```ts
-import type {
-  MedusaRequest,
-  MedusaResponse,
-} from "@medusajs/framework/http"
-
-export const GET = async (
-  req: MedusaRequest,
-  res: MedusaResponse
-) => {
-  const productModuleService = req.scope.resolve("product")
-
-  const [, count] = await productModuleService.listAndCount()
-
-  res.json({
-    count,
-  })
-}
-```
-
-## Middleware
-
-You can apply middleware to your routes by creating a file called `/api/middlewares.ts`. This file must export a configuration object with what middleware you want to apply to which routes.
-
-For example, if you want to apply a custom middleware function to the `/store/custom` route, you can do so by adding the following to your `/api/middlewares.ts` file:
-
-```ts
-import { defineMiddlewares } from "@medusajs/framework/http"
-import type {
-  MedusaRequest,
-  MedusaResponse,
-  MedusaNextFunction,
-} from "@medusajs/framework/http";
-
-async function logger(
-  req: MedusaRequest,
-  res: MedusaResponse,
-  next: MedusaNextFunction
-) {
-  console.log("Request received");
-  next();
-}
-
-export default defineMiddlewares({
-  routes: [
-    {
-      matcher: "/store/custom",
-      middlewares: [logger],
-    },
-  ],
-})
-```
-
-The `matcher` property can be either a string or a regular expression. The `middlewares` property accepts an array of middleware functions.

package/mercur/backend/src/api/admin/custom/route.ts

@@ -1,8 +0,0 @@
-import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
-
-export async function GET(
-  req: MedusaRequest,
-  res: MedusaResponse
-) {
-  res.sendStatus(200);
-}

package/mercur/backend/src/api/store/custom/route.ts

@@ -1,8 +0,0 @@
-import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
-
-export async function GET(
-  req: MedusaRequest,
-  res: MedusaResponse
-) {
-  res.sendStatus(200);
-}

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

@@ -1,38 +0,0 @@
-# Custom scheduled jobs
-
-A scheduled job is a function executed at a specified interval of time in the background of your Medusa application.
-
-> Learn more about scheduled jobs in [this documentation](https://docs.medusajs.com/learn/fundamentals/scheduled-jobs).
-
-A scheduled job is created in a TypeScript or JavaScript file under the `src/jobs` directory.
-
-For example, create the file `src/jobs/hello-world.ts` with the following content:
-
-```ts
-import {
-  MedusaContainer
-} from "@medusajs/framework/types";
-
-export default async function myCustomJob(container: MedusaContainer) {
-  const productService = container.resolve("product")
-
-  const products = await productService.listAndCountProducts();
-
-  // Do something with the products
-}
-
-export const config = {
-  name: "daily-product-report",
-  schedule: "0 0 * * *", // Every day at midnight
-};
-```
-
-A scheduled job file must export:
-
-- The function to be executed whenever it’s time to run the scheduled job.
-- A configuration object defining the job. It has three properties:
-  - `name`: a unique name for the job.
-  - `schedule`: a [cron expression](https://crontab.guru/).
-  - `numberOfExecutions`: an optional integer, specifying how many times the job will execute before being removed
-
-The `handler` is a function that accepts one parameter, `container`, which is a `MedusaContainer` instance used to resolve services.

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

@@ -1,26 +0,0 @@
-# Module Links
-
-A module link forms an association between two data models of different modules, while maintaining module isolation.
-
-> Learn more about links in [this documentation](https://docs.medusajs.com/learn/fundamentals/module-links)
-
-For example:
-
-```ts
-import BlogModule from "../modules/blog"
-import ProductModule from "@medusajs/medusa/product"
-import { defineLink } from "@medusajs/framework/utils"
-
-export default defineLink(
-  ProductModule.linkable.product,
-  BlogModule.linkable.post
-)
-```
-
-This defines a link between the Product Module's `product` data model and the Blog Module (custom module)'s `post` data model.
-
-Then, in the Medusa application, run the following command to sync the links to the database:
-
-```bash
-npx medusa db:migrate
-```

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

@@ -1,117 +0,0 @@
-# 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
-  })
-}
-```