@phpsandbox/sdk 0.1.6 → 0.1.10

package/dist/composer.d.ts

@@ -1,5 +1,5 @@
-import { ComposerCredentials, type Action, type Client, type NotebookInstance } from './index.js';
-import { ProcessResult, type ProcessOutputChunk, type ProcessOutputSource, type ProcessResultData } from './shell.js';
+import type { Action, Client, ComposerCredentialInfo, ComposerCredentialInput, ComposerCredentialType, NotebookInstance } from './index.js';
+import { type ProcessOutputChunk, type ProcessOutputSource, type ProcessResult } from './shell.js';
 export interface ComposerEventData {
     'composer.output': {
         id: string;
@@ -23,7 +23,7 @@ export interface ComposerActions {
         command: ComposerCommand;
         args: Argument;
         options: Options;
-    }, ProcessResultData>;
+    }, ProcessResult>;
     'composer.kill': Action<{
         id: string;
     }, boolean>;
@@ -32,6 +32,13 @@ export interface ComposerActions {
 export type ComposerCommand = 'install' | 'update' | 'require' | 'remove' | 'search' | 'show' | 'dump-autoload';
 export type Argument<Name extends string = string, Type extends string | string[] = string | string[]> = Record<Name, Type>;
 export type Options<Name extends string = string, Type extends string | string[] | boolean = string | string[] | boolean> = Record<Name, Type>;
+declare class ComposerCredentials {
+    private readonly client;
+    private readonly notebookId;
+    constructor(client: Client, notebookId: string);
+    set(input: ComposerCredentialInput): Promise<ComposerCredentialInfo>;
+    remove(type: ComposerCredentialType, url?: string): Promise<void>;
+}
 export declare class ComposerProcess {
     readonly id: string;
     private readonly okra;
@@ -48,11 +55,6 @@ export default class Composer {
     readonly credentials: ComposerCredentials;
     constructor(okra: NotebookInstance, client: Client);
     run(command: ComposerCommand, args?: Argument, options?: Options): ComposerProcess;
-    dumpAutoload(options?: Options): ComposerProcess;
-    install(options?: Options): ComposerProcess;
-    update(args: Argument<'packages'>, options?: Options): ComposerProcess;
-    require(packages: Argument<'packages'>, options?: Options): ComposerProcess;
-    remove(args: Argument<'packages'>, options?: Options): ComposerProcess;
     packages(): Promise<ComposerPackage[]>;
 }
 export {};

package/dist/composer.js

@@ -1,6 +1,21 @@
-import { ComposerCredentials } from './index.js';
-import { ProcessReadable, ProcessResult, } from './shell.js';
+import { ProcessReadable, } from './shell.js';
 import { nanoid } from 'nanoid';
+class ComposerCredentials {
+    constructor(client, notebookId) {
+        this.client = client;
+        this.notebookId = notebookId;
+    }
+    async set(input) {
+        const response = await this.client.put(`/notebook/${this.notebookId}/composer/credentials`, input);
+        return response.data;
+    }
+    async remove(type, url) {
+        const params = new URLSearchParams({ type });
+        if (url)
+            params.set('url', url);
+        await this.client.delete(`/notebook/${this.notebookId}/composer/credentials?${params.toString()}`);
+    }
+}
 export class ComposerProcess {
     constructor(id, okra, command, args, options) {
         this.id = id;
@@ -39,7 +54,7 @@ export class ComposerProcess {
         };
         this.completion = this.okra.invoke('composer.invoke', { id, command, args, options }).then((result) => {
             finish();
-            return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+            return result;
         }).catch((error) => {
             fail(error);
             throw error;
@@ -60,21 +75,6 @@ export default class Composer {
     run(command, args = {}, options = {}) {
         return new ComposerProcess(nanoid(), this.okra, command, args, options);
     }
-    dumpAutoload(options = {}) {
-        return this.run('dump-autoload', {}, options);
-    }
-    install(options = {}) {
-        return this.run('install', {}, options);
-    }
-    update(args, options = {}) {
-        return this.run('update', args, options);
-    }
-    require(packages, options = {}) {
-        return this.run('require', packages, options);
-    }
-    remove(args, options = {}) {
-        return this.run('remove', args, options);
-    }
     packages() {
         return this.okra.invoke('composer.packages');
     }

package/dist/errors/index.d.ts

@@ -1,14 +1,49 @@
+export type RemoteErrorSource = 'core' | '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';
+export interface ValidationErrorDetails {
+    errors: Record<string, string[]>;
+}
+export interface RemoteErrorOptions<TCode extends RemoteErrorCode = RemoteErrorCode, TDetails = unknown> {
+    source: RemoteErrorSource;
+    status: number;
+    code: TCode;
+    details?: TDetails;
+    cause?: unknown;
+}
+export declare class PHPSandboxError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class RemoteError<TCode extends RemoteErrorCode = RemoteErrorCode, TDetails = unknown> extends PHPSandboxError {
+    readonly source: RemoteErrorSource;
+    readonly status: number;
+    readonly code: TCode;
+    readonly details: TDetails | undefined;
+    constructor(message: string, options: RemoteErrorOptions<TCode, TDetails>);
+    static is(error: unknown): error is RemoteError;
+    static is<TCode extends RemoteErrorCode>(error: unknown, code: TCode): error is RemoteError<TCode>;
+    static isValidation(error: unknown): error is RemoteError<'ValidationFailed', ValidationErrorDetails> & {
+        readonly details: ValidationErrorDetails;
+    };
+    is<TExpectedCode extends RemoteErrorCode>(code: TExpectedCode): this is this & RemoteError<TExpectedCode>;
+}
+export declare class TransportError<TCode extends TransportErrorCode = TransportErrorCode> extends PHPSandboxError {
+    readonly code: TCode;
+    constructor(message: string, code: TCode, cause?: unknown);
+    static is(error: unknown): error is TransportError;
+    static is<TCode extends TransportErrorCode>(error: unknown, code: TCode): error is TransportError<TCode>;
+    is<TExpectedCode extends TransportErrorCode>(code: TExpectedCode): this is this & TransportError<TExpectedCode>;
+}
+export declare function remoteError(source: RemoteErrorSource, payload: unknown, cause?: unknown): RemoteError;
 export declare class PromiseTimeoutError extends Error {
     time: number;
     constructor(message: string, time: number);
 }
-export declare class SendTimeoutError extends PromiseTimeoutError {
+export declare class SendTimeoutError extends TransportError<'SendTimeout'> {
+    readonly time: number;
     static fromPromiseTimeoutError(error: PromiseTimeoutError): SendTimeoutError;
+    constructor(message: string, time: number, cause?: unknown);
 }
-export declare class NotebookUnavailableError extends Error {
-    readonly raw: object;
-    constructor(message?: string, raw?: object);
-}
-export declare class UnsupportedRuntimeTransportError extends Error {
-    constructor(message: string);
-}
+export {};

package/dist/errors/index.js

@@ -1,24 +1,130 @@
-export class PromiseTimeoutError extends Error {
-    constructor(message, time) {
+const remoteErrorCodes = [
+    '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 class PHPSandboxError extends Error {
+    constructor(message, cause) {
         super(message);
-        this.time = time;
+        this.name = new.target.name;
+        this.cause = cause;
     }
 }
-export class SendTimeoutError extends PromiseTimeoutError {
-    static fromPromiseTimeoutError(error) {
-        return new SendTimeoutError(error.message, error.time);
+export class RemoteError extends PHPSandboxError {
+    constructor(message, options) {
+        super(message, options.cause);
+        this.source = options.source;
+        this.status = options.status;
+        this.code = options.code;
+        this.details = options.details;
+    }
+    static is(error, code) {
+        return error instanceof RemoteError && (code === undefined || error.code === code);
+    }
+    static isValidation(error) {
+        return RemoteError.is(error, 'ValidationFailed') && validationDetails(error.details) !== undefined;
+    }
+    is(code) {
+        return this.code === code;
     }
 }
-export class NotebookUnavailableError extends Error {
-    constructor(message = 'Notebook is no longer available', raw = {}) {
-        super(message);
-        this.raw = raw;
-        this.name = 'NotebookUnavailableError';
+export class TransportError extends PHPSandboxError {
+    constructor(message, code, cause) {
+        super(message, cause);
+        this.code = code;
+    }
+    static is(error, code) {
+        return error instanceof TransportError && (code === undefined || error.code === code);
+    }
+    is(code) {
+        return this.code === code;
+    }
+}
+export function remoteError(source, payload, cause) {
+    const error = record(payload);
+    const status = positiveInteger(error?.status);
+    const code = nonEmptyString(error?.code);
+    const message = nonEmptyString(error?.message);
+    if (status === undefined || !isRemoteErrorCode(code) || message === undefined) {
+        throw new TransportError('PHPSandbox returned an invalid error response.', 'InvalidResponse', cause ?? payload);
+    }
+    return new RemoteError(message, {
+        source,
+        status,
+        code,
+        details: error?.details,
+        cause,
+    });
+}
+function isRemoteErrorCode(value) {
+    return typeof value === 'string' && remoteErrorCodes.includes(value);
+}
+function positiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringArrayRecord(value) {
+    const candidate = record(value);
+    if (candidate === undefined) {
+        return undefined;
     }
+    const entries = Object.entries(candidate);
+    if (!entries.every(([, messages]) => Array.isArray(messages) && messages.every((message) => typeof message === 'string'))) {
+        return undefined;
+    }
+    return Object.fromEntries(entries);
+}
+function validationDetails(value) {
+    const details = record(value);
+    const errors = stringArrayRecord(details?.errors);
+    return errors === undefined ? undefined : { errors };
 }
-export class UnsupportedRuntimeTransportError extends Error {
-    constructor(message) {
+export class PromiseTimeoutError extends Error {
+    constructor(message, time) {
         super(message);
-        this.name = 'UnsupportedRuntimeTransportError';
+        this.time = time;
+    }
+}
+export class SendTimeoutError extends TransportError {
+    static fromPromiseTimeoutError(error) {
+        return new SendTimeoutError(error.message, error.time, error);
+    }
+    constructor(message, time, cause) {
+        super(message, 'SendTimeout', cause);
+        this.time = time;
     }
 }

package/dist/feedback.js

@@ -21,8 +21,7 @@ export class Feedback {
             if (value !== undefined)
                 query.set(name, String(value));
         }
-        const response = await this.client.get(`${this.path()}${query.size === 0 ? '' : `?${query.toString()}`}`);
-        return response.data;
+        return this.client.get(`${this.path()}${query.size === 0 ? '' : `?${query.toString()}`}`);
     }
     async get(id) {
         const response = await this.client.get(this.path(`/${encodeURIComponent(id)}`));

package/dist/filesystem.d.ts

@@ -1,12 +1,7 @@
 import type { Action, Disposable, NotebookInstance } from './index.js';
-import { ErrorEvent } from './types.js';
 export interface FileResult {
     name: string;
     directory: string;
-    relativePath: string;
-    /**
-     * Same value as `relativePath`.
-     */
     path: string;
 }
 export declare enum FileType {
@@ -470,18 +465,6 @@ type PrefixKey<K extends keyof FilesystemEventData> = `${K}.${string}`;
 export type FilesystemEvents = FilesystemEventData & {
     [K in keyof FilesystemEventData as PrefixKey<K>]: FilesystemEventData[K];
 };
-export declare enum FilesystemErrorType {
-    Unavailable = "Unavailable",
-    NoPermissions = "NoPermissions",
-    FileExists = "FileExists",
-    FileNotFound = "FileNotFound",
-    FileIsADirectory = "FileIsADirectory",
-    FileNotADirectory = "FileNotADirectory"
-}
-export declare class FilesystemError extends ErrorEvent {
-    readonly name: FilesystemErrorType;
-    constructor(inner: ErrorEvent, name: FilesystemErrorType);
-}
 declare class FilesystemSubscription {
     private disposable;
     private onDispose;

package/dist/filesystem.js

@@ -1,5 +1,4 @@
-import { UnsupportedRuntimeTransportError } from './errors/index.js';
-import { ErrorEvent } from './types.js';
+import { PHPSandboxError } from './errors/index.js';
 import { nanoid } from 'nanoid';
 export var FileType;
 (function (FileType) {
@@ -39,21 +38,6 @@ export var FileChangeType;
     FileChangeType[FileChangeType["ADDED"] = 2] = "ADDED";
     FileChangeType[FileChangeType["DELETED"] = 3] = "DELETED";
 })(FileChangeType || (FileChangeType = {}));
-export var FilesystemErrorType;
-(function (FilesystemErrorType) {
-    FilesystemErrorType["Unavailable"] = "Unavailable";
-    FilesystemErrorType["NoPermissions"] = "NoPermissions";
-    FilesystemErrorType["FileExists"] = "FileExists";
-    FilesystemErrorType["FileNotFound"] = "FileNotFound";
-    FilesystemErrorType["FileIsADirectory"] = "FileIsADirectory";
-    FilesystemErrorType["FileNotADirectory"] = "FileNotADirectory";
-})(FilesystemErrorType || (FilesystemErrorType = {}));
-export class FilesystemError extends ErrorEvent {
-    constructor(inner, name) {
-        super(inner.code, inner.message);
-        this.name = name;
-    }
-}
 class FilesystemSubscription {
     constructor(disposable, onDispose) {
         this.disposable = disposable;
@@ -209,7 +193,7 @@ export class Filesystem {
         if (this.okra.runtimeTransport === 'rest') {
             return new ReadableStream({
                 start(controller) {
-                    controller.error(new UnsupportedRuntimeTransportError('Following files requires the realtime transport.'));
+                    controller.error(new PHPSandboxError('Following files requires the realtime transport.'));
                 },
             });
         }
@@ -439,9 +423,6 @@ export class Filesystem {
         return this.okra.invoke('fs.tree', { path });
     }
     handleError(e) {
-        if (e instanceof ErrorEvent && 'name' in e.raw) {
-            throw new FilesystemError(e, e.raw.name);
-        }
         throw e;
     }
 }

package/dist/git.d.ts

@@ -62,7 +62,6 @@ export interface GitTargetConfiguration {
     branch?: string;
     setDefault?: boolean;
 }
-export type CreateGitTargetInput = GitTargetConfiguration;
 export interface GitSyncExistingTargetInput {
     direction?: GitSyncDirection;
     author?: GitSyncAuthor;
@@ -175,8 +174,6 @@ export interface GitResolveResult {
     ref?: string;
     message: string;
 }
-export interface GitEvents {
-}
 export interface GitActions {
     'git.checkpoint': Action<{
         author: string;
@@ -239,10 +236,9 @@ export declare class GitTargetApi {
     private readonly notebookId;
     private readonly client;
     constructor(notebookId: string, client: Client);
-    create(input: CreateGitTargetInput): Promise<GitTarget>;
+    create(input: GitTargetConfiguration): Promise<GitTarget>;
     list(): Promise<GitTarget[]>;
     get(target: GitTargetReference): Promise<GitTarget>;
-    sync(target: GitTargetReference, input?: GitSyncExistingTargetInput): Promise<GitTarget>;
 }
 export declare class GitTarget {
     readonly data: GitTargetData;

package/dist/git.js

@@ -40,8 +40,9 @@ export default class Git {
     revert(input) {
         return this.okra.invoke('git.revert', input);
     }
-    credentials() {
-        return this.okra.gitCredentials();
+    async credentials() {
+        const response = await this.client.post(`/notebook/${this.okra.data.id}/git/credentials`);
+        return response.data;
     }
     restore(ref) {
         return this.okra.invoke('git.restore', { ref });
@@ -96,10 +97,6 @@ export class GitTargetApi {
         const response = await this.client.get(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}`);
         return new GitTarget(response.data, this.notebookId, this.client);
     }
-    async sync(target, input = {}) {
-        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}/sync`, omitUndefined({ ...input }));
-        return new GitTarget(response.data, this.notebookId, this.client);
-    }
 }
 export class GitTarget {
     constructor(data, notebookId, client) {
@@ -110,8 +107,9 @@ export class GitTarget {
     get id() {
         return this.data.id;
     }
-    sync(input = {}) {
-        return new GitTargetApi(this.notebookId, this.client).sync(this, input);
+    async sync(input = {}) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(this.id)}/sync`, omitUndefined({ ...input }));
+        return new GitTarget(response.data, this.notebookId, this.client);
     }
 }
 function gitTargetId(target) {