Resolver Input/Output

Type definitions for the data structures passed to and returned from resolvers.

ResolverInput

The input object passed to your resolver handler.

Definition

interface ResolverInput {
  readonly config: Record<string, unknown>;
  readonly files: ResolvedFile[];
}

Definition

@dataclass
class ResolverInput:
    config: Dict[str, Any]
    files: list[ResolvedFile]

Definition

record ResolverInput(
    Dictionary<string, object> Config,
        IEnumerable<ResolvedFile> Files
    );

Properties

Prop

Type

ResolvedFile

Information about a single file version from a template layer.

Definition

interface ResolvedFile {
  readonly path: string;
  readonly content: string;
  readonly origin: FileOrigin;
}

Definition

@dataclass
class ResolvedFile:
    path: str
    content: str
    origin: FileOrigin

Definition

record ResolvedFile(
    string Path,
    string Content,
    FileOrigin Origin
    );

Properties

Prop

Type

FileOrigin

Information about where a file came from.

Definition

interface FileOrigin {
  readonly template: string;
  readonly layer: number;
}

Definition

@dataclass
class FileOrigin:
    template: str
    layer: int

Definition

record FileOrigin(
    string Template,
    int Layer
    );

Properties

Prop

Type

Files are sorted by layer number during resolution. Lower layer numbers indicate higher priority and should be processed first in the merge.

ResolverOutput

The return value from your resolver handler.

Definition

interface ResolverOutput {
  readonly path: string;
  readonly content: string;
}

Definition

@dataclass
class ResolverOutput:
    path: str
    content: str

Definition

record ResolverOutput(
    string Path,
    string Content
    );

Properties

Prop

Type

Usage Example

index.ts

import { ResolverOutput, StartResolverWithLambda } from '@atomicloud/cyan-sdk';

StartResolverWithLambda(async (input): Promise<ResolverOutput> => {
  // Access config
  const strategy = input.config['arrayStrategy'] as string || 'replace';

  // Sort files by layer (lower = higher priority)
  const sorted = [...input.files].sort(
    (a, b) => a.origin.layer - b.origin.layer
  );

  // Merge content
  let merged = {};
  for (const file of sorted) {
    const content = JSON.parse(file.content);
    merged = { ...merged, ...content };
  }

  return {
    path: input.files[0].path,
    content: JSON.stringify(merged, null, 2)
  };
});

main.py

import json
from typing import Any
from cyanprintsdk.domain.resolver.input import ResolverInput, ResolvedFile
from cyanprintsdk.domain.resolver.output import ResolverOutput
from cyanprintsdk.main import start_resolver_with_fn


async def resolver(input: ResolverInput) -> ResolverOutput:
    # Access config
    strategy: str = input.config.get('arrayStrategy', 'replace')

    # Sort files by layer (lower = higher priority)
    sorted_files = sorted(input.files, key=lambda f: f.origin.layer)

    # Merge content
    merged: dict[str, Any] = {}
    for file in sorted_files:
        content = json.loads(file.content)
        merged = {**merged, **content}

    return ResolverOutput(
        path=input.files[0].path,
        content=json.dumps(merged, indent=2)
    )


if __name__ == "__main__":
    start_resolver_with_fn(resolver)

Program.cs

using System.Text.Json;
using sulfone_helium;
using sulfone_helium.Domain.Resolver;

CyanEngine.StartResolver(
    args,
    async (ResolverInput input) =>
    {
        // Access config
        var strategy = input.Config.TryGetValue("arrayStrategy", out var stratObj)
            ? stratObj?.ToString() ?? "replace"
            : "replace";

        // Sort files by layer (lower = higher priority)
        var sorted = input.Files.OrderBy(f => f.Origin.Layer).ToList();

        // Merge content
        var merged = new Dictionary<string, object>();
        foreach (var file in sorted)
        {
            var content = JsonSerializer.Deserialize<Dictionary<string, object>>(file.Content)
                ?? new Dictionary<string, object>();
            foreach (var kvp in content)
            {
                merged[kvp.Key] = kvp.Value;
            }
        }

        return new ResolverOutput(
            input.Files.First().Path,
            JsonSerializer.Serialize(merged, new JsonSerializerOptions { WriteIndented = true })
        );
    }
);

StartResolver Functions

Entry point API reference

Merge JSON Files

Practical guide

Resolver Input/Output

StartResolver Functions

Merge JSON Files

On this page