industrial-model 0.6.0 → 0.7.0

package/dist/cognite-core/index.d.cts

@@ -1,5 +1,5 @@
 import { CogniteClient } from '@cognite/sdk';
-import { c as IndustrialModel, N as NodeId, h as AggregateOptions, a as AggregateResult, b as AggregateResultItem, g as QuerySelect, i as QueryOptions, e as QueryResult, f as QueryResultItem, I as IndustrialModelClientOptions } from '../types-DCP5GMi3.cjs';
+import { i as IndustrialModel, N as NodeId, s as AggregateOptions, b as AggregateResult, c as AggregateResultItem, m as QuerySelect, t as QueryOptions, k as QueryResult, l as QueryResultItem, o as UpsertOptions, q as UpsertResult, I as IndustrialModelClientOptions, a as DeleteResult } from '../types-2jjbs2i7.cjs';
 
 type CogniteCoreViewExternalId = "CogniteDescribable" | "CogniteSourceable" | "CogniteSourceSystem" | "CogniteSchedulable" | "CogniteVisualizable" | "Cognite3DTransformation" | "CogniteCubeMap" | "Cognite3DObject" | "Cognite3DModel" | "CogniteCADModel" | "Cognite3DRevision" | "CognitePointCloudModel" | "Cognite360ImageModel" | "CogniteCADRevision" | "CognitePointCloudRevision" | "Cognite360ImageCollection" | "CogniteCADNode" | "CognitePointCloudVolume" | "Cognite360Image" | "Cognite360ImageStation" | "Cognite360ImageAnnotation" | "CogniteAsset" | "CogniteAssetClass" | "CogniteAssetType" | "CogniteEquipment" | "CogniteEquipmentType" | "CogniteFile" | "CogniteFileCategory" | "CogniteActivity" | "CogniteTimeSeries" | "CogniteAnnotation" | "CogniteDiagramAnnotation" | "CogniteUnit";
 type CogniteDescribable = IndustrialModel<{
@@ -515,6 +515,7 @@ type CogniteCoreQueryExecutor<TView extends CogniteCoreViewExternalId> = {
     }): Promise<QueryResult<QueryResultItem<CogniteCoreModel<TView>, undefined>>>;
 };
 type CogniteCoreAggregateExecutor<TView extends CogniteCoreViewExternalId> = <const TOptions extends Omit<AggregateOptions<CogniteCoreModel<TView>>, "viewExternalId">>(options?: TOptions) => Promise<AggregateResult<AggregateResultItem<CogniteCoreModel<TView>, TOptions["groupBy"], TOptions["aggregate"]>>>;
+type CogniteCoreUpsertExecutor<TView extends CogniteCoreViewExternalId> = (options: Omit<UpsertOptions<CogniteCoreModel<TView>>, "viewExternalId">) => Promise<UpsertResult>;
 
 /** Data model id for Cognite Core v1. */
 declare const COGNITE_CORE_DATA_MODEL: {
@@ -527,6 +528,8 @@ declare class CogniteCoreClient {
     constructor(client: CogniteClient, options?: IndustrialModelClientOptions);
     query<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreQueryExecutor<TView>;
     aggregate<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreAggregateExecutor<TView>;
+    upsert<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreUpsertExecutor<TView>;
+    delete<TItem extends NodeId>(items: TItem[]): Promise<DeleteResult>;
 }
 
-export { COGNITE_CORE_DATA_MODEL, type Cognite360Image, type Cognite360ImageAnnotation, type Cognite360ImageCollection, type Cognite360ImageModel, type Cognite360ImageStation, type Cognite3DModel, type Cognite3DObject, type Cognite3DRevision, type Cognite3DTransformation, type CogniteActivity, type CogniteAnnotation, type CogniteAsset, type CogniteAssetClass, type CogniteAssetType, type CogniteCADModel, type CogniteCADNode, type CogniteCADRevision, type CogniteCoreAggregateExecutor, CogniteCoreClient, type CogniteCoreModel, type CogniteCoreModelByView, type CogniteCoreQueryExecutor, type CogniteCoreViewExternalId, type CogniteCubeMap, type CogniteDescribable, type CogniteDiagramAnnotation, type CogniteEquipment, type CogniteEquipmentType, type CogniteFile, type CogniteFileCategory, type CognitePointCloudModel, type CognitePointCloudRevision, type CognitePointCloudVolume, type CogniteSchedulable, type CogniteSourceSystem, type CogniteSourceable, type CogniteTimeSeries, type CogniteUnit, type CogniteVisualizable };
+export { COGNITE_CORE_DATA_MODEL, type Cognite360Image, type Cognite360ImageAnnotation, type Cognite360ImageCollection, type Cognite360ImageModel, type Cognite360ImageStation, type Cognite3DModel, type Cognite3DObject, type Cognite3DRevision, type Cognite3DTransformation, type CogniteActivity, type CogniteAnnotation, type CogniteAsset, type CogniteAssetClass, type CogniteAssetType, type CogniteCADModel, type CogniteCADNode, type CogniteCADRevision, type CogniteCoreAggregateExecutor, CogniteCoreClient, type CogniteCoreModel, type CogniteCoreModelByView, type CogniteCoreQueryExecutor, type CogniteCoreUpsertExecutor, type CogniteCoreViewExternalId, type CogniteCubeMap, type CogniteDescribable, type CogniteDiagramAnnotation, type CogniteEquipment, type CogniteEquipmentType, type CogniteFile, type CogniteFileCategory, type CognitePointCloudModel, type CognitePointCloudRevision, type CognitePointCloudVolume, type CogniteSchedulable, type CogniteSourceSystem, type CogniteSourceable, type CogniteTimeSeries, type CogniteUnit, type CogniteVisualizable };

package/dist/cognite-core/index.d.ts

@@ -1,5 +1,5 @@
 import { CogniteClient } from '@cognite/sdk';
-import { c as IndustrialModel, N as NodeId, h as AggregateOptions, a as AggregateResult, b as AggregateResultItem, g as QuerySelect, i as QueryOptions, e as QueryResult, f as QueryResultItem, I as IndustrialModelClientOptions } from '../types-DCP5GMi3.js';
+import { i as IndustrialModel, N as NodeId, s as AggregateOptions, b as AggregateResult, c as AggregateResultItem, m as QuerySelect, t as QueryOptions, k as QueryResult, l as QueryResultItem, o as UpsertOptions, q as UpsertResult, I as IndustrialModelClientOptions, a as DeleteResult } from '../types-2jjbs2i7.js';
 
 type CogniteCoreViewExternalId = "CogniteDescribable" | "CogniteSourceable" | "CogniteSourceSystem" | "CogniteSchedulable" | "CogniteVisualizable" | "Cognite3DTransformation" | "CogniteCubeMap" | "Cognite3DObject" | "Cognite3DModel" | "CogniteCADModel" | "Cognite3DRevision" | "CognitePointCloudModel" | "Cognite360ImageModel" | "CogniteCADRevision" | "CognitePointCloudRevision" | "Cognite360ImageCollection" | "CogniteCADNode" | "CognitePointCloudVolume" | "Cognite360Image" | "Cognite360ImageStation" | "Cognite360ImageAnnotation" | "CogniteAsset" | "CogniteAssetClass" | "CogniteAssetType" | "CogniteEquipment" | "CogniteEquipmentType" | "CogniteFile" | "CogniteFileCategory" | "CogniteActivity" | "CogniteTimeSeries" | "CogniteAnnotation" | "CogniteDiagramAnnotation" | "CogniteUnit";
 type CogniteDescribable = IndustrialModel<{
@@ -515,6 +515,7 @@ type CogniteCoreQueryExecutor<TView extends CogniteCoreViewExternalId> = {
     }): Promise<QueryResult<QueryResultItem<CogniteCoreModel<TView>, undefined>>>;
 };
 type CogniteCoreAggregateExecutor<TView extends CogniteCoreViewExternalId> = <const TOptions extends Omit<AggregateOptions<CogniteCoreModel<TView>>, "viewExternalId">>(options?: TOptions) => Promise<AggregateResult<AggregateResultItem<CogniteCoreModel<TView>, TOptions["groupBy"], TOptions["aggregate"]>>>;
+type CogniteCoreUpsertExecutor<TView extends CogniteCoreViewExternalId> = (options: Omit<UpsertOptions<CogniteCoreModel<TView>>, "viewExternalId">) => Promise<UpsertResult>;
 
 /** Data model id for Cognite Core v1. */
 declare const COGNITE_CORE_DATA_MODEL: {
@@ -527,6 +528,8 @@ declare class CogniteCoreClient {
     constructor(client: CogniteClient, options?: IndustrialModelClientOptions);
     query<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreQueryExecutor<TView>;
     aggregate<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreAggregateExecutor<TView>;
+    upsert<TView extends CogniteCoreViewExternalId>(viewExternalId: TView): CogniteCoreUpsertExecutor<TView>;
+    delete<TItem extends NodeId>(items: TItem[]): Promise<DeleteResult>;
 }
 
-export { COGNITE_CORE_DATA_MODEL, type Cognite360Image, type Cognite360ImageAnnotation, type Cognite360ImageCollection, type Cognite360ImageModel, type Cognite360ImageStation, type Cognite3DModel, type Cognite3DObject, type Cognite3DRevision, type Cognite3DTransformation, type CogniteActivity, type CogniteAnnotation, type CogniteAsset, type CogniteAssetClass, type CogniteAssetType, type CogniteCADModel, type CogniteCADNode, type CogniteCADRevision, type CogniteCoreAggregateExecutor, CogniteCoreClient, type CogniteCoreModel, type CogniteCoreModelByView, type CogniteCoreQueryExecutor, type CogniteCoreViewExternalId, type CogniteCubeMap, type CogniteDescribable, type CogniteDiagramAnnotation, type CogniteEquipment, type CogniteEquipmentType, type CogniteFile, type CogniteFileCategory, type CognitePointCloudModel, type CognitePointCloudRevision, type CognitePointCloudVolume, type CogniteSchedulable, type CogniteSourceSystem, type CogniteSourceable, type CogniteTimeSeries, type CogniteUnit, type CogniteVisualizable };
+export { COGNITE_CORE_DATA_MODEL, type Cognite360Image, type Cognite360ImageAnnotation, type Cognite360ImageCollection, type Cognite360ImageModel, type Cognite360ImageStation, type Cognite3DModel, type Cognite3DObject, type Cognite3DRevision, type Cognite3DTransformation, type CogniteActivity, type CogniteAnnotation, type CogniteAsset, type CogniteAssetClass, type CogniteAssetType, type CogniteCADModel, type CogniteCADNode, type CogniteCADRevision, type CogniteCoreAggregateExecutor, CogniteCoreClient, type CogniteCoreModel, type CogniteCoreModelByView, type CogniteCoreQueryExecutor, type CogniteCoreUpsertExecutor, type CogniteCoreViewExternalId, type CogniteCubeMap, type CogniteDescribable, type CogniteDiagramAnnotation, type CogniteEquipment, type CogniteEquipmentType, type CogniteFile, type CogniteFileCategory, type CognitePointCloudModel, type CognitePointCloudRevision, type CognitePointCloudVolume, type CogniteSchedulable, type CogniteSourceSystem, type CogniteSourceable, type CogniteTimeSeries, type CogniteUnit, type CogniteVisualizable };

package/dist/cognite-core/index.js

@@ -41,6 +41,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
@@ -794,6 +801,85 @@ ${result.error.issues.map((issue) => `- ${issue.path.map(String).join(".")}: ${i
     return (isList ? z.array(nestedSchema) : nestedSchema).optional();
   }
 };
+var strictNodeIdSchema = z.object({
+  space: z.string().min(1),
+  externalId: z.string().min(1)
+}).strict();
+var nodeIdLikeSchema = z.object({
+  space: z.string().min(1),
+  externalId: z.string().min(1)
+}).loose();
+var optionsSchema = z.object({
+  viewExternalId: z.string().min(1),
+  items: z.array(z.record(z.string(), z.unknown())),
+  onEdgeCreation: z.record(z.string(), z.function()).optional(),
+  replace: z.boolean().optional(),
+  edgeMode: 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 z.never();
+  }
+  return z.union([nodeIdLikeSchema, 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 ? 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([
@@ -1361,6 +1447,216 @@ var QueryResultMapper = class {
   }
 };
 
+// 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 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 } : {}
+    };
+  }
+  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)) {
+        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 });
+        }
+      }
+    }
+    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;
+  }
+  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 {
   constructor(cognite, dataModelId) {
@@ -1408,6 +1704,7 @@ var ViewMapper = class {
 };
 
 // src/client.ts
+var APPLY_ITEM_LIMIT = 1e3;
 var IndustrialModelClient = class {
   constructor(client, dataModelId, options = {}) {
     const cognite = createCogniteAdapter(client);
@@ -1415,6 +1712,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);
@@ -1428,6 +1726,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);
@@ -1484,6 +1830,18 @@ 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");
+  }
+}
 
 // src/cognite-core/client.ts
 var COGNITE_CORE_DATA_MODEL = {
@@ -1506,6 +1864,14 @@ var CogniteCoreClient = class {
     const execute = (options = {}) => aggregate({ ...options, viewExternalId });
     return execute;
   }
+  upsert(viewExternalId) {
+    const upsert = this.model.upsert();
+    const execute = (options) => upsert({ ...options, viewExternalId });
+    return execute;
+  }
+  delete(items) {
+    return this.model.delete(items);
+  }
 };
 
 export { COGNITE_CORE_DATA_MODEL, CogniteCoreClient };