@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/errors/DynamoDb_Error.res.mjs

@@ -0,0 +1,86 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Util_Error$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Error.res.mjs";
+import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+
+function isTransient(err) {
+  switch (err.TAG) {
+    case "Transient" :
+      return true;
+    case "StaleState" :
+    case "Permanent" :
+      return false;
+  }
+}
+
+function classify(err) {
+  let name = Stdlib_Option.getOr(Stdlib_JsExn.name(err), "");
+  if (name === "TransactionCanceledException") {
+    let reasons = Stdlib_Option.getOr(err.CancellationReasons, []);
+    let codeMatches = code => reasons.some(r => Stdlib_Option.getOr(r.Code, "") === code);
+    let msg = Util_Error$ReventlessCore.message(undefined, err);
+    if (codeMatches("ConditionalCheckFailed")) {
+      return {
+        TAG: "StaleState",
+        _0: msg
+      };
+    } else if (codeMatches("TransactionConflict") || codeMatches("ProvisionedThroughputExceeded") || codeMatches("ThrottlingError")) {
+      return {
+        TAG: "Transient",
+        _0: msg
+      };
+    } else {
+      return {
+        TAG: "Permanent",
+        _0: msg
+      };
+    }
+  }
+  let match = DynamoDb_DocumentClient$AwsSdk.PutError.classify(err);
+  switch (match.TAG) {
+    case "ConditionCheckFailedException" :
+      return {
+        TAG: "StaleState",
+        _0: Util_Error$ReventlessCore.message(undefined, err)
+      };
+    case "InternalServerError" :
+    case "ProvisionedThroughputExceededException" :
+    case "RequestLimitExceeded" :
+    case "TransactionConflictException" :
+      return {
+        TAG: "Transient",
+        _0: Util_Error$ReventlessCore.message(undefined, err)
+      };
+    default:
+      let msg$1 = Util_Error$ReventlessCore.messageFromUnknown(err, "DynamoDB error");
+      if (msg$1.includes("ThrottlingException") || msg$1.includes("ServiceUnavailable") || msg$1.includes("InternalServerError")) {
+        return {
+          TAG: "Transient",
+          _0: msg$1
+        };
+      } else {
+        return {
+          TAG: "Permanent",
+          _0: msg$1
+        };
+      }
+  }
+}
+
+function message(err) {
+  return err._0;
+}
+
+let retrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(500))), Schedule.recurs(5)), isTransient);
+
+export {
+  isTransient,
+  classify,
+  message,
+  retrySchedule,
+}
+/* retrySchedule Not a pure module */

package/src/errors/Kinesis_Error.res

@@ -0,0 +1,36 @@
+type t =
+  | Transient(string)
+  | Permanent(string)
+
+let isTransient = err =>
+  switch err {
+  | Transient(_) => true
+  | Permanent(_) => false
+  }
+
+let classify = (err: unknown): t => {
+  let msg = ReventlessCore.Util.Error.messageFromUnknown(err, "Kinesis error")
+  if (
+    msg->String.includes("ThrottlingException") ||
+    msg->String.includes("ProvisionedThroughputExceededException") ||
+    msg->String.includes("ServiceUnavailable") ||
+    msg->String.includes("InternalFailureException") ||
+    msg->String.includes("InternalServerError") ||
+    msg->String.includes("RequestLimitExceeded")
+  ) {
+    Transient(msg)
+  } else {
+    Permanent(msg)
+  }
+}
+
+let message = err =>
+  switch err {
+  | Transient(msg) | Permanent(msg) => msg
+  }
+
+let retrySchedule: Schedule.t<(Duration.t, int), t, unit> =
+  Schedule.exponential(Duration.millis(1000))
+  ->Schedule.jittered
+  ->Schedule.intersect(Schedule.recurs(5))
+  ->Schedule.whileInput(isTransient)

package/src/errors/Kinesis_Error.res.mjs

@@ -0,0 +1,38 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Util_Error$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Error.res.mjs";
+
+function isTransient(err) {
+  return err.TAG === "Transient";
+}
+
+function classify(err) {
+  let msg = Util_Error$ReventlessCore.messageFromUnknown(err, "Kinesis error");
+  if (msg.includes("ThrottlingException") || msg.includes("ProvisionedThroughputExceededException") || msg.includes("ServiceUnavailable") || msg.includes("InternalFailureException") || msg.includes("InternalServerError") || msg.includes("RequestLimitExceeded")) {
+    return {
+      TAG: "Transient",
+      _0: msg
+    };
+  } else {
+    return {
+      TAG: "Permanent",
+      _0: msg
+    };
+  }
+}
+
+function message(err) {
+  return err._0;
+}
+
+let retrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(1000))), Schedule.recurs(5)), isTransient);
+
+export {
+  isTransient,
+  classify,
+  message,
+  retrySchedule,
+}
+/* retrySchedule Not a pure module */

package/src/errors/SNS_Error.res

@@ -0,0 +1,34 @@
+type t =
+  | Transient(string)
+  | Permanent(string)
+
+let isTransient = err =>
+  switch err {
+  | Transient(_) => true
+  | Permanent(_) => false
+  }
+
+let classify = (err: unknown): t => {
+  let msg = ReventlessCore.Util.Error.messageFromUnknown(err, "SNS error")
+  if (
+    msg->String.includes("ThrottlingException") ||
+    msg->String.includes("ServiceUnavailable") ||
+    msg->String.includes("InternalServerError") ||
+    msg->String.includes("RequestLimitExceeded")
+  ) {
+    Transient(msg)
+  } else {
+    Permanent(msg)
+  }
+}
+
+let message = err =>
+  switch err {
+  | Transient(msg) | Permanent(msg) => msg
+  }
+
+let retrySchedule: Schedule.t<(Duration.t, int), t, unit> =
+  Schedule.exponential(Duration.millis(1000))
+  ->Schedule.jittered
+  ->Schedule.intersect(Schedule.recurs(5))
+  ->Schedule.whileInput(isTransient)

package/src/errors/SNS_Error.res.mjs

@@ -0,0 +1,38 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Util_Error$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Error.res.mjs";
+
+function isTransient(err) {
+  return err.TAG === "Transient";
+}
+
+function classify(err) {
+  let msg = Util_Error$ReventlessCore.messageFromUnknown(err, "SNS error");
+  if (msg.includes("ThrottlingException") || msg.includes("ServiceUnavailable") || msg.includes("InternalServerError") || msg.includes("RequestLimitExceeded")) {
+    return {
+      TAG: "Transient",
+      _0: msg
+    };
+  } else {
+    return {
+      TAG: "Permanent",
+      _0: msg
+    };
+  }
+}
+
+function message(err) {
+  return err._0;
+}
+
+let retrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(1000))), Schedule.recurs(5)), isTransient);
+
+export {
+  isTransient,
+  classify,
+  message,
+  retrySchedule,
+}
+/* retrySchedule Not a pure module */

package/src/errors/SQS_Error.res

@@ -0,0 +1,40 @@
+type t =
+  | Transient(string)
+  | Permanent(string)
+
+let isTransient = err =>
+  switch err {
+  | Transient(_) => true
+  | Permanent(_) => false
+  }
+
+let classify = (err: unknown): t => {
+  let msg = ReventlessCore.Util.Error.messageFromUnknown(err, "SQS error")
+  if (
+    msg->String.includes("ThrottlingException") ||
+    msg->String.includes("ServiceUnavailable") ||
+    msg->String.includes("InternalServerError") ||
+    msg->String.includes("RequestLimitExceeded")
+  ) {
+    Transient(msg)
+  } else {
+    Permanent(msg)
+  }
+}
+
+let message = err =>
+  switch err {
+  | Transient(msg) | Permanent(msg) => msg
+  }
+
+let retrySchedule: Schedule.t<(Duration.t, int), t, unit> =
+  Schedule.exponential(Duration.millis(1000))
+  ->Schedule.jittered
+  ->Schedule.intersect(Schedule.recurs(5))
+  ->Schedule.whileInput(isTransient)
+
+let sendRetrySchedule: Schedule.t<(Duration.t, int), t, unit> =
+  Schedule.exponential(Duration.millis(3000))
+  ->Schedule.jittered
+  ->Schedule.intersect(Schedule.recurs(10))
+  ->Schedule.whileInput(isTransient)

package/src/errors/SQS_Error.res.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Util_Error$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Error.res.mjs";
+
+function isTransient(err) {
+  return err.TAG === "Transient";
+}
+
+function classify(err) {
+  let msg = Util_Error$ReventlessCore.messageFromUnknown(err, "SQS error");
+  if (msg.includes("ThrottlingException") || msg.includes("ServiceUnavailable") || msg.includes("InternalServerError") || msg.includes("RequestLimitExceeded")) {
+    return {
+      TAG: "Transient",
+      _0: msg
+    };
+  } else {
+    return {
+      TAG: "Permanent",
+      _0: msg
+    };
+  }
+}
+
+function message(err) {
+  return err._0;
+}
+
+let retrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(1000))), Schedule.recurs(5)), isTransient);
+
+let sendRetrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(3000))), Schedule.recurs(10)), isTransient);
+
+export {
+  isTransient,
+  classify,
+  message,
+  retrySchedule,
+  sendRetrySchedule,
+}
+/* retrySchedule Not a pure module */

package/src/plugin/cloner/ClonerRunner.res

@@ -0,0 +1 @@
+module Fargate = ClonerRunner_Fargate

package/src/plugin/cloner/ClonerRunner.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Fargate;
+
+export {
+  Fargate,
+}
+/* No side effect */

package/src/plugin/cloner/ClonerRunner_Fargate.res

@@ -0,0 +1,362 @@
+open PulumiAws
+
+type api = Types.AppSync.api
+
+let make: ReventlessCore.Cloner.Adapter.runnerMaker<api> = (
+  ~name,
+  ~api: api,
+  ~fullQualifiedStackName,
+  ~reventlessCiSecretUrn,
+  ~secretUrns,
+  ~opts=?,
+) => {
+  let cluster = {
+    open ECS.Cluster
+    make(~name, ~opts?)
+  }
+
+  let taskExecutionRole = IAM.Role.make(
+    ~name=name ++ "TaskExecution",
+    ~args={
+      IAM.Role.assumeRolePolicy: IAM.Policy.assumeRolePolicy(
+        name,
+        "ecs-tasks.amazonaws.com",
+      )->Pulumi.Input.make,
+      inlinePolicies: [
+        IAM.InlinePolicy.makeForActions(
+          ~name="clonerTask",
+          ~actions=["logs:PutLogEvents", "logs:CreateLogGroup", "logs:CreateLogStream"],
+        ),
+      ]->Pulumi.Input.make,
+    },
+  )
+
+  let secretsManagerPolicyDocument = PolicyDocument.make(
+    ~id=name ++ "SecretsManagerPolicy",
+    ~statements=[
+      {
+        sid: "AllowManageSecrets",
+        effect: PolicyDocument.Allow,
+        actions: PolicyDocument.Actions([
+          "secretsmanager:GetRandomPassword",
+          "secretsmanager:GetResourcePolicy",
+          "secretsmanager:GetSecretValue",
+          "secretsmanager:DescribeSecret",
+          "secretsmanager:ListSecretVersionIds",
+        ]),
+      },
+    ],
+  )
+
+  let secretsManagerAccessPolicy = IAM.Policy.make(
+    ~name="secretsManagerAccess",
+    ~args={
+      policy: secretsManagerPolicyDocument
+      ->PolicyDocument.toJsonString
+      ->Pulumi.Input.make,
+    },
+  )
+
+  let taskRunnerPolicyDocument = PolicyDocument.make(
+    ~id=name ++ "TaskRunnerPolicy",
+    ~statements=[
+      {
+        sid: "AllowRunTask",
+        effect: PolicyDocument.Allow,
+        actions: PolicyDocument.Actions(["ecs:RunTask", "iam:PassRole"]),
+      },
+    ],
+  )
+
+  let taskRunnerPolicy = IAM.Policy.make(
+    ~name="taskRunner",
+    ~args={
+      policy: taskRunnerPolicyDocument
+      ->PolicyDocument.toJsonString
+      ->Pulumi.Input.make,
+    },
+  )
+
+  let _ = {
+    open IAM.RolePolicyAttachment
+    make(
+      ~name="ClonerTaskExecutionSecretsManagerAccess",
+      ~args={
+        policyArn: secretsManagerAccessPolicy.arn->Pulumi.Output.asInput,
+        role: taskExecutionRole.id->Pulumi.Output.asInput,
+      },
+      ~opts,
+    )
+  }
+
+  let entryPointCode = `import { ECSClient, RunTaskCommand } from "@aws-sdk/client-ecs";
+const client = new ECSClient();
+export const handler = async (event) => {
+  const environment = Object.fromEntries([
+    ["REVENTLESS_CORE_STACK", process.env.STACK_ORG + "/" + process.env.STACK_PROJECT + "/" + process.env.STACK_STACK],
+    ["RESTORE_DATE_TIME", event.restoreDateTime],
+  ]);
+  console.log("clone: requested by user " + event.meta.user + " from ip " + event.meta.ip);
+  await client.send(new RunTaskCommand({
+    taskDefinition: process.env.TASK_DEFINITION_ARN,
+    cluster: process.env.CLUSTER_ARN,
+    launchType: "FARGATE",
+    networkConfiguration: { awsvpcConfiguration: { subnets: JSON.parse(process.env.SUBNETS) } },
+    overrides: {
+      containerOverrides: [{
+        name: "reventless-ci",
+        command: ["reventless-ci", "clone-environment"],
+        environment: environment,
+      }],
+    },
+  }));
+};`
+  let clonerArchiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
+  clonerArchiveContents->Dict.set(
+    "index.mjs",
+    Pulumi.Asset.stringAsset(entryPointCode)->Pulumi.Archive.assetToAssetOrArchive,
+  )
+  let code = Pulumi.Archive.assetArchive(clonerArchiveContents)
+  let sourceCodeHash = Util_Bundle.hashString(entryPointCode)
+
+  let layers =
+    Lambda.reventlessLayerArn
+    ->Option.map(arn => [arn->Pulumi.Input.make])
+    ->Option.getOr([])
+    ->Pulumi.Input.make
+
+  let vpcStackName = Pulumi.Config.make(Some("vpc"))->Pulumi.Config.get("stack")->Option.getOrThrow
+  let vpcConfig = Util_Vpc.getVpcConfig(~stackName=vpcStackName, ~outputName="vpc")
+
+  let secrets =
+    secretUrns
+    ->Array.map(urn =>
+      PulumiAws.GetSecretVersion.getSecretNames(urn)->Pulumi.Output.apply(names =>
+        names->Array.map(name => {ECS.Container.name, valueFrom: `${urn}:${name}::`})
+      )
+    )
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(s => Array.flat(s))
+
+  let resources =
+    (secretsManagerAccessPolicy.arn, taskRunnerPolicy.arn, vpcConfig, secrets)
+    ->Pulumi.Output.all4
+    ->Pulumi.Output.apply(((
+      _secretsManagerAccessPolicyArn,
+      _taskRunnerPolicyArn,
+      vpcConfig,
+      secrets,
+    )) => {
+      let containerDefinitions = [
+        {
+          ECS.Container.name: "reventless-ci",
+          image: Pulumi.Config.make(Some("ci"))->Pulumi.Config.require("image"),
+          cpu: 1024,
+          memory: 4096,
+          repositoryCredentials: {credentialsParameter: reventlessCiSecretUrn},
+          secrets,
+          logConfiguration: {
+            logDriver: "awslogs",
+            options: {
+              awslogsCreateGroup: true,
+              awslogsGroup: "/aws/ecs/reventless-cloner",
+              awslogsRegion: Pulumi.Config.make(Some("aws"))->Pulumi.Config.require("region"),
+              awslogsStreamPrefix: "reventless-cloner",
+            },
+          },
+          ulimits: [
+            {
+              name: #nofile,
+              hardLimit: 1048576,
+              softLimit: 1048576,
+            },
+          ],
+        },
+      ]
+
+      let taskDefinition = ECS.TaskDefinition.make(
+        ~name,
+        ~args={
+          family: name->Pulumi.Input.make,
+          containerDefinitions: containerDefinitions
+          ->JSON.stringifyAny
+          ->Option.getOrThrow
+          ->Pulumi.Input.make,
+          executionRoleArn: taskExecutionRole.arn->Pulumi.Output.asInput,
+          memory: "4096"->Pulumi.Input.make,
+          cpu: "1024"->Pulumi.Input.make,
+          requiresCompatibilities: ["FARGATE"],
+          networkMode: #awsvpc,
+        },
+        ~opts?,
+      )
+
+      let lambdaRole = PulumiAws.IAM.Role.makeWithDefaultPolicy(
+        ~name,
+        ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+        ~opts?,
+      )
+
+      let lambda = Lambda.Function.make(
+        ~name,
+        ~args={
+          handler: "index.handler"->Pulumi.Input.make,
+          runtime: "nodejs22.x"->Pulumi.Input.make,
+          code: code->Pulumi.Input.make,
+          sourceCodeHash: sourceCodeHash->Pulumi.Input.make,
+          role: lambdaRole.arn->Pulumi.Output.asInput,
+          memorySize: 1024->Pulumi.Input.make,
+          timeout: 180->Pulumi.Input.make,
+          layers,
+          tags: AWS.Tags.make(~name, ReventlessCore.Cloner.componentType),
+          environment: (
+            {
+              Lambda.Function.variables: Dict.fromArray([
+                ("TASK_DEFINITION_ARN", taskDefinition.arn->Pulumi.Output.asInput),
+                ("CLUSTER_ARN", cluster.arn->Pulumi.Output.asInput),
+                (
+                  "STACK_ORG",
+                  fullQualifiedStackName.organization->Pulumi.Input.make,
+                ),
+                (
+                  "STACK_PROJECT",
+                  fullQualifiedStackName.project->Pulumi.Input.make,
+                ),
+                ("STACK_STACK", fullQualifiedStackName.stack->Pulumi.Input.make),
+                (
+                  "SUBNETS",
+                  vpcConfig.subnetIds
+                  ->JSON.stringifyAny
+                  ->Option.getOr("[]")
+                  ->Pulumi.Input.make,
+                ),
+                ("Environment", Pulumi.Pulumi.getStackName()->Pulumi.Input.make),
+              ]),
+            }: Lambda.Function.functionEnvironment
+          )->Pulumi.Input.make,
+        },
+        ~opts?,
+      )
+      let _ = lambda.arn->Pulumi.Output.apply(arn => {
+        let appsyncInvokeLambdaPolicyDocument = PulumiAws.PolicyDocument.make(
+          ~id=name ++ "AppSyncInvokePolicy",
+          ~statements=[
+            {
+              sid: "AllowAppSyncInvoke",
+              effect: PulumiAws.PolicyDocument.Allow,
+              actions: PulumiAws.PolicyDocument.Action("lambda:InvokeFunction"),
+              resources: PulumiAws.PolicyDocument.Resource(arn),
+              principal: PulumiAws.PolicyDocument.Principals({
+                service: PulumiAws.PolicyDocument.PrincipalId(AWS.AppSync.principal),
+              }),
+            },
+          ],
+        )
+
+        let lambdaPolicyDocument = PulumiAws.PolicyDocument.mergePolicyDocuments(
+          name ++ "LambdaPolicy",
+          [
+            PulumiAws.Lambda.defaultLoggingPolicyDocument,
+            appsyncInvokeLambdaPolicyDocument,
+            secretsManagerPolicyDocument,
+            taskRunnerPolicyDocument,
+          ],
+        )
+
+        lambdaRole.id->Pulumi.Output.apply(
+          lambdaRoleId => {
+            let _lambdaRolePolicy = PulumiAws.IAM.RolePolicy.make(
+              ~name=name ++ "LambdaRolePolicy",
+              ~args={
+                policy: lambdaPolicyDocument
+                ->Pulumi.Output.apply(lambdaPolicyDocument => lambdaPolicyDocument)
+                ->Pulumi.Output.asInput,
+                role: lambdaRoleId->Pulumi.Input.make,
+              },
+            )
+          },
+        )
+      })
+
+      let dataSourceRole = IAM.Role.makeWithDefaultPolicy(
+        ~name=name ++ "DS",
+        ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+        ~opts?,
+      )
+
+      let _dataSourcePolicy = {
+        open IAM
+        RolePolicy.make(
+          ~name=name ++ "DS",
+          ~args={
+            policy: lambda.arn
+            ->Pulumi.Output.apply(lambdaArn =>
+              //RolePolicy.generatePolicy([lambdaArn], "lambda:InvokeFunction")
+              PolicyDocument.make(
+                ~id=name ++ "LambdaPolicy",
+                ~statements=[
+                  {
+                    sid: "AllowInvokeLambda",
+                    effect: PolicyDocument.Allow,
+                    actions: PolicyDocument.Action("lambda:InvokeFunction"),
+                    resources: PolicyDocument.Resource(lambdaArn),
+                  },
+                ],
+              )->PolicyDocument.toJsonString
+            )
+            ->Pulumi.Output.asInput,
+            role: dataSourceRole.id->Pulumi.Output.asInput,
+          },
+          ~opts?,
+        )
+      }
+
+      let dataSource = AppSync.DataSource.make(
+        ~name,
+        ~args={
+          AppSync.DataSource.type_: AWS_LAMBDA,
+          apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+          lambdaConfig: {
+            AppSync.DataSource.functionArn: lambda.arn->Pulumi.Output.asInput,
+          }->Pulumi.Input.make,
+          serviceRoleArn: dataSourceRole.arn->Pulumi.Output.asInput,
+        },
+        ~opts,
+      )
+
+      let invokeCloneCode =
+        `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  return {
+    operation: 'Invoke',
+    payload: {
+      restoreDateTime: ctx.args.restoreDateTime,
+      meta: {
+        ip: ctx.identity.sourceIp,
+        user: ctx.identity.username
+      }
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`->Pulumi.Input.make
+
+      let field = ReventlessCore.AdminApi.cloneMutationEntry.fieldNames->Array.getUnsafe(0)
+      let resolver = AppSync_Resolver_Retrying.makeUnitJsResolver(
+        ~name=field,
+        ~api,
+        ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+        ~type_="Mutation"->Pulumi.Input.make,
+        ~field=field->Pulumi.Input.make,
+        ~code=invokeCloneCode,
+        ~opts?,
+      )
+
+      [resolver->Util_AppSync.toResourceNative]
+    })
+
+  {resources: resources}
+}