@suss/packs 0.29.0 → 0.30.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/{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/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-CZY5QLMS.js";
+} from "./chunk-NYWZHQBJ.js";
 export {
   declares,
   index_default as default,

package/dist/sqlmodel.js

@@ -2,7 +2,7 @@ import {
   sqlalchemyModels,
   sqlalchemyRawSql,
   sqlalchemyStorage
-} from "./chunk-CZY5QLMS.js";
+} from "./chunk-NYWZHQBJ.js";
 
 // ../framework/sqlmodel/dist/index.js
 import { z } from "zod";
@@ -78,6 +78,10 @@ function sqlmodelModels() {
     entryFunctions: [
       ...model.entryFunctions,
       { module: "sqlmodel", name: "select", argument: 0 }
+    ],
+    relationships: [
+      ...model.relationships ?? [],
+      { module: "sqlmodel", name: "Relationship" }
     ]
   }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/packs",
-  "version": "0.29.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.29.0",
-    "@suss/adapter-ruby": "0.29.0",
-    "@suss/adapter-typescript": "0.29.0",
-    "@suss/behavioral-ir": "0.29.0",
-    "@suss/contract-graphql": "0.29.0",
-    "@suss/extractor": "0.29.0",
-    "@suss/manifest-aws": "0.29.0",
-    "@suss/recognize": "0.29.0",
-    "@suss/sql": "0.29.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": {