ranna-ts 1.4.6

package/.github/workflows/release.yml

@@ -0,0 +1,32 @@
+name: Release CI
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish-gpr:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+          registry-url: https://npm.pkg.github.com/
+      - run: npx gitv
+      - run: npm run build
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+
+  publish-npm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+      - run: npx gitv
+      - run: npm run build
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.prettierrc.yml

@@ -0,0 +1,6 @@
+tabWidth:       2
+singleQuote:    true
+quoteProps:     consistent
+trailingComma:  es5
+bracketSpacing: true
+arrowParens:    always

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ranna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# ranna-ts
+TypeScript client wrapper for the ranna API.

package/dist/client.d.ts

@@ -0,0 +1,42 @@
+import { ExecutionRequest, ExecutionResponse, SpecMap, SystemInfo } from './models';
+import { ClientOptions, RequestClient } from './request';
+import { WebSocketClient } from './ws/client';
+/**
+ * Request client to perform API requests with.
+ */
+export declare class Client extends RequestClient {
+    /**
+     * Initialize a new client connected to the passed ranna
+     * server endpoint.
+     *
+     * You can specify additional options like the API version
+     * (default 'v1'), the user agent header or the authorization
+     * header, if required.
+     *
+     * @param endpoint The ranna server endpoint.
+     * @param options Additional options.
+     */
+    constructor(endpoint: string, options?: ClientOptions);
+    /**
+     * Request the available spec map.
+     * @returns SpecMap
+     */
+    spec(): Promise<SpecMap>;
+    /**
+     * Execute code.
+     * @param req Execution request
+     * @returns Execution response
+     */
+    exec(req: ExecutionRequest, bypassCache?: boolean): Promise<ExecutionResponse>;
+    /**
+     * Request service information.
+     * @returns
+     */
+    info(): Promise<SystemInfo>;
+    /**
+     * Connects to the ranna WebSocket API using
+     * the specified endpoint.
+     * @returns the websocket client.
+     */
+    connectWs(): WebSocketClient;
+}

package/dist/client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const request_1 = require("./request");
+const client_1 = require("./ws/client");
+const defaultOptions = {
+    version: 'v1',
+    userAgent: 'ranna-ts',
+    auth: null,
+};
+/**
+ * Request client to perform API requests with.
+ */
+class Client extends request_1.RequestClient {
+    /**
+     * Initialize a new client connected to the passed ranna
+     * server endpoint.
+     *
+     * You can specify additional options like the API version
+     * (default 'v1'), the user agent header or the authorization
+     * header, if required.
+     *
+     * @param endpoint The ranna server endpoint.
+     * @param options Additional options.
+     */
+    constructor(endpoint, options = defaultOptions) {
+        super(endpoint, options);
+    }
+    /**
+     * Request the available spec map.
+     * @returns SpecMap
+     */
+    spec() {
+        return this.request('GET', 'spec');
+    }
+    /**
+     * Execute code.
+     * @param req Execution request
+     * @returns Execution response
+     */
+    exec(req, bypassCache = false) {
+        return this.request('POST', `exec?bypass_cache=${bypassCache}`, req);
+    }
+    /**
+     * Request service information.
+     * @returns
+     */
+    info() {
+        return this.request('GET', 'info');
+    }
+    /**
+     * Connects to the ranna WebSocket API using
+     * the specified endpoint.
+     * @returns the websocket client.
+     */
+    connectWs() {
+        let endpoint = this.clientEndpoint;
+        if (endpoint.startsWith('https://'))
+            endpoint = 'wss://' + endpoint.substring(8);
+        else if (endpoint.startsWith('http://'))
+            endpoint = 'ws://' + endpoint.substring(7);
+        return new client_1.WebSocketClient(`${endpoint}/${this.clientOptions.version}/ws`);
+    }
+}
+exports.Client = Client;

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+import { ErrorResponse } from './models';
+export declare class APIError extends Error implements ErrorResponse {
+    private _code;
+    private _status;
+    private _error;
+    private _context;
+    constructor(res: ErrorResponse);
+    get code(): number;
+    get status(): number;
+    get error(): string;
+    get context(): string;
+}
+export declare class ResponseError extends Error {
+    private _response;
+    constructor(res: Response);
+    get response(): Response;
+}

package/dist/errors.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.APIError = void 0;
+class APIError extends Error {
+    constructor(res) {
+        super(res.error);
+        this._code = res.code;
+        this._status = res.status;
+        this._error = res.error;
+        this._context = res.context;
+    }
+    get code() {
+        return this._code;
+    }
+    get status() {
+        return this._status;
+    }
+    get error() {
+        return this._error;
+    }
+    get context() {
+        return this._context;
+    }
+}
+exports.APIError = APIError;
+class ResponseError extends Error {
+    constructor(res) {
+        super(`request failed: ${res.status}`);
+        this._response = res;
+    }
+    get response() {
+        return this._response;
+    }
+}
+exports.ResponseError = ResponseError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Client } from './client';
+export { APIError, ResponseError } from './errors';
+export { ExecutionRequest, ExecutionResponse, SpecMap, Spec, StringMap, Snippet, ErrorResponse, } from './models';
+export { SnippetsClient } from './snippets';
+export { ClientOptions } from './request';
+export { WebSocketClient } from './ws/client';
+export { Event, EventCode, LogData, Operation, StopData, Nonced, OpCode, RunID, WsError, } from './ws/models';

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpCode = exports.EventCode = exports.WebSocketClient = exports.SnippetsClient = exports.ResponseError = exports.APIError = exports.Client = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "APIError", { enumerable: true, get: function () { return errors_1.APIError; } });
+Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function () { return errors_1.ResponseError; } });
+var snippets_1 = require("./snippets");
+Object.defineProperty(exports, "SnippetsClient", { enumerable: true, get: function () { return snippets_1.SnippetsClient; } });
+var client_2 = require("./ws/client");
+Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return client_2.WebSocketClient; } });
+var models_1 = require("./ws/models");
+Object.defineProperty(exports, "EventCode", { enumerable: true, get: function () { return models_1.EventCode; } });
+Object.defineProperty(exports, "OpCode", { enumerable: true, get: function () { return models_1.OpCode; } });

package/dist/models.d.ts

@@ -0,0 +1,70 @@
+export interface Inline {
+    import_regex: string;
+    template: string;
+}
+export interface Spec {
+    image: string;
+    entrypoint: string;
+    cmd: string;
+    filename: string;
+    use: string;
+    registry: string;
+    language: string;
+    example: string;
+    inline: Inline;
+}
+export type SpecMap = {
+    [key: string]: Spec;
+};
+export type StringMap = {
+    [key: string]: string;
+};
+export interface ExecutionRequest {
+    language: string;
+    code: string;
+    arguments?: string[];
+    environment?: StringMap;
+    inline_expression: boolean;
+}
+export interface ExecutionResponse {
+    stdout: string;
+    stderr: string;
+    exectimems: number;
+    from_cache: boolean;
+    cache_date: string;
+}
+export interface ErrorResponse {
+    error: string;
+    code: number;
+    status: number;
+    context: string;
+}
+export interface Entity {
+    id: string;
+    timestamp: string;
+}
+export interface Snippet extends Entity {
+    ident: string;
+    displayname: string;
+    language: string;
+    code: string;
+}
+export interface SandboxInfo {
+    type: string;
+    version: string;
+}
+export interface SystemInfo {
+    sandbox: SandboxInfo;
+    version: string;
+    builddate: string;
+    go_version: string;
+}
+export interface User extends Entity {
+    username: string;
+}
+export interface UserCreate extends User {
+    masterkey: string;
+}
+export interface Token {
+    token: string;
+}

package/dist/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/request.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Wrap additional options for the Client.
+ */
+export interface ClientOptions {
+    version: string;
+    userAgent: string | null;
+    auth: string | null;
+}
+export declare class RequestClient {
+    private endpoint;
+    private options;
+    constructor(endpoint: string, options: ClientOptions);
+    request<T>(method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: string, body?: any): Promise<T>;
+    get clientOptions(): ClientOptions;
+    get clientEndpoint(): string;
+    set clientEndpoint(v: string);
+}

package/dist/request.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestClient = void 0;
+const errors_1 = require("./errors");
+class RequestClient {
+    constructor(endpoint, options) {
+        this.endpoint = endpoint;
+        this.options = options;
+    }
+    request(method, path, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
+            if (this.options.auth)
+                headers.set('Authorization', this.options.auth);
+            if (this.options.userAgent)
+                headers.set('User-Agent', this.options.userAgent);
+            const res = yield window.fetch(`${this.endpoint}/${this.options.version}/${path}`, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : null,
+                credentials: this.options.auth ? 'include' : 'omit',
+            });
+            if (res.status === 204) {
+                return {};
+            }
+            if (!res.ok) {
+                let data;
+                try {
+                    data = yield res.json();
+                }
+                catch (_a) {
+                    throw new errors_1.ResponseError(res);
+                }
+                throw new errors_1.APIError(data);
+            }
+            return res.json();
+        });
+    }
+    get clientOptions() {
+        return this.options;
+    }
+    get clientEndpoint() {
+        return this.endpoint;
+    }
+    set clientEndpoint(v) {
+        this.endpoint = v;
+    }
+}
+exports.RequestClient = RequestClient;

package/dist/snippets.d.ts

@@ -0,0 +1,99 @@
+import { Snippet, Token, UserCreate } from './models';
+import { ClientOptions, RequestClient } from './request';
+/**
+ * Request client to perform API requests
+ * against the snippet API.
+ */
+export declare class SnippetsClient extends RequestClient {
+    /**
+     * Initialize a new client connected to the passed ranna
+     * server endpoint.
+     *
+     * You can specify additional options like the API version
+     * (default 'v1'), the user agent header or the authorization
+     * header, if required.
+     *
+     * @param endpoint The ranna snippets server endpoint.
+     * @param options Additional options.
+     */
+    constructor(endpoint: string, options?: ClientOptions);
+    /**
+     * Creaates an account with the given username and returns
+     * the account properties including the account master key.
+     *
+     * This masterkey is exchanged againbst an API key later,
+     * which can be reviewed and regenerated. Also, the master
+     * key is required to delete an account.
+     *
+     * The masterkey is only shown ONCE at account creation
+     * and CAN NOT BE REVIEWED AGAIN AFTER THAT!
+     *
+     * @param username
+     * @returns
+     */
+    createAccount(username: string): Promise<UserCreate>;
+    /**
+     * Exchanges the passed master key for the passed username
+     * against an API key which is used for subsequent requests.
+     *
+     * The API key can also be regenerated using this endpoint
+     * if already existent.
+     *
+     * You can set `store` to true to stroe the received API
+     * key in the request client.
+     *
+     * @param username
+     * @param masterkey
+     * @param store
+     * @returns
+     */
+    exchangeAPIToken(username: string, masterkey: string, store?: boolean): Promise<Token>;
+    /**
+     * Deletes the user wtih the passed username if the passed
+     * masterkey matches the account.
+     *
+     * @param username
+     * @param masterkey
+     * @returns
+     */
+    deleteAccount(username: string, masterkey: string): Promise<Token>;
+    /**
+     * Returns a list of snippets belonging to the
+     * authorized account.
+     *
+     * This endpoijt must be authorized with an API
+     * token.
+     *
+     * @returns
+     */
+    list(): Promise<Snippet[]>;
+    /**
+     * Reqeusts a sinlie snippet by ident or id.
+     * @param ident
+     * @returns
+     */
+    get(ident: string): Promise<Snippet>;
+    /**
+     * Creates a new snippet with the passed content.
+     * @param snippet
+     * @returns
+     */
+    create(snippet: Snippet): Promise<Snippet>;
+    /**
+     * Updates a snippet with the passed content.
+     * @param snippet
+     * @returns
+     */
+    update(snippet: Snippet): Promise<Snippet>;
+    /**
+     * Deletes a snipped by its ident or ID.
+     *
+     * This endpoint required authorization by the owner of
+     * the snippet. If the snippet was created anonymously,
+     * it can not be deleted!
+     *
+     * @param ident
+     * @returns
+     */
+    delete(ident: string): Promise<{}>;
+}

package/dist/snippets.js

@@ -0,0 +1,163 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnippetsClient = void 0;
+const request_1 = require("./request");
+const defaultOptions = {
+    version: 'v1',
+    userAgent: 'ranna-ts',
+    auth: null,
+};
+/**
+ * Request client to perform API requests
+ * against the snippet API.
+ */
+class SnippetsClient extends request_1.RequestClient {
+    /**
+     * Initialize a new client connected to the passed ranna
+     * server endpoint.
+     *
+     * You can specify additional options like the API version
+     * (default 'v1'), the user agent header or the authorization
+     * header, if required.
+     *
+     * @param endpoint The ranna snippets server endpoint.
+     * @param options Additional options.
+     */
+    constructor(endpoint, options = defaultOptions) {
+        super(endpoint, options);
+    }
+    /**
+     * Creaates an account with the given username and returns
+     * the account properties including the account master key.
+     *
+     * This masterkey is exchanged againbst an API key later,
+     * which can be reviewed and regenerated. Also, the master
+     * key is required to delete an account.
+     *
+     * The masterkey is only shown ONCE at account creation
+     * and CAN NOT BE REVIEWED AGAIN AFTER THAT!
+     *
+     * @param username
+     * @returns
+     */
+    createAccount(username) {
+        return this.request('PUT', `users/${username}`);
+    }
+    /**
+     * Exchanges the passed master key for the passed username
+     * against an API key which is used for subsequent requests.
+     *
+     * The API key can also be regenerated using this endpoint
+     * if already existent.
+     *
+     * You can set `store` to true to stroe the received API
+     * key in the request client.
+     *
+     * @param username
+     * @param masterkey
+     * @param store
+     * @returns
+     */
+    exchangeAPIToken(username_1, masterkey_1) {
+        return __awaiter(this, arguments, void 0, function* (username, masterkey, store = false) {
+            this.clientOptions.auth = 'bearer ' + masterkey;
+            let res = null;
+            try {
+                res = yield this.request('POST', `users/${username}/apitoken`);
+                return res;
+            }
+            catch (err) {
+                throw err;
+            }
+            finally {
+                if (store && !!res)
+                    this.clientOptions.auth = 'bearer ' + res.token;
+                else
+                    this.clientOptions.auth = null;
+            }
+        });
+    }
+    /**
+     * Deletes the user wtih the passed username if the passed
+     * masterkey matches the account.
+     *
+     * @param username
+     * @param masterkey
+     * @returns
+     */
+    deleteAccount(username, masterkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clientOptions.auth = 'bearer ' + masterkey;
+            let res = null;
+            try {
+                res = yield this.request('DELETE', `users/${username}`);
+                return res;
+            }
+            catch (err) {
+                throw err;
+            }
+            finally {
+                this.clientOptions.auth = null;
+            }
+        });
+    }
+    /**
+     * Returns a list of snippets belonging to the
+     * authorized account.
+     *
+     * This endpoijt must be authorized with an API
+     * token.
+     *
+     * @returns
+     */
+    list() {
+        return this.request('GET', 'snippets');
+    }
+    /**
+     * Reqeusts a sinlie snippet by ident or id.
+     * @param ident
+     * @returns
+     */
+    get(ident) {
+        return this.request('GET', `snippets/${ident}`);
+    }
+    /**
+     * Creates a new snippet with the passed content.
+     * @param snippet
+     * @returns
+     */
+    create(snippet) {
+        return this.request('POST', 'snippets', snippet);
+    }
+    /**
+     * Updates a snippet with the passed content.
+     * @param snippet
+     * @returns
+     */
+    update(snippet) {
+        return this.request('POST', `snippets/${snippet.ident}`, snippet);
+    }
+    /**
+     * Deletes a snipped by its ident or ID.
+     *
+     * This endpoint required authorization by the owner of
+     * the snippet. If the snippet was created anonymously,
+     * it can not be deleted!
+     *
+     * @param ident
+     * @returns
+     */
+    delete(ident) {
+        return this.request('DELETE', `snippets/${ident}`);
+    }
+}
+exports.SnippetsClient = SnippetsClient;