@parsrun/service-adapters 0.1.0

package/dist/index.js

@@ -0,0 +1,934 @@
+// src/email/definition.ts
+import { defineService } from "@parsrun/service";
+var emailServiceDefinition = defineService({
+  name: "email",
+  version: "1.0.0",
+  description: "Email sending microservice",
+  queries: {
+    /**
+     * Check if email configuration is valid
+     */
+    verify: {
+      input: void 0,
+      output: void 0,
+      description: "Verify email provider configuration"
+    },
+    /**
+     * Get available email templates
+     */
+    getTemplates: {
+      input: void 0,
+      output: void 0,
+      description: "List available email templates"
+    }
+  },
+  mutations: {
+    /**
+     * Send a single email
+     */
+    send: {
+      input: void 0,
+      output: void 0,
+      description: "Send a single email"
+    },
+    /**
+     * Send batch emails
+     */
+    sendBatch: {
+      input: void 0,
+      output: void 0,
+      description: "Send multiple emails in batch"
+    },
+    /**
+     * Render an email template
+     */
+    renderTemplate: {
+      input: void 0,
+      output: void 0,
+      description: "Render an email template without sending"
+    }
+  },
+  events: {
+    emits: {
+      /**
+       * Emitted when an email is sent successfully
+       */
+      "email.sent": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Email was sent successfully"
+      },
+      /**
+       * Emitted when an email fails to send
+       */
+      "email.failed": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Email failed to send"
+      }
+    },
+    handles: [
+      // Events this service listens to
+      "user.created",
+      // Send welcome email
+      "user.password_reset_requested",
+      // Send password reset email
+      "user.email_verification_requested",
+      // Send verification email
+      "tenant.invitation_created",
+      // Send invitation email
+      "dunning.notification_required"
+      // Send dunning emails
+    ]
+  }
+});
+
+// src/email/server.ts
+import { createLogger } from "@parsrun/core";
+import {
+  createRpcServer,
+  createEventEmitter,
+  createMemoryEventTransport,
+  getEmbeddedRegistry
+} from "@parsrun/service";
+function createEmailServiceServer(options) {
+  const logger = options.logger ?? createLogger({ name: "email-service" });
+  const eventTransport = options.eventTransport ?? createMemoryEventTransport();
+  const eventEmitter = createEventEmitter({
+    service: "email",
+    definition: emailServiceDefinition,
+    transport: eventTransport,
+    logger
+  });
+  const handlers = {
+    queries: {
+      verify: async (_input, ctx) => {
+        ctx.logger.debug("Verifying email configuration");
+        return {
+          valid: !!options.provider.apiKey || options.provider.type === "console",
+          provider: options.provider.type
+        };
+      },
+      getTemplates: async (_input, ctx) => {
+        ctx.logger.debug("Getting available templates");
+        return {
+          templates: [
+            {
+              name: "welcome",
+              description: "Welcome email for new users",
+              variables: ["name", "loginUrl"]
+            },
+            {
+              name: "password-reset",
+              description: "Password reset email",
+              variables: ["resetUrl", "expiresInMinutes"]
+            },
+            {
+              name: "email-verification",
+              description: "Email verification link",
+              variables: ["verificationUrl", "expiresInHours"]
+            },
+            {
+              name: "otp",
+              description: "One-time password email",
+              variables: ["code", "expiresInMinutes"]
+            },
+            {
+              name: "magic-link",
+              description: "Magic link for passwordless login",
+              variables: ["url", "expiresInMinutes"]
+            },
+            {
+              name: "invitation",
+              description: "Team/organization invitation",
+              variables: ["inviterName", "organizationName", "url", "role", "expiresInDays"]
+            }
+          ]
+        };
+      }
+    },
+    mutations: {
+      send: async (input, ctx) => {
+        const { to, subject, html, text: _text, templateName, templateData: _templateData } = input;
+        void _text;
+        void _templateData;
+        ctx.logger.info("Sending email", { to, subject, templateName });
+        try {
+          const toArray = Array.isArray(to) ? to : [to];
+          const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+          if (options.provider.type === "console") {
+            console.log("\u{1F4E7} Email sent:", {
+              to: toArray,
+              subject,
+              templateName,
+              html: html?.slice(0, 100)
+            });
+          }
+          await eventEmitter.emit("email.sent", {
+            messageId,
+            to: toArray,
+            subject,
+            provider: options.provider.type,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { success: true, messageId };
+        } catch (error) {
+          const toArray = Array.isArray(to) ? to : [to];
+          await eventEmitter.emit("email.failed", {
+            to: toArray,
+            subject,
+            error: error.message,
+            provider: options.provider.type,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { success: false, error: error.message };
+        }
+      },
+      sendBatch: async (input, ctx) => {
+        const { emails, stopOnError } = input;
+        ctx.logger.info("Sending batch emails", { count: emails.length });
+        const results = [];
+        let successful = 0;
+        let failed = 0;
+        for (const email of emails) {
+          try {
+            const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+            if (options.provider.type === "console") {
+              console.log("\u{1F4E7} Batch email:", { to: email.to, subject: email.subject });
+            }
+            results.push({ success: true, messageId });
+            successful++;
+          } catch (error) {
+            results.push({ success: false, error: error.message });
+            failed++;
+            if (stopOnError) {
+              break;
+            }
+          }
+        }
+        return {
+          total: emails.length,
+          successful,
+          failed,
+          results
+        };
+      },
+      renderTemplate: async (input, ctx) => {
+        const { templateName, data } = input;
+        ctx.logger.debug("Rendering template", { templateName });
+        const templates = {
+          welcome: {
+            subject: `Welcome to ${data["appName"] ?? "Our App"}!`,
+            html: `<h1>Welcome ${data["name"]}!</h1><p>Click <a href="${data["loginUrl"]}">here</a> to login.</p>`,
+            text: `Welcome ${data["name"]}! Visit ${data["loginUrl"]} to login.`
+          },
+          otp: {
+            subject: "Your verification code",
+            html: `<h1>Your code is: ${data["code"]}</h1><p>Expires in ${data["expiresInMinutes"]} minutes.</p>`,
+            text: `Your code is: ${data["code"]}. Expires in ${data["expiresInMinutes"]} minutes.`
+          }
+        };
+        const template = templates[templateName];
+        if (!template) {
+          throw new Error(`Template not found: ${templateName}`);
+        }
+        return template;
+      }
+    }
+  };
+  const rpcServer = createRpcServer({
+    definition: emailServiceDefinition,
+    handlers,
+    logger
+  });
+  const register = () => {
+    const registry = getEmbeddedRegistry();
+    registry.register("email", rpcServer);
+    logger.info("Email service registered");
+  };
+  return {
+    rpcServer,
+    eventEmitter,
+    register
+  };
+}
+
+// src/email/client.ts
+import {
+  useService
+} from "@parsrun/service";
+function createEmailServiceClient(options) {
+  const client = useService("email", options);
+  return {
+    async verify() {
+      return client.query("verify", void 0);
+    },
+    async getTemplates() {
+      return client.query("getTemplates", void 0);
+    },
+    async send(emailOptions) {
+      return client.mutate("send", emailOptions);
+    },
+    async sendBatch(batchOptions) {
+      return client.mutate("sendBatch", batchOptions);
+    },
+    async renderTemplate(templateName, data) {
+      return client.mutate("renderTemplate", { templateName, data });
+    },
+    onEmailSent(handler) {
+      return client.on("email.sent", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onEmailFailed(handler) {
+      return client.on("email.failed", async (event) => {
+        await handler(event.data);
+      });
+    },
+    async close() {
+      if ("close" in client && typeof client.close === "function") {
+        await client.close();
+      }
+    }
+  };
+}
+
+// src/payments/definition.ts
+import { defineService as defineService2 } from "@parsrun/service";
+var paymentsServiceDefinition = defineService2({
+  name: "payments",
+  version: "1.0.0",
+  description: "Payments, billing, and subscription management microservice",
+  queries: {
+    /**
+     * Get subscription details
+     */
+    getSubscription: {
+      input: void 0,
+      output: void 0,
+      description: "Get subscription details by ID or customer ID"
+    },
+    /**
+     * Get customer details
+     */
+    getCustomer: {
+      input: void 0,
+      output: void 0,
+      description: "Get customer details"
+    },
+    /**
+     * Check quota status
+     */
+    checkQuota: {
+      input: void 0,
+      output: void 0,
+      description: "Check if customer has quota for a feature"
+    },
+    /**
+     * Get usage summary
+     */
+    getUsage: {
+      input: void 0,
+      output: void 0,
+      description: "Get usage summary for a customer"
+    },
+    /**
+     * Get available plans
+     */
+    getPlans: {
+      input: void 0,
+      output: void 0,
+      description: "Get available subscription plans"
+    },
+    /**
+     * Get dunning status
+     */
+    getDunningStatus: {
+      input: void 0,
+      output: void 0,
+      description: "Get dunning status for a customer"
+    }
+  },
+  mutations: {
+    /**
+     * Create a checkout session
+     */
+    createCheckout: {
+      input: void 0,
+      output: void 0,
+      description: "Create a checkout session for subscription"
+    },
+    /**
+     * Cancel a subscription
+     */
+    cancelSubscription: {
+      input: void 0,
+      output: void 0,
+      description: "Cancel a subscription"
+    },
+    /**
+     * Update subscription
+     */
+    updateSubscription: {
+      input: void 0,
+      output: void 0,
+      description: "Update a subscription (e.g., change plan)"
+    },
+    /**
+     * Create customer portal session
+     */
+    createPortalSession: {
+      input: void 0,
+      output: void 0,
+      description: "Create a customer portal session for self-service"
+    },
+    /**
+     * Track usage
+     */
+    trackUsage: {
+      input: void 0,
+      output: void 0,
+      description: "Track usage of a metered feature"
+    },
+    /**
+     * Assign plan to customer
+     */
+    assignPlan: {
+      input: void 0,
+      output: void 0,
+      description: "Manually assign a plan to a customer"
+    },
+    /**
+     * Handle webhook
+     */
+    handleWebhook: {
+      input: void 0,
+      output: void 0,
+      description: "Handle payment provider webhook"
+    }
+  },
+  events: {
+    emits: {
+      /**
+       * Subscription was created
+       */
+      "subscription.created": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "A new subscription was created"
+      },
+      /**
+       * Subscription was renewed
+       */
+      "subscription.renewed": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Subscription was renewed for a new period"
+      },
+      /**
+       * Subscription was canceled
+       */
+      "subscription.canceled": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Subscription was canceled"
+      },
+      /**
+       * Subscription plan changed
+       */
+      "subscription.plan_changed": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Subscription plan was changed"
+      },
+      /**
+       * Payment succeeded
+       */
+      "payment.succeeded": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Payment was successful"
+      },
+      /**
+       * Payment failed
+       */
+      "payment.failed": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Payment failed"
+      },
+      /**
+       * Quota exceeded
+       */
+      "quota.exceeded": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Customer exceeded their quota for a feature"
+      },
+      /**
+       * Quota threshold reached
+       */
+      "quota.threshold_reached": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Customer reached a usage threshold (e.g., 80%)"
+      },
+      /**
+       * Dunning started
+       */
+      "dunning.started": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Dunning process started for a customer"
+      },
+      /**
+       * Dunning resolved
+       */
+      "dunning.resolved": {
+        data: void 0,
+        delivery: "at-least-once",
+        description: "Dunning process was resolved"
+      }
+    },
+    handles: [
+      // Events this service listens to
+      "user.created",
+      // Create customer record
+      "user.deleted",
+      // Cancel subscriptions
+      "tenant.suspended"
+      // Pause billing
+    ]
+  }
+});
+
+// src/payments/server.ts
+import { createLogger as createLogger2 } from "@parsrun/core";
+import {
+  createRpcServer as createRpcServer2,
+  createEventEmitter as createEventEmitter2,
+  createMemoryEventTransport as createMemoryEventTransport2,
+  getEmbeddedRegistry as getEmbeddedRegistry2
+} from "@parsrun/service";
+var InMemoryPaymentsStorage = class {
+  usage = /* @__PURE__ */ new Map();
+  customerPlans = /* @__PURE__ */ new Map();
+  plans = [
+    {
+      id: "free",
+      name: "free",
+      displayName: "Free",
+      tier: 0,
+      basePrice: 0,
+      currency: "USD",
+      billingInterval: "month",
+      features: [
+        { featureKey: "api_calls", limitValue: 1e3, limitPeriod: "month" },
+        { featureKey: "storage_mb", limitValue: 100, limitPeriod: null }
+      ]
+    },
+    {
+      id: "pro",
+      name: "pro",
+      displayName: "Pro",
+      tier: 1,
+      basePrice: 2900,
+      currency: "USD",
+      billingInterval: "month",
+      features: [
+        { featureKey: "api_calls", limitValue: 1e5, limitPeriod: "month" },
+        { featureKey: "storage_mb", limitValue: 1e4, limitPeriod: null }
+      ]
+    },
+    {
+      id: "enterprise",
+      name: "enterprise",
+      displayName: "Enterprise",
+      tier: 2,
+      basePrice: 9900,
+      currency: "USD",
+      billingInterval: "month",
+      features: [
+        { featureKey: "api_calls", limitValue: null, limitPeriod: "month" },
+        { featureKey: "storage_mb", limitValue: null, limitPeriod: null }
+      ]
+    }
+  ];
+  async getUsage(customerId, featureKey) {
+    return this.usage.get(`${customerId}:${featureKey}`) ?? 0;
+  }
+  async trackUsage(customerId, featureKey, quantity) {
+    const key = `${customerId}:${featureKey}`;
+    const current = this.usage.get(key) ?? 0;
+    const newTotal = current + quantity;
+    this.usage.set(key, newTotal);
+    return newTotal;
+  }
+  async resetUsage(customerId, featureKey) {
+    if (featureKey) {
+      this.usage.delete(`${customerId}:${featureKey}`);
+    } else {
+      for (const key of this.usage.keys()) {
+        if (key.startsWith(`${customerId}:`)) {
+          this.usage.delete(key);
+        }
+      }
+    }
+  }
+  async getPlan(planId) {
+    return this.plans.find((p) => p.id === planId) ?? null;
+  }
+  async getPlans() {
+    return this.plans;
+  }
+  async getCustomerPlan(customerId) {
+    return this.customerPlans.get(customerId) ?? "free";
+  }
+  async setCustomerPlan(customerId, planId) {
+    this.customerPlans.set(customerId, planId);
+  }
+};
+function createPaymentsServiceServer(options) {
+  const logger = options.logger ?? createLogger2({ name: "payments-service" });
+  const eventTransport = options.eventTransport ?? createMemoryEventTransport2();
+  const storage = options.storage ?? new InMemoryPaymentsStorage();
+  const eventEmitter = createEventEmitter2({
+    service: "payments",
+    definition: paymentsServiceDefinition,
+    transport: eventTransport,
+    logger
+  });
+  const handlers = {
+    queries: {
+      getSubscription: async (input, ctx) => {
+        const { subscriptionId, customerId } = input;
+        ctx.logger.debug("Getting subscription", { subscriptionId, customerId });
+        if (!subscriptionId && !customerId) {
+          return null;
+        }
+        return {
+          id: subscriptionId ?? `sub_${customerId}`,
+          customerId: customerId ?? "cus_123",
+          status: "active",
+          planId: "pro",
+          planName: "Pro",
+          currentPeriodStart: (/* @__PURE__ */ new Date()).toISOString(),
+          currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString(),
+          cancelAtPeriodEnd: false,
+          provider: options.providers.default.type
+        };
+      },
+      getCustomer: async (input, ctx) => {
+        const { customerId } = input;
+        ctx.logger.debug("Getting customer", { customerId });
+        return {
+          id: customerId,
+          email: `${customerId}@example.com`,
+          name: "Test Customer",
+          provider: options.providers.default.type
+        };
+      },
+      checkQuota: async (input, ctx) => {
+        const { customerId, featureKey } = input;
+        ctx.logger.debug("Checking quota", { customerId, featureKey });
+        const planId = await storage.getCustomerPlan(customerId);
+        const plan = planId ? await storage.getPlan(planId) : null;
+        const feature = plan?.features.find((f) => f.featureKey === featureKey);
+        const used = await storage.getUsage(customerId, featureKey);
+        const limit = feature?.limitValue ?? null;
+        const percentage = limit ? Math.round(used / limit * 100) : 0;
+        const allowed = limit === null || used < limit;
+        return {
+          allowed,
+          remaining: limit !== null ? Math.max(0, limit - used) : null,
+          limit,
+          percentage
+        };
+      },
+      getUsage: async (input, ctx) => {
+        const { customerId, featureKey } = input;
+        ctx.logger.debug("Getting usage", { customerId, featureKey });
+        const planId = await storage.getCustomerPlan(customerId);
+        const plan = planId ? await storage.getPlan(planId) : null;
+        const features = [];
+        const featuresToCheck = featureKey ? plan?.features.filter((f) => f.featureKey === featureKey) ?? [] : plan?.features ?? [];
+        for (const f of featuresToCheck) {
+          const used = await storage.getUsage(customerId, f.featureKey);
+          features.push({
+            featureKey: f.featureKey,
+            used,
+            limit: f.limitValue,
+            percentage: f.limitValue ? Math.round(used / f.limitValue * 100) : 0
+          });
+        }
+        return {
+          features,
+          period: {
+            start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString(),
+            end: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        };
+      },
+      getPlans: async (_input, ctx) => {
+        ctx.logger.debug("Getting plans");
+        const plans = await storage.getPlans();
+        return { plans };
+      },
+      getDunningStatus: async (input, ctx) => {
+        const { customerId } = input;
+        ctx.logger.debug("Getting dunning status", { customerId });
+        return { inDunning: false };
+      }
+    },
+    mutations: {
+      createCheckout: async (input, ctx) => {
+        const { email, planId, successUrl: _successUrl, cancelUrl: _cancelUrl, countryCode } = input;
+        void _successUrl;
+        void _cancelUrl;
+        ctx.logger.info("Creating checkout", { email, planId, countryCode });
+        const sessionId = `cs_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        const customerId = `cus_${Date.now()}`;
+        return {
+          checkoutUrl: `https://checkout.example.com/${sessionId}`,
+          sessionId,
+          customerId,
+          provider: options.providers.default.type
+        };
+      },
+      cancelSubscription: async (input, ctx) => {
+        const { subscriptionId, cancelAtPeriodEnd, reason } = input;
+        ctx.logger.info("Canceling subscription", { subscriptionId, reason });
+        await eventEmitter.emit("subscription.canceled", {
+          subscriptionId,
+          customerId: "cus_123",
+          reason,
+          effectiveAt: cancelAtPeriodEnd ? new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          success: true,
+          canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          effectiveAt: cancelAtPeriodEnd ? new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+        };
+      },
+      updateSubscription: async (input, ctx) => {
+        const { subscriptionId, planId } = input;
+        ctx.logger.info("Updating subscription", { subscriptionId, planId });
+        if (planId) {
+          await eventEmitter.emit("subscription.plan_changed", {
+            subscriptionId,
+            customerId: "cus_123",
+            previousPlanId: "pro",
+            newPlanId: planId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        return {
+          success: true,
+          subscription: {
+            id: subscriptionId,
+            planId: planId ?? "pro",
+            status: "active"
+          }
+        };
+      },
+      createPortalSession: async (input, ctx) => {
+        const { customerId, returnUrl: _returnUrl } = input;
+        void _returnUrl;
+        ctx.logger.info("Creating portal session", { customerId });
+        return {
+          portalUrl: `https://billing.example.com/portal/${customerId}`,
+          expiresAt: new Date(Date.now() + 60 * 60 * 1e3).toISOString()
+        };
+      },
+      trackUsage: async (input, ctx) => {
+        const { customerId, featureKey, quantity } = input;
+        ctx.logger.debug("Tracking usage", { customerId, featureKey, quantity });
+        const newTotal = await storage.trackUsage(customerId, featureKey, quantity);
+        const planId = await storage.getCustomerPlan(customerId);
+        const plan = planId ? await storage.getPlan(planId) : null;
+        const feature = plan?.features.find((f) => f.featureKey === featureKey);
+        const limit = feature?.limitValue ?? null;
+        if (limit !== null) {
+          const percentage = Math.round(newTotal / limit * 100);
+          if (percentage >= 100 && newTotal - quantity < limit) {
+            await eventEmitter.emit("quota.exceeded", {
+              customerId,
+              featureKey,
+              used: newTotal,
+              limit,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } else if (percentage >= 80 && Math.round((newTotal - quantity) / limit * 100) < 80) {
+            await eventEmitter.emit("quota.threshold_reached", {
+              customerId,
+              featureKey,
+              percentage,
+              used: newTotal,
+              limit,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        return {
+          success: true,
+          newTotal,
+          remaining: limit !== null ? Math.max(0, limit - newTotal) : null
+        };
+      },
+      assignPlan: async (input, ctx) => {
+        const { customerId, planId } = input;
+        ctx.logger.info("Assigning plan", { customerId, planId });
+        const previousPlanId = await storage.getCustomerPlan(customerId);
+        await storage.setCustomerPlan(customerId, planId);
+        return {
+          success: true,
+          previousPlanId: previousPlanId ?? void 0,
+          newPlanId: planId
+        };
+      },
+      handleWebhook: async (input, ctx) => {
+        const { provider, payload: _payload, signature: _signature } = input;
+        void _payload;
+        void _signature;
+        ctx.logger.info("Handling webhook", { provider });
+        return {
+          success: true,
+          eventType: "payment.succeeded",
+          eventId: `evt_${Date.now()}`
+        };
+      }
+    }
+  };
+  const rpcServer = createRpcServer2({
+    definition: paymentsServiceDefinition,
+    handlers,
+    logger
+  });
+  const register = () => {
+    const registry = getEmbeddedRegistry2();
+    registry.register("payments", rpcServer);
+    logger.info("Payments service registered");
+  };
+  return {
+    rpcServer,
+    eventEmitter,
+    register
+  };
+}
+
+// src/payments/client.ts
+import {
+  useService as useService2
+} from "@parsrun/service";
+function createPaymentsServiceClient(options) {
+  const client = useService2("payments", options);
+  return {
+    // Queries
+    async getSubscription(opts) {
+      return client.query("getSubscription", opts);
+    },
+    async getCustomer(customerId) {
+      return client.query("getCustomer", { customerId });
+    },
+    async checkQuota(customerId, featureKey) {
+      return client.query("checkQuota", { customerId, featureKey });
+    },
+    async getUsage(opts) {
+      return client.query("getUsage", opts);
+    },
+    async getPlans() {
+      return client.query("getPlans", void 0);
+    },
+    async getDunningStatus(customerId) {
+      return client.query("getDunningStatus", { customerId });
+    },
+    // Mutations
+    async createCheckout(opts) {
+      return client.mutate("createCheckout", opts);
+    },
+    async cancelSubscription(opts) {
+      return client.mutate("cancelSubscription", opts);
+    },
+    async updateSubscription(opts) {
+      return client.mutate("updateSubscription", opts);
+    },
+    async createPortalSession(customerId, returnUrl) {
+      return client.mutate("createPortalSession", { customerId, returnUrl });
+    },
+    async trackUsage(opts) {
+      return client.mutate("trackUsage", opts);
+    },
+    async assignPlan(customerId, planId, expiresAt) {
+      return client.mutate("assignPlan", { customerId, planId, expiresAt });
+    },
+    async handleWebhook(opts) {
+      return client.mutate("handleWebhook", opts);
+    },
+    // Event subscriptions
+    onSubscriptionCreated(handler) {
+      return client.on("subscription.created", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onSubscriptionRenewed(handler) {
+      return client.on("subscription.renewed", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onSubscriptionCanceled(handler) {
+      return client.on("subscription.canceled", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onSubscriptionPlanChanged(handler) {
+      return client.on("subscription.plan_changed", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onPaymentSucceeded(handler) {
+      return client.on("payment.succeeded", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onPaymentFailed(handler) {
+      return client.on("payment.failed", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onQuotaExceeded(handler) {
+      return client.on("quota.exceeded", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onQuotaThresholdReached(handler) {
+      return client.on("quota.threshold_reached", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onDunningStarted(handler) {
+      return client.on("dunning.started", async (event) => {
+        await handler(event.data);
+      });
+    },
+    onDunningResolved(handler) {
+      return client.on("dunning.resolved", async (event) => {
+        await handler(event.data);
+      });
+    },
+    async close() {
+      if ("close" in client && typeof client.close === "function") {
+        await client.close();
+      }
+    }
+  };
+}
+export {
+  createEmailServiceClient,
+  createEmailServiceServer,
+  createPaymentsServiceClient,
+  createPaymentsServiceServer,
+  emailServiceDefinition,
+  paymentsServiceDefinition
+};
+//# sourceMappingURL=index.js.map