industrial-model 0.1.0

package/dist/index.js

@@ -0,0 +1,738 @@
+// src/cognite/adapter.ts
+function createCogniteAdapter(client) {
+  return new CogniteSdkAdapter(client);
+}
+var CogniteSdkAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async retrieveDataModels(ids, options) {
+    const response = await this.client.dataModels.retrieve(ids, options);
+    return {
+      items: response.items.map((item) => ({
+        createdTime: item.createdTime,
+        views: item.views ?? []
+      }))
+    };
+  }
+  async queryInstances(request) {
+    const response = await this.client.instances.query(
+      request
+    );
+    return {
+      items: response.items,
+      nextCursor: response.nextCursor
+    };
+  }
+};
+
+// src/constants.ts
+var NESTED_SEP = "|";
+var EDGE_MARKER = "<EdgeMarker>";
+var MAX_LIMIT = 1e4;
+var DEFAULT_LIMIT = 1e3;
+var MAX_DEPENDENCY_DEPTH = 3;
+
+// src/mappers/utils.ts
+var NODE_PROPERTIES = /* @__PURE__ */ new Set([
+  "externalId",
+  "space",
+  "createdTime",
+  "deletedTime",
+  "lastUpdatedTime"
+]);
+function getPropertyRef(property, view, instanceType = "node") {
+  if (NODE_PROPERTIES.has(property)) return [instanceType, property];
+  return [view.space, `${view.externalId}/${view.version}`, property];
+}
+function toViewReference(view) {
+  return { type: "view", space: view.space, externalId: view.externalId, version: view.version };
+}
+function isViewPropertyDefinition(p) {
+  return "container" in p;
+}
+function isReverseDirectRelation(p) {
+  return "through" in p;
+}
+function isEdgeConnection(p) {
+  return !isViewPropertyDefinition(p) && !isReverseDirectRelation(p) && "source" in p;
+}
+function getDirectRelationSource(p) {
+  const type = p.type;
+  if (type.type === "direct" && type.source) return type.source;
+  return void 0;
+}
+function isDirectRelationWithSource(p) {
+  if (!isViewPropertyDefinition(p)) return false;
+  return getDirectRelationSource(p) !== void 0;
+}
+function isListDirectRelation(p) {
+  return p.type.list === true;
+}
+function buildSelect(source, properties) {
+  if (properties.length === 0) return {};
+  return { sources: [{ source, properties }] };
+}
+
+// src/mappers/filter-mapper.ts
+var LEAF_OPS = /* @__PURE__ */ new Set([
+  "eq",
+  "in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "prefix",
+  "containsAny",
+  "containsAll"
+]);
+function isLeafFilter(value) {
+  return Object.keys(value).some((k) => LEAF_OPS.has(k));
+}
+var FilterMapper = class {
+  constructor(viewMapper) {
+    this.viewMapper = viewMapper;
+  }
+  async map(input, rootView) {
+    const result = [];
+    for (const [key, value] of Object.entries(input)) {
+      if (value == null) continue;
+      if (key === "AND") {
+        const clauses = Array.isArray(value) ? value : [value];
+        const inner = await Promise.all(clauses.map((c) => this.whereInputToSingle(c, rootView)));
+        result.push({ and: inner });
+      } else if (key === "OR") {
+        const clauses = value;
+        const branches = await Promise.all(
+          clauses.map((c) => this.whereInputToSingle(c, rootView))
+        );
+        result.push({ or: branches });
+      } else if (key === "NOT") {
+        const clauses = Array.isArray(value) ? value : [value];
+        const [firstClause, ...restClauses] = clauses;
+        const combined = restClauses.length === 0 && firstClause !== void 0 ? firstClause : { AND: clauses };
+        result.push({ not: await this.whereInputToSingle(combined, rootView) });
+      } else {
+        const filterValue = value;
+        const property = getPropertyRef(key, rootView);
+        if (isLeafFilter(filterValue)) {
+          result.push(...this.leafToFilterDefs(property, filterValue));
+        } else {
+          const targetView = await this.getNestedTargetView(key, rootView);
+          const innerFilter = await this.whereInputToSingle(filterValue, targetView);
+          result.push({ nested: { scope: property, filter: innerFilter } });
+        }
+      }
+    }
+    return result;
+  }
+  async whereInputToSingle(input, rootView) {
+    const filters = await this.map(input, rootView);
+    const [firstFilter, ...restFilters] = filters;
+    if (restFilters.length === 0 && firstFilter !== void 0) {
+      return firstFilter;
+    }
+    return { and: filters };
+  }
+  leafToFilterDefs(property, filter) {
+    const result = [];
+    if ("eq" in filter && filter.eq !== void 0) {
+      result.push({
+        equals: { property, value: this.coerceValue(filter.eq) }
+      });
+    }
+    if ("in" in filter && filter.in !== void 0) {
+      result.push({
+        in: { property, values: this.coerceValue(filter.in) }
+      });
+    }
+    if ("gt" in filter && filter.gt !== void 0) {
+      result.push({ range: { property, gt: this.coerceValue(filter.gt) } });
+    }
+    if ("gte" in filter && filter.gte !== void 0) {
+      result.push({ range: { property, gte: this.coerceValue(filter.gte) } });
+    }
+    if ("lt" in filter && filter.lt !== void 0) {
+      result.push({ range: { property, lt: this.coerceValue(filter.lt) } });
+    }
+    if ("lte" in filter && filter.lte !== void 0) {
+      result.push({ range: { property, lte: this.coerceValue(filter.lte) } });
+    }
+    if ("exists" in filter) {
+      if (filter.exists === true) {
+        result.push({ exists: { property } });
+      } else if (filter.exists === false) {
+        result.push({ not: { exists: { property } } });
+      }
+    }
+    if ("prefix" in filter && filter.prefix !== void 0) {
+      result.push({ prefix: { property, value: this.coerceValue(filter.prefix) } });
+    }
+    if ("containsAll" in filter && filter.containsAll !== void 0) {
+      result.push({
+        containsAll: {
+          property,
+          values: this.coerceValue(filter.containsAll)
+        }
+      });
+    }
+    if ("containsAny" in filter && filter.containsAny !== void 0) {
+      result.push({
+        containsAny: {
+          property,
+          values: this.coerceValue(filter.containsAny)
+        }
+      });
+    }
+    return result;
+  }
+  async getNestedTargetView(property, rootView) {
+    const viewProp = rootView.properties[property];
+    if (!viewProp || !isViewPropertyDefinition(viewProp)) {
+      throw new Error(`Property "${property}" is not a mapped property`);
+    }
+    const source = getDirectRelationSource(viewProp);
+    if (!source) throw new Error(`Property "${property}" has no relation source`);
+    return this.viewMapper.getView(source.externalId);
+  }
+  coerceValue(value) {
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) return value.map((v) => this.coerceValue(v));
+    return value;
+  }
+};
+
+// src/mappers/sort-mapper.ts
+var SortMapper = class {
+  map(sortClauses, rootView) {
+    return Object.entries(sortClauses).map(([property, direction]) => ({
+      property: getPropertyRef(property, rootView),
+      direction,
+      nullsFirst: this.isNullsFirst(property, rootView, direction)
+    }));
+  }
+  isNullsFirst(property, view, direction) {
+    const prop = view.properties[property];
+    if (prop && isDirectRelationWithSource(prop)) {
+      return direction === "ascending";
+    }
+    return direction === "descending";
+  }
+};
+
+// src/mappers/query-mapper.ts
+var QueryMapper = class {
+  constructor(viewMapper) {
+    this.viewMapper = viewMapper;
+    this.filterMapper = new FilterMapper(viewMapper);
+    this.sortMapper = new SortMapper();
+  }
+  async map(options) {
+    const {
+      viewExternalId,
+      select = { _all: true },
+      filters,
+      sortClauses = {},
+      limit: requestedLimit = DEFAULT_LIMIT,
+      cursor = null
+    } = options;
+    const limit = requestedLimit === -1 ? DEFAULT_LIMIT : requestedLimit;
+    const rootView = await this.viewMapper.getView(viewExternalId);
+    const rootViewRef = toViewReference(rootView);
+    const whereFilters = filters ? await this.filterMapper.map(filters, rootView) : [];
+    const baseFilters = [{ hasData: [rootViewRef] }, ...whereFilters];
+    const withExprs = {
+      [viewExternalId]: {
+        nodes: {
+          filter: { and: baseFilters }
+        },
+        sort: this.sortMapper.map(sortClauses, rootView),
+        limit
+      }
+    };
+    const selectExprs = {};
+    const properties = await this.includeStatements(
+      viewExternalId,
+      rootView,
+      select,
+      withExprs,
+      selectExprs
+    );
+    selectExprs[viewExternalId] = buildSelect(rootViewRef, properties);
+    const cursors = {};
+    if (cursor != null) cursors[viewExternalId] = cursor;
+    return { with: withExprs, select: selectExprs, cursors };
+  }
+  async includeStatements(key, view, select, withExprs, selectExprs) {
+    const selectProperties = [];
+    const selectRecord = select;
+    for (const [propertyName, property] of Object.entries(view.properties)) {
+      const propertyKey = `${key}${NESTED_SEP}${propertyName}`;
+      const canIncludeProperty = select._all === true || propertyName in select;
+      if (!canIncludeProperty) {
+        continue;
+      }
+      const relationToInclude = propertyName in select && selectRecord[propertyName] != null && typeof selectRecord[propertyName] === "object" ? selectRecord[propertyName] : null;
+      if (isViewPropertyDefinition(property)) {
+        const relSource = getDirectRelationSource(property);
+        if (!relSource) {
+          selectProperties.push(propertyName);
+        } else {
+          selectProperties.push(propertyName);
+          const nestedView = await this.viewMapper.getView(relSource.externalId);
+          const props = relationToInclude != null ? await this.includeStatements(
+            propertyKey,
+            nestedView,
+            relationToInclude,
+            withExprs,
+            selectExprs
+          ) : [];
+          if (props.length > 0) {
+            withExprs[propertyKey] = {
+              nodes: {
+                from: key,
+                direction: "outwards",
+                through: { view: toViewReference(view), identifier: propertyName }
+              },
+              limit: MAX_LIMIT
+            };
+            selectExprs[propertyKey] = buildSelect(relSource, props);
+          }
+        }
+      } else if (isReverseDirectRelation(property) && relationToInclude != null) {
+        const nestedView = await this.viewMapper.getView(property.source.externalId);
+        const props = await this.includeStatements(
+          propertyKey,
+          nestedView,
+          relationToInclude,
+          withExprs,
+          selectExprs
+        );
+        if (!props.includes(property.through.identifier)) {
+          props.push(property.through.identifier);
+        }
+        withExprs[propertyKey] = {
+          nodes: {
+            from: key,
+            direction: "inwards",
+            through: {
+              source: property.through.source,
+              identifier: property.through.identifier
+            }
+          },
+          limit: MAX_LIMIT
+        };
+        selectExprs[propertyKey] = buildSelect(property.source, props);
+      } else if (isEdgeConnection(property) && relationToInclude != null) {
+        const edgePropertyKey = `${propertyKey}${NESTED_SEP}${EDGE_MARKER}`;
+        withExprs[edgePropertyKey] = {
+          edges: {
+            from: key,
+            maxDistance: 1,
+            filter: {
+              equals: { property: ["edge", "type"], value: property.type }
+            },
+            direction: property.direction ?? "outwards"
+          },
+          limit: MAX_LIMIT
+        };
+        withExprs[propertyKey] = {
+          nodes: { from: edgePropertyKey },
+          limit: MAX_LIMIT
+        };
+        selectExprs[edgePropertyKey] = {};
+        const nestedView = await this.viewMapper.getView(property.source.externalId);
+        const props = await this.includeStatements(
+          propertyKey,
+          nestedView,
+          relationToInclude,
+          withExprs,
+          selectExprs
+        );
+        selectExprs[propertyKey] = buildSelect(property.source, props);
+      }
+    }
+    return selectProperties;
+  }
+};
+
+// src/mappers/result-mapper.ts
+function nodeInstanceId(node) {
+  return `${node.space}:${node.externalId}`;
+}
+function getElementKeys(node, element) {
+  if (element && typeof element === "object" && !Array.isArray(element)) {
+    const ref = element;
+    return [`${ref.space ?? ""}:${ref.externalId ?? ""}`];
+  }
+  if (Array.isArray(element)) {
+    return element.filter((item) => item && typeof item === "object").map((item) => {
+      const ref = item;
+      return `${ref.space ?? ""}:${ref.externalId ?? ""}`;
+    });
+  }
+  return [nodeInstanceId(node)];
+}
+var QueryResultMapper = class {
+  constructor(viewMapper) {
+    this.viewMapper = viewMapper;
+  }
+  async mapNodes(rootNode, queryResult) {
+    if (!(rootNode in queryResult)) {
+      throw new Error(`"${rootNode}" is not available in the query result`);
+    }
+    const rootView = await this.viewMapper.getView(rootNode);
+    const values = await this.mapNodeProperty(rootNode, rootView, queryResult);
+    if (!values) return [];
+    return [...values.values()].flatMap((nodes) => nodes.map((n) => this.nodeToDict(n)));
+  }
+  async mapNodeProperty(key, view, queryResult, resultPropertyKey) {
+    if (!(key in queryResult)) return null;
+    const mappings = await this.getPropertyMappings(key, view, queryResult);
+    const viewKey = `${view.externalId}/${view.version}`;
+    const visited = /* @__PURE__ */ new Set();
+    const result = /* @__PURE__ */ new Map();
+    for (const item of queryResult[key] ?? []) {
+      if (item.instanceType !== "node") continue;
+      const node = item;
+      const id = nodeInstanceId(node);
+      if (visited.has(id)) continue;
+      visited.add(id);
+      const spaceProps = node.properties?.[view.space];
+      if (!spaceProps || !(viewKey in spaceProps)) continue;
+      const properties = { ...spaceProps[viewKey] ?? {} };
+      const getResultId = () => {
+        if (!resultPropertyKey) return id;
+        const entry = properties[resultPropertyKey];
+        if (!entry || typeof entry !== "object") {
+          throw new Error(`Invalid result property key "${resultPropertyKey}"`);
+        }
+        const ref = entry;
+        return `${ref.space ?? ""}:${ref.externalId ?? ""}`;
+      };
+      const edgesMapping = {};
+      const resultId = getResultId();
+      for (const [mappingKey, mapping] of Object.entries(mappings)) {
+        const element = properties[mappingKey];
+        const { isList, connectionType, nodes: mappingNodes, edges: mappingEdges } = mapping;
+        if (element === void 0 && connectionType === "DirectRelation") continue;
+        const elementKeys = getElementKeys(node, element);
+        const nodeEntries = elementKeys.flatMap((k) => mappingNodes.get(k) ?? []);
+        if (nodeEntries.length === 0) {
+          delete properties[mappingKey];
+          continue;
+        }
+        const entryData = nodeEntries.map((n) => this.nodeToDict(n));
+        properties[mappingKey] = isList ? entryData : entryData[0];
+        const edgeEntries = elementKeys.flatMap((k) => mappingEdges.get(k) ?? []);
+        if (edgeEntries.length > 0) edgesMapping[mappingKey] = edgeEntries;
+      }
+      properties._edges = edgesMapping;
+      if (node.properties?.[view.space]) {
+        node.properties[view.space] = {
+          ...node.properties[view.space],
+          [viewKey]: properties
+        };
+      }
+      const existing = result.get(resultId);
+      if (existing) {
+        existing.push(node);
+      } else {
+        result.set(resultId, [node]);
+      }
+    }
+    return result;
+  }
+  async getPropertyMappings(key, view, queryResult) {
+    const mappings = {};
+    for (const [propertyName, property] of Object.entries(view.properties)) {
+      const propertyKey = `${key}${NESTED_SEP}${propertyName}`;
+      let nodes = null;
+      let edges = /* @__PURE__ */ new Map();
+      let isList = false;
+      let connectionType = "DirectRelation";
+      if (isViewPropertyDefinition(property)) {
+        const source = getDirectRelationSource(property);
+        if (source) {
+          const nestedView = await this.viewMapper.getView(source.externalId);
+          nodes = await this.mapNodeProperty(propertyKey, nestedView, queryResult);
+          isList = isListDirectRelation(property);
+          connectionType = "DirectRelation";
+        }
+      } else if (isReverseDirectRelation(property)) {
+        const rel = property;
+        const nestedView = await this.viewMapper.getView(rel.source.externalId);
+        nodes = await this.mapNodeProperty(
+          propertyKey,
+          nestedView,
+          queryResult,
+          rel.through.identifier
+        );
+        isList = rel.connectionType === "multi_reverse_direct_relation" || rel.targetsList === true;
+        connectionType = "ReverseDirectRelation";
+      } else if (isEdgeConnection(property)) {
+        const nestedView = await this.viewMapper.getView(property.source.externalId);
+        const [edgeNodes, edgeEdges] = await this.mapEdgeProperty(
+          propertyKey,
+          nestedView,
+          queryResult,
+          property.direction ?? "outwards"
+        );
+        nodes = edgeNodes;
+        edges = edgeEdges ?? /* @__PURE__ */ new Map();
+        isList = true;
+        connectionType = "Edge";
+      }
+      if (nodes !== null) {
+        mappings[propertyName] = { isList, connectionType, nodes, edges };
+      }
+    }
+    return mappings;
+  }
+  async mapEdgeProperty(key, view, queryResult, edgeDirection) {
+    const edgeKey = `${key}${NESTED_SEP}${EDGE_MARKER}`;
+    if (!(key in queryResult) || !(edgeKey in queryResult)) return [null, null];
+    const nodes = await this.mapNodeProperty(key, view, queryResult);
+    if (!nodes) return [null, null];
+    const visitedEdges = /* @__PURE__ */ new Set();
+    const nodesResult = /* @__PURE__ */ new Map();
+    const edgesResult = /* @__PURE__ */ new Map();
+    for (const item of queryResult[edgeKey] ?? []) {
+      if (item.instanceType !== "edge") continue;
+      const edge = item;
+      const edgeId = `${edge.space}:${edge.externalId}`;
+      if (visitedEdges.has(edgeId)) continue;
+      visitedEdges.add(edgeId);
+      const entryKey = edgeDirection === "inwards" ? `${edge.endNode.space}:${edge.endNode.externalId}` : `${edge.startNode.space}:${edge.startNode.externalId}`;
+      const nodeKey = edgeDirection === "inwards" ? `${edge.startNode.space}:${edge.startNode.externalId}` : `${edge.endNode.space}:${edge.endNode.externalId}`;
+      const existingEdges = edgesResult.get(entryKey);
+      if (existingEdges) existingEdges.push(edge);
+      else edgesResult.set(entryKey, [edge]);
+      const relatedNodes = nodes.get(nodeKey);
+      if (relatedNodes) {
+        const existingNodes = nodesResult.get(entryKey);
+        if (existingNodes) existingNodes.push(...relatedNodes);
+        else nodesResult.set(entryKey, relatedNodes.slice());
+      }
+    }
+    return [nodesResult, edgesResult];
+  }
+  nodeToDict(node) {
+    const { properties, ...rest } = node;
+    const entry = { ...rest };
+    for (const spaceProp of Object.values(properties ?? {})) {
+      for (const viewProp of Object.values(spaceProp)) {
+        Object.assign(entry, viewProp);
+      }
+    }
+    return entry;
+  }
+};
+
+// src/mappers/view-mapper.ts
+var ViewMapper = class {
+  constructor(cognite, dataModelId) {
+    this.cognite = cognite;
+    this.dataModelId = dataModelId;
+    this.cachePromise = null;
+  }
+  async getView(externalId) {
+    const views = await this.loadViews();
+    const view = views.get(externalId);
+    if (!view) {
+      throw new Error(
+        `View "${externalId}" not found in data model "${this.dataModelId.externalId}"`
+      );
+    }
+    return view;
+  }
+  loadViews() {
+    if (this.cachePromise == null) {
+      this.cachePromise = this.fetchViews();
+    }
+    return this.cachePromise;
+  }
+  async fetchViews() {
+    const response = await this.cognite.retrieveDataModels(
+      [
+        {
+          space: this.dataModelId.space,
+          externalId: this.dataModelId.externalId,
+          version: this.dataModelId.version
+        }
+      ],
+      { inlineViews: true }
+    );
+    const dm = response.items.sort((a, b) => b.createdTime - a.createdTime)[0];
+    if (!dm) {
+      throw new Error(`Data model "${this.dataModelId.externalId}" not found`);
+    }
+    const views = /* @__PURE__ */ new Map();
+    for (const view of dm.views ?? []) {
+      views.set(view.externalId, view);
+    }
+    return views;
+  }
+};
+
+// src/utils/query.ts
+function mapNodesAndEdges(queryResult, _query) {
+  return queryResult.items;
+}
+function appendNodesAndEdges(initial, additional) {
+  if (!additional) return initial;
+  for (const [key, items] of Object.entries(additional)) {
+    const existing = initial[key];
+    if (existing) {
+      existing.push(...items);
+    } else {
+      initial[key] = [...items];
+    }
+  }
+  return initial;
+}
+function getQueryForDependenciesPagination(query, queryResult, viewExternalId) {
+  const cursorKeys = new Set(Object.keys(queryResult.nextCursor));
+  const { nodesParent, nodesChildren } = getParentAndChildrenNodes(cursorKeys);
+  const leafCursors = getLeafCursors(queryResult, viewExternalId, nodesParent, nodesChildren);
+  if (Object.keys(leafCursors).length === 0) {
+    return null;
+  }
+  return buildDependenciesQuery(query, nodesParent, nodesChildren, leafCursors);
+}
+function getParentAndChildrenNodes(keys) {
+  const nodesParent = /* @__PURE__ */ new Map();
+  const nodesChildren = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const keyParts = key.split(NESTED_SEP);
+    const validParents = /* @__PURE__ */ new Set();
+    for (let i = keyParts.length - 1; i > 0; i--) {
+      const parentPath = keyParts.slice(0, i).join(NESTED_SEP);
+      const parentWithEdgeMarker = `${parentPath}${NESTED_SEP}${EDGE_MARKER}`;
+      if (keys.has(parentWithEdgeMarker)) {
+        validParents.add(parentWithEdgeMarker);
+        const children = nodesChildren.get(parentWithEdgeMarker) ?? /* @__PURE__ */ new Set();
+        children.add(key);
+        nodesChildren.set(parentWithEdgeMarker, children);
+      }
+      if (keys.has(parentPath)) {
+        validParents.add(parentPath);
+        const children = nodesChildren.get(parentPath) ?? /* @__PURE__ */ new Set();
+        children.add(key);
+        nodesChildren.set(parentPath, children);
+      }
+    }
+    nodesParent.set(key, validParents);
+  }
+  return { nodesParent, nodesChildren };
+}
+function getLeafCursors(queryResult, viewExternalId, nodesParent, nodesChildren) {
+  const targetCursors = {};
+  const targetCursorKeys = /* @__PURE__ */ new Set();
+  for (const [cursorKey, cursorValue] of Object.entries(queryResult.nextCursor)) {
+    if (cursorKey === viewExternalId || !cursorValue || (queryResult.items[cursorKey]?.length ?? 0) !== MAX_LIMIT) {
+      continue;
+    }
+    const children = nodesChildren.get(cursorKey) ?? /* @__PURE__ */ new Set();
+    let skipDueToChild = false;
+    for (const c of children) {
+      if (targetCursorKeys.has(c)) {
+        skipDueToChild = true;
+        break;
+      }
+    }
+    if (skipDueToChild) continue;
+    const parent = nodesParent.get(cursorKey) ?? /* @__PURE__ */ new Set();
+    for (const key of parent) {
+      if (targetCursorKeys.has(key)) {
+        delete targetCursors[key];
+        targetCursorKeys.delete(key);
+      }
+    }
+    targetCursors[cursorKey] = cursorValue;
+    targetCursorKeys.add(cursorKey);
+  }
+  return targetCursors;
+}
+function buildDependenciesQuery(previousQuery, nodesParent, nodesChildren, leafCursors) {
+  const withExprs = {};
+  const selectExprs = {};
+  const finalCursors = {};
+  for (const [cursorKey, cursorValue] of Object.entries(leafCursors)) {
+    const children = nodesChildren.get(cursorKey) ?? /* @__PURE__ */ new Set();
+    const parent = nodesParent.get(cursorKey) ?? /* @__PURE__ */ new Set();
+    const validKeys = /* @__PURE__ */ new Set([...parent, ...children, cursorKey]);
+    for (const [k, v] of Object.entries(previousQuery.with)) {
+      if (validKeys.has(k)) withExprs[k] = v;
+    }
+    for (const [k, v] of Object.entries(previousQuery.select)) {
+      if (validKeys.has(k)) selectExprs[k] = v;
+    }
+    for (const [k, v] of Object.entries(previousQuery.cursors ?? {})) {
+      if (parent.has(k) && v) finalCursors[k] = v;
+    }
+    finalCursors[cursorKey] = cursorValue;
+  }
+  return { with: withExprs, select: selectExprs, cursors: finalCursors };
+}
+
+// src/client.ts
+var IndustrialModel = class {
+  constructor(client, dataModelId) {
+    const cognite = createCogniteAdapter(client);
+    this.cognite = cognite;
+    const viewMapper = new ViewMapper(cognite, dataModelId);
+    this.queryMapper = new QueryMapper(viewMapper);
+    this.resultMapper = new QueryResultMapper(viewMapper);
+  }
+  async query(options) {
+    const { viewExternalId, limit = DEFAULT_LIMIT } = options;
+    const allPages = options.limit === -1;
+    const cogniteQuery = await this.queryMapper.map(options);
+    const data = [];
+    while (true) {
+      const queryResult = await this.cognite.queryInstances(cogniteQuery);
+      const dependenciesData = await this.queryDependenciesPages(
+        cogniteQuery,
+        queryResult,
+        viewExternalId
+      );
+      const queryResultData = appendNodesAndEdges(
+        mapNodesAndEdges(queryResult),
+        dependenciesData
+      );
+      const pageResult = await this.resultMapper.mapNodes(viewExternalId, queryResultData);
+      const nextCursor = queryResult.nextCursor[viewExternalId] ?? null;
+      data.push(...pageResult);
+      const isLastPage = pageResult.length < limit || !nextCursor;
+      const resolvedCursor = isLastPage ? null : nextCursor;
+      if (!isLastPage && resolvedCursor !== null) {
+        cogniteQuery.cursors = { [viewExternalId]: resolvedCursor };
+      }
+      if (!allPages || isLastPage) {
+        return { items: data, cursor: resolvedCursor };
+      }
+    }
+  }
+  async queryDependenciesPages(cogniteQuery, queryResult, viewExternalId, remainingDepth = MAX_DEPENDENCY_DEPTH) {
+    if (remainingDepth <= 0) {
+      return null;
+    }
+    const newQuery = getQueryForDependenciesPagination(cogniteQuery, queryResult, viewExternalId);
+    if (!newQuery) return null;
+    const newQueryResult = await this.cognite.queryInstances(newQuery);
+    const result = mapNodesAndEdges(newQueryResult);
+    const nestedResults = await this.queryDependenciesPages(
+      newQuery,
+      newQueryResult,
+      viewExternalId,
+      remainingDepth - 1
+    );
+    return appendNodesAndEdges(result, nestedResults);
+  }
+};
+
+export { IndustrialModel };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map