@suss/packs 0.11.0

package/dist/aws-sqs.js

@@ -0,0 +1,296 @@
+// ../framework/aws-sqs/dist/index.js
+import {
+  Node as N
+} from "ts-morph";
+import { readConfiguredCall, rootIdentifier } from "@suss/adapter-typescript";
+import { messageBusBinding } from "@suss/behavioral-ir";
+import { unwrapJsonStringify } from "@suss/extractor";
+var SEND_COMMANDS = {
+  SendMessageCommand: "send",
+  SendMessageBatchCommand: "sendBatch"
+};
+function sqsRecognizer(call, ctx) {
+  const callNode = call;
+  const recognizerCtx = ctx;
+  const calleeExpr = callNode.getExpression();
+  if (!N.isPropertyAccessExpression(calleeExpr)) {
+    return null;
+  }
+  if (calleeExpr.getName() !== "send") {
+    return null;
+  }
+  const args = callNode.getArguments();
+  if (args.length === 0) {
+    return null;
+  }
+  const firstArg = args[0];
+  if (!N.isNewExpression(firstArg)) {
+    return null;
+  }
+  const ctorExpr = firstArg.getExpression();
+  const ctorLeafName = N.isPropertyAccessExpression(ctorExpr) ? ctorExpr.getName() : ctorExpr.getText();
+  const operation = SEND_COMMANDS[ctorLeafName];
+  if (operation === void 0) {
+    return null;
+  }
+  const importCheckTarget = N.isPropertyAccessExpression(ctorExpr) ? rootIdentifier(ctorExpr) : ctorExpr;
+  if (importCheckTarget === null || !recognizerCtx.isImportedFrom(importCheckTarget, "@aws-sdk/client-sqs")) {
+    return null;
+  }
+  const ctorArgs = firstArg.getArguments();
+  if (ctorArgs.length === 0) {
+    return null;
+  }
+  const input = ctorArgs[0];
+  if (!N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  const channel = readQueueUrlChannel(
+    input,
+    recognizerCtx.resolveWrittenValue ?? (() => null)
+  );
+  const rawBody = readPropertyArg(
+    input,
+    "MessageBody",
+    recognizerCtx.extractArgs,
+    callNode
+  );
+  const body = unwrapJsonStringify(rawBody);
+  return [
+    {
+      type: "interaction",
+      binding: messageBusBinding({
+        recognition: "@suss/framework-aws-sqs",
+        messageBus: "aws_sqs",
+        channel
+      }),
+      callee: callNode.getExpression().getText(),
+      interaction: {
+        class: "message-send",
+        ...body !== null ? { body } : {}
+        // routingKey unused for SQS standard queues. SQS FIFO uses
+        // MessageGroupId; future enhancement.
+      }
+    }
+  ];
+}
+function readQueueUrlChannel(input, resolveWrittenValue) {
+  if (!N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  for (const prop of input.getProperties()) {
+    if (!N.isPropertyAssignment(prop)) {
+      continue;
+    }
+    if (prop.getName() !== "QueueUrl") {
+      continue;
+    }
+    const initializer = prop.getInitializer();
+    if (initializer === void 0) {
+      return null;
+    }
+    const named = channelNamedBy(initializer);
+    if (named !== null) {
+      return named;
+    }
+    const resolved = resolveWrittenValue(initializer);
+    return resolved === null ? null : channelNamedBy(resolved);
+  }
+  return null;
+}
+function channelNamedBy(expr) {
+  if (N.isPropertyAccessExpression(expr)) {
+    const text = expr.getText();
+    const match = text.match(/^process\.env\.(\w+)$/);
+    return match === null ? null : match[1] ?? null;
+  }
+  if (N.isStringLiteral(expr)) {
+    return expr.getLiteralValue();
+  }
+  return null;
+}
+function readPropertyArg(input, propName, extractCallArgs, callNode) {
+  const callArgs = extractCallArgs();
+  const first = callArgs[0];
+  if (first === null || typeof first !== "object" || first.kind !== "call") {
+    return null;
+  }
+  const ctorArgs = first.args ?? [];
+  const inputArg = ctorArgs[0];
+  if (inputArg === null || typeof inputArg !== "object" || inputArg.kind !== "object") {
+    return null;
+  }
+  const fields = inputArg.fields ?? {};
+  void input;
+  void callNode;
+  return fields[propName] ?? null;
+}
+function messageReceiveRecognizer(call, ctx) {
+  const callNode = call;
+  void ctx;
+  const calleeExpr = callNode.getExpression();
+  if (!N.isPropertyAccessExpression(calleeExpr)) {
+    return null;
+  }
+  if (calleeExpr.getName() !== "parse") {
+    return null;
+  }
+  const receiver = calleeExpr.getExpression();
+  if (!N.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+    return null;
+  }
+  const args = callNode.getArguments();
+  if (args.length !== 1) {
+    return null;
+  }
+  const arg = args[0];
+  if (!N.isPropertyAccessExpression(arg)) {
+    return null;
+  }
+  if (arg.getName() !== "body") {
+    return null;
+  }
+  const recordExpr = arg.getExpression();
+  if (!N.isIdentifier(recordExpr)) {
+    return null;
+  }
+  if (!isSqsRecordIdentifier(recordExpr)) {
+    return null;
+  }
+  const fields = extractDestructuredFields(callNode);
+  return [
+    {
+      type: "interaction",
+      // Channel intentionally null: the queue a handler drains is
+      // stated by the CFN event-source mapping, so this side does not
+      // name it and the pairing pass joins by codeScope instead.
+      binding: messageBusBinding({
+        recognition: "@suss/framework-aws-sqs",
+        messageBus: "aws_sqs",
+        channel: null
+      }),
+      callee: callNode.getExpression().getText(),
+      interaction: {
+        class: "message-receive",
+        ...fields !== null ? { body: { kind: "object", fields } } : {}
+      }
+    }
+  ];
+}
+function isSqsRecordIdentifier(recordExpr) {
+  if (!N.isIdentifier(recordExpr)) {
+    return false;
+  }
+  const symbol = recordExpr.getSymbol();
+  if (symbol === void 0) {
+    return false;
+  }
+  for (const decl of symbol.getDeclarations()) {
+    if (!N.isVariableDeclaration(decl)) {
+      continue;
+    }
+    const declList = decl.getParent();
+    if (declList === void 0) {
+      continue;
+    }
+    const forOf = declList.getParent();
+    if (forOf === void 0 || !N.isForOfStatement(forOf)) {
+      continue;
+    }
+    const iterated = forOf.getExpression();
+    if (N.isPropertyAccessExpression(iterated) && iterated.getName() === "Records") {
+      return true;
+    }
+  }
+  return false;
+}
+function extractDestructuredFields(call) {
+  let parent = call.getParent();
+  while (parent !== void 0 && (N.isAsExpression(parent) || N.isParenthesizedExpression(parent))) {
+    parent = parent.getParent();
+  }
+  if (parent === void 0 || !N.isVariableDeclaration(parent)) {
+    return null;
+  }
+  const nameNode = parent.getNameNode();
+  if (!N.isObjectBindingPattern(nameNode)) {
+    return null;
+  }
+  const fields = {};
+  for (const element of nameNode.getElements()) {
+    const propertyNameNode = element.getPropertyNameNode();
+    let fieldName;
+    if (propertyNameNode !== void 0) {
+      fieldName = propertyNameNode.getText();
+    } else {
+      const nameInner = element.getNameNode();
+      if (!N.isIdentifier(nameInner)) {
+        continue;
+      }
+      fieldName = nameInner.getText();
+    }
+    fields[fieldName] = {
+      kind: "identifier",
+      name: fieldName
+    };
+  }
+  return fields;
+}
+function configuredProducerRecognizer(spec) {
+  return ((call, ctx) => {
+    const read = readConfiguredCall(
+      call,
+      ctx,
+      spec
+    );
+    if (read === null) {
+      return null;
+    }
+    return [
+      {
+        type: "interaction",
+        binding: messageBusBinding({
+          recognition: "@suss/framework-aws-sqs",
+          messageBus: "aws_sqs",
+          channel: read.subject
+        }),
+        callee: read.callee,
+        interaction: {
+          class: "message-send",
+          ...read.body !== null ? { body: read.body } : {}
+        }
+      }
+    ];
+  });
+}
+function sqsFramework(options = {}) {
+  const producers = options.producers ?? [];
+  return {
+    name: "sqs",
+    protocol: "sqs",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    // Skip files that don't import either `@aws-sdk/client-sqs`
+    // (producer side) or `aws-lambda` (consumer side; SQSEvent type).
+    // The recognizers' structural checks are quick but the import
+    // gate spares walking SQS-irrelevant files in monorepos.
+    requiresImport: [
+      .../* @__PURE__ */ new Set([
+        "@aws-sdk/client-sqs",
+        "aws-lambda",
+        ...producers.map((p) => p.module)
+      ])
+    ],
+    invocationRecognizers: [
+      sqsRecognizer,
+      messageReceiveRecognizer,
+      ...producers.map(configuredProducerRecognizer)
+    ]
+  };
+}
+var index_default = sqsFramework;
+export {
+  index_default as default
+};

package/dist/axios.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/client-axios';

package/dist/axios.js

@@ -0,0 +1,107 @@
+// ../client/axios/dist/index.js
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+function discoveryForVerb(verb, factories) {
+  const patterns = [
+    {
+      // Matches both shapes:
+      //   axios.<verb>("/path", ...)
+      //   const api = axios.create({ ... }); api.<verb>("/path", ...)
+      // The factoryMethods entry tells the adapter that variables initialized
+      // from axios.create(...) are also clients, wherever that call and
+      // this one turn out to live.
+      kind: "client",
+      match: {
+        type: "clientCall",
+        importModule: "axios",
+        importName: "axios",
+        methodFilter: [verb],
+        factoryMethods: ["create"]
+      },
+      bindingExtraction: {
+        method: { type: "literal", value: verb.toUpperCase() },
+        path: { type: "fromArgumentLiteral", position: 0 }
+      },
+      requiresImport: ["axios"]
+    }
+  ];
+  for (const factory of factories) {
+    patterns.push({
+      kind: "client",
+      match: {
+        type: "clientCall",
+        importModule: factory.module,
+        importName: factory.export,
+        methodFilter: [verb]
+      },
+      bindingExtraction: {
+        method: { type: "literal", value: verb.toUpperCase() },
+        path: { type: "fromArgumentLiteral", position: 0 }
+      },
+      // A bare specifier gates the way "axios" above does: cheap and
+      // exact, since two files spelling a package name the same way
+      // mean the same package. A path-shaped module ("./apiClient")
+      // points at a location relative to wherever it's written, and the
+      // pre-filter only ever reads a file's own import text before
+      // anything is parsed, so it has no way to tell "./apiClient"
+      // and a consumer's "../apiClient" apart from string text alone.
+      // Narrowing on that string would exclude the consumer roughly
+      // as often as include it, so a path-shaped factory gives no
+      // gate at all and every file is walked; the discovery layer
+      // resolves the module correctly once it's reading a file's
+      // imports against a parsed project.
+      requiresImport: isPathShapedSpecifier(factory.module) ? [] : [factory.module]
+    });
+  }
+  return patterns;
+}
+function isPathShapedSpecifier(specifier) {
+  return specifier.startsWith(".") || specifier.startsWith("/");
+}
+function axiosPack(options = {}) {
+  const factories = options.factories ?? [];
+  return {
+    name: "axios",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    discovery: HTTP_METHODS.flatMap(
+      (verb) => discoveryForVerb(verb, factories)
+    ),
+    terminals: [
+      {
+        kind: "return",
+        match: { type: "returnStatement" },
+        extraction: {}
+      },
+      {
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      }
+    ],
+    inputMapping: {
+      type: "positionalParams",
+      params: []
+    },
+    responseSemantics: [
+      // axios returns AxiosResponse: body lives on .data, not .body or .json()
+      { name: "data", access: "property", semantics: { type: "body" } },
+      { name: "status", access: "property", semantics: { type: "statusCode" } },
+      { name: "headers", access: "property", semantics: { type: "headers" } }
+    ],
+    // A non-2xx rejects, so the caller never gets a response to read a
+    // status off, and its catch is where every failure arrives.
+    failureDelivery: "exception"
+  };
+}
+var index_default = axiosPack;
+export {
+  index_default as default
+};

package/dist/cloudflare-workers.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-cloudflare-workers';