@phpsandbox/sdk 0.3.4 → 0.4.0

package/dist/errors/index.d.ts

@@ -1,4 +1,4 @@
-export type RemoteErrorSource = 'core' | 'runtime';
+export type RemoteErrorSource = 'core' | 'platform' | 'runtime';
 declare const remoteErrorCodes: readonly ["ActionNotFound", "AuthenticationRequired", "BadGateway", "BadRequest", "Conflict", "FileAlreadyExists", "FileIsDirectory", "FileNotDirectory", "FileNotFound", "FilesystemUnavailable", "InternalError", "InvalidArgument", "InvalidConfiguration", "InvalidRequest", "InvalidResponse", "InvalidServiceCommand", "MethodNotAllowed", "NotebookInitializationFailed", "NotebookUnavailable", "NotFound", "PayloadTooLarge", "PermissionDenied", "RateLimited", "RequestFailed", "RuntimeOperationFailed", "ServiceNotFound", "ServiceUnavailable", "UnprocessableEntity", "ValidationFailed", "WorkspaceUnavailable"];
 export type RemoteErrorCode = (typeof remoteErrorCodes)[number];
 export type TransportErrorCode = 'ConnectionFailed' | 'ConnectionTimeout' | 'InvalidResponse' | 'SendTimeout';

package/dist/index.d.ts

@@ -18,6 +18,8 @@ import { PublicationApi } from './publication/index.js';
 import { ServerApi } from './servers.js';
 import { Feedback } from './feedback.js';
 import { IntegrationApi, SandboxIntegrationApi } from './integrations/index.js';
+import { PaymentsApi, NotebookPayments } from './payments.js';
+export * from './payments.js';
 export type { Disposable } from './types.js';
 export { LspConnection } from './lsp.js';
 export { FileChangeFilter, FileChangeType, FileType } from './filesystem.js';
@@ -35,7 +37,7 @@ export type { ConfigPortMapping, ProjectConfig } from './config.js';
 export { PHPSandboxError, RemoteError, TransportError } from './errors/index.js';
 export type { HttpResponseDiagnostics, RemoteErrorCode, RemoteErrorSource, TransportErrorCode, ValidationErrorDetails, } from './errors/index.js';
 export * from './publication/index.js';
-export type { CreateServerInput, ServerData, ServerInstance, ServerListOptions, ServerMemberData, ServerSshOptions, } from './servers.js';
+export type { CreateServerInput, ServerData, ServerInstance, ServerListOptions, ServerMemberData, ServerInvitationData, ServerInvitationTarget, ServerOrganizationTarget, ShareServerInput, ServerSshOptions, } from './servers.js';
 export type { ConfigureFeedbackInput, FeedbackData, FeedbackListOptions, FeedbackSource, FeedbackStatus, FeedbackType, FeedbackWidgetConfig, FeedbackWidgetTarget, SubmitFeedbackInput, UpdateFeedbackInput, } from './feedback.js';
 export type { Integration, IntegrationAuthorization, IntegrationAuthorizationType, IntegrationData, IntegrationProvider, IntegrationReference, LinkIntegrationInput, UpdateIntegrationInput, AttachSandboxIntegrationInput, SandboxIntegration, SandboxIntegrationData, SandboxIntegrationEffect, SandboxIntegrationReference, UpdateSandboxIntegrationInput, } from './integrations/index.js';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
@@ -329,6 +331,7 @@ declare class ClientImplementation {
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly integrations: IntegrationApi;
+    readonly payments: PaymentsApi;
     readonly options: PHPSandboxClientOptions;
     private readonly runtimeTransportValue;
     get runtimeTransport(): RuntimeTransport;
@@ -364,6 +367,7 @@ export declare class PHPSandbox {
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly integrations: IntegrationApi;
+    readonly payments: PaymentsApi;
     private constructor();
     whoami(): Promise<Identity>;
     get runtimeTransport(): RuntimeTransport;
@@ -399,6 +403,7 @@ export declare class NotebookInstance {
     readonly config: Config;
     readonly secrets: NotebookSecrets;
     readonly integrations: SandboxIntegrationApi;
+    readonly payments: NotebookPayments;
     readonly preview: NotebookPreview;
     readonly mail: NotebookMail;
     readonly feedback: Feedback;

package/dist/index.js

@@ -31,6 +31,8 @@ import { RestRuntimeInvoker } from './runtime/rest.js';
 import { Feedback } from './feedback.js';
 import { IntegrationApi, SandboxIntegrationApi } from './integrations/index.js';
 import { authenticatedRequest } from './http.js';
+import { PaymentsApi, NotebookPayments } from './payments.js';
+export * from './payments.js';
 export { LspConnection } from './lsp.js';
 export { FileChangeFilter, FileChangeType, FileType } from './filesystem.js';
 export { notebookBuiltinServices, notebookKnownServices } from './services.js';
@@ -86,6 +88,7 @@ class ClientImplementation {
         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(url);
@@ -157,7 +160,7 @@ class ClientImplementation {
             headers: this.headers,
         }));
         if (!response.ok) {
-            throw await responseError(response);
+            throw await responseError(response, path.startsWith('/platform/') ? 'platform' : 'core');
         }
         if (response.status === 204) {
             return { data: undefined };
@@ -195,10 +198,10 @@ class ClientImplementation {
         }
     }
 }
-async function responseError(response) {
+async function responseError(response, source = 'core') {
     const body = await response.text();
     try {
-        return remoteError('core', errorPayload(body === '' ? undefined : JSON.parse(body)), response);
+        return remoteError(source, errorPayload(body === '' ? undefined : JSON.parse(body)), response);
     }
     catch {
         return new TransportError(`PHPSandbox API returned an invalid error response (HTTP ${response.status}).`, 'InvalidResponse', response, {
@@ -220,6 +223,7 @@ export 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');
@@ -287,6 +291,7 @@ export 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);

package/dist/payments.d.ts

@@ -0,0 +1,347 @@
+import { z } from 'zod';
+import type { Client } from './index.js';
+export declare const DEFAULT_PAYMENT_CALLBACK_PATH = "/api/phpsandbox-payments/events";
+export declare const paymentModeSchema: z.ZodEnum<{
+    test: "test";
+    live: "live";
+}>;
+export type PaymentMode = z.infer<typeof paymentModeSchema>;
+declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    chargesEnabled: z.ZodBoolean;
+    payoutsEnabled: z.ZodBoolean;
+    detailsSubmitted: z.ZodBoolean;
+    requirements: z.ZodArray<z.ZodString>;
+    disabledReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PaymentAccountData = z.infer<typeof accountSchema>;
+declare const accessSchema: z.ZodObject<{
+    subscribed: z.ZodBoolean;
+    liveAllowed: z.ZodBoolean;
+    testConfigured: z.ZodBoolean;
+    liveConfigured: z.ZodBoolean;
+    feeBasisPoints: z.ZodNullable<z.ZodNumber>;
+    canRead: z.ZodBoolean;
+    canManage: z.ZodBoolean;
+    canRefund: z.ZodBoolean;
+    recoveryEndsAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type PaymentsAccess = z.infer<typeof accessSchema>;
+declare const applicationsSchema: z.ZodObject<{
+    notebookId: z.ZodString;
+    applications: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        healthy: z.ZodBoolean;
+        passwordProtected: z.ZodBoolean;
+        deployedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PaymentApplicationsData = z.infer<typeof applicationsSchema>;
+declare const bindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    notebookId: z.ZodString;
+    applicationId: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    revision: z.ZodNumber;
+    accountId: z.ZodString;
+    enabled: z.ZodBoolean;
+    callbackUrl: z.ZodNullable<z.ZodString>;
+    originUrl: z.ZodNullable<z.ZodString>;
+    runtimeConfigured: z.ZodBoolean;
+}, z.core.$strip>;
+export type PaymentBindingData = z.infer<typeof bindingSchema>;
+declare const priceSchema: z.ZodObject<{
+    billingInterval: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        month: "month";
+        year: "year";
+    }>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    bindingId: z.ZodString;
+}, z.core.$strip>;
+export type PaymentPriceData = z.infer<typeof priceSchema>;
+declare const transactionSchema: z.ZodObject<{
+    subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    orderId: z.ZodString;
+    priceId: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    feeAmount: z.ZodNumber;
+    revision: z.ZodNumber;
+    refundedAmount: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        paid: "paid";
+        refunded: "refunded";
+        partially_refunded: "partially_refunded";
+    }>;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    deliveredAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PaymentTransactionData = z.infer<typeof transactionSchema>;
+declare const subscriptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    priceId: z.ZodString;
+    orderId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        incomplete: "incomplete";
+        incomplete_expired: "incomplete_expired";
+        trialing: "trialing";
+        active: "active";
+        past_due: "past_due";
+        canceled: "canceled";
+        unpaid: "unpaid";
+        paused: "paused";
+    }>;
+    billingInterval: z.ZodEnum<{
+        month: "month";
+        year: "year";
+    }>;
+    paidThrough: z.ZodNullable<z.ZodString>;
+    cancelAtPeriodEnd: z.ZodBoolean;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+}, z.core.$strip>;
+export type PaymentSubscriptionData = z.infer<typeof subscriptionSchema>;
+export interface PaymentSubscriptionPortalInput {
+    returnPath: string;
+}
+declare const refundResultSchema: z.ZodObject<{
+    subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    bindingId: z.ZodString;
+    orderId: z.ZodString;
+    priceId: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    feeAmount: z.ZodNumber;
+    revision: z.ZodNumber;
+    refundedAmount: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        paid: "paid";
+        refunded: "refunded";
+        partially_refunded: "partially_refunded";
+    }>;
+    checkoutUrl: z.ZodNullable<z.ZodString>;
+    deliveredAt: z.ZodNullable<z.ZodString>;
+    refund: z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+            canceled: "canceled";
+            requires_action: "requires_action";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PaymentRefundResult = z.infer<typeof refundResultSchema>;
+declare const activationSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    reviewId: z.ZodString;
+    expiresAt: z.ZodString;
+    blockers: z.ZodArray<z.ZodString>;
+    binding: z.ZodObject<{
+        id: z.ZodString;
+        notebookId: z.ZodString;
+        applicationId: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        revision: z.ZodNumber;
+        accountId: z.ZodString;
+        enabled: z.ZodBoolean;
+        callbackUrl: z.ZodNullable<z.ZodString>;
+        originUrl: z.ZodNullable<z.ZodString>;
+        runtimeConfigured: z.ZodBoolean;
+    }, z.core.$strip>;
+    account: z.ZodObject<{
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        chargesEnabled: z.ZodBoolean;
+        payoutsEnabled: z.ZodBoolean;
+        detailsSubmitted: z.ZodBoolean;
+        requirements: z.ZodArray<z.ZodString>;
+        disabledReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    feeBasisPoints: z.ZodNullable<z.ZodNumber>;
+    prices: z.ZodArray<z.ZodObject<{
+        billingInterval: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            month: "month";
+            year: "year";
+        }>>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        bindingId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PaymentActivationReview = z.infer<typeof activationSchema>;
+export interface ConfigurePaymentsInput {
+    expectedRevision: number;
+    applicationId?: string | null;
+    callbackPath?: string;
+}
+export interface CreatePaymentPriceInput {
+    billingInterval?: 'month' | 'year';
+    requestId: string;
+    name: string;
+    amount: number;
+    currency: string;
+}
+export interface CreatePaymentCheckoutInput {
+    requestId: string;
+    orderId: string;
+    priceId: string;
+    successPath: string;
+    cancelPath: string;
+}
+export interface RefundPaymentInput {
+    requestId: string;
+    amount?: number;
+}
+export declare class PaymentsApi {
+    private readonly client;
+    readonly runtime: PaymentRuntime;
+    constructor(client: Client);
+    forNotebook(notebookId: string): NotebookPayments;
+    applications(notebookId: string): Promise<PaymentApplicationsData>;
+    access(): Promise<PaymentsAccess>;
+    accounts(): Promise<PaymentAccountData[]>;
+    createAccount(mode: PaymentMode, country?: string): Promise<PaymentAccountData>;
+    onboarding(mode: PaymentMode): Promise<{
+        url: string;
+        expiresAt: string;
+    }>;
+}
+export declare class NotebookPayments {
+    private readonly notebookId;
+    private readonly client;
+    constructor(notebookId: string, client: Client);
+    private path;
+    get(mode?: PaymentMode): Promise<PaymentBindingData | null>;
+    configure(input: ConfigurePaymentsInput, mode?: PaymentMode): Promise<PaymentBindingData>;
+    provision(mode?: PaymentMode): Promise<PaymentBindingData>;
+    prices(mode?: PaymentMode): Promise<PaymentPriceData[]>;
+    createPrice(input: CreatePaymentPriceInput, mode?: PaymentMode): Promise<PaymentPriceData>;
+    prepareActivation(mode?: PaymentMode): Promise<PaymentActivationReview>;
+    activate(reviewId: string, mode?: PaymentMode): Promise<PaymentBindingData>;
+    disable(mode?: PaymentMode): Promise<PaymentBindingData>;
+    checkout(input: CreatePaymentCheckoutInput, mode?: PaymentMode): Promise<PaymentTransactionData>;
+    subscribe(input: CreatePaymentCheckoutInput, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    subscriptions(mode?: PaymentMode): Promise<PaymentSubscriptionData[]>;
+    subscription(id: string, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    cancelSubscription(id: string, mode?: PaymentMode): Promise<PaymentSubscriptionData>;
+    subscriptionPortal(id: string, input: PaymentSubscriptionPortalInput, mode?: PaymentMode): Promise<{
+        url: string;
+    }>;
+    transactions(mode?: PaymentMode): Promise<PaymentTransactionData[]>;
+    refund(id: string, input: RefundPaymentInput, mode?: PaymentMode): Promise<PaymentRefundResult>;
+}
+declare const paymentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"payment.updated">;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    transaction: z.ZodObject<{
+        subscriptionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        periodStart: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        periodEnd: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        id: z.ZodString;
+        bindingId: z.ZodString;
+        orderId: z.ZodString;
+        priceId: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        feeAmount: z.ZodNumber;
+        revision: z.ZodNumber;
+        refundedAmount: z.ZodNumber;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            paid: "paid";
+            refunded: "refunded";
+            partially_refunded: "partially_refunded";
+        }>;
+        checkoutUrl: z.ZodNullable<z.ZodString>;
+        deliveredAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"subscription.updated">;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    subscription: z.ZodObject<{
+        id: z.ZodString;
+        bindingId: z.ZodString;
+        priceId: z.ZodString;
+        orderId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            incomplete: "incomplete";
+            incomplete_expired: "incomplete_expired";
+            trialing: "trialing";
+            active: "active";
+            past_due: "past_due";
+            canceled: "canceled";
+            unpaid: "unpaid";
+            paused: "paused";
+        }>;
+        billingInterval: z.ZodEnum<{
+            month: "month";
+            year: "year";
+        }>;
+        paidThrough: z.ZodNullable<z.ZodString>;
+        cancelAtPeriodEnd: z.ZodBoolean;
+        checkoutUrl: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type PaymentEvent = z.infer<typeof paymentEventSchema>;
+/** Verify the original bytes before parsing JSON. Use only in trusted server code. */
+export declare function verifyPaymentEvent(body: string, signature: string, token: string, mode: PaymentMode, now?: number): Promise<PaymentEvent>;
+export declare class PaymentRuntime {
+    private readonly client;
+    constructor(client: Client);
+    checkout(input: CreatePaymentCheckoutInput): Promise<PaymentTransactionData>;
+    transaction(id: string): Promise<PaymentTransactionData>;
+    subscribe(input: CreatePaymentCheckoutInput): Promise<PaymentSubscriptionData>;
+    subscription(id: string): Promise<PaymentSubscriptionData>;
+    cancelSubscription(id: string): Promise<PaymentSubscriptionData>;
+    subscriptionPortal(id: string, input: PaymentSubscriptionPortalInput): Promise<{
+        url: string;
+    }>;
+    prices(): Promise<PaymentPriceData[]>;
+}
+export {};