@suss/packs 0.25.0 → 0.27.0

package/dist/activerecord.d.ts

@@ -39,5 +39,6 @@ import '@suss/framework-react';
 import '@suss/framework-redis';
 import '@suss/client-requests';
 import '@suss/framework-sqlalchemy';
+import '@suss/framework-sqlmodel';
 import '@suss/framework-ts-rest';
 import '@suss/framework-zustand';

package/dist/axios.js

@@ -82,15 +82,56 @@ function discoveryForVerb(verb, factories) {
 function isPathShapedSpecifier(specifier) {
   return specifier.startsWith(".") || specifier.startsWith("/");
 }
+function configCallDiscovery(factories) {
+  const bindingExtraction = {
+    method: {
+      type: "fromArgumentProperty",
+      position: 0,
+      property: "method",
+      default: "GET"
+    },
+    path: { type: "fromArgumentProperty", position: 0, property: "url" }
+  };
+  const patterns = [
+    {
+      kind: "client",
+      match: {
+        type: "clientCall",
+        importModule: "axios",
+        importName: "axios",
+        methodFilter: ["request"],
+        factoryMethods: ["create"],
+        callable: true
+      },
+      bindingExtraction,
+      requiresImport: ["axios"]
+    }
+  ];
+  for (const factory of factories) {
+    patterns.push({
+      kind: "client",
+      match: {
+        type: "clientCall",
+        importModule: factory.module,
+        importName: factory.export,
+        methodFilter: ["request"]
+      },
+      bindingExtraction,
+      requiresImport: isPathShapedSpecifier(factory.module) ? [] : [factory.module]
+    });
+  }
+  return patterns;
+}
 function axiosPack(options = {}) {
   const factories = options.factories ?? [];
   return {
     name: "axios",
     protocol: "http",
     languages: ["typescript", "javascript"],
-    discovery: HTTP_METHODS.flatMap(
-      (verb) => discoveryForVerb(verb, factories)
-    ),
+    discovery: [
+      ...HTTP_METHODS.flatMap((verb) => discoveryForVerb(verb, factories)),
+      ...configCallDiscovery(factories)
+    ],
     terminals: [
       {
         kind: "return",

package/dist/chunk-SKGM3QL5.js

@@ -0,0 +1,101 @@
+// ../framework/sqlalchemy/dist/index.js
+import { z } from "zod";
+import { storageSystemOption } from "@suss/extractor";
+var optionsSchema = z.object({
+  /**
+   * Which database is behind the connection. SQLAlchemy talks to all of
+   * them and the URL says which, so this is the project's own choice
+   * rather than something the library settles.
+   */
+  storageSystem: storageSystemOption
+}).strict();
+function sqlalchemyStorage(options) {
+  return [
+    {
+      module: "sqlalchemy.orm",
+      queryTypes: ["Query", "Session"],
+      writes: [
+        "update",
+        "delete",
+        "add",
+        "add_all",
+        "merge",
+        "flush",
+        "commit",
+        "bulk_save_objects",
+        "bulk_insert_mappings",
+        "bulk_update_mappings"
+      ],
+      // A Session runs a statement built by `select`/`update`/... whose
+      // own chain is read, and the rest of these manage the session.
+      recordsNothing: [
+        "execute",
+        "scalars",
+        "scalar",
+        "begin",
+        "rollback",
+        "close",
+        "expire",
+        "expire_all",
+        "expunge",
+        "expunge_all"
+      ],
+      storageSystem: options.storageSystem
+    },
+    {
+      module: "sqlalchemy",
+      queryTypes: ["Select", "Update", "Delete", "Insert"],
+      writes: ["update", "delete", "insert", "commit"],
+      // 2.0 style writes `select(User.id).where(...)`, importing the
+      // constructor rather than reaching it through a mapped class, so there
+      // is no project method in between whose return says what it is.
+      queryFunctions: ["select", "insert", "update", "delete"],
+      valueMethods: ["values"],
+      storageSystem: options.storageSystem
+    }
+  ];
+}
+function sqlalchemyRawSql(options) {
+  return [
+    {
+      module: "sqlalchemy",
+      functions: ["text"],
+      storageSystem: options.storageSystem
+    }
+  ];
+}
+function sqlalchemyFramework(options) {
+  if (typeof options?.storageSystem !== "string") {
+    throw new Error(
+      "it needs `storageSystem`, which database is behind the engine: postgresql, mysql, or sqlite. SQLAlchemy talks to all of them and the connection URL settles which, so the pack cannot."
+    );
+  }
+  return {
+    name: "sqlalchemy",
+    protocol: options.storageSystem,
+    discovery: [],
+    storage: sqlalchemyStorage(options),
+    rawSql: sqlalchemyRawSql(options)
+  };
+}
+var declares = {
+  kind: "effects",
+  package: "@suss/framework-sqlalchemy",
+  dependencies: [{ ecosystem: "pypi", name: "sqlalchemy" }],
+  reads: `SQLAlchemy calls (Python): says which types a query comes back as and which methods write, and the adapter matches a call chain by resolving through a project's own base class to what the method behind it says it returns.`,
+  configuration: {
+    file: "suss.sqlalchemy.json",
+    example: { storageSystem: "postgresql" },
+    required: true,
+    why: "which database is behind the engine: postgresql, mysql, or sqlite. SQLAlchemy talks to all of them and the connection URL settles which, so the pack cannot."
+  }
+};
+var index_default = sqlalchemyFramework;
+
+export {
+  optionsSchema,
+  sqlalchemyStorage,
+  sqlalchemyRawSql,
+  declares,
+  index_default
+};

package/dist/express.js

@@ -5,7 +5,17 @@ import {
   routeHelperIndex,
   wrapperDiscovery
 } from "@suss/extractor";
-var METHODS = [".get", ".post", ".put", ".delete", ".patch", ".all"];
+var METHODS = [
+  ".get",
+  ".post",
+  ".put",
+  ".delete",
+  ".patch",
+  ".head",
+  ".options",
+  ".search",
+  ".all"
+];
 var HEADER_SETTERS = [
   "set",
   "header",

package/dist/fastify.js

@@ -19,7 +19,6 @@ function fastifyFramework(_options = {}) {
     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",

package/dist/graphql-ruby.js

@@ -95,14 +95,30 @@ function graphqlRubyFramework(options) {
   return {
     name: "graphql-ruby",
     protocol: "http-graphql",
-    discovery: [pattern]
+    discovery: [pattern],
+    // A resolver that reads a model through the dataloader passes the model
+    // as an argument, so the read is recorded against that model when a
+    // storage pack in the same run says it is one.
+    loaders: [
+      {
+        loader: "dataloader",
+        pick: "with",
+        reads: ["load", "load_all", "request", "request_all"],
+        shortcuts: [
+          "dataload",
+          "dataload_all",
+          "dataload_record",
+          "dataload_all_records"
+        ]
+      }
+    ]
   };
 }
 var declares = {
   kind: "framework",
   package: "@suss/framework-graphql-ruby",
   dependencies: [{ ecosystem: "rubygems", name: "graphql" }],
-  reads: "graphql-ruby class-based field DSL (Ruby), including `mutation:` / `resolver:` wiring one hop out to what the referenced class itself declares.",
+  reads: "graphql-ruby class-based field DSL (Ruby), including `mutation:` / `resolver:` wiring one hop out to what the referenced class itself declares, and the model a resolver reads through `dataloader` when a storage pack in the run recognizes it.",
   configuration: {
     file: "suss.graphql-ruby.json",
     example: { root: "app/graphql" },

package/dist/prisma.js

@@ -278,23 +278,23 @@ function fieldsOfRows(read) {
   return out.size === 0 ? ["*"] : [...out];
 }
 function isPrismaClientReceiver(node) {
-  const type = node.getType();
-  if (type === null || typeof type !== "object") {
+  return extendsPrismaClient(node.getType(), /* @__PURE__ */ new Set());
+}
+function extendsPrismaClient(type, seen) {
+  if (seen.has(type)) {
     return false;
   }
-  const symbol = type.getSymbol?.();
-  if (symbol === null || symbol === void 0) {
-    return false;
+  seen.add(type);
+  const declarations = type.getSymbol()?.getDeclarations() ?? [];
+  if (declarations.some(
+    (declaration) => isPrismaClientPath(declaration.getSourceFile().getFilePath())
+  )) {
+    return true;
   }
-  const decls = symbol.getDeclarations?.() ?? [];
-  for (const decl of decls) {
-    const declSourceFile = decl.getSourceFile();
-    const filePath = declSourceFile.getFilePath();
-    if (filePath.includes("/@prisma/client/") || filePath.includes("/.prisma/client/")) {
-      return true;
-    }
-  }
-  return false;
+  return type.getBaseTypes().some((base) => extendsPrismaClient(base, seen));
+}
+function isPrismaClientPath(filePath) {
+  return filePath.includes("/@prisma/client/") || filePath.includes("/.prisma/client/");
 }
 function capitalizeFirst(name) {
   if (name.length === 0) {