CAM Assets Subgraph Reference

The su-cam-assets subgraph provides Connected Asset Management (CAM) capabilities for managing asset types, asset properties, and asset hierarchy in connected operations.

Subgraph Information

Name: su-cam-assets
Routing URL: https://mijlot8lad.execute-api.us-west-2.amazonaws.com/poc/graphql
Last Updated: 2025-11-03
SDL: View Schema

Overview

CAM Assets manages the foundational structure for connected operations:

Asset Types: Define schemas for different kinds of operational assets
Asset Properties: Custom attributes and their data types
Asset Hierarchy: Parent-child relationships between assets
Camera Assets: Specialized operations for camera and detection assets
Batch Operations: Large-scale asset creation and updates
Geospatial: Full GeoJSON support for asset locations

Key Concepts

Asset Types

Asset types define the structure and schema for operational assets:

Properties: Custom attributes (name, data type, required, default value)
Extensions: External data source integrations
Status Tracking: Configuration for asset state management
Hierarchy Rules: Parent-child relationship constraints

Assets

Assets are instances of asset types representing operational entities:

Sites: Top-level geographic locations
Equipment: Major operational assets
Components: Sub-components within equipment
Wells: Oil and gas well assets
Pipelines: Pipeline infrastructure

Asset Hierarchy

Assets can be organized in parent-child relationships:

Multi-level organizational structures
Inherited properties and configurations
Hierarchical queries and filtering
Geographic nesting (e.g., equipment within sites)

Core Types

CamAssets

Main entry point for querying assets:

type CamAssets {
  byId(id: ID!): CamAsset
  all(
    first: Int
    after: String
    filter: CamAssetFilter
    fullTextSearch: CamAssetFullTextSearch
    sortBy: CamAssetSortBy
    withExtensions: [ID]
    includeDelta: Boolean
  ): CamAssetsConnection
}

CamAsset

Individual asset instance:

type CamAsset {
  id: ID!
  name: String!
  description: String
  assetTypeId: ID!
  active: Boolean!
  geometry: GeoJSONGeometry
  properties: JSONObject
  parent: CamAssetReference
  children: [CamAssetReference]
  status: CamAssetStatus
  extensionData: [CamAssetExtensionData]
  audit: AuditInfo
}

AssetTypes

Manage asset type definitions:

type AssetTypes {
  byId(assetTypeId: ID!): AssetType
  all(
    first: Int
    after: String
    filter: AssetTypeFilter
    sortBy: AssetTypeSortBy
  ): AssetTypesConnection
}

AssetType

Asset type definition:

type AssetType {
  assetTypeId: ID!
  name: String!
  description: String
  properties: [AssetTypeProperty!]
  extensions: [AssetTypeExtension!]
  parentAssetTypes: [ID!]
  childAssetTypes: [ID!]
  audit: AuditInfo
}

AssetTypeProperty

Property definition within an asset type:

type AssetTypeProperty {
  id: ID!
  name: String!
  dataType: PropertyDataType!
  required: Boolean!
  defaultValue: String
  validation: PropertyValidation
  displayOrder: Int
}

Query Operations

camAssets

Query assets by type:

query GetAssetsByType($assetTypeId: ID!) {
  camAssets(assetTypeId: $assetTypeId) {
    all(first: 20) {
      edges {
        node {
          id
          name
          assetTypeId
          properties
          geometry {
            type
            coordinates
          }
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
}

assetTypes

Query available asset types:

query GetAssetTypes {
  assetTypes {
    all(first: 100) {
      edges {
        node {
          assetTypeId
          name
          description
          properties {
            id
            name
            dataType
            required
          }
        }
      }
    }
  }
}

camAssetReferences

Lightweight asset references for dropdowns:

query GetAssetReferences {
  camAssetReferences {
    all(first: 100) {
      edges {
        node {
          id
          name
          assetTypeId
        }
      }
    }
  }
}

camEngine

Query CAM engine configuration and datasets:

query GetCamEngine {
  camEngine {
    datasets {
      id
      name
      assetTypeId
      sourceType
      lastUpdated
    }
    configuration {
      key
      value
    }
  }
}

camAssetsDatasets

Get datasets for a specific tenant:

query GetDatasets($group: ID!) {
  camAssetsDatasets(group: $group) {
    dataset
    displayName
    assetTypeId
    recordCount
  }
}

assetConfigs

Query tenant-specific configurations:

query GetConfigs($group: ID!) {
  assetConfigs(group: $group) {
    all {
      id
      value
      updatedAt
    }
  }
}

generateBatchUpsertUploadUrl

Generate presigned S3 URL for batch operations:

query GenerateUploadUrl($input: GenerateBatchUpsertUploadUrlInput!) {
  generateBatchUpsertUploadUrl(input: $input) {
    uploadUrl
    batchUpsertReference
    expiresAt
  }
}

camCatalog

Query catalog configuration for a group:

query GetCatalog($group: ID!) {
  camCatalog(group: $group) {
    catalogId
    assetTypes {
      assetTypeId
      name
    }
  }
}

assetAuditing

Access audit trail information:

query GetAssetAudit {
  assetAuditing {
    history(assetId: "asset-123") {
      version
      eventType
      eventTime
      updatedBy
    }
  }
}

Mutation Operations

createAsset

Create a new asset:

mutation CreateAsset($input: CreateAssetInput!, $correlationId: ID) {
  createAsset(input: $input, correlationId: $correlationId) {
    asset {
      id
      name
      assetTypeId
    }
    correlationId
    errors {
      message
      type
    }
  }
}

updateAsset

Update an existing asset:

mutation UpdateAsset($input: UpdateAssetInput!, $correlationId: ID) {
  updateAsset(input: $input, correlationId: $correlationId) {
    asset {
      id
      name
      properties
    }
    correlationId
    errors {
      message
      type
    }
  }
}

updateAssetProperty

Update specific asset properties:

mutation UpdateAssetProperty($input: UpdateAssetPropertyInput!, $correlationId: ID) {
  updateAssetProperty(input: $input, correlationId: $correlationId) {
    asset {
      id
      properties
    }
    correlationId
    errors {
      message
      type
    }
  }
}

updateAssetGeometry

Update asset geolocation:

mutation UpdateAssetGeometry($input: UpdateAssetGeometryInput!, $correlationId: ID) {
  updateAssetGeometry(input: $input, correlationId: $correlationId) {
    asset {
      id
      geometry {
        type
        coordinates
      }
    }
    correlationId
    errors {
      message
      type
    }
  }
}

createAssetStatus

Create asset status record:

mutation CreateAssetStatus($input: CreateAssetStatusInput!, $correlationId: ID) {
  createAssetStatus(input: $input, correlationId: $correlationId) {
    assetStatus {
      assetId
      statusId
      label
      setAt
      setBy
    }
    correlationId
    errors {
      message
      type
    }
  }
}

manageCamAssets

Batch operations for assets:

mutation ManageAssets {
  manageCamAssets(dryRun: false) {
    batchUpsert(batchUpsertReference: "ref-from-upload") {
      success
      processedCount
      errors {
        row
        message
      }
    }
  }
}

setAssetConfig

Update tenant configuration:

mutation SetConfig($group: ID!, $id: ID!, $value: JSONObject!) {
  setAssetConfig(group: $group, id: $id, value: $value) {
    config {
      id
      value
    }
    correlationId
    errors {
      message
      type
    }
  }
}

reloadCamAssetsDatasets

Reload datasets from external sources:

mutation ReloadDatasets($group: ID!) {
  reloadCamAssetsDatasets(group: $group) {
    dataset
    displayName
    recordCount
  }
}

updateAssetStatus

Update asset status:

mutation UpdateAssetStatus($input: UpdateAssetStatusInput!, $correlationId: ID) {
  updateAssetStatus(input: $input, correlationId: $correlationId) {
    asset {
      id
      status {
        statusId
        label
      }
    }
  }
}

deleteAssetStatus

Delete asset status record:

mutation DeleteAssetStatus($input: DeleteAssetStatusInput!, $correlationId: ID) {
  deleteAssetStatus(input: $input, correlationId: $correlationId) {
    asset {
      id
    }
  }
}

deleteAsset

Delete an asset:

mutation DeleteAsset($input: DeleteAssetInput!, $correlationId: ID) {
  deleteAsset(input: $input, correlationId: $correlationId) {
    correlationId
  }
}

createAssetType

Create a new asset type:

mutation CreateAssetType($input: CreateAssetTypeInput!) {
  createAssetType(input: $input) {
    assetType {
      assetTypeId
      name
    }
  }
}

updateAssetType

Update an asset type:

mutation UpdateAssetType($input: UpdateAssetTypeInput!) {
  updateAssetType(input: $input) {
    assetType {
      assetTypeId
      name
    }
  }
}

activateAssetType

Activate an asset type:

mutation ActivateAssetType($input: ActivateAssetTypeInput!) {
  activateAssetType(input: $input) {
    assetType {
      assetTypeId
      active
    }
  }
}

deleteAssetType

Delete an asset type:

mutation DeleteAssetType($input: DeleteAssetTypeInput!) {
  deleteAssetType(input: $input) {
    correlationId
  }
}

flushCamStreamDatasetDelta

Flush streaming dataset delta:

mutation FlushDatasetDelta($streamDatasetId: ID!) {
  flushCamStreamDatasetDelta(streamDatasetId: $streamDatasetId)
}

deleteAssetConfig

Delete asset configuration:

mutation DeleteAssetConfig($group: ID!, $id: ID!) {
  deleteAssetConfig(group: $group, id: $id) {
    correlationId
  }
}

Deprecated Operations

The following legacy operations are deprecated in favor of the unified camAssets query:

assetSites → Use camAssets(assetTypeId: "site")
assetEquipments → Use camAssets(assetTypeId: "equipment")
assetComponents → Use camAssets(assetTypeId: "component")
assetWells → Use camAssets(assetTypeId: "well")
assetPipelines → Use camAssets(assetTypeId: "pipeline")
assetUnattributeds → Use camAssets without assetTypeId filter

Filtering and Sorting

CamAssetFilter

Filter assets by various criteria:

input CamAssetFilter {
  active: Boolean
  assetTypeIds: [ID!]
  parentId: ID
  geometry: GeoJSONGeometryFilter
  properties: JSONObject
  extensionIds: [ID!]
}

CamAssetFullTextSearch

Search assets by text:

input CamAssetFullTextSearch {
  text: String!
  fields: [String!]  # Search specific fields
}

CamAssetSortBy

Sort asset results:

input CamAssetSortBy {
  field: CamAssetSortField!
  direction: SortDirection!
}

enum CamAssetSortField {
  NAME
  CREATED_AT
  UPDATED_AT
  ASSET_TYPE_ID
}

GeoJSON Support

Full GeoJSON geometry types supported:

union GeoJSONGeometry =
  | GeoJSONPoint
  | GeoJSONLineString
  | GeoJSONPolygon
  | GeoJSONMultiPoint
  | GeoJSONMultiLineString
  | GeoJSONMultiPolygon
  | GeoJSONGeometryCollection

Example Geometries

Point:

{
  "type": "Point",
  "coordinates": [-114.0719, 51.0447]
}

Polygon:

{
  "type": "Polygon",
  "coordinates": [[
    [-114.073, 51.045],
    [-114.071, 51.045],
    [-114.071, 51.044],
    [-114.073, 51.044],
    [-114.073, 51.045]
  ]]
}

Audit Information

All assets include audit metadata:

type AuditInfo {
  createdAt: DateTime!
  createdBy: UserReference
  updatedAt: DateTime
  updatedBy: UserReference
  version: Int
}

Error Handling

Mutations return standardized error types:

type AssetMutationResult {
  asset: CamAsset
  correlationId: ID
  errors: [AssetMutationError!]
}

type AssetMutationError implements MutationError {
  message: String!
  type: String!
}

Common error types:

DUPLICATE_ID: Asset ID already exists
INVALID_PARENT: Parent asset not found or invalid type
INVALID_PROPERTY: Property validation failed
INVALID_GEOMETRY: GeoJSON geometry is malformed
MISSING_REQUIRED: Required field not provided
INVALID_ASSET_TYPE: Asset type does not exist

Extension System

Assets can integrate with external data sources through extensions:

type AssetTypeExtension {
  id: ID!
  name: String!
  sourceType: ExtensionSourceType!
  connectionDetails: AssetTypeExtensionConnectionDetails
  stateSyncProperties: [AssetTypeExtensionStateSyncProperty!]
  statusProperties: [AssetTypeExtensionStatusProperty!]
}

enum ExtensionSourceType {
  DATABASE
  API
  FILE
  STREAM
}

Batch Operations

Upload Flow

Generate presigned S3 upload URL
Upload CSV/JSONL file to S3
Trigger batch upsert with reference
Monitor processing status

File Formats

CSV:

id,name,assetTypeId,properties.operator,geometry.coordinates
site-001,Station A,site,ACME Energy,"[-114.0719,51.0447]"

JSONL:

{"id":"site-001","name":"Station A","assetTypeId":"site","properties":{"operator":"ACME Energy"},"geometry":{"type":"Point","coordinates":[-114.0719,51.0447]}}

CAM Assets Guide - Comprehensive usage guide
Common Patterns - Pagination and filtering
Full SDL Schema - Complete type definitions
Core Platform Guide - Maps and geospatial services

GraphQL APIs

MCP Tools

Documentation Index

​CAM Assets Subgraph Reference

​Subgraph Information

​Overview

​Key Concepts

​Asset Types

​Assets

​Asset Hierarchy

​Core Types

​CamAssets

​CamAsset

​AssetTypes

​AssetType

​AssetTypeProperty

​Query Operations

​camAssets

​assetTypes

​camAssetReferences

​camEngine

​camAssetsDatasets

​assetConfigs

​generateBatchUpsertUploadUrl

​camCatalog

​assetAuditing

​Mutation Operations

​createAsset

​updateAsset

​updateAssetProperty

​updateAssetGeometry

​createAssetStatus

​manageCamAssets

​setAssetConfig

​reloadCamAssetsDatasets

​updateAssetStatus

​deleteAssetStatus

​deleteAsset

​createAssetType

​updateAssetType

​activateAssetType

​deleteAssetType

​flushCamStreamDatasetDelta

​deleteAssetConfig

​Deprecated Operations

​Filtering and Sorting

​CamAssetFilter

​CamAssetFullTextSearch

​CamAssetSortBy

​GeoJSON Support

​Example Geometries

​Audit Information

​Error Handling

​Extension System

​Batch Operations

​Upload Flow

​File Formats

​Related Resources