@suss/packs 0.21.0 → 0.22.0

package/dist/activerecord.d.ts

@@ -28,6 +28,7 @@ import '@suss/framework-nextjs';
 import '@suss/runtime-node';
 import '@suss/framework-package-exports';
 import '@suss/framework-prisma';
+import '@suss/framework-rails';
 import '@suss/framework-react-query';
 import '@suss/framework-react-router';
 import '@suss/framework-react';

package/dist/aws-dynamodb.js

@@ -24,8 +24,15 @@ var ATTRIBUTES = ({ input, entry, kind }) => {
   if (projected !== null) {
     return projected;
   }
+  if (kind !== "write") {
+    return everything(kind);
+  }
   const written = namesIn(input.property("Item"));
-  return kind === "write" && written.length > 0 ? written : everything(kind);
+  if (written.length > 0) {
+    return written;
+  }
+  const updated = updatedAttributes(input);
+  return updated.length > 0 ? updated : everything(kind);
 };
 var KEY_ATTRIBUTES = ({ input, entry }) => {
   if (entry !== null) {
@@ -101,6 +108,10 @@ function aliasesIn(input) {
   }
   return names;
 }
+function updatedAttributes(input) {
+  const expression = input.property("UpdateExpression")?.text() ?? null;
+  return expression === null ? [] : updateExpressionAttributes(expression, aliasesIn(input));
+}
 var REQUESTED = ["Item", "Key", "Keys"];
 function requestedAttributes(requests) {
   const found = /* @__PURE__ */ new Set();
@@ -129,7 +140,7 @@ var ATTRIBUTE_POSITIONS = [
   /\(\s*([#\w.]+)\s*,/g,
   /([#\w.]+)\s+[A-Za-z_]+\s+:/g
 ];
-function keyConditionAttributes(expression, names) {
+function attributeCollector(names) {
   const found = [];
   const add = (token) => {
     if (token === void 0) {
@@ -140,6 +151,10 @@ function keyConditionAttributes(expression, names) {
       found.push(name);
     }
   };
+  return { found, add };
+}
+function keyConditionAttributes(expression, names) {
+  const { found, add } = attributeCollector(names);
   for (const pattern of ATTRIBUTE_POSITIONS) {
     for (const match of expression.matchAll(pattern)) {
       add(match[1]);
@@ -147,6 +162,56 @@ function keyConditionAttributes(expression, names) {
   }
   return found;
 }
+function updateClauses(expression) {
+  const pattern = /\b(set|remove|add|delete)\b/gi;
+  const starts = [];
+  for (let match = pattern.exec(expression); match !== null; match = pattern.exec(expression)) {
+    starts.push({
+      keyword: match[0].toLowerCase(),
+      index: match.index,
+      bodyStart: match.index + match[0].length
+    });
+  }
+  return starts.map(({ keyword, bodyStart }, position) => ({
+    keyword,
+    body: expression.slice(
+      bodyStart,
+      starts[position + 1]?.index ?? expression.length
+    )
+  }));
+}
+function firstToken(item) {
+  return item.split(/\s+/)[0];
+}
+var CLAUSE_PATH = {
+  set: (item) => {
+    const at = item.indexOf("=");
+    return at === -1 ? null : item.slice(0, at);
+  },
+  remove: (item) => item,
+  add: firstToken,
+  delete: firstToken
+};
+function firstPathElement(path) {
+  return /^[#\w]+/.exec(path.trim())?.[0];
+}
+function updateExpressionAttributes(expression, names) {
+  const { found, add } = attributeCollector(names);
+  for (const clause of updateClauses(expression)) {
+    for (const raw of clause.body.split(",")) {
+      const item = raw.trim();
+      if (item === "") {
+        continue;
+      }
+      const path = CLAUSE_PATH[clause.keyword](item);
+      if (path === null) {
+        continue;
+      }
+      add(firstPathElement(path));
+    }
+  }
+  return found;
+}
 var optionsSchema = z.object({
   /**
    * Further modules whose presence makes a file worth reading. A helper

package/dist/graphql-ruby.d.ts

@@ -1 +1 @@
-export { default, optionsSchema } from '@suss/framework-graphql-ruby';
+export { GRAPHQL_RUBY_ROOT_CLASS_NAMES, default, optionsSchema } from '@suss/framework-graphql-ruby';

package/dist/graphql-ruby.js

@@ -20,6 +20,16 @@ var optionsSchema = z.object({
   /** The schema-wide camelCase default. A `field` or `argument` call's own `camelize:` keyword overrides it for that one name. */
   camelize: z.boolean().optional()
 }).strict();
+var GRAPHQL_RUBY_ROOT_CLASS_NAMES = [
+  "GraphQL::Schema::Object",
+  "GraphQL::Schema::Mutation",
+  "GraphQL::Schema::Resolver",
+  "GraphQL::Schema::Interface",
+  "GraphQL::Schema::InputObject",
+  "GraphQL::Schema::Enum",
+  "GraphQL::Schema::Union",
+  "GraphQL::Schema::Scalar"
+];
 var DEFAULT_BASE_CLASS_NAMES = [
   "Types::BaseObject",
   "Types::BaseInterface",
@@ -53,18 +63,7 @@ function graphqlRubyFramework(options) {
     argumentCallName: "argument",
     wiringKeywords: ["mutation", "resolver"],
     resolverMethodName: "resolve",
-    // The classes graphql-ruby's own generated base classes extend or
-    // mix in. A project's chain ends at one of them.
-    ancestryRootClassNames: [
-      "GraphQL::Schema::Object",
-      "GraphQL::Schema::Mutation",
-      "GraphQL::Schema::Resolver",
-      "GraphQL::Schema::Interface",
-      "GraphQL::Schema::InputObject",
-      "GraphQL::Schema::Enum",
-      "GraphQL::Schema::Union",
-      "GraphQL::Schema::Scalar"
-    ],
+    ancestryRootClassNames: [...GRAPHQL_RUBY_ROOT_CLASS_NAMES],
     requiredKeyword: "required",
     // graphql-ruby registers an argument as required unless the call
     // opts out with `required: false`.
@@ -99,6 +98,7 @@ function graphqlRubyFramework(options) {
 }
 var index_default = graphqlRubyFramework;
 export {
+  GRAPHQL_RUBY_ROOT_CLASS_NAMES,
   index_default as default,
   optionsSchema
 };

package/dist/rails.d.ts

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

package/dist/rails.js

@@ -0,0 +1,425 @@
+// ../framework/rails/dist/index.js
+import path from "path";
+import { z } from "zod";
+import { underscoreConstantPath } from "@suss/adapter-ruby";
+import fs from "fs";
+import {
+  bodyStatements,
+  field,
+  hashKeySymbolName,
+  parseRubySync,
+  stringLiteralValue,
+  symbolValue
+} from "@suss/adapter-ruby";
+function readSimpleArgs(call) {
+  const argumentList = field(call, "arguments");
+  const positional = [];
+  const keyword = {};
+  let hashRocketPair = null;
+  if (argumentList === null) {
+    return { positional, keyword, hashRocketPair };
+  }
+  for (const child of bodyStatements(argumentList)) {
+    if (child.type !== "pair") {
+      positional.push(child);
+      continue;
+    }
+    const keyNode = field(child, "key");
+    const valueNode = field(child, "value");
+    if (keyNode === null || valueNode === null) {
+      continue;
+    }
+    const symbolKey = hashKeySymbolName(keyNode);
+    if (symbolKey !== null) {
+      keyword[symbolKey] = valueNode;
+    } else {
+      hashRocketPair = { key: keyNode, value: valueNode };
+    }
+  }
+  return { positional, keyword, hashRocketPair };
+}
+function wordValue(node) {
+  if (node === void 0) {
+    return null;
+  }
+  return symbolValue(node) ?? stringLiteralValue(node);
+}
+function splitControllerAction(text) {
+  const index = text.indexOf("#");
+  if (index === -1) {
+    return null;
+  }
+  return { controllerKey: text.slice(0, index), action: text.slice(index + 1) };
+}
+function readRouteTarget(args) {
+  const toText = args.keyword.to ? stringLiteralValue(args.keyword.to) : null;
+  if (toText !== null) {
+    const target = splitControllerAction(toText);
+    return target === null ? null : { ...target, path: null };
+  }
+  if (args.hashRocketPair !== null) {
+    const pathText = stringLiteralValue(args.hashRocketPair.key);
+    const actionText = stringLiteralValue(args.hashRocketPair.value);
+    const target = actionText !== null ? splitControllerAction(actionText) : null;
+    return target !== null && pathText !== null ? { ...target, path: pathText } : null;
+  }
+  return null;
+}
+function readSymbolList(node) {
+  if (node === void 0) {
+    return null;
+  }
+  if (node.type === "array") {
+    return bodyStatements(node).map((child) => symbolValue(child)).filter((name) => name !== null);
+  }
+  const single = symbolValue(node);
+  return single === null ? null : [single];
+}
+var RESTFUL_ROUTES_PLURAL = {
+  index: (base) => ({ method: "GET", path: base }),
+  create: (base) => ({ method: "POST", path: base }),
+  new: (base) => ({ method: "GET", path: `${base}/new` }),
+  show: (base) => ({ method: "GET", path: `${base}/:id` }),
+  edit: (base) => ({ method: "GET", path: `${base}/:id/edit` }),
+  update: (base) => ({ method: "PATCH", path: `${base}/:id` }),
+  destroy: (base) => ({ method: "DELETE", path: `${base}/:id` })
+};
+var RESTFUL_ROUTES_SINGULAR = {
+  create: (base) => ({ method: "POST", path: base }),
+  new: (base) => ({ method: "GET", path: `${base}/new` }),
+  show: (base) => ({ method: "GET", path: base }),
+  edit: (base) => ({ method: "GET", path: `${base}/edit` }),
+  update: (base) => ({ method: "PATCH", path: base }),
+  destroy: (base) => ({ method: "DELETE", path: base })
+};
+function pluralize(word) {
+  if (/[^aeiou]y$/.test(word)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (/(s|x|z|ch|sh)$/.test(word)) {
+    return `${word}es`;
+  }
+  return `${word}s`;
+}
+function singularize(word) {
+  if (/ies$/.test(word)) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (/(ses|xes|zes|ches|shes)$/.test(word)) {
+    return word.slice(0, -2);
+  }
+  return /s$/.test(word) ? word.slice(0, -1) : word;
+}
+var RouteAccumulator = class {
+  byKey = /* @__PURE__ */ new Map();
+  unread = /* @__PURE__ */ new Set();
+  add(controllerKey, action, route) {
+    this.byKey.set(`${controllerKey}#${action}`, route);
+  }
+  recordUnread(callName) {
+    this.unread.add(callName);
+  }
+  routeFor(controllerKey, action) {
+    return this.byKey.get(`${controllerKey}#${action}`) ?? null;
+  }
+  gapsAgainst(displayPath) {
+    if (this.unread.size === 0) {
+      return [];
+    }
+    const names = [...this.unread].sort().join(", ");
+    return [
+      `${displayPath} also declares ${names}, which this pack does not read; whatever those declarations route is missing from what suss reports`
+    ];
+  }
+};
+function joinKey(prefix, segment) {
+  return prefix === "" ? segment : `${prefix}/${segment}`;
+}
+function joinPath(prefix, segment) {
+  return `${prefix}/${segment}`;
+}
+function handleResourceCall(call, ctx, out, plural) {
+  const args = readSimpleArgs(call);
+  const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
+  if (symbol === null) {
+    return;
+  }
+  const controllerSegment = plural ? symbol : pluralize(symbol);
+  const controllerKey = joinKey(ctx.modulePrefix, controllerSegment);
+  const prefixBase = ctx.resource !== void 0 ? ctx.resource.nestedBase : ctx.pathPrefix;
+  const base = joinPath(prefixBase, symbol);
+  const only = readSymbolList(args.keyword.only);
+  const except = readSymbolList(args.keyword.except);
+  const table = plural ? RESTFUL_ROUTES_PLURAL : RESTFUL_ROUTES_SINGULAR;
+  for (const [action, routeAt] of Object.entries(table)) {
+    if (only !== null && !only.includes(action)) {
+      continue;
+    }
+    if (except?.includes(action)) {
+      continue;
+    }
+    out.add(controllerKey, action, routeAt(base));
+  }
+  const block = field(call, "block");
+  const body = block !== null ? field(block, "body") : null;
+  if (body === null) {
+    return;
+  }
+  const nested = {
+    controllerKey,
+    collectionBase: base,
+    memberBase: plural ? `${base}/:id` : base,
+    nestedBase: `${base}/:${singularize(symbol)}_id`,
+    ambientBase: null
+  };
+  walkBody(body, { ...ctx, resource: nested }, out);
+}
+function handleOnBlock(call, ctx, out, isMember) {
+  if (ctx.resource === void 0) {
+    return;
+  }
+  const block = field(call, "block");
+  const body = block !== null ? field(block, "body") : null;
+  if (body === null) {
+    return;
+  }
+  const ambientBase = isMember ? ctx.resource.memberBase : ctx.resource.collectionBase;
+  walkBody(body, { ...ctx, resource: { ...ctx.resource, ambientBase } }, out);
+}
+function handleVerb(call, ctx, out, method) {
+  const args = readSimpleArgs(call);
+  const target = readRouteTarget(args);
+  if (target !== null) {
+    const literalPath = args.positional[0] ? stringLiteralValue(args.positional[0]) : null;
+    const path2 = target.path ?? literalPath;
+    if (path2 !== null) {
+      out.add(target.controllerKey, target.action, {
+        method,
+        path: `${ctx.pathPrefix}${path2}`
+      });
+    }
+    return;
+  }
+  if (ctx.resource === void 0) {
+    return;
+  }
+  const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
+  if (symbol === null) {
+    return;
+  }
+  const on = wordValue(args.keyword.on);
+  const base = on === "collection" ? ctx.resource.collectionBase : on === "member" ? ctx.resource.memberBase : ctx.resource.ambientBase;
+  if (base === null) {
+    return;
+  }
+  out.add(ctx.resource.controllerKey, symbol, {
+    method,
+    path: `${base}/${symbol}`
+  });
+}
+function handleRoot(call, ctx, out) {
+  const args = readSimpleArgs(call);
+  const target = readRouteTarget(args) ?? (args.positional[0] ? splitControllerAction(stringLiteralValue(args.positional[0]) ?? "") : null);
+  if (target !== null) {
+    out.add(target.controllerKey, target.action, {
+      method: "GET",
+      path: ctx.pathPrefix === "" ? "/" : ctx.pathPrefix
+    });
+  }
+}
+function handleNamespace(call, ctx, out) {
+  const args = readSimpleArgs(call);
+  const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
+  const block = field(call, "block");
+  const body = block !== null ? field(block, "body") : null;
+  if (symbol === null || body === null) {
+    return;
+  }
+  walkBody(
+    body,
+    {
+      pathPrefix: joinPath(ctx.pathPrefix, symbol),
+      modulePrefix: joinKey(ctx.modulePrefix, symbol)
+    },
+    out
+  );
+}
+function handleScope(call, ctx, out) {
+  const args = readSimpleArgs(call);
+  const moduleName = wordValue(args.keyword.module);
+  const pathSegment = wordValue(args.keyword.path);
+  const block = field(call, "block");
+  const body = block !== null ? field(block, "body") : null;
+  if (body === null) {
+    return;
+  }
+  walkBody(
+    body,
+    {
+      pathPrefix: pathSegment !== null ? joinPath(ctx.pathPrefix, pathSegment) : ctx.pathPrefix,
+      modulePrefix: moduleName !== null ? joinKey(ctx.modulePrefix, moduleName) : ctx.modulePrefix
+    },
+    out
+  );
+}
+var HANDLERS = {
+  resources: (call, ctx, out) => handleResourceCall(call, ctx, out, true),
+  resource: (call, ctx, out) => handleResourceCall(call, ctx, out, false),
+  member: (call, ctx, out) => handleOnBlock(call, ctx, out, true),
+  collection: (call, ctx, out) => handleOnBlock(call, ctx, out, false),
+  namespace: handleNamespace,
+  scope: handleScope,
+  root: handleRoot,
+  get: (call, ctx, out) => handleVerb(call, ctx, out, "GET"),
+  post: (call, ctx, out) => handleVerb(call, ctx, out, "POST"),
+  patch: (call, ctx, out) => handleVerb(call, ctx, out, "PATCH"),
+  put: (call, ctx, out) => handleVerb(call, ctx, out, "PUT"),
+  delete: (call, ctx, out) => handleVerb(call, ctx, out, "DELETE")
+};
+function walkBody(body, ctx, out) {
+  for (const statement of bodyStatements(body)) {
+    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+      continue;
+    }
+    const name = field(statement, "method")?.text;
+    if (name === void 0) {
+      continue;
+    }
+    const handler = HANDLERS[name];
+    if (handler === void 0) {
+      out.recordUnread(name);
+      continue;
+    }
+    handler(statement, ctx, out);
+  }
+}
+function drawBlockBody(root) {
+  for (const statement of bodyStatements(root)) {
+    if (statement.type !== "call") {
+      continue;
+    }
+    const block = field(statement, "block");
+    const body = block !== null ? field(block, "body") : null;
+    if (body !== null) {
+      return body;
+    }
+  }
+  return null;
+}
+function readRoutesFile(absRoutesPath, displayPath) {
+  if (!fs.existsSync(absRoutesPath)) {
+    return {
+      routeFor: () => null,
+      fileFound: false,
+      gaps: [
+        `${displayPath} does not exist, so this run assumes each action's path and method from Rails' RESTful naming convention instead of reading it from routing`
+      ]
+    };
+  }
+  const source = fs.readFileSync(absRoutesPath, "utf8");
+  const tree = parseRubySync(source);
+  const out = new RouteAccumulator();
+  const body = drawBlockBody(tree.rootNode);
+  if (body !== null) {
+    walkBody(body, { pathPrefix: "", modulePrefix: "" }, out);
+  }
+  return {
+    routeFor: (controllerKey, action) => out.routeFor(controllerKey, action),
+    fileFound: true,
+    gaps: out.gapsAgainst(displayPath)
+  };
+}
+var optionsSchema = z.object({
+  /** The app directory a bare controller name is looked up under. Every Rails app scaffolds this at `app`. */
+  root: z.string().optional(),
+  /**
+   * The directory of the config file these options came from. Whatever
+   * read that file supplies this; it is not written in the file itself.
+   */
+  configDirectory: z.string().optional(),
+  /** Base classes beyond `ApplicationController` that also mark a class as a controller. */
+  baseClassNames: z.array(z.string()).optional(),
+  /** Where this project's routes live, relative to `configDirectory` when there is one. Every Rails app scaffolds this at `config/routes.rb`. */
+  routesFile: z.string().optional()
+}).strict();
+var RAILS_ROOT_CLASS_NAMES = [
+  "ActionController::Base",
+  "ActionController::API"
+];
+var RESTFUL_ACTIONS = {
+  index: { method: "GET", pathTemplate: "/:resource" },
+  show: { method: "GET", pathTemplate: "/:resource/:id" },
+  new: { method: "GET", pathTemplate: "/:resource/new" },
+  create: { method: "POST", pathTemplate: "/:resource" },
+  edit: { method: "GET", pathTemplate: "/:resource/:id/edit" },
+  update: { method: "PATCH", pathTemplate: "/:resource/:id" },
+  destroy: { method: "DELETE", pathTemplate: "/:resource/:id" }
+};
+function controllerKeyFromQualified(qualifiedName) {
+  const withoutSuffix = qualifiedName.endsWith("Controller") ? qualifiedName.slice(0, -"Controller".length) : qualifiedName;
+  return underscoreConstantPath(withoutSuffix);
+}
+function conventionalRoute(controllerKey, actionName) {
+  const template = RESTFUL_ACTIONS[actionName];
+  if (template === void 0) {
+    return null;
+  }
+  const resource = controllerKey.split("/").pop() ?? controllerKey;
+  return {
+    method: template.method,
+    path: template.pathTemplate.replace(":resource", resource)
+  };
+}
+function resolveAgainst(configDirectory, value) {
+  if (configDirectory === void 0 || path.isAbsolute(value)) {
+    return value;
+  }
+  return path.resolve(configDirectory, value);
+}
+function railsFramework(options = {}) {
+  const root = resolveAgainst(options.configDirectory, options.root ?? "app");
+  const routesFile = resolveAgainst(
+    options.configDirectory,
+    options.routesFile ?? "config/routes.rb"
+  );
+  let table;
+  const routeTable = () => {
+    table ??= readRoutesFile(
+      routesFile,
+      options.routesFile ?? "config/routes.rb"
+    );
+    return table;
+  };
+  const pattern = {
+    type: "controllerActions",
+    baseClassNames: [
+      "ApplicationController",
+      ...options.baseClassNames ?? []
+    ],
+    root,
+    pathConvention: "railsUnderscore",
+    ancestryRootClassNames: [...RAILS_ROOT_CLASS_NAMES],
+    defaultStatusCode: 200,
+    routesFile,
+    routeFor: (controllerQualifiedName, actionName) => {
+      const key = controllerKeyFromQualified(controllerQualifiedName);
+      const found = routeTable();
+      return found.fileFound ? found.routeFor(key, actionName) : conventionalRoute(key, actionName);
+    },
+    routingGaps: () => routeTable().gaps
+  };
+  return {
+    name: "rails",
+    protocol: "http",
+    discovery: [pattern],
+    // The routes file decides every action's method and path but is
+    // never walked, so the cache key has to read it here.
+    discoveryInputs: () => [routesFile]
+  };
+}
+var index_default = railsFramework;
+export {
+  RAILS_ROOT_CLASS_NAMES,
+  index_default as default,
+  optionsSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/packs",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "type": "module",
   "description": "Every pack suss ships, as one package with a subpath per pack.",
   "keywords": [
@@ -140,6 +140,10 @@
       "types": "./dist/prisma.d.ts",
       "import": "./dist/prisma.js"
     },
+    "./rails": {
+      "types": "./dist/rails.d.ts",
+      "import": "./dist/rails.js"
+    },
     "./react": {
       "types": "./dist/react.d.ts",
       "import": "./dist/react.js"
@@ -185,15 +189,15 @@
     "ts-morph": "^23.0.0"
   },
   "dependencies": {
-    "@suss/adapter-python": "0.21.0",
-    "@suss/adapter-ruby": "0.21.0",
-    "@suss/adapter-typescript": "0.21.0",
-    "@suss/behavioral-ir": "0.21.0",
-    "@suss/contract-graphql": "0.21.0",
-    "@suss/extractor": "0.21.0",
-    "@suss/manifest-aws": "0.21.0",
-    "@suss/recognize": "0.21.0",
-    "@suss/sql": "0.21.0",
+    "@suss/adapter-python": "0.22.0",
+    "@suss/adapter-ruby": "0.22.0",
+    "@suss/adapter-typescript": "0.22.0",
+    "@suss/behavioral-ir": "0.22.0",
+    "@suss/contract-graphql": "0.22.0",
+    "@suss/extractor": "0.22.0",
+    "@suss/manifest-aws": "0.22.0",
+    "@suss/recognize": "0.22.0",
+    "@suss/sql": "0.22.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
@@ -226,6 +230,7 @@
     "@suss/framework-nextjs": "*",
     "@suss/framework-package-exports": "*",
     "@suss/framework-prisma": "*",
+    "@suss/framework-rails": "*",
     "@suss/framework-react": "*",
     "@suss/framework-react-query": "*",
     "@suss/framework-zustand": "*",