@phpsandbox/sdk 0.0.52 → 0.0.54

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

@@ -35,6 +35,8 @@ var PHPSandbox = (() => {
     BeaconTimeoutError: () => BeaconTimeoutError,
     Client: () => Client,
     CommandError: () => CommandError,
+    DeploymentApi: () => DeploymentApi,
+    DeploymentInstance: () => DeploymentInstance,
     ErrorEvent: () => ErrorEvent,
     FileChangeFilter: () => FileChangeFilter,
     FileChangeType: () => FileChangeType,
@@ -45,6 +47,7 @@ var PHPSandbox = (() => {
     LspConnection: () => LspConnection,
     Navigator: () => Navigator,
     NotebookApi: () => NotebookApi,
+    NotebookDeploymentApi: () => NotebookDeploymentApi,
     NotebookInitError: () => NotebookInitError,
     NotebookInstance: () => NotebookInstance,
     NotebookMail: () => NotebookMail,
@@ -2905,15 +2908,15 @@ var PHPSandbox = (() => {
       };
       ReconnectingWebSocket3.prototype._getNextDelay = function() {
         var _a = this._options, _b = _a.reconnectionDelayGrowFactor, reconnectionDelayGrowFactor = _b === void 0 ? DEFAULT.reconnectionDelayGrowFactor : _b, _c = _a.minReconnectionDelay, minReconnectionDelay = _c === void 0 ? DEFAULT.minReconnectionDelay : _c, _d = _a.maxReconnectionDelay, maxReconnectionDelay = _d === void 0 ? DEFAULT.maxReconnectionDelay : _d;
-        var delay = 0;
+        var delay2 = 0;
         if (this._retryCount > 0) {
-          delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
-          if (delay > maxReconnectionDelay) {
-            delay = maxReconnectionDelay;
+          delay2 = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+          if (delay2 > maxReconnectionDelay) {
+            delay2 = maxReconnectionDelay;
           }
         }
-        this._debug("next delay", delay);
-        return delay;
+        this._debug("next delay", delay2);
+        return delay2;
       };
       ReconnectingWebSocket3.prototype._wait = function() {
         var _this = this;
@@ -3882,10 +3885,10 @@ var PHPSandbox = (() => {
       return this.okra.invoke("git.log", { ref });
     }
     diff(input) {
-      return this.okra.invoke("git.diff", input);
+      return this.okra.invoke("git.diff", this.normalizeRemoteInput(input));
     }
     merge(input) {
-      return this.okra.invoke("git.merge", input);
+      return this.okra.invoke("git.merge", this.normalizeRemoteInput(input));
     }
     conflicts() {
       return this.okra.invoke("git.conflicts", {});
@@ -3917,6 +3920,35 @@ var PHPSandbox = (() => {
     status() {
       return this.okra.invoke("git.status", {});
     }
+    normalizeRemoteInput(input) {
+      if (input.notebookId === void 0) {
+        return input;
+      }
+      const notebookId = input.notebookId.trim();
+      if (!notebookId) {
+        throw new Error("'notebookId' cannot be empty.");
+      }
+      if (input.url?.trim()) {
+        throw new Error("Pass either 'url' or 'notebookId', not both.");
+      }
+      if (input.target?.trim()) {
+        throw new Error("Pass either 'target' or 'notebookId', not both.");
+      }
+      const { notebookId: _notebookId, ...payload } = input;
+      return {
+        ...payload,
+        url: this.gitUrlForNotebook(notebookId)
+      };
+    }
+    gitUrlForNotebook(notebookId) {
+      const url = new URL(this.okra.data.gitUrl);
+      url.username = "";
+      url.password = "";
+      url.pathname = `/${encodeURIComponent(notebookId)}.git`;
+      url.search = "";
+      url.hash = "";
+      return url.toString();
+    }
   };
 
   // src/beacon/navigator.ts
@@ -4645,6 +4677,198 @@ var PHPSandbox = (() => {
     }
   }
 
+  // src/deployments.ts
+  var NotebookDeploymentApi = class {
+    constructor(client) {
+      this.client = client;
+    }
+    async create(id, input = {}) {
+      const response = await this.client.post(`/notebook/${id}/deployments`, input);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async list(id) {
+      const response = await this.client.get(`/notebook/${id}/deployments`);
+      return response.data;
+    }
+    async slugAvailability(id, slug) {
+      const query = new URLSearchParams({ slug }).toString();
+      const response = await this.client.get(
+        `/notebook/${id}/deployments/slug-availability?${query}`
+      );
+      return response.data;
+    }
+  };
+  var DeploymentApi = class {
+    constructor(client) {
+      this.client = client;
+    }
+    async get(id) {
+      const response = await this.client.get(`/deployments/${id}`);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async redeploy(id, input = {}) {
+      const response = await this.client.post(`/deployments/${id}/redeploy`, input);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async delete(id) {
+      await this.client.delete(`/deployments/${id}`);
+    }
+    async setProtection(id, input) {
+      const response = await this.client.put(`/deployments/${id}/protection`, input);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async protection(id) {
+      const response = await this.client.get(`/deployments/${id}/protection`);
+      return response.data;
+    }
+    async createProtectionSession(id) {
+      const response = await this.client.post(`/deployments/${id}/protection/session`);
+      return response.data;
+    }
+    async disableProtection(id) {
+      const response = await this.client.delete(`/deployments/${id}/protection`);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async setFeedback(id, input) {
+      const response = await this.client.put(`/deployments/${id}/feedback`, input);
+      return new DeploymentInstance(response.data, this.client);
+    }
+    async listDomains(id) {
+      const response = await this.client.get(
+        `/deployments/${id}/domains`
+      );
+      return unwrapDeploymentDomainCollection(response.data);
+    }
+    async createDomain(id, input) {
+      const response = await this.client.post(`/deployments/${id}/domains`, input);
+      return response.data;
+    }
+    async refreshDomain(id, domainId) {
+      const response = await this.client.post(`/deployments/${id}/domains/${domainId}/refresh`);
+      return response.data;
+    }
+    async deleteDomain(id, domainId) {
+      await this.client.delete(`/deployments/${id}/domains/${domainId}`);
+    }
+    async events(id) {
+      return parseNdjsonStream(await this.client.stream(`/deployments/${id}/events/stream`));
+    }
+    async buildLogs(id, buildId) {
+      return parseNdjsonStream(
+        await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`)
+      );
+    }
+    async logs(id) {
+      return parseNdjsonStream(await this.client.stream(`/deployments/${id}/logs/stream`));
+    }
+  };
+  var DeploymentInstance = class {
+    constructor(data, client) {
+      this.data = data;
+      this.client = client;
+    }
+    refresh() {
+      return this.client.deployments.get(this.data.id);
+    }
+    redeploy(input = {}) {
+      return this.client.deployments.redeploy(this.data.id, input);
+    }
+    delete() {
+      return this.client.deployments.delete(this.data.id);
+    }
+    async wait(options = {}) {
+      const intervalMs = options.intervalMs ?? 1e3;
+      const timeoutMs = options.timeoutMs ?? 3e5;
+      const startedAt = Date.now();
+      let current = this;
+      while (!deploymentStatusIsTerminal(current.data.status)) {
+        if (Date.now() - startedAt > timeoutMs) {
+          throw new Error(`Timed out waiting for deployment ${this.data.id}`);
+        }
+        await delay(intervalMs);
+        current = await current.refresh();
+      }
+      return current;
+    }
+    events() {
+      return this.client.deployments.events(this.data.id);
+    }
+    buildLogs(buildId = this.data.latest_build?.id ?? "") {
+      if (buildId === "") {
+        return Promise.reject(new Error("Deployment has no latest build id"));
+      }
+      return this.client.deployments.buildLogs(this.data.id, buildId);
+    }
+    logs() {
+      return this.client.deployments.logs(this.data.id);
+    }
+    setProtection(input) {
+      return this.client.deployments.setProtection(this.data.id, input);
+    }
+    protection() {
+      return this.client.deployments.protection(this.data.id);
+    }
+    createProtectionSession() {
+      return this.client.deployments.createProtectionSession(this.data.id);
+    }
+    disableProtection() {
+      return this.client.deployments.disableProtection(this.data.id);
+    }
+    setFeedback(input) {
+      return this.client.deployments.setFeedback(this.data.id, input);
+    }
+    domains() {
+      return this.client.deployments.listDomains(this.data.id);
+    }
+    addDomain(input) {
+      return this.client.deployments.createDomain(this.data.id, input);
+    }
+    refreshDomain(domainId) {
+      return this.client.deployments.refreshDomain(this.data.id, domainId);
+    }
+    deleteDomain(domainId) {
+      return this.client.deployments.deleteDomain(this.data.id, domainId);
+    }
+  };
+  function deploymentStatusIsTerminal(status) {
+    return ["healthy", "failed", "stopped", "deleted", "delete_failed"].includes(status);
+  }
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  function unwrapDeploymentDomainCollection(input) {
+    if (Array.isArray(input)) {
+      return input;
+    }
+    return Array.isArray(input.data) ? input.data : [];
+  }
+  function parseNdjsonStream(input) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    return input.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          buffer += decoder.decode(chunk, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed !== "") {
+              controller.enqueue(JSON.parse(trimmed));
+            }
+          }
+        },
+        flush(controller) {
+          buffer += decoder.decode();
+          const trimmed = buffer.trim();
+          if (trimmed !== "") {
+            controller.enqueue(JSON.parse(trimmed));
+          }
+        }
+      })
+    );
+  }
+
   // src/index.ts
   function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
@@ -4665,18 +4889,42 @@ var PHPSandbox = (() => {
   };
   var ApiError = class extends Error {
     constructor(response, body) {
-      super(`PHPSandbox API Error: ${response.status} ${response.statusText} - ${body}`);
+      const data = parseApiErrorBody(body);
+      const apiMessage = apiErrorMessage(data, body);
+      super(`PHPSandbox API Error: ${response.status} ${response.statusText}${apiMessage === "" ? "" : ` - ${apiMessage}`}`);
       this.response = response;
       this.body = body;
       this.status = response.status;
+      this.data = data;
+      this.apiMessage = apiMessage === "" ? void 0 : apiMessage;
     }
   };
+  function parseApiErrorBody(body) {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return null;
+    }
+  }
+  function apiErrorMessage(data, fallback) {
+    if (data !== null && typeof data === "object") {
+      const record = data;
+      if (typeof record.message === "string" && record.message.trim() !== "") {
+        return record.message.trim();
+      }
+      if (record.error !== void 0) {
+        return typeof record.error === "string" ? record.error.trim() : JSON.stringify(record.error);
+      }
+    }
+    return fallback.trim();
+  }
   var NotebookApi = class {
     constructor(client) {
       this.client = client;
       this.secrets = new NotebookSecretApi(client);
       this.preview = new NotebookPreviewApi(client);
       this.mail = new NotebookMailApi(client);
+      this.deployments = new NotebookDeploymentApi(client);
     }
     async create(template, input = {}, init = true) {
       const response = await this.client.post("/notebook", { template, ...input });
@@ -4728,6 +4976,7 @@ var PHPSandbox = (() => {
   var Client = class {
     constructor(token, url = "https://api.phpsandbox.io/v1", options = {}) {
       this.fetch = globalThis.fetch;
+      this.deployments = new DeploymentApi(this);
       this.notebook = new NotebookApi(this);
       this.options = Object.assign({ startClosed: true }, options);
       this.baseUrl = normalizeApiBaseUrl(url);
@@ -4752,6 +5001,21 @@ var PHPSandbox = (() => {
     put(path, body) {
       return this.makeRequest("PUT", path, { body: body === void 0 ? void 0 : JSON.stringify(body) });
     }
+    async stream(path) {
+      const response = await this.fetch(
+        new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
+          method: "GET",
+          headers: this.headers
+        })
+      );
+      if (!response.ok) {
+        throw new ApiError(response, await response.text());
+      }
+      if (!response.body) {
+        throw new Error("PHPSandbox API Error: response body is not readable");
+      }
+      return response.body;
+    }
     async makeRequest(method, path, init) {
       const response = await this.fetch(
         new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
@@ -4898,6 +5162,9 @@ var PHPSandbox = (() => {
     fork(input = {}) {
       return this.client.notebook.fork(this.data.id, input);
     }
+    deploy(input = {}) {
+      return this.client.notebook.deployments.create(this.data.id, input);
+    }
     gitCredentials() {
       return this.client.notebook.gitCredentials(this.data.id);
     }