Merge pull request #17 from lambda-curry/mohsen/360t-167-move-plugin-code-from-monorepo-packages-into-its-own-package

Author: dwene

.gitignore

@@ -29,3 +29,5 @@ build
 
 .yalc
 yalc.lock
+
+plugins/**/node_modules

plugins/braintree-payment/README.md

@@ -0,0 +1,129 @@
+# Braintree Payment Provider for Medusa
+
+This plugin integrates Braintree as a payment provider for your Medusa store. It allows you to process payments, handle 3D Secure authentication, and manage payment methods seamlessly.
+
+## Quick Start
+
+1. **Install the plugin:**
+   ```bash
+   npm install @lambdacurry/medusa-payment-braintree
+   ```
+2. **Set the required environment variables** in your `.env` file (see below).
+3. **Add the provider** to your `medusa-config.js` or `config.ts` (see below).
+4. **Add the required custom fields** in your Braintree dashboard (see below).
+5. **Restart your Medusa server.**
+
+## Features
+
+- Secure payment processing with Braintree.
+- Support for 3D Secure authentication.
+- Webhook handling for payment updates.
+- Save payment methods for future transactions.
+
+## Installation
+
+Install the plugin in your Medusa project:
+
+```bash
+npm install @lambdacurry/medusa-payment-braintree
+```
+
+## Configuration
+
+### Environment Variables
+
+Set the following environment variables in your `.env` file:
+
+```env
+BRAINTREE_PUBLIC_KEY=<your_public_key>
+BRAINTREE_MERCHANT_ID=<your_merchant_id>
+BRAINTREE_PRIVATE_KEY=<your_private_key>
+BRAINTREE_WEBHOOK_SECRET=<your_webhook_secret>
+BRAINTREE_ENVIRONMENT=sandbox|development|production|qa
+BRAINTREE_ENABLE_3D_SECURE=true|false
+```
+
+- `BRAINTREE_PUBLIC_KEY`: Your Braintree public key.
+- `BRAINTREE_MERCHANT_ID`: Your Braintree merchant ID.
+- `BRAINTREE_PRIVATE_KEY`: Your Braintree private key.
+- `BRAINTREE_WEBHOOK_SECRET`: Secret for validating Braintree webhooks.
+- `BRAINTREE_ENVIRONMENT`: One of `sandbox`, `development`, `production`, or `qa`.
+- `BRAINTREE_ENABLE_3D_SECURE`: Set to `true` to enable 3D Secure authentication, otherwise `false`.
+
+### Medusa Configuration
+
+Add the following configuration to the `payment` section of your `medusa-config.js` or `config.ts` file:
+
+```javascript
+{
+  resolve: '@lambdacurry/medusa-payment-braintree/providers/payment-braintree',
+  id: 'braintree',
+  options: {
+    environment: process.env.BRAINTREE_ENVIRONMENT || (process.env.NODE_ENV !== 'production' ? 'sandbox' : 'production'),
+    merchantId: process.env.BRAINTREE_MERCHANT_ID,
+    publicKey: process.env.BRAINTREE_PUBLIC_KEY,
+    privateKey: process.env.BRAINTREE_PRIVATE_KEY,
+    webhookSecret: process.env.BRAINTREE_WEBHOOK_SECRET,
+    enable3DSecure: process.env.BRAINTREE_ENABLE_3D_SECURE === 'true',
+    savePaymentMethod: true, // Save payment methods for future use
+    autoCapture: true,        // Automatically capture payments
+  }
+}
+```
+
+#### Options
+
+- **merchantId**: Your Braintree Merchant ID.
+- **publicKey**: Your Braintree Public Key.
+- **privateKey**: Your Braintree Private Key.
+- **webhookSecret**: Secret for validating Braintree webhooks.
+- **enable3DSecure**: Enable 3D Secure authentication (`true` or `false`).
+- **savePaymentMethod**: Save payment methods for future use (default: `true`).
+- **autoCapture**: Automatically capture payments (default: `true`).
+
+> **Note:**
+> - `autoCapture`: If set to `true`, payments are captured automatically after authorization.
+> - `savePaymentMethod`: If set to `true`, customer payment methods are saved for future use.
+
+### 3D Secure Setup
+
+If you enable 3D Secure (`BRAINTREE_ENABLE_3D_SECURE=true`), you may need to make additional changes on your storefront to support 3D Secure flows. Refer to the [Braintree 3D Secure documentation](https://developer.paypal.com/braintree/docs/guides/3d-secure/overview/) for more details.
+
+### Webhook Setup
+
+To handle payment updates from Braintree, you need to configure webhooks:
+
+1. In your Braintree dashboard, go to **Settings > Webhooks**.
+2. Add a new webhook and set the URL to your Medusa server's webhook endpoint (e.g., `https://your-medusa-server.com/webhooks/braintree`).
+3. Use the value of `BRAINTREE_WEBHOOK_SECRET` as the secret for validating incoming webhooks.
+4. Make sure your Medusa server is configured to handle Braintree webhook events.
+
+For more information, see the [Braintree Webhooks documentation](https://developer.paypal.com/braintree/docs/guides/webhooks/overview).
+
+### Adding Custom Fields in the Braintree Dashboard
+
+To ensure proper integration with Medusa, you need to add the following custom fields in your Braintree dashboard:
+
+1. **Navigate to:**  
+   `Account Settings` → `Transactions` → `Custom Fields`
+
+2. **Add each custom field:**
+   - Click the **Options** button.
+   - Click the **Add** button.
+   - Enter the details for each field as shown below:
+
+| Field Name                | API Name                    | Description         | Options             |
+|--------------------------|-----------------------------|---------------------|---------------------|
+| Medusa Payment Session Id | `medusa_payment_session_id` | Medusa Session Id   | Store and Pass back |
+| Cart Id                   | `cart_id`                   | Cart Id             | Store and Pass back |
+| Customer Id               | `customer_id`               | Customer Id         | Store and Pass back |
+
+> **Note:**  
+> - The **API Name** must be in lowercase.  
+> - Set the **Options** to "Store and Pass back" for each field.
+
+## License
+
+This plugin is licensed under the [MIT License](LICENSE).
+
+For more information, visit the [Braintree Documentation](https://developer.paypal.com/braintree/docs).  

plugins/braintree-payment/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@lambdacurry/medusa-payment-braintree",
+  "version": "0.0.5",
+  "description": "Braintree plugin for Medusa",
+  "author": "Lambda Curry (https://lambdacurry.dev)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lambda-curry/medusa-plugins.git"
+  },
+  "homepage": "https://github.com/lambda-curry/medusa-plugins/tree/main/plugins/braintree-payment",
+  "files": [
+    ".medusa/server"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./.medusa/server/src/modules/*": "./.medusa/server/src/modules/*/index.js",
+    "./providers/*": "./.medusa/server/src/providers/*/src/index.js",
+    "./*": "./.medusa/server/src/*.js"
+  },
+  "keywords": [
+    "medusa",
+    "plugin",
+    "braintree",
+    "medusa-plugin-integration",
+    "medusa-v2",
+    "medusa-plugin-braintree",
+    "medusa-plugin",
+    "medusa-plugin-payment",
+    "lambdacurry"
+  ],
+  "devDependencies": {
+    "@medusajs/admin-sdk": "2.8.2",
+    "@medusajs/cli": "2.8.2",
+    "@medusajs/framework": "2.8.2",
+    "@medusajs/icons": "2.8.2",
+    "@medusajs/medusa": "2.8.2",
+    "@medusajs/test-utils": "2.8.2",
+    "@medusajs/ui": "4.0.3",
+    "@swc/core": "1.5.7",
+    "@types/braintree": "^3.3.14"
+  },
+  "scripts": {
+    "build": "npx medusa plugin:build",
+    "plugin:dev": "npx medusa plugin:develop",
+    "prepublishOnly": "npx medusa plugin:build"
+  },
+  "peerDependencies": {
+    "@medusajs/admin-sdk": "2.8.2",
+    "@medusajs/cli": "2.8.2",
+    "@medusajs/framework": "2.8.2",
+    "@medusajs/icons": "2.8.2",
+    "@medusajs/medusa": "2.8.2",
+    "@medusajs/test-utils": "2.8.2",
+    "@medusajs/ui": "4.0.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "braintree": "^3.30.0"
+  }
+}

plugins/braintree-payment/src/admin/README.md

@@ -0,0 +1,31 @@
+# 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.
+
+## 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.

plugins/braintree-payment/src/admin/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "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": ["."]
+}

plugins/braintree-payment/src/admin/vite-env.d.ts

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

plugins/braintree-payment/src/api/README.md

@@ -0,0 +1,133 @@
+# 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`.
+
+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.

plugins/braintree-payment/src/api/admin/plugin/README.md

@@ -0,0 +1 @@
+### place holder for store routes