@phpsandbox/sdk 0.0.67 → 0.1.1

package/dist/{deployments.js → publications.js}

@@ -1,14 +1,14 @@
 import { ApiError } from './index.js';
-import { DeploymentEventDataSchema, DeploymentLogChunkDataSchema, DeployStreamSseEventNameSchema, DeployStreamSseEventSchema, } from './schemas/deployments.js';
-export * from './schemas/deployments.js';
-export class NotebookDeploymentApi {
+import { PublicationEventDataSchema, PublicationLogChunkDataSchema, PublishStreamSseEventNameSchema, PublishStreamSseEventSchema, } from './schemas/publications.js';
+export * from './schemas/publications.js';
+export class NotebookPublicationApi {
     constructor(client) {
         this.client = client;
     }
     async current(notebookId) {
         try {
-            const response = await this.client.get(`/notebook/${notebookId}/deployment`);
-            return new DeploymentInstance(response.data, this.client, notebookId);
+            const response = await this.client.get(`/notebook/${notebookId}/publication`);
+            return new PublicationInstance(response.data, this.client, notebookId);
         }
         catch (error) {
             if (error instanceof ApiError && error.status === 404) {
@@ -18,74 +18,69 @@ export class NotebookDeploymentApi {
         }
     }
     async publish(notebookId, input) {
-        const response = await this.client.post(`/notebook/${notebookId}/deployment/publish`, input);
-        const run = new DeploymentRun(new DeploymentInstance(response.data, this.client, notebookId), this.client);
+        const response = await this.client.post(`/notebook/${notebookId}/publication`, input);
+        const run = new PublicationRun(new PublicationInstance(response.data, this.client, notebookId), this.client);
         run.start();
         return run;
     }
-    async slugAvailability(id, slug) {
-        const query = new URLSearchParams({ slug }).toString();
-        const response = await this.client.get(`/notebook/${id}/deployment/slug-availability?${query}`);
-        return response.data;
-    }
 }
-export class DeploymentApi {
+export class PublicationApi {
     constructor(client) {
         this.client = client;
     }
     async get(id) {
-        const response = await this.client.get(`/deployments/${id}`);
-        return new DeploymentInstance(response.data, this.client);
+        const response = await this.client.get(`/publications/${id}`);
+        return new PublicationInstance(response.data, this.client);
     }
-    async delete(id) {
-        await this.client.delete(`/deployments/${id}`);
+    async destroy(id) {
+        await this.client.delete(`/publications/${id}`);
     }
     async setProtection(id, input) {
-        const response = await this.client.put(`/deployments/${id}/protection`, input);
-        return new DeploymentInstance(response.data, this.client);
+        const response = await this.client.put(`/publications/${id}/protection`, input);
+        return new PublicationInstance(response.data, this.client);
     }
     async protection(id) {
-        const response = await this.client.get(`/deployments/${id}/protection`);
+        const response = await this.client.get(`/publications/${id}/protection`);
         return response.data;
     }
     async createProtectionSession(id) {
-        const response = await this.client.post(`/deployments/${id}/protection/session`);
+        const response = await this.client.post(`/publications/${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);
+        const response = await this.client.delete(`/publications/${id}/protection`);
+        return new PublicationInstance(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);
+        const response = await this.client.put(`/publications/${id}/feedback`, input);
+        return new PublicationInstance(response.data, this.client);
     }
     async listDomains(id) {
-        const response = await this.client.get(`/deployments/${id}/domains`);
-        return unwrapDeploymentDomainCollection(response.data);
+        const response = await this.client.get(`/publications/${id}/domains`);
+        return unwrapPublicationDomainCollection(response.data);
     }
     async createDomain(id, input) {
-        const response = await this.client.post(`/deployments/${id}/domains`, input);
+        const response = await this.client.post(`/publications/${id}/domains`, input);
         return response.data;
     }
     async refreshDomain(id, domainId) {
-        const response = await this.client.post(`/deployments/${id}/domains/${domainId}/refresh`);
+        const response = await this.client.post(`/publications/${id}/domains/${domainId}/refresh`);
         return response.data;
     }
     async deleteDomain(id, domainId) {
-        await this.client.delete(`/deployments/${id}/domains/${domainId}`);
+        await this.client.delete(`/publications/${id}/domains/${domainId}`);
     }
     async events(id) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/events/stream`), DeploymentEventDataSchema);
+        return parseNdjsonStream(await this.client.stream(`/publications/${id}/events/stream`), PublicationEventDataSchema);
     }
     async buildLogs(id, buildId) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`), DeploymentLogChunkDataSchema);
+        return parseNdjsonStream(await this.client.stream(`/publications/${id}/builds/${buildId}/logs/stream`), PublicationLogChunkDataSchema);
     }
     async logs(id) {
-        return parseNdjsonStream(await this.client.stream(`/deployments/${id}/logs/stream`), DeploymentLogChunkDataSchema);
+        return parseNdjsonStream(await this.client.stream(`/publications/${id}/logs/stream`), PublicationLogChunkDataSchema);
     }
 }
-export class DeploymentRun {
+export class PublicationRun {
     constructor(initial, client) {
         this.initial = initial;
         this.client = client;
@@ -116,7 +111,7 @@ export class DeploymentRun {
         this.start();
         return this.resultPromise;
     }
-    async deployment() {
+    async publication() {
         await this.result();
         return this.initial.refresh();
     }
@@ -124,9 +119,9 @@ export class DeploymentRun {
         if (this.started) {
             return this;
         }
-        const eventStreamUrl = this.initial.data.eventStreamUrl ?? this.initial.data.okraUrl;
+        const eventStreamUrl = this.initial.data.eventStreamUrl;
         if (!eventStreamUrl) {
-            throw new Error(`Deployment ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
+            throw new Error(`Publication ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
         }
         this.started = true;
         this.resultPromise = new Promise((resolve, reject) => {
@@ -138,7 +133,7 @@ export class DeploymentRun {
         return this;
     }
     subscribe() {
-        const queue = new AsyncDeployEventQueue();
+        const queue = new AsyncPublishEventQueue();
         for (const event of this.bufferedEvents) {
             queue.push(event);
         }
@@ -156,7 +151,7 @@ export class DeploymentRun {
     async consumeStream(eventStreamUrl) {
         try {
             const stream = await this.client.sse(eventStreamUrl);
-            for await (const event of readDeployStreamEvents(stream)) {
+            for await (const event of readPublishStreamEvents(stream)) {
                 this.publish(event);
                 if (event.type === 'result') {
                     const { type: _, ...result } = event;
@@ -165,7 +160,7 @@ export class DeploymentRun {
                 }
             }
             if (!this.finalResult) {
-                throw new Error('Deploy stream ended without result');
+                throw new Error('Publish stream ended without result');
             }
             this.closeSubscribers();
         }
@@ -196,33 +191,33 @@ export class DeploymentRun {
         this.subscribers.clear();
     }
 }
-export class DeploymentInstance {
+export class PublicationInstance {
     constructor(data, client, notebookId) {
         this.data = data;
         this.client = client;
         this.notebookId = notebookId;
     }
     async refresh() {
-        const response = await this.client.get(`/deployments/${this.data.id}`);
-        return new DeploymentInstance(response.data, this.client, this.notebookId);
+        const response = await this.client.get(`/publications/${this.data.id}`);
+        return new PublicationInstance(response.data, this.client, this.notebookId);
     }
     publish() {
         if (!this.notebookId) {
-            return Promise.reject(new Error('Deployment publish requires a notebook-scoped deployment instance.'));
+            return Promise.reject(new Error('Publishing requires a notebook-scoped publication instance.'));
         }
-        return this.client.notebook.deployment.publish(this.notebookId);
+        return this.client.notebook.publication.publish(this.notebookId);
     }
-    delete() {
-        return this.client.deployments.delete(this.data.id);
+    destroy() {
+        return this.client.publications.destroy(this.data.id);
     }
     async wait(options = {}) {
         const intervalMs = options.intervalMs ?? 1000;
         const timeoutMs = options.timeoutMs ?? 300000;
         const startedAt = Date.now();
         let current = this;
-        while (!deploymentStatusIsTerminal(current.data.status)) {
+        while (!publicationStatusIsTerminal(current.data.status)) {
             if (Date.now() - startedAt > timeoutMs) {
-                throw new Error(`Timed out waiting for deployment ${this.data.id}`);
+                throw new Error(`Timed out waiting for publication ${this.data.id}`);
             }
             await delay(intervalMs);
             current = await current.refresh();
@@ -230,58 +225,58 @@ export class DeploymentInstance {
         return current;
     }
     events() {
-        return this.client.deployments.events(this.data.id);
+        return this.client.publications.events(this.data.id);
     }
     buildLogs(buildId = this.data.latestBuild?.id ?? '') {
         if (buildId === '') {
-            return Promise.reject(new Error('Deployment has no latest build id'));
+            return Promise.reject(new Error('Publication has no latest build id'));
         }
-        return this.client.deployments.buildLogs(this.data.id, buildId);
+        return this.client.publications.buildLogs(this.data.id, buildId);
     }
     logs() {
-        return this.client.deployments.logs(this.data.id);
+        return this.client.publications.logs(this.data.id);
     }
     setProtection(input) {
-        return this.client.deployments.setProtection(this.data.id, input);
+        return this.client.publications.setProtection(this.data.id, input);
     }
     protection() {
-        return this.client.deployments.protection(this.data.id);
+        return this.client.publications.protection(this.data.id);
     }
     createProtectionSession() {
-        return this.client.deployments.createProtectionSession(this.data.id);
+        return this.client.publications.createProtectionSession(this.data.id);
     }
     disableProtection() {
-        return this.client.deployments.disableProtection(this.data.id);
+        return this.client.publications.disableProtection(this.data.id);
     }
     setFeedback(input) {
-        return this.client.deployments.setFeedback(this.data.id, input);
+        return this.client.publications.setFeedback(this.data.id, input);
     }
     domains() {
-        return this.client.deployments.listDomains(this.data.id);
+        return this.client.publications.listDomains(this.data.id);
     }
     addDomain(input) {
-        return this.client.deployments.createDomain(this.data.id, input);
+        return this.client.publications.createDomain(this.data.id, input);
     }
     refreshDomain(domainId) {
-        return this.client.deployments.refreshDomain(this.data.id, domainId);
+        return this.client.publications.refreshDomain(this.data.id, domainId);
     }
     deleteDomain(domainId) {
-        return this.client.deployments.deleteDomain(this.data.id, domainId);
+        return this.client.publications.deleteDomain(this.data.id, domainId);
     }
 }
-function deploymentStatusIsTerminal(status) {
+function publicationStatusIsTerminal(status) {
     return ['healthy', 'failed', 'stopped', 'deleted', 'delete_failed'].includes(status);
 }
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function unwrapDeploymentDomainCollection(input) {
+function unwrapPublicationDomainCollection(input) {
     if (Array.isArray(input)) {
         return input;
     }
     return Array.isArray(input.data) ? input.data : [];
 }
-class AsyncDeployEventQueue {
+class AsyncPublishEventQueue {
     constructor() {
         this.values = [];
         this.pending = [];
@@ -343,7 +338,7 @@ class AsyncDeployEventQueue {
         });
     }
 }
-async function* readDeployStreamEvents(stream) {
+async function* readPublishStreamEvents(stream) {
     const reader = parseSSEStream(stream).getReader();
     try {
         while (true) {
@@ -351,7 +346,7 @@ async function* readDeployStreamEvents(stream) {
             if (done) {
                 return;
             }
-            const event = parseDeployStreamEvent(value);
+            const event = parsePublishStreamEvent(value);
             if (event) {
                 yield event;
             }
@@ -361,11 +356,11 @@ async function* readDeployStreamEvents(stream) {
         reader.releaseLock();
     }
 }
-function parseDeployStreamEvent(event) {
-    if (!DeployStreamSseEventNameSchema.safeParse(event.event).success) {
+function parsePublishStreamEvent(event) {
+    if (!PublishStreamSseEventNameSchema.safeParse(event.event).success) {
         return null;
     }
-    return DeployStreamSseEventSchema.parse(event);
+    return PublishStreamSseEventSchema.parse(event);
 }
 function parseSSEStream(input) {
     const decoder = new TextDecoder();

package/dist/repl.d.ts

@@ -17,7 +17,6 @@ export interface ReplActions {
         input: string;
     }>;
     'repl.stop': Action<{}, void>;
-    'repl.start': Action<{}>;
     'repl.resize': Action<{
         cols: number;
         rows: number;
@@ -32,7 +31,6 @@ export default class Repl {
     eval(code: string, args?: string, repl?: ReplOption): Promise<EvalResult>;
     write(input: string): Promise<void>;
     stop(): Promise<void>;
-    start(): Promise<void>;
     resize(cols: number, rows: number): Promise<void>;
     listen<T extends keyof ReplEvents>(event: T, handler: (data: ReplEvents[T]) => void): Disposable;
     onOutput(handler: (data: ReplEvents['repl.output']) => void): Disposable;

package/dist/repl.js

@@ -11,9 +11,6 @@ export default class Repl {
     stop() {
         return this.okra.invoke('repl.stop');
     }
-    start() {
-        return this.okra.invoke('repl.start');
-    }
     resize(cols, rows) {
         return this.okra.invoke('repl.resize', { cols, rows });
     }

package/dist/runtime/rest.js

@@ -62,7 +62,7 @@ export class RestRuntimeInvoker {
         this.refresh = refresh;
         this.refreshPromise = null;
         this.notebookId = data.id;
-        this.configure(data.runtimeUrl ?? data.okraUrl);
+        this.configure(data.runtimeUrl);
     }
     configure(runtimeUrl) {
         const actionUrl = new URL(runtimeUrl);