@reventlessdev/rescript-pulumi-aws 2.4.0-alpha.43

package/src/AppSync/AppSync_Resolver.res

@@ -0,0 +1,229 @@
+/** @pulumi/aws/appsync/Resolver
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/appsync/resolver
+*/
+type t = {
+  id: Pulumi.Output.t<string>,
+  arn: Pulumi.Output.t<string>,
+  @as("type") type_: Pulumi.Output.t<string>,
+  field: Pulumi.Output.t<string>,
+}
+
+module Functions = AppSync_Resolver_Functions
+
+type pipelineConfig = {functions: array<Pulumi.Input.t<string>>}
+
+type kind = UNIT | PIPELINE
+
+type runtime = {
+  name: string,
+  runtimeVersion: string,
+}
+
+/** APPSYNC_JS runtime v1.0.0 — use with `code` instead of VTL templates. */
+let appsyncJs: runtime = {name: "APPSYNC_JS", runtimeVersion: "1.0.0"}
+
+type args = {
+  apiId: Pulumi.Input.t<string>,
+  dataSource?: Pulumi.Input.t<string>,
+  field: Pulumi.Input.t<string>,
+  requestTemplate?: Pulumi.Input.t<string>,
+  responseTemplate?: Pulumi.Input.t<string>,
+  @as("type") type_: Pulumi.Input.t<string>,
+  kind?: kind,
+  pipelineConfig?: Pulumi.Input.t<pipelineConfig>,
+  /** Bundled JS resolver code (APPSYNC_JS runtime). Replaces requestTemplate/responseTemplate. */
+  code?: Pulumi.Input.t<string>,
+  /** Runtime config — set to appsyncJs when using code. */
+  runtime?: Pulumi.Input.t<runtime>,
+}
+
+@module("@pulumi/aws") @scope("appsync") @new
+external make: (~name: string, ~args: args, ~opts: option<Pulumi.CustomResourceOptions.t>=?) => t =
+  "Resolver"
+
+/*
+
+type kind =
+  | Unit
+  | Pipeline(array(AppSync_Function.t));
+
+
+type kind =
+  | Unit
+  | Pipeline(array(AppSync_Function.t));
+let makeHelper =
+    (
+      ~name,
+      ~api: Pulumi.Output.t(PulumiAws.AppSync_GraphQLApi.t),
+      ~dataSourceName,
+      ~_type,
+      ~field,
+      ~requestTemplate,
+      ~responseTemplate,
+      ~kind,
+      ~opts=?,
+      _,
+    ) => {
+  let (kind, pipelineConfig) =
+    switch (kind) {
+    | Unit => (`UNIT, None)
+    | Pipeline(functions) => (
+        `PIPELINE,
+        Some(
+          PipelineConfig.make(
+            ~functions=
+              functions->Array.map(f =>
+                f##functionId->Pulumi.Output.asInput
+              ),
+          )
+          ->Pulumi.Input.make,
+        ),
+      )
+    };
+
+  make(
+    ~name,
+    ~args=
+      Args.make(
+        ~apiId=
+          api->Pulumi.Output.flatMap(api => api##id)->Pulumi.Output.asInput,
+        ~dataSource=dataSourceName,
+        ~field,
+        ~requestTemplate,
+        ~responseTemplate,
+        ~kind,
+        ~pipelineConfig?,
+        ~_type,
+        (),
+      ),
+    ~opts=
+      opts->Option.map(opts => {
+        let optsWithDelete = Object.assign(Object.make(), opts);
+        optsWithDelete##deleteBeforeReplace #= Some(true);
+        optsWithDelete;
+      }),
+  );
+};
+*/
+
+let makeUnitResolver = (
+  ~name,
+  ~api: Pulumi.Output.t<PulumiAws.AppSync_GraphQLApi.t>,
+  ~dataSourceName,
+  ~type_,
+  ~field,
+  ~requestTemplate,
+  ~responseTemplate,
+  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
+) =>
+  make(
+    ~name,
+    ~args={
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      dataSource: dataSourceName,
+      field,
+      requestTemplate,
+      responseTemplate,
+      kind: UNIT,
+      type_,
+    },
+    ~opts=Some(
+      switch opts {
+      | Some(opts) => {...opts, deleteBeforeReplace: true}
+      | None => {deleteBeforeReplace: true}
+      },
+    ),
+  )
+
+let makePipelineResolver = (
+  ~name,
+  ~api: Pulumi.Output.t<PulumiAws.AppSync_GraphQLApi.t>,
+  ~type_,
+  ~field,
+  ~requestTemplate,
+  ~responseTemplate,
+  ~functions: array<AppSync_Function.t>,
+  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
+) =>
+  make(
+    ~name,
+    ~args={
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      field,
+      requestTemplate,
+      responseTemplate,
+      kind: PIPELINE,
+      pipelineConfig: {
+        functions: functions->Array.map(f => f.functionId->Pulumi.Output.asInput),
+      }->Pulumi.Input.make,
+      type_,
+    },
+    ~opts=Some(
+      switch opts {
+      | Some(opts) => {...opts, deleteBeforeReplace: true}
+      | None => {deleteBeforeReplace: true}
+      },
+    ),
+  )
+
+/** Create a unit resolver using the APPSYNC_JS runtime.
+    Pass bundled JS code via `~code` instead of VTL request/response templates. */
+let makeUnitJsResolver = (
+  ~name,
+  ~api: Pulumi.Output.t<PulumiAws.AppSync_GraphQLApi.t>,
+  ~dataSourceName,
+  ~type_,
+  ~field,
+  ~code: Pulumi.Input.t<string>,
+  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
+) =>
+  make(
+    ~name,
+    ~args={
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      dataSource: dataSourceName,
+      field,
+      code,
+      runtime: appsyncJs->Pulumi.Input.make,
+      kind: UNIT,
+      type_,
+    },
+    ~opts=Some(
+      switch opts {
+      | Some(opts) => {...opts, deleteBeforeReplace: true}
+      | None => {deleteBeforeReplace: true}
+      },
+    ),
+  )
+
+/** Create a pipeline resolver using the APPSYNC_JS runtime.
+    Pass bundled JS code for the before/after steps via `~code`. */
+let makePipelineJsResolver = (
+  ~name,
+  ~api: Pulumi.Output.t<PulumiAws.AppSync_GraphQLApi.t>,
+  ~type_,
+  ~field,
+  ~code: Pulumi.Input.t<string>,
+  ~functions: array<AppSync_Function.t>,
+  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
+) =>
+  make(
+    ~name,
+    ~args={
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      field,
+      code,
+      runtime: appsyncJs->Pulumi.Input.make,
+      kind: PIPELINE,
+      pipelineConfig: {
+        functions: functions->Array.map(f => f.functionId->Pulumi.Output.asInput),
+      }->Pulumi.Input.make,
+      type_,
+    },
+    ~opts=Some(
+      switch opts {
+      | Some(opts) => {...opts, deleteBeforeReplace: true}
+      | None => {deleteBeforeReplace: true}
+      },
+    ),
+  )

package/src/AppSync/AppSync_Resolver.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+
+let appsyncJs = {
+  name: "APPSYNC_JS",
+  runtimeVersion: "1.0.0"
+};
+
+function makeUnitResolver(name, api, dataSourceName, type_, field, requestTemplate, responseTemplate, opts) {
+  let tmp;
+  if (opts !== undefined) {
+    let newrecord = {...opts};
+    newrecord.deleteBeforeReplace = true;
+    tmp = newrecord;
+  } else {
+    tmp = {
+      deleteBeforeReplace: true
+    };
+  }
+  return new (Aws.appsync.Resolver)(name, {
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    dataSource: dataSourceName,
+    field: field,
+    requestTemplate: requestTemplate,
+    responseTemplate: responseTemplate,
+    type: type_,
+    kind: "UNIT"
+  }, tmp);
+}
+
+function makePipelineResolver(name, api, type_, field, requestTemplate, responseTemplate, functions, opts) {
+  let tmp;
+  if (opts !== undefined) {
+    let newrecord = {...opts};
+    newrecord.deleteBeforeReplace = true;
+    tmp = newrecord;
+  } else {
+    tmp = {
+      deleteBeforeReplace: true
+    };
+  }
+  return new (Aws.appsync.Resolver)(name, {
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    field: field,
+    requestTemplate: requestTemplate,
+    responseTemplate: responseTemplate,
+    type: type_,
+    kind: "PIPELINE",
+    pipelineConfig: {
+      functions: functions.map(f => f.functionId)
+    }
+  }, tmp);
+}
+
+function makeUnitJsResolver(name, api, dataSourceName, type_, field, code, opts) {
+  let tmp;
+  if (opts !== undefined) {
+    let newrecord = {...opts};
+    newrecord.deleteBeforeReplace = true;
+    tmp = newrecord;
+  } else {
+    tmp = {
+      deleteBeforeReplace: true
+    };
+  }
+  return new (Aws.appsync.Resolver)(name, {
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    dataSource: dataSourceName,
+    field: field,
+    type: type_,
+    kind: "UNIT",
+    code: code,
+    runtime: appsyncJs
+  }, tmp);
+}
+
+function makePipelineJsResolver(name, api, type_, field, code, functions, opts) {
+  let tmp;
+  if (opts !== undefined) {
+    let newrecord = {...opts};
+    newrecord.deleteBeforeReplace = true;
+    tmp = newrecord;
+  } else {
+    tmp = {
+      deleteBeforeReplace: true
+    };
+  }
+  return new (Aws.appsync.Resolver)(name, {
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    field: field,
+    type: type_,
+    kind: "PIPELINE",
+    pipelineConfig: {
+      functions: functions.map(f => f.functionId)
+    },
+    code: code,
+    runtime: appsyncJs
+  }, tmp);
+}
+
+let Functions;
+
+export {
+  Functions,
+  appsyncJs,
+  makeUnitResolver,
+  makePipelineResolver,
+  makeUnitJsResolver,
+  makePipelineJsResolver,
+}
+/* @pulumi/aws Not a pure module */

package/src/AppSync/AppSync_ResolverRuntime.res

@@ -0,0 +1,214 @@
+/** Bindings for @aws-appsync/utils and AppSync JS resolver context types.
+    Used in resolver source files compiled to APPSYNC_JS — not Pulumi deploy-time code.
+
+    Generated JS uses `import * as X from "@aws-appsync/utils"` which is equivalent to
+    the named-import form `import { util, runtime } from "@aws-appsync/utils"` since
+    AppSync provides the module as an object with named exports. When bundled with
+    esbuild (--external:@aws-appsync/utils), the import is preserved for AppSync runtime.
+*/
+
+// ---------------------------------------------------------------------------
+// Context types
+// ---------------------------------------------------------------------------
+
+type error = {
+  message: string,
+  @as("type") type_: string,
+}
+
+type cognitoIdentity = {
+  username: string,
+  sub: string,
+  sourceIp: array<string>,
+  claims: Dict.t<JSON.t>,
+}
+
+type info = {
+  fieldName: string,
+  parentTypeName: string,
+}
+
+/** AppSync JS resolver context object. 'args, 'source and 'result are parametric. */
+type ctx<'args, 'source, 'result> = {
+  args: 'args,
+  identity: cognitoIdentity,
+  result: 'result,
+  source: 'source,
+  error: Nullable.t<error>,
+  info: info,
+  stash: Dict.t<JSON.t>,
+}
+
+// ---------------------------------------------------------------------------
+// DynamoDB attribute types
+// ---------------------------------------------------------------------------
+
+/** Opaque DynamoDB typed attribute value (e.g. {S: "foo"}, {N: "42"}, {BOOL: true}). */
+type dynamoDbValue
+
+/** A map of DynamoDB attribute values — used in keys, attributeValues, etc. */
+type dynamoDbMap = Dict.t<dynamoDbValue>
+
+// ---------------------------------------------------------------------------
+// @aws-appsync/utils — util.dynamodb.*
+// ---------------------------------------------------------------------------
+
+module DynamoDB = {
+  /** Auto-detect type and convert a JS value to a DynamoDB attribute value.
+      Equivalent to VTL's $util.dynamodb.toDynamoDBJson(val). */
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toDynamoDB: 'a => dynamoDbValue = "toDynamoDB"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toString: string => dynamoDbValue = "toString"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toNumber: float => dynamoDbValue = "toNumber"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toBoolean: bool => dynamoDbValue = "toBoolean"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toNull: unit => dynamoDbValue = "toNull"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toList: array<dynamoDbValue> => dynamoDbValue = "toList"
+
+  /** Convert a plain JS object's values to DynamoDB attribute values. */
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toMapValues: {..} => dynamoDbMap = "toMapValues"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toStringSet: array<string> => dynamoDbValue = "toStringSet"
+
+  @module("@aws-appsync/utils") @scope(("util", "dynamodb"))
+  external toNumberSet: array<float> => dynamoDbValue = "toNumberSet"
+}
+
+// ---------------------------------------------------------------------------
+// @aws-appsync/utils — util.*
+// ---------------------------------------------------------------------------
+
+module Util = {
+  /** Throw a resolver error. Calling this terminates the resolver. */
+  @module("@aws-appsync/utils") @scope("util")
+  external error: (string, ~errorType: string=?) => 'a = "error"
+
+  /** Throw an unauthorized error. Calling this terminates the resolver. */
+  @module("@aws-appsync/utils") @scope("util")
+  external unauthorized: unit => 'a = "unauthorized"
+
+  @module("@aws-appsync/utils") @scope("util")
+  external defaultIfNull: (Nullable.t<'a>, 'a) => 'a = "defaultIfNull"
+
+  @module("@aws-appsync/utils") @scope("util")
+  external defaultIfNullOrBlank: (Nullable.t<string>, string) => string = "defaultIfNullOrBlank"
+
+  @module("@aws-appsync/utils") @scope("util")
+  external isNull: Nullable.t<'a> => bool = "isNull"
+
+  @module("@aws-appsync/utils") @scope("util")
+  external isNullOrBlank: Nullable.t<string> => bool = "isNullOrBlank"
+
+  @module("@aws-appsync/utils") @scope("util")
+  external isList: 'a => bool = "isList"
+}
+
+// ---------------------------------------------------------------------------
+// @aws-appsync/utils — runtime.*
+// ---------------------------------------------------------------------------
+
+module Runtime = {
+  /** Return a value early from a resolver pipeline function, skipping remaining functions. */
+  @module("@aws-appsync/utils") @scope("runtime")
+  external earlyReturn: 'a => 'b = "earlyReturn"
+}
+
+// ---------------------------------------------------------------------------
+// DynamoDB request helpers (typed record shapes accepted by AppSync)
+// ---------------------------------------------------------------------------
+
+type expressionQuery = {
+  expression: string,
+  expressionNames: Dict.t<string>,
+  expressionValues: dynamoDbMap,
+}
+
+type expressionFilter = {
+  expression: string,
+  expressionNames: Dict.t<string>,
+  expressionValues: dynamoDbMap,
+}
+
+type getItemRequest = {
+  operation: string,
+  key: dynamoDbMap,
+}
+
+type queryRequest = {
+  operation: string,
+  query: expressionQuery,
+  index?: string,
+  limit?: int,
+  nextToken?: Nullable.t<string>,
+  scanIndexForward?: bool,
+  filter?: expressionFilter,
+}
+
+type putItemRequest = {
+  operation: string,
+  key: dynamoDbMap,
+  attributeValues: dynamoDbMap,
+}
+
+type updateItemRequest = {
+  operation: string,
+  key: dynamoDbMap,
+  update: {
+    expression: string,
+    expressionNames: Dict.t<string>,
+    expressionValues: dynamoDbMap,
+  },
+}
+
+type deleteItemRequest = {
+  operation: string,
+  key: dynamoDbMap,
+}
+
+type batchGetItemTable = {
+  keys: array<dynamoDbMap>,
+  consistentRead: bool,
+}
+
+type batchGetItemRequest = {
+  operation: string,
+  tables: Dict.t<batchGetItemTable>,
+}
+
+type scanRequest = {
+  operation: string,
+  limit?: int,
+  nextToken?: Nullable.t<string>,
+}
+
+type lambdaRequest = {
+  operation: string,
+  payload: JSON.t,
+}
+
+// ---------------------------------------------------------------------------
+// DynamoDB result helpers
+// ---------------------------------------------------------------------------
+
+/** Result shape from a DynamoDB Query or Scan operation. */
+type queryResult<'item> = {
+  items: array<'item>,
+  nextToken: Nullable.t<string>,
+  scannedCount: int,
+}
+
+/** Result shape from a DynamoDB BatchGetItem operation. */
+type batchGetItemResult<'item> = {
+  data: Dict.t<array<'item>>,
+}

package/src/AppSync/AppSync_ResolverRuntime.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let DynamoDB = {};
+
+let Util = {};
+
+let Runtime = {};
+
+export {
+  DynamoDB,
+  Util,
+  Runtime,
+}
+/* No side effect */