industrial-model 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,7 +1,46 @@
 import { CogniteClient } from '@cognite/sdk';
+import { z } from 'zod';
 
+interface ViewReference {
+    type: "view";
+    space: string;
+    externalId: string;
+    version: string;
+}
+interface ViewPropertyType {
+    type?: string;
+    source?: ViewReference;
+    list?: boolean;
+}
+interface ViewPropertyDefinition {
+    container: unknown;
+    containerPropertyIdentifier: string;
+    type: ViewPropertyType;
+}
+interface ReverseDirectRelationConnection {
+    through: {
+        source: ViewReference;
+        identifier: string;
+    };
+    source: ViewReference;
+    connectionType?: string;
+    targetsList?: boolean;
+}
+interface EdgeConnection {
+    type: unknown;
+    source: ViewReference;
+    direction?: "outwards" | "inwards";
+}
+type ViewDefinitionProperty = ViewPropertyDefinition | ReverseDirectRelationConnection | EdgeConnection;
+interface ViewDefinition {
+    space: string;
+    externalId: string;
+    version: string;
+    properties: Record<string, ViewDefinitionProperty>;
+}
 interface NodeDefinition {
     instanceType: "node";
+    version?: number;
     space: string;
     externalId: string;
     properties?: Record<string, Record<string, Record<string, unknown>>>;
@@ -18,6 +57,9 @@ type DataModelId = NodeId & {
     version: string;
 };
 type SortDirection = "ascending" | "descending";
+interface IndustrialModelClientOptions {
+    validateResults?: boolean;
+}
 type Simplify<T> = {
     [K in keyof T]: T[K];
 } & {};
@@ -61,11 +103,12 @@ interface QueryOptions<TModel, TSelect extends QuerySelect<TModel> | undefined =
     limit?: number;
     cursor?: string | null;
 }
-type QueryResultMetadata = Pick<NodeDefinition, "space" | "externalId" | "createdTime" | "deletedTime" | "lastUpdatedTime">;
+type QueryResultMetadata = Pick<NodeDefinition, "space" | "externalId" | "version" | "createdTime" | "deletedTime" | "lastUpdatedTime">;
 type ResultShapeForKey<TModel, K extends PropertyKey> = K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : K extends RelationKeys<TModel> ? ModelRelations<TModel>[K] : never;
 type ResultEntityForKey<TModel, K extends PropertyKey> = K extends RelationKeys<TModel> ? ModelRelations<TModel>[K] : K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : never;
 type WrapResultValue<TShape, TValue> = [NonNull<TShape>] extends [readonly unknown[]] ? TValue[] : TValue;
-type SelectedValue<TModel, K extends PropertyKey, TValue, TDepth extends QueryDepth> = TValue extends true ? K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : never : TDepth extends 0 ? never : TValue extends object ? WrapResultValue<ResultShapeForKey<TModel, K>, QueryResultItem<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, TValue & QuerySelect<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, PrevDepth[TDepth]>, PrevDepth[TDepth]>> : never;
+type AsQuerySelect<TModel, TSelect> = TSelect extends QuerySelect<TModel> ? TSelect : never;
+type SelectedValue<TModel, K extends PropertyKey, TValue, TDepth extends QueryDepth> = TValue extends true ? K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : never : TDepth extends 0 ? never : TValue extends object ? WrapResultValue<ResultShapeForKey<TModel, K>, QueryResultItem<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, AsQuerySelect<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, TValue>, PrevDepth[TDepth]>> : never;
 type ExplicitSelectionResult<TModel, TSelect, TDepth extends QueryDepth> = Simplify<{
     [K in keyof NonNull<TSelect> as K extends "_all" ? never : SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth> extends never ? never : IsOptionalKey<ModelProps<TModel>, K> extends true ? never : IsOptionalKey<ModelRelations<TModel>, K> extends true ? never : K]-?: SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth>;
 } & {
@@ -78,6 +121,14 @@ interface QueryResult<TItem = Record<string, unknown>> {
     items: TItem[];
     cursor: string | null;
 }
+type QueryExecutor<TModel> = {
+    <const TSelect extends QuerySelect<TModel>>(options: Omit<QueryOptions<TModel, TSelect>, "select"> & {
+        select: TSelect & QuerySelect<TModel>;
+    }): Promise<QueryResult<QueryResultItem<TModel, TSelect>>>;
+    (options: Omit<QueryOptions<TModel, undefined>, "select"> & {
+        select?: undefined;
+    }): Promise<QueryResult<QueryResultItem<TModel, undefined>>>;
+};
 type StringFilters = {
     eq?: string;
     in?: string[];
@@ -131,10 +182,21 @@ declare class IndustrialModelClient {
     private readonly cognite;
     private readonly queryMapper;
     private readonly resultMapper;
-    constructor(client: CogniteClient, dataModelId: DataModelId);
-    query<TModel>(): <const TSelect extends QuerySelect<TModel> | undefined = undefined>(options: QueryOptions<TModel, TSelect>) => Promise<QueryResult<QueryResultItem<TModel, TSelect>>>;
+    private readonly resultValidator;
+    private readonly validateResults;
+    constructor(client: CogniteClient, dataModelId: DataModelId, options?: IndustrialModelClientOptions);
+    query<TModel>(): QueryExecutor<TModel>;
     private queryInternal;
     private queryDependenciesPages;
 }
 
-export { type DataModelId, type IndustrialModel, IndustrialModelClient, type ModelProps, type ModelRelations, type NodeId, type QueryOptions, type QueryResult, type QueryResultItem, type QueryResultMetadata, type QuerySelect };
+interface BuildViewSchemaOptions {
+    dateMode?: "preserve" | "coerce";
+}
+declare const nodeIdSchema: z.ZodObject<{
+    space: z.ZodString;
+    externalId: z.ZodString;
+}, z.core.$strip>;
+declare function buildViewSchema(view: ViewDefinition, options?: BuildViewSchemaOptions): z.ZodObject<Record<string, z.ZodType>>;
+
+export { type BuildViewSchemaOptions, type DataModelId, type IndustrialModel, IndustrialModelClient, type IndustrialModelClientOptions, type ModelProps, type ModelRelations, type NodeId, type QueryOptions, type QueryResult, type QueryResultItem, type QueryResultMetadata, type QuerySelect, buildViewSchema, nodeIdSchema };

package/dist/index.js

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 // src/cognite/adapter.ts
 function createCogniteAdapter(client) {
   return new CogniteSdkAdapter(client);
@@ -202,6 +204,345 @@ var FilterMapper = class {
     return value;
   }
 };
+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;
+}
+function buildViewSchema(view, options = {}) {
+  const shape = {};
+  for (const [name, property] of Object.entries(view.properties)) {
+    if (isViewPropertyDefinition(property)) {
+      shape[name] = propertyValueSchema(property, options).optional();
+    }
+  }
+  return z.object(shape).strict();
+}
+
+// src/mappers/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",
+  "containsAny",
+  "containsAll"
+]);
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isLeafFilter2(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) {
+    return z.object({
+      containsAny: z.array(value).optional(),
+      containsAll: z.array(value).optional(),
+      exists: z.boolean().optional()
+    }).strict();
+  }
+  if (property === "node-string" || typeof property !== "string" && property.type.type === "text") {
+    return z.object({
+      eq: z.string().optional(),
+      in: z.array(z.string()).optional(),
+      prefix: z.string().optional(),
+      exists: z.boolean().optional()
+    }).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.validateFilters(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;
+      }
+      const targetView = await this.viewMapper.getView(target);
+      errors.push(...await this.validateSelect(value, targetView, [...path, name]));
+    }
+    return errors;
+  }
+  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 && !isLeafFilter2(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/mappers/sort-mapper.ts
 var SortMapper = class {
@@ -227,6 +568,7 @@ var QueryMapper = class {
     this.viewMapper = viewMapper;
     this.filterMapper = new FilterMapper(viewMapper);
     this.sortMapper = new SortMapper();
+    this.validator = new QueryValidator(viewMapper);
   }
   async map(options) {
     const {
@@ -239,6 +581,7 @@ var QueryMapper = class {
     } = 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];
@@ -529,6 +872,92 @@ var QueryResultMapper = class {
     return entry;
   }
 };
+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();
+  }
+};
 
 // src/mappers/view-mapper.ts
 var ViewMapper = class {
@@ -679,15 +1108,18 @@ function buildDependenciesQuery(previousQuery, nodesParent, nodesChildren, leafC
 
 // src/client.ts
 var IndustrialModelClient = class {
-  constructor(client, dataModelId) {
+  constructor(client, dataModelId, options = {}) {
     const cognite = createCogniteAdapter(client);
     this.cognite = cognite;
     const viewMapper = new ViewMapper(cognite, dataModelId);
     this.queryMapper = new QueryMapper(viewMapper);
     this.resultMapper = new QueryResultMapper(viewMapper);
+    this.resultValidator = new QueryResultValidator(viewMapper);
+    this.validateResults = options.validateResults ?? false;
   }
   query() {
-    return (options) => this.queryInternal(options);
+    const execute = (options) => this.queryInternal(options);
+    return execute;
   }
   async queryInternal(options) {
     const { viewExternalId, limit = DEFAULT_LIMIT } = options;
@@ -705,7 +1137,8 @@ var IndustrialModelClient = class {
         mapNodesAndEdges(queryResult),
         dependenciesData
       );
-      const pageResult = await this.resultMapper.mapNodes(viewExternalId, queryResultData);
+      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;
@@ -736,6 +1169,6 @@ var IndustrialModelClient = class {
   }
 };
 
-export { IndustrialModelClient };
+export { IndustrialModelClient, buildViewSchema, nodeIdSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map