Dune SDK Generator

Generate strongly-typed TypeScript SDKs that unify native CDF APIs and custom Data Modeling types with automatic relationship discovery.

Quick Start

$3

``bash
npx dune-sdk-generator generate
`

That's it! The generator will:
- Automatically call dune-key to get your CDF token (if CDF_TOKEN is not set)
- Prompt you for the project name (defaults to lervik-industries if you press Enter)
- Prompt you for the cluster (defaults to api if you press Enter)
- Launch an interactive UI to browse and select views for SDK generation

$3

`bash


Minimal command - all prompts handled interactively

npx dune-sdk-generator generate

Specify output location and name

npx dune-sdk-generator generate --output ./sdk --name equipment-sdk

Regenerate from saved config

npx dune-sdk-generator generate --config dune.config.json

Override defaults with environment variables

CDF_PROJECT="my-project" CDF_CLUSTER="greenfield" npx dune-sdk-generator generate
`

$3

`bash


1. Search for views

npx dune-sdk-generator search "canvas" --limit 10 > views.json

2. Generate SDK non-interactively (requires environment variables)

CDF_PROJECT="my-project" CDF_TOKEN="..." npx dune-sdk-generator generate \
--views views.json \
--name canvas-sdk \
--output ./sdk \
--non-interactive \
--format json
`

$3

| Variable | Required | Notes |
|----------|----------|-------|
| CDF_PROJECT | ✅* | Required in non-interactive mode. In interactive mode, defaults to lervik-industries if not provided. |
| CDF_TOKEN | ✅* | Required in non-interactive mode. In interactive mode, automatically retrieved via dune-key if not set. |
| CDF_CLUSTER | ⚠️ | Required if CDF_BASE_URL is not set. In interactive mode, defaults to api if not provided. |
| CDF_BASE_URL | Optional | Overrides cluster-based URL construction. |

*Required in non-interactive mode or if running without a TTY (e.g., in CI/CD pipelines).

Features

$3

The generator produces a unified SDK that combines:

- Native CDF APIs with narrower, InstanceId-focused interfaces (timeseries, files, datapoints, events, sequences, annotations, labels)
- Custom Data Modeling types discovered via introspection (Canvas, Equipment, etc.)

All accessible from a single entry point:

`typescript
const sdk = initializeSDK(client);

// Native APIs with narrower interfaces
sdk.timeseries.create([{ space, externalId, name, unit }]);
sdk.files.upload(id, metadata, content);
sdk.datapoints.insert([{ id, datapoints }]);

// Custom DM types
sdk.canvas.create({ space, externalId, properties });
sdk.equipment.list({ filter });
`

Key Benefits:
- Consistent patterns: All APIs use InstanceId instead of mixed id/externalId
- Type safety: Full TypeScript support across native and custom types
- Unified workflows: Seamlessly combine native APIs with Data Modeling
- Focused interfaces: Streamlined API surface removes unused parameters

$3

The CLI is designed for both interactive use and programmatic/agentic workflows:

- search - Search for views by keyword with JSON output
- introspect - Get detailed view definitions
- generate - Generate SDKs interactively or non-interactively
- --format json - Machine-readable output for parsing
- --non-interactive - Skip all prompts for CI/CD and agent contexts

See CLI Reference for details.

$3


Generated SDKs provide fully typed methods for:
- create() - Create new instances
- get() - Retrieve by ID
- update() - Update existing instances
- delete() - Delete instances
- list() - List with pagination and filtering
- query() - Advanced queries with custom filters

$3

The SDK generator automatically discovers reverse relationships in your data model.

#### What are Reverse Relationships?

In data modeling, you often have one-way references:
- CanvasAnnotation has a property canvas: InstanceId pointing to Canvas
- Canvas doesn't explicitly know about CanvasAnnotation
- But semantically, a Canvas "has many" CanvasAnnotations

The SDK generator discovers these implicit relationships and generates helper methods:

`typescript
// Without reverse relationships (manual query)
const annotations = await client.canvasAnnotations.query({
filter: {
equals: {
property: CanvasAnnotationSDK.PROPERTY_PATHS.canvas,
value: { space: 'mySpace', externalId: 'canvas-1' }
}
}
});

// With reverse relationships (generated helper)
const annotations = await client.canvases.getAnnotations(
{ space: 'mySpace', externalId: 'canvas-1' }
);
`

#### Interactive Configuration

When you generate an SDK, the CLI automatically discovers and prompts you to configure reverse relationships:

`bash
npx dune-sdk-generator generate

After view selection and introspection...

🔗 Discovered 3 reverse relationship(s):

Canvas:
• getAnnotations() → CanvasAnnotation[]
from CanvasAnnotation.canvas
• getComments() → CanvasComment[]
from CanvasComment.canvas

Equipment:
• getMaintenanceRecords() → MaintenanceRecord[]
from MaintenanceRecord.equipment

? Review and customize relationship names? (y/N)
`

Interactive Customization:

If you choose to review/customize (or if conflicts are detected):

`bash
Canvas.getAnnotations()
From: CanvasAnnotation.canvas
Returns: CanvasAnnotation[]

? Configure this relationship:
❯ Keep default (getAnnotations)
Customize method name
Skip this relationship

If you choose "Customize method name":


? Method name: getCanvasAnnotations
`

Conflict Detection:

The CLI automatically detects naming conflicts:

`bash
⚠️ Naming conflicts detected:

Canvas.getAnnotations
Multiple relationships would generate the same method name

? Review and customize relationship names? (Y/n) # Required for conflicts
`

Configuration is Saved:
Your choices are automatically saved to dune.config.json for regeneration.

#### Manual Configuration (Advanced)

You can also edit dune.config.json directly:

`json
{
"reverseRelationships": {
"Canvas": {
"annotations": {
"from": "CanvasAnnotation.canvas",
"methodName": "getAnnotations"
}
}
}
}
`

When regenerating with --config, your existing relationship configuration is preserved.

#### Generated Methods

For each reverse relationship, the SDK generates:

`typescript
/**
* Get all CanvasAnnotation that reference this Canvas
*
* This is a reverse relationship - CanvasAnnotation has a property 'canvas'
* that references Canvas, but Canvas doesn't explicitly define this relationship.
*
* @param id The Canvas instance to find related CanvasAnnotation for
* @param options Query options (limit, additional filters, cursor)
* @returns Array of CanvasAnnotation instances referencing this Canvas
*
* @performance This performs a filtered query on CanvasAnnotation
*/
async getAnnotations(
id: InstanceId,
options?: {
limit?: number;
additionalFilter?: any;
cursor?: string;
}
): Promise
`

#### Advanced Usage

Combine reverse relationships with additional filters:

`typescript
// Get only annotations created in the last week
const recentAnnotations = await client.canvases.getAnnotations(
canvasId,
{
limit: 50,
additionalFilter: {
range: {
property: ['node', 'createdTime'],
gte: Date.now() - 7 24 60 60 1000
}
}
}
);
`

$3

The generator automatically:
- Discovers parent views (via implements)
- Generates type definitions for dependencies
- Resolves transitive dependencies

$3

Save your configuration for easy regeneration:

`bash


First generation saves config

npx dune-sdk-generator generate

Later regeneration

npx dune-sdk-generator generate --config dune.config.json
`

CLI Reference

$3

Search for views by keyword and output results in JSON format compatible with --views.

`bash
dune-sdk-generator search [options]
`

Arguments:
- - Search query string (single query per command)

Options:
- --limit - Maximum number of results (default: 1000)

Output: JSON array of view references

`json
[
{
"space": "cdf_industrial_canvas",
"externalId": "Canvas",
"version": "v1"
}
]
`

Examples:

`bash


Search for canvas-related views

dune-sdk-generator search "canvas" > canvas-views.json

Search with custom limit

dune-sdk-generator search "equipment" --limit 50

Multiple searches (run separately)

dune-sdk-generator search "annotation" > annotations.json
dune-sdk-generator search "comment" > comments.json
`

$3

Get detailed view definitions including properties, constraints, and relationships.

`bash
dune-sdk-generator introspect
`

Arguments:
- - One or more view references in format: space/externalId/version

Output: JSON array of complete view definitions

Examples:

`bash


Introspect single view

dune-sdk-generator introspect cdf_industrial_canvas/Canvas/v1

Introspect multiple views

dune-sdk-generator introspect \
cdf_industrial_canvas/Canvas/v1 \
cdf_industrial_canvas/CanvasAnnotation/v1
`

$3

Generate SDK with interactive or non-interactive view selection.

`bash
dune-sdk-generator generate [options]
`

Options:
- --views - Views to generate SDK for (file path or inline JSON array)
- --output - Output directory (default: ./sdk)
- --name - SDK name for generated file (default: generated-sdk)
- --reverse-relationships - Reverse relationship mode: auto, none, or config (default: auto)
- --non-interactive, -y - Skip all prompts (use defaults or fail)
- --format - Output format: text or json (default: text)
- --config - Regenerate from existing config file

Native API Configuration:

Native CDF API wrappers are always included in the generated SDK - they provide InstanceId-focused interfaces for timeseries, files, and datapoints. You can configure which APIs to include in dune.config.json (though all are enabled by default):

`json
{
"includeNativeAPIs": true,
"nativeAPIs": {
"timeseries": true,
"files": true,
"datapoints": true,
"events": true,
"sequences": true,
"annotations": true,
"labels": true
}
}
`

Modes:

1. Interactive Mode (default): Browse and select views with UI
2. Non-Interactive Mode: Provide views via --views flag
3. Regeneration Mode: Use existing config with --config

Examples:

`bash


Interactive mode

dune-sdk-generator generate

Non-interactive with views from file

dune-sdk-generator generate \
--views views.json \
--name my-sdk \
--output ./sdk \
--non-interactive

Non-interactive with inline JSON

dune-sdk-generator generate \
--views '[{"space":"x","externalId":"y","version":"v1"}]' \
--non-interactive \
--format json

Regenerate from config

dune-sdk-generator generate --config dune.config.json

Non-interactive without reverse relationships

dune-sdk-generator generate \
--views views.json \
--reverse-relationships none \
--non-interactive
`

JSON Output Format (when --format json):

`json
{
"success": true,
"sdkName": "my-sdk",
"outputDirectory": "./sdk",
"files": [
"./sdk/my-sdk.ts",
"./sdk/my-sdk.test.ts"
],
"configPath": "./dune.config.json",
"stats": {
"sdkViews": 5,
"typeOnlyViews": 3,
"reverseRelationships": 8
}
}
`

Generated SDK Structure

The generated SDK provides a unified interface combining both native CDF APIs and custom Data Modeling types:

`typescript
// Initialize SDK
import { CogniteClient } from '@cognite/sdk';
import { initializeSDK } from './sdk/my-sdk';

const client = new CogniteClient({ ... });
const sdk = initializeSDK(client);

// ============================================================================
// Native CDF APIs (Focused Interfaces)
// ============================================================================

// Time Series - InstanceId-based interface
const timeseries = await sdk.timeseries.create([{
space: 'mySpace',
externalId: 'temp-sensor-1',
name: 'Temperature Sensor',
unit: 'C',
isStep: false
}]);

// Data Points - Insert and retrieve
await sdk.datapoints.insert([{
id: { space: 'mySpace', externalId: 'temp-sensor-1' },
datapoints: [
{ timestamp: Date.now(), value: 23.5 },
{ timestamp: Date.now() + 60000, value: 24.1 }
]
}]);

const datapoints = await sdk.datapoints.retrieve({
items: [{ id: { space: 'mySpace', externalId: 'temp-sensor-1' } }],
start: Date.now() - 3600000,
end: Date.now()
});

// Files - Upload and download
await sdk.files.upload(
{ space: 'mySpace', externalId: 'manual-1' },
{ name: 'equipment-manual.pdf', mimeType: 'application/pdf' },
fileBuffer
);

const fileData = await sdk.files.download({ space: 'mySpace', externalId: 'manual-1' });

// Events - Create with instance linkage
await sdk.events.create([{
type: 'maintenance',
description: 'Routine inspection',
startTime: new Date(),
linkedInstance: { space: 'mySpace', externalId: 'equipment-1' }
}]);

// Find events for an instance
const events = await sdk.events.findByInstance(
{ space: 'mySpace', externalId: 'equipment-1' }
);

// ============================================================================
// Custom Data Modeling Types
// ============================================================================

// Create canvas instance
const canvas = await sdk.canvas.create({
space: 'mySpace',
externalId: 'canvas-1',
properties: {
name: 'My Canvas',
width: 1920,
height: 1080
}
});

// Use reverse relationships
const annotations = await sdk.canvas.getAnnotations(
{ space: canvas.space, externalId: canvas.externalId }
);

// Query with filters
const results = await sdk.canvas.query({
filter: {
equals: {
property: ['mySpace', 'Canvas/v1', 'name'],
value: 'My Canvas'
}
},
limit: 100
});

// ============================================================================
// Combined Workflows
// ============================================================================

// Create equipment with time series and files
const equipment = await sdk.equipment.create({
space: 'industrial',
externalId: 'pump-001',
properties: {
name: 'Main Pump',
location: 'Building A'
}
});

// Create associated time series
await sdk.timeseries.create([{
space: 'industrial',
externalId: 'pump-001-pressure',
name: 'Pump 001 Pressure',
unit: 'bar'
}]);

// Upload equipment manual
await sdk.files.upload(
{ space: 'industrial', externalId: 'pump-001-manual' },
{ name: 'pump-manual.pdf' },
manualBuffer
);

// Log maintenance event
await sdk.events.create([{
type: 'maintenance',
description: 'Pressure sensor calibration',
linkedInstance: { space: 'industrial', externalId: 'pump-001' }
}]);
`

Agentic Usage Guide

This section demonstrates how an AI agent can use the CLI to help users generate SDKs through a conversational workflow.

$3

Here's a complete example of how an agent would interact with a user to generate an SDK:

1. Understand Requirements - Ask user for keywords
2. Search - Find matching views
3. Introspect - Analyze view structure and relationships
4. Present Options - Show recommendations based on analysis
5. Prepare - Create filtered view list
6. Configure - Get SDK preferences
7. Generate - Create SDK non-interactively
8. Report - Parse and display results

Step 1: Understand User Requirements

`
Agent: "What data models would you like to generate an SDK for? Please provide some keywords that describe the views you need (e.g., 'canvas', 'equipment', 'work orders')."

User: "I need views related to industrial canvases and annotations"

Agent: "Got it! Let me search for views matching those keywords..."
`

Step 2: Search for Views

`bash


Agent executes: Search for "canvas" views

dune-sdk-generator search "canvas" --limit 50 > canvas-results.json

Agent executes: Search for "annotation" views

dune-sdk-generator search "annotation" --limit 50 > annotation-results.json
`

Step 3: Introspect Views to Understand Structure

`bash


Agent parses search results and introspects top candidates


dune-sdk-generator introspect \
cdf_industrial_canvas/Canvas/v1 \
cdf_industrial_canvas/CanvasConfig/v1 \
cdf_apps_shared/Canvas/v1 \
cdf_industrial_canvas/CanvasAnnotation/v1 \
cdf_apps_shared/Annotation/v1 > view-details.json
`

`
Agent analyzes the introspection results:
- Canvas (cdf_industrial_canvas): 15 properties, implements CogniteDescribableNode
- Has relationships to CanvasAnnotation, CanvasComment
- Properties: name, width, height, data, etc.

- CanvasAnnotation (cdf_industrial_canvas): 8 properties
- References Canvas via 'canvas' property (direct relation)
- Properties: text, position, color, etc.

- CanvasConfig (cdf_industrial_canvas): 5 properties
- Configuration for canvas display settings

- Canvas (cdf_apps_shared): Similar to cdf_industrial_canvas/Canvas
- Likely a duplicate/different version

- Annotation (cdf_apps_shared): Generic annotation
- May not be specific to Canvas
`

Step 4: Present Analyzed Results to User

`
Agent: "I found the following views that match your criteria. After analyzing their structure, here are my recommendations:

✅ Recommended (tightly related to industrial canvases):
• cdf_industrial_canvas/Canvas/v1
- Main canvas view with 15 properties
- Core entity for canvas operations

• cdf_industrial_canvas/CanvasAnnotation/v1
- Annotations linked to Canvas (8 properties)
- Has direct relationship to Canvas

• cdf_industrial_canvas/CanvasConfig/v1
- Canvas display configuration (5 properties)
- Likely needed for Canvas functionality

⚠️ Alternative options (may be duplicates):
• cdf_apps_shared/Canvas/v1
- Similar to the industrial canvas version
- Consider if you need both

• cdf_apps_shared/Annotation/v1
- Generic annotation, not canvas-specific

My recommendation: Start with the three cdf_industrial_canvas views. They form a cohesive set for canvas and annotation management.

Would you like to:
a) Generate SDK with my recommended views
b) Include the cdf_apps_shared views as well
c) Let me search for additional related views

Please choose an option."

User: "Option a, that looks perfect"

Agent: "Excellent! I'll generate an SDK with these three cohesive views:
• Canvas (main entity)
• CanvasAnnotation (linked annotations)
• CanvasConfig (configuration)

This will include automatic reverse relationships, so you'll be able to:
- Get all annotations for a canvas: canvas.getAnnotations()
- Standard CRUD operations on all three types
- Type-safe access to all properties"
`

Step 5: Prepare View List

`bash


Agent creates a filtered views.json file


cat > views.json << 'EOF'
[
{
"space": "cdf_industrial_canvas",
"externalId": "Canvas",
"version": "v1"
},
{
"space": "cdf_industrial_canvas",
"externalId": "CanvasConfig",
"version": "v1"
},
{
"space": "cdf_industrial_canvas",
"externalId": "CanvasAnnotation",
"version": "v1"
}
]
EOF
`

Step 6: Ask for Configuration Preferences

`
Agent: "Great! Now I need a few configuration details:

1. What should I name the SDK? (default: generated-sdk)
2. Where should I output the files? (default: ./sdk)
3. Should I include reverse relationships? (recommended: yes)

Please provide your preferences or type 'use defaults'."

User: "Name it canvas-sdk, output to ./src/sdk, and yes to reverse relationships"
`

Step 7: Generate SDK Non-Interactively

`bash


Agent executes the generation


dune-sdk-generator generate \
--views views.json \
--name canvas-sdk \
--output ./src/sdk \
--reverse-relationships auto \
--non-interactive \
--format json > generation-result.json
`

Step 8: Report Results

`bash


Agent parses the JSON output


cat generation-result.json
`

`json
{
"success": true,
"sdkName": "canvas-sdk",
"outputDirectory": "./src/sdk",
"files": [
"./src/sdk/canvas-sdk.ts",
"./src/sdk/canvas-sdk.test.ts"
],
"configPath": "./dune.config.json",
"stats": {
"sdkViews": 3,
"typeOnlyViews": 2,
"reverseRelationships": 5
}
}
`

`
Agent: "✅ SDK generated successfully!

Generated files:
• ./src/sdk/canvas-sdk.ts (main SDK)
• ./src/sdk/canvas-sdk.test.ts (test suite)
• ./dune.config.json (configuration for regeneration)

SDK Stats:
• 3 main views with full CRUD operations
• 2 type-only dependency views
• 5 reverse relationships discovered

You can now import and use your SDK:
import { initializeSDK } from './src/sdk/canvas-sdk';

To regenerate later with the same configuration:
dune-sdk-generator generate --config dune.config.json"
`

$3

Here's how to implement the agentic workflow in code:

`typescript
// Example agent implementation
async function generateSDKWithAgent(userRequest: string) {
// 1. Extract keywords from user request
const keywords = extractKeywords(userRequest); // e.g., ["canvas", "annotation"]

// 2. Search for each keyword
const allViews = [];
for (const keyword of keywords) {
const { stdout } = await exec(
dune-sdk-generator search "${keyword}" --limit 50
);
const views = JSON.parse(stdout);
allViews.push(...views);
}

// 3. Remove duplicates
const uniqueViews = deduplicateViews(allViews);

// 4. Introspect views to understand their structure
const viewRefs = uniqueViews.map(v => ${v.space}/${v.externalId}/${v.version});
const { stdout: introspectData } = await exec(
dune-sdk-generator introspect ${viewRefs.join(' ')}
);
const viewDetails = JSON.parse(introspectData);

// 5. Analyze views to make recommendations
const analysis = analyzeViews(viewDetails);
// - Check for relationships between views
// - Count properties
// - Identify core vs auxiliary views
// - Detect duplicates across spaces

// 6. Present recommendations to user
const recommendations = await presentRecommendations(analysis, uniqueViews);
const selectedViews = await askUserToConfirm(recommendations);

// 7. Write selected views to file
await writeFile('views.json', JSON.stringify(selectedViews, null, 2));

// 8. Get configuration preferences
const config = await askUserForConfig();

// 9. Generate SDK
const { stdout } = await exec(
dune-sdk-generator generate \
--views views.json \
--name ${config.name} \
--output ${config.output} \
--reverse-relationships auto \
--non-interactive \
--format json
);

// 10. Parse and report results
const result = JSON.parse(stdout);
return result;
}

// Helper function to analyze view relationships
function analyzeViews(viewDetails: any[]): ViewAnalysis {
const relationships = new Map();

for (const view of viewDetails) {
// Check for direct relations pointing to other views
for (const [propName, prop] of Object.entries(view.properties || {})) {
if (prop.type?.type === 'direct') {
const target = findViewByContainer(viewDetails, prop.type.source);
if (target) {
relationships.set(
${view.externalId}->${target.externalId},
{ source: view, target, property: propName }
);
}
}
}
}

return {
views: viewDetails,
relationships: Array.from(relationships.values()),
clusters: clusterRelatedViews(viewDetails, relationships),
};
}
`

$3

Simple view search with introspection:

`bash
#!/bin/bash


search-and-select.sh

KEYWORD=$1
echo "Searching for views matching: $KEYWORD"

Search

dune-sdk-generator search "$KEYWORD" --limit 20 > results.json

Show results

echo "Found views:"
jq -r '.[] | " • \(.space)/\(.externalId)/\(.version)"' results.json

Introspect top 5 views to understand structure

echo ""
echo "Analyzing top 5 views..."
VIEW_REFS=$(jq -r 'limit(5; .[]) | "\(.space)/\(.externalId)/\(.version)"' results.json | tr '\n' ' ')
dune-sdk-generator introspect $VIEW_REFS > introspect-results.json

Show analysis

echo ""
echo "View details:"
jq -r '.[] | " \(.externalId): \(.properties | length) properties"' introspect-results.json

echo ""
echo "Full results saved to:"
echo " - results.json (search results)"
echo " - introspect-results.json (detailed view info)"
echo ""
echo "To generate SDK: dune-sdk-generator generate --views results.json --non-interactive"
`

Batch SDK generation:

`bash
#!/bin/bash


batch-generate.sh

for config in ./configs/*.json; do
sdk_name=$(basename "$config" .json)
echo "Generating SDK: $sdk_name"

dune-sdk-generator generate \
--views "$config" \
--name "$sdk_name" \
--output "./sdks/$sdk_name" \
--non-interactive \
--format json > "./results/${sdk_name}-result.json"

echo "✓ $sdk_name complete"
done
`

$3

Using in GitHub Actions:

`yaml


.github/workflows/generate-sdk.yml

name: Generate SDK

on:
push:
paths:
- 'config/views.json'

jobs:
generate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3

- name: Setup Node
uses: actions/setup-node@v3
with:
node-version: '18'

- name: Generate SDK
run: |
npx dune-sdk-generator generate \
--views ./config/views.json \
--name production-sdk \
--output ./src/sdk \
--non-interactive \
--format json > result.json
env:
CDF_PROJECT: ${{ secrets.CDF_PROJECT }}
CDF_TOKEN: ${{ secrets.CDF_TOKEN }}

- name: Check result
run: |
if jq -e '.success == true' result.json > /dev/null; then
echo "✅ SDK generated successfully"
jq '.stats' result.json
else
echo "❌ SDK generation failed"
jq '.error' result.json
exit 1
fi

- name: Commit generated SDK
run: |
git config user.name "SDK Generator Bot"
git config user.email "bot@example.com"
git add src/sdk/
git commit -m "chore: regenerate SDK"
git push
`

Best Practices

$3

1. Start with Auto-Discovery: Enable autoDiscoverReverseRelationships: true to see all possible relationships
2. Refine Manually: Switch to manual configuration to control which relationships are exposed
3. Name Thoughtfully: Use descriptive method names that reflect the business domain
4. Document Performance: Reverse relationships perform queries - be mindful of limits and pagination

$3

The CLI automatically detects naming conflicts:

`bash
⚠️ Naming conflicts detected:

Canvas.getItems
Multiple relationships would generate the same method name

? Review and customize relationship names? (Y/n) # Defaults to Yes
`

When conflicts are detected:
- You'll be prompted to customize (required to proceed)
- The CLI suggests the conflicting relationships
- You provide unique names for each

$3

Best Practices

$3

1. Start with Auto-Discovery: Enable autoDiscoverReverseRelationships: true to see all possible relationships
2. Refine Manually: Switch to manual configuration to control which relationships are exposed
3. Name Thoughtfully: Use descriptive method names that reflect the business domain
4. Document Performance: Reverse relationships perform queries - be mindful of limits and pagination

$3

The CLI automatically detects naming conflicts:

`bash
⚠️ Naming conflicts detected:

Canvas.getItems
Multiple relationships would generate the same method name

? Review and customize relationship names? (Y/n) # Defaults to Yes
`

When conflicts are detected:
- You'll be prompted to customize (required to proceed)
- The CLI suggests the conflicting relationships
- You provide unique names for each

$3

- Use limit parameter to control result set size
- Leverage cursor for pagination
- Add additionalFilter to narrow results
- Consider caching frequently accessed relationships

Development

$3

For development, you can clone the Cognite SDK source for reference:

`bash
mkdir -p reference
git clone https://github.com/cognitedata/cognite-sdk-js.git reference/cognite-sdk
``

This directory is gitignored and read-only (via Cursor rules).

License

MIT