@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/mappers/property-mapper.js

@@ -0,0 +1,339 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyMapper = void 0;
+const moment_1 = __importDefault(require("moment"));
+const culture_insensitive_property_1 = require("../contracts/base/culture-insensitive-property");
+const culture_sensitive_property_1 = require("../contracts/base/culture-sensitive-property");
+const data_type_1 = __importStar(require("../contracts/base/data-type"));
+const minimal_schema_1 = require("../contracts/querying/minimal-schema");
+const property_data_1 = require("../contracts/querying/property-data");
+const guard_1 = __importDefault(require("../guard"));
+class PropertyMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    mapPropertiesAsync(resource, loadedCultures, schema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resource == null || resource.properties == null || Object.keys(resource.properties).length === 0) {
+                return [];
+            }
+            // If no minimal schema is available, build it from the definition.
+            if (schema == null) {
+                const definitionName = yield this._client.linkHelper.nameFromDefinitionAsync(resource.entityDefinition);
+                if (definitionName == null) {
+                    throw new Error(`Could not resolve definition name from entity resource.`);
+                }
+                const definition = yield this._client.entityDefinitions.getCachedAsync(definitionName);
+                if (definition == null) {
+                    throw new Error(`Could not load definition with name '${definitionName}.`);
+                }
+                schema = new minimal_schema_1.MinimalSchema(definitionName);
+                const loadedProperties = Object.keys(resource.properties);
+                schema.properties = definition
+                    .getPropertyDefinitions()
+                    .filter(propertyDefinition => loadedProperties.includes(propertyDefinition.name))
+                    .map(propertyDefinition => {
+                    let hasDataSource = false;
+                    if (propertyDefinition.type === data_type_1.default.String) {
+                        const stringPropertyDef = propertyDefinition;
+                        hasDataSource = !!(stringPropertyDef.dataSourceName && stringPropertyDef.dataSourceName.length > 0);
+                    }
+                    return new property_data_1.PropertyData({
+                        name: propertyDefinition.name,
+                        isMultiValue: propertyDefinition.isMultiValue,
+                        isMultilingual: propertyDefinition.isMultiLanguage,
+                        hasDataSource: hasDataSource,
+                        dataType: data_type_1.default[propertyDefinition.type],
+                    });
+                });
+            }
+            const list = [];
+            for (const definition of schema.properties) {
+                const prop = this.mapProperty(resource, loadedCultures, definition);
+                list.push(prop);
+            }
+            return list;
+        });
+    }
+    mapProperty(resource, loadedCultures, definition) {
+        const name = definition.name;
+        const typeInfo = PropertyMapper.getType(definition);
+        const propertyValue = resource.properties[name];
+        let property;
+        if (definition.hasDataSource) {
+            property = PropertyMapper.mapDataSource(definition, name, typeInfo, propertyValue);
+        }
+        else if (definition.isMultilingual) {
+            property = PropertyMapper.mapMultilingualProperty(loadedCultures, name, typeInfo, propertyValue);
+        }
+        else {
+            let value;
+            if (definition.isMultiValue) {
+                value = PropertyMapper.convertValue(typeInfo.type, true, propertyValue);
+            }
+            else {
+                value = PropertyMapper.convertValue(typeInfo.type, false, propertyValue);
+            }
+            property = new culture_insensitive_property_1.CultureInsensitiveProperty(name, typeInfo, value);
+        }
+        return property;
+    }
+    static mapMultilingualProperty(loadedCultures, name, typeInfo, propertyValue) {
+        const values = {};
+        for (const culture of Object.keys(propertyValue)) {
+            let value;
+            if (typeInfo.isArray) {
+                value = this.convertValue(typeInfo.type, true, propertyValue[culture]);
+            }
+            else {
+                value = this.convertValue(typeInfo.type, false, propertyValue[culture]);
+            }
+            values[culture] = value;
+        }
+        const prop = new culture_sensitive_property_1.CultureSensitiveProperty(name, typeInfo, loadedCultures, values);
+        return prop;
+    }
+    //#region SDK to Base
+    // mapProperties
+    static mapToPropertyResources(entity) {
+        guard_1.default.notNullOrUndefined(entity);
+        const dict = {};
+        for (const property of entity.properties) {
+            const mappedProp = this.mapToPropertyData(property);
+            dict[mappedProp.key] = mappedProp.value;
+        }
+        return dict;
+    }
+    static mapDirtyProperties(entity) {
+        guard_1.default.notNullOrUndefined(entity);
+        const result = {};
+        const dirtyProperties = entity.properties.filter(property => property.isDirty);
+        for (const property of dirtyProperties) {
+            const mappedProp = this.mapToPropertyData(property);
+            result[mappedProp.key] = mappedProp.value;
+        }
+        return result;
+    }
+    // mapProperty
+    static mapToPropertyData(property) {
+        let propertyData;
+        if (property instanceof culture_sensitive_property_1.CultureSensitiveProperty) {
+            const values = property.getValues();
+            propertyData = { key: property.name, value: values };
+        }
+        else if (property instanceof culture_insensitive_property_1.CultureInsensitiveProperty) {
+            const value = property.getValue();
+            propertyData = { key: property.name, value: value };
+        }
+        else {
+            throw new Error(`Property of type ${property.dataType} is not supported.`);
+        }
+        return propertyData;
+    }
+    //#endregion
+    static getType(data) {
+        let type;
+        switch (data.dataType) {
+            case "Boolean":
+                type = data_type_1.default.Boolean;
+                break;
+            case "Decimal":
+                type = data_type_1.default.Decimal;
+                break;
+            case "Int32":
+            case data_type_1.default[data_type_1.default.Integer]:
+                type = data_type_1.default.Integer;
+                break;
+            case "Int64":
+            case data_type_1.default[data_type_1.default.Long]:
+                type = data_type_1.default.Long;
+                break;
+            case "DateTime":
+                type = data_type_1.default.DateTime;
+                break;
+            case "DateTimeOffset":
+                type = data_type_1.default.DateTimeOffset;
+                break;
+            case "String":
+                type = data_type_1.default.String;
+                break;
+            case "JToken":
+            case data_type_1.default[data_type_1.default.Json]:
+                type = data_type_1.default.Json;
+                break;
+            default:
+                throw new Error("Unsupported value type.");
+        }
+        return new data_type_1.TypeInfo(type, data.isMultiValue);
+    }
+    static convertValue(type, isArray, value) {
+        let result;
+        if (value == null) {
+            return null;
+        }
+        if (isArray) {
+            if (value == null) {
+                return [];
+            }
+            else if (value instanceof Array) {
+                return value.map(item => this.convertValue(type, false, item));
+            }
+            else if (typeof value === "string") {
+                // If it's a string, we might be able to parse it.
+                try {
+                    const parsedValue = JSON.parse(value);
+                    if (parsedValue instanceof Array) {
+                        return parsedValue.map(item => this.convertValue(type, false, item));
+                    }
+                    else {
+                        value = parsedValue;
+                    }
+                }
+                catch (ex) {
+                    // If parsing fails, simply use the string.
+                }
+            }
+            //  else {
+            //     return null; //TODO: Throw error?
+            // }
+        }
+        switch (type) {
+            case data_type_1.default.String:
+                result = String(value); // typeof value === "string" ? value : `${value}`;
+                break;
+            case data_type_1.default.Boolean:
+                result = typeof value === "string" ? value === "true" : !!value;
+                break;
+            case data_type_1.default.Integer:
+            case data_type_1.default.Long: {
+                const number = parseInt(value, 10);
+                if (Number.isNaN(number)) {
+                    result = null; //TODO: Use regex /^[-+]?[0-9]*$/ and throw error?
+                }
+                else {
+                    result = number;
+                }
+                break;
+            }
+            case data_type_1.default.Decimal: {
+                const number = parseFloat(value);
+                if (Number.isNaN(number)) {
+                    result = null; //TODO: Use regex /^[-+]?\b[0-9]*\.?[0-9]*$/ and throw error?
+                }
+                else {
+                    result = number;
+                }
+                break;
+            }
+            case data_type_1.default.Json: {
+                // Valid JSON values: string, number, boolean, null, array or JSON-object
+                if (value == null) {
+                    result = null;
+                }
+                else if (typeof value === "object") {
+                    // Covers JSON-object and array
+                    result = JSON.parse(JSON.stringify(value));
+                }
+                else if (typeof value === "string") {
+                    try {
+                        // When we have a string, it might be a serialized object we can parse.
+                        result = JSON.parse(value);
+                    }
+                    catch (ex) {
+                        // Not a valid JSON-object, so return the string value as-is.
+                        result = value;
+                    }
+                }
+                else {
+                    // We might be dealing with a boolean, number or null.
+                    result = value;
+                }
+                break;
+            }
+            case data_type_1.default.DateTime: {
+                const date = moment_1.default(value);
+                if (!date.isValid()) {
+                    return null; //TODO: Throw error?
+                }
+                result = date;
+                break;
+            }
+            case data_type_1.default.DateTimeOffset: {
+                const date = moment_1.default.parseZone(value);
+                if (!date.isValid()) {
+                    return null; //TODO: Throw error?
+                }
+                result = date;
+                break;
+            }
+        }
+        return result;
+    }
+    static mapDataSource(definition, name, typeInfo, propertyValue) {
+        if (propertyValue == null) {
+            const prop = new culture_insensitive_property_1.CultureInsensitiveProperty(name, typeInfo, null);
+            return prop;
+        }
+        if (definition.isMultiValue) {
+            const array = propertyValue instanceof Array
+                ? propertyValue
+                : typeof propertyValue === "string"
+                    ? JSON.parse(propertyValue)
+                    : null;
+            const list = [];
+            for (const token of array) {
+                const value = this.mapDataSourceValue(token);
+                if (value != null) {
+                    list.push(value);
+                }
+            }
+            const prop = new culture_insensitive_property_1.CultureInsensitiveProperty(name, typeInfo, [...list]);
+            return prop;
+        }
+        else {
+            const value = this.mapDataSourceValue(propertyValue);
+            const prop = new culture_insensitive_property_1.CultureInsensitiveProperty(name, typeInfo, value);
+            return prop;
+        }
+    }
+    static mapDataSourceValue(dataSourceValue) {
+        if (dataSourceValue == null) {
+            return null;
+        }
+        const identifier = dataSourceValue["identifier"];
+        return identifier;
+    }
+}
+exports.PropertyMapper = PropertyMapper;

package/dist/mappers/querying-mapper.d.ts

@@ -0,0 +1,16 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IEntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
+import { IEntityQueryResult } from "../contracts/querying/entity-query-result";
+import { IIdQueryResult } from "../contracts/querying/id-query-result";
+import { Query } from "../contracts/querying/query";
+import { QueryResultResource } from "../models/query-result-resource";
+export declare class QueryingMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapEntityQueryResultAsync(resource: QueryResultResource, query: Query, loadConfiguration: IEntityLoadConfiguration): NullableResultPromise<IEntityQueryResult>;
+    mapEntityIdQueryResultAsync(resource: QueryResultResource, query: Query): NullableResultPromise<IIdQueryResult>;
+    private static getMinimalSchemas;
+    private getEntitiesAsync;
+    private getEntityIdsAsync;
+}

package/dist/mappers/querying-mapper.js

@@ -0,0 +1,96 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryingMapper = void 0;
+const ta_json_1 = require("ta-json");
+const api_1 = require("../constants/api");
+const entity_query_result_1 = require("../contracts/querying/entity-query-result");
+const id_query_result_1 = require("../contracts/querying/id-query-result");
+const minimal_schema_1 = require("../contracts/querying/minimal-schema");
+const guard_1 = __importDefault(require("../guard"));
+class QueryingMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    mapEntityQueryResultAsync(resource, query, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resource == null)
+                return null;
+            guard_1.default.notNullOrUndefined(query, "query");
+            const entities = yield this.getEntitiesAsync(resource);
+            const total = resource.totalItems || 0;
+            const skip = query.skip || 0;
+            const result = new entity_query_result_1.EntityQueryResult(this._client, query, loadConfiguration, entities, total, skip);
+            return result;
+        });
+    }
+    mapEntityIdQueryResultAsync(resource, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resource == null)
+                return null;
+            guard_1.default.notNullOrUndefined(query, "query");
+            const ids = yield this.getEntityIdsAsync(resource);
+            const total = resource.totalItems || 0;
+            const skip = query.skip || 0;
+            const result = new id_query_result_1.EntityIdQueryResult(this._client, query, ids, total, skip);
+            return result;
+        });
+    }
+    // async mapEntityScrollResultAsync(resource: QueryResultResource, offset: number): Promise<IEntityScrollResult> {
+    //     throw "Not implemented";
+    // }
+    // async mapEntityIdScrollResultAsync(resource: QueryResultResource, offset: number): Promise<IIdScrollResult> {
+    //     throw "Not implemented";
+    // }
+    static getMinimalSchemas(resource) {
+        const map = {};
+        const minimalSchema = resource.minimalSchemaList || resource[api_1.EXTENSION_DATA_KEYS.minimalSchema];
+        if (minimalSchema == null) {
+            return map;
+        }
+        const schemaTokens = (minimalSchema instanceof Array
+            ? minimalSchema
+            : typeof minimalSchema === "string"
+                ? JSON.parse(minimalSchema)
+                : []);
+        for (const token of schemaTokens) {
+            const schema = ta_json_1.TaJson.deserialize(token, minimal_schema_1.MinimalSchema);
+            map[schema.definitionName] = schema;
+        }
+        return map;
+    }
+    getEntitiesAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resource.items || !resource.items.length) {
+                return [];
+            }
+            const schemasMap = QueryingMapper.getMinimalSchemas(resource);
+            const resources = resource.items.map(item => item.entity);
+            const entities = yield this._client.entityMapper.mapEntitiesAsync(resources, schemasMap);
+            return entities;
+        });
+    }
+    getEntityIdsAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resource.items || !resource.items.length) {
+                return [];
+            }
+            const links = resource.items.map(item => item.link);
+            const ids = yield this._client.linkHelper.idsFromEntitiesAsync(links);
+            return ids;
+        });
+    }
+}
+exports.QueryingMapper = QueryingMapper;

package/dist/mappers/relation-cardinality-mapper.d.ts

@@ -0,0 +1,5 @@
+import { RelationCardinality, RelationCardinalityType } from "../contracts/base/relation-cardinality";
+export declare class RelationCardinalityMapper {
+    static mapToEnumValue(value: RelationCardinalityType | string): RelationCardinality;
+    static mapToType(value: RelationCardinality | string): RelationCardinalityType;
+}

package/dist/mappers/relation-cardinality-mapper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationCardinalityMapper = void 0;
+const relation_cardinality_1 = require("../contracts/base/relation-cardinality");
+class RelationCardinalityMapper {
+    static mapToEnumValue(value) {
+        if (value === "ManyToMany") {
+            return relation_cardinality_1.RelationCardinality.ManyToMany;
+        }
+        else if (value === "OneToMany") {
+            return relation_cardinality_1.RelationCardinality.OneToMany;
+        }
+        else if (value === "OneToOne") {
+            return relation_cardinality_1.RelationCardinality.OneToOne;
+        }
+        else {
+            throw Error(`Can't map '${value}' to enum value.`);
+        }
+    }
+    static mapToType(value) {
+        if (value === relation_cardinality_1.RelationCardinality.ManyToMany || value === relation_cardinality_1.RelationCardinality[relation_cardinality_1.RelationCardinality.ManyToMany]) {
+            return "ManyToMany";
+        }
+        else if (value === relation_cardinality_1.RelationCardinality.OneToMany ||
+            value === relation_cardinality_1.RelationCardinality[relation_cardinality_1.RelationCardinality.OneToMany]) {
+            return "OneToMany";
+        }
+        else if (value === relation_cardinality_1.RelationCardinality.OneToOne ||
+            value === relation_cardinality_1.RelationCardinality[relation_cardinality_1.RelationCardinality.OneToOne]) {
+            return "OneToOne";
+        }
+        else {
+            throw Error(`Can't map '${value} to type.`);
+        }
+    }
+}
+exports.RelationCardinalityMapper = RelationCardinalityMapper;

package/dist/mappers/relation-mapper.d.ts

@@ -0,0 +1,16 @@
+import { MapStringTo } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IEntity } from "../contracts/base/entity";
+import { IRelation } from "../contracts/base/relation";
+import { MinimalSchema } from "../contracts/querying/minimal-schema";
+import { EntityResource } from "../models/entity-resource";
+import { RelationResource } from "../models/relation-resource";
+export declare class RelationMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapRelationsAsync(resource: EntityResource, schema?: MinimalSchema): Promise<Array<IRelation>>;
+    mapToRelationResourcesAsync(entity: IEntity): Promise<MapStringTo<RelationResource>>;
+    mapRelationToResourceAsync(relation: IRelation): Promise<RelationResource>;
+    mapDirtyRelationsAsync(entity: IEntity): Promise<MapStringTo<RelationResource>>;
+    private mapRelationsToResourcesAsync;
+}