@suss/packs 0.35.1 → 0.36.0

package/dist/apollo-client.js

@@ -9,6 +9,7 @@ var DOCUMENT_HOOKS = [
   { hookName: "useMutation", operationType: "mutation" },
   { hookName: "useSubscription", operationType: "subscription" }
 ];
+var CLIENT_OPTION = { argument: 1, property: "client" };
 var optionsSchema = z.object({
   /**
    * The provider workspace each client talks to, keyed by the endpoint
@@ -26,7 +27,13 @@ var optionsSchema = z.object({
    */
   operationScopes: z.array(
     z.object({ files: z.array(z.string()), workspace: z.string() }).strict()
-  ).optional()
+  ).optional(),
+  /**
+   * What to do with an operation whose client neither `clients` nor
+   * `operationScopes` ties to a service, when the project builds
+   * clients for more than one endpoint. `unchecked` is the default.
+   */
+  unboundClients: z.enum(["unchecked", "pairWithAll"]).optional()
 }).strict();
 function apolloClientPack(options = {}) {
   return {
@@ -41,7 +48,8 @@ function apolloClientPack(options = {}) {
         match: {
           type: "graphqlHookCall",
           importModule: "@apollo/client",
-          hooks: [...DOCUMENT_HOOKS]
+          hooks: [...DOCUMENT_HOOKS],
+          clientOption: CLIENT_OPTION
         },
         // requiresImport matches by prefix, so it also admits
         // `@apollo/client/react`. importModule above matches exactly.
@@ -53,7 +61,8 @@ function apolloClientPack(options = {}) {
         match: {
           type: "graphqlHookCall",
           importModule: "@apollo/client/react",
-          hooks: [...DOCUMENT_HOOKS]
+          hooks: [...DOCUMENT_HOOKS],
+          clientOption: CLIENT_OPTION
         },
         requiresImport: ["@apollo/client"]
       },
@@ -94,6 +103,7 @@ function apolloClientPack(options = {}) {
         importModule: "@apollo/client",
         importName: "ApolloClient",
         uriProperty: "uri",
+        linkProperty: "link",
         // With a registry from `createFragmentRegistry` on the cache, a
         // document can spread a fragment it does not define, and the
         // client fills it in at run time.
@@ -119,6 +129,7 @@ function apolloClientPack(options = {}) {
     ],
     ...options.clients !== void 0 ? { graphqlClientBindings: options.clients } : {},
     ...options.operationScopes !== void 0 ? { graphqlOperationScopes: options.operationScopes } : {},
+    ...options.unboundClients !== void 0 ? { graphqlUnboundClients: options.unboundClients } : {},
     terminals: [
       {
         kind: "return",

package/dist/aws-lambda-python.d.ts

@@ -0,0 +1 @@
+export { declaresPython as declares, awsLambdaPython as default, optionsSchema } from '@suss/framework-aws-lambda';

package/dist/aws-lambda-python.js

@@ -0,0 +1,10 @@
+import {
+  awsLambdaPython,
+  declaresPython,
+  optionsSchema
+} from "./chunk-63BQSSQT.js";
+export {
+  declaresPython as declares,
+  awsLambdaPython as default,
+  optionsSchema
+};

package/dist/aws-lambda-ruby.d.ts

@@ -0,0 +1 @@
+export { declaresRuby as declares, awsLambdaRuby as default, optionsSchema } from '@suss/framework-aws-lambda';

package/dist/aws-lambda-ruby.js

@@ -0,0 +1,10 @@
+import {
+  awsLambdaRuby,
+  declaresRuby,
+  optionsSchema
+} from "./chunk-63BQSSQT.js";
+export {
+  declaresRuby as declares,
+  awsLambdaRuby as default,
+  optionsSchema
+};

package/dist/aws-lambda.js

@@ -1,431 +1,8 @@
-// ../framework/aws-lambda/dist/index.js
-import { z } from "zod";
-import { compile, declarationsIn } from "@suss/recognize";
-import fs from "fs";
-import path from "path";
 import {
-  loadTemplateTree,
-  qualifiedLogicalId,
-  readAppSyncResolvers,
-  readServerlessFunctions,
-  unfollowedStackMessage
-} from "@suss/manifest-aws";
-import { constructedFrom, unitInvokes } from "@suss/recognize";
-var TEMPLATE_NAMES = ["template.yaml", "template.yml", "template.json"];
-var dirToTemplate = /* @__PURE__ */ new Map();
-var templateToIndex = /* @__PURE__ */ new Map();
-var templateToDocuments = /* @__PURE__ */ new Map();
-function findTemplate(startDir) {
-  const chain = [];
-  let dir = startDir;
-  while (true) {
-    const cached = dirToTemplate.get(dir);
-    if (cached !== void 0) {
-      for (const d of chain) {
-        dirToTemplate.set(d, cached);
-      }
-      return cached;
-    }
-    chain.push(dir);
-    const found = TEMPLATE_NAMES.map((name) => path.join(dir, name)).find(
-      (candidate) => fs.existsSync(candidate)
-    ) ?? null;
-    if (found !== null) {
-      for (const d of chain) {
-        dirToTemplate.set(d, found);
-      }
-      return found;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      for (const d of chain) {
-        dirToTemplate.set(d, null);
-      }
-      return null;
-    }
-    dir = parent;
-  }
-}
-function indexForTemplate(templatePath) {
-  const cached = templateToIndex.get(templatePath);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const index = /* @__PURE__ */ new Map();
-  const documents = /* @__PURE__ */ new Set([templatePath]);
-  try {
-    const tree = loadTemplateTree(templatePath);
-    for (const document of tree.documents) {
-      documents.add(document.path);
-    }
-    for (const stack of tree.unfollowed) {
-      process.stderr.write(
-        `[suss] aws-lambda: ${unfollowedStackMessage(stack)}
-`
-      );
-      if (stack.templatePath !== null) {
-        documents.add(stack.templatePath);
-      }
-    }
-    for (const document of tree.documents) {
-      const templateDir = path.dirname(document.path);
-      const fieldsByFunction = groupFieldsByFunction(
-        readAppSyncResolvers(document.template)
-      );
-      for (const fn of readServerlessFunctions(document.template)) {
-        const resolvedModule = path.resolve(
-          templateDir,
-          fn.codeUri,
-          fn.modulePath
-        );
-        const list = index.get(resolvedModule) ?? [];
-        list.push({
-          functionLogicalId: qualifiedLogicalId(
-            document.stackPath,
-            fn.logicalId
-          ),
-          graphqlFields: fieldsByFunction.get(fn.logicalId) ?? [],
-          handler: fn.handler,
-          exportName: fn.exportName,
-          httpRoutes: fn.httpRoutes,
-          nonHttpEvents: fn.nonHttpEvents
-        });
-        index.set(resolvedModule, list);
-      }
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[suss] aws-lambda: failed to read ${templatePath}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  templateToIndex.set(templatePath, index);
-  templateToDocuments.set(templatePath, [...documents]);
-  return index;
-}
-function toModulePath(filePath) {
-  const resolved = path.resolve(filePath);
-  const ext = path.extname(resolved);
-  return ext === "" ? resolved : resolved.slice(0, -ext.length);
-}
-function groupFieldsByFunction(bindings) {
-  const out = /* @__PURE__ */ new Map();
-  for (const binding of bindings) {
-    for (const logicalId of binding.lambdaFunctionLogicalIds) {
-      const fields = out.get(logicalId) ?? [];
-      fields.push({ typeName: binding.typeName, fieldName: binding.fieldName });
-      out.set(logicalId, fields);
-    }
-  }
-  return out;
-}
-function handlersForFile(filePath) {
-  const templatePath = findTemplate(path.dirname(path.resolve(filePath)));
-  if (templatePath === null) {
-    return [];
-  }
-  const index = indexForTemplate(templatePath);
-  return index.get(toModulePath(filePath)) ?? [];
-}
-function templatesForFiles(files) {
-  const roots = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const templatePath = findTemplate(path.dirname(path.resolve(file)));
-    if (templatePath !== null) {
-      roots.add(templatePath);
-    }
-  }
-  const documents = /* @__PURE__ */ new Set();
-  for (const root of roots) {
-    indexForTemplate(root);
-    for (const document of templateToDocuments.get(root) ?? [root]) {
-      documents.add(document);
-    }
-  }
-  return [...documents];
-}
-var HTTP_TERMINALS = [
-  {
-    // `return { statusCode, body, headers? }`, at the return or in a helper
-    // the adapter follows. `body` contains the serialized payload, so
-    // `JSON.stringify(x)` is unwrapped to the shape of `x`.
-    kind: "response",
-    match: { type: "returnShape", requiredProperties: ["statusCode"] },
-    extraction: {
-      statusCode: { from: "property", name: "statusCode" },
-      body: { from: "property", name: "body", unwrapJsonStringify: true }
-    }
-  },
-  {
-    // `return { batchItemFailures }` makes Lambda retry the records it
-    // lists. Lambda defines this shape, so the pack can match on it the
-    // same way it matches the envelope above.
-    kind: "return",
-    match: {
-      type: "returnShape",
-      requiredProperties: ["batchItemFailures"]
-    },
-    extraction: {}
-  },
-  {
-    // An uncaught throw becomes a throw-output transition. API Gateway
-    // turns it into a 5xx, and the platform picks which one.
-    kind: "throw",
-    match: { type: "throwExpression" },
-    extraction: {}
-  }
-];
-var NON_HTTP_TERMINALS = [
-  ...HTTP_TERMINALS,
-  {
-    kind: "return",
-    match: { type: "returnShape" },
-    extraction: {}
-  },
-  {
-    // A queue consumer acknowledges a batch by returning without an error.
-    // Without this pattern the handler has no terminal, so it gets no
-    // transition and everything it does is lost with it.
-    kind: "return",
-    match: { type: "functionFallthrough" },
-    extraction: {}
-  }
-];
-var METADATA_NAMESPACE = "awsLambda";
-function deployableUnit(entry) {
-  return { deploymentTarget: "lambda", instanceName: entry.functionLogicalId };
-}
-function httpRouteUnits(entry, func) {
-  const units = [];
-  for (const route of entry.httpRoutes) {
-    if (route.method === "ANY") {
-      continue;
-    }
-    units.push({
-      func,
-      kind: "handler",
-      name: `${entry.functionLogicalId}.${entry.exportName}`,
-      routeInfo: { method: route.method, path: route.path },
-      deployableUnit: deployableUnit(entry),
-      metadata: {
-        [METADATA_NAMESPACE]: {
-          handler: entry.handler,
-          eventId: route.eventId,
-          apiEventType: route.eventType
-        }
-      }
-    });
-  }
-  return units;
-}
-var OPERATION_ROOT_TYPES = ["Query", "Mutation", "Subscription"];
-function operationFields(entry) {
-  return entry.graphqlFields.filter(
-    (f) => OPERATION_ROOT_TYPES.includes(f.typeName)
-  );
-}
-function typeFields(entry) {
-  return entry.graphqlFields.filter(
-    (f) => !OPERATION_ROOT_TYPES.includes(f.typeName)
-  );
-}
-function graphqlResolverUnits(entry, func) {
-  return operationFields(entry).map((field) => ({
-    func,
-    kind: "handler",
-    name: `${entry.functionLogicalId}.${entry.exportName}`,
-    resolverInfo: { typeName: field.typeName, fieldName: field.fieldName },
-    deployableUnit: deployableUnit(entry),
-    metadata: {
-      [METADATA_NAMESPACE]: {
-        handler: entry.handler,
-        recognition: "appsync-resolver"
-      }
-    }
-  }));
-}
-function accountingUnit(entry, func) {
-  const eventTypes = accountedEventTypes(entry);
-  const backs = typeFields(entry);
-  const wire = messageBusWire(eventTypes);
-  const unit = deployableUnit(entry);
-  return {
-    func,
-    kind: "handler",
-    name: `${entry.functionLogicalId}.${entry.exportName}`,
-    terminals: NON_HTTP_TERMINALS,
-    ...wire !== null ? { channelInfo: { messageBus: wire, channel: null } } : { invocationInfo: unit },
-    deployableUnit: unit,
-    metadata: {
-      [METADATA_NAMESPACE]: {
-        handler: entry.handler,
-        recognition: "recognized-not-http",
-        eventTypes,
-        ...backs.length > 0 ? { graphqlTypeFields: backs } : {}
-      }
-    }
-  };
-}
-var EVENT_WIRES = {
-  SQS: "aws_sqs",
-  SNS: "aws.sns",
-  S3: "s3",
-  Schedule: "eventbridge",
-  ScheduleV2: "eventbridge",
-  EventBridgeRule: "eventbridge",
-  CloudWatchEvent: "eventbridge"
-};
-function messageBusWire(eventTypes) {
-  const wires = new Set(
-    eventTypes.map((type) => EVENT_WIRES[type] ?? null)
-  );
-  if (wires.size !== 1) {
-    return null;
-  }
-  const [wire] = wires;
-  return wire ?? null;
-}
-function accountedEventTypes(entry) {
-  return [
-    ...entry.nonHttpEvents.map((e) => e.eventType),
-    ...entry.httpRoutes.filter((r) => r.method === "ANY").map((r) => r.eventType)
-  ];
-}
-function hasBindableRoute(entry) {
-  return entry.httpRoutes.some((r) => r.method !== "ANY");
-}
-function awsLambdaDiscovery() {
-  return (sourceFile, ctx) => {
-    const sf = sourceFile;
-    const tsCtx = ctx;
-    const filePath = tsCtx.getFilePath(sf);
-    const entries = handlersForFile(filePath);
-    if (entries.length === 0) {
-      return [];
-    }
-    const exported = /* @__PURE__ */ new Map();
-    for (const { name, func } of tsCtx.exportedFunctions(sf)) {
-      exported.set(name, func);
-    }
-    const units = [];
-    for (const entry of entries) {
-      const func = exported.get(entry.exportName);
-      if (func === void 0) {
-        continue;
-      }
-      units.push(...httpRouteUnits(entry, func));
-      units.push(...graphqlResolverUnits(entry, func));
-      const unaccountedEvents = accountedEventTypes(entry);
-      const boundToNothing = !hasBindableRoute(entry) && operationFields(entry).length === 0;
-      if (unaccountedEvents.length > 0 || boundToNothing) {
-        units.push(accountingUnit(entry, func));
-      }
-    }
-    return units;
-  };
-}
-var LAMBDA = "@aws-sdk/client-lambda";
-var INSIDE_THE_COMMAND = (named) => ({
-  send: {
-    input: {
-      at: 0,
-      of: [
-        {
-          to: "argument",
-          at: 0,
-          origin: constructedFrom({ from: [LAMBDA], named })
-        }
-      ]
-    }
-  }
-});
-function invokeDeclarations() {
-  return [
-    unitInvokes({
-      platform: "lambda",
-      client: constructedFrom(LAMBDA),
-      named: ["FunctionName"],
-      payload: "Payload"
-    }).methods(INSIDE_THE_COMMAND(["InvokeCommand"])).example(
-      'client.send(new InvokeCommand({ FunctionName: "Worker", Payload: "{}" }))'
-    ),
-    unitInvokes({
-      platform: "lambda",
-      client: constructedFrom(LAMBDA),
-      named: ["FunctionName"],
-      payload: "InvokeArgs"
-    }).methods(INSIDE_THE_COMMAND(["InvokeAsyncCommand"])).example(
-      'client.send(new InvokeAsyncCommand({ FunctionName: "Worker", InvokeArgs: "{}" }))'
-    )
-  ];
-}
-var optionsSchema = z.object({}).strict();
-function awsLambdaFramework(_options = {}) {
-  const invokes = invokeDeclarations();
-  return {
-    name: "aws-lambda",
-    protocol: "http",
-    // The adapter cannot read Sentry's wrapper inside the library, so the
-    // pack declares that the handler is argument 0. A wrapper written in
-    // the project needs no entry, because the adapter reads its body.
-    transparentWrappers: [
-      { module: "@sentry/aws-serverless", name: "wrapHandler", argument: 0 }
-    ],
-    languages: ["typescript", "javascript"],
-    // The routing is in the template, so the callback finds handlers
-    // there and the pattern list stays empty.
-    discovery: [],
-    discoverUnits: awsLambdaDiscovery(),
-    // Discovery reads the templates, so they go into the cache key and an
-    // edited template makes the next run read the project again.
-    discoveryInputs: templatesForFiles,
-    // No import gate: a JavaScript handler imports nothing from
-    // `aws-lambda`, so the template acts as the gate. See the README.
-    // A unit that is not HTTP gets a longer list from the discovery
-    // callback in place of this one.
-    terminals: HTTP_TERMINALS,
-    inputMapping: {
-      type: "positionalParams",
-      params: [
-        { position: 0, role: "event" },
-        { position: 1, role: "context" }
-      ]
-    },
-    // A proxy integration passes the handler API Gateway's event, with the
-    // body as a string the handler parses. A read of the body records that
-    // the handler took all of it, with no field name.
-    requestSpelling: {
-      headers: { path: ["event", "headers"], saysWhichField: true },
-      query: {
-        path: ["event", "queryStringParameters"],
-        saysWhichField: true
-      },
-      params: { path: ["event", "pathParameters"], saysWhichField: true },
-      body: { path: ["event", "body"], saysWhichField: false }
-    },
-    // Powertools reads these variables from inside node_modules, where no
-    // walk over the project goes, so without this entry they look unread.
-    libraryEnvVars: [
-      {
-        module: "@aws-lambda-powertools/",
-        prefixes: ["POWERTOOLS_"]
-      }
-    ],
-    // A pack-level `requiresImport` would gate `discoverUnits` too. Each
-    // declaration already checks which SDK its command class came from.
-    invocationRecognizers: invokes.map(
-      (match) => compile(match.declared, "@suss/framework-aws-lambda")
-    ),
-    declarations: declarationsIn(invokes)
-  };
-}
-var declares = {
-  kind: "framework",
-  package: "@suss/framework-aws-lambda",
-  dependencies: [{ ecosystem: "npm", name: "@types/aws-lambda" }],
-  reads: "AWS Lambda HTTP handlers, paired with the routes a SAM or CloudFormation template declares."
-};
-var index_default = awsLambdaFramework;
+  declares,
+  index_default,
+  optionsSchema
+} from "./chunk-63BQSSQT.js";
 export {
   declares,
   index_default as default,