@suss/packs 0.12.0 → 0.13.0

package/dist/aws-dynamodb.js

@@ -1,237 +1,127 @@
 // ../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";
+import { constructedFrom, pack, storageCalls } from "@suss/recognize";
 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"
+var COMMAND = {
+  to: "argument",
+  at: { from: 0 },
+  origin: constructedFrom(...COMMAND_MODULES)
 };
-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)) {
+var COMMAND_INPUT = { at: 0 };
+var TABLE = { at: 0, property: ["TableName"] };
+var INDEX = { at: 0, property: ["IndexName"] };
+var TABLES = { at: 0, property: ["RequestItems"] };
+var ATTRIBUTES = ({ input, entry, kind }) => {
+  if (entry !== null) {
+    const requested = requestedAttributes(entry);
+    return requested.length > 0 ? requested : everything(kind);
+  }
+  const projected = projectedAttributes(input);
+  if (projected !== null) {
+    return projected;
+  }
+  const written = namesIn(input.property("Item"));
+  return kind === "write" && written.length > 0 ? written : everything(kind);
+};
+var KEY_ATTRIBUTES = ({ input, entry }) => {
+  if (entry !== null) {
     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 });
+  const key = namesIn(input.property("Key"));
+  if (key.length > 0) {
+    return key;
   }
-  if (N.isStringLiteral(nameNode) || N.isIdentifier(nameNode)) {
-    return nameNode.getText().replace(/^["']|["']$/g, "");
-  }
-  return null;
+  const condition = input.property("KeyConditionExpression")?.text() ?? null;
+  return condition === null ? [] : keyConditionAttributes(condition, aliasesIn(input));
+};
+function everything(kind) {
+  return kind === "read" ? ["*"] : [];
 }
-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);
+var READ = {
+  kind: "read",
+  fields: ATTRIBUTES,
+  selector: KEY_ATTRIBUTES
+};
+var WRITE = {
+  kind: "write",
+  fields: ATTRIBUTES,
+  selector: KEY_ATTRIBUTES
+};
+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
+};
+var COMMAND_CALLS = storageCalls({
+  system: "aws.dynamodb",
+  transport: "aws-sdk"
+}).about(COMMAND).methods(COMMANDS).input(COMMAND_INPUT).container(TABLE).accessPath(INDEX).containersIn(TABLES).example(
+  'client.send(new GetCommand({ TableName: "orders-v1", Key: { orderId: "a" } }))'
+);
+function namesIn(value) {
+  const found = [];
+  for (const entry of value?.entries("nothing") ?? []) {
+    if (entry.key !== null) {
+      found.push(entry.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));
+  return found;
 }
-function property(input, name) {
-  if (!N.isObjectLiteralExpression(input)) {
+function projectedAttributes(input) {
+  const projection = input.property("ProjectionExpression")?.text() ?? null;
+  if (projection === null) {
     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" ? ["*"] : [];
+  const aliases = aliasesIn(input);
+  return projection.split(",").map((field) => field.trim()).filter((field) => field !== "").map((field) => aliases.get(field) ?? field);
 }
-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) {
+function aliasesIn(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;
+  const declared = input.property("ExpressionAttributeNames");
+  for (const entry of declared?.entries("nothing") ?? []) {
+    const written = entry.value.text();
+    if (entry.key !== null && written !== null) {
+      names.set(entry.key, written);
     }
-    names.set(prop.getName().replace(/^["']|["']$/g, ""), written);
   }
   return names;
 }
-function literalText(value) {
-  return N.isStringLiteral(value) || N.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
+var REQUESTED = ["Item", "Key", "Keys"];
+function requestedAttributes(requests) {
+  const found = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    for (const item of value.items()) {
+      walk(item);
+    }
+    for (const entry of value.entries("nothing")) {
+      if (entry.key !== null && REQUESTED.includes(entry.key)) {
+        for (const name of attributeNames(entry.value)) {
+          found.add(name);
+        }
+      }
+      walk(entry.value);
+    }
+  };
+  walk(requests);
+  return [...found];
+}
+function attributeNames(value) {
+  const items = value.items();
+  return items.length > 0 ? items.flatMap(namesIn) : namesIn(value);
 }
 var ATTRIBUTE_POSITIONS = [
   /([#\w.]+)\s*(?:<>|<=|>=|=|<|>)/g,
@@ -256,82 +146,40 @@ function keyConditionAttributes(expression, names) {
   }
   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 requestFunctionCalls(spec) {
+  const operation = { at: spec.operationArg };
+  const request = (property) => ({
+    at: spec.requestArg,
+    property: [property]
   });
+  return storageCalls({
+    system: "aws.dynamodb",
+    ...spec.module === void 0 ? {} : { client: constructedFrom(spec.module) }
+  }).methods({
+    [spec.name]: {
+      operation,
+      kind: { asks: operation, means: spec.operations },
+      fields: ATTRIBUTES,
+      selector: KEY_ATTRIBUTES
+    }
+  }).input({ at: spec.requestArg }).container(request("TableName")).accessPath(request("IndexName")).containersIn(request("RequestItems")).example(exampleCall(spec));
 }
-function calledName(callee) {
-  if (N.isPropertyAccessExpression(callee)) {
-    return callee.getName();
+function exampleCall(spec) {
+  const [operation] = Object.keys(spec.operations);
+  const written = [];
+  for (let at = 0; at <= Math.max(spec.operationArg, spec.requestArg); at++) {
+    written.push(argumentText(spec, at, operation ?? ""));
   }
-  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);
+  return `${spec.name}(${written.join(", ")})`;
 }
-function argumentText(arg, resolve) {
-  if (arg === void 0) {
-    return null;
+function argumentText(spec, at, operation) {
+  if (at === spec.operationArg) {
+    return JSON.stringify(operation);
   }
-  const direct = literalText(arg);
-  if (direct !== null) {
-    return direct;
+  if (at === spec.requestArg) {
+    return '{ TableName: "orders-v1", Key: { orderId: "a" } }';
   }
-  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;
+  return "undefined";
 }
 var isArgumentPosition = (index) => Number.isInteger(index) && index >= 0;
 function checkRequestFunction(spec, at) {
@@ -360,25 +208,16 @@ function checkRequestFunction(spec, at) {
 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)
-    ]
-  };
+  return pack(
+    "aws-dynamodb",
+    [COMMAND_CALLS, ...requestFunctions.map(requestFunctionCalls)],
+    {
+      languages: ["typescript", "javascript"],
+      recognizedAs: RECOGNITION,
+      protocol: "dynamodb",
+      ...options.requiresImport === void 0 ? {} : { requiresImport: options.requiresImport }
+    }
+  );
 }
 var index_default = dynamoFramework;
 export {

package/dist/aws-s3.js

@@ -1,118 +1,38 @@
 // ../framework/aws-s3/dist/index.js
-import { Node as N } from "ts-morph";
-import { readName, rootIdentifier } from "@suss/adapter-typescript";
-import { storageBinding } from "@suss/behavioral-ir";
-var RECOGNITION = "@suss/framework-aws-s3";
+import { constructedFrom, pack, storageCalls } from "@suss/recognize";
 var COMMAND_MODULE = "@aws-sdk/client-s3";
+var COMMAND = { to: "argument", at: { from: 0 } };
+var ADDRESSED = { at: 0, property: ["Key", "Prefix"] };
+var BUCKET = { at: 0, property: ["Bucket"] };
+var READ_OBJECT = { kind: "read", selector: ADDRESSED };
+var WRITE_OBJECT = { kind: "write", selector: ADDRESSED };
 var COMMANDS = {
-  GetObjectCommand: "read",
-  HeadObjectCommand: "read",
-  ListObjectsV2Command: "read",
-  ListObjectsCommand: "read",
-  PutObjectCommand: "write",
-  DeleteObjectCommand: "write",
-  DeleteObjectsCommand: "write",
-  CopyObjectCommand: "write",
+  GetObjectCommand: READ_OBJECT,
+  HeadObjectCommand: READ_OBJECT,
+  ListObjectsV2Command: READ_OBJECT,
+  ListObjectsCommand: READ_OBJECT,
+  PutObjectCommand: WRITE_OBJECT,
+  DeleteObjectCommand: WRITE_OBJECT,
+  DeleteObjectsCommand: WRITE_OBJECT,
+  CopyObjectCommand: WRITE_OBJECT,
   // A large object goes up in parts, and each command in that sequence
   // writes the same object.
-  CreateMultipartUploadCommand: "write",
-  UploadPartCommand: "write",
-  CompleteMultipartUploadCommand: "write",
-  AbortMultipartUploadCommand: "write"
+  CreateMultipartUploadCommand: WRITE_OBJECT,
+  UploadPartCommand: WRITE_OBJECT,
+  CompleteMultipartUploadCommand: WRITE_OBJECT,
+  AbortMultipartUploadCommand: WRITE_OBJECT
 };
-function s3Recognizer(call, ctx) {
-  const callNode = call;
-  const recognizerCtx = ctx;
-  const resolve = recognizerCtx.resolveWrittenValue ?? (() => null);
-  const built = commandArgument(callNode, resolve);
-  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 || !fromS3Module(ctorExpr, recognizerCtx)) {
-    return null;
-  }
-  const input = built.getArguments()[0];
-  if (input === void 0 || !N.isObjectLiteralExpression(input)) {
-    return null;
-  }
-  const key = nameOfProperty(input, "Key", resolve);
-  const prefix = nameOfProperty(input, "Prefix", resolve);
-  const addressed = key ?? prefix;
-  return [
-    {
-      type: "interaction",
-      binding: storageBinding({
-        recognition: RECOGNITION,
-        storageSystem: "s3",
-        transport: "aws-sdk",
-        scope: "default",
-        container: nameOfProperty(input, "Bucket", resolve),
-        accessPath: null
-      }),
-      callee: callNode.getExpression().getText(),
-      interaction: {
-        class: "storage-access",
-        kind,
-        // An object has no fields, so a call says nothing about any.
-        fields: [],
-        operation: commandName,
-        ...addressed !== null ? { selector: [addressed] } : {}
-      }
-    }
-  ];
-}
-function commandArgument(call, resolve) {
-  for (const arg of call.getArguments()) {
-    if (N.isNewExpression(arg)) {
-      return arg;
-    }
-    if (!N.isIdentifier(arg) || !typedAsCommand(arg)) {
-      continue;
-    }
-    const written = resolve(arg);
-    if (written !== null && N.isNewExpression(written)) {
-      return written;
-    }
-  }
-  return null;
-}
-function typedAsCommand(value) {
-  const declared = value.getType().getSymbol();
-  return declared !== void 0 && COMMANDS[declared.getName()] !== void 0;
-}
-function fromS3Module(ctorExpr, ctx) {
-  const target = N.isPropertyAccessExpression(ctorExpr) ? rootIdentifier(ctorExpr) : ctorExpr;
-  return target !== null && ctx.isImportedFrom(target, COMMAND_MODULE);
-}
-function nameOfProperty(input, name, resolve) {
-  const written = property(input, name);
-  return written === null ? null : readName(written, { resolve, unsettled: "reference" });
-}
-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;
-}
+var OBJECT_CALLS = storageCalls({
+  system: "s3",
+  transport: "aws-sdk",
+  client: constructedFrom(COMMAND_MODULE)
+}).about(COMMAND).methods(COMMANDS).container(BUCKET).example('s3.send(new GetObjectCommand({ Bucket: "photos", Key: "a.jpg" }))');
 function s3Framework() {
-  return {
-    name: "aws-s3",
-    protocol: "s3",
+  return pack("aws-s3", [OBJECT_CALLS], {
     languages: ["typescript", "javascript"],
-    discovery: [],
-    terminals: [],
-    inputMapping: { type: "positionalParams", params: [] },
-    requiresImport: [COMMAND_MODULE],
-    invocationRecognizers: [s3Recognizer]
-  };
+    recognizedAs: "@suss/framework-aws-s3",
+    protocol: "s3"
+  });
 }
 var index_default = s3Framework;
 export {

package/dist/axios.js

@@ -27,7 +27,7 @@ function discoveryForVerb(verb, factories) {
       },
       bindingExtraction: {
         method: { type: "literal", value: verb.toUpperCase() },
-        path: { type: "fromArgumentLiteral", position: 0 }
+        path: { type: "fromArgument", position: 0 }
       },
       requiresImport: ["axios"]
     }
@@ -43,7 +43,7 @@ function discoveryForVerb(verb, factories) {
       },
       bindingExtraction: {
         method: { type: "literal", value: verb.toUpperCase() },
-        path: { type: "fromArgumentLiteral", position: 0 }
+        path: { type: "fromArgument", position: 0 }
       },
       // A bare specifier gates the way "axios" above does: cheap and
       // exact, since two files spelling a package name the same way