@phpsandbox/sdk 0.3.4 → 0.4.0

package/README.md

@@ -55,6 +55,25 @@ PHPSandbox.rest('token', 'https://api.phpsandbox.io/v1', {
 });
 ```
 
+## Server invitations
+
+Server administrators can invite someone by email and inspect the shared invitation state:
+
+```typescript
+const server = await client.servers.get('SERVER_ID');
+const invitation = await server.share({ email: 'person@example.com', requestId: crypto.randomUUID() });
+const invitations = await server.invitations();
+
+// The recipient uses their own workspace credential and the proof from their invitation link.
+await recipientClient.servers.acceptInvitation(invitation.id, invitationProof);
+```
+
+Keep the same `requestId` when retrying creation. Use `client.servers.inspectInvitation()`, `acceptInvitation()` and `declineInvitation()` to respond, and `server.resendInvitation()` or `cancelInvitation()` to manage pending invitations. An `accepting` status means access confirmation is still in progress; retry acceptance with the same recipient workspace.
+
+For an immediate grant to an existing workspace, use `server.share({ organizationId: 'WORKSPACE_ID', requestId })`.
+
+Invitation operations use the same API base URL and credential as all other operations. No additional endpoint configuration is required.
+
 ## Notebook Lifecycle
 
 ```ts

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

@@ -19676,6 +19676,15 @@ var ServerApi = class {
   constructor(client) {
     this.client = client;
   }
+  async inspectInvitation(id, token) {
+    return (await this.client.post(`/platform/server-invitations/${encodeURIComponent(id)}/inspect`, { token })).data;
+  }
+  async acceptInvitation(id, token) {
+    return (await this.client.post(`/platform/server-invitations/${encodeURIComponent(id)}/accept`, { token })).data;
+  }
+  async declineInvitation(id, token) {
+    return (await this.client.post(`/platform/server-invitations/${encodeURIComponent(id)}/decline`, { token })).data;
+  }
   async list(options = {}) {
     const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
     return this.client.get(`/servers${query}`);
@@ -19701,17 +19710,40 @@ var ServerInstance = class {
     const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
     return this.client.get(`/servers/${encodeURIComponent(this.data.id)}/members${query}`);
   }
-  async share(email3) {
-    return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { email: email3 })).data;
-  }
-  async shareWithOrganization(organizationId) {
-    return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { organizationId })).data;
+  async share(target) {
+    if (target.email !== void 0) {
+      return (await this.client.post(`/platform/servers/${encodeURIComponent(this.data.id)}/invitations`, {
+        email: target.email,
+        requestId: target.requestId ?? crypto.randomUUID()
+      })).data;
+    }
+    const body = { organizationId: target.organizationId, requestId: target.requestId };
+    return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, body)).data;
   }
   async revokeAccess(memberId) {
     await this.client.delete(
       `/servers/${encodeURIComponent(this.data.id)}/members/${encodeURIComponent(String(memberId))}`
     );
   }
+  async invitations(options = {}) {
+    const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
+    return this.client.get(`/platform/servers/${encodeURIComponent(this.data.id)}/invitations${query}`);
+  }
+  async cancelInvitation(id) {
+    const response = await this.client.delete(
+      `/platform/servers/${encodeURIComponent(this.data.id)}/invitations/${encodeURIComponent(id)}`
+    );
+    if (response.data === void 0) {
+      throw new PHPSandboxError("Missing invitation cancellation response.");
+    }
+    return response.data;
+  }
+  async resendInvitation(id) {
+    return (await this.client.post(
+      `/platform/servers/${encodeURIComponent(this.data.id)}/invitations/${encodeURIComponent(id)}/resend`,
+      {}
+    )).data;
+  }
   refresh() {
     return this.client.servers.get(this.data.id);
   }
@@ -20120,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)) {
@@ -20170,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);
@@ -20250,7 +20557,7 @@ var ClientImplementation = class {
       })
     );
     if (!response.ok) {
-      throw await responseError(response);
+      throw await responseError(response, path.startsWith("/platform/") ? "platform" : "core");
     }
     if (response.status === 204) {
       return { data: void 0 };
@@ -20283,10 +20590,10 @@ var ClientImplementation = class {
     }
   }
 };
-async function responseError(response) {
+async function responseError(response, source = "core") {
   const body = await response.text();
   try {
-    return remoteError("core", errorPayload(body === "" ? void 0 : JSON.parse(body)), response);
+    return remoteError(source, errorPayload(body === "" ? void 0 : JSON.parse(body)), response);
   } catch {
     return new TransportError(
       `PHPSandbox API returned an invalid error response (HTTP ${response.status}).`,
@@ -20310,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");
@@ -20376,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);
@@ -20708,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,
@@ -20727,7 +21040,9 @@ export {
   laravelCloudSetupForRepublish,
   notebookBuiltinServices,
   notebookKnownServices,
-  readPublicationStream
+  paymentModeSchema,
+  readPublicationStream,
+  verifyPaymentEvent
 };
 /*! Bundled license information: