@sgftech/medusa-plugin-product-variant-licenses 0.0.1

package/datasource.js

@@ -0,0 +1,18 @@
+const { DataSource } = require("typeorm");
+const dotenv = require("dotenv")
+dotenv.config()
+
+const AppDataSource = new DataSource({
+    type: "postgres",
+    port: 5432,
+    schema:"public",
+    username: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_NAME,
+    entities: ["dist/models/*.js"],
+    migrations: ["dist/migrations/*.js"]
+});
+
+module.exports = {
+    datasource: AppDataSource
+};

package/dist/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/index.js

@@ -0,0 +1,50 @@
+const express = require("express")
+const { GracefulShutdownServer } = require("medusa-core-utils")
+
+const loaders = require("@medusajs/medusa/dist/loaders/index").default
+
+;(async() => {
+  async function start() {
+    const app = express()
+    const directory = process.cwd()
+
+    try {
+      const { container } = await loaders({
+        directory,
+        expressApp: app
+      })
+      const configModule = container.resolve("configModule")
+      const port = process.env.PORT ?? configModule.projectConfig.port ?? 9000
+
+      const server = GracefulShutdownServer.create(
+        app.listen(port, (err) => {
+          if (err) {
+            return
+          }
+          console.log(`Server is ready on port: ${port}`)
+        })
+      )
+
+      // Handle graceful shutdown
+      const gracefulShutDown = () => {
+        server
+          .shutdown()
+          .then(() => {
+            console.info("Gracefully stopping the server.")
+            process.exit(0)
+          })
+          .catch((e) => {
+            console.error("Error received when shutting down the server.", e)
+            process.exit(1)
+          })
+      }
+      process.on("SIGTERM", gracefulShutDown)
+      process.on("SIGINT", gracefulShutDown)
+    } catch (err) {
+      console.error("Error starting server", err)
+      process.exit(1)
+    }
+  }
+
+  await start()
+})()

package/medusa-config.js

@@ -0,0 +1,153 @@
+const dotenv = require("dotenv");
+
+let ENV_FILE_NAME = "";
+switch (process.env.NODE_ENV) {
+    case "production":
+        ENV_FILE_NAME = ".env.production";
+        break;
+    case "staging":
+        ENV_FILE_NAME = ".env.staging";
+        break;
+    case "test":
+        ENV_FILE_NAME = ".env.test";
+        break;
+    case "development":
+    default:
+        ENV_FILE_NAME = ".env";
+        break;
+}
+
+try {
+    dotenv.config({ path: process.cwd() + "/" + ENV_FILE_NAME });
+} catch (e) {
+    console.error("No .env file found");
+    process.exit(1);
+}
+
+// CORS when consuming Medusa from admin
+const ADMIN_CORS =
+    process.env.ADMIN_CORS || "http://localhost:7000,http://localhost:7001";
+
+// CORS to avoid issues when consuming Medusa from a client
+const STORE_CORS = process.env.STORE_CORS || "http://localhost:8000";
+
+const DATABASE_URL =
+    process.env.DATABASE_URL || "postgres://localhost/medusa-starter-default";
+
+const OAuth2AuthorizationURL =
+    process.env.OAUTH2_AUTHORIZATION_URL ||
+    "https://discord.com/api/oauth2/authorize";
+const OAuth2TokenURL =
+    process.env.OAUTH2_TOKEN_URL || "https://discord.com/api/oauth2/token";
+const OAuth2ClientId = process.env.OAUTH2_CLIENT_ID || "1242890848341856257";
+
+const OAuth2ClientSecret = process.env.OAUTH2_CLIENT_SECRET;
+
+const OAuth2Scope = process.env.OAUTH2_SCOPE || "identify,email,guilds";
+
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+
+const BACKEND_URL = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000";
+
+const STORE_URL = process.env.MEDUSA_STORE_URL || "http://localhost:8000";
+
+const medusaOathConfig = {
+    type: "oauth2",
+    strict: "store",
+    identifier: "oauth2",
+    authorizationURL: OAuth2AuthorizationURL,
+    tokenURL: OAuth2TokenURL,
+    clientID: OAuth2ClientId,
+    clientSecret: OAuth2ClientSecret,
+    scope: OAuth2Scope.split(","),
+    // admin: {
+    // callbackUrl: `${BACKEND_URL}/admin/auth/oauth2/cb`,
+    // failureRedirect: `${ADMIN_URL}/login`,
+    // successRedirect: `${ADMIN_URL}/`,
+    // },
+    store: {
+        callbackUrl: `${BACKEND_URL}/store/auth/oauth2/cb`,
+        failureRedirect: `${STORE_URL}/login`,
+        successRedirect: `${STORE_URL}/`
+    }
+};
+
+const plugins = [
+    "medusa-fulfillment-manual",
+    "medusa-payment-manual",
+    {
+        resolve: "@medusajs/file-local",
+        options: {
+            upload_dir: "uploads"
+        }
+    },
+    {
+        resolve: "medusa-plugin-auth",
+        /** @type {import('medusa-plugin-auth').AuthOptions} */
+        options: medusaOathConfig
+    },
+    {
+        resolve: "@medusajs/admin",
+        /** @type {import('@medusajs/admin').PluginOptions} */
+        options: {
+            autoRebuild: true,
+            serve: true, // process.env.NODE_ENV?.includes("prod") ? true : false,
+            backend: process.env.MEDUSA_BACKEND_URL,
+            path: "/app",
+            develop: {
+                open: true,
+                port: 7001,
+                host: process.env.MEDUSA_BACKEND_URL,
+                logLevel: "verbose",
+                stats: "debug",
+                allowedHosts: "auto",
+                webSocketURL: undefined
+            }
+        }
+    },
+    {
+        resolve: `@rsc-labs/medusa-store-analytics`,
+        options: {
+          enableUI: true
+        }
+      },
+      {
+        resolve: `@rsc-labs/medusa-documents`,
+        options: {
+          enableUI: true
+        }
+      }
+];
+
+const modules = {
+    /* eventBus: {
+    resolve: "@medusajs/event-bus-redis",
+    options: {
+      redisUrl: REDIS_URL
+    }
+  },
+  cacheService: {
+    resolve: "@medusajs/cache-redis",
+    options: {
+      redisUrl: REDIS_URL
+    }
+  },*/
+};
+
+/** @type {import('@medusajs/medusa').ConfigModule["projectConfig"]} */
+const projectConfig = {
+    jwt_secret: process.env.JWT_SECRET || "supersecret",
+    cookie_secret: process.env.COOKIE_SECRET || "supersecret",
+    store_cors: STORE_CORS,
+    database_url: DATABASE_URL,
+    admin_cors: ADMIN_CORS,
+    // Uncomment the following lines to enable REDIS
+    redis_url: REDIS_URL
+};
+
+/** @type {import('@medusajs/medusa').ConfigModule} */
+module.exports = {
+    projectConfig,
+    plugins,
+    modules
+};

package/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@sgftech/medusa-plugin-product-variant-licenses",
+  "version": "0.0.1",
+  "description": "A plugin to handle licenses",
+  "author": "SGFGOV",
+  "license": "MIT",
+  "keywords": [
+    "sqlite",
+    "postgres",
+    "typescript",
+    "ecommerce",
+    "headless",
+    "medusa",
+    "medusa-plugin"
+  ],
+  "scripts": {
+    "clean": "cross-env ./node_modules/.bin/rimraf dist",
+    "build": "cross-env npm run clean && npm run build:server && npm run build:admin",
+    "build:server": "cross-env npm run clean && tsc -p tsconfig.server.json",
+    "build:admin": "cross-env medusa-admin build",
+    "watch": "cross-env tsc --watch",
+    "test": "cross-env jest",
+    "seed": "cross-env medusa seed -f ./data/seed.json",
+    "start": "cross-env npm run build && medusa start",
+    "start:custom": "cross-env npm run build && node --preserve-symlinks --trace-warnings index.js",
+    "dev": "cross-env npm run build:server && medusa develop"
+  },
+  "dependencies": {
+   
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.14.3",
+    "@babel/core": "^7.14.3",
+    "@babel/preset-typescript": "^7.21.4",
+    "@medusajs/medusa-cli": "latest",
+    "@stdlib/number-float64-base-normalize": "0.0.8",
+    "@types/express": "^4.17.13",
+    "@types/jest": "^27.4.0",
+    "@types/mime": "1.3.5",
+    "@types/node": "^17.0.8",
+    "babel-preset-medusa-package": "^1.1.19",
+    "cross-env": "^7.0.3",
+    "medusa-plugin-auth": "^1.11.1",
+    "eslint": "^8.23.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-typescript": "^3.0.0",
+    "eslint-plugin-file-progress": "^1.3.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.4.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.22.0",
+    "eslint-plugin-react-hooks": "^4.2.0",
+    "jest": "^27.3.1",
+    "prettier": "^2.7.1",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.0.7",
+    "ts-loader": "^9.2.6",
+    "typescript": "^4.5.2",
+    "@medusajs/admin": "^7.1.14",
+    "@medusajs/cache-inmemory": "latest",
+    "@medusajs/cache-redis": "^1.9.1",
+    "@medusajs/event-bus-local": "latest",
+    "@medusajs/event-bus-redis": "^1.8.13",
+    "@medusajs/file-local": "latest",
+    "@medusajs/medusa": "^1.20.7",
+    "@tanstack/react-query": "4.22.0",
+    "body-parser": "^1.19.0",
+    "cors": "^2.8.5",
+    "dotenv": "16.3.1",
+    "express": "^4.17.2",
+    "medusa-fulfillment-manual": "latest",
+    "medusa-interfaces": "latest",
+    "medusa-payment-manual": "latest",
+    "medusa-payment-stripe": "latest",
+    "prism-react-renderer": "^2.0.4",
+    "typeorm": "^0.3.16"
+  },
+  "peerDependencies": {
+    "@medusajs/admin": "^7.1.14",
+    "@medusajs/cache-inmemory": "latest",
+    "@medusajs/cache-redis": "^1.9.1",
+    "@medusajs/event-bus-local": "latest",
+    "@medusajs/event-bus-redis": "^1.8.13",
+    "@medusajs/file-local": "latest",
+    "@medusajs/medusa": "^1.20.7",
+    "@tanstack/react-query": "4.22.0",
+    "body-parser": "^1.19.0",
+    "cors": "^2.8.5",
+    "dotenv": "16.3.1",
+    "express": "^4.17.2",
+    "medusa-fulfillment-manual": "latest",
+    "medusa-interfaces": "latest",
+    "medusa-payment-manual": "latest",
+    "medusa-payment-stripe": "latest",
+    "prism-react-renderer": "^2.0.4",
+    "typeorm": "^0.3.16"
+  },
+  "jest": {
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.spec.json"
+      }
+    },
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "<rootDir>/node_modules/"
+    ],
+    "rootDir": "src",
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|js)$",
+    "transform": {
+      ".ts": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "./coverage",
+    "testEnvironment": "node"
+  },
+  "resolutions": {
+    "string-width": "4.2.3"
+  }
+}

package/src/api/README.md

@@ -0,0 +1,179 @@
+# Custom API Routes
+
+You may define custom API Routes by putting files in the `/api` directory that export functions returning an express router or a collection of express routers.
+Medusa supports adding custom API Routes using a file based approach. This means that you can add files in the `/api` directory and the files path will be used as the API Route path. For example, if you add a file called `/api/store/custom/route.ts` it will be available on the `/store/custom` API Route.
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/medusa";
+
+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, if you want to define a handler for the `GET`, `POST`, and `PUT` methods, you can do so by exporting functions with the names `GET`, `POST`, and `PUT`:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/medusa";
+
+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
+
+You can define parameters in the path of your route by using wrapping the parameter name in square brackets. 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,
+  ProductService,
+} from "@medusajs/medusa";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const { productId } = req.params;
+
+  const productService: ProductService = req.scope.resolve("productService");
+
+  const product = await productService.retrieve(productId);
+
+  res.json({
+    product,
+  });
+}
+```
+
+If you want to define a route that takes multiple parameters, you can do so by adding multiple parameters in the path. It is important that each parameter is given a unique name. 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`. Duplicate parameter names are not allowed, and will result in an error.
+
+## Using the container
+
+A global container is available on `req.scope` to allow you to use any of the registered services from the core, installed plugins or your local project:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+  ProductService,
+} from "@medusajs/medusa";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const productService: ProductService = req.scope.resolve("productService");
+
+  const products = await productService.list();
+
+  res.json({
+    products,
+  });
+}
+```
+
+## Middleware
+
+You can apply middleware to your routes by creating a file called `/api/middlewares.ts`. This file should 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 type {
+  MiddlewaresConfig,
+  MedusaRequest,
+  MedusaResponse,
+  MedusaNextFunction,
+} from "@medusajs/medusa";
+
+async function logger(
+  req: MedusaRequest,
+  res: MedusaResponse,
+  next: MedusaNextFunction
+) {
+  console.log("Request received");
+  next();
+}
+
+export const config: MiddlewaresConfig = {
+  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.
+
+You might only want to apply middleware to certain HTTP methods. You can do so by adding a `method` property to the route configuration object:
+
+```ts
+export const config: MiddlewaresConfig = {
+  routes: [
+    {
+      matcher: "/store/custom",
+      method: "GET",
+      middlewares: [logger],
+    },
+  ],
+};
+```
+
+The `method` property can be either a HTTP method or an array of HTTP methods. By default the middlewares will apply to all HTTP methods for the given `matcher`.
+
+### Default middleware
+
+Some middleware functions are applied per default:
+
+#### Global middleware
+
+JSON parsing is applied to all routes. This means that you can access the request body as `req.body` and it will be parsed as JSON, if the request has a `Content-Type` header of `application/json`.
+
+If you want to use a different parser for a specific route, such as `urlencoded`, you can do so by adding the following export to your `route.ts` file:
+
+```ts
+import { urlencoded } from "express";
+
+export const config: MiddlewaresConfig = {
+  routes: [
+    {
+      method: "POST",
+      matcher: "/store/custom",
+      middlewares: [urlencoded()],
+    },
+  ],
+};
+```
+
+#### Store middleware
+
+For all `/store` routes, the appropriate CORS settings are applied. The STORE_CORS value can be configured in your `medusa-config.js` file.
+
+#### Admin middleware
+
+For all `/admin` routes, the appropriate CORS settings are applied. The ADMIN_CORS value can be configured in your `medusa-config.js` file.
+
+All `/admin` routes also have admin authentication applied per default. If you want to disable this for a specific route, you can do so by adding the following export to your `route.ts` file:
+
+```ts
+export const AUTHENTICATE = false;
+```

package/src/jobs/README.md

@@ -0,0 +1,32 @@
+# Custom scheduled jobs
+
+You may define custom scheduled jobs (cron jobs) by creating files in the `/jobs` directory.
+
+```ts
+import {
+  ProductService,
+  ScheduledJobArgs,
+  ScheduledJobConfig,
+} from "@medusajs/medusa";
+
+export default async function myCustomJob({ container }: ScheduledJobArgs) {
+  const productService: ProductService = container.resolve("productService");
+
+  const products = await productService.listAndCount();
+
+  // Do something with the products
+}
+
+export const config: ScheduledJobConfig = {
+  name: "daily-product-report",
+  schedule: "0 0 * * *", // Every day at midnight
+};
+```
+
+A scheduled job is defined in two parts a `handler` and a `config`. The `handler` is a function which is invoked when the job is scheduled. The `config` is an object which defines the name of the job, the schedule, and an optional data object.
+
+The `handler` is a function which takes one parameter, an `object` of type `ScheduledJobArgs` with the following properties:
+
+- `container` - a `MedusaContainer` instance which can be used to resolve services.
+- `data` - an `object` containing data passed to the job when it was scheduled. This object is passed in the `config` object.
+- `pluginOptions` - an `object` containing plugin options, if the job is defined in a plugin.

package/src/loaders/README.md

@@ -0,0 +1,19 @@
+# Custom loader
+
+The loader allows you have access to the Medusa service container. This allows you to access the database and the services registered on the container.
+you can register custom registrations in the container or run custom code on startup.
+
+```ts
+// src/loaders/my-loader.ts
+
+import { AwilixContainer } from 'awilix'
+
+/**
+ * 
+ * @param container The container in which the registrations are made
+ * @param config The options of the plugin or the entire config object
+ */
+export default (container: AwilixContainer, config: Record<string, unknown>): void | Promise<void> => {
+  /* Implement your own loader. */
+}
+```

package/src/migrations/1717765546068-licenseVariant.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class LicenseVariant1717765546068 implements MigrationInterface {
+
+    identifier = 'LicenseVariant1717765546068'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+
+        const query = `ALTER TABLE "product_variant" ADD COLUMN IF NOT EXISTS "refresh_url" varchar(255) NULL;`
+        await queryRunner.query(query)
+
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+
+        const query = `ALTER TABLE "product_variant" DROP COLUMN IF EXISTS "refresh_url" varchar(255) NULL;`
+        await queryRunner.query(query)
+    }
+
+}

package/src/migrations/README.md

@@ -0,0 +1,29 @@
+# Custom migrations
+
+You may define custom models (entities) that will be registered on the global container by creating files in the `src/models` directory that export an instance of `BaseEntity`.
+In that case you also need to provide a migration in order to create the table in the database.
+
+## Example
+
+### 1. Create the migration
+
+See [How to Create Migrations](https://docs.medusajs.com/advanced/backend/migrations/) in the documentation.
+
+```ts
+// src/migration/my-migration.ts
+
+import { MigrationInterface, QueryRunner } from "typeorm"
+
+export class MyMigration1617703530229 implements MigrationInterface {
+  name = "myMigration1617703530229"
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // write you migration here
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // write you migration here
+  }
+}
+
+```

package/src/models/README.md

@@ -0,0 +1,46 @@
+# Custom models
+
+You may define custom models (entities) that will be registered on the global container by creating files in the `src/models` directory that export an instance of `BaseEntity`.
+
+## Example
+
+### 1. Create the Entity
+
+```ts
+// src/models/post.ts
+
+import { BeforeInsert, Column, Entity, PrimaryColumn } from "typeorm";
+import { generateEntityId } from "@medusajs/utils";
+import { BaseEntity } from "@medusajs/medusa";
+
+@Entity()
+export class Post extends BaseEntity {
+  @Column({type: 'varchar'})
+  title: string | null;
+
+  @BeforeInsert()
+  private beforeInsert(): void {
+    this.id = generateEntityId(this.id, "post")
+  }
+}
+```
+
+### 2. Create the Migration
+
+You also need to create a Migration to create the new table in the database. See [How to Create Migrations](https://docs.medusajs.com/advanced/backend/migrations/) in the documentation.
+
+### 3. Create a Repository
+Entities data can be easily accessed and modified using [TypeORM Repositories](https://typeorm.io/working-with-repository). To create a repository, create a file in `src/repositories`. For example, here’s a repository `PostRepository` for the `Post` entity:
+
+```ts
+// src/repositories/post.ts
+
+import { EntityRepository, Repository } from "typeorm"
+
+import { Post } from "../models/post"
+
+@EntityRepository(Post)
+export class PostRepository extends Repository<Post> { }
+```
+
+See more about defining and accesing your custom [Entities](https://docs.medusajs.com/advanced/backend/entities/overview) in the documentation.