restapi.Object

import * as pulumi from "@pulumi/pulumi";
import * as restapi from "@pulumi/restapi";

const foo2 = new restapi.Object("Foo2", {
    path: "/api/objects",
    data: "{ \"id\": \"55555\", \"first\": \"Foo\", \"last\": \"Bar\" }",
});

import pulumi
import pulumi_restapi as restapi

foo2 = restapi.Object("Foo2",
    path="/api/objects",
    data="{ \"id\": \"55555\", \"first\": \"Foo\", \"last\": \"Bar\" }")

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/restapi/v3/restapi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := restapi.NewObject(ctx, "Foo2", &restapi.ObjectArgs{
			Path: pulumi.String("/api/objects"),
			Data: pulumi.String("{ \"id\": \"55555\", \"first\": \"Foo\", \"last\": \"Bar\" }"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Restapi = Pulumi.Restapi;

return await Deployment.RunAsync(() => 
{
    var foo2 = new Restapi.Object("Foo2", new()
    {
        Path = "/api/objects",
        Data = "{ \"id\": \"55555\", \"first\": \"Foo\", \"last\": \"Bar\" }",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.restapi.Object;
import com.pulumi.restapi.ObjectArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo2 = new Object("foo2", ObjectArgs.builder()
            .path("/api/objects")
            .data("{ \"id\": \"55555\", \"first\": \"Foo\", \"last\": \"Bar\" }")
            .build());

    }
}

resources:
  foo2:
    type: restapi:Object
    name: Foo2
    properties:
      path: /api/objects
      data: '{ "id": "55555", "first": "Foo", "last": "Bar" }'

import * as pulumi from "@pulumi/pulumi";
import * as restapi from "@pulumi/restapi";

// Example: Using read_search with search_patch to transform API responses
//
// When an API returns objects in a wrapped structure or with extra metadata,
// you can use search_patch to transform the response to match your desired state.
const userWithSearchPatch = new restapi.Object("user_with_search_patch", {
    path: "/api/users",
    data: JSON.stringify({
        id: "user123",
        name: "John Doe",
        email: "john@example.com",
    }),
    readSearch: {
        searchKey: "email",
        searchValue: "john@example.com",
        searchPatch: JSON.stringify([
            {
                op: "copy",
                from: "/data/id",
                path: "/id",
            },
            {
                op: "copy",
                from: "/data/name",
                path: "/name",
            },
            {
                op: "copy",
                from: "/data/email",
                path: "/email",
            },
            {
                op: "remove",
                path: "/data",
            },
            {
                op: "remove",
                path: "/metadata",
            },
        ]),
    },
});
// Example: Remove server-generated fields from API responses
const cleanResponse = new restapi.Object("clean_response", {
    path: "/api/resources",
    data: JSON.stringify({
        id: "resource456",
        name: "My Resource",
    }),
    readSearch: {
        searchKey: "id",
        searchValue: "{id}",
        searchPatch: JSON.stringify([
            {
                op: "remove",
                path: "/createdAt",
            },
            {
                op: "remove",
                path: "/updatedAt",
            },
            {
                op: "remove",
                path: "/metadata",
            },
        ]),
    },
});

import pulumi
import json
import pulumi_restapi as restapi

# Example: Using read_search with search_patch to transform API responses
#
# When an API returns objects in a wrapped structure or with extra metadata,
# you can use search_patch to transform the response to match your desired state.
user_with_search_patch = restapi.Object("user_with_search_patch",
    path="/api/users",
    data=json.dumps({
        "id": "user123",
        "name": "John Doe",
        "email": "john@example.com",
    }),
    read_search={
        "search_key": "email",
        "search_value": "john@example.com",
        "search_patch": json.dumps([
            {
                "op": "copy",
                "from": "/data/id",
                "path": "/id",
            },
            {
                "op": "copy",
                "from": "/data/name",
                "path": "/name",
            },
            {
                "op": "copy",
                "from": "/data/email",
                "path": "/email",
            },
            {
                "op": "remove",
                "path": "/data",
            },
            {
                "op": "remove",
                "path": "/metadata",
            },
        ]),
    })
# Example: Remove server-generated fields from API responses
clean_response = restapi.Object("clean_response",
    path="/api/resources",
    data=json.dumps({
        "id": "resource456",
        "name": "My Resource",
    }),
    read_search={
        "search_key": "id",
        "search_value": "{id}",
        "search_patch": json.dumps([
            {
                "op": "remove",
                "path": "/createdAt",
            },
            {
                "op": "remove",
                "path": "/updatedAt",
            },
            {
                "op": "remove",
                "path": "/metadata",
            },
        ]),
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/restapi/v3/restapi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"id":    "user123",
			"name":  "John Doe",
			"email": "john@example.com",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal([]interface{}{
			map[string]interface{}{
				"op":   "copy",
				"from": "/data/id",
				"path": "/id",
			},
			map[string]interface{}{
				"op":   "copy",
				"from": "/data/name",
				"path": "/name",
			},
			map[string]interface{}{
				"op":   "copy",
				"from": "/data/email",
				"path": "/email",
			},
			map[string]interface{}{
				"op":   "remove",
				"path": "/data",
			},
			map[string]interface{}{
				"op":   "remove",
				"path": "/metadata",
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		// Example: Using read_search with search_patch to transform API responses
		//
		// When an API returns objects in a wrapped structure or with extra metadata,
		// you can use search_patch to transform the response to match your desired state.
		_, err = restapi.NewObject(ctx, "user_with_search_patch", &restapi.ObjectArgs{
			Path: pulumi.String("/api/users"),
			Data: pulumi.String(json0),
			ReadSearch: &restapi.ObjectReadSearchArgs{
				SearchKey:   pulumi.String("email"),
				SearchValue: pulumi.String("john@example.com"),
				SearchPatch: pulumi.String(json1),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"id":   "resource456",
			"name": "My Resource",
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		tmpJSON3, err := json.Marshal([]map[string]interface{}{
			map[string]interface{}{
				"op":   "remove",
				"path": "/createdAt",
			},
			map[string]interface{}{
				"op":   "remove",
				"path": "/updatedAt",
			},
			map[string]interface{}{
				"op":   "remove",
				"path": "/metadata",
			},
		})
		if err != nil {
			return err
		}
		json3 := string(tmpJSON3)
		// Example: Remove server-generated fields from API responses
		_, err = restapi.NewObject(ctx, "clean_response", &restapi.ObjectArgs{
			Path: pulumi.String("/api/resources"),
			Data: pulumi.String(json2),
			ReadSearch: &restapi.ObjectReadSearchArgs{
				SearchKey:   pulumi.String("id"),
				SearchValue: pulumi.String("{id}"),
				SearchPatch: pulumi.String(json3),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Restapi = Pulumi.Restapi;

return await Deployment.RunAsync(() => 
{
    // Example: Using read_search with search_patch to transform API responses
    //
    // When an API returns objects in a wrapped structure or with extra metadata,
    // you can use search_patch to transform the response to match your desired state.
    var userWithSearchPatch = new Restapi.Object("user_with_search_patch", new()
    {
        Path = "/api/users",
        Data = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["id"] = "user123",
            ["name"] = "John Doe",
            ["email"] = "john@example.com",
        }),
        ReadSearch = new Restapi.Inputs.ObjectReadSearchArgs
        {
            SearchKey = "email",
            SearchValue = "john@example.com",
            SearchPatch = JsonSerializer.Serialize(new[]
            {
                new Dictionary<string, object?>
                {
                    ["op"] = "copy",
                    ["from"] = "/data/id",
                    ["path"] = "/id",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "copy",
                    ["from"] = "/data/name",
                    ["path"] = "/name",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "copy",
                    ["from"] = "/data/email",
                    ["path"] = "/email",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "remove",
                    ["path"] = "/data",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "remove",
                    ["path"] = "/metadata",
                },
            }),
        },
    });

    // Example: Remove server-generated fields from API responses
    var cleanResponse = new Restapi.Object("clean_response", new()
    {
        Path = "/api/resources",
        Data = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["id"] = "resource456",
            ["name"] = "My Resource",
        }),
        ReadSearch = new Restapi.Inputs.ObjectReadSearchArgs
        {
            SearchKey = "id",
            SearchValue = "{id}",
            SearchPatch = JsonSerializer.Serialize(new[]
            {
                new Dictionary<string, object?>
                {
                    ["op"] = "remove",
                    ["path"] = "/createdAt",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "remove",
                    ["path"] = "/updatedAt",
                },
                new Dictionary<string, object?>
                {
                    ["op"] = "remove",
                    ["path"] = "/metadata",
                },
            }),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.restapi.Object;
import com.pulumi.restapi.ObjectArgs;
import com.pulumi.restapi.inputs.ObjectReadSearchArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // Example: Using read_search with search_patch to transform API responses
        //
        // When an API returns objects in a wrapped structure or with extra metadata,
        // you can use search_patch to transform the response to match your desired state.
        var userWithSearchPatch = new Object("userWithSearchPatch", ObjectArgs.builder()
            .path("/api/users")
            .data(serializeJson(
                jsonObject(
                    jsonProperty("id", "user123"),
                    jsonProperty("name", "John Doe"),
                    jsonProperty("email", "john@example.com")
                )))
            .readSearch(ObjectReadSearchArgs.builder()
                .searchKey("email")
                .searchValue("john@example.com")
                .searchPatch(serializeJson(
                    jsonArray(
                        jsonObject(
                            jsonProperty("op", "copy"),
                            jsonProperty("from", "/data/id"),
                            jsonProperty("path", "/id")
                        ), 
                        jsonObject(
                            jsonProperty("op", "copy"),
                            jsonProperty("from", "/data/name"),
                            jsonProperty("path", "/name")
                        ), 
                        jsonObject(
                            jsonProperty("op", "copy"),
                            jsonProperty("from", "/data/email"),
                            jsonProperty("path", "/email")
                        ), 
                        jsonObject(
                            jsonProperty("op", "remove"),
                            jsonProperty("path", "/data")
                        ), 
                        jsonObject(
                            jsonProperty("op", "remove"),
                            jsonProperty("path", "/metadata")
                        )
                    )))
                .build())
            .build());

        // Example: Remove server-generated fields from API responses
        var cleanResponse = new Object("cleanResponse", ObjectArgs.builder()
            .path("/api/resources")
            .data(serializeJson(
                jsonObject(
                    jsonProperty("id", "resource456"),
                    jsonProperty("name", "My Resource")
                )))
            .readSearch(ObjectReadSearchArgs.builder()
                .searchKey("id")
                .searchValue("{id}")
                .searchPatch(serializeJson(
                    jsonArray(
                        jsonObject(
                            jsonProperty("op", "remove"),
                            jsonProperty("path", "/createdAt")
                        ), 
                        jsonObject(
                            jsonProperty("op", "remove"),
                            jsonProperty("path", "/updatedAt")
                        ), 
                        jsonObject(
                            jsonProperty("op", "remove"),
                            jsonProperty("path", "/metadata")
                        )
                    )))
                .build())
            .build());

    }
}

resources:
  # Example: Using read_search with search_patch to transform API responses
  #
  # When an API returns objects in a wrapped structure or with extra metadata,
  # you can use search_patch to transform the response to match your desired state.
  userWithSearchPatch:
    type: restapi:Object
    name: user_with_search_patch
    properties:
      path: /api/users
      data:
        fn::toJSON:
          id: user123
          name: John Doe
          email: john@example.com
      readSearch:
        searchKey: email
        searchValue: john@example.com
        searchPatch:
          fn::toJSON:
            - op: copy
              from: /data/id
              path: /id
            - op: copy
              from: /data/name
              path: /name
            - op: copy
              from: /data/email
              path: /email
            - op: remove
              path: /data
            - op: remove
              path: /metadata
  # Example: Remove server-generated fields from API responses
  cleanResponse:
    type: restapi:Object
    name: clean_response
    properties:
      path: /api/resources
      data:
        fn::toJSON:
          id: resource456
          name: My Resource
      readSearch:
        searchKey: id
        searchValue: '{id}'
        searchPatch:
          fn::toJSON:
            - op: remove
              path: /createdAt
            - op: remove
              path: /updatedAt
            - op: remove
              path: /metadata

var objectResource = new Restapi.Object("objectResource", new()
{
    Data = "string",
    Path = "string",
    IgnoreChangesTos = new[]
    {
        "string",
    },
    IgnoreServerAdditions = false,
    DestroyData = "string",
    DestroyMethod = "string",
    DestroyPath = "string",
    ForceNews = new[]
    {
        "string",
    },
    IdAttribute = "string",
    IgnoreAllServerChanges = false,
    CreateMethod = "string",
    Debug = false,
    ObjectId = "string",
    CreatePath = "string",
    QueryString = "string",
    ReadData = "string",
    ReadMethod = "string",
    ReadPath = "string",
    ReadSearch = new Restapi.Inputs.ObjectReadSearchArgs
    {
        SearchKey = "string",
        SearchValue = "string",
        QueryString = "string",
        ResultsKey = "string",
        SearchData = "string",
        SearchPatch = "string",
    },
    UpdateData = "string",
    UpdateMethod = "string",
    UpdatePath = "string",
});

example, err := restapi.NewObject(ctx, "objectResource", &restapi.ObjectArgs{
	Data: pulumi.String("string"),
	Path: pulumi.String("string"),
	IgnoreChangesTos: pulumi.StringArray{
		pulumi.String("string"),
	},
	IgnoreServerAdditions: pulumi.Bool(false),
	DestroyData:           pulumi.String("string"),
	DestroyMethod:         pulumi.String("string"),
	DestroyPath:           pulumi.String("string"),
	ForceNews: pulumi.StringArray{
		pulumi.String("string"),
	},
	IdAttribute:            pulumi.String("string"),
	IgnoreAllServerChanges: pulumi.Bool(false),
	CreateMethod:           pulumi.String("string"),
	Debug:                  pulumi.Bool(false),
	ObjectId:               pulumi.String("string"),
	CreatePath:             pulumi.String("string"),
	QueryString:            pulumi.String("string"),
	ReadData:               pulumi.String("string"),
	ReadMethod:             pulumi.String("string"),
	ReadPath:               pulumi.String("string"),
	ReadSearch: &restapi.ObjectReadSearchArgs{
		SearchKey:   pulumi.String("string"),
		SearchValue: pulumi.String("string"),
		QueryString: pulumi.String("string"),
		ResultsKey:  pulumi.String("string"),
		SearchData:  pulumi.String("string"),
		SearchPatch: pulumi.String("string"),
	},
	UpdateData:   pulumi.String("string"),
	UpdateMethod: pulumi.String("string"),
	UpdatePath:   pulumi.String("string"),
})

var objectResource = new Object("objectResource", ObjectArgs.builder()
    .data("string")
    .path("string")
    .ignoreChangesTos("string")
    .ignoreServerAdditions(false)
    .destroyData("string")
    .destroyMethod("string")
    .destroyPath("string")
    .forceNews("string")
    .idAttribute("string")
    .ignoreAllServerChanges(false)
    .createMethod("string")
    .debug(false)
    .objectId("string")
    .createPath("string")
    .queryString("string")
    .readData("string")
    .readMethod("string")
    .readPath("string")
    .readSearch(ObjectReadSearchArgs.builder()
        .searchKey("string")
        .searchValue("string")
        .queryString("string")
        .resultsKey("string")
        .searchData("string")
        .searchPatch("string")
        .build())
    .updateData("string")
    .updateMethod("string")
    .updatePath("string")
    .build());

object_resource = restapi.Object("objectResource",
    data="string",
    path="string",
    ignore_changes_tos=["string"],
    ignore_server_additions=False,
    destroy_data="string",
    destroy_method="string",
    destroy_path="string",
    force_news=["string"],
    id_attribute="string",
    ignore_all_server_changes=False,
    create_method="string",
    debug=False,
    object_id="string",
    create_path="string",
    query_string="string",
    read_data="string",
    read_method="string",
    read_path="string",
    read_search={
        "search_key": "string",
        "search_value": "string",
        "query_string": "string",
        "results_key": "string",
        "search_data": "string",
        "search_patch": "string",
    },
    update_data="string",
    update_method="string",
    update_path="string")

const objectResource = new restapi.Object("objectResource", {
    data: "string",
    path: "string",
    ignoreChangesTos: ["string"],
    ignoreServerAdditions: false,
    destroyData: "string",
    destroyMethod: "string",
    destroyPath: "string",
    forceNews: ["string"],
    idAttribute: "string",
    ignoreAllServerChanges: false,
    createMethod: "string",
    debug: false,
    objectId: "string",
    createPath: "string",
    queryString: "string",
    readData: "string",
    readMethod: "string",
    readPath: "string",
    readSearch: {
        searchKey: "string",
        searchValue: "string",
        queryString: "string",
        resultsKey: "string",
        searchData: "string",
        searchPatch: "string",
    },
    updateData: "string",
    updateMethod: "string",
    updatePath: "string",
});

type: restapi:Object
properties:
    createMethod: string
    createPath: string
    data: string
    debug: false
    destroyData: string
    destroyMethod: string
    destroyPath: string
    forceNews:
        - string
    idAttribute: string
    ignoreAllServerChanges: false
    ignoreChangesTos:
        - string
    ignoreServerAdditions: false
    objectId: string
    path: string
    queryString: string
    readData: string
    readMethod: string
    readPath: string
    readSearch:
        queryString: string
        resultsKey: string
        searchData: string
        searchKey: string
        searchPatch: string
        searchValue: string
    updateData: string
    updateMethod: string
    updatePath: string