Publish Object

Use PublishObject to create or update a single Object, using object.id to control the upsert behavior:

An existing object.id updates that Object.
A new object.id creates a new Object with that ID.
An omitted object.id lets the service assign a new random ID.

Go C++ Java Python TypeScript REST

package main

import (
	"context"
	"log"
	"time"

	"connectrpc.com/connect"
	"google.golang.org/protobuf/types/known/timestamppb"

	wdmsdk "github.com/raft-tech/raft-wdm-sdk-go"
	pb "github.com/raft-tech/raft-wdm-sdk-go/gen/raft/wdm/v1"
	svc "github.com/raft-tech/raft-wdm-sdk-go/gen/raft/wdm/v1/service"
)

func main() {
	cfg, err := wdmsdk.LoadConfig()
	if err != nil {
		log.Fatal(err)
	}

	client, err := wdmsdk.NewFromConfig(cfg)
	if err != nil {
		log.Fatal(err)
	}

	updatedAt := time.Now().UTC()
	_, err = client.ObjectService().PublishObject(context.Background(), connect.NewRequest(&svc.PublishObjectRequest{
		Object: &pb.Object{
			Id:     "link16-track-47210",
			Name:   "TRACK-47210",
			Status: pb.ObjectStatus_OBJECT_STATUS_ACTIVE,
			Ttl:    timestamppb.New(updatedAt.Add(5 * time.Minute)),
			Provenance: &pb.ProvenanceRecord{
				Name:      "aegis-radar-07",
				UpdatedAt: timestamppb.New(updatedAt),
			},
		},
	}))
	if err != nil {
		log.Fatal(err)
	}
}

#include "rdp/sdk/client.hpp"

#include <google/protobuf/util/time_util.h>

#include <chrono>
#include <iostream>

int main() {
    auto config = raft::rdp::LoadConfig();
    auto client = raft::rdp::Client::FromConfig(
        config,
        {raft::rdp::WithTimeout(std::chrono::seconds(10))}
    );

    raft::wdm::v1::service::PublishObjectRequest request;
    auto* object = request.mutable_object();
    object->set_id("link16-track-47210");
    object->set_name("TRACK-47210");
    object->set_status(raft::wdm::v1::OBJECT_STATUS_ACTIVE);

    const auto updated_at = google::protobuf::util::TimeUtil::GetCurrentTime();
    *object->mutable_ttl() = updated_at;
    object->mutable_ttl()->set_seconds(updated_at.seconds() + 300);
    object->mutable_provenance()->set_name("aegis-radar-07");
    *object->mutable_provenance()->mutable_updated_at() = updated_at;

    raft::wdm::v1::service::PublishObjectResponse response;
    auto context = client.NewGrpcContext();
    const auto status = client.ObjectService().PublishObject(
        context.get(), request, &response
    );
    if (!status.ok()) {
        std::cerr << "PublishObject: " << status.error_message() << '\n';
        return 1;
    }
}

import com.google.protobuf.Timestamp;
import com.raft.wdm.Wdm;
import com.raft.wdm.raft.wdm.v1.Object;
import com.raft.wdm.raft.wdm.v1.ObjectStatus;
import com.raft.wdm.raft.wdm.v1.ProvenanceRecord;
import com.raft.wdm.raft.wdm.v1.service.PublishObjectRequest;
import com.raft.wdm.v1.WdmV1Client;
import java.time.Instant;

public final class PublishObjectExample {
  public static void main(String[] args) {
    var options = Wdm.toOptions(Wdm.loadConfig(null, null));
    var updatedAt = Instant.now();

    try (var client = WdmV1Client.create(options)) {
      var req = PublishObjectRequest.newBuilder()
          .setObject(Object.newBuilder()
              .setId("link16-track-47210")
              .setName("TRACK-47210")
              .setStatus(ObjectStatus.OBJECT_STATUS_ACTIVE)
              .setTtl(timestamp(updatedAt.plusSeconds(300)))
              .setProvenance(ProvenanceRecord.newBuilder()
                  .setName("aegis-radar-07")
                  .setUpdatedAt(timestamp(updatedAt))))
          .build();

      client.getObjectServiceBlocking()
          .publishObjectBlocking(req)
          .execute();
    }
  }

  private static Timestamp timestamp(Instant instant) {
    return Timestamp.newBuilder()
        .setSeconds(instant.getEpochSecond())
        .setNanos(instant.getNano())
        .build();
  }
}

import asyncio
from datetime import datetime, timedelta, timezone

from google.protobuf.timestamp_pb2 import Timestamp
from raft.wdm.v1 import object_pb2
from raft.wdm.v1 import common_pb2
from raft.wdm.v1.service import object_service_pb2

import raft_wdm_sdk


def timestamp(dt: datetime) -> Timestamp:
    value = Timestamp()
    value.FromDatetime(dt)
    return value


async def main() -> None:
    updated_at = datetime.now(timezone.utc)

    async with raft_wdm_sdk.Client.from_config(raft_wdm_sdk.load_config()) as client:
        await client.object_service.publish_object(
            object_service_pb2.PublishObjectRequest(
                object=object_pb2.Object(
                    id="link16-track-47210",
                    name="TRACK-47210",
                    status=object_pb2.OBJECT_STATUS_ACTIVE,
                    ttl=timestamp(updated_at + timedelta(minutes=5)),
                    provenance=common_pb2.ProvenanceRecord(
                        name="aegis-radar-07",
                        updated_at=timestamp(updated_at),
                    ),
                ),
            ),
        )


asyncio.run(main())

import { create } from "@bufbuild/protobuf";
import { timestampFromDate } from "@bufbuild/protobuf/wkt";
import { createClient, fromNodeConfig, loadConfig } from "@raft-tech/raft-wdm-sdk-typescript";
import { ObjectStatus } from "@raft-tech/raft-wdm-sdk-typescript/gen/raft/wdm/v1/object_pb.js";
import { PublishObjectRequestSchema } from "@raft-tech/raft-wdm-sdk-typescript/gen/raft/wdm/v1/service/object_service_pb.js";

const client = createClient(...fromNodeConfig(loadConfig()));

const updatedAt = new Date();

await client.objectService.publishObject(
  create(PublishObjectRequestSchema, {
    object: {
      id: "link16-track-47210",
      name: "TRACK-47210",
      status: ObjectStatus.OBJECT_STATUS_ACTIVE,
      ttl: timestampFromDate(new Date(updatedAt.getTime() + 5 * 60 * 1000)),
      provenance: {
        name: "aegis-radar-07",
        updatedAt: timestampFromDate(updatedAt),
      },
    },
  }),
);

curl -X POST "${RDP_SERVER_URL}/api/v1/wdm/objects" \
  -H "X-API-KEY: ${RDP_API_KEY}" \
  -H "Content-Type: application/json" \
  --json @- <<JSON
{
  "object": {
    "id": "link16-track-47210",
    "name": "TRACK-47210",
    "status": "OBJECT_STATUS_ACTIVE",
    "ttl": "2026-08-18T20:22:07Z",
    "provenance": {
      "name": "aegis-radar-07",
      "updatedAt": "2026-08-18T20:17:07Z"
    }
  }
}
JSON

Publish Object

See Also

Search

Get

Stream