@mercurjs/core 2.1.0-canary.4

package/.medusa/server/src/api/admin/subscription-plans/[id]/overrides/route.d.ts

@@ -0,0 +1,4 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { HttpTypes } from "@mercurjs/types";
+import { AdminCreateSubscriptionOverrideType } from "../../validators";
+export declare const POST: (req: AuthenticatedMedusaRequest<AdminCreateSubscriptionOverrideType>, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanResponse>) => Promise<void>;

package/.medusa/server/src/api/admin/subscription-plans/[id]/overrides/route.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const subscription_1 = require("../../../../../workflows/subscription");
+const POST = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    await (0, subscription_1.createSubscriptionOverridesWorkflow)(req.scope).run({
+        input: [
+            {
+                ...req.validatedBody,
+                plan_id: req.params.id,
+            },
+        ],
+    });
+    const { data: [subscription_plan], } = await query.graph({
+        entity: "subscription_plan",
+        fields: req.queryConfig.fields,
+        filters: { id: req.params.id },
+    });
+    res.status(201).json({ subscription_plan });
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL3N1YnNjcmlwdGlvbi1wbGFucy9baWRdL292ZXJyaWRlcy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxxREFBcUU7QUFJckUsd0VBQTJGO0FBRXBGLE1BQU0sSUFBSSxHQUFHLEtBQUssRUFDdkIsR0FBb0UsRUFDcEUsR0FBNEQsRUFDNUQsRUFBRTtJQUNGLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGlDQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRWhFLE1BQU0sSUFBQSxrREFBbUMsRUFBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQ3ZELEtBQUssRUFBRTtZQUNMO2dCQUNFLEdBQUcsR0FBRyxDQUFDLGFBQWE7Z0JBQ3BCLE9BQU8sRUFBRSxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUU7YUFDdkI7U0FDRjtLQUNGLENBQUMsQ0FBQTtJQUVGLE1BQU0sRUFDSixJQUFJLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxHQUMxQixHQUFHLE1BQU0sS0FBSyxDQUFDLEtBQUssQ0FBQztRQUNwQixNQUFNLEVBQUUsbUJBQW1CO1FBQzNCLE1BQU0sRUFBRSxHQUFHLENBQUMsV0FBVyxDQUFDLE1BQU07UUFDOUIsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFO0tBQy9CLENBQUMsQ0FBQTtJQUVGLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFBO0FBQzdDLENBQUMsQ0FBQTtBQXhCWSxRQUFBLElBQUksUUF3QmhCIn0=

package/.medusa/server/src/api/admin/subscription-plans/[id]/route.d.ts

@@ -0,0 +1,6 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { HttpTypes } from "@mercurjs/types";
+import { AdminUpdateSubscriptionPlanType } from "../validators";
+export declare const GET: (req: AuthenticatedMedusaRequest, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanResponse>) => Promise<void>;
+export declare const POST: (req: AuthenticatedMedusaRequest<AdminUpdateSubscriptionPlanType>, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanResponse>) => Promise<void>;
+export declare const DELETE: (req: AuthenticatedMedusaRequest, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanDeleteResponse>) => Promise<void>;

package/.medusa/server/src/api/admin/subscription-plans/[id]/route.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = exports.POST = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const subscription_1 = require("../../../../workflows/subscription");
+const GET = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: [subscription_plan], } = await query.graph({
+        entity: "subscription_plan",
+        fields: req.queryConfig.fields,
+        filters: { id: req.params.id },
+    });
+    if (!subscription_plan) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Subscription plan with id ${req.params.id} was not found`);
+    }
+    res.json({ subscription_plan });
+};
+exports.GET = GET;
+const POST = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { result } = await (0, subscription_1.updateSubscriptionPlansWorkflow)(req.scope).run({
+        input: [{ id: req.params.id, ...req.validatedBody }],
+    });
+    const { data: [subscription_plan], } = await query.graph({
+        entity: "subscription_plan",
+        fields: req.queryConfig.fields,
+        filters: { id: result[0].id },
+    });
+    res.json({ subscription_plan });
+};
+exports.POST = POST;
+const DELETE = async (req, res) => {
+    await (0, subscription_1.deleteSubscriptionPlansWorkflow)(req.scope).run({
+        input: { ids: [req.params.id] },
+    });
+    res.json({
+        id: req.params.id,
+        object: "subscription_plan",
+        deleted: true,
+    });
+};
+exports.DELETE = DELETE;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/subscription-plans/middlewares.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareRoute } from "@medusajs/framework/http";
+export declare const adminSubscriptionPlanRoutesMiddlewares: MiddlewareRoute[];

package/.medusa/server/src/api/admin/subscription-plans/middlewares.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminSubscriptionPlanRoutesMiddlewares = void 0;
+const framework_1 = require("@medusajs/framework");
+const query_config_1 = require("./query-config");
+const validators_1 = require("./validators");
+exports.adminSubscriptionPlanRoutesMiddlewares = [
+    // GET /admin/subscription-plans — list plans
+    {
+        method: ["GET"],
+        matcher: "/admin/subscription-plans",
+        middlewares: [
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlansParams, query_config_1.subscriptionPlanQueryConfig.list),
+        ],
+    },
+    // POST /admin/subscription-plans — create plan
+    {
+        method: ["POST"],
+        matcher: "/admin/subscription-plans",
+        middlewares: [
+            (0, framework_1.validateAndTransformBody)(validators_1.AdminCreateSubscriptionPlan),
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieve),
+        ],
+    },
+    // GET /admin/subscription-plans/:id — get plan
+    {
+        method: ["GET"],
+        matcher: "/admin/subscription-plans/:id",
+        middlewares: [
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieve),
+        ],
+    },
+    // POST /admin/subscription-plans/:id — update plan
+    {
+        method: ["POST"],
+        matcher: "/admin/subscription-plans/:id",
+        middlewares: [
+            (0, framework_1.validateAndTransformBody)(validators_1.AdminUpdateSubscriptionPlan),
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieve),
+        ],
+    },
+    // DELETE /admin/subscription-plans/:id — delete plan
+    {
+        method: ["DELETE"],
+        matcher: "/admin/subscription-plans/:id",
+        middlewares: [],
+    },
+    // POST /admin/subscription-plans/:id/overrides — create override
+    {
+        method: ["POST"],
+        matcher: "/admin/subscription-plans/:id/overrides",
+        middlewares: [
+            (0, framework_1.validateAndTransformBody)(validators_1.AdminCreateSubscriptionOverride),
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieve),
+        ],
+    },
+    // GET /admin/subscription-plans/:id/overrides/:override_id — get override
+    {
+        method: ["GET"],
+        matcher: "/admin/subscription-plans/:id/overrides/:override_id",
+        middlewares: [
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieveOverride),
+        ],
+    },
+    // POST /admin/subscription-plans/:id/overrides/:override_id — update override
+    {
+        method: ["POST"],
+        matcher: "/admin/subscription-plans/:id/overrides/:override_id",
+        middlewares: [
+            (0, framework_1.validateAndTransformBody)(validators_1.AdminUpdateSubscriptionOverride),
+            (0, framework_1.validateAndTransformQuery)(validators_1.AdminGetSubscriptionPlanParams, query_config_1.subscriptionPlanQueryConfig.retrieveOverride),
+        ],
+    },
+    // DELETE /admin/subscription-plans/:id/overrides/:override_id — delete override
+    {
+        method: ["DELETE"],
+        matcher: "/admin/subscription-plans/:id/overrides/:override_id",
+        middlewares: [],
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/subscription-plans/query-config.d.ts

@@ -0,0 +1,17 @@
+export declare const subscriptionPlanFields: string[];
+export declare const subscriptionOverrideFields: string[];
+export declare const subscriptionPlanQueryConfig: {
+    list: {
+        defaults: string[];
+        defaultLimit: number;
+        isList: boolean;
+    };
+    retrieve: {
+        defaults: string[];
+        isList: boolean;
+    };
+    retrieveOverride: {
+        defaults: string[];
+        isList: boolean;
+    };
+};

package/.medusa/server/src/api/admin/subscription-plans/query-config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptionPlanQueryConfig = exports.subscriptionOverrideFields = exports.subscriptionPlanFields = void 0;
+exports.subscriptionPlanFields = [
+    "id",
+    "currency_code",
+    "monthly_amount",
+    "free_months",
+    "requires_orders",
+    "*overrides",
+    "metadata",
+    "created_at",
+    "updated_at",
+];
+exports.subscriptionOverrideFields = [
+    "id",
+    "reference",
+    "reference_id",
+    "plan_id",
+    "monthly_amount",
+    "free_months",
+    "free_from",
+    "free_to",
+    "metadata",
+    "created_at",
+    "updated_at",
+];
+exports.subscriptionPlanQueryConfig = {
+    list: {
+        defaults: exports.subscriptionPlanFields,
+        defaultLimit: 50,
+        isList: true,
+    },
+    retrieve: {
+        defaults: exports.subscriptionPlanFields,
+        isList: false,
+    },
+    retrieveOverride: {
+        defaults: exports.subscriptionOverrideFields,
+        isList: false,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwaS9hZG1pbi9zdWJzY3JpcHRpb24tcGxhbnMvcXVlcnktY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFhLFFBQUEsc0JBQXNCLEdBQUc7SUFDcEMsSUFBSTtJQUNKLGVBQWU7SUFDZixnQkFBZ0I7SUFDaEIsYUFBYTtJQUNiLGlCQUFpQjtJQUNqQixZQUFZO0lBQ1osVUFBVTtJQUNWLFlBQVk7SUFDWixZQUFZO0NBQ2IsQ0FBQTtBQUVZLFFBQUEsMEJBQTBCLEdBQUc7SUFDeEMsSUFBSTtJQUNKLFdBQVc7SUFDWCxjQUFjO0lBQ2QsU0FBUztJQUNULGdCQUFnQjtJQUNoQixhQUFhO0lBQ2IsV0FBVztJQUNYLFNBQVM7SUFDVCxVQUFVO0lBQ1YsWUFBWTtJQUNaLFlBQVk7Q0FDYixDQUFBO0FBRVksUUFBQSwyQkFBMkIsR0FBRztJQUN6QyxJQUFJLEVBQUU7UUFDSixRQUFRLEVBQUUsOEJBQXNCO1FBQ2hDLFlBQVksRUFBRSxFQUFFO1FBQ2hCLE1BQU0sRUFBRSxJQUFJO0tBQ2I7SUFDRCxRQUFRLEVBQUU7UUFDUixRQUFRLEVBQUUsOEJBQXNCO1FBQ2hDLE1BQU0sRUFBRSxLQUFLO0tBQ2Q7SUFDRCxnQkFBZ0IsRUFBRTtRQUNoQixRQUFRLEVBQUUsa0NBQTBCO1FBQ3BDLE1BQU0sRUFBRSxLQUFLO0tBQ2Q7Q0FDRixDQUFBIn0=

package/.medusa/server/src/api/admin/subscription-plans/route.d.ts

@@ -0,0 +1,5 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { HttpTypes } from "@mercurjs/types";
+import { AdminCreateSubscriptionPlanType, AdminGetSubscriptionPlansParamsType } from "./validators";
+export declare const GET: (req: AuthenticatedMedusaRequest<AdminGetSubscriptionPlansParamsType>, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanListResponse>) => Promise<void>;
+export declare const POST: (req: AuthenticatedMedusaRequest<AdminCreateSubscriptionPlanType>, res: MedusaResponse<HttpTypes.AdminSubscriptionPlanResponse>) => Promise<void>;

package/.medusa/server/src/api/admin/subscription-plans/route.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const subscription_1 = require("../../../workflows/subscription");
+const GET = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: subscription_plans, metadata } = await query.graph({
+        entity: "subscription_plan",
+        fields: req.queryConfig.fields,
+        filters: req.filterableFields,
+        pagination: req.queryConfig.pagination,
+    });
+    res.json({
+        subscription_plans,
+        count: metadata?.count ?? 0,
+        offset: metadata?.skip ?? 0,
+        limit: metadata?.take ?? 0,
+    });
+};
+exports.GET = GET;
+const POST = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { result } = await (0, subscription_1.createSubscriptionPlansWorkflow)(req.scope).run({
+        input: [req.validatedBody],
+    });
+    const { data: [subscription_plan], } = await query.graph({
+        entity: "subscription_plan",
+        fields: req.queryConfig.fields,
+        filters: { id: result[0].id },
+    });
+    res.status(201).json({ subscription_plan });
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2FkbWluL3N1YnNjcmlwdGlvbi1wbGFucy9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxxREFBcUU7QUFJckUsa0VBQWlGO0FBRTFFLE1BQU0sR0FBRyxHQUFHLEtBQUssRUFDdEIsR0FBb0UsRUFDcEUsR0FBZ0UsRUFDaEUsRUFBRTtJQUNGLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGlDQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRWhFLE1BQU0sRUFBRSxJQUFJLEVBQUUsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLEdBQUcsTUFBTSxLQUFLLENBQUMsS0FBSyxDQUFDO1FBQy9ELE1BQU0sRUFBRSxtQkFBbUI7UUFDM0IsTUFBTSxFQUFFLEdBQUcsQ0FBQyxXQUFXLENBQUMsTUFBTTtRQUM5QixPQUFPLEVBQUUsR0FBRyxDQUFDLGdCQUFnQjtRQUM3QixVQUFVLEVBQUUsR0FBRyxDQUFDLFdBQVcsQ0FBQyxVQUFVO0tBQ3ZDLENBQUMsQ0FBQTtJQUVGLEdBQUcsQ0FBQyxJQUFJLENBQUM7UUFDUCxrQkFBa0I7UUFDbEIsS0FBSyxFQUFFLFFBQVEsRUFBRSxLQUFLLElBQUksQ0FBQztRQUMzQixNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksSUFBSSxDQUFDO1FBQzNCLEtBQUssRUFBRSxRQUFRLEVBQUUsSUFBSSxJQUFJLENBQUM7S0FDM0IsQ0FBQyxDQUFBO0FBQ0osQ0FBQyxDQUFBO0FBbkJZLFFBQUEsR0FBRyxPQW1CZjtBQUVNLE1BQU0sSUFBSSxHQUFHLEtBQUssRUFDdkIsR0FBZ0UsRUFDaEUsR0FBNEQsRUFDNUQsRUFBRTtJQUNGLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGlDQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRWhFLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLElBQUEsOENBQStCLEVBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQztRQUN0RSxLQUFLLEVBQUUsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDO0tBQzNCLENBQUMsQ0FBQTtJQUVGLE1BQU0sRUFDSixJQUFJLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxHQUMxQixHQUFHLE1BQU0sS0FBSyxDQUFDLEtBQUssQ0FBQztRQUNwQixNQUFNLEVBQUUsbUJBQW1CO1FBQzNCLE1BQU0sRUFBRSxHQUFHLENBQUMsV0FBVyxDQUFDLE1BQU07UUFDOUIsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7S0FDOUIsQ0FBQyxDQUFBO0lBRUYsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxpQkFBaUIsRUFBRSxDQUFDLENBQUE7QUFDN0MsQ0FBQyxDQUFBO0FBbkJZLFFBQUEsSUFBSSxRQW1CaEIifQ==

package/.medusa/server/src/api/admin/subscription-plans/validators.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export type AdminGetSubscriptionPlansParamsType = z.infer<typeof AdminGetSubscriptionPlansParams>;
+export declare const AdminGetSubscriptionPlansParams: z.ZodObject<{
+    fields: z.ZodOptional<z.ZodString>;
+} & {
+    offset: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodNumber>>, number, unknown>;
+    limit: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodNumber>>, number, unknown>;
+    order: z.ZodOptional<z.ZodString> | z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    with_deleted: z.ZodEffects<z.ZodOptional<z.ZodBoolean>, boolean | undefined, unknown>;
+} & {
+    currency_code: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    offset: number;
+    limit: number;
+    fields?: string | undefined;
+    order?: string | undefined;
+    with_deleted?: boolean | undefined;
+    currency_code?: string | undefined;
+}, {
+    offset?: unknown;
+    limit?: unknown;
+    fields?: string | undefined;
+    order?: string | undefined;
+    with_deleted?: unknown;
+    currency_code?: string | undefined;
+}>;
+export type AdminGetSubscriptionPlanParamsType = z.infer<typeof AdminGetSubscriptionPlanParams>;
+export declare const AdminGetSubscriptionPlanParams: z.ZodObject<{
+    fields: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    fields?: string | undefined;
+}, {
+    fields?: string | undefined;
+}>;
+export type AdminCreateSubscriptionPlanType = z.infer<typeof AdminCreateSubscriptionPlan>;
+export declare const AdminCreateSubscriptionPlan: z.ZodObject<{
+    currency_code: z.ZodString;
+    monthly_amount: z.ZodNumber;
+    free_months: z.ZodOptional<z.ZodNumber>;
+    requires_orders: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    currency_code: string;
+    monthly_amount: number;
+    metadata?: Record<string, unknown> | null | undefined;
+    free_months?: number | undefined;
+    requires_orders?: boolean | undefined;
+}, {
+    currency_code: string;
+    monthly_amount: number;
+    metadata?: Record<string, unknown> | null | undefined;
+    free_months?: number | undefined;
+    requires_orders?: boolean | undefined;
+}>;
+export type AdminUpdateSubscriptionPlanType = z.infer<typeof AdminUpdateSubscriptionPlan>;
+export declare const AdminUpdateSubscriptionPlan: z.ZodObject<{
+    monthly_amount: z.ZodOptional<z.ZodNumber>;
+    free_months: z.ZodOptional<z.ZodNumber>;
+    requires_orders: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | undefined;
+    free_months?: number | undefined;
+    requires_orders?: boolean | undefined;
+}, {
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | undefined;
+    free_months?: number | undefined;
+    requires_orders?: boolean | undefined;
+}>;
+export type AdminCreateSubscriptionOverrideType = z.infer<typeof AdminCreateSubscriptionOverride>;
+export declare const AdminCreateSubscriptionOverride: z.ZodObject<{
+    reference: z.ZodString;
+    reference_id: z.ZodString;
+    monthly_amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    free_months: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    free_from: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    free_to: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    reference: string;
+    reference_id: string;
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | null | undefined;
+    free_months?: number | null | undefined;
+    free_from?: Date | null | undefined;
+    free_to?: Date | null | undefined;
+}, {
+    reference: string;
+    reference_id: string;
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | null | undefined;
+    free_months?: number | null | undefined;
+    free_from?: Date | null | undefined;
+    free_to?: Date | null | undefined;
+}>;
+export type AdminUpdateSubscriptionOverrideType = z.infer<typeof AdminUpdateSubscriptionOverride>;
+export declare const AdminUpdateSubscriptionOverride: z.ZodObject<{
+    monthly_amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    free_months: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    free_from: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    free_to: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | null | undefined;
+    free_months?: number | null | undefined;
+    free_from?: Date | null | undefined;
+    free_to?: Date | null | undefined;
+}, {
+    metadata?: Record<string, unknown> | null | undefined;
+    monthly_amount?: number | null | undefined;
+    free_months?: number | null | undefined;
+    free_from?: Date | null | undefined;
+    free_to?: Date | null | undefined;
+}>;

package/.medusa/server/src/api/admin/subscription-plans/validators.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminUpdateSubscriptionOverride = exports.AdminCreateSubscriptionOverride = exports.AdminUpdateSubscriptionPlan = exports.AdminCreateSubscriptionPlan = exports.AdminGetSubscriptionPlanParams = exports.AdminGetSubscriptionPlansParams = void 0;
+const zod_1 = require("zod");
+const validators_1 = require("@medusajs/medusa/api/utils/validators");
+exports.AdminGetSubscriptionPlansParams = (0, validators_1.createFindParams)({
+    offset: 0,
+    limit: 50,
+}).merge(zod_1.z.object({
+    currency_code: zod_1.z.string().optional(),
+}));
+exports.AdminGetSubscriptionPlanParams = (0, validators_1.createSelectParams)();
+exports.AdminCreateSubscriptionPlan = zod_1.z.object({
+    currency_code: zod_1.z.string(),
+    monthly_amount: zod_1.z.number(),
+    free_months: zod_1.z.number().int().min(0).max(120).optional(),
+    requires_orders: zod_1.z.boolean().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).nullable().optional(),
+});
+exports.AdminUpdateSubscriptionPlan = zod_1.z.object({
+    monthly_amount: zod_1.z.number().optional(),
+    free_months: zod_1.z.number().int().min(0).max(120).optional(),
+    requires_orders: zod_1.z.boolean().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).nullable().optional(),
+});
+exports.AdminCreateSubscriptionOverride = zod_1.z.object({
+    reference: zod_1.z.string(),
+    reference_id: zod_1.z.string(),
+    monthly_amount: zod_1.z.number().nullable().optional(),
+    free_months: zod_1.z.number().int().min(0).max(120).nullable().optional(),
+    free_from: zod_1.z.coerce.date().nullable().optional(),
+    free_to: zod_1.z.coerce.date().nullable().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).nullable().optional(),
+});
+exports.AdminUpdateSubscriptionOverride = zod_1.z.object({
+    monthly_amount: zod_1.z.number().nullable().optional(),
+    free_months: zod_1.z.number().int().min(0).max(120).nullable().optional(),
+    free_from: zod_1.z.coerce.date().nullable().optional(),
+    free_to: zod_1.z.coerce.date().nullable().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).nullable().optional(),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/hooks/middlewares.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareRoute } from "@medusajs/framework/http";
+export declare const hooksRoutesMiddlewares: MiddlewareRoute[];

package/.medusa/server/src/api/hooks/middlewares.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooksRoutesMiddlewares = void 0;
+exports.hooksRoutesMiddlewares = [
+    {
+        method: ["POST"],
+        bodyParser: { preserveRawBody: true },
+        matcher: "/hooks/payout",
+    },
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2hvb2tzL21pZGRsZXdhcmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVhLFFBQUEsc0JBQXNCLEdBQXNCO0lBQ3ZEO1FBQ0UsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDO1FBQ2hCLFVBQVUsRUFBRSxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUU7UUFDckMsT0FBTyxFQUFFLGVBQWU7S0FDekI7Q0FDRixDQUFBIn0=

package/.medusa/server/src/api/hooks/payout/route.d.ts

@@ -0,0 +1,2 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+export declare const POST: (req: MedusaRequest, res: MedusaResponse) => Promise<void>;

package/.medusa/server/src/api/hooks/payout/route.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const POST = async (req, res) => {
+    try {
+        const event = {
+            data: req.body, rawData: req.rawBody, headers: req.headers
+        };
+        const eventBus = req.scope.resolve(utils_1.Modules.EVENT_BUS);
+        await eventBus.emit({
+            name: "payout.webhook_received",
+            data: event,
+        }, {
+            delay: 5000,
+            attempts: 3,
+        });
+    }
+    catch (err) {
+        res.status(400).send(`Webhook Error: ${err.message}`);
+        return;
+    }
+    res.sendStatus(200);
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBpL2hvb2tzL3BheW91dC9yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxxREFBbUQ7QUFFNUMsTUFBTSxJQUFJLEdBQUcsS0FBSyxFQUFFLEdBQWtCLEVBQUUsR0FBbUIsRUFBRSxFQUFFO0lBQ3BFLElBQUksQ0FBQztRQUNILE1BQU0sS0FBSyxHQUFHO1lBQ1osSUFBSSxFQUFFLEdBQUcsQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxPQUFPO1NBQzNELENBQUE7UUFFRCxNQUFNLFFBQVEsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxlQUFPLENBQUMsU0FBUyxDQUFDLENBQUE7UUFFckQsTUFBTSxRQUFRLENBQUMsSUFBSSxDQUNqQjtZQUNFLElBQUksRUFBRSx5QkFBeUI7WUFDL0IsSUFBSSxFQUFFLEtBQUs7U0FDWixFQUNEO1lBQ0UsS0FBSyxFQUFFLElBQUk7WUFDWCxRQUFRLEVBQUUsQ0FBQztTQUNaLENBQ0YsQ0FBQTtJQUNILENBQUM7SUFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO1FBQ2xCLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLGtCQUFrQixHQUFHLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQTtRQUNyRCxPQUFNO0lBQ1IsQ0FBQztJQUVELEdBQUcsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUE7QUFDckIsQ0FBQyxDQUFBO0FBeEJZLFFBQUEsSUFBSSxRQXdCaEIifQ==

package/.medusa/server/src/api/middlewares.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@medusajs/medusa").MiddlewaresConfig;
+export default _default;

package/.medusa/server/src/api/middlewares.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const medusa_1 = require("@medusajs/medusa");
+const middlewares_1 = require("./admin/middlewares");
+const middlewares_2 = require("./store/middlewares");
+const middlewares_3 = require("./vendor/middlewares");
+const middlewares_4 = require("./hooks/middlewares");
+const types_1 = require("@mercurjs/types");
+function dashboardMiddleware(service) {
+    return (req, res, next) => {
+        const options = service.getOptions();
+        if (options.disable) {
+            return next();
+        }
+        const app = service.getApp();
+        app(req, res, next);
+    };
+}
+exports.default = (0, medusa_1.defineMiddlewares)({
+    routes: [
+        ...middlewares_1.adminMiddlewares,
+        ...middlewares_2.storeMiddlewares,
+        ...middlewares_3.vendorMiddlewares,
+        ...middlewares_4.hooksRoutesMiddlewares,
+        {
+            matcher: "*",
+            method: ["GET"],
+            middlewares: [(req, res, next) => {
+                    const adminUI = req.scope.resolve(types_1.MercurModules.ADMIN_UI);
+                    const vendorUI = req.scope.resolve(types_1.MercurModules.VENDOR_UI);
+                    dashboardMiddleware(adminUI)(req, res, (err) => {
+                        if (err)
+                            return next(err);
+                        dashboardMiddleware(vendorUI)(req, res, next);
+                    });
+                }],
+        },
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBpL21pZGRsZXdhcmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNkNBQW9EO0FBRXBELHFEQUFzRDtBQUN0RCxxREFBc0Q7QUFDdEQsc0RBQXdEO0FBQ3hELHFEQUE0RDtBQUU1RCwyQ0FBK0M7QUFLL0MsU0FBUyxtQkFBbUIsQ0FBQyxPQUFzQjtJQUNqRCxPQUFPLENBQUMsR0FBa0IsRUFBRSxHQUFtQixFQUFFLElBQXdCLEVBQUUsRUFBRTtRQUMzRSxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUE7UUFDcEMsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDcEIsT0FBTyxJQUFJLEVBQUUsQ0FBQTtRQUNmLENBQUM7UUFDRCxNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUE7UUFDNUIsR0FBRyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLENBQUE7SUFDckIsQ0FBQyxDQUFBO0FBQ0gsQ0FBQztBQUVELGtCQUFlLElBQUEsMEJBQWlCLEVBQUM7SUFDL0IsTUFBTSxFQUFFO1FBQ04sR0FBRyw4QkFBZ0I7UUFDbkIsR0FBRyw4QkFBZ0I7UUFDbkIsR0FBRywrQkFBaUI7UUFDcEIsR0FBRyxvQ0FBc0I7UUFDekI7WUFDRSxPQUFPLEVBQUUsR0FBRztZQUNaLE1BQU0sRUFBRSxDQUFDLEtBQUssQ0FBQztZQUNmLFdBQVcsRUFBRSxDQUFDLENBQUMsR0FBa0IsRUFBRSxHQUFtQixFQUFFLElBQXdCLEVBQUUsRUFBRTtvQkFDbEYsTUFBTSxPQUFPLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQXVCLHFCQUFhLENBQUMsUUFBUSxDQUFDLENBQUE7b0JBQy9FLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUF3QixxQkFBYSxDQUFDLFNBQVMsQ0FBQyxDQUFBO29CQUVsRixtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLENBQUMsR0FBUyxFQUFFLEVBQUU7d0JBQ25ELElBQUksR0FBRzs0QkFBRSxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTt3QkFDekIsbUJBQW1CLENBQUMsUUFBUSxDQUFDLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQTtvQkFDL0MsQ0FBQyxDQUFDLENBQUE7Z0JBQ0osQ0FBQyxDQUFDO1NBQ0g7S0FDRjtDQUNGLENBQUMsQ0FBQSJ9

package/.medusa/server/src/api/store/carts/[id]/complete/query-config.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultStoreRetrieveOrderGroupFields: string[];
+export declare const storeCompleteCartQueryConfig: {
+    defaults: string[];
+    isList: boolean;
+};

package/.medusa/server/src/api/store/carts/[id]/complete/query-config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeCompleteCartQueryConfig = exports.defaultStoreRetrieveOrderGroupFields = void 0;
+exports.defaultStoreRetrieveOrderGroupFields = [
+    "id",
+    "customer_id",
+    "cart_id",
+    "seller_count",
+    "total",
+    "created_at",
+    "updated_at",
+];
+exports.storeCompleteCartQueryConfig = {
+    defaults: exports.defaultStoreRetrieveOrderGroupFields,
+    isList: false,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwaS9zdG9yZS9jYXJ0cy9baWRdL2NvbXBsZXRlL3F1ZXJ5LWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLG9DQUFvQyxHQUFHO0lBQ2hELElBQUk7SUFDSixhQUFhO0lBQ2IsU0FBUztJQUNULGNBQWM7SUFDZCxPQUFPO0lBQ1AsWUFBWTtJQUNaLFlBQVk7Q0FDZixDQUFBO0FBRVksUUFBQSw0QkFBNEIsR0FBRztJQUN4QyxRQUFRLEVBQUUsNENBQW9DO0lBQzlDLE1BQU0sRUFBRSxLQUFLO0NBQ2hCLENBQUEifQ==

package/.medusa/server/src/api/store/carts/[id]/complete/route.d.ts

@@ -0,0 +1,4 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { HttpTypes } from "@mercurjs/types";
+import { StoreCompleteCartParamsType } from "./validators";
+export declare const POST: (req: MedusaRequest<{}, StoreCompleteCartParamsType>, res: MedusaResponse<HttpTypes.StoreCompleteCartResponse>) => Promise<void>;

package/.medusa/server/src/api/store/carts/[id]/complete/route.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const cart_1 = require("../../../../../workflows/cart");
+const helpers_1 = require("../../helpers");
+const POST = async (req, res) => {
+    const cart_id = req.params.id;
+    const { errors, result } = await (0, cart_1.completeCartWithSplitOrdersWorkflow)(req.scope).run({
+        input: { cart_id },
+        throwOnError: false,
+    });
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    // When an error occurs on the workflow, it's potentially to do with cart validations, payments
+    // or inventory checks. Return the cart here along with errors for the consumer to take more action
+    // and fix them
+    if (errors?.[0]) {
+        const error = errors[0].error;
+        const statusOKErrors = [
+            utils_1.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
+            utils_1.MedusaError.Types.PAYMENT_REQUIRES_MORE_ERROR,
+        ];
+        const cart = await (0, helpers_1.refetchCart)(cart_id, req.scope, helpers_1.defaultStoreCartFields);
+        if (!statusOKErrors.includes(error?.type)) {
+            throw error;
+        }
+        res.status(200).json({
+            type: "cart",
+            cart,
+            error: {
+                message: error.message,
+                name: error.name,
+                type: error.type,
+            },
+        });
+        return;
+    }
+    // Fetch the order group with orders
+    const { data: orderGroups } = await query.graph({
+        entity: "order_group",
+        fields: req.queryConfig.fields,
+        filters: { id: result.order_group_id },
+    });
+    res.status(200).json({
+        type: "order_group",
+        order_group: orderGroups[0],
+    });
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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