@medusajs/framework 0.0.2-snapshot-20240821132459 → 0.0.2-snapshot-20240821152538

package/dist/config/__fixtures__/medusa-config-2.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@medusajs/types").ConfigModule;
+export default _default;
+//# sourceMappingURL=medusa-config-2.d.ts.map

package/dist/config/__fixtures__/medusa-config-2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"medusa-config-2.d.ts","sourceRoot":"","sources":["../../../src/config/__fixtures__/medusa-config-2.js"],"names":[],"mappings":""}

package/dist/config/__fixtures__/medusa-config-2.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+exports.default = (0, utils_1.defineConfig)({
+    projectConfig: {
+        databaseName: "foo",
+    },
+});

package/dist/config/__fixtures__/medusa-config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@medusajs/types").ConfigModule;
+export default _default;
+//# sourceMappingURL=medusa-config.d.ts.map

package/dist/config/__fixtures__/medusa-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"medusa-config.d.ts","sourceRoot":"","sources":["../../../src/config/__fixtures__/medusa-config.js"],"names":[],"mappings":""}

package/dist/config/__fixtures__/medusa-config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+exports.default = (0, utils_1.defineConfig)();

package/dist/config/__tests__/index.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.spec.d.ts.map

package/dist/config/__tests__/index.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.spec.d.ts","sourceRoot":"","sources":["../../../src/config/__tests__/index.spec.ts"],"names":[],"mappings":""}

package/dist/config/__tests__/index.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_1 = require("../loader");
+const path_1 = require("path");
+const container_1 = require("../../container");
+const utils_1 = require("@medusajs/utils");
+describe("configLoader", () => {
+    const entryDirectory = (0, path_1.join)(__dirname, "../__fixtures__");
+    it("should load the config properly", async () => {
+        let configModule = container_1.container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        expect(configModule).toBeUndefined();
+        (0, loader_1.configLoader)(entryDirectory, "medusa-config.js");
+        configModule = container_1.container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        expect(configModule).toBeDefined();
+        expect(configModule.projectConfig.databaseName).toBeUndefined();
+        (0, loader_1.configLoader)(entryDirectory, "medusa-config-2.js");
+        configModule = container_1.container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        expect(configModule).toBeDefined();
+        expect(configModule.projectConfig.databaseName).toBe("foo");
+        expect(configModule.projectConfig.workerMode).toBe("shared");
+        process.env.MEDUSA_WORKER_MODE = "worker";
+        (0, loader_1.configLoader)(entryDirectory, "medusa-config-2.js");
+        configModule = container_1.container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+        expect(configModule).toBeDefined();
+        expect(configModule.projectConfig.databaseName).toBe("foo");
+        expect(configModule.projectConfig.workerMode).toBe("worker");
+    });
+});

package/dist/config/types.d.ts

@@ -10,6 +10,17 @@ export type AdminOptions = {
     /**
      * Whether to disable the admin dashboard. If set to `true`, the admin dashboard is disabled,
      * in both development and production environments. The default value is `false`.
+     *
+     * @example
+     * ```js title="medusa-config.js"
+     * module.exports = defineConfig({
+     *   admin: {
+     *     disable: process.env.ADMIN_DISABLED === "true" ||
+     *       false
+     *   },
+     *   // ...
+     * })
+     * ```
      */
     disable?: boolean;
     /**
@@ -20,15 +31,46 @@ export type AdminOptions = {
      * - `/store`
      * - `/auth`
      * - `/`
+     *
+     * @example
+     * ```js title="medusa-config.js"
+     * module.exports = defineConfig({
+     *   admin: {
+     *     path: process.env.ADMIN_PATH || `/app`,
+     *   },
+     *   // ...
+     * })
+     * ```
      */
     path?: `/${string}`;
     /**
-     * The directory where the admin build is output. This is where the build process places the generated files.
+     * The directory where the admin build is outputted when you run the `build` command.
      * The default value is `./build`.
+     *
+     * @example
+     * ```js title="medusa-config.js"
+     * module.exports = defineConfig({
+     *   admin: {
+     *     outDir: process.env.ADMIN_BUILD_DIR || `./build`,
+     *   },
+     *   // ...
+     * })
+     * ```
      */
     outDir?: string;
     /**
-     * The URL of your Medusa backend. Defaults to an empty string, which means requests will hit the same server that serves the dashboard.
+     * The URL of your Medusa application. This is useful to set when you deploy the Medusa application.
+     *
+     * @example
+     * ```js title="medusa-config.js"
+     * module.exports = defineConfig({
+     *   admin: {
+     *     backendUrl: process.env.MEDUSA_BACKEND_URL ||
+     *       "http://localhost:9000"
+     *   },
+     *   // ...
+     * })
+     * ```
      */
     backendUrl?: string;
     /**
@@ -105,11 +147,11 @@ export type HttpCompressionOptions = {
 /**
  * @interface
  *
- * Essential configurations related to the Medusa backend, such as database and CORS configurations.
+ * Essential configurations related to the Medusa application, such as database and CORS configurations.
  */
 export type ProjectConfigOptions = {
     /**
-     * The name of the database to connect to. If specified in `databaseUrl`, then it’s not required to include it.
+     * The name of the database to connect to. If the name is specified in `databaseUrl`, then you don't have to use this configuration.
      *
      * Make sure to create the PostgreSQL database before using it. You can check how to create a database in
      * [PostgreSQL's documentation](https://www.postgresql.org/docs/current/sql-createdatabase.html).
@@ -128,7 +170,7 @@ export type ProjectConfigOptions = {
      */
     databaseName?: string;
     /**
-     * The connection URL of the database. The format of the connection URL for PostgreSQL is:
+     * The PostgreSQL connection URL of the database, which is of the following format:
      *
      * ```bash
      * postgres://[user][:password]@[host][:port]/[dbname]
@@ -180,19 +222,13 @@ export type ProjectConfigOptions = {
      */
     databaseSchema?: string;
     /**
-     * This configuration specifies what database messages to log. Its value can be one of the following:
-     *
-     * - (default) A boolean value that indicates whether any messages should be logged.
-     * - The string value `all` that indicates all types of messages should be logged.
-     * - An array of log-level strings to indicate which type of messages to show in the logs. The strings can be `query`, `schema`, `error`, `warn`, `info`, `log`, or `migration`. Refer to [Typeorm’s documentation](https://typeorm.io/logging#logging-options) for more details on what each of these values means.
-     *
-     * If this configuration isn't set, its default value is `false`, meaning no database messages are logged.
+     * This configuration specifies whether database messages should be logged.
      *
      * @example
      * ```js title="medusa-config.js"
      * module.exports = defineConfig({
      *   projectConfig: {
-     *     databaseLogging: boolean
+     *     databaseLogging: false
      *     // ...
      *   },
      *   // ...
@@ -209,12 +245,18 @@ export type ProjectConfigOptions = {
      */
     databaseType?: string;
     /**
-     * An object that includes additional configurations to pass to the database connection for v2. You can pass any configuration. One defined configuration to pass is
-     * `ssl` which enables support for TLS/SSL connections.
+     * This configuration is used to pass additional options to the database connection. You can pass any configuration. For example, pass the
+     * `ssl` property that enables support for TLS/SSL connections.
      *
      * This is useful for production databases, which can be supported by setting the `rejectUnauthorized` attribute of `ssl` object to `false`.
      * During development, it’s recommended not to pass this option.
      *
+     * :::note
+     *
+     * Make sure to add to the end of the database URL `?ssl_mode=disable` as well when disabling `rejectUnauthorized`.
+     *
+     * :::
+     *
      * @example
      * ```js title="medusa-config.js"
      * module.exports = defineConfig({
@@ -241,7 +283,7 @@ export type ProjectConfigOptions = {
         };
     };
     /**
-     * Used to specify the URL to connect to Redis. This is only used for scheduled jobs. If you omit this configuration, scheduled jobs won't work.
+     * This configuration specifies the connection URL to Redis to store the Medusa server's session.
      *
      * :::note
      *
@@ -271,7 +313,7 @@ export type ProjectConfigOptions = {
      */
     redisUrl?: string;
     /**
-     * The prefix set on all keys stored in Redis. The default value is `sess:`.
+     * This configuration defines a prefix on all keys stored in Redis for the Medusa server's session. The default value is `sess:`.
      *
      * If this configuration option is provided, it is prepended to `sess:`.
      *
@@ -288,7 +330,7 @@ export type ProjectConfigOptions = {
      */
     redisPrefix?: string;
     /**
-     * An object of options to pass ioredis. You can refer to [ioredis’s RedisOptions documentation](https://redis.github.io/ioredis/index.html#RedisOptions)
+     * This configuration defines options to pass ioredis for the Redis connection used to store the Medusa server's session. Refer to [ioredis’s RedisOptions documentation](https://redis.github.io/ioredis/index.html#RedisOptions)
      * for the list of available options.
      *
      * @example
@@ -307,7 +349,7 @@ export type ProjectConfigOptions = {
      */
     redisOptions?: RedisOptions;
     /**
-     * An object of options to pass to [express-session](https://www.npmjs.com/package/express-session).
+     * This configuration defines additional options to pass to [express-session](https://www.npmjs.com/package/express-session), which is used to store the Medusa server's session.
      *
      * @example
      * ```js title="medusa-config.js"
@@ -324,7 +366,7 @@ export type ProjectConfigOptions = {
      */
     sessionOptions?: SessionOptions;
     /**
-     * Configure HTTP compression from the application layer. If you have access to the HTTP server, the recommended approach would be to enable it there.
+     * This property configures the HTTP compression from the application layer. If you have access to the HTTP server, the recommended approach would be to enable it there.
      * However, some platforms don't offer access to the HTTP layer and in those cases, this is a good alternative.
      *
      * If you enable HTTP compression and you want to disable it for specific API Routes, you can pass in the request header `"x-no-compression": true`.
@@ -348,22 +390,38 @@ export type ProjectConfigOptions = {
      *   // ...
      * })
      * ```
+     *
+     * @ignore
+     *
+     * @privateRemarks
+     * Couldn't find any use for this option.
      */
     jobsBatchSize?: number;
     /**
-     * Configure the application's worker mode. Default is `shared`.
+     * Configure the application's worker mode.
+     *
+     * Workers are processes running separately from the main application. They're useful for executing long-running or resource-heavy tasks in the background, such as importing products.
+     *
+     * With a worker, these tasks are offloaded to a separate process. So, they won't affect the performance of the main application.
+     *
+     * ![Diagram showcasing how the server and worker work together](https://res.cloudinary.com/dza7lstvk/image/upload/fl_lossy/f_auto/r_16/ar_16:9,c_pad/v1/Medusa%20Book/medusa-worker_klkbch.jpg?_a=BATFJtAA0)
+     *
+     * Medusa has three runtime modes:
      *
      * - Use `shared` to run the application in a single process.
      * - Use `worker` to run the a worker process only.
      * - Use `server` to run the application server only.
      *
-     * Learn more in [this guide](https://docs.medusajs.com/development/medusa-worker).
+     * In production, it's recommended to deploy two instances:
+     *
+     * 1. One having the `workerMode` configuration set to `server`.
+     * 2. Another having the `workerMode` configuration set to `worker`.
      *
      * @example
      * ```js title="medusa-config.js"
      * module.exports = defineConfig({
      *   projectConfig: {
-     *     workerMode: "shared"
+     *     workerMode: process.env.WORKER_MODE || "shared"
      *     // ...
      *   },
      *   // ...
@@ -372,7 +430,7 @@ export type ProjectConfigOptions = {
      */
     workerMode?: "shared" | "worker" | "server";
     /**
-     * Configure the application's http-specific settings
+     * This property configures the application's http-specific settings.
      *
      * @example
      * ```js title="medusa-config.js"
@@ -394,8 +452,8 @@ export type ProjectConfigOptions = {
         /**
          * A random string used to create authentication tokens in the http layer. Although this configuration option is not required, it’s highly recommended to set it for better security.
          *
-         * In a development environment, if this option is not set the default secret is `supersecret` However, in production, if this configuration is not set an error, an
-         * error is thrown and the backend crashes.
+         * In a development environment, if this option is not set the default secret is `supersecret`. However, in production, if this configuration is not set, an
+         * error is thrown and the application crashes.
          *
          * @example
          * ```js title="medusa-config.js"
@@ -412,7 +470,9 @@ export type ProjectConfigOptions = {
          */
         jwtSecret?: string;
         /**
-         * The expiration time for the JWT token. If not provided, the default value is `24h`.
+         * The expiration time for the JWT token. Its format is based off the [ms package](https://github.com/vercel/ms).
+         *
+         * If not provided, the default value is `24h`.
          *
          * @example
          * ```js title="medusa-config.js"
@@ -431,8 +491,8 @@ export type ProjectConfigOptions = {
         /**
          * A random string used to create cookie tokens in the http layer. Although this configuration option is not required, it’s highly recommended to set it for better security.
          *
-         * In a development environment, if this option is not set, the default secret is `supersecret` However, in production, if this configuration is not set, an error is thrown and
-         * the backend crashes.
+         * In a development environment, if this option is not set, the default secret is `supersecret`. However, in production, if this configuration is not set, an error is thrown and
+         * the application crashes.
          *
          * @example
          * ```js title="medusa-config.js"
@@ -449,14 +509,14 @@ export type ProjectConfigOptions = {
          */
         cookieSecret?: string;
         /**
-         * The Medusa backend’s API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
+         * The Medusa application's API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
          *
          * `cors` is a string used to specify the accepted URLs or patterns for API Routes starting with `/auth`. It can either be one accepted origin, or a comma-separated list of accepted origins.
          *
          * Every origin in that list must either be:
          *
          * 1. A URL. For example, `http://localhost:7001`. The URL must not end with a backslash;
-         * 2. Or a regular expression pattern that can match more than one origin. For example, `.example.com`. The regex pattern that the backend tests for is `^([\/~@;%#'])(.*?)\1([gimsuy]*)$`.
+         * 2. Or a regular expression pattern that can match more than one origin. For example, `.example.com`. The regex pattern that Medusa tests for is `^([\/~@;%#'])(.*?)\1([gimsuy]*)$`.
          *
          * @example
          * Some example values of common use cases:
@@ -506,9 +566,8 @@ export type ProjectConfigOptions = {
          * Configure HTTP compression from the application layer. If you have access to the HTTP server, the recommended approach would be to enable it there.
          * However, some platforms don't offer access to the HTTP layer and in those cases, this is a good alternative.
          *
-         * Its value is an object that has the following properties:
-         *
          * If you enable HTTP compression and you want to disable it for specific API Routes, you can pass in the request header `"x-no-compression": true`.
+         * Learn more in the [API Reference](https://docs.medusajs.com/v2/api/store#http-compression).
          *
          * @example
          * ```js title="medusa-config.js"
@@ -530,7 +589,7 @@ export type ProjectConfigOptions = {
          */
         compression?: HttpCompressionOptions;
         /**
-         * The Medusa backend’s API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
+         * The Medusa application's API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
          *
          * `store_cors` is a string used to specify the accepted URLs or patterns for store API Routes. It can either be one accepted origin, or a comma-separated list of accepted origins.
          *
@@ -583,7 +642,7 @@ export type ProjectConfigOptions = {
          */
         storeCors: string;
         /**
-         * The Medusa backend’s API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
+         * The Medusa application's API Routes are protected by Cross-Origin Resource Sharing (CORS). So, only allowed URLs or URLs matching a specified pattern can send requests to the backend’s API Routes.
          *
          * `admin_cors` is a string used to specify the accepted URLs or patterns for admin API Routes. It can either be one accepted origin, or a comma-separated list of accepted origins.
          *
@@ -636,11 +695,10 @@ export type ProjectConfigOptions = {
          */
         adminCors: string;
         /**
-         * Optionally you can specify the supported authentication providers per actor type (such as user, customer, or any custom actors).
-         * For example, you only want to allow SSO logins for `users` to the admin, while you want to allow email/password logins for `customers` to the storefront.
-         *
-         * `authMethodsPerActor` is a a map where the actor type (eg. 'user') is the key, and an array of supported auth providers as the value.
+         * This configuration specifies the supported authentication providers per actor type (such as `user`, `customer`, or any custom actors).
+         * For example, you only want to allow SSO logins for `users`, while you want to allow email/password logins for `customers` to the storefront.
          *
+         * `authMethodsPerActor` is a a map where the actor type (eg. 'user') is the key, and the value is an array of supported auth provider IDs.
          *
          * @example
          * Some example values of common use cases:
@@ -653,7 +711,7 @@ export type ProjectConfigOptions = {
          *     http: {
          *       authMethodsPerActor: {
          *         user: ["email"],
-         *         customer: ["emailpas", "google"]
+         *         customer: ["emailpass", "google"]
          *       }
          *     }
          *     // ...
@@ -668,14 +726,15 @@ export type ProjectConfigOptions = {
 /**
  * @interface
  *
- * The configurations for your Medusa backend are in `medusa-config.js` located in the root of your Medusa project. The configurations include database, modules, and plugin configurations, among other configurations.
+ * The configurations for your Medusa application are in `medusa-config.js` located in the root of your Medusa project. The configurations include configurations for database, modules, and more.
  *
- * `medusa-config.js` exports an object having the following properties:
+ * `medusa-config.js` exports the value returned by the `defineConfig` utility function imported from `@medusajs/utils`.
  *
- * - {@link ConfigModule.projectConfig | projectConfig} (required): An object that holds general configurations related to the Medusa backend, such as database or CORS configurations.
+ * `defineConfig` accepts as a parameter an object with the following properties:
+ *
+ * - {@link ConfigModule.projectConfig | projectConfig} (required): An object that holds general configurations related to the Medusa application, such as database or CORS configurations.
  * - {@link ConfigModule.admin | admin}: An object that holds admin-related configurations.
- * - {@link ConfigModule.plugins | plugins}: An array of plugin configurations that defines what plugins are installed and optionally specifies each of their configurations.
- * - {@link ConfigModule.modules | modules}: An object that defines what modules are installed and optionally specifies each of their configurations.
+ * - {@link ConfigModule.modules | modules}: An object that configures the Medusa application's modules.
  * - {@link ConfigModule.featureFlags | featureFlags}: An object that enables or disables features guarded by a feature flag.
  *
  * For example:
@@ -703,18 +762,18 @@ export type ProjectConfigOptions = {
  *
  * It's highly recommended to store the values of configurations in environment variables, then reference them within `medusa-config.js`.
  *
- * During development, you can set your environment variables in the `.env` file at the root of your Medusa backend project. In production,
+ * During development, you can set your environment variables in the `.env` file at the root of your Medusa application project. In production,
  * setting the environment variables depends on the hosting provider.
  *
  * ---
  */
 export type ConfigModule = {
     /**
-     * This property holds essential configurations related to the Medusa backend, such as database and CORS configurations.
+     * This property holds essential configurations related to the Medusa application, such as database and CORS configurations.
      */
     projectConfig: ProjectConfigOptions;
     /**
-     * Admin dashboard configurations.
+     * This property holds configurations for the Medusa Admin dashboard.
      *
      * @example
      * ```js title="medusa-config.js"
@@ -769,18 +828,21 @@ export type ConfigModule = {
         options: Record<string, unknown>;
     } | string)[];
     /**
-     * In Medusa, commerce and core logic are modularized to allow developers to extend or replace certain [modules](https://docs.medusajs.com/development/modules/overview)
-     * with custom implementations.
+     * This property holds all custom modules installed in your Medusa application.
      *
-     * Aside from installing the module with NPM, you must add it to the exported object in `medusa-config.js`.
+     * :::note
+     *
+     * Medusa's commerce modules are configured by default, so only
+     * add them to this property if you're changing their configurations or adding providers to a module.
+     *
+     * :::
      *
      * The keys of the `modules` configuration object refer to the module's registration name. Its value can be one of the following:
      *
      * 1. A boolean value indicating whether the module type is enabled. This is only supported for Medusa's commerce and architectural modules;
      * 2. Or an object having the following properties:
-     *     1. `resolve`: a string indicating the path to the module relative to `src`, or the module's NPM package name.
+     *     1. `resolve`: a string indicating the path to the module relative to `src`, or the module's NPM package name. For example, `./modules/my-module`.
      *     2. `options`: (optional) an object indicating the options to pass to the module.
-     *     3. `definition`: (optional) an object of extra configurations, such as `isQueryable` used when a module has relationships.
      *
      * @example
      * ```js title="medusa-config.js"
@@ -796,12 +858,12 @@ export type ConfigModule = {
      */
     modules?: Record<string, boolean | Partial<InternalModuleDeclaration | ExternalModuleDeclaration>>;
     /**
-     * Some features in the Medusa backend are guarded by a feature flag. This ensures constant shipping of new features while maintaining the engine’s stability.
+     * Some features in the Medusa application are guarded by a feature flag. This ensures constant shipping of new features while maintaining the engine’s stability.
      *
-     * You can specify whether a feature should or shouldn’t be used in your backend by enabling its feature flag. Feature flags can be enabled through either environment
-     * variables or through this configuration exported in `medusa-config.js`.
+     * You can enable a feature in your application by enabling its feature flag. Feature flags are enabled through either environment
+     * variables or through this configuration property exported in `medusa-config.js`.
      *
-     * The `featureFlags` configuration is an object. Its properties are the names of the feature flags. Each property’s value is a boolean indicating whether the feature flag is enabled.
+     * The `featureFlags`'s value is an object. Its properties are the names of the feature flags, and their value is a boolean indicating whether the feature flag is enabled.
      *
      * You can find available feature flags and their key name [here](https://github.com/medusajs/medusa/tree/develop/packages/medusa/src/loaders/feature-flags).
      *
@@ -809,7 +871,7 @@ export type ConfigModule = {
      * ```js title="medusa-config.js"
      * module.exports = defineConfig({
      *   featureFlags: {
-     *     product_categories: true,
+     *     analytics: true,
      *     // ...
      *   }
      *   // ...

package/dist/config/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAExC;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,IAAI,MAAM,EAAE,CAAA;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,YAAY,CAAA;CAC9C,CAAA;AAED;;;;GAIG;AACH,KAAK,cAAc,GAAG;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IAEzB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAChD,UAAU,CAAC,EAAE;YACX;;eAEG;YACH,GAAG,CAAC,EAAE;gBACJ;;mBAEG;gBACH,kBAAkB,CAAC,EAAE,KAAK,CAAA;aAC3B,CAAA;SACF,CAAA;KACF,CAAA;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,YAAY,CAAA;IAE3B;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,EAAE,cAAc,CAAA;IAE/B;;;;;;;;;;OAUG;IACH,eAAe,CAAC,EAAE,sBAAsB,CAAA;IAExC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAA;IAE3C;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,EAAE;QACJ;;;;;;;;;;;;;;;;;;WAkBG;QACH,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB;;;;;;;;;;;;;;;WAeG;QACH,YAAY,CAAC,EAAE,MAAM,CAAA;QACrB;;;;;;;;;;;;;;;;;;WAkBG;QACH,YAAY,CAAC,EAAE,MAAM,CAAA;QACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmDG;QACH,QAAQ,EAAE,MAAM,CAAA;QAChB;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,WAAW,CAAC,EAAE,sBAAsB,CAAA;QACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmDG;QACH,SAAS,EAAE,MAAM,CAAA;QAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmDG;QACH,SAAS,EAAE,MAAM,CAAA;QAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;KAC/C,CAAA;CACF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;OAEG;IACH,aAAa,EAAE,oBAAoB,CAAA;IAEnC;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,OAAO,EAAE,CACL;QACE,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACjC,GACD,MAAM,CACT,EAAE,CAAA;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,EAAE,MAAM,CACd,MAAM,EACN,OAAO,GAAG,OAAO,CAAC,yBAAyB,GAAG,yBAAyB,CAAC,CACzE,CAAA;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACzE,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"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"}

package/dist/feature-flags/__tests__/feature-flags.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=feature-flags.spec.d.ts.map

package/dist/feature-flags/__tests__/feature-flags.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.spec.d.ts","sourceRoot":"","sources":["../../../src/feature-flags/__tests__/feature-flags.spec.ts"],"names":[],"mappings":""}

package/dist/feature-flags/__tests__/feature-flags.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const path_1 = require("path");
+const feature_flag_loader_1 = require("../feature-flag-loader");
+const config_1 = require("../../config");
+const filesystem = new utils_1.FileSystem((0, path_1.join)(__dirname, "__ff-test__"));
+const buildFeatureFlag = (key, defaultVal) => {
+    const snakeCaseKey = key.replace(/-/g, "_");
+    return `
+    export default {
+      description: "${key} descr",
+      key: "${snakeCaseKey}",
+      env_key: "MEDUSA_FF_${snakeCaseKey.toUpperCase()}",
+      default_val: ${defaultVal},
+    }
+  `;
+};
+describe("feature flags", () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(async () => {
+        jest.resetModules();
+        jest.clearAllMocks();
+        process.env = { ...OLD_ENV };
+        await filesystem.cleanup();
+        config_1.configManager.loadConfig({
+            projectConfig: {},
+            baseDir: filesystem.basePath,
+        });
+    });
+    afterAll(async () => {
+        process.env = OLD_ENV;
+        await filesystem.cleanup();
+    });
+    it("should load the flag from project", async () => {
+        config_1.configManager.loadConfig({
+            projectConfig: { featureFlags: { flag_1: false } },
+            baseDir: filesystem.basePath,
+        });
+        await filesystem.create("flags/flag-1.js", buildFeatureFlag("flag-1", true));
+        const flags = await (0, feature_flag_loader_1.featureFlagsLoader)((0, path_1.join)(filesystem.basePath, "flags"));
+        expect(flags.isFeatureEnabled("flag_1")).toEqual(false);
+    });
+    it("should load a nested + simple flag from project", async () => {
+        config_1.configManager.loadConfig({
+            projectConfig: {
+                featureFlags: { test: { nested: true }, simpletest: true },
+            },
+            baseDir: filesystem.basePath,
+        });
+        await filesystem.create("flags/test.js", buildFeatureFlag("test", false));
+        await filesystem.create("flags/simpletest.js", buildFeatureFlag("simpletest", false));
+        const flags = await (0, feature_flag_loader_1.featureFlagsLoader)((0, path_1.join)(filesystem.basePath, "flags"));
+        expect(flags.isFeatureEnabled({ test: "nested" })).toEqual(true);
+        expect(flags.isFeatureEnabled("simpletest")).toEqual(true);
+    });
+    it("should load the default feature flags", async () => {
+        await filesystem.create("flags/flag-1.js", buildFeatureFlag("flag-1", false));
+        const flags = await (0, feature_flag_loader_1.featureFlagsLoader)((0, path_1.join)(filesystem.basePath, "flags"));
+        expect(flags.isFeatureEnabled("flag_1")).toEqual(false);
+    });
+    it("should load the flag from env", async () => {
+        process.env.MEDUSA_FF_FLAG_1 = "false";
+        await filesystem.create("flags/flag-1.js", buildFeatureFlag("flag-1", false));
+        const flags = await (0, feature_flag_loader_1.featureFlagsLoader)((0, path_1.join)(filesystem.basePath, "flags"));
+        expect(flags.isFeatureEnabled("flag_1")).toEqual(false);
+    });
+    it("should load mix of flags", async () => {
+        config_1.configManager.loadConfig({
+            projectConfig: { featureFlags: { flag_2: false } },
+            baseDir: filesystem.basePath,
+        });
+        process.env.MEDUSA_FF_FLAG_3 = "true";
+        await filesystem.create("flags/flag-1.js", buildFeatureFlag("flag-1", false));
+        await filesystem.create("flags/flag-2.js", buildFeatureFlag("flag-2", false));
+        await filesystem.create("flags/flag-3.js", buildFeatureFlag("flag-3", false));
+        const flags = await (0, feature_flag_loader_1.featureFlagsLoader)((0, path_1.join)(filesystem.basePath, "flags"));
+        expect(flags.isFeatureEnabled("flag_1")).toEqual(false);
+        expect(flags.isFeatureEnabled("flag_2")).toEqual(false);
+        expect(flags.isFeatureEnabled("flag_3")).toEqual(true);
+    });
+});

package/dist/http/__fixtures__/mocks/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { ConfigModule } from "@medusajs/types";
+export declare const customersGlobalMiddlewareMock: jest.Mock<any, any, any>;
+export declare const customersCreateMiddlewareMock: jest.Mock<any, any, any>;
+export declare const storeGlobalMiddlewareMock: jest.Mock<any, any, any>;
+export declare const config: ConfigModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/http/__fixtures__/mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http/__fixtures__/mocks/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,eAAO,MAAM,6BAA6B,0BAAY,CAAA;AACtD,eAAO,MAAM,6BAA6B,0BAAY,CAAA;AACtD,eAAO,MAAM,yBAAyB,0BAAY,CAAA;AAElD,eAAO,MAAM,MAAM,EAAE,YAapB,CAAA"}

package/dist/http/__fixtures__/mocks/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.storeGlobalMiddlewareMock = exports.customersCreateMiddlewareMock = exports.customersGlobalMiddlewareMock = void 0;
+exports.customersGlobalMiddlewareMock = jest.fn();
+exports.customersCreateMiddlewareMock = jest.fn();
+exports.storeGlobalMiddlewareMock = jest.fn();
+exports.config = {
+    projectConfig: {
+        databaseLogging: false,
+        http: {
+            authCors: "http://localhost:9000",
+            storeCors: "http://localhost:8000",
+            adminCors: "http://localhost:7001",
+            jwtSecret: "supersecret",
+            cookieSecret: "superSecret",
+        },
+    },
+    featureFlags: {},
+    plugins: [],
+};

package/dist/http/__fixtures__/routers/_private/route.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response } from "express";
+export declare const GET: (req: Request, res: Response) => Promise<void>;
+//# sourceMappingURL=route.d.ts.map