@cloudize/sdk-core 23.1.3

package/lib/classes/resource.object.js

@@ -0,0 +1,279 @@
+"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.ResourceObjectMode = void 0;
+const json_1 = require("@cloudize/json");
+const __1 = require("..");
+var ResourceObjectMode;
+(function (ResourceObjectMode) {
+    ResourceObjectMode[ResourceObjectMode["NewDocument"] = 0] = "NewDocument";
+    ResourceObjectMode[ResourceObjectMode["ExistingDocument"] = 1] = "ExistingDocument";
+})(ResourceObjectMode = exports.ResourceObjectMode || (exports.ResourceObjectMode = {}));
+class ResourceObject {
+    constructor(container, mode) {
+        this._mode = ResourceObjectMode.NewDocument;
+        this._container = container;
+        this._mode = mode;
+    }
+    EndpointContentType() {
+        throw new Error('Method or Property not implemented.');
+    }
+    LoadAttributes(value) {
+        throw new Error('Method or Property not implemented.');
+    }
+    LoadRelationships(value) {
+        throw new Error('Method or Property not implemented.');
+    }
+    RelationshipType(relationshipName) {
+        throw new Error('Method or Property not implemented.');
+    }
+    UpdateAttributes(value) {
+        throw new Error('Method or Property not implemented.');
+    }
+    UpdateRelationships(value) {
+        throw new Error('Method or Property not implemented.');
+    }
+    LoadData(value) {
+        if (!(0, json_1.hasProperty)(value, 'type') || (value.type !== this.type)) {
+            throw new __1.SDKException('INVALID-RESOURCE-MAPPING', 'The resource data being loaded cannot be '
+                + 'read into this object');
+        }
+        if ((0, json_1.hasProperty)(value, 'id'))
+            this._id = value.id;
+        if ((0, json_1.hasProperty)(value, 'attributes'))
+            this.LoadAttributes(value.attributes);
+        if ((0, json_1.hasProperty)(value, 'relationships'))
+            this.LoadRelationships(value.relationships);
+        if ((0, json_1.hasProperty)(value, 'links') && (0, json_1.isObject)(value.links) && (0, json_1.hasProperty)(value.links, 'self')
+            && (0, json_1.isString)(value.links.self)) {
+            this._uri = value.links.self;
+        }
+        this._mode = ResourceObjectMode.ExistingDocument;
+        return this;
+    }
+    SerializeAttributesPayload(shadow, data) {
+        if ((0, json_1.areEqual)(shadow, data))
+            return undefined;
+        if ((0, json_1.isUndefined)(data) && (0, json_1.isUndefined)(shadow))
+            return undefined;
+        if ((0, json_1.isUndefined)(shadow))
+            return data;
+        if ((0, json_1.isDate)(data))
+            return data;
+        if ((0, json_1.isArray)(data))
+            return data;
+        if ((0, json_1.isObject)(data)) {
+            if ((Object.keys(data).length === 2)
+                && ((0, json_1.hasProperty)(data, 'latitude') && (0, json_1.isNumber)(data.latitude))
+                && ((0, json_1.hasProperty)(data, 'longitude') && (0, json_1.isNumber)(data.longitude))) {
+                return data;
+            }
+            const payload = {};
+            for (const fieldName in data) {
+                if ((0, json_1.hasProperty)(data, fieldName)) {
+                    if ((0, json_1.isDefined)(shadow))
+                        payload[fieldName] = this.SerializeAttributesPayload(shadow[fieldName], data[fieldName]);
+                    else
+                        payload[fieldName] = this.SerializeAttributesPayload(undefined, data[fieldName]);
+                }
+            }
+            if ((0, json_1.isDefined)(shadow) && (0, json_1.isObject)(shadow)) {
+                for (const fieldName in shadow) {
+                    if ((0, json_1.hasProperty)(shadow, fieldName)) {
+                        if ((0, json_1.isDefinedAndNotNull)(shadow[fieldName]) && (0, json_1.isUndefinedOrNull)(data[fieldName]))
+                            payload[fieldName] = null;
+                    }
+                }
+            }
+            return payload;
+        }
+        return data;
+    }
+    SerializeRelationshipsPayload(shadow, data) {
+        if ((0, json_1.areEqual)(shadow, data))
+            return undefined;
+        if ((0, json_1.isUndefined)(data) && (0, json_1.isUndefined)(shadow))
+            return undefined;
+        if ((0, json_1.isObject)(data)) {
+            const payload = {};
+            for (const fieldName in data) {
+                if ((0, json_1.hasProperty)(data, fieldName)) {
+                    if ((0, json_1.isDefinedAndNotNull)(data[fieldName])) {
+                        if ((0, __1.isResourceObjectRelationships)(data[fieldName])) {
+                            payload[fieldName] = {
+                                data: [],
+                            };
+                            for (const relationship of data[fieldName]) {
+                                payload[fieldName].data.push({
+                                    type: relationship.type,
+                                    id: relationship.id,
+                                });
+                            }
+                        }
+                        else if ((0, __1.isResourceObjectRelationship)(data[fieldName])) {
+                            if ((0, json_1.isUndefined)(shadow)
+                                || (0, json_1.isUndefined)(shadow[fieldName])
+                                || ((shadow[fieldName].type !== data[fieldName].type) || (shadow[fieldName].id !== data[fieldName].id))) {
+                                if (data[fieldName].id === null) {
+                                    payload[fieldName] = { data: null };
+                                }
+                                else {
+                                    payload[fieldName] = {
+                                        data: {
+                                            type: data[fieldName].type,
+                                            id: data[fieldName].id,
+                                        },
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if ((0, json_1.isDefined)(shadow) && (0, json_1.isObject)(shadow)) {
+                for (const fieldName in shadow) {
+                    if ((0, json_1.hasProperty)(shadow, fieldName)) {
+                        if ((0, json_1.isDefinedAndNotNull)(shadow[fieldName]) && (0, json_1.isUndefinedOrNull)(data[fieldName]))
+                            payload[fieldName] = null;
+                    }
+                }
+            }
+            return payload;
+        }
+        return data;
+    }
+    GetInsertPayload() {
+        const payload = {
+            data: {
+                type: this.type,
+            },
+        };
+        if ((0, json_1.isDefined)(this.id))
+            payload.data.id = this.id;
+        if ((0, json_1.isDefined)(this.attributes)) {
+            payload.data.attributes = this.SerializeAttributesPayload(this.shadowAttributes, this.attributes);
+        }
+        if ((0, json_1.isDefined)(this.relationships)) {
+            payload.data.relationships = this.SerializeRelationshipsPayload(this.shadowRelationships, this.relationships);
+        }
+        (0, json_1.redactUndefinedValues)(payload);
+        return payload;
+    }
+    GetUpdatePayload() {
+        const payload = {
+            data: {
+                type: this.type,
+                id: this.id,
+            },
+        };
+        if ((0, json_1.isDefined)(this.attributes)) {
+            payload.data.attributes = this.SerializeAttributesPayload(this.shadowAttributes, this.attributes);
+        }
+        if ((0, json_1.isDefined)(this.relationships)) {
+            payload.data.relationships = this.SerializeRelationshipsPayload(this.shadowRelationships, this.relationships);
+        }
+        (0, json_1.redactUndefinedValues)(payload);
+        return payload;
+    }
+    Delete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._container.Delete(this);
+        });
+    }
+    GetHeaderValue(headers, key) {
+        let value;
+        for (const headerName in headers) {
+            if (headerName.toLowerCase() === key.toLowerCase()) {
+                value = headers[headerName];
+            }
+        }
+        return value;
+    }
+    HasHeader(headers, key) {
+        let hasHeader = false;
+        for (const headerName in headers) {
+            if (headerName.toLowerCase() === key.toLowerCase()) {
+                hasHeader = true;
+            }
+        }
+        return hasHeader;
+    }
+    InsertResource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryUri = this._container.uri;
+            const queryHeaders = this._container.GetHeaders('INSERT');
+            const queryOptions = {};
+            const payload = this.GetInsertPayload();
+            const response = yield this._container.restClient.Post(queryUri, payload, queryHeaders, queryOptions);
+            if (!this.HasHeader(response.headers, 'location')) {
+                throw new __1.SDKException('INVALID-LOCATION', 'The save operation was unable to retrieve the location '
+                    + 'of the resource created by the API.');
+            }
+            if (!this.HasHeader(response.headers, 'x-api-resource-id')) {
+                throw new __1.SDKException('INVALID-RESOURCE-ID', 'The save operation was unable to retrieve the '
+                    + 'identifier of the resource created by the API.');
+            }
+            this.id = this.GetHeaderValue(response.headers, 'x-api-resource-id');
+            this._uri = this.GetHeaderValue(response.headers, 'location');
+            this._mode = ResourceObjectMode.ExistingDocument;
+        });
+    }
+    UpdateResource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryUri = this.uri;
+            const queryHeaders = this._container.GetHeaders('UPDATE');
+            const queryOptions = {};
+            const payload = this.GetUpdatePayload();
+            yield this._container.restClient.Patch(queryUri, payload, queryHeaders, queryOptions);
+        });
+    }
+    Save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._mode === ResourceObjectMode.NewDocument) {
+                yield this.InsertResource();
+            }
+            else {
+                yield this.UpdateResource();
+            }
+            if ((0, json_1.isDefined)(this.attributes)) {
+                this.shadowAttributes.LoadData(this.attributes, __1.ResourceObjectAttributesLoadType.Replace);
+            }
+            if ((0, json_1.isDefined)(this.relationships)) {
+                this.shadowRelationships.LoadData(this.relationships, __1.ResourceObjectRelationshipsLoadType.Replace);
+            }
+        });
+    }
+    get type() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get attributes() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get relationships() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get shadowAttributes() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get shadowRelationships() {
+        throw new Error('Method or Property not implemented.');
+    }
+    get uri() {
+        return this._uri;
+    }
+}
+exports.default = ResourceObject;

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

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

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

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

package/lib/classes/sdk.config.d.ts

@@ -0,0 +1,21 @@
+import { ResourceObjectClass } from './resource.object';
+export type SDKResourceMap = {
+    [index: string]: ResourceObjectClass;
+};
+export declare class SDKConfiguration {
+    private _accessToken;
+    private _apiKey;
+    private _hostName;
+    private _resourceMap;
+    constructor();
+    RegisterResourceClass(type: string, resourceClass: ResourceObjectClass): void;
+    ResourceClass(type: string): ResourceObjectClass;
+    FormatURL(path: string): string;
+    get accessToken(): string;
+    set accessToken(value: string);
+    get apiKey(): string;
+    set apiKey(value: string);
+    get hostName(): string;
+    set hostName(value: string);
+}
+export declare function SDKConfig(): SDKConfiguration;

package/lib/classes/sdk.config.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKConfig = exports.SDKConfiguration = void 0;
+const json_1 = require("@cloudize/json");
+class SDKConfiguration {
+    constructor() {
+        this._resourceMap = {};
+    }
+    RegisterResourceClass(type, resourceClass) {
+        this._resourceMap[type] = resourceClass;
+    }
+    ResourceClass(type) {
+        return this._resourceMap[type];
+    }
+    FormatURL(path) {
+        let url = this.hostName;
+        url = url.endsWith('/') ? url.slice(0, -1) : url;
+        return path.startsWith('/') ? `${url}${path}` : `${url}/${path}`;
+    }
+    get accessToken() {
+        return this._accessToken;
+    }
+    set accessToken(value) {
+        this._accessToken = value;
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    set apiKey(value) {
+        this._apiKey = value;
+    }
+    get hostName() {
+        return this._hostName;
+    }
+    set hostName(value) {
+        this._hostName = value;
+    }
+}
+exports.SDKConfiguration = SDKConfiguration;
+let configInstance;
+function SDKConfig() {
+    if ((0, json_1.isUndefined)(configInstance))
+        configInstance = new SDKConfiguration();
+    return configInstance;
+}
+exports.SDKConfig = SDKConfig;

package/lib/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { default as SDKException } from './sdk.exception';

package/lib/exceptions/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKException = void 0;
+var sdk_exception_1 = require("./sdk.exception");
+Object.defineProperty(exports, "SDKException", { enumerable: true, get: function () { return __importDefault(sdk_exception_1).default; } });

package/lib/exceptions/sdk.exception.d.ts

@@ -0,0 +1,6 @@
+import { ISDKException } from '..';
+export default class SDKException extends Error implements ISDKException {
+    private _code;
+    constructor(code: string, message: string);
+    get code(): string;
+}

package/lib/exceptions/sdk.exception.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SDKException extends Error {
+    constructor(code, message) {
+        super(message);
+        this._code = '';
+        this.name = 'SDKException';
+        this._code = code;
+    }
+    get code() {
+        return this._code;
+    }
+}
+exports.default = SDKException;

package/lib/helpers/index.d.ts

@@ -0,0 +1,3 @@
+import { GeospatialPoint } from '../interfaces';
+export declare function LoadDateTime(value: string): Date;
+export declare function LoadGeospatialPoint(geospatialPoint: GeospatialPoint, value: any): GeospatialPoint;

package/lib/helpers/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadGeospatialPoint = exports.LoadDateTime = void 0;
+const json_1 = require("@cloudize/json");
+const interfaces_1 = require("../interfaces");
+function LoadDateTime(value) {
+    if ((0, json_1.isDefined)(value))
+        return new Date(value);
+    return undefined;
+}
+exports.LoadDateTime = LoadDateTime;
+function LoadGeospatialPoint(geospatialPoint, value) {
+    if ((0, json_1.isUndefinedOrNull)(geospatialPoint)) {
+        if ((0, json_1.isDefined)(value) && (0, json_1.isObject)(value) && (Object.keys(value).length === 2)
+            && (0, json_1.hasProperty)(value, 'longitude') && (0, json_1.isNumber)(value.longitude)
+            && (0, json_1.hasProperty)(value, 'latitude') && (0, json_1.isNumber)(value.latitude)) {
+            const result = new interfaces_1.GeospatialPoint();
+            result.LoadData(value);
+            return result;
+        }
+    }
+    else if ((0, json_1.isDefined)(value) && (0, json_1.isObject)(value) && (Object.keys(value).length <= 2)
+        && (((0, json_1.hasProperty)(value, 'longitude') && (0, json_1.isNumber)(value.longitude))
+            || ((0, json_1.hasProperty)(value, 'latitude') && (0, json_1.isNumber)(value.latitude)))) {
+        geospatialPoint.LoadData(value);
+        return geospatialPoint;
+    }
+    return undefined;
+}
+exports.LoadGeospatialPoint = LoadGeospatialPoint;

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './exceptions';
+export * from './classes';
+export * from './helpers';
+export * from './type-guards';

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./exceptions"), exports);
+__exportStar(require("./classes"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./type-guards"), exports);

package/lib/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export { ISDKError, ISDKRequestError, ISDKException, ISDKRequestException, } from './sdk.errors';
+export { IResourceContainer, ResourceContainerIncludedResourceTypes, ResourceFilterName, ResourceFilterValue, ResourceSortOption, ResourceIncludeOption, IResourceObject, IResourceObjectAttributes, IResourceObjectRelationships, GeospatialPoint, ResourceObjectAttributeBase, ResourceObjectAttributesLoadType, ResourceObjectRelationshipLinkObject, ResourceObjectRelationshipLink, ResourceObjectRelationshipsLinks, ResourceObjectRelationshipsLoadType, ResourceObjectRelationship, ResourceObjectRelationships, ResourceObjectUri, ResourceObjectRelationshipBase, } from './resource.interfaces';

package/lib/interfaces/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceObjectRelationshipBase = exports.ResourceObjectRelationship = exports.ResourceObjectRelationshipsLoadType = exports.ResourceObjectAttributesLoadType = exports.ResourceObjectAttributeBase = exports.GeospatialPoint = void 0;
+var resource_interfaces_1 = require("./resource.interfaces");
+Object.defineProperty(exports, "GeospatialPoint", { enumerable: true, get: function () { return resource_interfaces_1.GeospatialPoint; } });
+Object.defineProperty(exports, "ResourceObjectAttributeBase", { enumerable: true, get: function () { return resource_interfaces_1.ResourceObjectAttributeBase; } });
+Object.defineProperty(exports, "ResourceObjectAttributesLoadType", { enumerable: true, get: function () { return resource_interfaces_1.ResourceObjectAttributesLoadType; } });
+Object.defineProperty(exports, "ResourceObjectRelationshipsLoadType", { enumerable: true, get: function () { return resource_interfaces_1.ResourceObjectRelationshipsLoadType; } });
+Object.defineProperty(exports, "ResourceObjectRelationship", { enumerable: true, get: function () { return resource_interfaces_1.ResourceObjectRelationship; } });
+Object.defineProperty(exports, "ResourceObjectRelationshipBase", { enumerable: true, get: function () { return resource_interfaces_1.ResourceObjectRelationshipBase; } });

package/lib/interfaces/resource.interfaces.d.ts

@@ -0,0 +1,94 @@
+import { IRestClient } from '@cloudize/rest-client';
+import { ResourceFilterType, ResourceHeaderParams } from '../classes';
+export type ResourceObjectType = string;
+export type ResourceObjectIdentifier = string;
+export declare enum ResourceObjectAttributesLoadType {
+    Replace = 0,
+    Update = 1
+}
+export interface IResourceObjectAttributes {
+    LoadData(data: any, action: ResourceObjectAttributesLoadType): void;
+}
+export type ResourceObjectRelationshipLinkObject = {
+    type: ResourceObjectType;
+    id: ResourceObjectIdentifier;
+};
+export type ResourceObjectRelationshipLink = {
+    data: ResourceObjectRelationshipLinkObject;
+};
+export type ResourceObjectRelationshipsLinks = {
+    data: ResourceObjectRelationshipLinkObject[];
+};
+export type ResourceContainerIncludedResources = {
+    [id: string]: IResourceObject;
+};
+export type ResourceContainerIncludedResourceTypes = {
+    [type: string]: ResourceContainerIncludedResources;
+};
+export declare class ResourceObjectRelationship {
+    private _includes;
+    readonly type: ResourceObjectType;
+    id: ResourceObjectIdentifier | null;
+    constructor(includes: ResourceContainerIncludedResourceTypes, type: ResourceObjectType, id?: ResourceObjectIdentifier);
+    clear(): void;
+    get target(): IResourceObject;
+}
+export type ResourceObjectRelationships = ResourceObjectRelationship[];
+export declare enum ResourceObjectRelationshipsLoadType {
+    Replace = 0,
+    Update = 1
+}
+export interface IResourceObjectRelationships {
+    LoadData(data: any, action: ResourceObjectRelationshipsLoadType): void;
+}
+export type ResourceObjectUri = string;
+export declare class ResourceObjectAttributeBase {
+    protected static LoadDateTime(value: string): Date;
+    protected static LoadGeospatialPoint(geospatialPoint: GeospatialPoint, value: any): GeospatialPoint;
+}
+export declare class GeospatialPoint extends ResourceObjectAttributeBase implements IResourceObjectAttributes {
+    longitude: number;
+    latitude: number;
+    LoadData(data: any): void;
+}
+export declare class ResourceObjectRelationshipBase {
+    private _includes;
+    constructor(includes: ResourceContainerIncludedResourceTypes);
+    protected LoadRelationship(expectedType: string, value: any): ResourceObjectRelationship;
+    protected LoadRelationships(expectedType: string, value: any): ResourceObjectRelationships;
+    static RelationshipType(relationshipName: string): string;
+}
+export interface IResourceObject {
+    type: ResourceObjectType;
+    id?: ResourceObjectIdentifier;
+    attributes: IResourceObjectAttributes;
+    relationships: IResourceObjectRelationships;
+    uri: ResourceObjectUri;
+    LoadData(value: any): IResourceObject;
+    Delete(): Promise<void>;
+    Save(): Promise<void>;
+    UpdateAttributes(value: any): void;
+    UpdateRelationships(value: any): void;
+}
+export type ResourceFilterName = string;
+export type ResourceFilterValue = string;
+export type ResourceSortOption = string;
+export type ResourceIncludeOption = string;
+export interface IResourceContainer {
+    data: IResourceObject | IResourceObject[];
+    includes: ResourceContainerIncludedResourceTypes;
+    restClient: IRestClient;
+    uri: string;
+    Filter(filter: ResourceFilterName, selector: ResourceFilterType, value: ResourceFilterValue): IResourceContainer;
+    GetHeaders(action: string): ResourceHeaderParams;
+    Sort(option: ResourceSortOption): IResourceContainer;
+    Include(include: ResourceIncludeOption): IResourceContainer;
+    PageOffset(pageOffset: number, pageSize: number): IResourceContainer;
+    PageNumber(pageNumber: number, pageSize: number): IResourceContainer;
+    Add(): IResourceObject;
+    Count(): Promise<number>;
+    Delete(resource: IResourceObject): Promise<void>;
+    Find(): Promise<void>;
+    Get(id: string): Promise<void>;
+    IncludedObject(type: ResourceObjectType, id: ResourceObjectIdentifier): IResourceObject;
+}

package/lib/interfaces/resource.interfaces.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceObjectRelationshipBase = exports.GeospatialPoint = exports.ResourceObjectAttributeBase = exports.ResourceObjectRelationshipsLoadType = exports.ResourceObjectRelationship = exports.ResourceObjectAttributesLoadType = void 0;
+const json_1 = require("@cloudize/json");
+const helpers_1 = require("../helpers");
+var ResourceObjectAttributesLoadType;
+(function (ResourceObjectAttributesLoadType) {
+    ResourceObjectAttributesLoadType[ResourceObjectAttributesLoadType["Replace"] = 0] = "Replace";
+    ResourceObjectAttributesLoadType[ResourceObjectAttributesLoadType["Update"] = 1] = "Update";
+})(ResourceObjectAttributesLoadType = exports.ResourceObjectAttributesLoadType || (exports.ResourceObjectAttributesLoadType = {}));
+class ResourceObjectRelationship {
+    constructor(includes, type, id) {
+        this._includes = includes;
+        this.type = type;
+        if (id)
+            this.id = id;
+    }
+    clear() {
+        this.id = null;
+    }
+    get target() {
+        if ((0, json_1.isDefined)(this.type) && (0, json_1.isDefined)(this.id) && (0, json_1.isDefined)(this._includes[this.type][this.id])) {
+            return this._includes[this.type][this.id];
+        }
+        return undefined;
+    }
+}
+exports.ResourceObjectRelationship = ResourceObjectRelationship;
+var ResourceObjectRelationshipsLoadType;
+(function (ResourceObjectRelationshipsLoadType) {
+    ResourceObjectRelationshipsLoadType[ResourceObjectRelationshipsLoadType["Replace"] = 0] = "Replace";
+    ResourceObjectRelationshipsLoadType[ResourceObjectRelationshipsLoadType["Update"] = 1] = "Update";
+})(ResourceObjectRelationshipsLoadType = exports.ResourceObjectRelationshipsLoadType || (exports.ResourceObjectRelationshipsLoadType = {}));
+class ResourceObjectAttributeBase {
+    static LoadDateTime(value) {
+        return (0, helpers_1.LoadDateTime)(value);
+    }
+    static LoadGeospatialPoint(geospatialPoint, value) {
+        return (0, helpers_1.LoadGeospatialPoint)(geospatialPoint, value);
+    }
+}
+exports.ResourceObjectAttributeBase = ResourceObjectAttributeBase;
+class GeospatialPoint extends ResourceObjectAttributeBase {
+    LoadData(data) {
+        if ((0, json_1.hasProperty)(data, 'longitude'))
+            this.longitude = data.longitude;
+        if ((0, json_1.hasProperty)(data, 'latitude'))
+            this.latitude = data.latitude;
+    }
+}
+exports.GeospatialPoint = GeospatialPoint;
+class ResourceObjectRelationshipBase {
+    constructor(includes) {
+        this._includes = includes;
+    }
+    LoadRelationship(expectedType, value) {
+        if ((0, json_1.isObject)(value)) {
+            if ((0, json_1.hasProperty)(value, 'data') && (0, json_1.isObject)(value.data) && (Object.keys(value.data).length === 2)
+                && (0, json_1.hasProperty)(value.data, 'type') && (0, json_1.isString)(value.data.type)
+                && (value.data.type === expectedType)
+                && (0, json_1.hasProperty)(value.data, 'id') && (0, json_1.isString)(value.data.id)) {
+                return new ResourceObjectRelationship(this._includes, value.data.type, value.data.id);
+            }
+            if ((Object.keys(value).length === 1) && (0, json_1.hasProperty)(value, 'id') && (0, json_1.isString)(value.id)) {
+                return new ResourceObjectRelationship(this._includes, expectedType, value.id);
+            }
+        }
+        return undefined;
+    }
+    LoadRelationships(expectedType, value) {
+        if ((0, json_1.isObject)(value)) {
+            if ((0, json_1.hasProperty)(value, 'data') && (0, json_1.isArray)(value.data)) {
+                const relationships = [];
+                for (const relationship of value.data) {
+                    if ((0, json_1.isObject)(relationship) && (Object.keys(relationship).length === 2)
+                        && (0, json_1.hasProperty)(relationship, 'type') && (0, json_1.isString)(relationship.type)
+                        && (relationship.type === expectedType)
+                        && (0, json_1.hasProperty)(relationship, 'id') && (0, json_1.isString)(relationship.id)) {
+                        relationships.push(new ResourceObjectRelationship(this._includes, relationship.type, relationship.id));
+                    }
+                }
+                return relationships;
+            }
+        }
+        else if ((0, json_1.isArray)(value)) {
+            const relationships = [];
+            for (const relationship of value) {
+                if ((0, json_1.isObject)(relationship) && (Object.keys(relationship).length === 1)
+                    && (0, json_1.hasProperty)(relationship, 'id') && (0, json_1.isString)(relationship.id)) {
+                    relationships.push(new ResourceObjectRelationship(this._includes, expectedType, relationship.id));
+                }
+            }
+            return relationships;
+        }
+        return undefined;
+    }
+    static RelationshipType(relationshipName) {
+        throw new Error('Method or Property not implemented.');
+    }
+}
+exports.ResourceObjectRelationshipBase = ResourceObjectRelationshipBase;