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

package/src/components/Api/AppSync_Adapter.res

@@ -146,97 +146,6 @@ let deploySchemaWithRetry = (
     () => startSchemaCreation(client, {apiId, definition})->Promise.then(_ => Promise.resolve()),
   )->Effect.retry(AppSync_Error.retrySchedule)
 
-// ── Schema-push serialization lock ──────────────────────────────────────────
-//
-// Plugin/service stacks share one AppSync API, and StartSchemaCreation REPLACES
-// the whole schema. When two stacks scan the deploy-schema table, stitch, and
-// push concurrently, a push built from a stale scan (missing a peer's not-yet-
-// written fragment) clobbers the peer's fields — orphaning their resolvers
-// (NotFoundException: No field named X). The shrink guard only catches
-// catastrophic (>threshold) drops, not a single dropped field.
-//
-// This lease serialises scan→stitch→push across stacks via a conditional-write
-// lock row in the shared PluginSchemaPersistence table. A push that holds the
-// lease always scans a table already containing every prior push's fragment, so
-// the last push is complete and nothing is clobbered. The lease carries a TTL so
-// a crashed holder cannot deadlock the table; if the lock cannot be acquired
-// within maxWaitMs we proceed best-effort rather than fail the deploy.
-
-@val external schemaLockSetTimeout: (unit => unit, int) => unit = "setTimeout"
-let schemaLockSleep = (ms: int): promise<unit> =>
-  Promise.make((resolve, _) => schemaLockSetTimeout(() => resolve(), ms))
-let _schemaLockCounter = ref(0)
-
-let withSchemaPushLock = async (
-  ~tableName: string,
-  ~apiId: string,
-  ~leaseMs: int=120000,
-  ~maxWaitMs: int=180000,
-  fn: unit => promise<'a>,
-): 'a => {
-  open AwsSdk.DynamoDb.DocumentClient
-  let lockId = `schema-push-lock:${apiId}`
-  _schemaLockCounter := _schemaLockCounter.contents + 1
-  let holder = `${apiId}#${Date.now()->Float.toString}#${_schemaLockCounter.contents->Int.toString}`
-
-  let acquire = async () => {
-    let deadline = Date.now() +. maxWaitMs->Int.toFloat
-    let acquired = ref(false)
-    while !acquired.contents {
-      let now = Date.now()
-      let ok =
-        await PutCommand.make({
-          PutCommand.tableName,
-          item: Dict.fromArray([
-            ("id", lockId->JSON.Encode.string),
-            ("holder", holder->JSON.Encode.string),
-            ("expiresAt", (now +. leaseMs->Int.toFloat)->JSON.Encode.float),
-          ])->JSON.Encode.object,
-          conditionExpression: "attribute_not_exists(id) OR expiresAt < :now",
-          expressionAttributeValues: Dict.fromArray([(":now", now->JSON.Encode.float)]),
-        })
-        ->PutCommand.send
-        ->Promise.thenResolve(_ => true)
-        ->Promise.catch(_ => Promise.resolve(false))
-      if ok {
-        acquired := true
-      } else if Date.now() > deadline {
-        log.warn(
-          ~comp="AppSync_Adapter",
-          `schema-push lock for ${apiId} not acquired within ${maxWaitMs->Int.toString}ms — proceeding best-effort`,
-        )
-        acquired := true
-      } else {
-        await schemaLockSleep(1000)
-      }
-    }
-  }
-
-  let release = async () => {
-    let _ =
-      await DeleteCommand.make({
-        DeleteCommand.tableName,
-        key: Dict.fromArray([("id", lockId->JSON.Encode.string)]),
-        conditionExpression: "holder = :holder",
-        expressionAttributeValues: Dict.fromArray([(":holder", holder->JSON.Encode.string)]),
-      })
-      ->DeleteCommand.send
-      ->Promise.thenResolve(_ => ())
-      ->Promise.catch(_ => Promise.resolve()) // expired lease stolen by a peer — leave theirs intact
-  }
-
-  await acquire()
-  try {
-    let r = await fn()
-    let _ = await release()
-    r
-  } catch {
-  | exn =>
-    let _ = await release()
-    throw(exn)
-  }
-}
-
 // Lazy singleton AppSync client (runtime only)
 let _client: ref<option<appSyncClient>> = ref(None)
 let getClient = () =>
@@ -248,6 +157,77 @@ let getClient = () =>
     c
   }
 
+// ── GetSourceApiAssociation — merged-API association status poll ──────────
+// Merged-API deploys must fail loudly on MERGE_FAILED (plan
+// merged-api-push-free-composition, Phase 0 finding: a failed merge silently
+// keeps the last-good merged schema serving). After creating a
+// SourceApiAssociation, poll until the initial merge lands.
+type getSourceApiAssociationInput = {
+  associationId: string,
+  mergedApiIdentifier: string,
+}
+type getSourceApiAssociationCommand
+type sourceApiAssociationSummary = {
+  sourceApiAssociationStatus: option<string>,
+  sourceApiAssociationStatusDetail: option<string>,
+}
+type getSourceApiAssociationResult = {sourceApiAssociation: option<sourceApiAssociationSummary>}
+
+@module("@aws-sdk/client-appsync") @new
+external makeGetSourceApiAssociationCommand: getSourceApiAssociationInput => getSourceApiAssociationCommand =
+  "GetSourceApiAssociationCommand"
+
+@send
+external sendGetSourceApiAssociation: (
+  appSyncClient,
+  getSourceApiAssociationCommand,
+) => promise<getSourceApiAssociationResult> = "send"
+
+// Poll until the association reports MERGE_SUCCESS; throw with the AWS status
+// detail on MERGE_FAILED / AUTO_MERGE_SCHEDULE_FAILED. Auto-merge lands in
+// ~12 s (spike-measured), so 60 × 2 s bounds the wait at two minutes.
+let rec waitForMergeSuccess = async (
+  client: appSyncClient,
+  ~associationId: string,
+  ~mergedApiIdentifier: string,
+  ~maxAttempts=60,
+  ~attempt=0,
+  ~delayMs=2000,
+) => {
+  let result = await client->sendGetSourceApiAssociation(
+    {associationId, mergedApiIdentifier}->makeGetSourceApiAssociationCommand,
+  )
+  let status =
+    result.sourceApiAssociation
+    ->Option.flatMap(a => a.sourceApiAssociationStatus)
+    ->Option.getOr("(no status)")
+  let detail =
+    result.sourceApiAssociation
+    ->Option.flatMap(a => a.sourceApiAssociationStatusDetail)
+    ->Option.getOr("(no details)")
+  switch status {
+  | "MERGE_SUCCESS" => ()
+  | "MERGE_FAILED" | "AUTO_MERGE_SCHEDULE_FAILED" =>
+    JsError.throwWithMessage(
+      `Source API association ${associationId} on ${mergedApiIdentifier} failed to merge (${status}): ${detail}`,
+    )
+  | _ if attempt >= maxAttempts =>
+    JsError.throwWithMessage(
+      `Source API association ${associationId} merge timed out after ${maxAttempts->Int.toString} attempts (status: ${status})`,
+    )
+  | _ =>
+    await Promise.make((resolve, _) => setTimeout(resolve, delayMs)->ignore)
+    await waitForMergeSuccess(
+      client,
+      ~associationId,
+      ~mergedApiIdentifier,
+      ~maxAttempts,
+      ~attempt=attempt + 1,
+      ~delayMs,
+    )
+  }
+}
+
 // ── @aws_auth directive injection ─────────────────────────────────────────
 // Injects @aws_auth(cognito_groups: [...]) directives into SDL field strings
 // based on authorization metadata from schema entries.
@@ -524,13 +504,40 @@ let stitchWithAwsDirectives = (
   ->stampSharedIamTypes
 }
 
+/**
+Merged-mode plugin subgraph document: one fragment rendered standalone
+(relay base types included, global `node` omitted — only the platform's
+canonical base document carries `node`), with the same AppSync dialect as
+`stitchWithAwsDirectives`. No `@canonical` stamps — plugin subgraphs stay
+unstamped; the admin source's canonical definitions win on merge.
+*/
+let stitchStandaloneWithAwsDirectives = (
+  ~fragment: Reventless.Plugin.apiSchemaFragment,
+): string => {
+  let sources = ReventlessCore.GraphQL_Stitcher.collectSubscriptionSources(
+    ~baseFragment=fragment,
+    ~pluginFragments=[],
+  )
+  ReventlessCore.GraphQL_Stitcher.stitchStandalone(~fragment)
+  ->AppSync_SdlDecorate.injectAwsSubscribe(~sources)
+  ->stampSharedIamTypes
+}
+
 // ── Provider implementation ────────────────────────────────────────────────
 
 type api = AppSync.GraphQLApi.t
 type role = IAM.Role.t
 
-let makeApiResource = (
+// Primary authentication mode every platform-created AppSync API uses. A
+// merged API and its source APIs must share this primary mode — exported via
+// StackReference (`mergedApiPrimaryAuth`) and asserted where associations are
+// created (AppSync_MergedApi.assertCompatiblePrimaryAuth).
+let primaryAuthenticationType = AppSync.GraphQLApi.AMAZON_COGNITO_USER_POOLS
+
+let _makeApiResourceWith = (
   ~name: string,
+  ~schema: option<string>,
+  ~userPoolConfig: option<Pulumi.Output.t<AppSync.GraphQLApi.userPoolConfig>>,
   ~opts: Pulumi.ComponentResource.options,
 ): (Pulumi.Output.t<api>, Pulumi.Output.t<role>) => {
   let customOpts: Pulumi.CustomResourceOptions.t = {
@@ -547,13 +554,16 @@ let makeApiResource = (
     ~opts=Some(customOpts),
   )
 
-  // Resolve the Cognito UserPool — cached inside Platform_Stack, so calling
-  // from each API call site (DomainApi, PlatformApi) is safe. Returned as a
-  // single Output that yields the {userPoolId, awsRegion, defaultAction}
-  // record AppSync expects.
-  let authConfigOut = Auth_Cognito.make(~name=`${name}-auth`)
-  let userPoolConfigOut =
-    authConfigOut->Pulumi.Output.apply((c: Auth_Cognito.authConfig) =>
+  // Resolve the Cognito UserPool — either supplied by the caller (plugin-stack
+  // source APIs read it from the platform's StackReference exports so they
+  // never provision pool/client resources of their own) or resolved via
+  // Auth_Cognito (cached inside Platform_Stack, so calling from each API call
+  // site — DomainApi, PlatformApi — is safe). A single Output yielding the
+  // {userPoolId, awsRegion, defaultAction} record AppSync expects.
+  let userPoolConfigOut = switch userPoolConfig {
+  | Some(config) => config
+  | None =>
+    Auth_Cognito.make(~name=`${name}-auth`)->Pulumi.Output.apply((c: Auth_Cognito.authConfig) =>
       (
         {
           userPoolId: c.userPoolId,
@@ -562,13 +572,13 @@ let makeApiResource = (
         }: AppSync.GraphQLApi.userPoolConfig
       )
     )
+  }
 
   // Cognito as primary auth, AWS_IAM as additional provider for
   // server-to-server lambdas (heartbeat, Plugin_Connected emission) signed via
   // the existing IAM role.
   let apiArgs: AppSync.GraphQLApi.args = {
-    authenticationType: AppSync.GraphQLApi
-    .AMAZON_COGNITO_USER_POOLS->Pulumi.Input.make,
+    authenticationType: primaryAuthenticationType->Pulumi.Input.make,
     userPoolConfig: userPoolConfigOut->Pulumi.Output.asInput,
     additionalAuthenticationProviders: [
       (
@@ -577,12 +587,45 @@ let makeApiResource = (
         }: AppSync.GraphQLApi.additionalAuthenticationProvider
       )->Pulumi.Input.make,
     ]->Pulumi.Input.make,
+    schema: ?(schema->Option.map(Pulumi.Input.make)),
   }
   let graphQLApi = AppSync.GraphQLApi.make(~name, ~args=apiArgs, ~opts=Some(customOpts))
 
   (graphQLApi->Pulumi.Output.make, iamRole->Pulumi.Output.make)
 }
 
+let makeApiResource = (
+  ~name: string,
+  ~opts: Pulumi.ComponentResource.options,
+): (Pulumi.Output.t<api>, Pulumi.Output.t<role>) =>
+  _makeApiResourceWith(~name, ~schema=None, ~userPoolConfig=None, ~opts)
+
+// Merged-mode source API: same auth shape as makeApiResource but with a
+// DECLARATIVE inline schema — the provider runs StartSchemaCreation + poll
+// before the resource resolves, so resolvers chained on the API are ordered
+// after the schema is ACTIVE without the push-path hook machinery. Not part
+// of the Api_Adapter.Provider interface (Platform.res calls it directly on
+// the merge path).
+let makeSourceApiResource = (
+  ~name: string,
+  ~schema: string,
+  ~opts: Pulumi.ComponentResource.options,
+): (Pulumi.Output.t<api>, Pulumi.Output.t<role>) =>
+  _makeApiResourceWith(~name, ~schema=Some(schema), ~userPoolConfig=None, ~opts)
+
+// Merged-mode PLUGIN source API: schema-less at creation (the plugin's
+// standalone subgraph document is only computable during P.make(), so
+// preResolversSchemaHook pushes it — the plugin's own API is a single writer
+// by construction). The user pool comes from the platform's StackReference
+// exports so the merged endpoint's Cognito primary auth matches across every
+// source API without the plugin stack provisioning pool/client resources.
+let makePluginSourceApiResource = (
+  ~name: string,
+  ~userPoolConfig: Pulumi.Output.t<AppSync.GraphQLApi.userPoolConfig>,
+  ~opts: Pulumi.ComponentResource.options,
+): (Pulumi.Output.t<api>, Pulumi.Output.t<role>) =>
+  _makeApiResourceWith(~name, ~schema=None, ~userPoolConfig=Some(userPoolConfig), ~opts)
+
 let generateFragment = (
   ~mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,
   ~queryEntries: array<ReventlessInfra.Api.querySchemaEntry>,

package/src/components/Api/AppSync_Adapter.res.mjs

@@ -10,15 +10,12 @@ import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Effect$1 from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as ClientAppsync from "@aws-sdk/client-appsync";
 import * as Auth_Cognito$ReventlessAws from "../../adapter/Auth/Auth_Cognito.res.mjs";
 import * as AppSync_Error$ReventlessAws from "../../errors/AppSync_Error.res.mjs";
-import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as AppSync_SdlDecorate$ReventlessAws from "./AppSync_SdlDecorate.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
@@ -90,84 +87,6 @@ function deploySchemaWithRetry(client, apiId, definition) {
   })).then(param => Promise.resolve())), AppSync_Error$ReventlessAws.retrySchedule);
 }
 
-function schemaLockSleep(ms) {
-  return new Promise((resolve, param) => {
-    setTimeout(() => resolve(), ms);
-  });
-}
-
-let _schemaLockCounter = {
-  contents: 0
-};
-
-async function withSchemaPushLock(tableName, apiId, leaseMsOpt, maxWaitMsOpt, fn) {
-  let leaseMs = leaseMsOpt !== undefined ? leaseMsOpt : 120000;
-  let maxWaitMs = maxWaitMsOpt !== undefined ? maxWaitMsOpt : 180000;
-  let lockId = `schema-push-lock:` + apiId;
-  _schemaLockCounter.contents = _schemaLockCounter.contents + 1 | 0;
-  let holder = apiId + `#` + Date.now().toString() + `#` + _schemaLockCounter.contents.toString();
-  let acquire = async () => {
-    let deadline = Date.now() + maxWaitMs;
-    let acquired = false;
-    while (!acquired) {
-      let now = Date.now();
-      let ok = await Stdlib_Promise.$$catch(DynamoDb_DocumentClient$AwsSdk.PutCommand.send(new LibDynamodb.PutCommand({
-        Item: Object.fromEntries([
-          [
-            "id",
-            lockId
-          ],
-          [
-            "holder",
-            holder
-          ],
-          [
-            "expiresAt",
-            now + leaseMs
-          ]
-        ]),
-        TableName: tableName,
-        ConditionExpression: "attribute_not_exists(id) OR expiresAt < :now",
-        ExpressionAttributeValues: Object.fromEntries([[
-            ":now",
-            now
-          ]])
-      })).then(param => true), param => Promise.resolve(false));
-      if (ok) {
-        acquired = true;
-      } else if (Date.now() > deadline) {
-        log.warn("AppSync_Adapter", undefined, `schema-push lock for ` + apiId + ` not acquired within ` + maxWaitMs.toString() + `ms — proceeding best-effort`);
-        acquired = true;
-      } else {
-        await schemaLockSleep(1000);
-      }
-    };
-  };
-  let release = async () => {
-    await Stdlib_Promise.$$catch(DynamoDb_DocumentClient$AwsSdk.DeleteCommand.send(new LibDynamodb.DeleteCommand({
-      TableName: tableName,
-      Key: Object.fromEntries([[
-          "id",
-          lockId
-        ]]),
-      ConditionExpression: "holder = :holder",
-      ExpressionAttributeValues: Object.fromEntries([[
-          ":holder",
-          holder
-        ]])
-    })).then(param => {}), param => Promise.resolve());
-  };
-  await acquire();
-  try {
-    let r = await fn();
-    await release();
-    return r;
-  } catch (exn) {
-    await release();
-    throw exn;
-  }
-}
-
 let _client = {
   contents: undefined
 };
@@ -182,6 +101,35 @@ function getClient() {
   return c$1;
 }
 
+async function waitForMergeSuccess(client, associationId, mergedApiIdentifier, maxAttemptsOpt, attemptOpt, delayMsOpt) {
+  let maxAttempts = maxAttemptsOpt !== undefined ? maxAttemptsOpt : 60;
+  let attempt = attemptOpt !== undefined ? attemptOpt : 0;
+  let delayMs = delayMsOpt !== undefined ? delayMsOpt : 2000;
+  let result = await client.send(new ClientAppsync.GetSourceApiAssociationCommand({
+    associationId: associationId,
+    mergedApiIdentifier: mergedApiIdentifier
+  }));
+  let status = Stdlib_Option.getOr(Stdlib_Option.flatMap(result.sourceApiAssociation, a => a.sourceApiAssociationStatus), "(no status)");
+  let detail = Stdlib_Option.getOr(Stdlib_Option.flatMap(result.sourceApiAssociation, a => a.sourceApiAssociationStatusDetail), "(no details)");
+  switch (status) {
+    case "AUTO_MERGE_SCHEDULE_FAILED" :
+    case "MERGE_FAILED" :
+      break;
+    case "MERGE_SUCCESS" :
+      return;
+    default:
+      if (attempt >= maxAttempts) {
+        return Stdlib_JsError.throwWithMessage(`Source API association ` + associationId + ` merge timed out after ` + maxAttempts.toString() + ` attempts (status: ` + status + `)`);
+      } else {
+        await new Promise((resolve, param) => {
+          setTimeout(resolve, delayMs);
+        });
+        return await waitForMergeSuccess(client, associationId, mergedApiIdentifier, maxAttempts, attempt + 1 | 0, delayMs);
+      }
+  }
+  return Stdlib_JsError.throwWithMessage(`Source API association ` + associationId + ` on ` + mergedApiIdentifier + ` failed to merge (` + status + `): ` + detail);
+}
+
 function _permissionToCognitoGroups(permission) {
   if (typeof permission !== "object") {
     switch (permission) {
@@ -349,7 +297,12 @@ function stitchWithAwsDirectives(baseFragment, pluginFragments) {
   return AppSync_SdlDecorate$ReventlessAws.stampSharedIamTypes(AppSync_SdlDecorate$ReventlessAws.injectAwsSubscribe(GraphQL_Stitcher$ReventlessCore.stitch(baseFragment, pluginFragments), sources));
 }
 
-function makeApiResource(name, opts) {
+function stitchStandaloneWithAwsDirectives(fragment) {
+  let sources = GraphQL_Stitcher$ReventlessCore.collectSubscriptionSources(fragment, []);
+  return AppSync_SdlDecorate$ReventlessAws.stampSharedIamTypes(AppSync_SdlDecorate$ReventlessAws.injectAwsSubscribe(GraphQL_Stitcher$ReventlessCore.stitchStandalone(fragment), sources));
+}
+
+function _makeApiResourceWith(name, schema, userPoolConfig, opts) {
   let customOpts_parent = opts.parent;
   let customOpts = {
     parent: customOpts_parent
@@ -357,18 +310,19 @@ function makeApiResource(name, opts) {
   let iamRole = new (Aws.iam.Role)(name + `-appsync-role`, {
     assumeRolePolicy: `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"appsync.amazonaws.com"},"Action":"sts:AssumeRole"}]}`
   }, customOpts);
-  let authConfigOut = Auth_Cognito$ReventlessAws.make(name + `-auth`, undefined);
-  let userPoolConfigOut = authConfigOut.apply(c => ({
-    userPoolId: c.userPoolId,
-    defaultAction: "ALLOW",
-    awsRegion: c.region
-  }));
+  let userPoolConfigOut = userPoolConfig !== undefined ? userPoolConfig : Auth_Cognito$ReventlessAws.make(name + `-auth`, undefined).apply(c => ({
+      userPoolId: c.userPoolId,
+      defaultAction: "ALLOW",
+      awsRegion: c.region
+    }));
+  let apiArgs_schema = Stdlib_Option.map(schema, prim => prim);
   let apiArgs_userPoolConfig = userPoolConfigOut;
   let apiArgs_additionalAuthenticationProviders = [{
       authenticationType: "AWS_IAM"
     }];
   let apiArgs = {
     authenticationType: "AMAZON_COGNITO_USER_POOLS",
+    schema: apiArgs_schema,
     userPoolConfig: apiArgs_userPoolConfig,
     additionalAuthenticationProviders: apiArgs_additionalAuthenticationProviders
   };
@@ -379,6 +333,18 @@ function makeApiResource(name, opts) {
   ];
 }
 
+function makeApiResource(name, opts) {
+  return _makeApiResourceWith(name, undefined, undefined, opts);
+}
+
+function makeSourceApiResource(name, schema, opts) {
+  return _makeApiResourceWith(name, schema, undefined, opts);
+}
+
+function makePluginSourceApiResource(name, userPoolConfig, opts) {
+  return _makeApiResourceWith(name, undefined, userPoolConfig, opts);
+}
+
 function generateFragment(mutationEntries, queryEntries) {
   let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries, queryEntries);
   return injectAwsAuth(fragment, mutationEntries, queryEntries);
@@ -400,6 +366,8 @@ function updateSchema(api, baseFragment, pluginFragments) {
 
 let stampSharedIamTypes = AppSync_SdlDecorate$ReventlessAws.stampSharedIamTypes;
 
+let primaryAuthenticationType = "AMAZON_COGNITO_USER_POOLS";
+
 export {
   log,
   sha256Hex,
@@ -408,11 +376,9 @@ export {
   waitForSchemaActive,
   getIntrospectionSdl,
   deploySchemaWithRetry,
-  schemaLockSleep,
-  _schemaLockCounter,
-  withSchemaPushLock,
   _client,
   getClient,
+  waitForMergeSuccess,
   _permissionToCognitoGroups,
   _formatGroupsDirective,
   _formatDualAuthDirective,
@@ -422,7 +388,12 @@ export {
   injectAwsAuth,
   injectAwsAuthAll,
   stitchWithAwsDirectives,
+  stitchStandaloneWithAwsDirectives,
+  primaryAuthenticationType,
+  _makeApiResourceWith,
   makeApiResource,
+  makeSourceApiResource,
+  makePluginSourceApiResource,
   generateFragment,
   updateSchema,
 }