@mapcreator/api 2.9.0 → 3.0.1

package/dist/errors/OAuthError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OAuth error
+ */
+export default class OAuthError extends Error {
+    /**
+     * OAuth error response
+     * @param {String} error - OAuth error key
+     * @param {String} message - OAuth error message
+     */
+    constructor(error: string, message?: string);
+    /**
+     * OAuth error code
+     * @type {String}
+     */
+    error: string;
+}
+//# sourceMappingURL=OAuthError.d.ts.map

package/dist/errors/StaticClassError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown upon invocation of a static class
+ * @see {@link StaticClass}
+ */
+export default class StaticClassError extends Error {
+}
+//# sourceMappingURL=StaticClassError.d.ts.map

package/dist/errors/ValidationError.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Contains schema errors.
+ * Normally thrown when a job object is invalid.
+ *
+ * @typedef {Object} SchemaError
+ * @property {string} property - json property
+ * @property {string} pointer - json pointer
+ * @property {string} message - error message
+ * @property {number} context -
+ * @property {Object} constraint -
+ * @property {Object<string, string>} constraint.params -
+ * @property {string} constraint.name -
+ * @see https://github.com/justinrainbow/json-schema
+ * @example
+ * {
+ *   property: "data.meta",
+ *   pointer: "/data/meta",
+ *   message: "The property meta is required",
+ *   constraint: {
+ *     name: "required",
+ *     params: {
+ *       property: "meta"
+ *     }
+ *   },
+ *   context: 1
+ * }
+ */
+/**
+ * Extension of {@link ApiError} containing an extra field for validation errors
+ */
+export default class ValidationError extends ApiError {
+    /**
+     * Any validation errors
+     * @type {Object.<String, Array<String>>} - Object containing arrays of validation errors where the field is stored in the key
+     */
+    validationErrors: any;
+    /**
+     * Get the schema errors if available
+     * @type {SchemaError[]} - Array containing schema errors
+     * @see {@link hasSchemaErrors}
+     * @example
+     * [
+     *   {
+     *     "property": "data.meta",
+     *     "pointer": "/data/meta",
+     *     "message": "The property meta is required",
+     *     "constraint": {
+     *       "name": "required",
+     *       "params": {
+     *         "property": "meta"
+     *       }
+     *     },
+     *     "context": 1
+     *   },
+     *    {
+     *     "property": "data.paper",
+     *     "pointer": "/data/paper",
+     *     "message": "The property paper is required",
+     *     "constraint": {
+     *       "name": "required",
+     *       "params": {
+     *         "property": "paper"
+     *       }
+     *     },
+     *     "context": 1
+     *   },
+     *    {
+     *     "property": "data.scaleDefinition",
+     *     "pointer": "/data/scaleDefinition",
+     *     "message": "The property scaleDefinition is required",
+     *     "constraint": {
+     *       "name": "required",
+     *       "params": {
+     *         "property": "scaleDefinition"
+     *       }
+     *     },
+     *     "context": 1
+     *   }
+     * ]
+     */
+    schemaErrors: SchemaError[];
+    /**
+     * True if the error contains schema errors
+     * @return {boolean} - Has schema errors
+     */
+    get hasSchemaErrors(): boolean;
+    /**
+     * Get validation error messages
+     * @returns {Array<String>} - All validation messages
+     */
+    get messages(): string[];
+}
+/**
+ * Contains schema errors.
+ * Normally thrown when a job object is invalid.
+ */
+export type SchemaError = {
+    /**
+     * - json property
+     */
+    property: string;
+    /**
+     * - json pointer
+     */
+    pointer: string;
+    /**
+     * - error message
+     */
+    message: string;
+    /**
+     * -
+     */
+    context: number;
+    /**
+     * -
+     */
+    constraint: {
+        params: {
+            [x: string]: string;
+        };
+        name: string;
+    };
+};
+import ApiError from "./ApiError";
+//# sourceMappingURL=ValidationError.d.ts.map

package/dist/errors/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./AbstractError";
+export { default as ApiError } from "./ApiError";
+export { default as ValidationError } from "./ValidationError";
+export { default as NodeError } from "./NodeError";
+export { default as OAuthError } from "./OAuthError";
+export { default as StaticClassError } from "./StaticClassError";
+export { default as GeoError } from "./GeoError";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export { default as Mapcreator } from "./Mapcreator";
+export { default as RequestParameters } from "./RequestParameters";
+export { default as StorageManager } from "./storage/StorageManager";
+export { default as Enum } from "./enums/Enum";
+export { default as OAuth } from "./oauth/OAuth";
+export { default as OAuthToken } from "./oauth/OAuthToken";
+export { default as ImplicitFlow } from "./oauth/ImplicitFlow";
+export { default as ImplicitFlowPopup } from "./oauth/ImplicitFlowPopup";
+export { default as PasswordFlow } from "./oauth/PasswordFlow";
+export { default as DummyFlow } from "./oauth/DummyFlow";
+export { default as ApiError } from "./errors/ApiError";
+export * from "./errors/AbstractError";
+export { default as ValidationError } from "./errors/ValidationError";
+export { default as StaticClassError } from "./errors/StaticClassError";
+export * as resources from "./resources";
+export * as helpers from "./utils/helpers";
+export { default as ResourceLister } from "./ResourceLister";
+export * as geo from "./utils/geo";
+export * as errors from "./errors";
+export * as proxies from "./proxy";
+/**
+ * Package version
+ * @private
+ */
+export const version: any;
+export { DeletedState, ResultStatus } from "./enums";
+//# sourceMappingURL=index.d.ts.map

package/dist/oauth/DummyFlow.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dummy flow for when the token should be available in the
+ * cache and no attempt at authentication should be made.
+ */
+export default class DummyFlow extends OAuth {
+    /**
+     * @param {String} [clientId=] - OAuth client id
+     * @param {Array<String>} scopes - A list of required scopes
+     */
+    constructor(clientId?: string, scopes?: Array<string>);
+    /**
+     * Authenticate
+     * @returns {Promise<OAuthToken>} - token
+     * @throws {OAuthError}
+     */
+    authenticate(): Promise<OAuthToken>;
+}
+import OAuth from "./OAuth";
+//# sourceMappingURL=DummyFlow.d.ts.map

package/dist/oauth/ImplicitFlow.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Implicit OAuth flow using redirection
+ */
+export default class ImplicitFlow extends OAuth {
+    /**
+     * Implicit authentication flow
+     * @param {String} clientId - OAuth client id
+     * @param {String} callbackUrl - callbackUrl for obtaining the token. This should be a
+     *                               page with this script on it. If left empty the current
+     *                               url will be used.
+     * @param {Array<String>} scopes - A list of required scopes
+     * @param {Boolean} useState - use state verification
+     */
+    constructor(clientId: string, callbackUrl?: string, scopes?: Array<string>, useState?: boolean);
+    callbackUrl: string;
+    useState: boolean;
+    _anchorParams: string[];
+    /**
+     * @inheritDoc
+     */
+    authenticate(): Promise<any>;
+    /**
+     * Builds the url for redirection
+     * @returns {String} - Redirect url
+     * @protected
+     */
+    protected _buildRedirectUrl(): string;
+    /**
+     * Builds an object containing all the anchor parameters
+     * @param {String} query - Url hash
+     * @returns {Object<String, String>} - Anchor parameters
+     * @protected
+     */
+    protected _getAnchorParams(query?: string): any;
+    /**
+     * Fetch OAuth anchor params
+     * @param {Object<String, String>} query - Optional override for the query to analyse, defaults to {@link ImplicitFlow#_getAnchorParams}
+     * @returns {Object<String, String>} - List of OAuth anchor parameters
+     * @protected
+     */
+    protected _getOAuthAnchorParams(query?: any): any;
+    /**
+     * Remove OAuth related anchor parameters
+     * @protected
+     */
+    protected _cleanAnchorParams(): void;
+    /**
+     * Test if the anchor contains an OAuth response
+     * @returns {Boolean} - If anchor tested positive for containing an OAuth response
+     * @protected
+     */
+    protected _anchorContainsOAuthResponse(): boolean;
+    /**
+     * Test if the anchor contains an OAuth error
+     * @returns {Boolean} - If anchor tested positive for containing an OAuth error
+     * @protected
+     */
+    protected _anchorContainsError(): boolean;
+    /**
+     * Get and return the error in the anchor
+     * @returns {OAuthError} - OAuthError object
+     * @protected
+     */
+    protected _getError(): OAuthError;
+}
+import OAuth from "./OAuth";
+import OAuthError from "../errors/OAuthError";
+//# sourceMappingURL=ImplicitFlow.d.ts.map

package/dist/oauth/ImplicitFlowPopup.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Implicit OAuth flow using a pop-up.
+ */
+export default class ImplicitFlowPopup extends ImplicitFlow {
+    /**
+     * Popup window name
+     * @returns {String} - window.name of the created pop-up
+     * @constant
+     */
+    static get popupWindowName(): string;
+    /**
+     * Implicit pop-up authentication flow
+     * @param {String} clientId - OAuth client id
+     * @param {String} callbackUrl - callbackUrl for obtaining the token. This should be a
+     *                               page with this script on it. If left empty the current
+     *                               url will be used.
+     * @param {Array<String>} scopes - A list of required scopes
+     * @param {Boolean} useState - use state verification
+     * @param {String} windowOptions - optional window options for the pop-up window
+     */
+    constructor(clientId: string, callbackUrl?: string, scopes?: Array<string>, useState?: boolean, windowOptions?: string);
+    windowOptions: string;
+}
+import ImplicitFlow from "./ImplicitFlow";
+//# sourceMappingURL=ImplicitFlowPopup.d.ts.map

package/dist/oauth/OAuth.d.ts

@@ -0,0 +1,50 @@
+/**
+ * OAuth base class
+ * @abstract
+ */
+export default class OAuth {
+    /**
+     * @param {String} clientId - OAuth client id
+     * @param {Array<String>} scopes - A list of required scopes
+     */
+    constructor(clientId: string, scopes?: Array<string>);
+    token: any;
+    path: string;
+    host: string;
+    clientId: string;
+    scopes: string[];
+    /**
+     * If the current instance has a valid token
+     * @returns {Boolean} - If a valid token is available
+     */
+    get authenticated(): boolean;
+    /**
+     * Authenticate
+     * @returns {Promise<OAuthToken>} - Authentication token
+     * @throws {OAuthError}
+     * @abstract
+     */
+    authenticate(): Promise<OAuthToken>;
+    /**
+     * Forget the current session
+     * Empty the session token store and forget the api token
+     */
+    forget(): void;
+    /**
+     * Invalidates the session token
+     * @throws {OAuthError} - If de-authentication fails
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    logout(): CancelablePromise;
+    /**
+     * Manually import OAuthToken, usefull for debugging
+     * @param {String} token - OAuth token
+     * @param {String} [type=Bearer] - token type
+     * @param {Date|Number} [expires=5 days] - expire time in seconds or Date
+     * @param {Array<string>} [scopes=[]] - Any scopes
+     */
+    importToken(token: string, type?: string, expires?: Date | number, scopes?: Array<string>): void;
+}
+import OAuthToken from "./OAuthToken";
+//# sourceMappingURL=OAuth.d.ts.map

package/dist/oauth/OAuthToken.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Oauth token container
+ */
+export default class OAuthToken {
+    /**
+     * Internal storage key name
+     * @returns {String} - storage name
+     * @constant
+     */
+    static get storageName(): string;
+    /**
+     * Build instance from response object
+     * @param {String|Object} data - object or JSON string
+     * @returns {OAuthToken} - New OAuthToken instance
+     */
+    static fromResponseObject(data: string | any): OAuthToken;
+    /**
+     * Recover a token by looking through the HTTPS cookies and localStorage
+     * @param {String} name - Storage key name
+     * @returns {OAuthToken|null} - null if none could be recovered
+     * @throws {OAuthToken#save}
+     */
+    static recover(name?: string): OAuthToken | null;
+    /**
+     * @param {String} token - OAuth token
+     * @param {String} [type=Bearer] - token type
+     * @param {Date|Number} [expires=5 days] - expire time in seconds or Date
+     * @param {Array<string>} [scopes=[]] - Any scopes
+     */
+    constructor(token: string, type?: string, expires?: Date | number, scopes?: Array<string>);
+    scopes: string[];
+    token: string;
+    type: string;
+    expires: Date;
+    /**
+     * String representation of the token, usable in the Authorization header
+     * @returns {string} - String representation
+     */
+    toString(): string;
+    /**
+     * Get equivalent OAuth response object
+     * @returns {{access_token: (String|*), token_type: String, expires_in: Number, scope: (Array.<String>|Array|*)}} - Raw response object
+     */
+    toResponseObject(): {
+        access_token: (string | any);
+        token_type: string;
+        expires_in: number;
+        scope: (Array<string> | any[] | any);
+    };
+    /**
+     * Export oauth response query string
+     * @returns {string} - OAuth response query
+     */
+    toQueryString(): string;
+    /**
+     * If the token has expired
+     * @returns {Boolean} - expired
+     */
+    get expired(): boolean;
+    /**
+     * Store the token for later recovery. Token will be stored in HTTPS cookie if possible.
+     * @param {String} name - db key name
+     * @throws {OAuthToken#recover}
+     */
+    save(name?: string): void;
+}
+//# sourceMappingURL=OAuthToken.d.ts.map

package/dist/oauth/PasswordFlow.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Password authentication flow
+ */
+export default class PasswordFlow extends OAuth {
+    /**
+     * @param {string} clientId - OAuth client id
+     * @param {string} secret - OAuth secret
+     * @param {string} username - Valid username (email)
+     * @param {string} password - Valid password
+     * @param {Array<string>} scopes - A list of required scopes
+     */
+    constructor(clientId: string, secret: string, username: string, password: string, scopes?: Array<string>);
+    _secret: string;
+    _username: string;
+    _password: string;
+    _path: string;
+    /**
+     * Set client secret
+     * @param {String} value - secret
+     */
+    set secret(arg: string);
+    /**
+     * it's a secret :o (client secret)
+     * @returns {String} - secret
+     */
+    get secret(): string;
+    /**
+     * Get the username for authentication
+     * @param {String} value - Username (email)
+     */
+    set username(arg: string);
+    /**
+     * Get the username for authentication
+     * @returns {String} - Username (email)
+     */
+    get username(): string;
+    /**
+     * Set the password
+     * @param {String} value - password
+     */
+    set password(arg: string);
+    /**
+     * Get the password
+     * @returns {String} - Password
+     */
+    get password(): string;
+    /**
+     * Authenticate
+     * @returns {CancelablePromise<OAuthToken>} - Response token
+     * @throws {OAuthError}
+     */
+    authenticate(): CancelablePromise<OAuthToken>;
+}
+import OAuth from "./OAuth";
+import OAuthToken from "./OAuthToken";
+//# sourceMappingURL=PasswordFlow.d.ts.map

package/dist/oauth/StateContainer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * State container for keeping track of OAuth states (crsf tokens)
+ * @static
+ * @private
+ */
+export default class StateContainer extends StaticClass {
+    /**
+     * LocalStorage key prefix
+     * @returns {String} - prefix
+     * @constant
+     */
+    static get prefix(): string;
+    /**
+     * Generate and store a state that can be checked at a later point
+     * @returns {string} - state
+     */
+    static generate(): string;
+    /**
+     * Validate a state
+     * @param {String} state - state to validate
+     * @param {Boolean} purge - remove from state db after validation
+     * @returns {Boolean} - if the state is valid
+     */
+    static validate(state: string, purge?: boolean): boolean;
+    /**
+     * Remove all states from the state db
+     */
+    static clean(): void;
+    /**
+     * Get states with their corresponding state db key
+     * @returns {Object<String, String>} - List of stored states
+     */
+    static list(): any;
+}
+import StaticClass from "../utils/StaticClass";
+//# sourceMappingURL=StateContainer.d.ts.map

package/dist/proxy/GeoResourceProxy.d.ts

@@ -0,0 +1,69 @@
+export default class GeoResourceProxy extends ResourceProxy {
+    /**
+     * @param {Mapcreator} api - Instance of the api
+     * @param {ResourceBase} Target - Target to wrap
+     * @param {?string} [altUrl=null] - Internal use, Optional alternative url for more complex routing
+     * @param {object} seedData - Internal use, used for seeding ::new
+     * @param {object} options - instance options
+     * @param {boolean} [options.hasForPoint=true] - If the endpoint supports for-point
+     * @param {boolean} [options.hasForBoundary=true] - If the endpoint supports for-boundary
+     */
+    constructor(api: Mapcreator, Target: ResourceBase, altUrl?: string | null, seedData?: object, { hasForPoint, hasForBoundary }?: {
+        hasForPoint?: boolean;
+        hasForBoundary?: boolean;
+    });
+    _hasForPoint: boolean;
+    _hasForBoundary: boolean;
+    /**
+     * If the proxy supports for-point operations
+     * @returns {boolean} - If it supports the operations
+     */
+    get hasForPoint(): boolean;
+    /**
+     * If the proxy supports for-point operations
+     * @returns {boolean} - If it supports the operations
+     */
+    get hasForBoundary(): boolean;
+    /**
+     * Get an array of results for boundary
+     * @param {Object} boundary - boundary to search within
+     * @param {Object} boundary.topLeft - top left corner of the boundary
+     * @param {Number} boundary.topLeft.lat - top left corner latitude
+     * @param {Number} boundary.topLeft.lng - top left corner longitude
+     * @param {Object} boundary.bottomRight - bottom right corner of the boundary
+     * @param {Number} boundary.bottomRight.lat - bottom right corner latitude
+     * @param {Number} boundary.bottomRight.lng - bottom right corner longitude
+     * @param {Number} limit - maximum amount of results, can't be larger then RequestParameters.maxPerPage
+     * @returns {CancelablePromise<ResourceBase[]>} - target resource for boundary
+     * @throws {ApiError} - If the api returns errors
+     * @throws TypeError
+     * @throws GeoError
+     */
+    forBoundary({ topLeft, bottomRight }: {
+        topLeft: {
+            lat: number;
+            lng: number;
+        };
+        bottomRight: {
+            lat: number;
+            lng: number;
+        };
+    }, limit?: number): CancelablePromise<ResourceBase[]>;
+    /**
+     * Get an array of results for point
+     * @param {Object} point - point to search at
+     * @param {Number} point.lat - top left corner latitude
+     * @param {Number} point.lng - top left corner longitude
+     * @param {Number} limit - maximum amount of results, can't be larger then RequestParameters.maxPerPage
+     * @returns {CancelablePromise<ResourceBase[]>} - target resource for boundary
+     * @throws {ApiError} - If the api returns errors
+     * @throws TypeError
+     * @throws GeoError
+     */
+    forPoint({ lat, lng }: {
+        lat: number;
+        lng: number;
+    }, limit?: number): CancelablePromise<ResourceBase[]>;
+}
+import ResourceProxy from "./ResourceProxy";
+//# sourceMappingURL=GeoResourceProxy.d.ts.map

package/dist/proxy/OrganisationProxy.d.ts

@@ -0,0 +1,62 @@
+export default class OrganisationProxy extends SimpleResourceProxy {
+    /**
+     * @param {Mapcreator} api - Instance of the api
+     * @param {ResourceBase} parent - Parent instance
+     */
+    constructor(api: Mapcreator, parent: ResourceBase);
+    _parent: ResourceBase;
+    /**
+     * Returns parent instance
+     * @returns {ResourceBase} - Parent instance
+     */
+    get parent(): ResourceBase;
+    /**
+     * Sync organisations to the parent resource
+     * The organisations attached to the target resource will be replaced with the organisations provided in the request.
+     * @param {Array<Organisation|number>} organisations - List of items to sync
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    sync(organisations: Array<Organisation | number>): CancelablePromise;
+    /**
+     * Attach organisations to the parent resource
+     * The provided organisations will be attached to the resource if they're not already attached
+     * @param {Array<Organisation|number>} organisations - List of items to attach
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    attach(organisations: Array<Organisation | number>): CancelablePromise;
+    /**
+     * Detach organisations from the parent resource
+     * The provided organisations will be detached from the resource
+     * @param {Array<Organisation|number>} organisations - List of items to detach
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    detach(organisations: Array<Organisation | number>): CancelablePromise;
+    /**
+     * Attach all organisations to the parent resource
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    attachAll(): CancelablePromise;
+    /**
+     * Detach all organisations from the parent resource
+     * @throws {ApiError} - If the api returns errors
+     * @returns {CancelablePromise}
+     */
+    detachAll(): CancelablePromise;
+    /**
+     * Sync, attach or unlink resources
+     * @param {Array<Organisation|Number>|Organisation|Number} items - List of items to sync or attach
+     * @param {String} method - Http method to use
+     * @param {Class<ResourceBase>} Type - Resource type
+     * @param {?String} path - Optional appended resource path, will guess if null
+     * @throws {ApiError} - If the api returns errors
+     * @protected
+     * @returns {CancelablePromise}
+     */
+    protected _modifyLink(items: Array<Organisation | number> | Organisation | number, method: string, Type: Class<ResourceBase>, path?: string | null): CancelablePromise;
+}
+import SimpleResourceProxy from "./SimpleResourceProxy";
+//# sourceMappingURL=OrganisationProxy.d.ts.map