@86d-store/memberships 0.1.0

package/dist/admin/endpoints/create-plan.js

@@ -0,0 +1,48 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { sanitizeText } from "@86d-store/core/sanitize";
+import { z } from "zod";
+export const createPlan = createAdminEndpoint("/admin/memberships/plans/create", {
+    method: "POST",
+    body: z.object({
+        name: z.string().min(1).max(200).transform(sanitizeText),
+        slug: z.string().min(1).max(200),
+        description: z.string().max(5000).transform(sanitizeText).optional(),
+        price: z.number().min(0),
+        billingInterval: z.enum(["monthly", "yearly", "lifetime"]),
+        trialDays: z.number().int().min(0).max(365).optional(),
+        features: z.array(z.string().max(500)).max(50).optional(),
+        isActive: z.boolean().optional(),
+        maxMembers: z.number().int().min(1).optional(),
+        sortOrder: z.number().int().min(0).max(10000).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const existing = await controller.getPlanBySlug(ctx.body.slug);
+    if (existing) {
+        return {
+            error: "A plan with this slug already exists",
+            status: 400,
+        };
+    }
+    const params = {
+        name: ctx.body.name,
+        slug: ctx.body.slug,
+        price: ctx.body.price,
+        billingInterval: ctx.body.billingInterval,
+    };
+    if (ctx.body.description != null)
+        params.description = ctx.body.description;
+    if (ctx.body.trialDays != null)
+        params.trialDays = ctx.body.trialDays;
+    if (ctx.body.features != null)
+        params.features = ctx.body.features;
+    if (ctx.body.isActive != null)
+        params.isActive = ctx.body.isActive;
+    if (ctx.body.maxMembers != null)
+        params.maxMembers = ctx.body.maxMembers;
+    if (ctx.body.sortOrder != null)
+        params.sortOrder = ctx.body.sortOrder;
+    const plan = await controller.createPlan(params);
+    return { plan };
+});

package/dist/admin/endpoints/delete-plan.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const deletePlan: import("better-call").StrictEndpoint<"/admin/memberships/plans/:id/delete", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    success?: never;
+} | {
+    success: boolean;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=delete-plan.d.ts.map

package/dist/admin/endpoints/delete-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-plan.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/delete-plan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;EAiBtB,CAAC"}

package/dist/admin/endpoints/delete-plan.js

@@ -0,0 +1,14 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const deletePlan = createAdminEndpoint("/admin/memberships/plans/:id/delete", {
+    method: "POST",
+    params: z.object({ id: z.string().min(1) }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const deleted = await controller.deletePlan(ctx.params.id);
+    if (!deleted) {
+        return { error: "Plan not found", status: 404 };
+    }
+    return { success: true };
+});

package/dist/admin/endpoints/gate-product.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const gateProduct: import("better-call").StrictEndpoint<"/admin/memberships/plans/:planId/products/gate", {
+    method: "POST";
+    params: z.ZodObject<{
+        planId: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        productIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    gated?: never;
+} | {
+    gated: number;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=gate-product.d.ts.map

package/dist/admin/endpoints/gate-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-product.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/gate-product.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;EA6BvB,CAAC"}

package/dist/admin/endpoints/gate-product.js

@@ -0,0 +1,25 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const gateProduct = createAdminEndpoint("/admin/memberships/plans/:planId/products/gate", {
+    method: "POST",
+    params: z.object({ planId: z.string().min(1) }),
+    body: z.object({
+        productIds: z.array(z.string().min(1)).min(1).max(100),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const plan = await controller.getPlan(ctx.params.planId);
+    if (!plan) {
+        return { error: "Plan not found", status: 404 };
+    }
+    let gated = 0;
+    for (const productId of ctx.body.productIds) {
+        await controller.gateProduct({
+            planId: ctx.params.planId,
+            productId,
+        });
+        gated++;
+    }
+    return { gated };
+});

package/dist/admin/endpoints/get-membership.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const getMembership: import("better-call").StrictEndpoint<"/admin/memberships/:id", {
+    method: "GET";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    membership?: never;
+    plan?: never;
+} | {
+    membership: import("../..").Membership;
+    plan: import("../..").MembershipPlan | null;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=get-membership.d.ts.map

package/dist/admin/endpoints/get-membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-membership.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/get-membership.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAmBzB,CAAC"}

package/dist/admin/endpoints/get-membership.js

@@ -0,0 +1,15 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const getMembership = createAdminEndpoint("/admin/memberships/:id", {
+    method: "GET",
+    params: z.object({ id: z.string().min(1) }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const membership = await controller.getMembership(ctx.params.id);
+    if (!membership) {
+        return { error: "Membership not found", status: 404 };
+    }
+    const plan = await controller.getPlan(membership.planId);
+    return { membership, plan };
+});

package/dist/admin/endpoints/get-stats.d.ts

@@ -0,0 +1,6 @@
+export declare const getStats: import("better-call").StrictEndpoint<"/admin/memberships/stats", {
+    method: "GET";
+}, {
+    stats: import("../..").MembershipStats;
+}>;
+//# sourceMappingURL=get-stats.d.ts.map

package/dist/admin/endpoints/get-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-stats.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/get-stats.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;EAWpB,CAAC"}

package/dist/admin/endpoints/get-stats.js

@@ -0,0 +1,7 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+export const getStats = createAdminEndpoint("/admin/memberships/stats", { method: "GET" }, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const stats = await controller.getStats();
+    return { stats };
+});

package/dist/admin/endpoints/list-memberships.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const listMemberships: import("better-call").StrictEndpoint<"/admin/memberships", {
+    method: "GET";
+    query: z.ZodObject<{
+        planId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            trial: "trial";
+            expired: "expired";
+            cancelled: "cancelled";
+            paused: "paused";
+        }>>;
+        take: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        skip: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+}, {
+    memberships: import("../..").Membership[];
+    total: number;
+}>;
+//# sourceMappingURL=list-memberships.d.ts.map

package/dist/admin/endpoints/list-memberships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-memberships.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-memberships.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;EAiC3B,CAAC"}

package/dist/admin/endpoints/list-memberships.js

@@ -0,0 +1,32 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const listMemberships = createAdminEndpoint("/admin/memberships", {
+    method: "GET",
+    query: z.object({
+        planId: z.string().optional(),
+        status: z
+            .enum(["active", "trial", "expired", "cancelled", "paused"])
+            .optional(),
+        take: z.coerce.number().int().min(1).max(100).optional(),
+        skip: z.coerce.number().int().min(0).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const params = {
+        take: ctx.query.take ?? 50,
+        skip: ctx.query.skip ?? 0,
+    };
+    if (ctx.query.planId != null)
+        params.planId = ctx.query.planId;
+    if (ctx.query.status != null)
+        params.status = ctx.query.status;
+    const memberships = await controller.listMemberships(params);
+    const countParams = {};
+    if (ctx.query.planId != null)
+        countParams.planId = ctx.query.planId;
+    if (ctx.query.status != null)
+        countParams.status = ctx.query.status;
+    const total = await controller.countMemberships(countParams);
+    return { memberships, total };
+});

package/dist/admin/endpoints/list-plans.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const listPlans: import("better-call").StrictEndpoint<"/admin/memberships/plans", {
+    method: "GET";
+    query: z.ZodObject<{
+        active: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+        take: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        skip: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+}, {
+    plans: import("../..").MembershipPlan[];
+    total: number;
+}>;
+//# sourceMappingURL=list-plans.d.ts.map

package/dist/admin/endpoints/list-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-plans.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-plans.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;EA8BrB,CAAC"}

package/dist/admin/endpoints/list-plans.js

@@ -0,0 +1,29 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const listPlans = createAdminEndpoint("/admin/memberships/plans", {
+    method: "GET",
+    query: z.object({
+        active: z.enum(["true", "false"]).optional(),
+        take: z.coerce.number().int().min(1).max(100).optional(),
+        skip: z.coerce.number().int().min(0).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const params = {
+        take: ctx.query.take ?? 50,
+        skip: ctx.query.skip ?? 0,
+    };
+    if (ctx.query.active === "true")
+        params.isActive = true;
+    else if (ctx.query.active === "false")
+        params.isActive = false;
+    const plans = await controller.listPlans(params);
+    const countParams = {};
+    if (ctx.query.active === "true")
+        countParams.isActive = true;
+    else if (ctx.query.active === "false")
+        countParams.isActive = false;
+    const total = await controller.countPlans(countParams);
+    return { plans, total };
+});

package/dist/admin/endpoints/pause-membership.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const pauseMembership: import("better-call").StrictEndpoint<"/admin/memberships/:id/pause", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    membership?: never;
+} | {
+    membership: import("../..").Membership;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=pause-membership.d.ts.map

package/dist/admin/endpoints/pause-membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pause-membership.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/pause-membership.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;EAqB3B,CAAC"}

package/dist/admin/endpoints/pause-membership.js

@@ -0,0 +1,19 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const pauseMembership = createAdminEndpoint("/admin/memberships/:id/pause", {
+    method: "POST",
+    params: z.object({ id: z.string().min(1) }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const membership = await controller.pauseMembership(ctx.params.id);
+    if (!membership) {
+        return { error: "Membership not found", status: 404 };
+    }
+    void ctx.context.events?.emit("membership.paused", {
+        membershipId: membership.id,
+        customerId: membership.customerId,
+        planId: membership.planId,
+    });
+    return { membership };
+});

package/dist/admin/endpoints/remove-benefit.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const removeBenefit: import("better-call").StrictEndpoint<"/admin/memberships/benefits/:id/remove", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    success?: never;
+} | {
+    success: boolean;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=remove-benefit.d.ts.map

package/dist/admin/endpoints/remove-benefit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-benefit.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/remove-benefit.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;EAiBzB,CAAC"}

package/dist/admin/endpoints/remove-benefit.js

@@ -0,0 +1,14 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const removeBenefit = createAdminEndpoint("/admin/memberships/benefits/:id/remove", {
+    method: "POST",
+    params: z.object({ id: z.string().min(1) }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const removed = await controller.removeBenefit(ctx.params.id);
+    if (!removed) {
+        return { error: "Benefit not found", status: 404 };
+    }
+    return { success: true };
+});

package/dist/admin/endpoints/resume-membership.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const resumeMembership: import("better-call").StrictEndpoint<"/admin/memberships/:id/resume", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    membership?: never;
+} | {
+    membership: import("../..").Membership;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=resume-membership.d.ts.map

package/dist/admin/endpoints/resume-membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-membership.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/resume-membership.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;EAqB5B,CAAC"}

package/dist/admin/endpoints/resume-membership.js

@@ -0,0 +1,19 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const resumeMembership = createAdminEndpoint("/admin/memberships/:id/resume", {
+    method: "POST",
+    params: z.object({ id: z.string().min(1) }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    const membership = await controller.resumeMembership(ctx.params.id);
+    if (!membership) {
+        return { error: "Membership not found", status: 404 };
+    }
+    void ctx.context.events?.emit("membership.resumed", {
+        membershipId: membership.id,
+        customerId: membership.customerId,
+        planId: membership.planId,
+    });
+    return { membership };
+});