gingersnap 0.22.0

package/data/decoders/msgpack.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var msgpack = require('@msgpack/msgpack');
+
+/**
+ * Converts Blob to JSON object that was packaged using msgpack
+ */
+class MsgpackDecoder {
+    decode(data) {
+        return msgpack.decode(new Uint8Array(data));
+    }
+}
+
+exports.MsgpackDecoder = MsgpackDecoder;

package/data/decoders/msgpack.d.ts

@@ -0,0 +1,7 @@
+import { Decoder } from "./type";
+/**
+ * Converts Blob to JSON object that was packaged using msgpack
+ */
+export declare class MsgpackDecoder<T> implements Decoder<T> {
+    decode(data: ArrayBuffer): T;
+}

package/data/decoders/msgpack.mjs

@@ -0,0 +1,12 @@
+import { decode } from '@msgpack/msgpack';
+
+/**
+ * Converts Blob to JSON object that was packaged using msgpack
+ */
+class MsgpackDecoder {
+    decode(data) {
+        return decode(new Uint8Array(data));
+    }
+}
+
+export { MsgpackDecoder };

package/data/decoders/protobuf.d.ts

@@ -0,0 +1,13 @@
+import { Decoder } from "./type";
+import { Message, Root, Type } from "protobufjs";
+/**
+ * Converts Blob to data that was encoded using protobuf
+ */
+export declare class ProtobufDecoder<T extends Message> implements Decoder<T> {
+    private readonly proto;
+    private readonly typePath;
+    private type;
+    constructor(proto: object | Root | Type, typePath: string);
+    decode(data: ArrayBuffer): T;
+    load(): void;
+}

package/data/decoders/string.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * Converts Blob to string data
+ */
+class StringDecoder {
+    decode(data) {
+        return new TextDecoder().decode(data);
+    }
+}
+
+exports.StringDecoder = StringDecoder;

package/data/decoders/string.d.ts

@@ -0,0 +1,7 @@
+import { Decoder } from "./type";
+/**
+ * Converts Blob to string data
+ */
+export declare class StringDecoder implements Decoder<string> {
+    decode(data: ArrayBuffer): string;
+}

package/data/decoders/string.mjs

@@ -0,0 +1,10 @@
+/**
+ * Converts Blob to string data
+ */
+class StringDecoder {
+    decode(data) {
+        return new TextDecoder().decode(data);
+    }
+}
+
+export { StringDecoder };

package/data/decoders/type.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Used for converting data from Blob to a given format
+ */
+export interface Decoder<T> {
+    decode: (data: ArrayBuffer) => T;
+    load?: () => void;
+}

package/data/decoders.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var string = require('./decoders/string.cjs');
+var json = require('./decoders/json.cjs');
+var msgpack = require('./decoders/msgpack.cjs');
+
+
+
+exports.StringDecoder = string.StringDecoder;
+exports.JSONDecoder = json.JSONDecoder;
+exports.MsgpackDecoder = msgpack.MsgpackDecoder;

package/data/decoders.mjs

@@ -0,0 +1,3 @@
+export { StringDecoder } from './decoders/string.mjs';
+export { JSONDecoder } from './decoders/json.mjs';
+export { MsgpackDecoder } from './decoders/msgpack.mjs';

package/data/model/credentials.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var model = require('./model.cjs');
+var property = require('./property.cjs');
+var browserOrNode = require('browser-or-node');
+
+/**
+ * Class that represents credentials used for sending authorized requests
+ */
+class Credentials extends model.Model {
+    /**
+     * Method for constructing the refresh headers used in a request to retrieve new credentials
+     */
+    buildRefreshHeaders() {
+        return {};
+    }
+}
+/**
+ * Credentials that support JWT
+ */
+class BearerCredentials extends Credentials {
+    constructor(accessToken, refreshToken, expirationDate) {
+        super();
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+        this.expirationDate = expirationDate;
+    }
+    buildAuthHeaders() {
+        return {
+            Authorization: `Bearer ${this.accessToken}`,
+        };
+    }
+    buildRefreshHeaders() {
+        var _a;
+        return {
+            access_token: this.accessToken,
+            refresh_token: (_a = this.refreshToken) !== null && _a !== void 0 ? _a : "",
+        };
+    }
+}
+_tslib.__decorate([
+    property.Alias("access_token"),
+    property.Field("accessToken"),
+    _tslib.__metadata("design:type", String)
+], BearerCredentials.prototype, "accessToken", void 0);
+_tslib.__decorate([
+    property.Alias("refresh_token"),
+    property.Field("refreshToken"),
+    _tslib.__metadata("design:type", String)
+], BearerCredentials.prototype, "refreshToken", void 0);
+_tslib.__decorate([
+    property.Ignore(),
+    property.Alias("expirationDate"),
+    property.Alias("expiration_date"),
+    property.Alias("expiryDate"),
+    property.Alias("exp"),
+    property.Field("expiry_date"),
+    _tslib.__metadata("design:type", Date)
+], BearerCredentials.prototype, "expirationDate", void 0);
+/**
+ * Credentials for using API service
+ */
+class APIKeyCredentials extends Credentials {
+    constructor(apiKey) {
+        super();
+        this.apiKey = apiKey;
+    }
+    buildAuthHeaders() {
+        return {
+            "X-API-Key": this.apiKey,
+        };
+    }
+}
+_tslib.__decorate([
+    property.Alias("api_key"),
+    property.Field("apiKey"),
+    _tslib.__metadata("design:type", String)
+], APIKeyCredentials.prototype, "apiKey", void 0);
+/**
+ * Credentials that is used for username and password authenticated requests
+ */
+class BasicCredentials extends Credentials {
+    constructor(username, password) {
+        super();
+        this.username = username;
+        this.password = password;
+    }
+    buildAuthHeaders() {
+        let token;
+        if (browserOrNode.isNode) {
+            token = Buffer.from(`${this.username}:${this.password}`).toString("base64");
+        }
+        else {
+            token = btoa(`${this.username}:${this.password}`);
+        }
+        return {
+            Authorization: `Basic ${token}`,
+        };
+    }
+}
+_tslib.__decorate([
+    property.Field("username"),
+    _tslib.__metadata("design:type", String)
+], BasicCredentials.prototype, "username", void 0);
+_tslib.__decorate([
+    property.Field("password"),
+    _tslib.__metadata("design:type", String)
+], BasicCredentials.prototype, "password", void 0);
+
+exports.APIKeyCredentials = APIKeyCredentials;
+exports.BasicCredentials = BasicCredentials;
+exports.BearerCredentials = BearerCredentials;
+exports.Credentials = Credentials;

package/data/model/credentials.d.ts

@@ -0,0 +1,61 @@
+import { Model } from "./model";
+import { MapOfHeaders } from "../../networking/types";
+/**
+ * Class that represents credentials used for sending authorized requests
+ */
+export declare abstract class Credentials extends Model {
+    /**
+     * Abstract method for constructing the authentication headers used in a request
+     */
+    abstract buildAuthHeaders(): MapOfHeaders;
+    /**
+     * Method for constructing the refresh headers used in a request to retrieve new credentials
+     */
+    buildRefreshHeaders(): MapOfHeaders;
+}
+/**
+ * Credentials that support JWT
+ */
+export declare class BearerCredentials extends Credentials {
+    /**
+     * JWT access token use for authenticated requests
+     */
+    accessToken: string;
+    /**
+     * JWT refresh token used to retrieve new access token
+     */
+    refreshToken?: string;
+    /**
+     * Expiration date
+     */
+    expirationDate?: Date;
+    constructor(accessToken: string, refreshToken?: string, expirationDate?: Date);
+    buildAuthHeaders(): MapOfHeaders;
+    buildRefreshHeaders(): MapOfHeaders;
+}
+/**
+ * Credentials for using API service
+ */
+export declare class APIKeyCredentials extends Credentials {
+    /**
+     * API Key used for authenticated requests
+     */
+    apiKey: string;
+    constructor(apiKey: string);
+    buildAuthHeaders(): MapOfHeaders;
+}
+/**
+ * Credentials that is used for username and password authenticated requests
+ */
+export declare class BasicCredentials extends Credentials {
+    /**
+     * Username for the authenticated user
+     */
+    username: string;
+    /**
+     * Password for the authenticated user
+     */
+    password: string;
+    constructor(username: string, password: string);
+    buildAuthHeaders(): MapOfHeaders;
+}

package/data/model/credentials.mjs

@@ -0,0 +1,109 @@
+import { __decorate, __metadata } from '../../_virtual/_tslib.mjs';
+import { Model } from './model.mjs';
+import { Alias, Field, Ignore } from './property.mjs';
+import { isNode } from 'browser-or-node';
+
+/**
+ * Class that represents credentials used for sending authorized requests
+ */
+class Credentials extends Model {
+    /**
+     * Method for constructing the refresh headers used in a request to retrieve new credentials
+     */
+    buildRefreshHeaders() {
+        return {};
+    }
+}
+/**
+ * Credentials that support JWT
+ */
+class BearerCredentials extends Credentials {
+    constructor(accessToken, refreshToken, expirationDate) {
+        super();
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+        this.expirationDate = expirationDate;
+    }
+    buildAuthHeaders() {
+        return {
+            Authorization: `Bearer ${this.accessToken}`,
+        };
+    }
+    buildRefreshHeaders() {
+        var _a;
+        return {
+            access_token: this.accessToken,
+            refresh_token: (_a = this.refreshToken) !== null && _a !== void 0 ? _a : "",
+        };
+    }
+}
+__decorate([
+    Alias("access_token"),
+    Field("accessToken"),
+    __metadata("design:type", String)
+], BearerCredentials.prototype, "accessToken", void 0);
+__decorate([
+    Alias("refresh_token"),
+    Field("refreshToken"),
+    __metadata("design:type", String)
+], BearerCredentials.prototype, "refreshToken", void 0);
+__decorate([
+    Ignore(),
+    Alias("expirationDate"),
+    Alias("expiration_date"),
+    Alias("expiryDate"),
+    Alias("exp"),
+    Field("expiry_date"),
+    __metadata("design:type", Date)
+], BearerCredentials.prototype, "expirationDate", void 0);
+/**
+ * Credentials for using API service
+ */
+class APIKeyCredentials extends Credentials {
+    constructor(apiKey) {
+        super();
+        this.apiKey = apiKey;
+    }
+    buildAuthHeaders() {
+        return {
+            "X-API-Key": this.apiKey,
+        };
+    }
+}
+__decorate([
+    Alias("api_key"),
+    Field("apiKey"),
+    __metadata("design:type", String)
+], APIKeyCredentials.prototype, "apiKey", void 0);
+/**
+ * Credentials that is used for username and password authenticated requests
+ */
+class BasicCredentials extends Credentials {
+    constructor(username, password) {
+        super();
+        this.username = username;
+        this.password = password;
+    }
+    buildAuthHeaders() {
+        let token;
+        if (isNode) {
+            token = Buffer.from(`${this.username}:${this.password}`).toString("base64");
+        }
+        else {
+            token = btoa(`${this.username}:${this.password}`);
+        }
+        return {
+            Authorization: `Basic ${token}`,
+        };
+    }
+}
+__decorate([
+    Field("username"),
+    __metadata("design:type", String)
+], BasicCredentials.prototype, "username", void 0);
+__decorate([
+    Field("password"),
+    __metadata("design:type", String)
+], BasicCredentials.prototype, "password", void 0);
+
+export { APIKeyCredentials, BasicCredentials, BearerCredentials, Credentials };

package/data/model/extra.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+var IllegalArgumentsError = require('../../errors/IllegalArgumentsError.cjs');
+var ParsingError = require('../../errors/ParsingError.cjs');
+var R = require('ramda');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+const View = (modelClass, path, option) => (data, ...otherArgs) => {
+    switch (option) {
+        case "json": {
+            const result = modelClass.fromJSON(data);
+            return R__namespace.view(R__namespace.lensPath(path), result);
+        }
+        case "string": {
+            const result = modelClass.fromString(data, ...otherArgs);
+            return R__namespace.view(R__namespace.lensPath(path), result);
+        }
+        case "blob": {
+            const result = modelClass.fromBlob(data, ...otherArgs);
+            return R__namespace.view(R__namespace.lensPath(path), result);
+        }
+        case "buffer": {
+            const result = modelClass.fromBuffer(data, ...otherArgs);
+            return R__namespace.view(R__namespace.lensPath(path), result);
+        }
+        default:
+            throw new IllegalArgumentsError.IllegalArgumentsError([option]);
+    }
+};
+const Union = (modelClasses, option) => (data, ...otherArgs) => {
+    switch (option) {
+        case "json":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromJSON(data);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError.ParsingError([], "Cannot find suitable model");
+        case "string":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromString(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError.ParsingError([], "Cannot find suitable model");
+        case "blob":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromBlob(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError.ParsingError([], "Cannot find suitable model");
+        case "buffer":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromBuffer(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError.ParsingError([], "Cannot find suitable model");
+        default:
+            throw new IllegalArgumentsError.IllegalArgumentsError([option]);
+    }
+};
+
+exports.Union = Union;
+exports.View = View;

package/data/model/extra.d.ts

@@ -0,0 +1,5 @@
+import { Model } from "./model";
+type UnionParserOptions = "json" | "string" | "blob" | "buffer";
+export declare const View: (modelClass: typeof Model, path: Array<string | number>, option: UnionParserOptions) => (data: any, ...otherArgs: any[]) => any;
+export declare const Union: (modelClasses: Array<typeof Model>, option: UnionParserOptions) => (data: any, ...otherArgs: any[]) => Model | Model[] | Promise<Model | Model[]>;
+export {};

package/data/model/extra.mjs

@@ -0,0 +1,66 @@
+import { IllegalArgumentsError } from '../../errors/IllegalArgumentsError.mjs';
+import { ParsingError } from '../../errors/ParsingError.mjs';
+import * as R from 'ramda';
+
+const View = (modelClass, path, option) => (data, ...otherArgs) => {
+    switch (option) {
+        case "json": {
+            const result = modelClass.fromJSON(data);
+            return R.view(R.lensPath(path), result);
+        }
+        case "string": {
+            const result = modelClass.fromString(data, ...otherArgs);
+            return R.view(R.lensPath(path), result);
+        }
+        case "blob": {
+            const result = modelClass.fromBlob(data, ...otherArgs);
+            return R.view(R.lensPath(path), result);
+        }
+        case "buffer": {
+            const result = modelClass.fromBuffer(data, ...otherArgs);
+            return R.view(R.lensPath(path), result);
+        }
+        default:
+            throw new IllegalArgumentsError([option]);
+    }
+};
+const Union = (modelClasses, option) => (data, ...otherArgs) => {
+    switch (option) {
+        case "json":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromJSON(data);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError([], "Cannot find suitable model");
+        case "string":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromString(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError([], "Cannot find suitable model");
+        case "blob":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromBlob(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError([], "Cannot find suitable model");
+        case "buffer":
+            for (const ModelClass of modelClasses) {
+                try {
+                    return ModelClass.fromBuffer(data, ...otherArgs);
+                }
+                catch (err) { }
+            }
+            throw new ParsingError([], "Cannot find suitable model");
+        default:
+            throw new IllegalArgumentsError([option]);
+    }
+};
+
+export { Union, View };

package/data/model/index.d.ts

@@ -0,0 +1,6 @@
+export { Model, Optional, IgnoreProps } from "./model";
+export * from "./property";
+export * from "./types";
+export * from "./credentials";
+export * from "./plugin";
+export { Union, View } from "./extra";