import { createClient } from "@nomacms/js-sdk"
 
const client = createClient({
  projectId: process.env.NOMA_PROJECT_ID!,
  apiKey: process.env.NOMA_API_KEY!,
})
 
const en = await client.content.get("blog-posts", enUuid, { state: "published" })
 
const tr = await client.content.get("blog-posts", enUuid, {
  state: "published",
  translation_locale: "tr",
})
 
await client.content.linkTranslation("blog-posts", enUuid, {
  translation_entry_uuid: otherUuid,
})

import axios from "axios"
 
const headers = {
  "project-id": process.env.NOMA_PROJECT_ID!,
  Authorization: `Bearer ${process.env.NOMA_API_KEY}`,
  Accept: "application/json",
}
 
async function main() {
  const base = `https://app.nomacms.com/api/blog-posts/${encodeURIComponent(enUuid)}`
 
  const english = await axios.get(base, {
    params: { state: "published" },
    headers,
  })
  console.log(english.data)
 
  const turkish = await axios.get(base, {
    params: { state: "published", translation_locale: "tr" },
    headers,
  })
  console.log(turkish.data)
 
  const linked = await axios.post(
    `${base}/link-translation`,
    { translation_entry_uuid: otherUuid },
    { headers: { ...headers, "Content-Type": "application/json" } },
  )
  console.log(linked.data)
}
 
void main()

<?php
 
$slug = 'blog-posts';
$enUuid = getenv('EN_UUID');
$basePath = '/api/' . rawurlencode($slug) . '/' . rawurlencode($enUuid);
$hdr = [
    'project-id: ' . getenv('NOMA_PROJECT_ID'),
    'Authorization: Bearer ' . getenv('NOMA_API_KEY'),
    'Accept: application/json',
];
 
// GET — linked translation (Turkish)
$query = http_build_query([
    'state' => 'published',
    'translation_locale' => 'tr',
]);
$ch = curl_init('https://app.nomacms.com' . $basePath . '?' . $query);
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $hdr,
    CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch) . "\n";
 
// POST — link translation
$body = json_encode(['translation_entry_uuid' => getenv('OTHER_UUID')]);
$ch = curl_init('https://app.nomacms.com' . $basePath . '/link-translation');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $body,
    CURLOPT_HTTPHEADER => array_merge([
        'Content-Type: application/json',
        'Content-Length: ' . strlen($body),
    ], $hdr),
    CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch);

# GET — fetch linked entry in another locale (path uuid = source entry)
curl -sS -G "https://app.nomacms.com/api/blog-posts/${EN_UUID}" \
  --data-urlencode "state=published" \
  --data-urlencode "translation_locale=tr" \
  -H "project-id: $NOMA_PROJECT_ID" \
  -H "Authorization: Bearer $NOMA_API_KEY" \
  -H "Accept: application/json"
 
# POST — link two entries as translations
curl -sS -X POST "https://app.nomacms.com/api/blog-posts/${EN_UUID}/link-translation" \
  -H "Content-Type: application/json" \
  -H "project-id: $NOMA_PROJECT_ID" \
  -H "Authorization: Bearer $NOMA_API_KEY" \
  -H "Accept: application/json" \
  -d "{\"translation_entry_uuid\":\"${OTHER_UUID}\"}"

package main
 
import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"net/url"
	"os"
)
 
func main() {
	host := "https://app.nomacms.com/api/blog-posts/" + url.PathEscape(os.Getenv("EN_UUID"))
	hdr := func(req *http.Request) {
		req.Header.Set("project-id", os.Getenv("NOMA_PROJECT_ID"))
		req.Header.Set("Authorization", "Bearer "+os.Getenv("NOMA_API_KEY"))
		req.Header.Set("Accept", "application/json")
	}
 
	// GET — linked translation
	u, _ := url.Parse(host)
	q := u.Query()
	q.Set("state", "published")
	q.Set("translation_locale", "tr")
	u.RawQuery = q.Encode()
	req, _ := http.NewRequest("GET", u.String(), nil)
	hdr(req)
	do(req)
 
	// POST — link translation
	payload, _ := json.Marshal(map[string]string{
		"translation_entry_uuid": os.Getenv("OTHER_UUID"),
	})
	req, _ = http.NewRequest("POST", host+"/link-translation", bytes.NewReader(payload))
	hdr(req)
	req.Header.Set("Content-Type", "application/json")
	do(req)
}
 
func do(req *http.Request) {
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	_, _ = io.Copy(os.Stdout, res.Body)
}

require "net/http"
require "json"
require "uri"
 
slug = "blog-posts"
en_uuid = ENV.fetch("EN_UUID")
base = URI("https://app.nomacms.com/api/#{slug}/#{en_uuid}")
 
headers = {
  "project-id" => ENV.fetch("NOMA_PROJECT_ID"),
  "Authorization" => "Bearer #{ENV.fetch('NOMA_API_KEY')}",
  "Accept" => "application/json"
}
 
# GET — linked translation
get_uri = base.dup
get_uri.query = URI.encode_www_form("state" => "published", "translation_locale" => "tr")
req = Net::HTTP::Get.new(get_uri)
headers.each { |k, v| req[k] = v }
Net::HTTP.start(get_uri.hostname, get_uri.port, use_ssl: get_uri.scheme == "https") do |http|
  puts http.request(req).body
end
 
# POST — link translation
post_uri = URI("https://app.nomacms.com/api/#{slug}/#{en_uuid}/link-translation")
req = Net::HTTP::Post.new(post_uri)
req["Content-Type"] = "application/json"
headers.each { |k, v| req[k] = v }
req.body = JSON.generate("translation_entry_uuid" => ENV.fetch("OTHER_UUID"))
Net::HTTP.start(post_uri.hostname, post_uri.port, use_ssl: post_uri.scheme == "https") do |http|
  puts http.request(req).body
end

import json
import os
import urllib.parse
import urllib.request
 
slug = "blog-posts"
en_uuid = os.environ["EN_UUID"]
path = f"/api/{urllib.parse.quote(slug, safe='')}/{urllib.parse.quote(en_uuid, safe='')}"
base = f"https://app.nomacms.com{path}"
hdr = {
    "project-id": os.environ["NOMA_PROJECT_ID"],
    "Authorization": f"Bearer {os.environ['NOMA_API_KEY']}",
    "Accept": "application/json",
}
 
# GET — linked translation
q = urllib.parse.urlencode({"state": "published", "translation_locale": "tr"})
req = urllib.request.Request(
    f"{base}?{q}",
    headers=hdr,
    method="GET",
)
with urllib.request.urlopen(req) as res:
    print(res.read().decode())
 
# POST — link translation
body = {"translation_entry_uuid": os.environ["OTHER_UUID"]}
req = urllib.request.Request(
    f"{base}/link-translation",
    data=json.dumps(body).encode(),
    headers={**hdr, "Content-Type": "application/json"},
    method="POST",
)
with urllib.request.urlopen(req) as res:
    print(res.read().decode())