@cloudize/sdk-core 23.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Cloudize Limited.
+
+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,23 @@
+# Cloudize SDK Core Package
+
+![](https://img.shields.io/badge/build-passing-brightgreen)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/8c3c5f94c0ac457ab23170cd9fca50f9)](https://www.codacy.com/gh/apigames-core/sdk-core/dashboard?utm_source=github.com&utm_medium=referral&utm_content=apigames-core/sdk-core&utm_campaign=Badge_Grade)
+[![Codacy Badge](https://app.codacy.com/project/badge/Coverage/8c3c5f94c0ac457ab23170cd9fca50f9)](https://www.codacy.com/gh/apigames-core/sdk-core/dashboard?utm_source=github.com&utm_medium=referral&utm_content=apigames-core/sdk-core&utm_campaign=Badge_Coverage)
+![](https://img.shields.io/npm/v/@cloudize/sdk-core)
+![](https://img.shields.io/badge/license-MIT-blue)
+
+This package includes the core capabilites required by SDKs built to access the Cloudize Platform.
+
+## Download & Installation
+
+```shell 
+$ npm i @cloudize/sdk-core
+```
+
+## Authors or Acknowledgments
+
+*   Cloudize Limited
+
+## License
+
+This project is licensed under the MIT License

package/lib/classes/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ResourceContainer, ResourceContainerParams, ResourceFilterType } from './resource.container';
+export { default as ResourceObject, ResourceObjectClass, ResourceObjectMode } from './resource.object';
+export { ResourceHeaderParams } from './resource.header.params';
+export { ResourcePathParams } from './resource.path.params';
+export { SDKConfiguration, SDKConfig } from './sdk.config';

package/lib/classes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKConfig = exports.SDKConfiguration = exports.ResourceObjectMode = exports.ResourceObject = exports.ResourceFilterType = exports.ResourceContainer = void 0;
+var resource_container_1 = require("./resource.container");
+Object.defineProperty(exports, "ResourceContainer", { enumerable: true, get: function () { return __importDefault(resource_container_1).default; } });
+Object.defineProperty(exports, "ResourceFilterType", { enumerable: true, get: function () { return resource_container_1.ResourceFilterType; } });
+var resource_object_1 = require("./resource.object");
+Object.defineProperty(exports, "ResourceObject", { enumerable: true, get: function () { return __importDefault(resource_object_1).default; } });
+Object.defineProperty(exports, "ResourceObjectMode", { enumerable: true, get: function () { return resource_object_1.ResourceObjectMode; } });
+var sdk_config_1 = require("./sdk.config");
+Object.defineProperty(exports, "SDKConfiguration", { enumerable: true, get: function () { return sdk_config_1.SDKConfiguration; } });
+Object.defineProperty(exports, "SDKConfig", { enumerable: true, get: function () { return sdk_config_1.SDKConfig; } });

package/lib/classes/resource.container.d.ts

@@ -0,0 +1,57 @@
+import { IRestClient, RestClientResponse } from '@cloudize/rest-client';
+import { IResourceContainer, IResourceObject, ResourceContainerIncludedResourceTypes, ResourceHeaderParams, ResourcePathParams, ResourceFilterName, ResourceFilterValue, ResourceIncludeOption, ResourceSortOption, SDKConfiguration } from '..';
+export declare enum ResourceFilterType {
+    Equal = "equal",
+    NotEqual = "!equal",
+    From = "from",
+    To = "to",
+    AutoComplete = "autocomplete",
+    TextSearch = "text",
+    NearLocation = "near",
+    Exists = "exists"
+}
+export type ResourceContainerParams = {
+    restClient?: IRestClient;
+    sdkConfig?: SDKConfiguration;
+};
+export default class ResourceContainer implements IResourceContainer {
+    private _count;
+    private _countQueryHash;
+    protected _data: IResourceObject | IResourceObject[];
+    protected _includes: ResourceContainerIncludedResourceTypes;
+    private _queryParams;
+    private readonly _restClient;
+    private readonly _sdkConfig;
+    protected headerParams: ResourceHeaderParams;
+    protected pathParams: ResourcePathParams;
+    constructor(params?: ResourceContainerParams);
+    get data(): IResourceObject | IResourceObject[];
+    get includes(): ResourceContainerIncludedResourceTypes;
+    get restClient(): IRestClient;
+    get sdkConfig(): SDKConfiguration;
+    get uri(): string;
+    isResourceObject(value: any): value is IResourceObject;
+    isResourceList(value: any): value is IResourceObject[];
+    protected EndpointContentType(): string;
+    protected EndpointPath(): string;
+    protected ClearData(): void;
+    protected AddResourceToMemoryStructure(obj: IResourceObject): void;
+    private RemoveResourceFromMemoryStructure;
+    protected LoadResourceData(resourceData: any): IResourceObject;
+    protected LoadResponse(response: RestClientResponse): void;
+    Add(): IResourceObject;
+    Delete(resource: IResourceObject): Promise<void>;
+    Count(): Promise<number>;
+    Find(): Promise<void>;
+    Get(id: string): Promise<void>;
+    InitParams(): void;
+    private InitializeDefaultHeaderParams;
+    GetHeaders(action: string): ResourceHeaderParams;
+    private GetQueryParams;
+    IncludedObject(type: string, id: string): IResourceObject;
+    Filter(filter: ResourceFilterName, selector: ResourceFilterType, value: ResourceFilterValue): IResourceContainer;
+    Sort(option: ResourceSortOption): IResourceContainer;
+    Include(include: ResourceIncludeOption): IResourceContainer;
+    PageOffset(pageOffset: number, pageSize: number): IResourceContainer;
+    PageNumber(pageNumber: number, pageSize: number): IResourceContainer;
+}

package/lib/classes/resource.container.js

@@ -0,0 +1,322 @@
+"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.ResourceFilterType = void 0;
+const json_1 = require("@cloudize/json");
+const rest_client_1 = require("@cloudize/rest-client");
+const __1 = require("..");
+const resource_object_1 = require("./resource.object");
+const hash = require('object-hash');
+var ResourceFilterType;
+(function (ResourceFilterType) {
+    ResourceFilterType["Equal"] = "equal";
+    ResourceFilterType["NotEqual"] = "!equal";
+    ResourceFilterType["From"] = "from";
+    ResourceFilterType["To"] = "to";
+    ResourceFilterType["AutoComplete"] = "autocomplete";
+    ResourceFilterType["TextSearch"] = "text";
+    ResourceFilterType["NearLocation"] = "near";
+    ResourceFilterType["Exists"] = "exists";
+})(ResourceFilterType = exports.ResourceFilterType || (exports.ResourceFilterType = {}));
+class ResourceContainer {
+    constructor(params) {
+        this._data = undefined;
+        this._includes = {};
+        this._restClient = (0, json_1.isDefined)(params === null || params === void 0 ? void 0 : params.restClient) ? params === null || params === void 0 ? void 0 : params.restClient : new rest_client_1.RestClient();
+        this._sdkConfig = (0, json_1.isDefined)(params === null || params === void 0 ? void 0 : params.sdkConfig) ? params === null || params === void 0 ? void 0 : params.sdkConfig : (0, __1.SDKConfig)();
+        this.headerParams = {};
+        this.pathParams = {};
+        this._queryParams = {
+            includes: {},
+            filters: {},
+            sort: undefined,
+            pagination: {},
+        };
+    }
+    get data() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get includes() {
+        return this._includes;
+    }
+    get restClient() {
+        return this._restClient;
+    }
+    get sdkConfig() {
+        return this._sdkConfig;
+    }
+    get uri() {
+        let uriPath = this.EndpointPath();
+        for (const pathParam in this.pathParams) {
+            if ((0, json_1.hasProperty)(this.pathParams, pathParam)) {
+                uriPath = uriPath.replace(`{${pathParam}}`, this.pathParams[pathParam]);
+            }
+        }
+        return uriPath;
+    }
+    isResourceObject(value) {
+        return (0, json_1.isObject)(value);
+    }
+    isResourceList(value) {
+        return (0, json_1.isArray)(value);
+    }
+    EndpointContentType() {
+        throw new Error('Method or Property not implemented.');
+    }
+    EndpointPath() {
+        throw new Error('Method or Property not implemented.');
+    }
+    ClearData() {
+        this._data = undefined;
+        this._includes = {};
+    }
+    AddResourceToMemoryStructure(obj) {
+        if ((0, json_1.isDefined)(this.data)) {
+            if (this.isResourceObject(this.data)) {
+                const currentObj = this.data;
+                this._data = [currentObj];
+            }
+            if (this.isResourceList(this.data)) {
+                this.data.push(obj);
+            }
+        }
+        else {
+            this._data = obj;
+        }
+        this._countQueryHash = undefined;
+    }
+    RemoveResourceFromMemoryStructure(resource) {
+        if (this.isResourceList(this.data)) {
+            this.data.forEach((item, index) => {
+                if (this.isResourceList(this.data) && (item.id === resource.id))
+                    this.data.splice(index, 1);
+            });
+        }
+        else if (this.isResourceObject(this.data) && this.data.id === resource.id) {
+            this._data = undefined;
+        }
+        this._countQueryHash = undefined;
+    }
+    LoadResourceData(resourceData) {
+        if ((0, json_1.hasProperty)(resourceData, 'type') && (0, json_1.isString)(resourceData.type)) {
+            if ((0, json_1.hasProperty)(resourceData, 'id') && (0, json_1.isString)(resourceData.id)) {
+                const ResourceClass = this.sdkConfig.ResourceClass(resourceData.type);
+                return new ResourceClass(this, resource_object_1.ResourceObjectMode.ExistingDocument).LoadData(resourceData);
+            }
+            throw new __1.SDKException('INVALID-RESOURCE-ID', 'The resource being loaded doesn\'t have the required resource id.');
+        }
+        throw new __1.SDKException('INVALID-RESOURCE-TYPE', 'The resource being loaded doesn\'t have the required resource type.');
+    }
+    LoadResponse(response) {
+        this.ClearData();
+        if ((0, json_1.hasProperty)(response.data, 'data')) {
+            if ((0, json_1.isArray)(response.data.data)) {
+                this._data = [];
+                for (const resourceData of response.data.data) {
+                    this.AddResourceToMemoryStructure(this.LoadResourceData(resourceData));
+                }
+            }
+            else if ((0, json_1.isObject)(response.data.data)) {
+                this.AddResourceToMemoryStructure(this.LoadResourceData(response.data.data));
+            }
+        }
+        if ((0, json_1.hasProperty)(response.data, 'included')) {
+            if ((0, json_1.isArray)(response.data.included)) {
+                for (const resourceData of response.data.included) {
+                    const resourceObject = this.LoadResourceData(resourceData);
+                    if ((0, json_1.isUndefined)(this._includes[resourceObject.type]))
+                        this._includes[resourceObject.type] = {};
+                    this._includes[resourceObject.type][resourceObject.id] = resourceObject;
+                }
+            }
+        }
+    }
+    Add() {
+        throw new Error('Method or Property not implemented.');
+    }
+    Delete(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((0, json_1.isDefined)(resource.id)) {
+                const queryUri = `${this.uri}/${resource.id}`;
+                const queryHeaders = this.GetHeaders('DELETE');
+                const queryOptions = {
+                    queryParams: this.GetQueryParams(),
+                };
+                this.InitParams();
+                (0, json_1.redactUndefinedValues)(queryOptions);
+                yield this._restClient.Delete(queryUri, queryHeaders, queryOptions);
+                this.RemoveResourceFromMemoryStructure(resource);
+            }
+            else {
+                this.RemoveResourceFromMemoryStructure(resource);
+            }
+        });
+    }
+    Count() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryUri = `${this.uri}`;
+            const queryHeaders = this.GetHeaders('COUNT');
+            const queryOptions = {
+                queryParams: this.GetQueryParams(),
+            };
+            if ((0, json_1.isDefinedAndNotNull)(queryOptions.queryParams)) {
+                (0, json_1.extractAndRedact)(queryOptions.queryParams, 'include');
+                (0, json_1.extractAndRedact)(queryOptions.queryParams, 'page[number]');
+                (0, json_1.extractAndRedact)(queryOptions.queryParams, 'page[offset]');
+                (0, json_1.extractAndRedact)(queryOptions.queryParams, 'page[size]');
+                (0, json_1.extractAndRedact)(queryOptions.queryParams, 'sort');
+            }
+            (0, json_1.redactUndefinedValues)(queryOptions);
+            const queryParams = {
+                uri: queryUri,
+                headers: queryHeaders,
+                queryOptions,
+            };
+            const queryHash = hash(queryParams);
+            if ((0, json_1.isDefinedAndNotNull)(this._countQueryHash) && (this._countQueryHash === queryHash) && (0, json_1.isDefinedAndNotNull)(this._count)) {
+                return this._count;
+            }
+            if ((0, json_1.isUndefinedOrNull)(queryOptions.queryParams))
+                queryOptions.queryParams = {};
+            queryOptions.queryParams['meta-action'] = 'count';
+            const response = yield this._restClient.Get(queryUri, queryHeaders, queryOptions);
+            if ((0, json_1.hasProperty)(response, 'data') && (0, json_1.hasProperty)(response.data, 'meta')
+                && (0, json_1.hasProperty)(response.data.meta, 'count') && (0, json_1.isNumber)(response.data.meta.count)) {
+                this._count = response.data.meta.count;
+                this._countQueryHash = queryHash;
+                return this._count;
+            }
+            throw new __1.SDKException('COUNT-FAILED', 'The request to count the number of resources related '
+                + 'to this query was unsuccessful.');
+        });
+    }
+    Find() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ClearData();
+            const queryUri = `${this.uri}`;
+            const queryHeaders = this.GetHeaders('FIND');
+            const queryOptions = {
+                queryParams: this.GetQueryParams(),
+            };
+            this.InitParams();
+            (0, json_1.redactUndefinedValues)(queryOptions);
+            this.LoadResponse(yield this._restClient.Get(queryUri, queryHeaders, queryOptions));
+        });
+    }
+    Get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ClearData();
+            const queryUri = `${this.uri}/${id}`;
+            const queryHeaders = this.GetHeaders('GET');
+            const queryOptions = {
+                queryParams: this.GetQueryParams(),
+            };
+            this.InitParams();
+            (0, json_1.redactUndefinedValues)(queryOptions);
+            this.LoadResponse(yield this._restClient.Get(queryUri, queryHeaders, queryOptions));
+        });
+    }
+    InitParams() {
+        this._queryParams = {
+            includes: {},
+            filters: {},
+            sort: undefined,
+            pagination: {},
+        };
+    }
+    InitializeDefaultHeaderParams() {
+        const headers = {};
+        if ((0, json_1.isDefined)(this.headerParams)) {
+            for (const headerParamName in this.headerParams) {
+                if ((0, json_1.hasProperty)(this.headerParams, headerParamName)) {
+                    headers[headerParamName] = this.headerParams[headerParamName];
+                }
+            }
+        }
+        return headers;
+    }
+    GetHeaders(action) {
+        const headers = this.InitializeDefaultHeaderParams();
+        switch (action) {
+            case 'GET':
+            case 'COUNT':
+            case 'FIND':
+                headers.Accept = this.EndpointContentType();
+                break;
+            default:
+                headers.Accept = this.EndpointContentType();
+                headers['Content-Type'] = this.EndpointContentType();
+                break;
+        }
+        if ((0, json_1.isDefined)(this.sdkConfig.apiKey)) {
+            headers['x-api-key'] = this.sdkConfig.apiKey;
+        }
+        if ((0, json_1.isDefined)(this.sdkConfig.accessToken)) {
+            headers.Authorization = `Bearer ${this.sdkConfig.accessToken}`;
+        }
+        return headers;
+    }
+    GetQueryParams() {
+        const queryParams = {};
+        for (const filterName in this._queryParams.filters) {
+            if ((0, json_1.hasProperty)(this._queryParams.filters, filterName)) {
+                queryParams[`filter[${filterName}]`] = this._queryParams.filters[filterName];
+            }
+        }
+        const includeList = [];
+        for (const includeName in this._queryParams.includes) {
+            if ((0, json_1.hasProperty)(this._queryParams.includes, includeName)) {
+                includeList.push(includeName);
+            }
+        }
+        if (includeList.length > 0)
+            queryParams.include = includeList.join(',');
+        if ((0, json_1.hasProperty)(this._queryParams.pagination, 'offset'))
+            queryParams['page[offset]'] = this._queryParams.pagination.offset;
+        if ((0, json_1.hasProperty)(this._queryParams.pagination, 'page'))
+            queryParams['page[number]'] = this._queryParams.pagination.page;
+        if ((0, json_1.hasProperty)(this._queryParams.pagination, 'size'))
+            queryParams['page[size]'] = this._queryParams.pagination.size;
+        if ((0, json_1.isDefined)(this._queryParams.sort))
+            queryParams.sort = this._queryParams.sort;
+        if ((0, json_1.isEmpty)(queryParams))
+            return undefined;
+        return queryParams;
+    }
+    IncludedObject(type, id) {
+        throw new Error('Method or Property not implemented.');
+    }
+    Filter(filter, selector, value) {
+        this._queryParams.filters[`${selector}:${filter}`] = value;
+        return this;
+    }
+    Sort(option) {
+        this._queryParams.sort = option;
+        return this;
+    }
+    Include(include) {
+        this._queryParams.includes[include] = true;
+        return this;
+    }
+    PageOffset(pageOffset, pageSize) {
+        (0, json_1.extractAndRedact)(this._queryParams.pagination, 'page');
+        this._queryParams.pagination.offset = pageOffset;
+        this._queryParams.pagination.size = pageSize;
+        return this;
+    }
+    PageNumber(pageNumber, pageSize) {
+        (0, json_1.extractAndRedact)(this._queryParams.pagination, 'offset');
+        this._queryParams.pagination.page = pageNumber;
+        this._queryParams.pagination.size = pageSize;
+        return this;
+    }
+}
+exports.default = ResourceContainer;

package/lib/classes/resource.header.params.d.ts

@@ -0,0 +1,3 @@
+export type ResourceHeaderParams = {
+    [index: string]: string;
+};

package/lib/classes/resource.header.params.js

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

package/lib/classes/resource.object.d.ts

@@ -0,0 +1,38 @@
+import { IResourceContainer, IResourceObject, IResourceObjectAttributes, IResourceObjectRelationships, ResourceObjectUri } from '..';
+export declare enum ResourceObjectMode {
+    NewDocument = 0,
+    ExistingDocument = 1
+}
+export default class ResourceObject implements IResourceObject {
+    private _container;
+    private _id;
+    private _mode;
+    private _uri;
+    constructor(container: IResourceContainer, mode: ResourceObjectMode);
+    protected EndpointContentType(): string;
+    protected LoadAttributes(value: any): void;
+    protected LoadRelationships(value: any): void;
+    protected RelationshipType(relationshipName: string): string;
+    UpdateAttributes(value: any): void;
+    UpdateRelationships(value: any): void;
+    LoadData(value: any): IResourceObject;
+    protected SerializeAttributesPayload(shadow: any, data: any): any;
+    protected SerializeRelationshipsPayload(shadow: any, data: any): any;
+    protected GetInsertPayload(): any;
+    protected GetUpdatePayload(): any;
+    Delete(): Promise<void>;
+    private GetHeaderValue;
+    private HasHeader;
+    private InsertResource;
+    private UpdateResource;
+    Save(): Promise<void>;
+    get type(): string;
+    get id(): string;
+    set id(value: string);
+    get attributes(): IResourceObjectAttributes;
+    get relationships(): IResourceObjectRelationships;
+    protected get shadowAttributes(): IResourceObjectAttributes;
+    protected get shadowRelationships(): IResourceObjectRelationships;
+    get uri(): ResourceObjectUri;
+}
+export type ResourceObjectClass = typeof ResourceObject;