industrial-model 0.11.2 → 0.12.0

package/dist/cognite-core/index.cjs

@@ -10,6 +10,7 @@ var CogniteSdkAdapter = class {
   constructor(client) {
     this.client = client;
   }
+  client;
   async retrieveDataModels(ids, options) {
     const response = await this.client.dataModels.retrieve(ids, options);
     return {
@@ -19,6 +20,11 @@ var CogniteSdkAdapter = class {
       }))
     };
   }
+  async retrieveViews(ids) {
+    const cleanIds = ids.map(({ space, externalId, version }) => ({ space, externalId, version }));
+    const response = await this.client.views.retrieve(cleanIds);
+    return { items: response.items };
+  }
   async queryInstances(request) {
     const response = await this.client.instances.query(
       request
@@ -525,6 +531,7 @@ var QueryValidator = class {
   constructor(viewMapper) {
     this.viewMapper = viewMapper;
   }
+  viewMapper;
   async validate(options, rootView) {
     const errors = [];
     errors.push(...this.validateOptionsShape(options, rootView));
@@ -694,6 +701,7 @@ function isEmptyObject(value) {
   return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
 }
 var AggregateValidator = class {
+  queryValidator;
   constructor(viewMapper) {
     this.queryValidator = new QueryValidator(viewMapper);
   }
@@ -901,6 +909,7 @@ var QueryResultValidator = class {
   constructor(viewMapper) {
     this.viewMapper = viewMapper;
   }
+  viewMapper;
   async parseItems(rootViewExternalId, items, select) {
     const rootView = await this.viewMapper.getView(rootViewExternalId);
     const schema = await this.buildResultSchema(rootView, MAX_DEPENDENCY_DEPTH, select);
@@ -1062,6 +1071,8 @@ var FilterMapper = class {
     this.viewMapper = viewMapper;
     this.cognite = cognite;
   }
+  viewMapper;
+  cognite;
   async map(input, rootView) {
     const result = [];
     const searchQueries = {};
@@ -1206,6 +1217,9 @@ var AggregateMapper = class {
     this.filterMapper = new FilterMapper(viewMapper, cognite);
     this.validator = new AggregateValidator(viewMapper);
   }
+  viewMapper;
+  filterMapper;
+  validator;
   async map(options) {
     const { viewExternalId, filters, groupBy, aggregate } = options;
     const rootView = await this.viewMapper.getView(viewExternalId);
@@ -1283,8 +1297,9 @@ var CHUNK_SIZE = 100;
 var DatapointsMapper = class {
   constructor(cognite) {
     this.cognite = cognite;
-    this.validator = new DatapointsValidator();
   }
+  cognite;
+  validator = new DatapointsValidator();
   async retrieve(options) {
     this.validator.validateRetrieve(options);
     const cogniteOptions = this.toCogniteOptions(options);
@@ -1405,6 +1420,7 @@ var FilesMapper = class {
   constructor(cognite) {
     this.cognite = cognite;
   }
+  cognite;
   async upload(fileInfo, content) {
     const { space, externalId, ...rest } = fileInfo;
     const result = await this.cognite.uploadFile(
@@ -1476,6 +1492,10 @@ var QueryMapper = class {
     this.sortMapper = new SortMapper();
     this.validator = new QueryValidator(viewMapper);
   }
+  viewMapper;
+  filterMapper;
+  sortMapper;
+  validator;
   async map(options) {
     const {
       viewExternalId,
@@ -1627,6 +1647,7 @@ var QueryResultMapper = class {
   constructor(viewMapper) {
     this.viewMapper = viewMapper;
   }
+  viewMapper;
   async mapNodes(rootNode, queryResult) {
     if (!(rootNode in queryResult)) {
       throw new Error(`"${rootNode}" is not available in the query result`);
@@ -1786,8 +1807,10 @@ var UpsertMapper = class {
   constructor(viewMapper, cognite) {
     this.viewMapper = viewMapper;
     this.cognite = cognite;
-    this.validator = new UpsertValidator();
   }
+  viewMapper;
+  cognite;
+  validator = new UpsertValidator();
   async map(options) {
     const rootView = await this.viewMapper.getView(options.viewExternalId);
     this.validator.validate(options, rootView);
@@ -1994,8 +2017,10 @@ var ViewMapper = class {
   constructor(cognite, dataModelId) {
     this.cognite = cognite;
     this.dataModelId = dataModelId;
-    this.cachePromise = null;
   }
+  cognite;
+  dataModelId;
+  cachePromise = null;
   async getView(externalId) {
     const views = await this.loadViews();
     const view = views.get(externalId);
@@ -2035,25 +2060,60 @@ var ViewMapper = class {
     for (const view of dm.views ?? []) {
       views.set(view.externalId, view);
     }
+    await this.loadDependencyViews(views);
     return views;
   }
+  async loadDependencyViews(views) {
+    const pending = /* @__PURE__ */ new Map();
+    for (const view of views.values()) {
+      for (const property of Object.values(view.properties)) {
+        for (const ref of collectPropertyRefs(property)) {
+          if (!views.has(ref.externalId) && !pending.has(ref.externalId)) {
+            pending.set(ref.externalId, ref);
+          }
+        }
+      }
+    }
+    if (pending.size === 0) return;
+    const sizeBefore = views.size;
+    const fetched = await this.cognite.retrieveViews(Array.from(pending.values()));
+    for (const view of fetched.items) {
+      views.set(view.externalId, view);
+    }
+    if (views.size > sizeBefore) {
+      await this.loadDependencyViews(views);
+    }
+  }
 };
+function collectPropertyRefs(property) {
+  if (isViewPropertyDefinition(property)) {
+    const source = getDirectRelationSource(property);
+    return source ? [source] : [];
+  }
+  if (isReverseDirectRelation(property)) {
+    return [property.source, property.through.source];
+  }
+  if (isEdgeConnection(property)) {
+    return [property.source];
+  }
+  return [];
+}
 
 // src/client.ts
 var APPLY_ITEM_LIMIT = 1e3;
 var IndustrialModelClient = class {
+  cognite;
+  queryMapper;
+  aggregateMapper;
+  upsertMapper;
+  aggregateResultMapper;
+  resultMapper;
+  datapointsMapper;
+  filesMapper;
+  deleteValidator = new DeleteValidator();
+  resultValidator;
+  validateResults;
   constructor(client, dataModelId, options = {}) {
-    this.deleteValidator = new DeleteValidator();
-    this.files = {
-      upload: (fileInfo, content) => this.filesMapper.upload(fileInfo, content),
-      getDownloadUrls: (nodeIds) => this.filesMapper.getDownloadUrls(nodeIds)
-    };
-    this.datapoints = {
-      retrieve: (options) => this.datapointsMapper.retrieve(options),
-      latest: (options) => this.datapointsMapper.retrieveLatest(options),
-      insert: (items) => this.datapointsMapper.insert(items),
-      delete: (ranges) => this.datapointsMapper.delete(ranges)
-    };
     const cognite = createCogniteAdapter(client);
     this.cognite = cognite;
     const viewMapper = new ViewMapper(cognite, dataModelId);
@@ -2079,6 +2139,16 @@ var IndustrialModelClient = class {
     const execute = (options) => this.upsertInternal(options);
     return execute;
   }
+  files = {
+    upload: (fileInfo, content) => this.filesMapper.upload(fileInfo, content),
+    getDownloadUrls: (nodeIds) => this.filesMapper.getDownloadUrls(nodeIds)
+  };
+  datapoints = {
+    retrieve: (options) => this.datapointsMapper.retrieve(options),
+    latest: (options) => this.datapointsMapper.retrieveLatest(options),
+    insert: (items) => this.datapointsMapper.insert(items),
+    delete: (ranges) => this.datapointsMapper.delete(ranges)
+  };
   async delete(items) {
     this.deleteValidator.validateItems(items);
     const deleteItems = items.map((item) => ({
@@ -2186,6 +2256,7 @@ var COGNITE_CORE_DATA_MODEL = {
   version: "v1"
 };
 var CogniteCoreClient = class {
+  model;
   constructor(client, options = {}) {
     this.model = new IndustrialModelClient(client, COGNITE_CORE_DATA_MODEL, options);
   }