@suss/packs 0.11.0

package/dist/cloudflare-workers.js

@@ -0,0 +1,562 @@
+// ../framework/cloudflare-workers/dist/index.js
+import { Node as N } from "ts-morph";
+import { Node as N2 } from "ts-morph";
+import { runtimeConfigBinding } from "@suss/behavioral-ir";
+import { Node as N3 } from "ts-morph";
+import { readName as readName2 } from "@suss/adapter-typescript";
+import { storageBinding } from "@suss/behavioral-ir";
+import { readSqlAccess } from "@suss/sql";
+var TRIGGERS = {
+  fetch: {
+    kind: "handler",
+    // A Worker serves whatever method reaches it, and the route it is
+    // bound to is declared outside the code, so the path is null.
+    routeInfo: { method: "*", path: null }
+  },
+  scheduled: {
+    kind: "worker",
+    channelInfo: { messageBus: "cloudflare-cron", channel: null }
+  },
+  queue: {
+    kind: "consumer",
+    channelInfo: { messageBus: "cloudflare-queues", channel: null }
+  },
+  tail: {
+    kind: "consumer",
+    channelInfo: { messageBus: "cloudflare-tail", channel: null }
+  }
+};
+var METADATA_NAMESPACE = "cloudflareWorkers";
+function cloudflareWorkersDiscovery(options = {}) {
+  return (sourceFile) => {
+    const sf = sourceFile;
+    const triggers = [...defaultExportTriggers(sf), ...listenerTriggers(sf)];
+    const units = [];
+    const taken = /* @__PURE__ */ new Set();
+    for (const trigger of triggers) {
+      if (taken.has(trigger.name)) {
+        continue;
+      }
+      taken.add(trigger.name);
+      units.push(unitFor(trigger, options.scriptName));
+    }
+    return units;
+  };
+}
+function unitFor(trigger, scriptName) {
+  const shape = TRIGGERS[trigger.name];
+  return {
+    func: trigger.func,
+    kind: shape.kind,
+    name: trigger.name,
+    ...shape.routeInfo !== void 0 ? { routeInfo: shape.routeInfo } : {},
+    ...shape.channelInfo !== void 0 ? { channelInfo: shape.channelInfo } : {},
+    ...scriptName !== void 0 ? {
+      deployableUnit: {
+        deploymentTarget: "worker",
+        instanceName: scriptName
+      }
+    } : {},
+    metadata: {
+      [METADATA_NAMESPACE]: {
+        trigger: trigger.name,
+        registration: trigger.registration
+      }
+    }
+  };
+}
+function defaultExportTriggers(sf) {
+  const literal = defaultExportObject(sf);
+  if (literal === null) {
+    return [];
+  }
+  const triggers = [];
+  for (const property of literal.getProperties()) {
+    const found = triggerOfProperty(property, sf);
+    if (found !== null) {
+      triggers.push(found);
+    }
+  }
+  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 propertyName(property) {
+  if (N.isMethodDeclaration(property) || N.isPropertyAssignment(property)) {
+    const name = property.getNameNode();
+    if (N.isIdentifier(name)) {
+      return name.getText();
+    }
+    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) {
+  const triggers = [];
+  sf.forEachDescendant((node) => {
+    const registered = listenerAt(node);
+    if (registered === null) {
+      return;
+    }
+    const func = functionBehind(registered.handler, sf);
+    if (func !== null) {
+      triggers.push({
+        name: registered.event,
+        func,
+        registration: "addEventListener"
+      });
+    }
+  });
+  return triggers;
+}
+function listenerAt(node) {
+  if (!N.isCallExpression(node)) {
+    return null;
+  }
+  const callee = node.getExpression();
+  if (!N.isIdentifier(callee) || callee.getText() !== "addEventListener") {
+    return null;
+  }
+  const [event, handler] = node.getArguments();
+  if (event === void 0 || handler === void 0) {
+    return null;
+  }
+  if (!N.isStringLiteral(event) || TRIGGERS[event.getLiteralValue()] === void 0) {
+    return null;
+  }
+  return { event: event.getLiteralValue(), handler };
+}
+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 read === null ? null : [configReadEffect(read, instanceName)];
+  };
+}
+function envReadAt(node) {
+  if (!N2.isPropertyAccessExpression(node)) {
+    return null;
+  }
+  const subject = node.getExpression();
+  if (!N2.isIdentifier(subject) || !isTriggerEnvArgument(subject)) {
+    return null;
+  }
+  const name = node.getName();
+  return name.length === 0 ? null : { name, defaulted: isDefaultedAt(node) };
+}
+function isTriggerEnvArgument(subject) {
+  for (const definition of subject.getSymbol()?.getDeclarations() ?? []) {
+    if (N2.isParameterDeclaration(definition) && isTriggerEnvParameter(definition)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isTriggerEnvParameter(parameter) {
+  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);
+}
+function triggerNameOf(owner) {
+  if (N2.isMethodDeclaration(owner)) {
+    const name = owner.getNameNode();
+    return N2.isIdentifier(name) ? name.getText() : null;
+  }
+  const parent = owner.getParent();
+  if (parent !== void 0 && N2.isPropertyAssignment(parent)) {
+    const name = parent.getNameNode();
+    return N2.isIdentifier(name) ? name.getText() : null;
+  }
+  return null;
+}
+function referredToByEntrypoint(owner) {
+  const name = declaredName(owner);
+  if (name === null) {
+    return false;
+  }
+  const assignment = owner.getSourceFile().getExportAssignment((a) => !a.isExportEquals());
+  if (assignment === 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;
+}
+function configReadEffect(read, instanceName) {
+  return {
+    type: "interaction",
+    binding: runtimeConfigBinding({
+      recognition: "@suss/framework-cloudflare-workers",
+      deploymentTarget: "worker",
+      instanceName
+    }),
+    callee: readName(read.name),
+    interaction: {
+      class: "config-read",
+      name: read.name,
+      defaulted: read.defaulted
+    }
+  };
+}
+var RECOGNITION = "@suss/framework-cloudflare-workers";
+var OBJECT_OPERATIONS = {
+  get: "read",
+  getWithMetadata: "read",
+  head: "read",
+  list: "read",
+  put: "write",
+  delete: "write"
+};
+var KEYED_OPERATIONS = /* @__PURE__ */ new Set([
+  "get",
+  "getWithMetadata",
+  "head",
+  "put",
+  "delete"
+]);
+var objectStoreAccess = (method, call, resolve) => {
+  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;
+  return { kind, ...selector !== null ? { selector } : {} };
+};
+var D1_STATEMENT_METHODS = /* @__PURE__ */ new Set(["prepare", "exec"]);
+var d1Access = (method, call, resolve) => {
+  if (!D1_STATEMENT_METHODS.has(method)) {
+    return null;
+  }
+  const sql = literalText(call.getArguments()[0], resolve);
+  if (sql === null) {
+    return null;
+  }
+  const accesses = readSqlAccess(sql, { dialect: "sqlite" });
+  if (accesses.length === 0) {
+    return null;
+  }
+  const kind = accesses.some((access) => access.kind === "write") ? "write" : "read";
+  return { kind };
+};
+var STORES = {
+  KVNamespace: { storageSystem: "cloudflare-kv", read: objectStoreAccess },
+  R2Bucket: { storageSystem: "r2", read: objectStoreAccess },
+  D1Database: { storageSystem: "d1", read: d1Access }
+};
+function storeBindingRecognizer(call, ctx) {
+  const callNode = call;
+  const resolve = ctx.resolveWrittenValue ?? (() => null);
+  const callee = callNode.getExpression();
+  if (!N3.isPropertyAccessExpression(callee)) {
+    return null;
+  }
+  const binding = boundReceiver(callee.getExpression(), resolve);
+  if (binding === null) {
+    return null;
+  }
+  const store = STORES[binding.typeName];
+  if (store === void 0) {
+    return null;
+  }
+  const method = callee.getName();
+  const access = store.read(method, callNode, resolve);
+  if (access === null) {
+    return null;
+  }
+  return [
+    {
+      type: "interaction",
+      binding: storageBinding({
+        recognition: RECOGNITION,
+        storageSystem: store.storageSystem,
+        scope: "default",
+        container: binding.name,
+        accessPath: null
+      }),
+      callee: callee.getText(),
+      interaction: {
+        class: "storage-access",
+        kind: access.kind,
+        // KV and R2 keep opaque values and a D1 statement is judged at
+        // database level, so no call states a field.
+        fields: [],
+        operation: method,
+        ...access.selector !== void 0 ? { selector: [access.selector] } : {}
+      }
+    }
+  ];
+}
+function boundReceiver(subject, resolve) {
+  let receiver = subject;
+  if (N3.isIdentifier(receiver)) {
+    const written = declaredInitializer(receiver) ?? resolve(receiver);
+    if (written !== null && written !== receiver) {
+      receiver = written;
+    }
+  }
+  if (!N3.isPropertyAccessExpression(receiver)) {
+    return null;
+  }
+  const env = receiver.getExpression();
+  if (!N3.isIdentifier(env) || !isTriggerEnvArgument(env)) {
+    return null;
+  }
+  const typeName = declaredTypeName(receiver);
+  if (typeName === null) {
+    return null;
+  }
+  return { name: receiver.getName(), typeName };
+}
+function declaredInitializer(identifier) {
+  for (const declaration of identifier.getSymbol()?.getDeclarations() ?? []) {
+    if (N3.isVariableDeclaration(declaration)) {
+      return declaration.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function declaredTypeName(receiver) {
+  const declarations = receiver.getNameNode().getSymbol()?.getDeclarations() ?? [];
+  for (const declaration of declarations) {
+    if (!N3.isPropertySignature(declaration)) {
+      continue;
+    }
+    const typeNode = declaration.getTypeNode();
+    if (typeNode !== void 0) {
+      return typeNode.getText();
+    }
+  }
+  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;
+}
+function cloudflareWorkersFramework(options = {}) {
+  return {
+    name: "cloudflare-workers",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    // Nothing is registered in code, so there is no data-driven
+    // discovery to declare.
+    discovery: [],
+    discoverUnits: cloudflareWorkersDiscovery(options),
+    terminals: [
+      {
+        // new Response(body, { status }), which is what a Worker returns
+        // for everything: JSON, a redirect, a stream, plain text.
+        kind: "response",
+        match: { type: "functionCall", functionName: "Response" },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          statusCode: { from: "argumentProperty", position: 1, name: "status" },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // Response.json(body, { status }), the platform's own helper.
+        kind: "response",
+        match: { type: "functionCall", functionName: "Response.json" },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          statusCode: { from: "argumentProperty", position: 1, name: "status" },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // Response.redirect(url, status). The platform sends 302 when
+        // the caller leaves the status off.
+        kind: "response",
+        match: { type: "functionCall", functionName: "Response.redirect" },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          defaultStatusCode: 302
+        }
+      },
+      {
+        // A returned value that is none of the above: a Response the
+        // handler got back from `fetch`, or from a helper of its own.
+        kind: "return",
+        match: { type: "returnStatement", excludeCallReturns: true },
+        extraction: {}
+      },
+      { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
+      {
+        // scheduled, queue and tail return nothing, so their bodies end
+        // by running off the end.
+        kind: "return",
+        match: { type: "functionFallthrough" },
+        extraction: {}
+      }
+    ],
+    // Every trigger takes its event first, its bindings second and its
+    // execution context third.
+    inputMapping: {
+      type: "positionalParams",
+      params: [
+        { position: 0, role: "event" },
+        { position: 1, role: "config" },
+        { position: 2, role: "context" }
+      ]
+    },
+    accessRecognizers: [envBindingRecognizer(options)],
+    // A store call on an env binding: `env.SESSIONS.get(key)`.
+    invocationRecognizers: [storeBindingRecognizer]
+  };
+}
+var index_default = cloudflareWorkersFramework;
+export {
+  index_default as default
+};

package/dist/drizzle.d.ts

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