@suss/packs 0.11.0

package/dist/drizzle.js

@@ -0,0 +1,383 @@
+// ../framework/drizzle/dist/index.js
+import { Node as N } from "ts-morph";
+import { resolveAliasedSymbol } from "@suss/adapter-typescript";
+import { storageBinding } from "@suss/behavioral-ir";
+import { readSqlAccess, sqlFromParts } from "@suss/sql";
+var QUERY_API_METHODS = /* @__PURE__ */ new Set(["findMany", "findFirst"]);
+var TABLE_FACTORIES = /* @__PURE__ */ new Set(["pgTable", "mysqlTable", "sqliteTable"]);
+var CHAIN_WALK_LIMIT = 12;
+var RAW_METHOD = "execute";
+function makeRawRecognizer(opts) {
+  const storageSystem = opts.storageSystem ?? "postgresql";
+  const scope = opts.scope ?? "default";
+  return ((call) => {
+    const callNode = call;
+    const callee = callNode.getExpression();
+    if (!N.isPropertyAccessExpression(callee)) {
+      return null;
+    }
+    if (callee.getName() !== RAW_METHOD) {
+      return null;
+    }
+    const statement = sqlTextOf(callNode.getArguments()[0]);
+    if (statement === null) {
+      return null;
+    }
+    const accesses = readSqlAccess(statement, { dialect: storageSystem });
+    if (accesses.length === 0) {
+      return null;
+    }
+    return accesses.map((access) => ({
+      type: "interaction",
+      binding: storageBinding({
+        recognition: "@suss/framework-drizzle",
+        storageSystem,
+        scope,
+        container: access.table
+      }),
+      callee: callee.getText(),
+      interaction: {
+        class: "storage-access",
+        kind: access.kind,
+        fields: access.fields,
+        ...access.selector.length > 0 ? { selector: access.selector } : {},
+        operation: callee.getName()
+      }
+    }));
+  });
+}
+function sqlTextOf(argument) {
+  if (argument === void 0) {
+    return null;
+  }
+  if (N.isNoSubstitutionTemplateLiteral(argument)) {
+    return argument.getLiteralValue();
+  }
+  if (N.isTaggedTemplateExpression(argument)) {
+    const template = argument.getTemplate();
+    if (N.isNoSubstitutionTemplateLiteral(template)) {
+      return template.getLiteralValue();
+    }
+    const spans = template.getTemplateSpans();
+    return sqlFromParts(
+      [
+        template.getHead().getLiteralText(),
+        ...spans.map((span) => span.getLiteral().getLiteralText())
+      ],
+      // A statement that interpolates a table interpolates the schema
+      // object, so the name it declares is what belongs in the text.
+      // Everything else is a value, and a parameter is what a value
+      // would have been.
+      spans.map((span) => resolveTableName(span.getExpression()))
+    );
+  }
+  if (N.isStringLiteral(argument)) {
+    return argument.getLiteralValue();
+  }
+  return null;
+}
+function makeRecognizer(opts) {
+  const storageSystem = opts.storageSystem ?? "postgresql";
+  const scope = opts.scope ?? "default";
+  return (call) => {
+    const query = recognizeAnchor(call);
+    if (query === null) {
+      return null;
+    }
+    return [
+      {
+        type: "interaction",
+        binding: storageBinding({
+          recognition: "@suss/framework-drizzle",
+          storageSystem,
+          scope,
+          container: query.table
+        }),
+        callee: query.calleeText,
+        interaction: {
+          class: "storage-access",
+          kind: query.kind,
+          fields: query.fields,
+          ...query.selector !== null ? { selector: query.selector } : {},
+          operation: query.operation
+        }
+      }
+    ];
+  };
+}
+function recognizeAnchor(call) {
+  const callee = call.getExpression();
+  if (!N.isPropertyAccessExpression(callee)) {
+    return null;
+  }
+  const method = callee.getName();
+  if (method === "from") {
+    return recognizeSelect(call, callee.getExpression());
+  }
+  if (method === "insert" || method === "update" || method === "delete") {
+    return recognizeMutation(call, callee.getExpression(), method);
+  }
+  if (QUERY_API_METHODS.has(method)) {
+    return recognizeQueryApi(call, callee.getExpression(), method);
+  }
+  return null;
+}
+function recognizeSelect(fromCall, receiver) {
+  if (!N.isCallExpression(receiver)) {
+    return null;
+  }
+  const selectCallee = receiver.getExpression();
+  if (!N.isPropertyAccessExpression(selectCallee)) {
+    return null;
+  }
+  const selectName = selectCallee.getName();
+  if (selectName !== "select" && selectName !== "selectDistinct") {
+    return null;
+  }
+  if (!isDrizzleReceiver(selectCallee.getExpression())) {
+    return null;
+  }
+  const tableArg = fromCall.getArguments()[0];
+  if (tableArg === void 0) {
+    return null;
+  }
+  const table = resolveTableName(tableArg);
+  const tableExprText = tableArg.getText();
+  const selectArg = receiver.getArguments()[0];
+  const fields = selectArg !== void 0 && N.isObjectLiteralExpression(selectArg) ? objectKeys(selectArg) : ["*"];
+  const chain = collectChainCalls(fromCall);
+  const selector = selectorFromWhere(chain.get("where"), tableExprText);
+  return {
+    kind: "read",
+    operation: selectName,
+    table,
+    tableExprText,
+    fields: fields.length > 0 ? fields : ["*"],
+    selector,
+    calleeText: fromCall.getExpression().getText()
+  };
+}
+function recognizeMutation(call, receiver, operation) {
+  if (!isDrizzleReceiver(receiver)) {
+    return null;
+  }
+  const tableArg = call.getArguments()[0];
+  if (tableArg === void 0) {
+    return null;
+  }
+  const table = resolveTableName(tableArg);
+  const tableExprText = tableArg.getText();
+  const chain = collectChainCalls(call);
+  const fields = operation === "insert" ? valuesKeys(chain.get("values")) : operation === "update" ? setKeys(chain.get("set")) : ["*"];
+  const selector = selectorFromWhere(chain.get("where"), tableExprText);
+  return {
+    kind: "write",
+    operation,
+    table,
+    tableExprText,
+    fields,
+    selector,
+    calleeText: call.getExpression().getText()
+  };
+}
+function recognizeQueryApi(call, receiver, operation) {
+  if (!N.isPropertyAccessExpression(receiver)) {
+    return null;
+  }
+  const queryAccess = receiver.getExpression();
+  if (!N.isPropertyAccessExpression(queryAccess) || queryAccess.getName() !== "query") {
+    return null;
+  }
+  if (!isDrizzleReceiver(queryAccess.getExpression())) {
+    return null;
+  }
+  const table = resolveTableName(receiver) ?? receiver.getName();
+  const optionsArg = call.getArguments()[0];
+  const fields = [];
+  if (optionsArg !== void 0 && N.isObjectLiteralExpression(optionsArg)) {
+    const columns = objectProperty(optionsArg, "columns");
+    if (columns !== null && N.isObjectLiteralExpression(columns)) {
+      fields.push(...objectKeys(columns));
+    }
+    const withProp = objectProperty(optionsArg, "with");
+    if (withProp !== null && N.isObjectLiteralExpression(withProp)) {
+      fields.push(...objectKeys(withProp));
+    }
+  }
+  return {
+    kind: "read",
+    operation,
+    table,
+    tableExprText: null,
+    fields: fields.length > 0 ? fields : ["*"],
+    selector: null,
+    calleeText: call.getExpression().getText()
+  };
+}
+function collectChainCalls(anchor) {
+  const chain = /* @__PURE__ */ new Map();
+  let current = anchor;
+  for (let i = 0; i < CHAIN_WALK_LIMIT; i++) {
+    const parent = current.getParent();
+    if (parent === void 0 || !N.isPropertyAccessExpression(parent)) {
+      break;
+    }
+    const grandparent = parent.getParent();
+    if (grandparent === void 0 || !N.isCallExpression(grandparent)) {
+      break;
+    }
+    const name = parent.getName();
+    if (!chain.has(name)) {
+      chain.set(name, grandparent);
+    }
+    current = grandparent;
+  }
+  return chain;
+}
+function isDrizzleReceiver(node) {
+  const type = node.getType();
+  const symbol = type.getSymbol() ?? type.getAliasSymbol();
+  if (symbol === void 0) {
+    return false;
+  }
+  for (const decl of symbol.getDeclarations()) {
+    if (decl.getSourceFile().getFilePath().includes("/drizzle-orm/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveTableName(tableExpr) {
+  const symbol = N.isPropertyAccessExpression(tableExpr) ? tableExpr.getNameNode().getSymbol() : tableExpr.getSymbol();
+  if (symbol === void 0) {
+    return null;
+  }
+  for (const decl of symbol.getDeclarations()) {
+    const declared = tableNameFromDeclaration(decl);
+    if (declared !== null) {
+      return declared;
+    }
+  }
+  return null;
+}
+function tableNameFromDeclaration(decl) {
+  if (N.isImportSpecifier(decl)) {
+    const symbol = decl.getNameNode().getSymbol();
+    const aliased = symbol === void 0 ? void 0 : resolveAliasedSymbol(symbol);
+    for (const target of aliased?.getDeclarations() ?? []) {
+      const name = tableNameFromDeclaration(target);
+      if (name !== null) {
+        return name;
+      }
+    }
+    return null;
+  }
+  if (!N.isVariableDeclaration(decl)) {
+    return null;
+  }
+  const init = decl.getInitializer();
+  if (init === void 0 || !N.isCallExpression(init)) {
+    return null;
+  }
+  const calleeText = init.getExpression().getText();
+  const calleeName = calleeText.split(".").pop() ?? calleeText;
+  if (!TABLE_FACTORIES.has(calleeName)) {
+    return null;
+  }
+  const first = init.getArguments()[0];
+  if (first !== void 0 && N.isStringLiteral(first)) {
+    return first.getLiteralValue();
+  }
+  return null;
+}
+function objectKeys(obj) {
+  if (!N.isObjectLiteralExpression(obj)) {
+    return [];
+  }
+  const keys = [];
+  for (const prop of obj.getProperties()) {
+    if (N.isPropertyAssignment(prop) || N.isShorthandPropertyAssignment(prop)) {
+      keys.push(prop.getName());
+    }
+  }
+  return keys;
+}
+function objectProperty(obj, name) {
+  if (!N.isObjectLiteralExpression(obj)) {
+    return null;
+  }
+  for (const prop of obj.getProperties()) {
+    if (N.isPropertyAssignment(prop) && prop.getName() === name) {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function valuesKeys(valuesCall) {
+  const arg = valuesCall?.getArguments()[0];
+  if (arg === void 0) {
+    return ["*"];
+  }
+  if (N.isObjectLiteralExpression(arg)) {
+    const keys = objectKeys(arg);
+    return keys.length > 0 ? keys : ["*"];
+  }
+  if (N.isArrayLiteralExpression(arg)) {
+    const union = /* @__PURE__ */ new Set();
+    for (const element of arg.getElements()) {
+      for (const key of objectKeys(element)) {
+        union.add(key);
+      }
+    }
+    return union.size > 0 ? [...union] : ["*"];
+  }
+  return ["*"];
+}
+function setKeys(setCall) {
+  const arg = setCall?.getArguments()[0];
+  if (arg === void 0) {
+    return ["*"];
+  }
+  const keys = objectKeys(arg);
+  return keys.length > 0 ? keys : ["*"];
+}
+function selectorFromWhere(whereCall, tableExprText) {
+  if (whereCall === void 0 || tableExprText === null) {
+    return null;
+  }
+  const arg = whereCall.getArguments()[0];
+  if (arg === void 0) {
+    return null;
+  }
+  const columns = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (N.isPropertyAccessExpression(node) && node.getExpression().getText() === tableExprText) {
+      columns.add(node.getName());
+    }
+    node.forEachChild(visit);
+  };
+  visit(arg);
+  return columns.size > 0 ? [...columns] : null;
+}
+function drizzleFramework(options = {}) {
+  return {
+    name: "drizzle",
+    protocol: "in-process",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    // Gate on drizzle-orm imports (matches subpaths like
+    // drizzle-orm/pg-core and driver entry points): files without
+    // them can't type-check as Drizzle receivers anyway.
+    requiresImport: ["drizzle-orm"],
+    invocationRecognizers: [
+      makeRecognizer(options),
+      makeRawRecognizer(options)
+    ]
+  };
+}
+var index_default = drizzleFramework;
+export {
+  index_default as default
+};

package/dist/express.d.ts

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

package/dist/express.js

@@ -0,0 +1,124 @@
+// ../framework/express/dist/index.js
+import { httpRouteDiscovery } from "@suss/extractor";
+function expressFramework() {
+  return {
+    name: "express",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    // Express exposes the routable via either `Router()` (named) or
+    // `express()` (default). Both drive handler registration the same
+    // way; `httpRouteDiscovery` emits one DiscoveryPattern per name.
+    // Either can also be mounted onto another with `app.use(prefix,
+    // router)`, so a route declared on the mounted router summarizes
+    // with the mount's prefix composed in.
+    discovery: httpRouteDiscovery({
+      importModule: "express",
+      importNames: ["Router", "express"],
+      methods: [".get", ".post", ".put", ".delete", ".patch", ".all"],
+      mount: { method: "use", prefixPosition: 0, targetPosition: 1 }
+    }),
+    terminals: [
+      {
+        // res.status(N).json(body)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["status", "json"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 },
+          body: { from: "argument", position: 0 }
+        }
+      },
+      {
+        // res.json(body): implicit 200
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["json"]
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // res.status(N).send(body)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["status", "send"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 },
+          body: { from: "argument", position: 0 }
+        }
+      },
+      {
+        // res.send(body): implicit 200
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["send"]
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // res.sendStatus(N): sends status code with status text as body
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["sendStatus"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 }
+        }
+      },
+      {
+        // res.redirect(url) or res.redirect(status, url)
+        // Arg 0 is a status code only in the 2-arg form; minArgs prevents
+        // extracting the URL string as a status code in the 1-arg form.
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["redirect"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0, minArgs: 2 },
+          defaultStatusCode: 302
+        }
+      },
+      {
+        // throw new SomeError(...); express error middleware sends the
+        // error's status as the wire response.
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {
+          statusCode: { from: "property", name: "status" }
+        },
+        producesResponse: true
+      }
+    ],
+    inputMapping: {
+      type: "positionalParams",
+      params: [
+        { position: 0, role: "request" },
+        { position: 1, role: "response" },
+        { position: 2, role: "next" }
+      ]
+    }
+  };
+}
+var index_default = expressFramework;
+export {
+  index_default as default
+};

package/dist/fastapi.d.ts

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

package/dist/fastapi.js

@@ -0,0 +1,42 @@
+// ../framework/fastapi/dist/index.js
+var VERB_ATTRIBUTE_NAMES = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE",
+  head: "HEAD",
+  options: "OPTIONS"
+};
+function fastapiFramework(options = {}) {
+  return {
+    name: "fastapi",
+    protocol: "http",
+    ...options.wrapperModules !== void 0 ? { projectModules: options.wrapperModules } : {},
+    discovery: [
+      {
+        type: "decoratedFunctionRoute",
+        importModule: ["fastapi", ...options.wrapperModules ?? []],
+        verbAttributeNames: VERB_ATTRIBUTE_NAMES,
+        pathParamSyntax: "braces",
+        annotatedClassIsRequestBody: true,
+        // FastAPI resolves both of these itself and calls the handler with
+        // the result, so a parameter defaulted to one is never sent.
+        injectedParameterCallees: ["Depends", "Security"],
+        // FastAPI returns 200 for a route that declares no status.
+        defaultStatusCode: 200,
+        responseModelKeyword: "response_model",
+        statusCodeKeyword: "status_code",
+        routerComposition: {
+          routerConstructorName: "APIRouter",
+          includeMethodName: "include_router",
+          prefixKeyword: "prefix"
+        }
+      }
+    ]
+  };
+}
+var index_default = fastapiFramework;
+export {
+  index_default as default
+};

package/dist/fastify.d.ts

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

package/dist/fastify.js

@@ -0,0 +1,116 @@
+// ../framework/fastify/dist/index.js
+import { httpRouteDiscovery } from "@suss/extractor";
+function fastifyFramework() {
+  return {
+    name: "fastify",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    // Fastify exposes the routable via either default `Fastify` or
+    // named `fastify()`. Both drive handler registration the same way.
+    // Unlike Express, Fastify's router supports `.head` and `.options`.
+    discovery: httpRouteDiscovery({
+      importModule: "fastify",
+      importNames: ["Fastify", "fastify"],
+      methods: [
+        ".get",
+        ".post",
+        ".put",
+        ".delete",
+        ".patch",
+        ".head",
+        ".options",
+        ".all"
+      ]
+    }),
+    terminals: [
+      {
+        // reply.code(N).send(body)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["code", "send"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 },
+          body: { from: "argument", position: 0 }
+        }
+      },
+      {
+        // reply.status(N).send(body), `.status` is the Express-style alias
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["status", "send"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 },
+          body: { from: "argument", position: 0 }
+        }
+      },
+      {
+        // reply.send(body): implicit 200
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["send"]
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // reply.redirect(url) or reply.redirect(N, url)
+        // Arg 0 is a status code only in the 2-arg form; minArgs prevents
+        // extracting the URL string as a status code in the 1-arg form.
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["redirect"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0, minArgs: 2 },
+          defaultStatusCode: 302
+        }
+      },
+      {
+        // throw new Error(...) / throw httpErrors.notFound() / etc.
+        // Status code is left for the consumer to infer from exception type;
+        // Fastify error libraries vary too widely to map here.
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      },
+      {
+        // `return user`, `return { id, name }`, `return await db.find(id)`,
+        // Fastify serialises the returned value as a 200 response body.
+        // `excludeCallReturns: true` keeps `return reply.send(...)` out
+        // of this branch: that call already lands as a parameterMethodCall
+        // terminal above, and matching it here would double-fire.
+        kind: "response",
+        match: {
+          type: "returnStatement",
+          excludeCallReturns: true
+        },
+        extraction: {
+          defaultStatusCode: 200
+        }
+      }
+    ],
+    inputMapping: {
+      type: "positionalParams",
+      params: [
+        { position: 0, role: "request" },
+        { position: 1, role: "reply" }
+      ]
+    }
+  };
+}
+var index_default = fastifyFramework;
+export {
+  index_default as default
+};

package/dist/fetch.d.ts

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