@phpsandbox/sdk 0.3.5 → 0.4.0

package/dist/browser/phpsandbox-sdk.esm.js

@@ -20152,6 +20152,280 @@ function sandboxIntegrationId(integration) {
   return typeof integration === "string" ? integration : integration.id;
 }
 
+// src/payments.ts
+var DEFAULT_PAYMENT_CALLBACK_PATH = "/api/phpsandbox-payments/events";
+var paymentModeSchema = external_exports.enum(["test", "live"]);
+var accountSchema = external_exports.object({
+  id: external_exports.string(),
+  mode: paymentModeSchema,
+  chargesEnabled: external_exports.boolean(),
+  payoutsEnabled: external_exports.boolean(),
+  detailsSubmitted: external_exports.boolean(),
+  requirements: external_exports.array(external_exports.string()),
+  disabledReason: external_exports.string().nullable()
+});
+var accessSchema = external_exports.object({
+  subscribed: external_exports.boolean(),
+  liveAllowed: external_exports.boolean(),
+  testConfigured: external_exports.boolean(),
+  liveConfigured: external_exports.boolean(),
+  feeBasisPoints: external_exports.number().int().min(0).max(1e4).nullable(),
+  canRead: external_exports.boolean(),
+  canManage: external_exports.boolean(),
+  canRefund: external_exports.boolean(),
+  recoveryEndsAt: external_exports.string().nullable().default(null)
+});
+var applicationsSchema = external_exports.object({
+  notebookId: external_exports.string(),
+  applications: external_exports.array(
+    external_exports.object({
+      id: external_exports.string(),
+      url: external_exports.string().nullable(),
+      healthy: external_exports.boolean(),
+      passwordProtected: external_exports.boolean(),
+      deployedAt: external_exports.string().datetime().nullable()
+    })
+  )
+});
+var bindingSchema = external_exports.object({
+  id: external_exports.string(),
+  notebookId: external_exports.string(),
+  applicationId: external_exports.string().nullable(),
+  mode: paymentModeSchema,
+  revision: external_exports.number().int(),
+  accountId: external_exports.string(),
+  enabled: external_exports.boolean(),
+  callbackUrl: external_exports.string().nullable(),
+  originUrl: external_exports.string().nullable(),
+  runtimeConfigured: external_exports.boolean()
+});
+var priceSchema = external_exports.object({
+  billingInterval: external_exports.enum(["month", "year"]).nullable().default(null),
+  id: external_exports.string(),
+  name: external_exports.string(),
+  amount: external_exports.number().int(),
+  currency: external_exports.string(),
+  bindingId: external_exports.string()
+});
+var transactionSchema = external_exports.object({
+  subscriptionId: external_exports.string().nullable().default(null),
+  periodStart: external_exports.string().datetime({ offset: true }).nullable().default(null),
+  periodEnd: external_exports.string().datetime({ offset: true }).nullable().default(null),
+  id: external_exports.string(),
+  bindingId: external_exports.string(),
+  orderId: external_exports.string(),
+  priceId: external_exports.string(),
+  amount: external_exports.number().int(),
+  currency: external_exports.string(),
+  feeAmount: external_exports.number().int(),
+  revision: external_exports.number().int(),
+  refundedAmount: external_exports.number().int(),
+  status: external_exports.enum(["pending", "paid", "failed", "refunded", "partially_refunded"]),
+  checkoutUrl: external_exports.string().nullable(),
+  deliveredAt: external_exports.string().nullable()
+});
+var subscriptionSchema = external_exports.object({
+  id: external_exports.string(),
+  bindingId: external_exports.string(),
+  priceId: external_exports.string(),
+  orderId: external_exports.string(),
+  status: external_exports.enum([
+    "pending",
+    "incomplete",
+    "incomplete_expired",
+    "trialing",
+    "active",
+    "past_due",
+    "canceled",
+    "unpaid",
+    "paused"
+  ]),
+  billingInterval: external_exports.enum(["month", "year"]),
+  paidThrough: external_exports.string().datetime({ offset: true }).nullable(),
+  cancelAtPeriodEnd: external_exports.boolean(),
+  checkoutUrl: external_exports.string().nullable(),
+  revision: external_exports.number().int()
+});
+var portalSchema = external_exports.object({ url: external_exports.string().url() });
+var refundResultSchema = transactionSchema.extend({
+  refund: external_exports.object({
+    id: external_exports.string(),
+    amount: external_exports.number().int().positive(),
+    status: external_exports.enum(["pending", "succeeded", "failed", "canceled", "requires_action"])
+  })
+});
+var activationSchema = external_exports.object({
+  revision: external_exports.number().int(),
+  reviewId: external_exports.string(),
+  expiresAt: external_exports.string(),
+  blockers: external_exports.array(external_exports.string()),
+  binding: bindingSchema,
+  account: accountSchema,
+  feeBasisPoints: external_exports.number().int().nullable(),
+  prices: external_exports.array(priceSchema)
+});
+var PaymentsApi = class {
+  constructor(client) {
+    this.client = client;
+    this.runtime = new PaymentRuntime(client);
+  }
+  forNotebook(notebookId) {
+    return new NotebookPayments(notebookId, this.client);
+  }
+  async applications(notebookId) {
+    return applicationsSchema.parse(
+      (await this.client.get(`/notebook/${encodeURIComponent(notebookId)}/payments/applications`)).data
+    );
+  }
+  async access() {
+    return accessSchema.parse((await this.client.get("/platform/payments/access")).data);
+  }
+  async accounts() {
+    return external_exports.array(accountSchema).parse((await this.client.get("/platform/payments/accounts")).data);
+  }
+  async createAccount(mode, country) {
+    return accountSchema.parse((await this.client.put(`/platform/payments/accounts/${mode}`, { country })).data);
+  }
+  async onboarding(mode) {
+    return external_exports.object({ url: external_exports.string().url(), expiresAt: external_exports.string() }).parse((await this.client.post(`/platform/payments/accounts/${mode}/onboarding`, {})).data);
+  }
+};
+var NotebookPayments = class {
+  constructor(notebookId, client) {
+    this.notebookId = notebookId;
+    this.client = client;
+  }
+  path(mode) {
+    return `/platform/payments/sandboxes/${encodeURIComponent(this.notebookId)}/${mode}`;
+  }
+  async get(mode = "test") {
+    return bindingSchema.nullable().parse((await this.client.get(this.path(mode))).data);
+  }
+  async configure(input, mode = "test") {
+    return bindingSchema.parse((await this.client.put(this.path(mode), input)).data);
+  }
+  async provision(mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/provision`, {})).data);
+  }
+  async prices(mode = "test") {
+    return external_exports.array(priceSchema).parse((await this.client.get(`${this.path(mode)}/prices`)).data);
+  }
+  async createPrice(input, mode = "test") {
+    return priceSchema.parse((await this.client.post(`${this.path(mode)}/prices`, input)).data);
+  }
+  async prepareActivation(mode = "test") {
+    return activationSchema.parse((await this.client.post(`${this.path(mode)}/activation`, {})).data);
+  }
+  async activate(reviewId, mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/activate`, { reviewId })).data);
+  }
+  async disable(mode = "test") {
+    return bindingSchema.parse((await this.client.post(`${this.path(mode)}/disable`, {})).data);
+  }
+  async checkout(input, mode = "test") {
+    return transactionSchema.parse((await this.client.post(`${this.path(mode)}/checkouts`, input)).data);
+  }
+  async subscribe(input, mode = "test") {
+    return subscriptionSchema.parse((await this.client.post(`${this.path(mode)}/subscriptions`, input)).data);
+  }
+  async subscriptions(mode = "test") {
+    return external_exports.array(subscriptionSchema).parse((await this.client.get(`${this.path(mode)}/subscriptions`)).data);
+  }
+  async subscription(id, mode = "test") {
+    return subscriptionSchema.parse(
+      (await this.client.get(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async cancelSubscription(id, mode = "test") {
+    return subscriptionSchema.parse(
+      (await this.client.post(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}/cancel`, {})).data
+    );
+  }
+  async subscriptionPortal(id, input, mode = "test") {
+    return portalSchema.parse(
+      (await this.client.post(`${this.path(mode)}/subscriptions/${encodeURIComponent(id)}/portal`, input)).data
+    );
+  }
+  async transactions(mode = "test") {
+    return external_exports.array(transactionSchema).parse((await this.client.get(`${this.path(mode)}/transactions`)).data);
+  }
+  async refund(id, input, mode = "test") {
+    return refundResultSchema.parse(
+      (await this.client.post(`${this.path(mode)}/transactions/${encodeURIComponent(id)}/refund`, input)).data
+    );
+  }
+};
+var paymentEventSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({
+    id: external_exports.string(),
+    type: external_exports.literal("payment.updated"),
+    mode: paymentModeSchema,
+    transaction: transactionSchema
+  }),
+  external_exports.object({
+    id: external_exports.string(),
+    type: external_exports.literal("subscription.updated"),
+    mode: paymentModeSchema,
+    subscription: subscriptionSchema
+  })
+]);
+async function verifyPaymentEvent(body, signature, token, mode, now = Date.now()) {
+  if (!/^hpay_[a-f0-9]{64}$/.test(token)) {
+    throw new Error("Invalid application payment credential.");
+  }
+  const match = /^t=(\d+),v1=([a-f0-9]{64})$/.exec(signature);
+  const timestamp = match?.[1];
+  const digest = match?.[2];
+  if (!timestamp || !digest || Math.abs(now - Number(timestamp) * 1e3) > 3e5 || body.length > 262144) {
+    throw new Error("Invalid or expired payment signature.");
+  }
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", encoder.encode(token), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+  const bytes = Uint8Array.from(digest.match(/../g) ?? [], (byte) => Number.parseInt(byte, 16));
+  if (!await crypto.subtle.verify("HMAC", key, bytes, encoder.encode(`${timestamp}.${body}`))) {
+    throw new Error("Invalid payment signature.");
+  }
+  const event = paymentEventSchema.parse(JSON.parse(body));
+  if (event.mode !== mode) {
+    throw new Error("Payment event mode does not match this application.");
+  }
+  return event;
+}
+var PaymentRuntime = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async checkout(input) {
+    return transactionSchema.parse((await this.client.post("/platform/payments/runtime/checkouts", input)).data);
+  }
+  async transaction(id) {
+    return transactionSchema.parse(
+      (await this.client.get(`/platform/payments/runtime/transactions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async subscribe(input) {
+    return subscriptionSchema.parse((await this.client.post("/platform/payments/runtime/subscriptions", input)).data);
+  }
+  async subscription(id) {
+    return subscriptionSchema.parse(
+      (await this.client.get(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}`)).data
+    );
+  }
+  async cancelSubscription(id) {
+    return subscriptionSchema.parse(
+      (await this.client.post(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}/cancel`, {})).data
+    );
+  }
+  async subscriptionPortal(id, input) {
+    return portalSchema.parse(
+      (await this.client.post(`/platform/payments/runtime/subscriptions/${encodeURIComponent(id)}/portal`, input)).data
+    );
+  }
+  async prices() {
+    return external_exports.array(priceSchema).parse((await this.client.get("/platform/payments/runtime/prices")).data);
+  }
+};
+
 // src/index.ts
 function normalizeNotebookSecretInputs(input) {
   if (Array.isArray(input)) {
@@ -20202,6 +20476,7 @@ var ClientImplementation = class {
     this.notebook = new NotebookApi(this);
     this.servers = new ServerApi(this);
     this.integrations = new IntegrationApi(this);
+    this.payments = new PaymentsApi(this);
     this.options = { ...options };
     this.runtimeTransportValue = runtimeTransport;
     this.baseUrl = normalizeApiBaseUrl(url2);
@@ -20342,6 +20617,7 @@ var PHPSandbox = class _PHPSandbox {
     this.publications = client.publications;
     this.servers = client.servers;
     this.integrations = client.integrations;
+    this.payments = client.payments;
   }
   async whoami() {
     const { data } = await this.client.get("/auth/whoami");
@@ -20408,6 +20684,7 @@ var _NotebookInstance = class _NotebookInstance {
     this.config = new Config(this);
     this.secrets = new NotebookSecrets(client, this.data.id);
     this.integrations = new SandboxIntegrationApi(this.data.id, client);
+    this.payments = new NotebookPayments(this.data.id, client);
     this.preview = new NotebookPreview(client, this.data.id);
     this.mail = new NotebookMail(client, this.data.id);
     this.feedback = new Feedback(client, this.data.id);
@@ -20740,14 +21017,18 @@ function formatQueryString(params) {
   return query === "" ? "" : `?${query}`;
 }
 export {
+  DEFAULT_PAYMENT_CALLBACK_PATH,
   FileChangeFilter,
   FileChangeType,
   FileType,
   LspConnection,
   NotebookInstance,
+  NotebookPayments,
   NotebookPublication,
   PHPSandbox,
   PHPSandboxError,
+  PaymentRuntime,
+  PaymentsApi,
   PublicationApi,
   PublicationDomains,
   PublicationInstance,
@@ -20759,7 +21040,9 @@ export {
   laravelCloudSetupForRepublish,
   notebookBuiltinServices,
   notebookKnownServices,
-  readPublicationStream
+  paymentModeSchema,
+  readPublicationStream,
+  verifyPaymentEvent
 };
 /*! Bundled license information: