@suss/packs 0.28.0 → 0.30.0

package/dist/activerecord.js

@@ -8,6 +8,96 @@ var optionsSchema = z.object({
    */
   storageSystem: storageSystemOption
 }).strict();
+var RETURNS_A_RECORD = [
+  "find",
+  "find_by",
+  "find_by!",
+  "find_or_create_by",
+  "find_or_create_by!",
+  "find_or_initialize_by",
+  "first",
+  "first!",
+  "last",
+  "last!",
+  "take",
+  "take!",
+  "sole",
+  "find_sole_by",
+  "new",
+  "build",
+  "create",
+  "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",
+  "or",
+  "order",
+  "reorder",
+  "limit",
+  "offset",
+  "includes",
+  "preload",
+  "eager_load",
+  "joins",
+  "left_joins",
+  "left_outer_joins",
+  "distinct",
+  "select",
+  "group",
+  "having",
+  "merge",
+  "readonly",
+  "lock",
+  "none",
+  "all",
+  "unscoped",
+  "unscope",
+  "extending",
+  "from",
+  "references",
+  "only",
+  "except"
+];
+var READS = [...RUNS_A_QUERY, ...RETURNS_A_RELATION, "not"];
 function activeRecordStorage(options) {
   return [
     {
@@ -29,8 +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
     }
   ];
@@ -55,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/{chunk-SKGM3QL5.js → chunk-NYWZHQBJ.js}

@@ -55,6 +55,52 @@ function sqlalchemyStorage(options) {
     }
   ];
 }
+var MODEL_BASE_NAMES = [
+  "DeclarativeBase",
+  "declarative_base",
+  "DeclarativeBaseNoMeta"
+];
+var NARROWS_A_QUERY = [
+  "filter",
+  "filter_by",
+  "where",
+  "order_by",
+  "limit",
+  "offset",
+  "options",
+  "join",
+  "outerjoin",
+  "distinct",
+  "group_by",
+  "having"
+];
+var RUNS_A_QUERY = [
+  "first",
+  "one",
+  "one_or_none",
+  "scalar",
+  "scalar_one",
+  "scalar_one_or_none",
+  "scalars",
+  "get",
+  "all"
+];
+var SESSION_ENTRY_METHODS = [
+  { method: "get", argument: 0 },
+  { method: "query", argument: 0 },
+  { method: "execute", argument: 0 }
+];
+function sqlalchemyModels() {
+  return [
+    {
+      baseNames: MODEL_BASE_NAMES,
+      givesBack: [...NARROWS_A_QUERY, ...RUNS_A_QUERY],
+      entryMethods: SESSION_ENTRY_METHODS,
+      entryFunctions: [{ module: "sqlalchemy", name: "select", argument: 0 }],
+      relationships: [{ module: "sqlalchemy.orm", name: "relationship" }]
+    }
+  ];
+}
 function sqlalchemyRawSql(options) {
   return [
     {
@@ -75,6 +121,7 @@ function sqlalchemyFramework(options) {
     protocol: options.storageSystem,
     discovery: [],
     storage: sqlalchemyStorage(options),
+    models: sqlalchemyModels(),
     rawSql: sqlalchemyRawSql(options)
   };
 }
@@ -95,6 +142,7 @@ var index_default = sqlalchemyFramework;
 export {
   optionsSchema,
   sqlalchemyStorage,
+  sqlalchemyModels,
   sqlalchemyRawSql,
   declares,
   index_default

package/dist/rails.js

@@ -133,25 +133,66 @@ function isolatedNamespaceOf(classNode, acronyms) {
   return "";
 }
 var ACRONYM_CALL = /\.acronym\s*\(?\s*(["'])([A-Za-z\d]+)\1/g;
-function readAcronyms(configDirectory) {
-  const found = /* @__PURE__ */ new Set();
+var IRREGULAR_CALL = /\.irregular\s*\(?\s*(["'])([^"']*)\1\s*,\s*(["'])([^"']*)\3/g;
+var UNCOUNTABLE_CALL = /\.uncountable\s*\(?\s*([^\n]*)/g;
+var SINGULAR_CALL = /\.singular\s*\(?\s*(?:(["'])([^"']*)\1|\/([^/]*)\/([a-z]*))\s*,\s*(["'])([^"']*)\5/g;
+var WORD_LIST = /%[wi][([{]([^)\]}]*)[)\]}]/;
+var EVERY_LITERAL = /(["'])([^"']*)\1/g;
+var ANY_CALL = /\.(acronym|irregular|uncountable|singular)[\s("'/]/;
+function group(match, at) {
+  return match[at] ?? "";
+}
+function readInflections(configDirectory) {
+  const acronyms = /* @__PURE__ */ new Set();
+  const irregular = [];
+  const uncountable = /* @__PURE__ */ new Set();
+  const singular = [];
   for (const file of inflectionFiles(configDirectory)) {
-    const source = fs2.readFileSync(file, "utf8");
+    const source = uncommented(fs2.readFileSync(file, "utf8"));
     for (const match of source.matchAll(ACRONYM_CALL)) {
-      found.add(match[2] ?? "");
+      acronyms.add(group(match, 2));
+    }
+    for (const match of source.matchAll(IRREGULAR_CALL)) {
+      irregular.push([group(match, 4), group(match, 2)]);
+    }
+    for (const match of source.matchAll(UNCOUNTABLE_CALL)) {
+      for (const word of wordsIn(group(match, 1))) {
+        uncountable.add(word);
+      }
+    }
+    for (const match of source.matchAll(SINGULAR_CALL)) {
+      singular.push([ruleOf(match), group(match, 6)]);
     }
   }
-  found.delete("");
-  return [...found].sort();
+  acronyms.delete("");
+  uncountable.delete("");
+  return {
+    acronyms: [...acronyms].sort(),
+    irregular,
+    uncountable: [...uncountable].sort(),
+    singular
+  };
+}
+function ruleOf(match) {
+  const literal = match[2];
+  return literal === void 0 ? `/${group(match, 3)}/${group(match, 4)}` : literal;
+}
+function wordsIn(argument) {
+  const list = WORD_LIST.exec(argument);
+  if (list !== null) {
+    return group(list, 1).split(/\s+/).filter((word) => word.length > 0);
+  }
+  return [...argument.matchAll(EVERY_LITERAL)].map((match) => group(match, 2));
 }
 function inflectionFiles(configDirectory) {
   const directory = path2.join(configDirectory, "config", "initializers");
   if (!fs2.existsSync(directory)) {
     return [];
   }
-  return fs2.readdirSync(directory, { withFileTypes: true, recursive: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".rb")).map((entry) => path2.join(entry.parentPath, entry.name)).filter(
-    (file) => fs2.readFileSync(file, "utf8").match(ACRONYM_CALL) !== null
-  ).sort();
+  return fs2.readdirSync(directory, { withFileTypes: true, recursive: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".rb")).map((entry) => path2.join(entry.parentPath, entry.name)).filter((file) => ANY_CALL.test(uncommented(fs2.readFileSync(file, "utf8")))).sort();
+}
+function uncommented(source) {
+  return source.split("\n").filter((line) => !line.trimStart().startsWith("#")).join("\n");
 }
 function readSimpleArgs(call, defaults = {}) {
   const argumentList = field2(call, "arguments");
@@ -926,6 +967,19 @@ var RAILS_CONTROLLER_METHODS = [
   "controller_name",
   "controller_path"
 ];
+var BODY_BLOCKS = [
+  { name: "included", moduleOnly: true },
+  { name: "prepended", moduleOnly: true },
+  { name: "class_methods", moduleOnly: true, definesClassMethods: true },
+  { name: "concerning" },
+  { name: "with_options" }
+];
+var EMPTY_INFLECTIONS = {
+  acronyms: [],
+  irregular: [],
+  uncountable: [],
+  singular: []
+};
 function controllerKeyFromQualified(qualifiedName, acronyms) {
   const withoutSuffix = qualifiedName.endsWith("Controller") ? qualifiedName.slice(0, -"Controller".length) : qualifiedName;
   return underscoreConstantPath2(withoutSuffix, acronyms);
@@ -956,7 +1010,8 @@ function railsFramework(options = {}) {
   const displayPathOf = (file) => options.configDirectory === void 0 ? file : path4.relative(options.configDirectory, file);
   const engineRoots = () => expandPatterns(options.configDirectory, options.engineRoots);
   const extraRoutesFiles = () => expandPatterns(options.configDirectory, options.routesFiles);
-  const acronyms = options.configDirectory === void 0 ? [] : readAcronyms(options.configDirectory);
+  const inflections = options.configDirectory === void 0 ? EMPTY_INFLECTIONS : readInflections(options.configDirectory);
+  const acronyms = inflections.acronyms;
   const routesInput = () => ({
     routesFile: {
       file: routesFile,
@@ -1006,6 +1061,8 @@ function railsFramework(options = {}) {
     name: "rails",
     protocol: "http",
     discovery: [pattern],
+    bodyBlocks: BODY_BLOCKS,
+    inflections,
     // Every file routing or naming is read from decides an action's
     // binding without being walked, so the cache key has to read them
     // here. This runs before the grammar loads, so nothing parses Ruby.

package/dist/sqlalchemy.js

@@ -2,7 +2,7 @@ import {
   declares,
   index_default,
   optionsSchema
-} from "./chunk-SKGM3QL5.js";
+} from "./chunk-NYWZHQBJ.js";
 export {
   declares,
   index_default as default,

package/dist/sqlmodel.js

@@ -1,7 +1,8 @@
 import {
+  sqlalchemyModels,
   sqlalchemyRawSql,
   sqlalchemyStorage
-} from "./chunk-SKGM3QL5.js";
+} from "./chunk-NYWZHQBJ.js";
 
 // ../framework/sqlmodel/dist/index.js
 import { z } from "zod";
@@ -69,6 +70,21 @@ function sqlmodelStorage(options) {
     ...sqlalchemyStorage(options)
   ];
 }
+function sqlmodelModels() {
+  return sqlalchemyModels().map((model) => ({
+    baseNames: [...model.baseNames, "SQLModel"],
+    givesBack: model.givesBack,
+    entryMethods: [...model.entryMethods, { method: "exec", argument: 0 }],
+    entryFunctions: [
+      ...model.entryFunctions,
+      { module: "sqlmodel", name: "select", argument: 0 }
+    ],
+    relationships: [
+      ...model.relationships ?? [],
+      { module: "sqlmodel", name: "Relationship" }
+    ]
+  }));
+}
 function sqlmodelRawSql(options) {
   return [
     {
@@ -90,6 +106,7 @@ function sqlmodelFramework(options) {
     protocol: options.storageSystem,
     discovery: [],
     storage: sqlmodelStorage(options),
+    models: sqlmodelModels(),
     rawSql: sqlmodelRawSql(options)
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/packs",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "description": "Every pack suss ships in one install, so it can read Express, Hono, NestJS, FastAPI, Rails, Prisma, OpenAPI and the rest.",
   "keywords": [
@@ -218,15 +218,15 @@
     "ts-morph": "^23.0.0"
   },
   "dependencies": {
-    "@suss/adapter-python": "0.28.0",
-    "@suss/adapter-ruby": "0.28.0",
-    "@suss/adapter-typescript": "0.28.0",
-    "@suss/behavioral-ir": "0.28.0",
-    "@suss/contract-graphql": "0.28.0",
-    "@suss/extractor": "0.28.0",
-    "@suss/manifest-aws": "0.28.0",
-    "@suss/recognize": "0.28.0",
-    "@suss/sql": "0.28.0",
+    "@suss/adapter-python": "0.30.0",
+    "@suss/adapter-ruby": "0.30.0",
+    "@suss/adapter-typescript": "0.30.0",
+    "@suss/behavioral-ir": "0.30.0",
+    "@suss/contract-graphql": "0.30.0",
+    "@suss/extractor": "0.30.0",
+    "@suss/manifest-aws": "0.30.0",
+    "@suss/recognize": "0.30.0",
+    "@suss/sql": "0.30.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {