@suss/packs 0.11.0

package/dist/aws-dynamodb.js

@@ -0,0 +1,386 @@
+// ../framework/aws-dynamodb/dist/index.js
+import { Node as N } from "ts-morph";
+import { readName, rootIdentifier } from "@suss/adapter-typescript";
+import { storageBinding } from "@suss/behavioral-ir";
+var COMMAND_MODULES = [
+  "@aws-sdk/lib-dynamodb",
+  "@aws-sdk/client-dynamodb"
+];
+var RECOGNITION = "@suss/framework-aws-dynamodb";
+var COMMANDS = {
+  GetCommand: "read",
+  GetItemCommand: "read",
+  QueryCommand: "read",
+  ScanCommand: "read",
+  BatchGetCommand: "read",
+  BatchGetItemCommand: "read",
+  PutCommand: "write",
+  PutItemCommand: "write",
+  UpdateCommand: "write",
+  UpdateItemCommand: "write",
+  DeleteCommand: "write",
+  DeleteItemCommand: "write",
+  BatchWriteCommand: "write",
+  BatchWriteItemCommand: "write"
+};
+function dynamoRecognizer(call, ctx) {
+  const callNode = call;
+  const recognizerCtx = ctx;
+  const resolve = recognizerCtx.resolveWrittenValue ?? (() => null);
+  const callee = callNode.getExpression();
+  if (!N.isPropertyAccessExpression(callee) || callee.getName() !== "send") {
+    return null;
+  }
+  const firstArg = callNode.getArguments()[0];
+  if (firstArg === void 0) {
+    return null;
+  }
+  const built = N.isNewExpression(firstArg) ? firstArg : asNewExpression(resolve(firstArg));
+  if (built === null) {
+    return null;
+  }
+  const ctorExpr = built.getExpression();
+  const commandName = N.isPropertyAccessExpression(ctorExpr) ? ctorExpr.getName() : ctorExpr.getText();
+  const kind = COMMANDS[commandName];
+  if (kind === void 0) {
+    return null;
+  }
+  if (!fromDynamoModule(ctorExpr, recognizerCtx)) {
+    return null;
+  }
+  const input = built.getArguments()[0];
+  if (input === void 0 || !N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  return requestEffects({
+    input,
+    kind,
+    operation: commandName,
+    callee: callee.getText(),
+    transport: "aws-sdk",
+    resolve
+  });
+}
+function requestEffects(read) {
+  const { input, kind, operation, callee, resolve } = read;
+  const requestItems = property(input, "RequestItems");
+  if (requestItems !== null) {
+    return batchEffects(requestItems, read);
+  }
+  const picked = selector(input);
+  return [
+    {
+      type: "interaction",
+      binding: dynamoBinding(read, {
+        container: nameOfProperty(input, "TableName", resolve),
+        accessPath: nameOfProperty(input, "IndexName", resolve)
+      }),
+      callee,
+      interaction: {
+        class: "storage-access",
+        kind,
+        fields: fieldsOf(input, kind),
+        operation,
+        ...picked.length > 0 ? { selector: picked } : {}
+      }
+    }
+  ];
+}
+function dynamoBinding(read, addressed) {
+  return storageBinding({
+    recognition: RECOGNITION,
+    storageSystem: "aws.dynamodb",
+    ...read.transport === void 0 ? {} : { transport: read.transport },
+    scope: "default",
+    container: addressed.container,
+    accessPath: addressed.accessPath
+  });
+}
+function batchEffects(requestItems, read) {
+  const { kind, operation, callee, resolve } = read;
+  if (!N.isObjectLiteralExpression(requestItems)) {
+    return [];
+  }
+  const effects = [];
+  for (const entry of requestItems.getProperties()) {
+    if (!N.isPropertyAssignment(entry)) {
+      continue;
+    }
+    const requests = entry.getInitializer();
+    effects.push({
+      type: "interaction",
+      binding: dynamoBinding(read, {
+        container: entryName(entry, resolve),
+        accessPath: null
+      }),
+      callee,
+      interaction: {
+        class: "storage-access",
+        kind,
+        fields: requests === void 0 ? [] : requestedFields(requests, kind),
+        operation
+      }
+    });
+  }
+  return effects;
+}
+function entryName(entry, resolve) {
+  if (!N.isPropertyAssignment(entry)) {
+    return null;
+  }
+  const nameNode = entry.getNameNode();
+  if (N.isComputedPropertyName(nameNode)) {
+    return readName(nameNode.getExpression(), { resolve });
+  }
+  if (N.isStringLiteral(nameNode) || N.isIdentifier(nameNode)) {
+    return nameNode.getText().replace(/^["']|["']$/g, "");
+  }
+  return null;
+}
+function requestedFields(requests, kind) {
+  const found = /* @__PURE__ */ new Set();
+  requests.forEachDescendant((node) => {
+    if (!N.isPropertyAssignment(node)) {
+      return;
+    }
+    const name = node.getName();
+    if (name !== "Item" && name !== "Key" && name !== "Keys") {
+      return;
+    }
+    const value = node.getInitializer();
+    if (value === void 0) {
+      return;
+    }
+    for (const key of N.isArrayLiteralExpression(value) ? value.getElements().flatMap((element) => objectKeys(element)) : objectKeys(value)) {
+      found.add(key);
+    }
+  });
+  return found.size > 0 ? [...found] : kind === "read" ? ["*"] : [];
+}
+function asNewExpression(resolved) {
+  return resolved !== null && N.isNewExpression(resolved) ? resolved : null;
+}
+function fromDynamoModule(ctorExpr, ctx) {
+  const target = N.isPropertyAccessExpression(ctorExpr) ? rootIdentifier(ctorExpr) : ctorExpr;
+  if (target === null) {
+    return false;
+  }
+  return COMMAND_MODULES.some((module) => ctx.isImportedFrom(target, module));
+}
+function property(input, name) {
+  if (!N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  for (const prop of input.getProperties()) {
+    if (N.isPropertyAssignment(prop) && prop.getName() === name) {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function nameOfProperty(input, name, resolve) {
+  const written = property(input, name);
+  return written === null ? null : readName(written, { resolve, unsettled: "reference" });
+}
+function fieldsOf(input, kind) {
+  const projection = property(input, "ProjectionExpression");
+  if (projection !== null) {
+    const text = literalText(projection);
+    if (text !== null) {
+      const aliases = expressionNames(input);
+      return text.split(",").map((field) => field.trim()).filter((field) => field !== "").map((field) => aliases.get(field) ?? field);
+    }
+  }
+  if (kind === "write") {
+    const item = property(input, "Item");
+    if (item !== null && N.isObjectLiteralExpression(item)) {
+      return objectKeys(item);
+    }
+  }
+  return kind === "read" ? ["*"] : [];
+}
+function selector(input) {
+  const key = property(input, "Key");
+  if (key !== null && N.isObjectLiteralExpression(key)) {
+    return objectKeys(key);
+  }
+  const condition = property(input, "KeyConditionExpression");
+  const text = condition === null ? null : literalText(condition);
+  if (text === null) {
+    return [];
+  }
+  return keyConditionAttributes(text, expressionNames(input));
+}
+function expressionNames(input) {
+  const names = /* @__PURE__ */ new Map();
+  const declared = property(input, "ExpressionAttributeNames");
+  if (declared === null || !N.isObjectLiteralExpression(declared)) {
+    return names;
+  }
+  for (const prop of declared.getProperties()) {
+    if (!N.isPropertyAssignment(prop)) {
+      continue;
+    }
+    const value = prop.getInitializer();
+    const written = value === void 0 ? null : literalText(value);
+    if (written === null) {
+      continue;
+    }
+    names.set(prop.getName().replace(/^["']|["']$/g, ""), written);
+  }
+  return names;
+}
+function literalText(value) {
+  return N.isStringLiteral(value) || N.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
+}
+var ATTRIBUTE_POSITIONS = [
+  /([#\w.]+)\s*(?:<>|<=|>=|=|<|>)/g,
+  /\(\s*([#\w.]+)\s*,/g,
+  /([#\w.]+)\s+[A-Za-z_]+\s+:/g
+];
+function keyConditionAttributes(expression, names) {
+  const found = [];
+  const add = (token) => {
+    if (token === void 0) {
+      return;
+    }
+    const name = token.startsWith("#") ? names.get(token) : token;
+    if (name !== void 0 && !found.includes(name)) {
+      found.push(name);
+    }
+  };
+  for (const pattern of ATTRIBUTE_POSITIONS) {
+    for (const match of expression.matchAll(pattern)) {
+      add(match[1]);
+    }
+  }
+  return found;
+}
+function objectKeys(literal) {
+  if (!N.isObjectLiteralExpression(literal)) {
+    return [];
+  }
+  const keys = [];
+  for (const prop of literal.getProperties()) {
+    if (N.isPropertyAssignment(prop) || N.isShorthandPropertyAssignment(prop)) {
+      keys.push(prop.getName().replace(/^["']|["']$/g, ""));
+    }
+  }
+  return keys;
+}
+function requestFunctionRecognizer(spec) {
+  return ((call, ctx) => {
+    const callNode = call;
+    const recognizerCtx = ctx;
+    const resolve = recognizerCtx.resolveWrittenValue ?? (() => null);
+    const callee = callNode.getExpression();
+    if (calledName(callee) !== spec.name) {
+      return null;
+    }
+    if (spec.module !== void 0 && !declaredIn(callee, spec.module, recognizerCtx)) {
+      return null;
+    }
+    const args = callNode.getArguments();
+    const operation = argumentText(args[spec.operationArg], resolve);
+    if (operation === null) {
+      return null;
+    }
+    const kind = spec.operations[operation];
+    if (kind === void 0) {
+      return null;
+    }
+    const input = objectArgument(args[spec.requestArg], resolve);
+    if (input === null) {
+      return null;
+    }
+    return requestEffects({
+      input,
+      kind,
+      operation,
+      callee: callee.getText(),
+      resolve
+    });
+  });
+}
+function calledName(callee) {
+  if (N.isPropertyAccessExpression(callee)) {
+    return callee.getName();
+  }
+  return N.isIdentifier(callee) ? callee.getText() : null;
+}
+function declaredIn(callee, module, ctx) {
+  const target = N.isPropertyAccessExpression(callee) ? rootIdentifier(callee) : callee;
+  return target !== null && ctx.isImportedFrom(target, module);
+}
+function argumentText(arg, resolve) {
+  if (arg === void 0) {
+    return null;
+  }
+  const direct = literalText(arg);
+  if (direct !== null) {
+    return direct;
+  }
+  const written = resolve(arg);
+  return written === null ? null : literalText(written);
+}
+function objectArgument(arg, resolve) {
+  if (arg === void 0) {
+    return null;
+  }
+  if (N.isObjectLiteralExpression(arg)) {
+    return arg;
+  }
+  const written = resolve(arg);
+  return written !== null && N.isObjectLiteralExpression(written) ? written : null;
+}
+var isArgumentPosition = (index) => Number.isInteger(index) && index >= 0;
+function checkRequestFunction(spec, at) {
+  const complain = (problem) => {
+    throw new Error(`requestFunctions[${at}] ${problem}`);
+  };
+  if (typeof spec.name !== "string" || spec.name === "") {
+    complain("needs the name of a function to read.");
+  }
+  if (!isArgumentPosition(spec.operationArg)) {
+    complain("needs operationArg: which argument says the operation, from 0.");
+  }
+  if (!isArgumentPosition(spec.requestArg)) {
+    complain("needs requestArg: which argument is the request, from 0.");
+  }
+  const operations = Object.entries(spec.operations ?? {});
+  if (operations.length === 0) {
+    complain("needs operations, saying what each one does to the table.");
+  }
+  for (const [operation, kind] of operations) {
+    if (kind !== "read" && kind !== "write") {
+      complain(`gives ${operation} as ${String(kind)}, not read or write.`);
+    }
+  }
+}
+function dynamoFramework(options = {}) {
+  const requestFunctions = options.requestFunctions ?? [];
+  requestFunctions.forEach(checkRequestFunction);
+  return {
+    name: "aws-dynamodb",
+    protocol: "dynamodb",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    requiresImport: [
+      .../* @__PURE__ */ new Set([
+        ...COMMAND_MODULES,
+        ...options.requiresImport ?? [],
+        ...requestFunctions.map((spec) => spec.module).filter((module) => module !== void 0)
+      ])
+    ],
+    invocationRecognizers: [
+      dynamoRecognizer,
+      ...requestFunctions.map(requestFunctionRecognizer)
+    ]
+  };
+}
+var index_default = dynamoFramework;
+export {
+  index_default as default
+};

package/dist/aws-eventbridge.d.ts

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

package/dist/aws-eventbridge.js

@@ -0,0 +1,240 @@
+// ../framework/aws-eventbridge/dist/index.js
+import {
+  Node as N
+} from "ts-morph";
+import { readConfiguredCall, rootIdentifier } from "@suss/adapter-typescript";
+import { formatChannel, messageBusBinding } from "@suss/behavioral-ir";
+import { unwrapJsonStringify } from "@suss/extractor";
+var SEND_COMMANDS = {
+  PutEventsCommand: "putEvents"
+};
+function eventBridgeRecognizer(call, ctx) {
+  const callNode = call;
+  const recognizerCtx = ctx;
+  const resolveValue = recognizerCtx.resolveWrittenValue ?? (() => null);
+  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();
+  if (SEND_COMMANDS[ctorLeafName] === void 0) {
+    return null;
+  }
+  const importCheckTarget = N.isPropertyAccessExpression(ctorExpr) ? rootIdentifier(ctorExpr) : ctorExpr;
+  if (importCheckTarget === null || !recognizerCtx.isImportedFrom(
+    importCheckTarget,
+    "@aws-sdk/client-eventbridge"
+  )) {
+    return null;
+  }
+  const callArgs = recognizerCtx.extractArgs();
+  const entries = readEntries(callArgs);
+  if (entries === null) {
+    return null;
+  }
+  const callee = callNode.getExpression().getText();
+  const astEntries = readAstEntries(firstArg);
+  const effects = [];
+  for (const [index, entry] of entries.entries()) {
+    const effect = buildEntryEffect(
+      entry,
+      callee,
+      astEntries?.[index],
+      resolveValue
+    );
+    if (effect !== null) {
+      effects.push(effect);
+    }
+  }
+  return effects.length > 0 ? effects : null;
+}
+function readAstEntries(command) {
+  if (!N.isNewExpression(command)) {
+    return null;
+  }
+  const input = command.getArguments()[0];
+  if (input === void 0 || !N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  for (const prop of input.getProperties()) {
+    if (!N.isPropertyAssignment(prop) || prop.getName() !== "Entries") {
+      continue;
+    }
+    const init = prop.getInitializer();
+    if (init === void 0 || !N.isArrayLiteralExpression(init)) {
+      return null;
+    }
+    return init.getElements();
+  }
+  return null;
+}
+function astField(entry, name) {
+  if (entry === void 0 || !N.isObjectLiteralExpression(entry)) {
+    return null;
+  }
+  for (const prop of entry.getProperties()) {
+    if (N.isPropertyAssignment(prop) && prop.getName() === name) {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function busTokenOf(expr) {
+  if (N.isStringLiteral(expr)) {
+    const value = expr.getLiteralValue();
+    return value === "" ? null : value;
+  }
+  const match = expr.getText().match(/^process\.env\.(\w+)$/);
+  return match === null ? null : match[1] ?? null;
+}
+function detailTypeOf(expr) {
+  if (!N.isStringLiteral(expr)) {
+    return null;
+  }
+  const value = expr.getLiteralValue();
+  return value === "" ? null : value;
+}
+function resolvedHalf(entry, name, readToken, resolve) {
+  const expr = astField(entry, name);
+  if (expr === null) {
+    return null;
+  }
+  const direct = readToken(expr);
+  if (direct !== null) {
+    return direct;
+  }
+  const resolved = resolve(expr);
+  return resolved === null ? null : readToken(resolved);
+}
+function readEntries(callArgs) {
+  const commandArg = callArgs[0];
+  if (!isEffectArgOfKind(commandArg, "call")) {
+    return null;
+  }
+  const ctorArgs = commandArg.args ?? [];
+  const inputArg = ctorArgs[0];
+  if (!isEffectArgOfKind(inputArg, "object")) {
+    return null;
+  }
+  const fields = inputArg.fields;
+  const entriesArg = fields?.Entries;
+  if (!isEffectArgOfKind(entriesArg, "array")) {
+    return null;
+  }
+  return entriesArg.items ?? [];
+}
+function buildEntryEffect(entry, callee, astEntry, resolve) {
+  if (!isEffectArgOfKind(entry, "object")) {
+    return null;
+  }
+  const fields = entry.fields;
+  const bus = fields.EventBusName === void 0 ? readBusToken(void 0) : resolvedHalf(astEntry, "EventBusName", busTokenOf, resolve) ?? readBusToken(fields.EventBusName);
+  const detailType = resolvedHalf(astEntry, "DetailType", detailTypeOf, resolve) ?? readLiteralString(fields.DetailType);
+  const channel = bus === null || detailType === null ? null : formatChannel(bus, detailType);
+  const body = unwrapJsonStringify(fields.Detail ?? null);
+  const source = readLiteralString(fields.Source);
+  return {
+    type: "interaction",
+    binding: messageBusBinding({
+      recognition: "@suss/framework-aws-eventbridge",
+      messageBus: "eventbridge",
+      channel
+    }),
+    callee,
+    interaction: {
+      class: "message-send",
+      ...body !== null ? { body } : {},
+      ...source !== null ? { routingKey: source } : {}
+    }
+  };
+}
+function readBusToken(arg) {
+  if (arg === void 0) {
+    return "default";
+  }
+  if (isEffectArgOfKind(arg, "string")) {
+    const value = arg.value;
+    return value === "" ? null : value;
+  }
+  if (isEffectArgOfKind(arg, "identifier")) {
+    const name = arg.name;
+    const match = name.match(/^process\.env\.(\w+)$/);
+    return match !== null ? match[1] : null;
+  }
+  return null;
+}
+function readLiteralString(arg) {
+  if (isEffectArgOfKind(arg, "string")) {
+    const value = arg.value;
+    return value === "" ? null : value;
+  }
+  return null;
+}
+function isEffectArgOfKind(arg, kind) {
+  return arg !== null && arg !== void 0 && typeof arg === "object" && arg.kind === kind;
+}
+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-eventbridge",
+          messageBus: "eventbridge",
+          channel: read.subject
+        }),
+        callee: read.callee,
+        interaction: {
+          class: "message-send",
+          ...read.body !== null ? { body: read.body } : {}
+        }
+      }
+    ];
+  });
+}
+function eventBridgeFramework(options = {}) {
+  const producers = options.producers ?? [];
+  return {
+    name: "eventbridge",
+    protocol: "eventbridge",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    // Skip files that don't import `@aws-sdk/client-eventbridge`.
+    requiresImport: [
+      .../* @__PURE__ */ new Set([
+        "@aws-sdk/client-eventbridge",
+        ...producers.map((p) => p.module)
+      ])
+    ],
+    invocationRecognizers: [
+      eventBridgeRecognizer,
+      ...producers.map(configuredProducerRecognizer)
+    ]
+  };
+}
+var index_default = eventBridgeFramework;
+export {
+  index_default as default
+};

package/dist/aws-lambda.d.ts

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