industrial-model 0.6.0 → 0.7.0

package/README.md

@@ -12,6 +12,7 @@ TypeScript SDK for querying [Cognite Flexible Data Models (FDM)](https://docs.co
 - **Industrial filters** - combine scalar filters, list filters, full-text search, and nested relation filters.
 - **Pagination support** - use cursors manually or fetch all root pages with `limit: -1`.
 - **Aggregation support** - count, group, list distinct values, and aggregate numeric properties.
+- **Mutation support** - upsert model-shaped node patches and delete nodes by identity.
 - **Runtime validation option** - parse query results with Zod schemas derived from Cognite view metadata.
 - **CJS and ESM builds** - works in Node.js and common bundler setups.
 
@@ -518,6 +519,114 @@ const { items } = await model.query<CogniteAsset>()({
 
 Expanded relations use internal pagination as well. When a nested relation query reaches the internal page size, the client follows dependency cursors for up to 3 additional rounds.
 
+## Upsert
+
+Use `upsert()` to create or patch nodes with the same model shape you use for queries. Each item must include `space` and `externalId`; all other fields are optional and only the fields you pass are updated.
+
+```ts
+await model.upsert<CogniteAsset>()({
+  viewExternalId: "CogniteAsset",
+  items: [
+    {
+      space: "asset-space",
+      externalId: "pump-1",
+      name: "Pump 1",
+      parent: { space: "asset-space", externalId: "root" },
+    },
+  ],
+});
+```
+
+Direct relations are written as `NodeId` values. Reverse direct relations are written by patching the target nodes through the relation field defined in Cognite. For example, writing `children` on an asset updates each child asset's `parent` reference.
+
+```ts
+await model.upsert<CogniteAsset>()({
+  viewExternalId: "CogniteAsset",
+  items: [
+    {
+      space: "asset-space",
+      externalId: "parent-asset",
+      children: [{ space: "asset-space", externalId: "child-1" }],
+    },
+  ],
+});
+```
+
+Edge-backed relations need an edge ID. Provide `onEdgeCreation` for every edge connection property you write. The callback receives normalized `startNode`, `endNode`, and `edgeType` values after the SDK has applied the relation direction from the view metadata.
+
+```ts
+await model.upsert<Cognite3DObject>()({
+  viewExternalId: "Cognite3DObject",
+  items: [
+    {
+      space: "object-space",
+      externalId: "object-1",
+      images360: [{ space: "image-space", externalId: "image-1" }],
+    },
+  ],
+  onEdgeCreation: {
+    images360: ({ startNode, endNode, edgeType }) => ({
+      space: startNode.space,
+      externalId: `${startNode.externalId}:${edgeType.externalId}:${endNode.externalId}`,
+    }),
+  },
+});
+```
+
+`edgeMode` controls how edge connection properties are applied:
+
+| Mode | Behavior |
+| --- | --- |
+| `"append"` | Default. Creates the generated edges and leaves existing edges untouched. |
+| `"replace"` | Queries existing edges for the provided edge connection fields, deletes edges that were not generated by the current upsert, then applies the new edges. |
+
+To clear an edge connection for a node, include the property with an empty array and use `edgeMode: "replace"`:
+
+```ts
+await model.upsert<Cognite3DObject>()({
+  viewExternalId: "Cognite3DObject",
+  edgeMode: "replace",
+  items: [
+    {
+      space: "object-space",
+      externalId: "object-1",
+      images360: [],
+    },
+  ],
+});
+```
+
+This deletes existing `images360` edges for `object-1`. Other edge connection fields on the same node are not touched, and omitting `images360` entirely leaves its existing edges unchanged.
+
+Use `replace: true` when you want Cognite apply replace semantics for container-backed node properties.
+
+Important constraints:
+
+- Relation fields accept only `NodeId` or `NodeId[]` references. Nested node mutation is intentionally not supported.
+- Unknown fields are rejected before Cognite is called.
+- Edge connection fields require `onEdgeCreation.<property>` only when the submitted array contains edges to create.
+- Cognite apply requests are limited to 1000 writes/deletes per call. You can still pass more than 1000 upsert items or edge references; the SDK follows paginated edge-replacement queries and splits large apply payloads into multiple Cognite calls.
+- `edgeMode: "replace"` only replaces edge connection fields included in the submitted items.
+
+## Delete
+
+Use `delete()` when you only need to delete nodes by identity. The method accepts an array of values with `space` and `externalId`; any extra fields are ignored.
+
+```ts
+await model.delete([
+  { space: "asset-space", externalId: "pump-1" },
+  { space: "asset-space", externalId: "pump-2", name: "Pump 2" },
+]);
+```
+
+The delete operation is view-independent, so it does not require `viewExternalId` and is also available directly on `CogniteCoreClient`.
+
+```ts
+await core.delete([{ space: "asset-space", externalId: "pump-1" }]);
+```
+
+Deletes are sent through Cognite apply. When more than 1000 nodes are provided, the SDK splits them into multiple Cognite calls.
+
 ## Aggregation
 
 Use `aggregate()` when you need grouped counts, distinct values, or numeric summaries without loading every instance.
@@ -654,7 +763,7 @@ For applications working with the Cognite Core Data Model (`cdf_cdm/CogniteCore/
 
 ```ts
 import { CogniteClient } from "@cognite/sdk";
-import { CogniteCoreClient } from "industrial-model";
+import { CogniteCoreClient } from "industrial-model/cognite-core";
 
 const client = new CogniteClient({ ... });
 const core = new CogniteCoreClient(client);
@@ -696,6 +805,27 @@ items[0]?.group?.manufacturer;
 items[0]?.aggregate?.value;
 ```
 
+Upserts use the same pattern and infer the item shape from the view name:
+
+```ts
+await core.upsert("CogniteAsset")({
+  items: [
+    {
+      space: "asset-space",
+      externalId: "pump-1",
+      name: "Pump 1",
+      parent: { space: "asset-space", externalId: "root" },
+    },
+  ],
+});
+```
+
+Deletes are view-independent:
+
+```ts
+await core.delete([{ space: "asset-space", externalId: "pump-1" }]);
+```
+
 All Cognite Core view types are exported from `industrial-model` and can be imported directly for use with `IndustrialModelClient` if needed:
 
 ```ts
@@ -849,6 +979,14 @@ Same as `model.query<TModel>()(options)` on `IndustrialModelClient`, except the
 
 Same as `model.aggregate<TModel>()(options)` on `IndustrialModelClient`, with the view name as the first positional argument.
 
+### `core.upsert(viewExternalId)(options)`
+
+Same as `model.upsert<TModel>()(options)` on `IndustrialModelClient`, with the view name as the first positional argument. The model type is inferred from the Cognite Core view name.
+
+### `core.delete(items)`
+
+Same as `model.delete(items)` on `IndustrialModelClient`. Deletes nodes by `space` and `externalId`; no view name is required.
+
 ### `new IndustrialModelClient(client, dataModelId, options?)`
 
 | Parameter | Type | Description |
@@ -883,6 +1021,58 @@ type QueryResult<TItem> = {
 
 Each item includes instance metadata such as `space`, `externalId`, `version`, `createdTime`, `deletedTime`, and `lastUpdatedTime`, plus the selected fields.
 
+### `model.upsert<TModel>()(options)`
+
+`upsert()` uses the same model type as `query()` and accepts partial node patches. It returns the Cognite apply result items.
+
+| Option | Description |
+| --- | --- |
+| `viewExternalId` | View to create or patch. |
+| `items` | Node patches. Each item must include `space` and `externalId`. Inputs larger than Cognite's 1000-item apply limit are split into multiple calls. |
+| `replace` | Optional. Enables Cognite apply replace semantics for submitted container-backed properties. |
+| `edgeMode` | Optional. `"append"` by default; use `"replace"` to remove existing edge connection edges for submitted edge fields before applying the new references. |
+| `onEdgeCreation` | Optional map of edge connection property names to callbacks that generate edge IDs. Required for every edge connection property that creates one or more edges. |
+
+Returns:
+
+```ts
+type UpsertResult = {
+  items: Array<{
+    instanceType: "node" | "edge";
+    space: string;
+    externalId: string;
+    version?: number;
+    wasModified?: boolean;
+    createdTime?: number;
+    lastUpdatedTime?: number;
+  }>;
+};
+```
+
+### `model.delete<TItem extends NodeId>(items)`
+
+Deletes nodes by identity. Each item must include `space` and `externalId`; extra fields are ignored. Inputs larger than Cognite's 1000-item apply limit are split into multiple calls.
+
+```ts
+await model.delete([{ space: "asset-space", externalId: "pump-1" }]);
+```
+
+Returns:
+
+```ts
+type DeleteResult = {
+  items: Array<{
+    instanceType: "node";
+    space: string;
+    externalId: string;
+    version?: number;
+    wasModified?: boolean;
+    createdTime?: number;
+    lastUpdatedTime?: number;
+  }>;
+};
+```
+
 ### `model.aggregate<TModel>()(options)`
 
 | Option | Description |
@@ -938,6 +1128,10 @@ Logical combinators `AND`, `OR`, and `NOT` are supported at any nesting level, i
 | `QuerySelect` | Type helper for reusable query selections. |
 | `QueryResult`, `QueryResultItem` | Query output types. |
 | `AggregateResult`, `AggregateResultItem` | Aggregate output types. |
+| `UpsertOptions`, `UpsertNode`, `UpsertProperties` | Upsert input helper types. |
+| `UpsertResult`, `UpsertResultItem` | Upsert output types. |
+| `DeleteExecutor`, `DeleteResult`, `DeleteResultItem` | Delete helper and output types. |
+| `EdgeCreationContext`, `EdgeCreationCallback`, `EdgeCreationCallbacks`, `EdgeMode` | Edge upsert helper types. |
 | `IndustrialModelClientOptions` | Client configuration options. |
 
 **Cognite Core**

package/dist/cognite-core/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
@@ -796,6 +803,85 @@ ${result.error.issues.map((issue) => `- ${issue.path.map(String).join(".")}: ${i
     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([
@@ -1363,6 +1449,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) {
@@ -1410,6 +1706,7 @@ var ViewMapper = class {
 };
 
 // src/client.ts
+var APPLY_ITEM_LIMIT = 1e3;
 var IndustrialModelClient = class {
   constructor(client, dataModelId, options = {}) {
     const cognite = createCogniteAdapter(client);
@@ -1417,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);
@@ -1430,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);
@@ -1486,6 +1832,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 = {
@@ -1508,6 +1866,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);
+  }
 };
 
 exports.COGNITE_CORE_DATA_MODEL = COGNITE_CORE_DATA_MODEL;