@phpsandbox/sdk 0.3.4 → 0.4.0

package/dist/payments.js

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+export const DEFAULT_PAYMENT_CALLBACK_PATH = '/api/phpsandbox-payments/events';
+export const paymentModeSchema = z.enum(['test', 'live']);
+const accountSchema = z.object({
+    id: z.string(),
+    mode: paymentModeSchema,
+    chargesEnabled: z.boolean(),
+    payoutsEnabled: z.boolean(),
+    detailsSubmitted: z.boolean(),
+    requirements: z.array(z.string()),
+    disabledReason: z.string().nullable(),
+});
+const accessSchema = z.object({
+    subscribed: z.boolean(),
+    liveAllowed: z.boolean(),
+    testConfigured: z.boolean(),
+    liveConfigured: z.boolean(),
+    feeBasisPoints: z.number().int().min(0).max(10000).nullable(),
+    canRead: z.boolean(),
+    canManage: z.boolean(),
+    canRefund: z.boolean(),
+    recoveryEndsAt: z.string().nullable().default(null),
+});
+const applicationsSchema = z.object({
+    notebookId: z.string(),
+    applications: z.array(z.object({
+        id: z.string(),
+        url: z.string().nullable(),
+        healthy: z.boolean(),
+        passwordProtected: z.boolean(),
+        deployedAt: z.string().datetime().nullable(),
+    })),
+});
+const bindingSchema = z.object({
+    id: z.string(),
+    notebookId: z.string(),
+    applicationId: z.string().nullable(),
+    mode: paymentModeSchema,
+    revision: z.number().int(),
+    accountId: z.string(),
+    enabled: z.boolean(),
+    callbackUrl: z.string().nullable(),
+    originUrl: z.string().nullable(),
+    runtimeConfigured: z.boolean(),
+});
+const priceSchema = z.object({
+    billingInterval: z.enum(['month', 'year']).nullable().default(null),
+    id: z.string(),
+    name: z.string(),
+    amount: z.number().int(),
+    currency: z.string(),
+    bindingId: z.string(),
+});
+const transactionSchema = z.object({
+    subscriptionId: z.string().nullable().default(null),
+    periodStart: z.string().datetime({ offset: true }).nullable().default(null),
+    periodEnd: z.string().datetime({ offset: true }).nullable().default(null),
+    id: z.string(),
+    bindingId: z.string(),
+    orderId: z.string(),
+    priceId: z.string(),
+    amount: z.number().int(),
+    currency: z.string(),
+    feeAmount: z.number().int(),
+    revision: z.number().int(),
+    refundedAmount: z.number().int(),
+    status: z.enum(['pending', 'paid', 'failed', 'refunded', 'partially_refunded']),
+    checkoutUrl: z.string().nullable(),
+    deliveredAt: z.string().nullable(),
+});
+const subscriptionSchema = z.object({
+    id: z.string(),
+    bindingId: z.string(),
+    priceId: z.string(),
+    orderId: z.string(),
+    status: z.enum([
+        'pending',
+        'incomplete',
+        'incomplete_expired',
+        'trialing',
+        'active',
+        'past_due',
+        'canceled',
+        'unpaid',
+        'paused',
+    ]),
+    billingInterval: z.enum(['month', 'year']),
+    paidThrough: z.string().datetime({ offset: true }).nullable(),
+    cancelAtPeriodEnd: z.boolean(),
+    checkoutUrl: z.string().nullable(),
+    revision: z.number().int(),
+});
+const portalSchema = z.object({ url: z.string().url() });
+const refundResultSchema = transactionSchema.extend({
+    refund: z.object({
+        id: z.string(),
+        amount: z.number().int().positive(),
+        status: z.enum(['pending', 'succeeded', 'failed', 'canceled', 'requires_action']),
+    }),
+});
+const activationSchema = z.object({
+    revision: z.number().int(),
+    reviewId: z.string(),
+    expiresAt: z.string(),
+    blockers: z.array(z.string()),
+    binding: bindingSchema,
+    account: accountSchema,
+    feeBasisPoints: z.number().int().nullable(),
+    prices: z.array(priceSchema),
+});
+export class PaymentsApi {
+    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 z.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 z
+            .object({ url: z.string().url(), expiresAt: z.string() })
+            .parse((await this.client.post(`/platform/payments/accounts/${mode}/onboarding`, {})).data);
+    }
+}
+export class NotebookPayments {
+    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 z.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 z.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 z.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);
+    }
+}
+const paymentEventSchema = z.discriminatedUnion('type', [
+    z.object({
+        id: z.string(),
+        type: z.literal('payment.updated'),
+        mode: paymentModeSchema,
+        transaction: transactionSchema,
+    }),
+    z.object({
+        id: z.string(),
+        type: z.literal('subscription.updated'),
+        mode: paymentModeSchema,
+        subscription: subscriptionSchema,
+    }),
+]);
+/** Verify the original bytes before parsing JSON. Use only in trusted server code. */
+export 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) * 1000) > 300000 || 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;
+}
+export class PaymentRuntime {
+    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 z.array(priceSchema).parse((await this.client.get('/platform/payments/runtime/prices')).data);
+    }
+}

package/dist/servers.d.ts

@@ -20,6 +20,16 @@ export interface ServerMemberData {
     email: string;
     access: 'deployer';
 }
+export interface ServerInvitationData {
+    recipientOrganizationId: string | null;
+    id: string;
+    serverId: string;
+    serverName: string;
+    email: string;
+    status: 'pending' | 'accepting' | 'accepted' | 'declined' | 'cancelled' | 'expired';
+    expiresAt: string;
+    createdAt: string;
+}
 export interface ServerSshOptions {
     user?: string;
     port?: number;
@@ -32,9 +42,23 @@ export interface CreateServerInput {
 export interface ServerListOptions {
     page?: number;
 }
+export interface ServerInvitationTarget {
+    email: string;
+    organizationId?: never;
+    requestId?: string;
+}
+export interface ServerOrganizationTarget {
+    organizationId: string;
+    email?: never;
+    requestId?: string;
+}
+export type ShareServerInput = ServerInvitationTarget | ServerOrganizationTarget;
 export declare class ServerApi {
     private readonly client;
     constructor(client: Client);
+    inspectInvitation(id: string, token: string): Promise<ServerInvitationData>;
+    acceptInvitation(id: string, token: string): Promise<ServerInvitationData>;
+    declineInvitation(id: string, token: string): Promise<ServerInvitationData>;
     list(options?: ServerListOptions): Promise<PaginatedApiResponse<ServerData>>;
     create(input: CreateServerInput): Promise<ServerInstance>;
     get(id: string): Promise<ServerInstance>;
@@ -47,9 +71,13 @@ export declare class ServerInstance {
         installCommand: string;
     }>;
     members(options?: ServerListOptions): Promise<PaginatedApiResponse<ServerMemberData>>;
-    share(email: string): Promise<ServerMemberData>;
-    shareWithOrganization(organizationId: string): Promise<ServerMemberData>;
+    share(target: ServerInvitationTarget): Promise<ServerInvitationData>;
+    share(target: ServerOrganizationTarget): Promise<ServerMemberData>;
+    share(target: ShareServerInput): Promise<ServerInvitationData | ServerMemberData>;
     revokeAccess(memberId: number): Promise<void>;
+    invitations(options?: ServerListOptions): Promise<PaginatedApiResponse<ServerInvitationData>>;
+    cancelInvitation(id: string): Promise<ServerInvitationData>;
+    resendInvitation(id: string): Promise<ServerInvitationData>;
     refresh(): Promise<ServerInstance>;
     delete(): Promise<void>;
     waitReady(options?: {

package/dist/servers.js

@@ -1,7 +1,17 @@
+import { PHPSandboxError } from './errors/index.js';
 export class ServerApi {
     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 === undefined ? '' : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
         return this.client.get(`/servers${query}`);
@@ -27,16 +37,33 @@ export class ServerInstance {
         const query = options.page === undefined ? '' : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
         return this.client.get(`/servers/${encodeURIComponent(this.data.id)}/members${query}`);
     }
-    async share(email) {
-        return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { email })).data;
-    }
-    async shareWithOrganization(organizationId) {
-        return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { organizationId }))
-            .data;
+    async share(target) {
+        if (target.email !== undefined) {
+            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 === undefined ? '' : `?${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 === undefined) {
+            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);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phpsandbox/sdk",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "The TypeScript SDK for PHPSandbox cloud development environments",
   "keywords": [
     "cloud",