industrial-model 0.5.0 → 0.7.0

package/dist/cognite-core/index.js

@@ -0,0 +1,1879 @@
+import { z } from 'zod';
+
+// 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
+    };
+  }
+  async searchInstances(request) {
+    const search = this.client.instances.search;
+    const response = await search(request);
+    return {
+      items: response.items
+    };
+  }
+  async aggregateInstances(request) {
+    const response = await this.client.instances.aggregate(
+      request
+    );
+    return {
+      items: response.items
+    };
+  }
+  async applyInstances(request) {
+    const apply = this.client.instances.apply;
+    const response = await apply(request);
+    return {
+      items: response.items
+    };
+  }
+};
+
+// src/constants.ts
+var NESTED_SEP = "|";
+var EDGE_MARKER = "<EdgeMarker>";
+var MAX_LIMIT = 1e4;
+var DEFAULT_LIMIT = 1e3;
+var MAX_DEPENDENCY_DEPTH = 3;
+var AGGREGATE_LIMIT = 1e3;
+var MAX_GROUP_BY = 5;
+
+// 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",
+  "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 }] };
+}
+var GROUPABLE_PROPERTY_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "direct",
+  "int32",
+  "int64",
+  "float32",
+  "float64",
+  "boolean",
+  "enum"
+]);
+var NUMERIC_PROPERTY_TYPES = /* @__PURE__ */ new Set(["int32", "int64", "float32", "float64"]);
+function isGroupableProperty(property) {
+  if (!isViewPropertyDefinition(property)) return false;
+  if (property.type.list === true) return false;
+  const type = property.type.type;
+  return type != null && GROUPABLE_PROPERTY_TYPES.has(type);
+}
+function isNumericProperty(property) {
+  const type = property.type.type;
+  return type != null && NUMERIC_PROPERTY_TYPES.has(type);
+}
+function getSelectedGroupByKeys(groupBy) {
+  return Object.entries(groupBy).filter((entry) => entry[1] === true).map(([key]) => key);
+}
+var nodeIdSchema = z.object({
+  space: z.string().min(1),
+  externalId: z.string().min(1)
+});
+function dateSchema(dateMode) {
+  if (dateMode === "coerce") {
+    return z.preprocess(
+      (value) => typeof value === "string" || typeof value === "number" ? new Date(value) : value,
+      z.date()
+    );
+  }
+  return z.union([z.string(), z.date()]);
+}
+function propertyValueSchema(property, options = {}) {
+  const type = property.type;
+  let schema;
+  switch (type.type) {
+    case "text":
+    case "enum":
+      schema = z.string();
+      break;
+    case "int32":
+    case "int64":
+      schema = z.number().int();
+      break;
+    case "float32":
+    case "float64":
+      schema = z.number();
+      break;
+    case "boolean":
+      schema = z.boolean();
+      break;
+    case "date":
+    case "timestamp":
+      schema = dateSchema(options.dateMode);
+      break;
+    case "direct":
+      schema = nodeIdSchema;
+      break;
+    case "json":
+      schema = z.unknown();
+      break;
+    default:
+      schema = z.unknown();
+      break;
+  }
+  return type.list === true ? z.array(schema) : schema;
+}
+
+// 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]);
+var SORT_DIRECTION_SCHEMA = z.enum(["ascending", "descending"]);
+var recordSchema = z.record(z.string(), z.unknown());
+var leafOps = /* @__PURE__ */ new Set([
+  "eq",
+  "in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "prefix",
+  "search",
+  "containsAny",
+  "containsAll"
+]);
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isLeafFilter(value) {
+  return Object.keys(value).some((key) => leafOps.has(key));
+}
+function issuePath(path) {
+  return path.length === 0 ? "query" : path.map(String).join(".");
+}
+function formatZodIssues(error, path) {
+  return error.issues.map((issue) => `${issuePath([...path, ...issue.path])}: ${issue.message}`);
+}
+function getRelationTarget(property) {
+  if (isViewPropertyDefinition(property)) {
+    return getDirectRelationSource(property)?.externalId ?? null;
+  }
+  if (isReverseDirectRelation(property) || isEdgeConnection(property)) {
+    return property.source.externalId;
+  }
+  return null;
+}
+function baseValueSchema(property) {
+  if (property === "node-string") return z.string();
+  if (property === "node-number") return z.number();
+  switch (property.type.type) {
+    case "text":
+    case "enum":
+      return z.string();
+    case "int32":
+    case "int64":
+      return z.number().int();
+    case "float32":
+    case "float64":
+      return z.number();
+    case "boolean":
+      return z.boolean();
+    case "date":
+    case "timestamp":
+      return z.union([z.string(), z.date()]);
+    case "direct":
+      return nodeIdSchema;
+    default:
+      return z.union([z.string(), z.number(), z.boolean()]);
+  }
+}
+function leafFilterSchema(property) {
+  const value = baseValueSchema(property);
+  const isList = typeof property !== "string" && property.type.list === true;
+  if (isList) {
+    const shape = {
+      containsAny: z.array(value).optional(),
+      containsAll: z.array(value).optional(),
+      exists: z.boolean().optional()
+    };
+    if (property.type.type === "text") {
+      shape.search = z.object({
+        query: z.string(),
+        operator: z.enum(["OR", "AND"]).optional()
+      }).strict().optional();
+    }
+    return z.object(shape).strict();
+  }
+  if (property === "node-string" || typeof property !== "string" && property.type.type === "text") {
+    const shape = {
+      eq: z.string().optional(),
+      in: z.array(z.string()).optional(),
+      prefix: z.string().optional(),
+      exists: z.boolean().optional()
+    };
+    if (property !== "node-string") {
+      shape.search = z.object({
+        query: z.string(),
+        operator: z.enum(["OR", "AND"]).optional()
+      }).strict().optional();
+    }
+    return z.object(shape).strict();
+  }
+  if (typeof property !== "string" && property.type.type === "enum") {
+    return z.object({
+      eq: z.string().optional(),
+      in: z.array(z.string()).optional(),
+      prefix: z.string().optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  if (property === "node-number" || typeof property !== "string" && ["int32", "int64", "float32", "float64"].includes(property.type.type ?? "")) {
+    return z.object({
+      eq: value.optional(),
+      in: z.array(value).optional(),
+      gt: value.optional(),
+      gte: value.optional(),
+      lt: value.optional(),
+      lte: value.optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  if (typeof property !== "string" && ["date", "timestamp"].includes(property.type.type ?? "")) {
+    return z.object({
+      eq: value.optional(),
+      in: z.array(value).optional(),
+      gt: value.optional(),
+      gte: value.optional(),
+      lt: value.optional(),
+      lte: value.optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  if (typeof property !== "string" && property.type.type === "boolean") {
+    return z.object({
+      eq: z.boolean().optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  if (typeof property !== "string" && property.type.type === "direct") {
+    return z.object({
+      eq: nodeIdSchema.optional(),
+      in: z.array(nodeIdSchema).optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  return z.object({
+    eq: value.optional(),
+    in: z.array(value).optional(),
+    exists: z.boolean().optional()
+  }).strict();
+}
+var QueryValidator = class {
+  constructor(viewMapper) {
+    this.viewMapper = viewMapper;
+  }
+  async validate(options, rootView) {
+    const errors = [];
+    errors.push(...this.validateOptionsShape(options, rootView));
+    if (options.select !== void 0) {
+      errors.push(...await this.validateSelect(options.select, rootView, ["select"]));
+    }
+    if (options.filters !== void 0) {
+      errors.push(...await this.validateWhereInput(options.filters, rootView, ["filters"]));
+    }
+    if (options.sort !== void 0) {
+      errors.push(...this.validateSort(options.sort, rootView, ["sort"]));
+    }
+    if (errors.length > 0) {
+      throw new Error(`Invalid query options:
+${errors.map((error) => `- ${error}`).join("\n")}`);
+    }
+  }
+  validateOptionsShape(options, rootView) {
+    const schema = z.object({
+      viewExternalId: z.literal(rootView.externalId),
+      select: z.unknown().optional(),
+      filters: z.unknown().optional(),
+      sort: z.unknown().optional(),
+      limit: z.union([z.literal(-1), z.number().int().positive().max(MAX_LIMIT)]).optional(),
+      cursor: z.string().nullable().optional()
+    }).strict();
+    const result = schema.safeParse(options);
+    return result.success ? [] : formatZodIssues(result.error, []);
+  }
+  async validateSelect(select, view, path) {
+    const shape = {
+      _all: z.literal(true).optional()
+    };
+    for (const property of NODE_PROPERTIES2) {
+      shape[property] = z.boolean().optional();
+    }
+    for (const [name, property] of Object.entries(view.properties)) {
+      const target = getRelationTarget(property);
+      if (target != null) {
+        const nestedSelect = recordSchema;
+        shape[name] = isViewPropertyDefinition(property) ? z.union([z.boolean(), nestedSelect]).optional() : nestedSelect.optional();
+      } else {
+        shape[name] = z.boolean().optional();
+      }
+    }
+    const result = z.object(shape).strict().safeParse(select);
+    if (!result.success) return formatZodIssues(result.error, path);
+    if (!isRecord(select)) return [];
+    const errors = [];
+    for (const [name, value] of Object.entries(select)) {
+      if (name === "_all" || value == null || typeof value !== "object" || Array.isArray(value)) {
+        continue;
+      }
+      const property = view.properties[name];
+      if (!property) continue;
+      const target = getRelationTarget(property);
+      if (target == null) {
+        errors.push(
+          `${issuePath([...path, name])}: property "${name}" does not support nested select`
+        );
+        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]));
+    }
+    return errors;
+  }
+  async validateWhereInput(filters, view, path) {
+    return this.validateFilters(filters, view, path);
+  }
+  async validateFilters(filters, view, path) {
+    const shape = {
+      AND: z.union([recordSchema, z.array(recordSchema)]).optional(),
+      OR: z.array(recordSchema).optional(),
+      NOT: z.union([recordSchema, z.array(recordSchema)]).optional()
+    };
+    for (const property of NODE_STRING_PROPERTIES) {
+      shape[property] = z.unknown().optional();
+    }
+    for (const property of NODE_NUMBER_PROPERTIES) {
+      shape[property] = z.unknown().optional();
+    }
+    for (const property of Object.keys(view.properties)) {
+      shape[property] = z.unknown().optional();
+    }
+    const result = z.object(shape).strict().safeParse(filters);
+    if (!result.success) return formatZodIssues(result.error, path);
+    if (!isRecord(filters)) return [];
+    const errors = [];
+    for (const [name, value] of Object.entries(filters)) {
+      if (value == null) continue;
+      if (name === "AND" || name === "OR" || name === "NOT") {
+        const clauses = Array.isArray(value) ? value : [value];
+        for (const [index, clause] of clauses.entries()) {
+          errors.push(...await this.validateFilters(clause, view, [...path, name, index]));
+        }
+        continue;
+      }
+      if (!isRecord(value)) {
+        errors.push(`${issuePath([...path, name])}: Expected object`);
+        continue;
+      }
+      const nodePropertyType = NODE_STRING_PROPERTIES.includes(
+        name
+      ) ? "node-string" : NODE_NUMBER_PROPERTIES.includes(name) ? "node-number" : null;
+      if (nodePropertyType != null) {
+        errors.push(...this.validateLeafFilter(value, nodePropertyType, [...path, name]));
+        continue;
+      }
+      const property = view.properties[name];
+      if (!property) continue;
+      if (isViewPropertyDefinition(property)) {
+        const target2 = getDirectRelationSource(property);
+        if (target2 != null && !isLeafFilter(value)) {
+          const targetView = await this.viewMapper.getView(target2.externalId);
+          errors.push(...await this.validateFilters(value, targetView, [...path, name]));
+        } else {
+          errors.push(...this.validateLeafFilter(value, property, [...path, name]));
+        }
+        continue;
+      }
+      const target = getRelationTarget(property);
+      if (target == null) {
+        errors.push(`${issuePath([...path, name])}: property "${name}" does not support filters`);
+        continue;
+      }
+      errors.push(
+        `${issuePath([...path, name])}: filtering through "${name}" is not supported by the query mapper`
+      );
+    }
+    return errors;
+  }
+  validateLeafFilter(value, property, path) {
+    const result = leafFilterSchema(property).safeParse(value);
+    return result.success ? [] : formatZodIssues(result.error, path);
+  }
+  validateSort(sort, view, path) {
+    const shape = {};
+    for (const property of NODE_PROPERTIES2) {
+      shape[property] = SORT_DIRECTION_SCHEMA.optional();
+    }
+    for (const [name, property] of Object.entries(view.properties)) {
+      if (isViewPropertyDefinition(property) && property.type.list !== true) {
+        shape[name] = SORT_DIRECTION_SCHEMA.optional();
+      }
+    }
+    const result = z.object(shape).strict().safeParse(sort);
+    return result.success ? [] : formatZodIssues(result.error, path);
+  }
+};
+
+// 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(".");
+}
+function formatZodIssues2(error, path) {
+  return error.issues.map((issue) => `${issuePath2([...path, ...issue.path])}: ${issue.message}`);
+}
+function isEmptyObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+var AggregateValidator = class {
+  constructor(viewMapper) {
+    this.queryValidator = new QueryValidator(viewMapper);
+  }
+  async validate(options, rootView) {
+    const errors = [];
+    errors.push(...this.validateOptionsShape(options, rootView));
+    const selectedGroupBy = options.groupBy ? getSelectedGroupByKeys(options.groupBy) : [];
+    if (selectedGroupBy.length === 0 && options.aggregate === void 0) {
+      errors.push("aggregate: either groupBy or aggregate must be provided");
+    }
+    if (options.filters !== void 0) {
+      errors.push(
+        ...await this.queryValidator.validateWhereInput(options.filters, rootView, ["filters"])
+      );
+    }
+    if (options.groupBy !== void 0) {
+      errors.push(...this.validateGroupBy(options.groupBy, rootView, ["groupBy"]));
+    }
+    if (options.aggregate !== void 0) {
+      errors.push(
+        ...this.validateAggregate(
+          options.aggregate,
+          rootView,
+          ["aggregate"]
+        )
+      );
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Invalid aggregate options:
+${errors.map((error) => `- ${error}`).join("\n")}`
+      );
+    }
+  }
+  validateOptionsShape(options, rootView) {
+    const schema = z.object({
+      viewExternalId: z.literal(rootView.externalId),
+      filters: z.unknown().optional(),
+      groupBy: z.unknown().optional(),
+      aggregate: z.unknown().optional()
+    }).strict();
+    const result = schema.safeParse(options);
+    return result.success ? [] : formatZodIssues2(result.error, []);
+  }
+  validateGroupBy(groupBy, view, path) {
+    const shape = {};
+    for (const [name, property] of Object.entries(view.properties)) {
+      if (isGroupableProperty(property)) {
+        shape[name] = z.literal(true).optional();
+      }
+    }
+    const result = z.object(shape).strict().safeParse(groupBy);
+    if (!result.success) {
+      return formatZodIssues2(result.error, path);
+    }
+    const selected = getSelectedGroupByKeys(groupBy);
+    const errors = [];
+    if (selected.length === 0) {
+      errors.push(`${issuePath2(path)}: at least one property must be set to true`);
+    }
+    if (selected.length > MAX_GROUP_BY) {
+      errors.push(`${issuePath2(path)}: at most ${MAX_GROUP_BY} properties can be grouped`);
+    }
+    for (const name of selected) {
+      const property = view.properties[name];
+      if (!property || !isGroupableProperty(property)) {
+        errors.push(`${issuePath2([...path, name])}: property "${name}" cannot be used in groupBy`);
+      }
+    }
+    return errors;
+  }
+  validateAggregate(aggregate, view, path) {
+    if ("count" in aggregate) {
+      const property2 = aggregate.count;
+      if (isEmptyObject(property2)) {
+        return [];
+      }
+      if (typeof property2 === "string") {
+        if (NODE_COUNT_PROPERTIES.has(property2)) {
+          return [];
+        }
+        const viewProperty = view.properties[property2];
+        if (!viewProperty || !isGroupableProperty(viewProperty)) {
+          return [`${issuePath2([...path, "count"])}: property "${property2}" cannot be counted`];
+        }
+        return [];
+      }
+      return [`${issuePath2([...path, "count"])}: invalid count property`];
+    }
+    let propertyName;
+    let numericOp = null;
+    if ("avg" in aggregate) {
+      numericOp = "avg";
+      propertyName = aggregate.avg;
+    } else if ("min" in aggregate) {
+      numericOp = "min";
+      propertyName = aggregate.min;
+    } else if ("max" in aggregate) {
+      numericOp = "max";
+      propertyName = aggregate.max;
+    } else if ("sum" in aggregate) {
+      numericOp = "sum";
+      propertyName = aggregate.sum;
+    }
+    if (numericOp == null) {
+      return [`${issuePath2(path)}: unknown aggregate operation`];
+    }
+    if (typeof propertyName !== "string") {
+      return [`${issuePath2(path)}: aggregate property must be a string`];
+    }
+    const property = view.properties[propertyName];
+    if (!property || !isViewPropertyDefinition(property) || !isNumericProperty(property)) {
+      return [
+        `${issuePath2([...path, numericOp])}: property "${propertyName}" must be a numeric view property`
+      ];
+    }
+    if (getDirectRelationSource(property) != null) {
+      return [
+        `${issuePath2([...path, numericOp])}: property "${propertyName}" is a relation and cannot be aggregated`
+      ];
+    }
+    return [];
+  }
+};
+var nodeMetadataSchema = {
+  instanceType: z.literal("node").optional(),
+  space: z.string(),
+  externalId: z.string(),
+  version: z.number().optional(),
+  createdTime: z.number().optional(),
+  deletedTime: z.number().optional(),
+  lastUpdatedTime: z.number().optional(),
+  _edges: z.record(z.string(), 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 = 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 = 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" }) : 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 ? z.array(nestedSchema) : nestedSchema;
+      return z.union([nestedRelationSchema, fallbackSchema]).optional();
+    }
+    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([
+  "eq",
+  "in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "prefix",
+  "containsAny",
+  "containsAll"
+]);
+function isLeafFilter2(value) {
+  return Object.keys(value).some((k) => LEAF_OPS.has(k));
+}
+var FilterMapper = class {
+  constructor(viewMapper, cognite) {
+    this.viewMapper = viewMapper;
+    this.cognite = cognite;
+  }
+  async map(input, rootView) {
+    const result = [];
+    const searchQueries = {};
+    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);
+        const hasLeafFilter = isLeafFilter2(filterValue);
+        if (hasLeafFilter) {
+          result.push(...this.leafToFilterDefs(property, filterValue));
+        }
+        if ("search" in filterValue && filterValue.search != null) {
+          searchQueries[key] = filterValue.search;
+        } else if (!hasLeafFilter) {
+          const targetView = await this.getNestedTargetView(key, rootView);
+          const innerFilter = await this.whereInputToSingle(filterValue, targetView);
+          result.push({ nested: { scope: property, filter: innerFilter } });
+        }
+      }
+    }
+    if (Object.keys(searchQueries).length > 0) {
+      const searchFilters = await Promise.all(
+        Object.entries(searchQueries).map(
+          ([key, filterValue]) => this.searchToFilterDef(key, filterValue, rootView)
+        )
+      );
+      result.push(...searchFilters);
+    }
+    return result;
+  }
+  async searchToFilterDef(propertyName, search, rootView) {
+    const response = await this.cognite.searchInstances({
+      view: toViewReference(rootView),
+      query: search.query,
+      instanceType: "node",
+      properties: [propertyName],
+      operator: search.operator ?? "OR",
+      limit: 1e3
+    });
+    const instanceRefs = response.items.map((item) => ({
+      space: item.space,
+      externalId: item.externalId
+    }));
+    return { instanceReferences: instanceRefs };
+  }
+  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/aggregate-mapper.ts
+var AggregateMapper = class {
+  constructor(viewMapper, cognite) {
+    this.viewMapper = viewMapper;
+    this.filterMapper = new FilterMapper(viewMapper, cognite);
+    this.validator = new AggregateValidator(viewMapper);
+  }
+  async map(options) {
+    const { viewExternalId, filters, groupBy, aggregate } = options;
+    const rootView = await this.viewMapper.getView(viewExternalId);
+    await this.validator.validate(options, rootView);
+    const filterParts = filters ? await this.filterMapper.map(filters, rootView) : [];
+    const filter = filterParts.length === 0 ? void 0 : filterParts.length === 1 ? filterParts[0] : { and: filterParts };
+    return {
+      view: toViewReference(rootView),
+      instanceType: "node",
+      limit: AGGREGATE_LIMIT,
+      ...filter !== void 0 ? { filter } : {},
+      ...groupBy ? { groupBy: getSelectedGroupByKeys(groupBy) } : {},
+      ...aggregate ? { aggregates: [mapAggregateDefinition(aggregate)] } : {}
+    };
+  }
+};
+function mapAggregateDefinition(aggregate) {
+  if ("count" in aggregate) {
+    const property = aggregate.count;
+    if (property != null && typeof property === "object" && !Array.isArray(property) && Object.keys(property).length === 0) {
+      return { count: {} };
+    }
+    if (typeof property === "string") {
+      return { count: { property } };
+    }
+    return { count: {} };
+  }
+  if ("avg" in aggregate) {
+    return { avg: { property: aggregate.avg } };
+  }
+  if ("min" in aggregate) {
+    return { min: { property: aggregate.min } };
+  }
+  if ("max" in aggregate) {
+    return { max: { property: aggregate.max } };
+  }
+  if ("sum" in aggregate) {
+    return { sum: { property: aggregate.sum } };
+  }
+  throw new Error("Invalid aggregate definition");
+}
+
+// src/mappers/aggregate-result-mapper.ts
+function isNodeId(value) {
+  return value != null && typeof value === "object" && "space" in value && "externalId" in value && typeof value.space === "string" && typeof value.externalId === "string";
+}
+var AggregateResultMapper = class {
+  map(response, options) {
+    const groupByKeys = options.groupBy ? getSelectedGroupByKeys(options.groupBy) : [];
+    return response.items.map((item) => {
+      let group;
+      if (item.group != null && groupByKeys.length > 0) {
+        group = {};
+        for (const key of groupByKeys) {
+          const value = item.group[key];
+          if (value === void 0) continue;
+          group[key] = isNodeId(value) ? { space: value.space, externalId: value.externalId } : value;
+        }
+        if (Object.keys(group).length === 0) {
+          group = void 0;
+        }
+      }
+      const aggregateValue = item.aggregates[0];
+      const aggregate = aggregateValue?.value !== void 0 ? aggregateValue.property != null ? { property: aggregateValue.property, value: aggregateValue.value } : { value: aggregateValue.value } : void 0;
+      return {
+        ...group !== void 0 ? { group } : {},
+        ...aggregate !== void 0 ? { aggregate } : {}
+      };
+    });
+  }
+};
+
+// src/mappers/sort-mapper.ts
+var SortMapper = class {
+  map(sort, rootView) {
+    return Object.entries(sort).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, cognite) {
+    this.viewMapper = viewMapper;
+    this.filterMapper = new FilterMapper(viewMapper, cognite);
+    this.sortMapper = new SortMapper();
+    this.validator = new QueryValidator(viewMapper);
+  }
+  async map(options) {
+    const {
+      viewExternalId,
+      select = { _all: true },
+      filters,
+      sort = {},
+      limit: requestedLimit = DEFAULT_LIMIT,
+      cursor = null
+    } = options;
+    const limit = requestedLimit === -1 ? DEFAULT_LIMIT : requestedLimit;
+    const rootView = await this.viewMapper.getView(viewExternalId);
+    await this.validator.validate(options, rootView);
+    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(sort, 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/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) {
+    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/client.ts
+var APPLY_ITEM_LIMIT = 1e3;
+var IndustrialModelClient = class {
+  constructor(client, dataModelId, options = {}) {
+    const cognite = createCogniteAdapter(client);
+    this.cognite = cognite;
+    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);
+    this.validateResults = options.validateResults ?? false;
+  }
+  query() {
+    const execute = (options) => this.queryInternal(options);
+    return execute;
+  }
+  aggregate() {
+    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);
+    const items = this.aggregateResultMapper.map(
+      response,
+      options
+    );
+    return { items };
+  }
+  async queryInternal(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 mappedPageResult = await this.resultMapper.mapNodes(viewExternalId, queryResultData);
+      const pageResult = this.validateResults ? await this.resultValidator.parseItems(viewExternalId, mappedPageResult, options.select) : mappedPageResult;
+      const nextCursor = queryResult.nextCursor[viewExternalId] ?? null;
+      const isLastPage = pageResult.length < limit || !nextCursor;
+      const resolvedCursor = isLastPage ? null : nextCursor;
+      data.push(...pageResult);
+      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);
+  }
+};
+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 = {
+  space: "cdf_cdm",
+  externalId: "CogniteCore",
+  version: "v1"
+};
+var CogniteCoreClient = class {
+  constructor(client, options = {}) {
+    this.model = new IndustrialModelClient(client, COGNITE_CORE_DATA_MODEL, options);
+  }
+  query(viewExternalId) {
+    const query = this.model.query();
+    const queryWithView = query;
+    const execute = (options = {}) => queryWithView({ ...options, viewExternalId });
+    return execute;
+  }
+  aggregate(viewExternalId) {
+    const aggregate = this.model.aggregate();
+    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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map