@suss/packs 0.29.0 → 0.31.0

package/dist/activerecord.js

@@ -29,6 +29,43 @@ var RETURNS_A_RECORD = [
   "create!",
   "reload"
 ];
+var RUNS_A_QUERY = [
+  "find",
+  "find_by",
+  "find_by!",
+  "find_sole_by",
+  "sole",
+  "first",
+  "first!",
+  "last",
+  "last!",
+  "take",
+  "take!",
+  "exists?",
+  "count",
+  "size",
+  "any?",
+  "none?",
+  "many?",
+  "empty?",
+  "pluck",
+  "pick",
+  "ids",
+  "sum",
+  "average",
+  "minimum",
+  "maximum",
+  "calculate",
+  "to_a",
+  "each",
+  "map",
+  "find_each",
+  "find_in_batches",
+  "in_batches",
+  "load",
+  "reload",
+  "find_or_initialize_by"
+];
 var RETURNS_A_RELATION = [
   "where",
   "rewhere",
@@ -60,6 +97,7 @@ var RETURNS_A_RELATION = [
   "only",
   "except"
 ];
+var READS = [...RUNS_A_QUERY, ...RETURNS_A_RELATION, "not"];
 function activeRecordStorage(options) {
   return [
     {
@@ -81,9 +119,24 @@ function activeRecordStorage(options) {
         "destroy_all",
         "delete",
         "delete_all",
-        "touch"
+        "touch",
+        // These two read first and store only when the read found
+        // nothing, and a write is the stronger of the two claims.
+        "find_or_create_by",
+        "find_or_create_by!"
       ],
+      reads: READS,
       givesBack: [...RETURNS_A_RECORD, ...RETURNS_A_RELATION],
+      byPrimaryKey: {
+        methods: ["find", "exists?", "update", "destroy", "delete"],
+        column: "id"
+      },
+      columnArguments: ["select", "pluck", "pick"],
+      associations: {
+        singular: ["has_one", "belongs_to"],
+        plural: ["has_many", "has_and_belongs_to_many"],
+        classNameKeyword: "class_name"
+      },
       storageSystem: options.storageSystem
     }
   ];
@@ -108,7 +161,7 @@ var declares = {
     { ecosystem: "rubygems", name: "activerecord" },
     { ecosystem: "rubygems", name: "rails" }
   ],
-  reads: "ActiveRecord calls (Ruby): a call matches when the constant its receivers start at reaches `ActiveRecord::Base`, following what each class extends through the project.",
+  reads: "ActiveRecord calls (Ruby): a call matches when its method is one ActiveRecord defines as a read or a write and the class behind its receiver reaches `ActiveRecord::Base`, following what each class extends through the project.",
   configuration: {
     file: "suss.activerecord.json",
     example: { storageSystem: "postgresql" },

package/dist/aiohttp.js

@@ -27,7 +27,10 @@ function aiohttpClient() {
         },
         receiverConstructors: ["ClientSession"]
       }
-    ]
+    ],
+    // `ClientSession.__aenter__` returns the session, so `async with
+    // aiohttp.ClientSession() as s` puts the constructed session in s.
+    contextManagers: [{ module: "aiohttp", returnsSelf: ["ClientSession"] }]
   };
 }
 var declares = {

package/dist/aws-sqs.js

@@ -1,7 +1,7 @@
 // ../framework/aws-sqs/dist/index.js
 import { Node as N } from "ts-morph";
 import { z } from "zod";
-import { readConfiguredCall } from "@suss/adapter-typescript";
+import { climbSyntax, readConfiguredCall } from "@suss/adapter-typescript";
 import { messageBusBinding } from "@suss/behavioral-ir";
 import { configuredCallOption } from "@suss/extractor";
 import { constructedFrom, messageSends, pack } from "@suss/recognize";
@@ -123,10 +123,7 @@ function isSqsRecordIdentifier(recordExpr) {
   return false;
 }
 function extractDestructuredFields(call) {
-  let parent = call.getParent();
-  while (parent !== void 0 && (N.isAsExpression(parent) || N.isParenthesizedExpression(parent))) {
-    parent = parent.getParent();
-  }
+  const parent = climbSyntax(call).getParent();
   if (parent === void 0 || !N.isVariableDeclaration(parent)) {
     return null;
   }

package/dist/{chunk-CZY5QLMS.js → chunk-NYWZHQBJ.js}

@@ -96,7 +96,8 @@ function sqlalchemyModels() {
       baseNames: MODEL_BASE_NAMES,
       givesBack: [...NARROWS_A_QUERY, ...RUNS_A_QUERY],
       entryMethods: SESSION_ENTRY_METHODS,
-      entryFunctions: [{ module: "sqlalchemy", name: "select", argument: 0 }]
+      entryFunctions: [{ module: "sqlalchemy", name: "select", argument: 0 }],
+      relationships: [{ module: "sqlalchemy.orm", name: "relationship" }]
     }
   ];
 }

package/dist/cloudflare-workers.js

@@ -1,10 +1,21 @@
 // ../framework/cloudflare-workers/dist/index.js
 import { z } from "zod";
 import { Node as N } from "ts-morph";
+import {
+  functionValueOf,
+  propertiesOf,
+  propertyFunctionOf,
+  propertyNameOf
+} from "@suss/adapter-typescript";
 import { Node as N2 } from "ts-morph";
+import {
+  isDefaultedAt,
+  propertyFunctionOf as propertyFunctionOf2,
+  propertyNameOf as propertyNameOf2
+} from "@suss/adapter-typescript";
 import { runtimeConfigBinding } from "@suss/behavioral-ir";
 import { Node as N3 } from "ts-morph";
-import { readName as readName2 } from "@suss/adapter-typescript";
+import { readName as readName2, stringValueOf } from "@suss/adapter-typescript";
 import { storageBinding } from "@suss/behavioral-ir";
 import { readSqlAccess } from "@suss/sql";
 var TRIGGERS = {
@@ -29,9 +40,13 @@ var TRIGGERS = {
 };
 var METADATA_NAMESPACE = "cloudflareWorkers";
 function cloudflareWorkersDiscovery(options = {}) {
-  return (sourceFile) => {
+  return (sourceFile, ctx) => {
     const sf = sourceFile;
-    const triggers = [...defaultExportTriggers(sf), ...listenerTriggers(sf)];
+    const { resolution } = ctx;
+    const triggers = [
+      ...defaultExportTriggers(sf, resolution),
+      ...listenerTriggers(sf, resolution)
+    ];
     const units = [];
     const taken = /* @__PURE__ */ new Set();
     for (const trigger of triggers) {
@@ -66,124 +81,58 @@ function unitFor(trigger, scriptName) {
     }
   };
 }
-function defaultExportTriggers(sf) {
-  const literal = defaultExportObject(sf);
+function defaultExportTriggers(sf, resolution) {
+  const literal = defaultExportObject(sf, resolution);
   if (literal === null) {
     return [];
   }
   const triggers = [];
-  for (const property of literal.getProperties()) {
-    const found = triggerOfProperty(property, sf);
-    if (found !== null) {
-      triggers.push(found);
+  for (const property of propertiesOf(literal, resolution)) {
+    const name = propertyNameOf(property);
+    if (name === null || TRIGGERS[name] === void 0) {
+      continue;
+    }
+    const func = propertyFunctionOf(property, resolution);
+    if (func !== null) {
+      triggers.push({ name, func, registration: "default-export" });
     }
   }
   return triggers;
 }
-function triggerOfProperty(property, sf) {
-  const named = propertyName(property);
-  if (named === null || TRIGGERS[named] === void 0) {
-    return null;
-  }
-  const func = functionOfProperty(property, sf);
-  return func === null ? null : { name: named, func, registration: "default-export" };
+function entrypointTriggerFunctions(sf, resolution) {
+  let perRun = triggerFunctionsPerRun.get(resolution);
+  if (perRun === void 0) {
+    perRun = /* @__PURE__ */ new Map();
+    triggerFunctionsPerRun.set(resolution, perRun);
+  }
+  const filePath = sf.getFilePath();
+  let found = perRun.get(filePath);
+  if (found === void 0) {
+    found = new Set(
+      defaultExportTriggers(sf, resolution).map((trigger) => trigger.func)
+    );
+    perRun.set(filePath, found);
+  }
+  return found;
 }
-function propertyName(property) {
-  if (N.isMethodDeclaration(property) || N.isPropertyAssignment(property)) {
-    const name = property.getNameNode();
-    if (N.isIdentifier(name)) {
-      return name.getText();
+var triggerFunctionsPerRun = /* @__PURE__ */ new WeakMap();
+function defaultExportObject(sf, resolution) {
+  for (const exported of resolution.exportsOf(sf).get("default") ?? []) {
+    const object = resolution.resolveObject(exported);
+    if (object !== null && N.isObjectLiteralExpression(object)) {
+      return object;
     }
-    return N.isStringLiteral(name) ? name.getLiteralValue() : null;
-  }
-  return N.isShorthandPropertyAssignment(property) ? property.getName() : null;
-}
-function functionOfProperty(property, sf) {
-  if (N.isMethodDeclaration(property)) {
-    return property;
-  }
-  if (N.isPropertyAssignment(property)) {
-    const written = property.getInitializer();
-    return written === void 0 ? null : functionBehind(written, sf);
-  }
-  if (N.isShorthandPropertyAssignment(property)) {
-    return functionBehind(property.getNameNode(), sf);
   }
   return null;
 }
-function functionBehind(expression, sf) {
-  if (N.isArrowFunction(expression) || N.isFunctionExpression(expression)) {
-    return expression;
-  }
-  if (!N.isIdentifier(expression)) {
-    return null;
-  }
-  for (const definition of expression.getDefinitionNodes()) {
-    const declared = declaredFunction(definition);
-    if (declared !== null) {
-      return declared;
-    }
-  }
-  return localFunction(sf, expression.getText());
-}
-function declaredFunction(definition) {
-  if (N.isFunctionDeclaration(definition)) {
-    return definition;
-  }
-  if (!N.isVariableDeclaration(definition)) {
-    return null;
-  }
-  const written = definition.getInitializer();
-  if (written === void 0) {
-    return null;
-  }
-  return N.isArrowFunction(written) || N.isFunctionExpression(written) ? written : null;
-}
-function localFunction(sf, name) {
-  const declaration = sf.getFunction(name);
-  if (declaration !== void 0) {
-    return declaration;
-  }
-  const variable = sf.getVariableDeclaration(name);
-  return variable === void 0 ? null : declaredFunction(variable);
-}
-function defaultExportObject(sf) {
-  const assignment = sf.getExportAssignment((a) => !a.isExportEquals());
-  if (assignment === void 0) {
-    return null;
-  }
-  return objectBehind(unwrap(assignment.getExpression()), sf);
-}
-function unwrap(expression) {
-  let inner = expression;
-  while (N.isSatisfiesExpression(inner) || N.isAsExpression(inner) || N.isParenthesizedExpression(inner)) {
-    inner = inner.getExpression();
-  }
-  return inner;
-}
-function objectBehind(expression, sf) {
-  if (N.isObjectLiteralExpression(expression)) {
-    return expression;
-  }
-  if (!N.isIdentifier(expression)) {
-    return null;
-  }
-  const declaration = sf.getVariableDeclaration(expression.getText());
-  const written = declaration?.getInitializer();
-  if (written === void 0) {
-    return null;
-  }
-  const inner = unwrap(written);
-  return N.isObjectLiteralExpression(inner) ? inner : null;
-}
-function listenerTriggers(sf) {
+function listenerTriggers(sf, resolution) {
   const triggers = [];
   sf.forEachDescendant((node) => {
     const registered = listenerAt(node);
     if (registered === null) {
       return;
     }
-    const func = functionBehind(registered.handler, sf);
+    const func = functionValueOf(registered.handler, resolution);
     if (func !== null) {
       triggers.push({
         name: registered.event,
@@ -215,118 +164,57 @@ var ENV_PARAMETER_POSITION = 1;
 var readName = (name) => `env.${name}`;
 function envBindingRecognizer(options = {}) {
   const instanceName = options.scriptName ?? "<unknown>";
-  return (access) => {
-    const read = envReadAt(access);
+  return (access, ctx) => {
+    const { resolution } = ctx;
+    const read = envReadAt(access, resolution);
     return read === null ? null : [configReadEffect(read, instanceName)];
   };
 }
-function envReadAt(node) {
+function envReadAt(node, resolution) {
   if (!N2.isPropertyAccessExpression(node)) {
     return null;
   }
   const subject = node.getExpression();
-  if (!N2.isIdentifier(subject) || !isTriggerEnvArgument(subject)) {
+  if (!N2.isIdentifier(subject) || !isTriggerEnvArgument(subject, resolution)) {
     return null;
   }
   const name = node.getName();
   return name.length === 0 ? null : { name, defaulted: isDefaultedAt(node) };
 }
-function isTriggerEnvArgument(subject) {
+function isTriggerEnvArgument(subject, resolution) {
   for (const definition of subject.getSymbol()?.getDeclarations() ?? []) {
-    if (N2.isParameterDeclaration(definition) && isTriggerEnvParameter(definition)) {
+    if (N2.isParameterDeclaration(definition) && isTriggerEnvParameter(definition, resolution)) {
       return true;
     }
   }
   return false;
 }
-function isTriggerEnvParameter(parameter) {
+function isTriggerEnvParameter(parameter, resolution) {
   const owner = parameter.getParent();
   const parameters = owner.getParameters?.() ?? [];
   if (parameters[ENV_PARAMETER_POSITION] !== parameter) {
     return false;
   }
-  return isTriggerBody(owner);
-}
-function isTriggerBody(owner) {
-  const named = triggerNameOf(owner);
-  if (named !== null) {
-    return TRIGGERS[named] !== void 0;
-  }
-  return referredToByEntrypoint(owner);
+  return isTriggerBody(owner, resolution);
 }
-function triggerNameOf(owner) {
-  if (N2.isMethodDeclaration(owner)) {
-    const name = owner.getNameNode();
-    return N2.isIdentifier(name) ? name.getText() : null;
+function isTriggerBody(owner, resolution) {
+  if (resolution !== void 0) {
+    return entrypointTriggerFunctions(owner.getSourceFile(), resolution).has(
+      owner
+    );
   }
-  const parent = owner.getParent();
-  if (parent !== void 0 && N2.isPropertyAssignment(parent)) {
-    const name = parent.getNameNode();
-    return N2.isIdentifier(name) ? name.getText() : null;
-  }
-  return null;
+  return writtenUnderTriggerName(owner);
 }
-function referredToByEntrypoint(owner) {
-  const name = declaredName(owner);
-  if (name === null) {
+function writtenUnderTriggerName(owner) {
+  const property = N2.isMethodDeclaration(owner) ? owner : owner.getParent();
+  if (property === void 0) {
     return false;
   }
-  const assignment = owner.getSourceFile().getExportAssignment((a) => !a.isExportEquals());
-  if (assignment === void 0) {
+  const name = propertyNameOf2(property);
+  if (name === null || TRIGGERS[name] === void 0) {
     return false;
   }
-  return triggerReferences(assignment.getExpression()).has(name);
-}
-function declaredName(owner) {
-  if (N2.isFunctionDeclaration(owner)) {
-    return owner.getName() ?? null;
-  }
-  const parent = owner.getParent();
-  return parent !== void 0 && N2.isVariableDeclaration(parent) ? parent.getName() : null;
-}
-function triggerReferences(expression) {
-  const names = /* @__PURE__ */ new Set();
-  if (!N2.isObjectLiteralExpression(expression)) {
-    return names;
-  }
-  for (const property of expression.getProperties()) {
-    if (!N2.isPropertyAssignment(property)) {
-      continue;
-    }
-    const key = property.getNameNode();
-    if (!N2.isIdentifier(key) || TRIGGERS[key.getText()] === void 0) {
-      continue;
-    }
-    const written = property.getInitializer();
-    if (written !== void 0 && N2.isIdentifier(written)) {
-      names.add(written.getText());
-    }
-  }
-  return names;
-}
-function isDefaultedAt(node) {
-  let child = node;
-  let parent = child.getParent();
-  while (parent !== void 0) {
-    if (N2.isParenthesizedExpression(parent)) {
-      child = parent;
-      parent = parent.getParent();
-      continue;
-    }
-    if (!N2.isBinaryExpression(parent)) {
-      return false;
-    }
-    const operator = parent.getOperatorToken().getText();
-    if (operator !== "??" && operator !== "||") {
-      return false;
-    }
-    if (parent.getLeft() === child) {
-      return true;
-    }
-    child = parent;
-    parent = parent.getParent();
-  }
-  return false;
+  return propertyFunctionOf2(property, void 0) === owner;
 }
 function configReadEffect(read, instanceName) {
   return {
@@ -360,21 +248,25 @@ var KEYED_OPERATIONS = /* @__PURE__ */ new Set([
   "put",
   "delete"
 ]);
-var objectStoreAccess = (method, call, resolve) => {
+var objectStoreAccess = (method, call, reading) => {
   const kind = OBJECT_OPERATIONS[method];
   if (kind === void 0) {
     return null;
   }
   const argument = call.getArguments()[0];
-  const selector = argument !== void 0 && KEYED_OPERATIONS.has(method) ? readName2(argument, { resolve, unsettled: "reference" }) : null;
+  const selector = argument !== void 0 && KEYED_OPERATIONS.has(method) ? readName2(argument, {
+    resolve: reading.resolve,
+    unsettled: "reference"
+  }) : null;
   return { kind, ...selector !== null ? { selector } : {} };
 };
 var D1_STATEMENT_METHODS = /* @__PURE__ */ new Set(["prepare", "exec"]);
-var d1Access = (method, call, resolve) => {
+var d1Access = (method, call, reading) => {
   if (!D1_STATEMENT_METHODS.has(method)) {
     return null;
   }
-  const sql = literalText(call.getArguments()[0], resolve);
+  const statement = call.getArguments()[0];
+  const sql = statement === void 0 ? null : stringValueOf(statement, reading.resolution);
   if (sql === null) {
     return null;
   }
@@ -392,12 +284,16 @@ var STORES = {
 };
 function storeBindingRecognizer(call, ctx) {
   const callNode = call;
-  const resolve = ctx.resolveWrittenValue ?? (() => null);
+  const given = ctx;
+  const reading = {
+    resolve: given.resolveWrittenValue ?? (() => null),
+    resolution: given.resolution
+  };
   const callee = callNode.getExpression();
   if (!N3.isPropertyAccessExpression(callee)) {
     return null;
   }
-  const binding = boundReceiver(callee.getExpression(), resolve);
+  const binding = boundReceiver(callee.getExpression(), reading);
   if (binding === null) {
     return null;
   }
@@ -406,7 +302,7 @@ function storeBindingRecognizer(call, ctx) {
     return null;
   }
   const method = callee.getName();
-  const access = store.read(method, callNode, resolve);
+  const access = store.read(method, callNode, reading);
   if (access === null) {
     return null;
   }
@@ -433,10 +329,10 @@ function storeBindingRecognizer(call, ctx) {
     }
   ];
 }
-function boundReceiver(subject, resolve) {
+function boundReceiver(subject, reading) {
   let receiver = subject;
   if (N3.isIdentifier(receiver)) {
-    const written = declaredInitializer(receiver) ?? resolve(receiver);
+    const written = declaredInitializer(receiver) ?? reading.resolve(receiver);
     if (written !== null && written !== receiver) {
       receiver = written;
     }
@@ -445,7 +341,7 @@ function boundReceiver(subject, resolve) {
     return null;
   }
   const env = receiver.getExpression();
-  if (!N3.isIdentifier(env) || !isTriggerEnvArgument(env)) {
+  if (!N3.isIdentifier(env) || !isTriggerEnvArgument(env, reading.resolution)) {
     return null;
   }
   const typeName = declaredTypeName(receiver);
@@ -475,16 +371,6 @@ function declaredTypeName(receiver) {
   }
   return null;
 }
-function literalText(argument, resolve) {
-  if (argument === void 0) {
-    return null;
-  }
-  const written = resolve(argument) ?? argument;
-  if (N3.isStringLiteral(written) || N3.isNoSubstitutionTemplateLiteral(written)) {
-    return written.getLiteralValue();
-  }
-  return null;
-}
 var optionsSchema = z.object({
   /**
    * The name the deployment gives this Worker, which is `name` in