@cognite/sdk-beta - npm Package Compare versions

Comparing version 1.3.2 to 1.4.0

CHANGELOG.md

@@ -6,2 +6,13 @@ # Change Log
 
+# [1.4.0](https://github.com/cognitedata/cognite-sdk-js/compare/@cognite/sdk-beta@1.3.2...@cognite/sdk-beta@1.4.0) (2021-02-12)
+
+
+### Features
+
+* **beta:** add Template Groups API ([#477](https://github.com/cognitedata/cognite-sdk-js/issues/477)) ([1b1398b](https://github.com/cognitedata/cognite-sdk-js/commit/1b1398b57e83a4313b2ae4c215eb24540ea48683))
+
+
+
+
+
 ## [1.3.2](https://github.com/cognitedata/cognite-sdk-js/compare/@cognite/sdk-beta@1.3.1...@cognite/sdk-beta@1.3.2) (2020-12-17)
@@ -8,0 +19,0 @@

dist/index.js

@@ -5,4 +5,8 @@ 'use strict';
 
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
 var sdk = require('@cognite/sdk');
 var sdkCore = require('@cognite/sdk-core');
+var fromPairs = _interopDefault(require('lodash/fromPairs'));
+var toPairs = _interopDefault(require('lodash/toPairs'));
 
@@ -38,2 +42,13 @@ /*! *****************************************************************************
 
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -76,4 +91,21 @@ return new (P || (P = Promise))(function (resolve, reject) {
 
-var version="1.3.2";
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
 
+var version="1.4.0";
+
 // Copyright 2020 Cognite AS
@@ -242,2 +274,355 @@ var EntityMatchingApi = /** @class */ (function (_super) {
 // Copyright 2020 Cognite AS
+var TemplateGraphQlApi = /** @class */ (function (_super) {
+    __extends(TemplateGraphQlApi, _super);
+    function TemplateGraphQlApi() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /**
+         * [Run a GraphQL query](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionGraphql)
+         *
+         * ```js
+         * client.templates.group("myGroup").versions(1).runQuery(`
+         *   wellList {
+         *     name
+         *   }
+         * `);
+         * ```
+         */
+        _this.runQuery = function (query) {
+            return _this.post(_this.url(), {
+                data: {
+                    query: query,
+                },
+            }).then(function (res) { return res.data; });
+        };
+        return _this;
+    }
+    return TemplateGraphQlApi;
+}(sdkCore.BaseResourceAPI));
+
+// Copyright 2020 Cognite AS
+var TemplateGroupsApi = /** @class */ (function (_super) {
+    __extends(TemplateGroupsApi, _super);
+    function TemplateGroupsApi() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /**
+         * [Create Template Groups](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroups)
+         *
+         * ```js
+         * const templateGroups = [
+         *   { externalId: 'Wells', description: 'Models a Well system', owners: ['[e-mail]'] },
+         * ];
+         * const createdTemplateGroups = await client.templates.groups.create(templateGroups);
+         * ```
+         */
+        _this.create = function (items) {
+            return _super.prototype.createEndpoint.call(_this, items);
+        };
+        /**
+         * [Upsert Template Groups](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsUpsert)
+         *
+         * ```js
+         * const templateGroups = [
+         *   { externalId: 'Wells', description: 'Models a Well system', owners: ['[e-mail]'] },
+         * ];
+         * const upsertedTemplateGroups = await client.templates.groups.upsert(templateGroups);
+         * ```
+         */
+        _this.upsert = function (items) {
+            return _super.prototype.createEndpoint.call(_this, items, _this.url('upsert'));
+        };
+        /**
+         * [Retrieve Template Groups](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsByids)
+         *
+         * ```js
+         * const templateGroups = await client.templates.groups.retrieve([{externalId: 'abc'}]);
+         * ```
+         */
+        _this.retrieve = function (ids, options) {
+            return _super.prototype.retrieveEndpoint.call(_this, ids, options || { ignoreUnknownIds: false });
+        };
+        /**
+         * [List Template Groups](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsList)
+         *
+         * ```js
+         * const templateGroups = await client.templates.groups.list({ filter: { owners: ["[e-mail]"] } });
+         * ```
+         */
+        _this.list = function (query) {
+            return _super.prototype.listEndpoint.call(_this, _this.callListEndpointWithPost, query);
+        };
+        /**
+         * [Delete Template Groups](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsDelete)
+         *
+         * ```js
+         * await client.templates.groups.delete([{ externalId: "Wells" }]);
+         * ```
+         */
+        _this.delete = function (ids, options) {
+            return _super.prototype.deleteEndpoint.call(_this, ids, options || {
+                ignoreUnknownIds: false,
+            });
+        };
+        return _this;
+    }
+    return TemplateGroupsApi;
+}(sdkCore.BaseResourceAPI));
+
+// Copyright 2020 Cognite AS
+var TemplateGroupVersionsApi = /** @class */ (function (_super) {
+    __extends(TemplateGroupVersionsApi, _super);
+    function TemplateGroupVersionsApi() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /**
+         * [Upsert a Template Group version](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsUpsert)
+      Create or update a Template Group version.
+         *
+         * ```js
+         * const version = { schema: "type MyType @template { someField: String }", conflictMode: ConflictMode.Patch };
+         * const newVersion = await client.group("myGroup").versions.upsert(version);
+         * ```
+         */
+        _this.upsert = function (item) {
+            return _this.post(_this.url('upsert'), {
+                data: item,
+            }).then(function (res) { return res.data; });
+        };
+        /**
+         * [List Template Group versions](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsList)
+         *
+         * ```js
+         * const versions = await client.templates.group("myGroup").versions.list( { minVersion: 1, maxVersion: 4 } );
+         * ```
+         */
+        _this.list = function (query) {
+            return _super.prototype.listEndpoint.call(_this, _this.callListEndpointWithPost, query);
+        };
+        /**
+         * [Delete a Template Group version](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsDelete)
+         *
+         * ```js
+         * await client.templates.group("myGroup").versions.delete(1);
+         * ```
+         */
+        _this.delete = function (version) {
+            return _this.post(_this.url('delete'), {
+                data: {
+                    version: version,
+                },
+            });
+        };
+        return _this;
+    }
+    return TemplateGroupVersionsApi;
+}(sdkCore.BaseResourceAPI));
+
+// Copyright 2020 Cognite AS
+var ContextJobStatus = {
+    QUEUED: 'QUEUED',
+    RUNNING: 'RUNNING',
+    COMPLETED: 'COMPLETED',
+    FAILED: 'FAILED',
+};
+var EntityMatchingFeatureType = {
+    SIMPLE: 'simple',
+    BIGRAM: 'bigram',
+    FREQUENCY_WEIGHTED_BIGRAM: 'frequencyweightedbigram',
+    BIGRAM_EXTRA_TOKENIZERS: 'bigramextratokenizers',
+    BIGRAM_COMBO: 'bigramcombo',
+};
+var EntityMatchingClassifier = {
+    RANDOM_FOREST: 'randomforest',
+    DECISION_TREE: 'decisiontree',
+    LOGISTIC_REGRESSION: 'logisticregression',
+    AUGMENTED_LOGISTIC_REGRESSION: 'augmentedlogisticregression',
+    AUGMENTED_RANDOM_FOREST: 'augmentedrandomforest',
+};
+(function (ConflictMode) {
+    /** Patch the existing version, but will fail if there are breaking changes. */
+    ConflictMode["Patch"] = "Patch";
+    /** Update the Template Group by bumping the version. */
+    ConflictMode["Update"] = "Update";
+    /** Force update the existing version even if there are breaking changes. Note, this can break consumers of that version. */
+    ConflictMode["Force"] = "Force";
+})(exports.ConflictMode || (exports.ConflictMode = {}));
+var ConstantResolver = /** @class */ (function () {
+    function ConstantResolver(value) {
+        this.type = 'constant';
+        this.value = value;
+    }
+    return ConstantResolver;
+}());
+var RawResolver = /** @class */ (function () {
+    function RawResolver(dbName, tableName, rowKey, columnName) {
+        this.type = 'raw';
+        this.dbName = dbName;
+        this.tableName = tableName;
+        this.rowKey = rowKey;
+        this.columnName = columnName;
+    }
+    return RawResolver;
+}());
+var SyntheticTimeSeriesResolver = /** @class */ (function () {
+    function SyntheticTimeSeriesResolver(expression, name, metadata, description, isStep, isString, unit) {
+        this.type = 'syntheticTimeSeries';
+        this.expression = expression;
+        this.name = name;
+        this.metadata = metadata;
+        this.description = description;
+        this.isStep = isStep;
+        this.isString = isString;
+        this.unit = unit;
+    }
+    return SyntheticTimeSeriesResolver;
+}());
+
+// Copyright 2020 Cognite AS
+var TemplateInstancesApi = /** @class */ (function (_super) {
+    __extends(TemplateInstancesApi, _super);
+    function TemplateInstancesApi() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /**
+         * [Create Template Instances](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionInstances)
+         *
+         * ```js
+         * const instances = [
+         *   { externalId: 'Well_a', templateName: "Well", fieldResolvers: { name: "Underwater P23", pressure: "21_PT19" } },
+         *   { externalId: 'Well_b', templateName: "Well", fieldResolvers: { name: "Underwater P01" } },
+         * ];
+         * const createdInstances = await client.templates.group("myGroup").version(1).create(instances);
+         * ```
+         */
+        _this.create = function (items) {
+            return _super.prototype.createEndpoint.call(_this, TemplateInstanceCodec.encodeTemplateInstances(items))
+                .then(TemplateInstanceCodec.decodeTemplateInstances);
+        };
+        /**
+         * [Upsert Template Instances](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionInstancesUpsert)
+         *
+         * ```js
+         * const instances = [
+         *   { externalId: "Well_a", templateName: "Well", fieldResolvers: { name: "Underwater P23", pressure: "21_PT19" } },
+         *   { externalId: "Well_b", templateName: "Well", fieldResolvers: { name: "Underwater P01" } },
+         * ];
+         * const createdInstances = await client.templates.group("myGroup").version(1).upsert(instances);
+         * ```
+         */
+        _this.upsert = function (items) {
+            return _super.prototype.createEndpoint.call(_this, TemplateInstanceCodec.encodeTemplateInstances(items), _this.url('upsert'))
+                .then(TemplateInstanceCodec.decodeTemplateInstances);
+        };
+        /**
+         * [Retrieve Template Instances](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionInstancesByids)
+         *
+         * ```js
+         * const instances = await client.templates.group("myGroup").version(1).retrieve([ { externalId: 'Well } ]);
+         * ```
+         */
+        _this.retrieve = function (ids, options) {
+            return _super.prototype.retrieveEndpoint.call(_this, ids, options || { ignoreUnknownIds: false })
+                .then(TemplateInstanceCodec.decodeTemplateInstances);
+        };
+        /**
+         * [List Template Instances](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionInstancesList)
+         *
+         * ```js
+         * const instances = await client.templates.group("myGroup").version(1).list( { templateNames: ["Well"] } );
+         * ```
+         */
+        _this.list = function (query) {
+            return _super.prototype.listEndpoint.call(_this, function (scope) { return __awaiter(_this, void 0, void 0, function () {
+                var res;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.callListEndpointWithPost(scope)];
+                        case 1:
+                            res = _a.sent();
+                            return [2 /*return*/, __assign(__assign({}, res), { data: __assign(__assign({}, res.data), { items: TemplateInstanceCodec.decodeTemplateInstances(res.data.items) }) })];
+                    }
+                });
+            }); }, query);
+        };
+        /**
+         * [Delete Template Instances](https://pr-1202.specs.preview.cogniteapp.com/v1.json.html#operation/postApiV1ProjectsProjectTemplategroupsExternalidVersionsVersionInstancesDelete)
+         *
+         * ```js
+         * const instances = await client.templates.group("myGroup").version(1).delete([{ externalId: ["Well_a"] }]);
+         * ```
+         */
+        _this.delete = function (ids, options) {
+            return _super.prototype.deleteEndpoint.call(_this, ids, options || {
+                ignoreUnknownIds: false,
+            });
+        };
+        return _this;
+    }
+    return TemplateInstancesApi;
+}(sdkCore.BaseResourceAPI));
+var TemplateInstanceCodec = /** @class */ (function () {
+    function TemplateInstanceCodec() {
+    }
+    TemplateInstanceCodec.encodeTemplateInstances = function (templateInstances) {
+        return templateInstances.map(function (item) {
+            return {
+                externalId: item.externalId,
+                templateName: item.templateName,
+                dataSetId: item.dataSetId,
+                fieldResolvers: TemplateInstanceCodec.encodeFieldResolvers(item.fieldResolvers),
+            };
+        });
+    };
+    TemplateInstanceCodec.encodeFieldResolvers = function (fieldResolvers) {
+        var _this = this;
+        var mappedResolvers = toPairs(fieldResolvers).map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], fieldResolver = _b[1];
+            if (!_this.isFieldResolver(fieldResolver)) {
+                // Auto-wrap objects, numbers etc. as ConstantResolver.
+                return [name, new ConstantResolver(fieldResolver)];
+            }
+            else {
+                return [name, fieldResolver];
+            }
+        });
+        return fromPairs(mappedResolvers);
+    };
+    TemplateInstanceCodec.decodeTemplateInstances = function (templateInstances) {
+        return templateInstances.map(function (item) {
+            return {
+                externalId: item.externalId,
+                templateName: item.templateName,
+                dataSetId: item.dataSetId,
+                fieldResolvers: TemplateInstanceCodec.decodeFieldResolvers(item.fieldResolvers),
+            };
+        });
+    };
+    TemplateInstanceCodec.decodeFieldResolvers = function (fieldResolvers) {
+        var mappedResolvers = toPairs(fieldResolvers).map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], fieldResolver = _b[1];
+            return [
+                name,
+                TemplateInstanceCodec.decodeFieldResolver(fieldResolver),
+            ];
+        });
+        return fromPairs(mappedResolvers);
+    };
+    TemplateInstanceCodec.decodeFieldResolver = function (fieldResolver) {
+        switch (fieldResolver.type) {
+            case 'constant':
+                return fieldResolver.value;
+            case 'raw':
+                return new RawResolver(fieldResolver.dbName, fieldResolver.tableName, fieldResolver.rowKey, fieldResolver.columnName);
+            case 'syntheticTimeSeries':
+                return new SyntheticTimeSeriesResolver(fieldResolver.expression, fieldResolver.name, fieldResolver.metadata, fieldResolver.description, fieldResolver.isStep, fieldResolver.isString, fieldResolver.unit);
+            default:
+                throw new Error('Unknown field resolver type');
+        }
+    };
+    TemplateInstanceCodec.isFieldResolver = function (fieldResolver) {
+        return (fieldResolver instanceof ConstantResolver ||
+            fieldResolver instanceof RawResolver ||
+            fieldResolver instanceof SyntheticTimeSeriesResolver);
+    };
+    return TemplateInstanceCodec;
+}());
+
+// Copyright 2020 Cognite AS
 var CogniteClientCleaned = /** @class */ (function (_super) {
@@ -279,2 +664,27 @@ __extends(CogniteClientCleaned, _super);
     });
+    Object.defineProperty(CogniteClient.prototype, "templates", {
+        get: function () {
+            var _this = this;
+            return {
+                groups: sdkCore.accessApi(this.templateGroupsApi),
+                group: function (externalId) {
+                    var urlsafeExternalId = CogniteClient.urlEncodeExternalId(externalId);
+                    var baseVersionsUrl = "templategroups/" + urlsafeExternalId + "/versions";
+                    return {
+                        versions: sdkCore.accessApi(_this.apiFactory(TemplateGroupVersionsApi, baseVersionsUrl)),
+                        version: function (version) {
+                            var baseGroupUrl = baseVersionsUrl + "/" + version;
+                            var graphQlApi = _this.apiFactory(TemplateGraphQlApi, baseGroupUrl + "/graphql");
+                            return {
+                                instances: sdkCore.accessApi(_this.apiFactory(TemplateInstancesApi, baseGroupUrl + "/instances")),
+                                runQuery: function (query) { return graphQlApi.runQuery(query); },
+                            };
+                        },
+                    };
+                },
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(CogniteClient.prototype, "version", {
@@ -290,28 +700,10 @@ get: function () {
         this.entityMatchingApi = this.apiFactory(EntityMatchingApi, 'context/entitymatching');
+        this.templateGroupsApi = this.apiFactory(TemplateGroupsApi, 'templategroups');
     };
+    CogniteClient.urlEncodeExternalId = function (externalId) {
+        return encodeURIComponent(externalId);
+    };
     return CogniteClient;
 }(CogniteClientCleaned));
 
-// Copyright 2020 Cognite AS
-var ContextJobStatus = {
-    QUEUED: 'QUEUED',
-    RUNNING: 'RUNNING',
-    COMPLETED: 'COMPLETED',
-    FAILED: 'FAILED',
-};
-var EntityMatchingFeatureType = {
-    SIMPLE: 'simple',
-    BIGRAM: 'bigram',
-    FREQUENCY_WEIGHTED_BIGRAM: 'frequencyweightedbigram',
-    BIGRAM_EXTRA_TOKENIZERS: 'bigramextratokenizers',
-    BIGRAM_COMBO: 'bigramcombo',
-};
-var EntityMatchingClassifier = {
-    RANDOM_FOREST: 'randomforest',
-    DECISION_TREE: 'decisiontree',
-    LOGISTIC_REGRESSION: 'logisticregression',
-    AUGMENTED_LOGISTIC_REGRESSION: 'augmentedlogisticregression',
-    AUGMENTED_RANDOM_FOREST: 'augmentedrandomforest',
-};
-
 Object.keys(sdk).forEach(function (k) {
@@ -321,5 +713,8 @@ if (k !== 'default') exports[k] = sdk[k];
 exports.CogniteClient = CogniteClient;
+exports.ConstantResolver = ConstantResolver;
 exports.ContextJobStatus = ContextJobStatus;
 exports.EntityMatchingClassifier = EntityMatchingClassifier;
 exports.EntityMatchingFeatureType = EntityMatchingFeatureType;
+exports.RawResolver = RawResolver;
+exports.SyntheticTimeSeriesResolver = SyntheticTimeSeriesResolver;
 //# sourceMappingURL=index.js.map

dist/src/cogniteClient.d.ts

 import { ClientOptions, CogniteClient as CogniteClientStable } from '@cognite/sdk';
 import { EntityMatchingApi } from './api/entityMatching/entityMatchingApi';
+import { TemplateGroupsApi } from './api/templateGroups/templateGroupsApi';
+import { TemplateGroupVersionsApi } from './api/templateGroups/templateGroupVersionsApi';
+import { TemplateInstancesApi } from './api/templateGroups/templateInstancesApi';
 declare class CogniteClientCleaned extends CogniteClientStable {
@@ -7,2 +10,3 @@ }
     private entityMatchingApi?;
+    private templateGroupsApi?;
     /**
@@ -27,5 +31,16 @@ * Create a new SDK client (beta)
     get entityMatching(): EntityMatchingApi;
+    get templates(): {
+        groups: TemplateGroupsApi;
+        group: (externalId: string) => {
+            versions: TemplateGroupVersionsApi;
+            version: (version: number) => {
+                instances: TemplateInstancesApi;
+                runQuery: (query: string) => Promise<import("./types").GraphQlResponse>;
+            };
+        };
+    };
     protected get version(): string;
     protected initAPIs(): void;
+    static urlEncodeExternalId(externalId: string): string;
 }
 export {};

dist/src/types.d.ts

@@ -1,2 +0,2 @@
-import { CogniteExternalId, CogniteInternalId, FilterQuery, IdEither, SinglePatchString } from '@cognite/sdk';
+import { CogniteExternalId, CogniteInternalId, ExternalId, FilterQuery, IdEither, SinglePatchString } from '@cognite/sdk';
 export declare type ContextJobStatus = 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED';
@@ -307,2 +307,114 @@ export declare const ContextJobStatus: {
 }
+export interface ExternalTemplateGroup extends ExternalId {
+    /**
+     * The externalId of a Template Group
+     */
+    externalId: CogniteExternalId;
+    /**
+     * The description of a Template Group
+     */
+    description?: string;
+    /**
+     * The owners of a Template Group
+     */
+    owners?: string[];
+}
+export declare type TemplateGroup = ExternalTemplateGroup & {
+    /**
+     * The owners of a Template Group
+     */
+    owners: string[];
+};
+export interface TemplateGroupFilter {
+    /**
+     * Filter on owners.
+     */
+    owners?: string[];
+}
+export interface TemplateGroupFilterQuery extends FilterQuery {
+    filter?: TemplateGroupFilter;
+}
+export interface TemplateGroupVersion {
+    version: number;
+    schema: string;
+}
+export declare enum ConflictMode {
+    /** Patch the existing version, but will fail if there are breaking changes. */
+    Patch = "Patch",
+    /** Update the Template Group by bumping the version. */
+    Update = "Update",
+    /** Force update the existing version even if there are breaking changes. Note, this can break consumers of that version. */
+    Force = "Force"
+}
+export interface ExternalTemplateGroupVersion {
+    schema: string;
+    /** Specifies the conflict mode to use. By default the mode is 'ConflictMode.Patch'.*/
+    conflictMode?: ConflictMode;
+    version?: number;
+}
+export interface TemplateGroupVersionFilter extends FilterQuery {
+    minVersion?: number;
+    maxVersion?: number;
+}
+export interface TemplateGroupVersionFilterQuery extends FilterQuery {
+    filter?: TemplateGroupVersionFilter;
+}
+export interface TemplateInstance extends ExternalId {
+    templateName: string;
+    dataSetId?: number;
+    fieldResolvers: {
+        [K in string]: FieldResolver | {};
+    };
+}
+export declare type ExternalTemplateInstance = TemplateInstance;
+export interface FieldResolver {
+    type: string;
+}
+export declare class ConstantResolver implements FieldResolver {
+    type: string;
+    value: {};
+    constructor(value: {});
+}
+export declare class RawResolver implements FieldResolver {
+    type: string;
+    dbName: string;
+    tableName: string;
+    rowKey?: string;
+    columnName?: string;
+    constructor(dbName: string, tableName: string, rowKey?: string, columnName?: string);
+}
+export declare class SyntheticTimeSeriesResolver implements FieldResolver {
+    type: string;
+    expression: string;
+    name?: string;
+    metadata?: {
+        [K in string]: string;
+    };
+    description?: string;
+    isStep?: boolean;
+    isString?: boolean;
+    unit?: string;
+    constructor(expression: string, name?: string, metadata?: {
+        [K in string]: string;
+    }, description?: string, isStep?: boolean, isString?: boolean, unit?: string);
+}
+export interface TemplateInstanceFilter {
+    dataSetIds?: number[];
+    templateNames?: string[];
+}
+export interface TemplateInstanceFilterQuery extends FilterQuery {
+    filter?: TemplateInstanceFilter;
+}
+export declare type GraphQlResponse = {
+    data: any;
+    errors: GraphQlError[];
+};
+export declare type GraphQlError = {
+    message: string;
+    path: string[];
+    locations: {
+        line: number;
+        column: number;
+    }[];
+};
 export {};

package.json

@@ -9,3 +9,3 @@ {
   "types": "dist/src/index.d.js",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "scripts": {
@@ -32,3 +32,3 @@ "clean": "rm -rf dist/ docs/ codeSnippets/",
   },
-  "gitHead": "265c58c48344fe1328afea6411693d322a4cccfd"
+  "gitHead": "e8fc520fab9507ef8c1387431eaeef3ec9b226e3"
 }

src/cogniteClient.ts

@@ -10,2 +10,6 @@ // Copyright 2020 Cognite AS
 import { EntityMatchingApi } from './api/entityMatching/entityMatchingApi';
+import { TemplateGraphQlApi } from './api/templateGroups/templateGraphQlApi';
+import { TemplateGroupsApi } from './api/templateGroups/templateGroupsApi';
+import { TemplateGroupVersionsApi } from './api/templateGroups/templateGroupVersionsApi';
+import { TemplateInstancesApi } from './api/templateGroups/templateInstancesApi';
 
@@ -18,2 +22,3 @@ class CogniteClientCleaned extends CogniteClientStable {
   private entityMatchingApi?: EntityMatchingApi;
+  private templateGroupsApi?: TemplateGroupsApi;
 
@@ -45,2 +50,33 @@ /**
 
+  public get templates() {
+    return {
+      groups: accessApi(this.templateGroupsApi),
+      group: (externalId: string) => {
+        const urlsafeExternalId = CogniteClient.urlEncodeExternalId(externalId);
+        const baseVersionsUrl = `templategroups/${urlsafeExternalId}/versions`;
+        return {
+          versions: accessApi(
+            this.apiFactory(TemplateGroupVersionsApi, baseVersionsUrl)
+          ),
+          version: (version: number) => {
+            const baseGroupUrl = `${baseVersionsUrl}/${version}`;
+            const graphQlApi = this.apiFactory(
+              TemplateGraphQlApi,
+              `${baseGroupUrl}/graphql`
+            );
+            return {
+              instances: accessApi(
+                this.apiFactory(
+                  TemplateInstancesApi,
+                  `${baseGroupUrl}/instances`
+                )
+              ),
+              runQuery: (query: string) => graphQlApi.runQuery(query),
+            };
+          },
+        };
+      },
+    };
+  }
+
   protected get version() {
@@ -57,3 +93,12 @@ return `${version}-beta`;
     );
+
+    this.templateGroupsApi = this.apiFactory(
+      TemplateGroupsApi,
+      'templategroups'
+    );
   }
+
+  static urlEncodeExternalId(externalId: string): string {
+    return encodeURIComponent(externalId);
+  }
 }

src/types.ts

@@ -6,2 +6,3 @@ // Copyright 2020 Cognite AS
   CogniteInternalId,
+  ExternalId,
   FilterQuery,
@@ -368,1 +369,156 @@ IdEither,
 }
+
+export interface ExternalTemplateGroup extends ExternalId {
+  /**
+   * The externalId of a Template Group
+   */
+  externalId: CogniteExternalId;
+
+  /**
+   * The description of a Template Group
+   */
+  description?: string;
+
+  /**
+   * The owners of a Template Group
+   */
+  owners?: string[];
+}
+
+export type TemplateGroup = ExternalTemplateGroup & {
+  /**
+   * The owners of a Template Group
+   */
+  owners: string[];
+};
+
+export interface TemplateGroupFilter {
+  /**
+   * Filter on owners.
+   */
+  owners?: string[];
+}
+
+export interface TemplateGroupFilterQuery extends FilterQuery {
+  filter?: TemplateGroupFilter;
+}
+
+export interface TemplateGroupVersion {
+  version: number;
+  schema: string;
+}
+
+export enum ConflictMode {
+  /** Patch the existing version, but will fail if there are breaking changes. */
+  Patch = 'Patch',
+  /** Update the Template Group by bumping the version. */
+  Update = 'Update',
+  /** Force update the existing version even if there are breaking changes. Note, this can break consumers of that version. */
+  Force = 'Force',
+}
+
+export interface ExternalTemplateGroupVersion {
+  schema: string;
+  /** Specifies the conflict mode to use. By default the mode is 'ConflictMode.Patch'.*/
+  conflictMode?: ConflictMode;
+  version?: number;
+}
+
+export interface TemplateGroupVersionFilter extends FilterQuery {
+  minVersion?: number;
+  maxVersion?: number;
+}
+
+export interface TemplateGroupVersionFilterQuery extends FilterQuery {
+  filter?: TemplateGroupVersionFilter;
+}
+
+export interface TemplateInstance extends ExternalId {
+  templateName: string;
+  dataSetId?: number;
+  fieldResolvers: { [K in string]: FieldResolver | {} };
+}
+
+export type ExternalTemplateInstance = TemplateInstance;
+
+export interface FieldResolver {
+  type: string;
+}
+
+export class ConstantResolver implements FieldResolver {
+  type = 'constant';
+  value: {};
+
+  constructor(value: {}) {
+    this.value = value;
+  }
+}
+
+export class RawResolver implements FieldResolver {
+  type = 'raw';
+  dbName: string;
+  tableName: string;
+  rowKey?: string;
+  columnName?: string;
+
+  constructor(
+    dbName: string,
+    tableName: string,
+    rowKey?: string,
+    columnName?: string
+  ) {
+    this.dbName = dbName;
+    this.tableName = tableName;
+    this.rowKey = rowKey;
+    this.columnName = columnName;
+  }
+}
+
+export class SyntheticTimeSeriesResolver implements FieldResolver {
+  type = 'syntheticTimeSeries';
+  expression: string;
+  name?: string;
+  metadata?: { [K in string]: string };
+  description?: string;
+  isStep?: boolean;
+  isString?: boolean;
+  unit?: string;
+
+  constructor(
+    expression: string,
+    name?: string,
+    metadata?: { [K in string]: string },
+    description?: string,
+    isStep?: boolean,
+    isString?: boolean,
+    unit?: string
+  ) {
+    this.expression = expression;
+    this.name = name;
+    this.metadata = metadata;
+    this.description = description;
+    this.isStep = isStep;
+    this.isString = isString;
+    this.unit = unit;
+  }
+}
+
+export interface TemplateInstanceFilter {
+  dataSetIds?: number[];
+  templateNames?: string[];
+}
+
+export interface TemplateInstanceFilterQuery extends FilterQuery {
+  filter?: TemplateInstanceFilter;
+}
+
+export type GraphQlResponse = {
+  data: any;
+  errors: GraphQlError[];
+};
+
+export type GraphQlError = {
+  message: string;
+  path: string[];
+  locations: { line: number; column: number }[];
+};

No alert changes

Improved metrics

Total package byte prevSize

154033

increased by70.81%

Number of package files

33

increased by57.14%

Lines of code

3028

increased by101.46%

No dependency changes