@reventlessdev/reventless-aws 3.0.0-alpha.210 → 3.0.0-alpha.212

package/src/adapter/Api/Platform_ApiFragments_Lambda.res

@@ -1,222 +0,0 @@
-// AWS resolver for the `Platform_ApiFragments` admin GraphQL query — the deploy-facing
-// push-status surface of the API-schema fragment registry.
-//
-// Backed by a Lambda DataSource that scans the ApiFragments StateViewSlice table (one item per
-// plugin name that has registered an API-schema fragment). The persisted state carries the same
-// status fields the in-memory adapter's `Platform_ApiFragmentsApi.encodeApiFragmentEntry`
-// projects (pluginId, apiTarget, pushStatus, pushMessage, pushedAt, registeredAt, updatedAt) —
-// all plain/bare-string primitives in DynamoDB — so the handler projects them as-is. The encoded
-// SDL is deliberately NOT exposed (the deploy waiter needs status only). The registry is keyed by
-// bare plugin name, so no name@version collapse is required (mirrors the ApiFragments slice).
-
-open PulumiAws
-
-let makeHandlerCode = (~tableName as _: string): string =>
-  `
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
-
-const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));
-const TABLE = process.env.API_FRAGMENT_RM_TABLE;
-
-export async function handler() {
-  if (!TABLE) {
-    console.error("Platform_ApiFragments: API_FRAGMENT_RM_TABLE env var not set");
-    return [];
-  }
-  const items = [];
-  let exclusiveStartKey;
-  do {
-    const out = await client.send(new ScanCommand({
-      TableName: TABLE,
-      Limit: 1000,
-      ExclusiveStartKey: exclusiveStartKey,
-    }));
-    if (out.Items) items.push(...out.Items);
-    exclusiveStartKey = out.LastEvaluatedKey;
-  } while (exclusiveStartKey);
-
-  // Status-only projection, byte-identical to Platform_ApiFragmentsApi.encodeApiFragmentEntry.
-  // The registry is keyed by bare plugin name; split("@")[0] is a defensive no-op against any
-  // legacy name@version row.
-  return items
-    .filter((item) => item && item.pluginId)
-    .map((item) => ({
-      pluginId: String(item.pluginId).split("@")[0],
-      apiTarget: item.apiTarget || "Domain",
-      pushStatus: item.pushStatus || "pending",
-      pushMessage: item.pushMessage || "",
-      pushedAt: item.pushedAt || "",
-      registeredAt: item.registeredAt || "",
-      updatedAt: item.updatedAt || "",
-    }));
-}
-`
-
-let resolverCode = `
-import { util } from '@aws-appsync/utils';
-export function request(ctx) {
-  return { operation: 'Invoke', payload: {} };
-}
-export function response(ctx) {
-  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  return ctx.result;
-}
-`->Pulumi.Input.make
-
-let make = (
-  ~api: Pulumi.Output.t<AppSync.GraphQLApi.t>,
-  ~apiFragmentRegistryTableName: Pulumi.Output.t<string>,
-  // Resolves when the admin-base schema push has completed and the API is ACTIVE
-  // (Platform_Admin.adminSchemaPushed). CreateResolver is gated on it so it never
-  // races StartSchemaCreation on this first-ever-deployed field.
-  ~schemaReady: Pulumi.Output.t<unit>,
-  ~opts: Pulumi.ComponentResource.options,
-) => {
-  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
-  let name = "PlatformApiFragments"
-
-  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
-    ~name=name ++ "Lambda",
-    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
-    ~opts,
-  )
-
-  let _ =
-    apiFragmentRegistryTableName->Pulumi.Output.apply(tableName => {
-      open PolicyDocument
-      let _rolePolicy = IAM.RolePolicy.make(
-        ~name=name ++ "LambdaPolicy",
-        ~args={
-          IAM.RolePolicy.policy: PolicyDocument.make(
-            ~id=name ++ "LambdaPolicy",
-            ~statements=[
-              {
-                sid: "AllowLambdaLogging",
-                effect: Allow,
-                actions: Action("logs:*"),
-                resources: Resource("arn:aws:logs:*:*:*"),
-              },
-              {
-                sid: "AllowScanApiFragmentsTable",
-                effect: Allow,
-                actions: Actions(["dynamodb:Scan"]),
-                resources: Resource("arn:aws:dynamodb:*:*:table/" ++ tableName),
-              },
-            ],
-          )
-          ->PolicyDocument.toJsonString
-          ->Pulumi.Input.make,
-          role: lambdaRole.id->Pulumi.Output.asInput,
-        },
-        ~opts,
-      )
-    })
-
-  let archiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
-  let handlerCodeStub = makeHandlerCode(~tableName="")
-  archiveContents->Dict.set(
-    "index.mjs",
-    Pulumi.Asset.stringAsset(handlerCodeStub)->Pulumi.Archive.assetToAssetOrArchive,
-  )
-  // ESM self-containment: the handler imports @aws-sdk/* bare specifiers the
-  // nodejs22.x runtime provides only under /var/runtime — unreachable from
-  // /var/task ESM without the resolver hook. Ship the loader + set its env vars.
-  let loaderHash = Util_Bundle.addEsmLoaderAssets(archiveContents)
-  let code = Pulumi.Archive.assetArchive(archiveContents)
-  let sourceCodeHash = Util_Bundle.hashString(handlerCodeStub ++ "\n---\n" ++ loaderHash)
-
-  let layers =
-    Lambda.reventlessLayerArn
-    ->Option.map(arn => [arn->Pulumi.Input.make])
-    ->Option.getOr([])
-    ->Pulumi.Input.make
-
-  let lambda = Lambda.Function.make(
-    ~name=name ++ "Lambda",
-    ~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: 512->Pulumi.Input.make,
-      timeout: 30->Pulumi.Input.make,
-      layers,
-      tags: AWS.Tags.make(~name=name ++ "Lambda", ReventlessCore.ReadModel.componentType),
-      environment: (
-        {
-          Lambda.Function.variables: Dict.fromArray([
-            ("Environment", Pulumi.Pulumi.getStackName()->Pulumi.Input.make),
-            ("API_FRAGMENT_RM_TABLE", apiFragmentRegistryTableName->Pulumi.Output.asInput),
-            ("NODE_OPTIONS", Util_Bundle.esmLoaderNodeOptions->Pulumi.Input.make),
-            ("ESM_FALLBACK_DIRS", Util_Bundle.esmFallbackDirs->Pulumi.Input.make),
-          ]),
-        }: Lambda.Function.functionEnvironment
-      )->Pulumi.Input.make,
-    },
-    ~opts,
-  )
-
-  let dataSourceRole = IAM.Role.makeWithDefaultPolicy(
-    ~name=name ++ "DataSource",
-    ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
-    ~opts,
-  )
-
-  let _ =
-    (lambda.arn, dataSourceRole.id)
-    ->Pulumi.Output.all2
-    ->Pulumi.Output.apply(((lambdaArn, dataSourceRoleId)) => {
-      open PolicyDocument
-      let _attach = IAM.RolePolicy.make(
-        ~name=name ++ "DataSource",
-        ~args={
-          IAM.RolePolicy.policy: PolicyDocument.make(
-            ~id=name ++ "DataSourcePolicy",
-            ~statements=[
-              {
-                sid: "AllowDataSourceInvokeLambda",
-                effect: Allow,
-                actions: Action("lambda:InvokeFunction"),
-                resources: Resource(lambdaArn),
-              },
-            ],
-          )
-          ->PolicyDocument.toJsonString
-          ->Pulumi.Input.make,
-          role: dataSourceRoleId->Pulumi.Input.make,
-        },
-        ~opts,
-      )
-    })
-
-  let dataSource = AppSync.DataSource.make(
-    ~name=name ++ "DataSource",
-    ~args={
-      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=Some(opts),
-  )
-
-  // Create the resolver only after the admin schema push is ACTIVE — otherwise
-  // CreateResolver races StartSchemaCreation and fails with "No field named
-  // Platform_ApiFragments found on type Query" the first time this field ships.
-  let _resolver =
-    schemaReady->Pulumi.Output.apply(() =>
-      AppSync_Resolver_Native.makeUnitJsResolver(
-        ~name=name ++ "Resolver",
-        ~api,
-        ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
-        ~type_="Query"->Pulumi.Input.make,
-        ~field="Platform_ApiFragments"->Pulumi.Input.make,
-        ~code=resolverCode,
-        ~opts,
-      )
-    )
-}

package/src/adapter/Api/Platform_ApiFragments_Lambda.res.mjs

@@ -1,202 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Aws from "@pulumi/aws";
-import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
-import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Pulumi from "@pulumi/pulumi";
-import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
-import * as AWS$ReventlessAws from "../AWS.res.mjs";
-import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
-import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
-import * as ReadModel$ReventlessCore from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel.res.mjs";
-import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
-import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
-import * as AppSync_Resolver_Native$ReventlessAws from "./AppSync_Resolver_Native.res.mjs";
-
-function makeHandlerCode(param) {
-  return `
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
-
-const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));
-const TABLE = process.env.API_FRAGMENT_RM_TABLE;
-
-export async function handler() {
-  if (!TABLE) {
-    console.error("Platform_ApiFragments: API_FRAGMENT_RM_TABLE env var not set");
-    return [];
-  }
-  const items = [];
-  let exclusiveStartKey;
-  do {
-    const out = await client.send(new ScanCommand({
-      TableName: TABLE,
-      Limit: 1000,
-      ExclusiveStartKey: exclusiveStartKey,
-    }));
-    if (out.Items) items.push(...out.Items);
-    exclusiveStartKey = out.LastEvaluatedKey;
-  } while (exclusiveStartKey);
-
-  // Status-only projection, byte-identical to Platform_ApiFragmentsApi.encodeApiFragmentEntry.
-  // The registry is keyed by bare plugin name; split("@")[0] is a defensive no-op against any
-  // legacy name@version row.
-  return items
-    .filter((item) => item && item.pluginId)
-    .map((item) => ({
-      pluginId: String(item.pluginId).split("@")[0],
-      apiTarget: item.apiTarget || "Domain",
-      pushStatus: item.pushStatus || "pending",
-      pushMessage: item.pushMessage || "",
-      pushedAt: item.pushedAt || "",
-      registeredAt: item.registeredAt || "",
-      updatedAt: item.updatedAt || "",
-    }));
-}
-`;
-}
-
-let resolverCode = `
-import { util } from '@aws-appsync/utils';
-export function request(ctx) {
-  return { operation: 'Invoke', payload: {} };
-}
-export function response(ctx) {
-  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  return ctx.result;
-}
-`;
-
-function make(api, apiFragmentRegistryTableName, schemaReady, opts) {
-  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
-  let name = "PlatformApiFragments";
-  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "Lambda", Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts$1);
-  apiFragmentRegistryTableName.apply(tableName => {
-    new (Aws.iam.RolePolicy)(name + "LambdaPolicy", {
-      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "LambdaPolicy", [
-        {
-          Sid: "AllowLambdaLogging",
-          Effect: "Allow",
-          Action: "logs:*",
-          Resource: "arn:aws:logs:*:*:*"
-        },
-        {
-          Sid: "AllowScanApiFragmentsTable",
-          Effect: "Allow",
-          Action: ["dynamodb:Scan"],
-          Resource: "arn:aws:dynamodb:*:*:table/" + tableName
-        }
-      ])),
-      role: lambdaRole.id
-    }, opts$1);
-  });
-  let archiveContents = {};
-  let handlerCodeStub = `
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
-
-const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));
-const TABLE = process.env.API_FRAGMENT_RM_TABLE;
-
-export async function handler() {
-  if (!TABLE) {
-    console.error("Platform_ApiFragments: API_FRAGMENT_RM_TABLE env var not set");
-    return [];
-  }
-  const items = [];
-  let exclusiveStartKey;
-  do {
-    const out = await client.send(new ScanCommand({
-      TableName: TABLE,
-      Limit: 1000,
-      ExclusiveStartKey: exclusiveStartKey,
-    }));
-    if (out.Items) items.push(...out.Items);
-    exclusiveStartKey = out.LastEvaluatedKey;
-  } while (exclusiveStartKey);
-
-  // Status-only projection, byte-identical to Platform_ApiFragmentsApi.encodeApiFragmentEntry.
-  // The registry is keyed by bare plugin name; split("@")[0] is a defensive no-op against any
-  // legacy name@version row.
-  return items
-    .filter((item) => item && item.pluginId)
-    .map((item) => ({
-      pluginId: String(item.pluginId).split("@")[0],
-      apiTarget: item.apiTarget || "Domain",
-      pushStatus: item.pushStatus || "pending",
-      pushMessage: item.pushMessage || "",
-      pushedAt: item.pushedAt || "",
-      registeredAt: item.registeredAt || "",
-      updatedAt: item.updatedAt || "",
-    }));
-}
-`;
-  archiveContents["index.mjs"] = new (Pulumi.asset.StringAsset)(handlerCodeStub);
-  let loaderHash = Util_Bundle$ReventlessAws.addEsmLoaderAssets(archiveContents);
-  let code = new (Pulumi.asset.AssetArchive)(archiveContents);
-  let sourceCodeHash = Util_Bundle$ReventlessAws.hashString(handlerCodeStub + "\n---\n" + loaderHash);
-  let layers = Stdlib_Option.getOr(Stdlib_Option.map(Lambda$PulumiAws.reventlessLayerArn, arn => [arn]), []);
-  let lambda = new (Aws.lambda.Function)(name + "Lambda", {
-    handler: "index.handler",
-    runtime: "nodejs22.x",
-    code: code,
-    role: lambdaRole.arn,
-    memorySize: 512,
-    timeout: 30,
-    layers: layers,
-    tags: AWS_Tags$ReventlessAws.make(name + "Lambda", ReadModel$ReventlessCore.componentType),
-    environment: {
-      variables: Object.fromEntries([
-        [
-          "Environment",
-          Pulumi.getStack()
-        ],
-        [
-          "API_FRAGMENT_RM_TABLE",
-          apiFragmentRegistryTableName
-        ],
-        [
-          "NODE_OPTIONS",
-          Util_Bundle$ReventlessAws.esmLoaderNodeOptions
-        ],
-        [
-          "ESM_FALLBACK_DIRS",
-          Util_Bundle$ReventlessAws.esmFallbackDirs
-        ]
-      ])
-    },
-    sourceCodeHash: sourceCodeHash
-  }, opts$1);
-  let dataSourceRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "DataSource", Pulumi.output(AWS$ReventlessAws.AppSync.principal), opts$1);
-  Pulumi.all([
-    lambda.arn,
-    dataSourceRole.id
-  ]).apply(param => {
-    new (Aws.iam.RolePolicy)(name + "DataSource", {
-      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "DataSourcePolicy", [{
-          Sid: "AllowDataSourceInvokeLambda",
-          Effect: "Allow",
-          Action: "lambda:InvokeFunction",
-          Resource: param[0]
-        }])),
-      role: param[1]
-    }, opts$1);
-  });
-  let dataSource = new (Aws.appsync.DataSource)(name + "DataSource", {
-    type: "AWS_LAMBDA",
-    apiId: Output$Pulumi.flatMap(api, api => api.id),
-    lambdaConfig: {
-      functionArn: lambda.arn
-    },
-    serviceRoleArn: dataSourceRole.arn
-  }, opts$1);
-  schemaReady.apply(() => AppSync_Resolver_Native$ReventlessAws.makeUnitJsResolver(name + "Resolver", api, dataSource.name, "Query", "Platform_ApiFragments", resolverCode, opts$1));
-}
-
-export {
-  makeHandlerCode,
-  resolverCode,
-  make,
-}
-/* @pulumi/aws Not a pure module */

package/src/adapter/QueryDb/NodeResolver_AppSync.res

@@ -1,71 +0,0 @@
-// AppSync Relay Node resolver.
-// Creates a pipeline resolver for node(id: ID!) that decodes the global ID
-// and routes to the correct DynamoDB table based on entity type.
-//
-// Usage: call `make` at platform deploy time after all QueryDb components are built,
-// passing the collected (typeName, dataSourceName) pairs.
-
-open PulumiAws.AppSync
-
-type nodeTypeEntry = {
-  typeName: string,
-  dataSourceName: Pulumi.Input.t<string>,
-}
-
-// Tracks registered entity types for the node resolver pipeline.
-let nodeTypeEntries: ref<array<nodeTypeEntry>> = ref([])
-
-let registerNodeType = (~typeName: string, ~dataSourceName: Pulumi.Input.t<string>) =>
-  nodeTypeEntries.contents->Array.push({typeName, dataSourceName})
-
-let make = (
-  ~api: Types.AppSync.api,
-  ~opts: Pulumi.ComponentResource.options,
-) => {
-  let entries = nodeTypeEntries.contents
-  if entries->Array.length == 0 {
-    []
-  } else {
-    let noneDataSource = DataSource.makeNoneDataSource(
-      ~name="NodeResolverNone",
-      ~api,
-      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
-    )
-
-    // First pipeline function: decode global ID (NONE datasource)
-    let decodeFn = Function.makeJs(
-      ~name="NodeDecodeGlobalId",
-      ~api,
-      ~dataSource=noneDataSource.name->Pulumi.Output.asInput,
-      ~code=Resolver.Functions.nodeDecodeGlobalId,
-      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
-    )
-
-    // Per-type pipeline functions: each checks ctx.stash.typeName and fetches if matching
-    let typeFunctions = entries->Array.map(entry => {
-      Function.makeJs(
-        ~name="NodeGet" ++ entry.typeName,
-        ~api,
-        ~dataSource=entry.dataSourceName,
-        ~code=Resolver.Functions.nodeGetItemForType(~typeName=entry.typeName),
-        ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
-      )
-    })
-
-    let allFunctions = Array.concat([decodeFn], typeFunctions)
-
-    let resolver = Resolver.makePipelineJsResolver(
-      ~name="NodeResolver",
-      ~api,
-      ~type_="Query"->Pulumi.Input.make,
-      ~field="node"->Pulumi.Input.make,
-      ~code=Resolver.Functions.pipelinePassThrough,
-      ~functions=allFunctions,
-      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
-    )
-
-    [resolver]->Array.map(Util_AppSync.toResource)
-  }
-}
-
-let reset = () => nodeTypeEntries.contents = []

package/src/adapter/QueryDb/NodeResolver_AppSync.res.mjs

@@ -1,44 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as AppSync_Function$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Function.res.mjs";
-import * as AppSync_Resolver$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver.res.mjs";
-import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
-import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
-import * as AppSync_DataSource$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_DataSource.res.mjs";
-import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
-
-let nodeTypeEntries = {
-  contents: []
-};
-
-function registerNodeType(typeName, dataSourceName) {
-  nodeTypeEntries.contents.push({
-    typeName: typeName,
-    dataSourceName: dataSourceName
-  });
-}
-
-function make(api, opts) {
-  let entries = nodeTypeEntries.contents;
-  if (entries.length === 0) {
-    return [];
-  }
-  let noneDataSource = AppSync_DataSource$PulumiAws.makeNoneDataSource("NodeResolverNone", api, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
-  let decodeFn = AppSync_Function$PulumiAws.makeJs("NodeDecodeGlobalId", api, noneDataSource.name, AppSync_Resolver_Functions$PulumiAws.nodeDecodeGlobalId, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
-  let typeFunctions = entries.map(entry => AppSync_Function$PulumiAws.makeJs("NodeGet" + entry.typeName, api, entry.dataSourceName, AppSync_Resolver_Functions$PulumiAws.nodeGetItemForType(entry.typeName), Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts)));
-  let allFunctions = [decodeFn].concat(typeFunctions);
-  let resolver = AppSync_Resolver$PulumiAws.makePipelineJsResolver("NodeResolver", api, "Query", "node", AppSync_Resolver_Functions$PulumiAws.pipelinePassThrough, allFunctions, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
-  return [resolver].map(Util_AppSync$ReventlessAws.toResource);
-}
-
-function reset() {
-  nodeTypeEntries.contents = [];
-}
-
-export {
-  nodeTypeEntries,
-  registerNodeType,
-  make,
-  reset,
-}
-/* AppSync_Function-PulumiAws Not a pure module */