industrial-model 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -43,6 +43,13 @@ var CogniteSdkAdapter = class {
       items: response.items
     };
   }
+  async applyInstances(request) {
+    const apply = this.client.instances.apply;
+    const response = await apply(request);
+    return {
+      items: response.items
+    };
+  }
 };
 
 // src/constants.ts
@@ -54,7 +61,108 @@ var MAX_DEPENDENCY_DEPTH = 3;
 var AGGREGATE_LIMIT = 1e3;
 var MAX_GROUP_BY = 5;
 
-// src/mappers/utils.ts
+// 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/utils/view.ts
 var NODE_PROPERTIES = /* @__PURE__ */ new Set([
   "externalId",
   "space",
@@ -118,8 +226,6 @@ function isNumericProperty(property) {
 function getSelectedGroupByKeys(groupBy) {
   return Object.entries(groupBy).filter((entry) => entry[1] === true).map(([key]) => key);
 }
-
-// src/validation.ts
 var nodeIdSchema = zod.z.object({
   space: zod.z.string().min(1),
   externalId: zod.z.string().min(1)
@@ -168,17 +274,8 @@ function propertyValueSchema(property, options = {}) {
   }
   return type.list === true ? zod.z.array(schema) : schema;
 }
-function buildViewSchema(view, options = {}) {
-  const shape = {};
-  for (const [name, property] of Object.entries(view.properties)) {
-    if (isViewPropertyDefinition(property)) {
-      shape[name] = propertyValueSchema(property, options).optional();
-    }
-  }
-  return zod.z.object(shape).strict();
-}
 
-// src/mappers/query-validator.ts
+// src/validators/query-validator.ts
 var NODE_STRING_PROPERTIES = ["externalId", "space"];
 var NODE_NUMBER_PROPERTIES = ["createdTime", "deletedTime", "lastUpdatedTime"];
 var NODE_PROPERTIES2 = /* @__PURE__ */ new Set([...NODE_STRING_PROPERTIES, ...NODE_NUMBER_PROPERTIES]);
@@ -389,6 +486,12 @@ ${errors.map((error) => `- ${error}`).join("\n")}`);
         );
         continue;
       }
+      if (isReverseDirectRelation(property) && property.targetsList) {
+        errors.push(
+          `${issuePath([...path, name])}: cannot select "${name}" \u2014 Cognite does not support inward traversal of list direct relations. Query "${property.source.externalId}" directly and filter by the "${property.through.identifier}" field instead.`
+        );
+        continue;
+      }
       const targetView = await this.viewMapper.getView(target);
       errors.push(...await this.validateSelect(value, targetView, [...path, name]));
     }
@@ -478,7 +581,7 @@ ${errors.map((error) => `- ${error}`).join("\n")}`);
   }
 };
 
-// src/mappers/aggregate-validator.ts
+// src/validators/aggregate-validator.ts
 var NODE_COUNT_PROPERTIES = /* @__PURE__ */ new Set(["externalId", "space"]);
 function issuePath2(path) {
   return path.length === 0 ? "aggregate" : path.map(String).join(".");
@@ -614,6 +717,171 @@ ${errors.map((error) => `- ${error}`).join("\n")}`
     return [];
   }
 };
+var nodeMetadataSchema = {
+  instanceType: zod.z.literal("node").optional(),
+  space: zod.z.string(),
+  externalId: zod.z.string(),
+  version: zod.z.number().optional(),
+  createdTime: zod.z.number().optional(),
+  deletedTime: zod.z.number().optional(),
+  lastUpdatedTime: zod.z.number().optional(),
+  _edges: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+};
+function isListRelation(property) {
+  if (isViewPropertyDefinition(property)) {
+    return isListDirectRelation(property);
+  }
+  if (isReverseDirectRelation(property)) {
+    return property.connectionType === "multi_reverse_direct_relation" || property.targetsList === true;
+  }
+  return isEdgeConnection(property);
+}
+function isRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+var QueryResultValidator = class {
+  constructor(viewMapper) {
+    this.viewMapper = viewMapper;
+  }
+  async parseItems(rootViewExternalId, items, select) {
+    const rootView = await this.viewMapper.getView(rootViewExternalId);
+    const schema = await this.buildResultSchema(rootView, MAX_DEPENDENCY_DEPTH, select);
+    const result = zod.z.array(schema).safeParse(items);
+    if (!result.success) {
+      throw new Error(
+        `Invalid query result:
+${result.error.issues.map((issue) => `- ${issue.path.map(String).join(".")}: ${issue.message}`).join("\n")}`
+      );
+    }
+    return result.data;
+  }
+  async buildResultSchema(view, remainingDepth, select) {
+    const shape = { ...nodeMetadataSchema };
+    const includeAllProperties = select == null || select._all === true;
+    for (const [name, property] of Object.entries(view.properties)) {
+      const isSelected = includeAllProperties || name in select;
+      if (!isSelected) continue;
+      const nestedSelect = isRecord2(select?.[name]) ? select[name] : void 0;
+      if (isViewPropertyDefinition(property)) {
+        const relationSource = getDirectRelationSource(property);
+        if (relationSource) {
+          shape[name] = await this.buildRelationSchema(
+            property,
+            relationSource.externalId,
+            remainingDepth,
+            nestedSelect
+          );
+        } else {
+          shape[name] = propertyValueSchema(property, { dateMode: "coerce" }).optional();
+        }
+        continue;
+      }
+      if (isReverseDirectRelation(property) || isEdgeConnection(property)) {
+        shape[name] = await this.buildRelationSchema(
+          property,
+          property.source.externalId,
+          remainingDepth,
+          nestedSelect
+        );
+      }
+    }
+    const schema = zod.z.object(shape);
+    return includeAllProperties ? schema.strict() : schema;
+  }
+  async buildRelationSchema(property, targetViewExternalId, remainingDepth, select) {
+    const isList = isListRelation(property);
+    const fallbackSchema = isViewPropertyDefinition(property) ? propertyValueSchema(property, { dateMode: "coerce" }) : zod.z.unknown();
+    if (remainingDepth <= 0 || select == null) {
+      return fallbackSchema.optional();
+    }
+    const targetView = await this.viewMapper.getView(targetViewExternalId);
+    const nestedSchema = await this.buildResultSchema(targetView, remainingDepth - 1, select);
+    if (isViewPropertyDefinition(property)) {
+      const nestedRelationSchema = isList ? zod.z.array(nestedSchema) : nestedSchema;
+      return zod.z.union([nestedRelationSchema, fallbackSchema]).optional();
+    }
+    return (isList ? zod.z.array(nestedSchema) : nestedSchema).optional();
+  }
+};
+var strictNodeIdSchema = zod.z.object({
+  space: zod.z.string().min(1),
+  externalId: zod.z.string().min(1)
+}).strict();
+var nodeIdLikeSchema = zod.z.object({
+  space: zod.z.string().min(1),
+  externalId: zod.z.string().min(1)
+}).loose();
+var optionsSchema = zod.z.object({
+  viewExternalId: zod.z.string().min(1),
+  items: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())),
+  onEdgeCreation: zod.z.record(zod.z.string(), zod.z.function()).optional(),
+  replace: zod.z.boolean().optional(),
+  edgeMode: zod.z.enum(["append", "replace"]).optional()
+}).strict();
+function issuePath3(path) {
+  return path.length === 0 ? "upsert" : path.map(String).join(".");
+}
+function formatZodIssues3(error, path) {
+  return error.issues.map((issue) => `${issuePath3([...path, ...issue.path])}: ${issue.message}`);
+}
+function relationValueSchema(property) {
+  if (isReverseDirectRelation(property) && property.targetsList === true) {
+    return zod.z.never();
+  }
+  return zod.z.union([nodeIdLikeSchema, zod.z.array(nodeIdLikeSchema)]);
+}
+var UpsertValidator = class {
+  validate(options, rootView) {
+    const errors = [];
+    const optionsResult = optionsSchema.safeParse(options);
+    if (!optionsResult.success) {
+      errors.push(...formatZodIssues3(optionsResult.error, []));
+    }
+    if (options.viewExternalId !== rootView.externalId) {
+      errors.push(
+        `viewExternalId: expected "${rootView.externalId}", received "${options.viewExternalId}"`
+      );
+    }
+    for (const [index, item] of options.items.entries()) {
+      errors.push(
+        ...this.validateItem(item, rootView, ["items", index])
+      );
+    }
+    if (errors.length > 0) {
+      throw new Error(`Invalid upsert options:
+${errors.map((error) => `- ${error}`).join("\n")}`);
+    }
+  }
+  validateItem(item, view, path) {
+    const errors = [];
+    const identityResult = strictNodeIdSchema.safeParse({
+      space: item.space,
+      externalId: item.externalId
+    });
+    if (!identityResult.success) {
+      errors.push(...formatZodIssues3(identityResult.error, path));
+    }
+    for (const [name, value] of Object.entries(item)) {
+      if (name === "space" || name === "externalId") continue;
+      const property = view.properties[name];
+      if (!property) {
+        errors.push(`${issuePath3([...path, name])}: unknown view property`);
+        continue;
+      }
+      if (isViewPropertyDefinition(property)) {
+        const schema = property.type.type === "direct" ? property.type.list === true ? zod.z.array(nodeIdLikeSchema) : nodeIdLikeSchema : propertyValueSchema(property);
+        const result = schema.safeParse(value);
+        if (!result.success) errors.push(...formatZodIssues3(result.error, [...path, name]));
+        continue;
+      }
+      if (isReverseDirectRelation(property) || isEdgeConnection(property)) {
+        const result = relationValueSchema(property).safeParse(value);
+        if (!result.success) errors.push(...formatZodIssues3(result.error, [...path, name]));
+      }
+    }
+    return errors;
+  }
+};
 
 // src/mappers/filter-mapper.ts
 var LEAF_OPS = /* @__PURE__ */ new Set([
@@ -1180,92 +1448,216 @@ var QueryResultMapper = class {
     return entry;
   }
 };
-var nodeMetadataSchema = {
-  instanceType: zod.z.literal("node").optional(),
-  space: zod.z.string(),
-  externalId: zod.z.string(),
-  version: zod.z.number().optional(),
-  createdTime: zod.z.number().optional(),
-  deletedTime: zod.z.number().optional(),
-  lastUpdatedTime: zod.z.number().optional(),
-  _edges: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-};
-function isListRelation(property) {
-  if (isViewPropertyDefinition(property)) {
-    return isListDirectRelation(property);
-  }
-  if (isReverseDirectRelation(property)) {
-    return property.connectionType === "multi_reverse_direct_relation" || property.targetsList === true;
-  }
-  return isEdgeConnection(property);
-}
-function isRecord2(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-var QueryResultValidator = class {
-  constructor(viewMapper) {
+
+// src/mappers/upsert-mapper.ts
+var IDENTITY_KEYS = /* @__PURE__ */ new Set(["space", "externalId"]);
+var EDGE_QUERY_LIMIT = 1e3;
+var UpsertMapper = class {
+  constructor(viewMapper, cognite) {
     this.viewMapper = viewMapper;
+    this.cognite = cognite;
+    this.validator = new UpsertValidator();
   }
-  async parseItems(rootViewExternalId, items, select) {
-    const rootView = await this.viewMapper.getView(rootViewExternalId);
-    const schema = await this.buildResultSchema(rootView, MAX_DEPENDENCY_DEPTH, select);
-    const result = zod.z.array(schema).safeParse(items);
-    if (!result.success) {
-      throw new Error(
-        `Invalid query result:
-${result.error.issues.map((issue) => `- ${issue.path.map(String).join(".")}: ${issue.message}`).join("\n")}`
-      );
-    }
-    return result.data;
+  async map(options) {
+    const rootView = await this.viewMapper.getView(options.viewExternalId);
+    this.validator.validate(options, rootView);
+    const edgeMode = options.edgeMode ?? "append";
+    const mappedItems = options.items.map(
+      (item) => this.mapItem(item, rootView, options.onEdgeCreation, edgeMode)
+    );
+    const items = mappedItems.flatMap((item) => item.writes);
+    const edgeReplacements = mappedItems.flatMap((item) => item.edgeReplacements);
+    const deleteItems = edgeMode === "replace" ? await this.mapEdgeReplacementDeletes(edgeReplacements) : [];
+    return {
+      items,
+      ...deleteItems.length > 0 ? { delete: deleteItems } : {},
+      ...options.replace === true ? { replace: true } : {}
+    };
   }
-  async buildResultSchema(view, remainingDepth, select) {
-    const shape = { ...nodeMetadataSchema };
-    const includeAllProperties = select == null || select._all === true;
-    for (const [name, property] of Object.entries(view.properties)) {
-      const isSelected = includeAllProperties || name in select;
-      if (!isSelected) continue;
-      const nestedSelect = isRecord2(select?.[name]) ? select[name] : void 0;
+  mapItem(item, rootView, onEdgeCreation, edgeMode) {
+    const node = { space: item.space, externalId: item.externalId };
+    const nodeProperties = {};
+    const inferredItems = [];
+    const edgeReplacements = [];
+    for (const [name, value] of Object.entries(item)) {
+      if (IDENTITY_KEYS.has(name)) continue;
+      const property = rootView.properties[name];
+      if (!property) continue;
       if (isViewPropertyDefinition(property)) {
-        const relationSource = getDirectRelationSource(property);
-        if (relationSource) {
-          shape[name] = await this.buildRelationSchema(
-            property,
-            relationSource.externalId,
-            remainingDepth,
-            nestedSelect
-          );
-        } else {
-          shape[name] = propertyValueSchema(property, { dateMode: "coerce" }).optional();
+        nodeProperties[name] = normalizeViewPropertyValue(value, property);
+      } else if (isReverseDirectRelation(property)) {
+        inferredItems.push(...this.mapReverseDirectRelation(node, value, property));
+      } else if (isEdgeConnection(property)) {
+        const desiredEdges = this.mapEdgeConnection(node, name, value, property, onEdgeCreation);
+        inferredItems.push(...desiredEdges);
+        if (edgeMode === "replace") {
+          edgeReplacements.push({ rootNode: node, propertyName: name, property, desiredEdges });
         }
-        continue;
-      }
-      if (isReverseDirectRelation(property) || isEdgeConnection(property)) {
-        shape[name] = await this.buildRelationSchema(
-          property,
-          property.source.externalId,
-          remainingDepth,
-          nestedSelect
-        );
       }
     }
-    const schema = zod.z.object(shape);
-    return includeAllProperties ? schema.strict() : schema;
+    const applyNode = {
+      instanceType: "node",
+      ...node
+    };
+    if (Object.keys(nodeProperties).length > 0) {
+      applyNode.sources = [{ source: toViewReference(rootView), properties: nodeProperties }];
+    }
+    return { writes: [applyNode, ...inferredItems], edgeReplacements };
+  }
+  async mapEdgeReplacementDeletes(replacements) {
+    const deletes = await Promise.all(
+      replacements.map(async (replacement) => {
+        const existingEdges = await this.queryExistingEdges(replacement);
+        const desiredEdgeKeys = new Set(replacement.desiredEdges.map((edge) => instanceKey(edge)));
+        return existingEdges.filter((edge) => !desiredEdgeKeys.has(instanceKey(edge))).map((edge) => ({
+          instanceType: "edge",
+          space: edge.space,
+          externalId: edge.externalId
+        }));
+      })
+    );
+    return uniqueDeletes(deletes.flat());
+  }
+  async queryExistingEdges(replacement) {
+    const rootKey = `${replacement.propertyName}Root`;
+    const edgeKey = `${replacement.propertyName}Edges`;
+    const direction = replacement.property.direction ?? "outwards";
+    const query = {
+      with: {
+        [rootKey]: {
+          nodes: {
+            filter: {
+              instanceReferences: [replacement.rootNode]
+            }
+          },
+          limit: 1
+        },
+        [edgeKey]: {
+          edges: {
+            from: rootKey,
+            maxDistance: 1,
+            direction,
+            filter: {
+              equals: { property: ["edge", "type"], value: replacement.property.type }
+            }
+          },
+          limit: EDGE_QUERY_LIMIT
+        }
+      },
+      select: {
+        [rootKey]: {},
+        [edgeKey]: {}
+      }
+    };
+    const edges = [];
+    let cursor;
+    do {
+      const response = await this.cognite.queryInstances({
+        ...query,
+        ...cursor ? { cursors: { [edgeKey]: cursor } } : {}
+      });
+      edges.push(
+        ...(response.items[edgeKey] ?? []).filter(
+          (item) => item.instanceType === "edge"
+        )
+      );
+      cursor = response.nextCursor[edgeKey];
+    } while (cursor);
+    return edges;
   }
-  async buildRelationSchema(property, targetViewExternalId, remainingDepth, select) {
-    const isList = isListRelation(property);
-    const fallbackSchema = isViewPropertyDefinition(property) ? propertyValueSchema(property, { dateMode: "coerce" }) : zod.z.unknown();
-    if (remainingDepth <= 0 || select == null) {
-      return fallbackSchema.optional();
-    }
-    const targetView = await this.viewMapper.getView(targetViewExternalId);
-    const nestedSchema = await this.buildResultSchema(targetView, remainingDepth - 1, select);
-    if (isViewPropertyDefinition(property)) {
-      const nestedRelationSchema = isList ? zod.z.array(nestedSchema) : nestedSchema;
-      return zod.z.union([nestedRelationSchema, fallbackSchema]).optional();
-    }
-    return (isList ? zod.z.array(nestedSchema) : nestedSchema).optional();
+  mapReverseDirectRelation(node, value, property) {
+    const targets = asNodeIdArray(value);
+    return targets.map((target) => ({
+      instanceType: "node",
+      ...target,
+      sources: [
+        {
+          source: property.through.source,
+          properties: {
+            [property.through.identifier]: normalizeReverseDirectRelationValue(node, property)
+          }
+        }
+      ]
+    }));
+  }
+  mapEdgeConnection(node, propertyName, value, property, onEdgeCreation) {
+    const direction = property.direction ?? "outwards";
+    return asNodeIdArray(value).map((target) => {
+      const startNode = direction === "inwards" ? target : node;
+      const endNode = direction === "inwards" ? node : target;
+      const edgeType = toNodeId(property.type, `edge type for "${propertyName}"`);
+      const createEdgeId = onEdgeCreation?.[propertyName];
+      if (!createEdgeId) {
+        throw new Error(
+          `Invalid upsert options:
+- onEdgeCreation.${propertyName}: required when ingesting edge connection "${propertyName}"`
+        );
+      }
+      const edgeId = createEdgeId({
+        startNode,
+        endNode,
+        edgeType
+      });
+      assertNodeId(edgeId, `onEdgeCreation(${propertyName})`);
+      return {
+        instanceType: "edge",
+        ...edgeId,
+        type: property.type,
+        startNode,
+        endNode
+      };
+    });
   }
 };
+function normalizeReverseDirectRelationValue(node, property) {
+  return property.targetsList === true ? [node] : node;
+}
+function normalizeViewPropertyValue(value, property) {
+  if (property.type.type !== "direct") return normalizePropertyValue(value);
+  if (Array.isArray(value)) return value.map((item) => toNodeId(item));
+  return toNodeId(value);
+}
+function normalizePropertyValue(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(normalizePropertyValue);
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nestedValue]) => [key, normalizePropertyValue(nestedValue)])
+    );
+  }
+  return value;
+}
+function asNodeIdArray(value) {
+  return Array.isArray(value) ? value.map((item) => toNodeId(item)) : [toNodeId(value)];
+}
+function toNodeId(value, label = "relation reference") {
+  if (!isPlainObject(value) || typeof value.space !== "string" || typeof value.externalId !== "string") {
+    throw new Error(`Invalid upsert options:
+- ${label}: expected a NodeId`);
+  }
+  return { space: value.space, externalId: value.externalId };
+}
+function instanceKey(instance) {
+  return `${instance.space}\0${instance.externalId}`;
+}
+function uniqueDeletes(deletes) {
+  const seen = /* @__PURE__ */ new Set();
+  return deletes.filter((item) => {
+    const key = instanceKey(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function assertNodeId(value, label) {
+  if (!isPlainObject(value) || typeof value.space !== "string" || typeof value.externalId !== "string") {
+    throw new Error(`Invalid upsert options:
+- ${label}: expected a NodeId`);
+  }
+}
+function isPlainObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
 
 // src/mappers/view-mapper.ts
 var ViewMapper = class {
@@ -1313,108 +1705,8 @@ var ViewMapper = class {
   }
 };
 
-// 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 APPLY_ITEM_LIMIT = 1e3;
 var IndustrialModelClient = class {
   constructor(client, dataModelId, options = {}) {
     const cognite = createCogniteAdapter(client);
@@ -1422,6 +1714,7 @@ var IndustrialModelClient = class {
     const viewMapper = new ViewMapper(cognite, dataModelId);
     this.queryMapper = new QueryMapper(viewMapper, cognite);
     this.aggregateMapper = new AggregateMapper(viewMapper, cognite);
+    this.upsertMapper = new UpsertMapper(viewMapper, cognite);
     this.aggregateResultMapper = new AggregateResultMapper();
     this.resultMapper = new QueryResultMapper(viewMapper);
     this.resultValidator = new QueryResultValidator(viewMapper);
@@ -1435,6 +1728,54 @@ var IndustrialModelClient = class {
     const execute = (options) => this.aggregateInternal(options);
     return execute;
   }
+  upsert() {
+    const execute = (options) => this.upsertInternal(options);
+    return execute;
+  }
+  async delete(items) {
+    const deleteItems = items.map((item) => {
+      assertNodeId2(item);
+      return {
+        instanceType: "node",
+        space: item.space,
+        externalId: item.externalId
+      };
+    });
+    const response = await this.applyInstancesInChunks({
+      items: [],
+      delete: deleteItems
+    });
+    return { items: response.items };
+  }
+  async upsertInternal(options) {
+    const cogniteRequest = await this.upsertMapper.map(options);
+    const response = await this.applyInstancesInChunks(cogniteRequest);
+    return { items: response.items };
+  }
+  async applyInstancesInChunks(request) {
+    const deleteItems = request.delete ?? [];
+    const totalItems = request.items.length + deleteItems.length;
+    if (totalItems === 0) return { items: [] };
+    if (totalItems <= APPLY_ITEM_LIMIT) {
+      return this.cognite.applyInstances(request);
+    }
+    const responses = [];
+    for (const deleteChunk of chunks(deleteItems, APPLY_ITEM_LIMIT)) {
+      const response = await this.cognite.applyInstances({
+        items: [],
+        delete: deleteChunk
+      });
+      responses.push(...response.items);
+    }
+    for (const itemChunk of chunks(request.items, APPLY_ITEM_LIMIT)) {
+      const response = await this.cognite.applyInstances({
+        items: itemChunk,
+        ...request.replace === true ? { replace: true } : {}
+      });
+      responses.push(...response.items);
+    }
+    return { items: responses };
+  }
   async aggregateInternal(options) {
     const cogniteRequest = await this.aggregateMapper.map(options);
     const response = await this.cognite.aggregateInstances(cogniteRequest);
@@ -1491,9 +1832,19 @@ var IndustrialModelClient = class {
     return appendNodesAndEdges(result, nestedResults);
   }
 };
+function chunks(items, size) {
+  const result = [];
+  for (let index = 0; index < items.length; index += size) {
+    result.push(items.slice(index, index + size));
+  }
+  return result;
+}
+function assertNodeId2(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value) || typeof value.space !== "string" || value.space?.length === 0 || typeof value.externalId !== "string" || value.externalId?.length === 0) {
+    throw new Error("Invalid delete options:\n- items: expected NodeId values");
+  }
+}
 
 exports.IndustrialModelClient = IndustrialModelClient;
-exports.buildViewSchema = buildViewSchema;
-exports.nodeIdSchema = nodeIdSchema;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map