@suss/packs 0.35.1 → 0.37.0

package/dist/graphql-ruby.js

@@ -4,11 +4,11 @@ import { z } from "zod";
 import { SCALAR_SHAPES } from "@suss/contract-graphql";
 var optionsSchema = z.object({
   /**
-   * The directory the pack looks under for the class a `mutation:` or
-   * `resolver:` field references, for example
-   * `path.join(repoRoot, "app/graphql")`. A relative path resolves
-   * against `configDirectory`, or the working directory when that is
-   * unset.
+   * The directory the pack looks under for a class a `mutation:` or
+   * `resolver:` field references when no file in the run declares it,
+   * for example `path.join(repoRoot, "app/graphql")`. A relative path
+   * resolves against `configDirectory`, or the working directory when
+   * that is unset.
    */
   root: z.string(),
   /**
@@ -29,6 +29,7 @@ var optionsSchema = z.object({
 var GRAPHQL_RUBY_ROOT_CLASS_NAMES = [
   "GraphQL::Schema::Object",
   "GraphQL::Schema::Mutation",
+  "GraphQL::Schema::RelayClassicMutation",
   "GraphQL::Schema::Resolver",
   "GraphQL::Schema::Interface",
   "GraphQL::Schema::InputObject",
@@ -44,6 +45,56 @@ var DEFAULT_BASE_CLASS_NAMES = [
   "Types::BaseUnion",
   "Types::BaseScalar"
 ];
+function orNull(shape) {
+  return { type: "union", variants: [shape, { type: "null" }] };
+}
+var PAGE_INFO_FIELDS = {
+  hasNextPage: { type: "boolean" },
+  hasPreviousPage: { type: "boolean" },
+  startCursor: orNull({ type: "text" }),
+  endCursor: orNull({ type: "text" })
+};
+var CONNECTION_TYPE = {
+  name: "{type}Connection",
+  types: {
+    "{type}Connection": {
+      edges: orNull({
+        type: "array",
+        items: orNull({ type: "ref", name: "{type}Edge" })
+      }),
+      nodes: orNull({
+        type: "array",
+        items: orNull({ type: "ref", name: "{type}" })
+      }),
+      pageInfo: { type: "ref", name: "PageInfo" }
+    },
+    "{type}Edge": {
+      cursor: { type: "text" },
+      node: orNull({ type: "ref", name: "{type}" })
+    }
+  }
+};
+var COLLECTION_METADATA_FIELDS = {
+  currentPage: { type: "number" },
+  limitValue: { type: "number" },
+  totalCount: { type: "number" },
+  totalPages: { type: "number" }
+};
+var COLLECTION_TYPE = {
+  name: "{type}Collection",
+  types: {
+    "{type}Collection": {
+      collection: { type: "array", items: { type: "ref", name: "{type}" } },
+      metadata: { type: "ref", name: "{metadata_type}" }
+    }
+  },
+  typeArguments: {
+    "{metadata_type}": {
+      keyword: "metadata_type",
+      fallback: "CollectionMetadata"
+    }
+  }
+};
 function rootDirectory(options) {
   if (options.configDirectory === void 0 || path.isAbsolute(options.root)) {
     return options.root;
@@ -69,6 +120,38 @@ function graphqlRubyFramework(options) {
     argumentCallName: "argument",
     wiringKeywords: ["mutation", "resolver"],
     resolverMethodName: "resolve",
+    resolverMethodKeyword: "resolver_method",
+    // A Mutation or Resolver runs ready?, then authorized?, then resolve.
+    // A hook that returns false, or [false, payload], stops the field,
+    // and the payload comes back in its place.
+    resolverHooks: {
+      methods: ["ready?", "authorized?"],
+      answerIsListHead: true,
+      // A bare false from `ready?` resolves the field to null. One from
+      // `authorized?` raises, and the schema decides what the client sees.
+      refusalRaises: { "authorized?": "GraphQL::UnauthorizedFieldError" }
+    },
+    typeKeyword: "type",
+    typeNameCallName: "graphql_name",
+    // A field, and a mutation's or resolver's own type, can be null unless
+    // it says `null: false`. The items of a list cannot unless the list
+    // type says `[Type, null: true]`.
+    nullability: {
+      keyword: "null",
+      callName: "null",
+      nullableByDefault: true,
+      listItemsNullableByDefault: false
+    },
+    typeWrappers: {
+      connection_type: CONNECTION_TYPE,
+      collection_type: COLLECTION_TYPE
+    },
+    libraryTypes: {
+      PageInfo: PAGE_INFO_FIELDS,
+      CollectionMetadata: COLLECTION_METADATA_FIELDS
+    },
+    // Returning one of these puts it in `errors[]` in place of the value.
+    returnedErrorClassNames: ["GraphQL::ExecutionError"],
     ancestryRootClassNames: [...GRAPHQL_RUBY_ROOT_CLASS_NAMES],
     requiredKeyword: "required",
     // graphql-ruby registers an argument as required unless the call
@@ -124,13 +207,14 @@ var declares = {
   kind: "framework",
   package: "@suss/framework-graphql-ruby",
   dependencies: [{ ecosystem: "rubygems", name: "graphql" }],
-  reads: "graphql-ruby class-based field DSL (Ruby). The pack follows `mutation:` and `resolver:` wiring one hop out to what the referenced class declares. It also records the model a resolver reads through `dataloader`, when a storage pack in the run recognizes that model.",
+  reads: "graphql-ruby class-based field DSL (Ruby). The pack follows `mutation:` and `resolver:` wiring to the referenced class, wherever the run declares it, and reads its arguments, its payload, its `resolve` method and the `ready?` and `authorized?` hooks that run first. It follows `resolver_method:` to the type's own method. Each path through that method records what the field returns, from its declared type with null where the schema allows it and the object type's fields, and the errors it raises or returns. It also records the model a resolver reads through `dataloader`, when a storage pack in the run recognizes that model.",
   configuration: {
     file: "suss.graphql-ruby.json",
     example: { root: "app/graphql" },
     required: true,
-    why: "the directory a field's wired class is looked up under, read relative to this file. A Rails app generated by the library keeps its types and mutations under app/graphql.",
-    defaults: { root: "app/graphql" }
+    why: "the directory a field's wired class is looked up under when no file in the run declares it, read relative to this file. A Rails app generated by the library keeps its types and mutations under app/graphql.",
+    defaults: { root: "app/graphql" },
+    paths: ["root"]
   }
 };
 var index_default = graphqlRubyFramework;

package/dist/node.js

@@ -6,9 +6,11 @@ import {
 } from "ts-morph";
 import {
   declarationsBehind,
-  findEnclosingFunction,
+  dottedPathOf,
+  fallbackOf,
   functionTargetOf,
   isDefaultedAt,
+  scalarValueOf,
   stringValueOf,
   symbolBehind,
   toFunctionRoot
@@ -36,6 +38,7 @@ import { functionCallBinding } from "@suss/behavioral-ir";
 import { Node as Node4 } from "ts-morph";
 import { writtenPayloadOf } from "@suss/adapter-typescript";
 import { ioBinding } from "@suss/behavioral-ir";
+import { callSiteKey } from "@suss/extractor";
 var RECOGNITION = "@suss/runtime-node";
 function configBinding(where) {
   return runtimeConfigBinding({ recognition: RECOGNITION, ...where });
@@ -295,98 +298,46 @@ function schemaEnvReadsInside(callee, resolution) {
   SCHEMA_READS_INSIDE.set(callee, found);
   return found;
 }
-var readName = (name) => `process.env.${name}`;
-function isProcessEnv(node) {
+var ENVIRONMENT_OBJECTS = [
+  "process.env",
+  "import.meta.env"
+];
+var PROCESS_ENV = "process.env";
+var IMPORT_META_ENV = "import.meta.env";
+var VITE_BUILD_KEYS = /* @__PURE__ */ new Set(["MODE", "BASE_URL", "PROD", "DEV", "SSR"]);
+var readName = (read) => read.name === null ? read.node.getText() : `${read.object}.${read.name}`;
+function environmentSpelling(node) {
   if (!N2.isPropertyAccessExpression(node) || node.getName() !== "env") {
-    return false;
+    return null;
   }
-  const root = node.getExpression();
-  return N2.isIdentifier(root) && root.getText() === "process";
+  const path = dottedPathOf(node);
+  return path !== null && ENVIRONMENT_OBJECTS.includes(path) ? path : null;
 }
 function dottedRead(node) {
-  if (!isProcessEnv(node.getExpression())) {
+  const object = environmentSpelling(node.getExpression());
+  if (object === null) {
     return [];
   }
-  return [{ name: node.getName(), defaulted: isDefaultedAt(node), node }];
+  return [
+    { name: node.getName(), defaulted: isDefaultedAt(node), node, object }
+  ];
 }
-function bracketRead(access, resolution) {
+function bracketRead(access, object) {
   const argument = access.getArgumentExpression();
   if (argument === void 0) {
     return [];
   }
-  if (N2.isStringLiteral(argument) || N2.isNoSubstitutionTemplateLiteral(argument)) {
-    const name = argument.getLiteralValue();
-    if (name.length === 0) {
-      return [];
-    }
-    return [{ name, defaulted: isDefaultedAt(access), node: access }];
-  }
-  if (N2.isIdentifier(argument)) {
-    return readsThroughParameter(access, argument, resolution);
-  }
-  return [];
-}
-var CALLER_LOOKUPS = /* @__PURE__ */ new WeakMap();
-function readsThroughParameter(access, index, resolution) {
-  const remembered = CALLER_LOOKUPS.get(access);
-  if (remembered !== void 0) {
-    return remembered;
-  }
-  const found = callerLiteralReads(access, index, resolution);
-  CALLER_LOOKUPS.set(access, found);
-  return found;
-}
-function callerLiteralReads(access, index, resolution) {
-  if (resolution === void 0) {
-    return [];
-  }
-  const enclosing = findEnclosingFunction(access);
-  if (enclosing === null) {
-    return [];
-  }
-  const start = enclosing.getParameters().find((parameter) => parameter.getName() === index.getText());
-  if (start === void 0) {
-    return [];
-  }
   const defaulted = isDefaultedAt(access);
-  const reads = [];
-  const pending = [start];
-  const taken = /* @__PURE__ */ new Set();
-  while (pending.length > 0) {
-    const wanted = pending.pop();
-    if (taken.has(wanted)) {
-      continue;
-    }
-    taken.add(wanted);
-    for (const passed of resolution.argumentsPassedTo(wanted)) {
-      const literal = stringValueOf(passed.argument, resolution);
-      if (literal !== null && literal.length > 0) {
-        reads.push({ name: literal, defaulted, node: passed.call });
-        continue;
-      }
-      const forwarded = forwardedParameter(passed.argument, passed.call);
-      if (forwarded !== null) {
-        pending.push(forwarded);
-      }
-    }
-  }
-  return reads;
-}
-function forwardedParameter(passed, call) {
-  if (!N2.isIdentifier(passed)) {
-    return null;
+  if (!N2.isStringLiteral(argument) && !N2.isNoSubstitutionTemplateLiteral(argument)) {
+    return [{ name: null, defaulted, node: access, object }];
   }
-  const caller = findEnclosingFunction(call);
-  if (caller === null) {
-    return null;
-  }
-  const behind = symbolBehind(passed)?.getValueDeclaration();
-  if (behind === void 0 || !N2.isParameterDeclaration(behind)) {
-    return null;
+  const name = argument.getLiteralValue();
+  if (name.length === 0) {
+    return [];
   }
-  return behind.getParent() === caller ? behind : null;
+  return [{ name, defaulted, node: access, object }];
 }
-function bindingRead(element) {
+function bindingRead(element, object) {
   if (element.getDotDotDotToken() !== void 0) {
     return [];
   }
@@ -404,24 +355,25 @@ function bindingRead(element) {
       // A binding default covers a missing variable the same way `??`
       // does after a dotted read.
       defaulted: element.getInitializer() !== void 0 || isDefaultedAt(element),
-      node: element
+      node: element,
+      object
     }
   ];
 }
-function destructuredReads(declaration) {
+function destructuredReads(declaration, object) {
   const pattern = declaration.getNameNode();
   if (!N2.isObjectBindingPattern(pattern)) {
     return [];
   }
-  return pattern.getElements().flatMap(bindingRead);
+  return pattern.getElements().flatMap((element) => bindingRead(element, object));
 }
-function readsThroughEnvObject(envNode, resolution) {
+function readsThroughEnvObject(envNode, object) {
   const parent = envNode.getParent();
   if (N2.isElementAccessExpression(parent)) {
-    return bracketRead(parent, resolution);
+    return bracketRead(parent, object);
   }
   if (N2.isVariableDeclaration(parent)) {
-    return destructuredReads(parent);
+    return destructuredReads(parent, object);
   }
   return [];
 }
@@ -433,7 +385,8 @@ function envReadsAt(node, resolution) {
   if (!N2.isPropertyAccessExpression(node)) {
     return [];
   }
-  return isProcessEnv(node) ? readsThroughEnvObject(node, resolution) : dottedRead(node);
+  const object = environmentSpelling(node);
+  return object === null ? dottedRead(node) : readsThroughEnvObject(node, object);
 }
 function readsThroughHelperCall(call, resolution) {
   const callee = functionBehindCallee(call.getExpression(), resolution);
@@ -442,14 +395,15 @@ function readsThroughHelperCall(call, resolution) {
   }
   const sitesNaming = namesReadAtSites(callee, resolution);
   const parameters = callee.getParameters();
-  const defaultedByName = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
   call.getArguments().forEach((passed, at) => {
     const parameter = parameters[at];
     if (parameter === void 0) {
       return;
     }
     const sites = sitesNaming(parameter) ?? directEnvReads(callee, parameter);
-    if (sites.length === 0) {
+    const [first] = sites;
+    if (first === void 0 || handsOnParameter(passed)) {
       return;
     }
     const literal = stringValueOf(passed, resolution);
@@ -457,25 +411,40 @@ function readsThroughHelperCall(call, resolution) {
       return;
     }
     const everywhere = sites.every(isDefaultedAt);
-    defaultedByName.set(
-      literal,
-      (defaultedByName.get(literal) ?? true) && everywhere
-    );
+    const known = byName.get(literal);
+    byName.set(literal, {
+      defaulted: (known?.defaulted ?? true) && everywhere,
+      object: known?.object ?? objectReadAt(first)
+    });
   });
   const wrapped = isDefaultedAt(call);
   return [
-    ...[...defaultedByName].map(([name, atSites]) => ({
+    ...[...byName].map(([name, read]) => ({
       name,
-      defaulted: atSites || wrapped,
-      node: call
+      defaulted: read.defaulted || wrapped,
+      node: call,
+      object: read.object
     })),
     // A config module often parses its schema inside a function that
     // every handler calls, so each call reports the keys that parse reads.
     ...anchoredAt(schemaEnvReadsInside(callee, resolution), call)
   ];
 }
+function handsOnParameter(passed) {
+  if (!N2.isIdentifier(passed)) {
+    return false;
+  }
+  const declared = symbolBehind(passed)?.getValueDeclaration();
+  return declared !== void 0 && N2.isParameterDeclaration(declared);
+}
+function objectReadAt(site) {
+  if (!N2.isElementAccessExpression(site)) {
+    return PROCESS_ENV;
+  }
+  return environmentSpelling(site.getExpression()) ?? PROCESS_ENV;
+}
 function anchoredAt(reads, node) {
-  return reads.map((read) => ({ ...read, node }));
+  return reads.map((read) => ({ ...read, node, object: PROCESS_ENV }));
 }
 function functionBehindCallee(callee, resolution) {
   const nameNode = N2.isPropertyAccessExpression(callee) ? callee.getNameNode() : callee;
@@ -524,7 +493,7 @@ function directEnvRead(fn, parameter) {
   for (const access of fn.getDescendantsOfKind(
     SyntaxKind2.ElementAccessExpression
   )) {
-    if (!isProcessEnv(access.getExpression())) {
+    if (environmentSpelling(access.getExpression()) === null) {
       continue;
     }
     const argument = access.getArgumentExpression();
@@ -534,24 +503,36 @@ function directEnvRead(fn, parameter) {
   }
   return null;
 }
-function configReadEffect(read, where) {
+function readsBuildKey(read) {
+  return read.object === IMPORT_META_ENV && read.name !== null && VITE_BUILD_KEYS.has(read.name);
+}
+function configReadEffect(read, where, resolution) {
+  if (readsBuildKey(read)) {
+    return opaqueRuntimeRead(readName(read));
+  }
+  const fallback = read.defaulted ? defaultValueAt(read.node, resolution) : null;
   return {
     type: "interaction",
     binding: configBinding(where),
-    callee: readName(read.name),
+    callee: readName(read),
     interaction: {
       class: "config-read",
       name: read.name,
-      defaulted: read.defaulted
+      defaulted: read.defaulted,
+      ...fallback === null ? {} : { default: fallback }
     }
   };
 }
+function defaultValueAt(read, resolution) {
+  const fallback = fallbackOf(read);
+  return fallback === null ? null : scalarValueOf(fallback, resolution);
+}
 function recognizeProcessEnvRead(access, where, resolution) {
   const reads = envReadsAt(access, resolution);
   if (reads.length === 0) {
     return null;
   }
-  return reads.map((read) => configReadEffect(read, where));
+  return reads.map((read) => configReadEffect(read, where, resolution));
 }
 function envVarRecognizer(opts = {}) {
   return (access, ctx) => recognizeProcessEnvRead(
@@ -561,6 +542,7 @@ function envVarRecognizer(opts = {}) {
   );
 }
 var FILE_LOCATION_GLOBALS = /* @__PURE__ */ new Set(["__dirname", "__filename"]);
+var ENVIRONMENT_PROPERTY = "env";
 var importMetaRecognizer = (access, _ctx) => {
   const node = access;
   if (!Node.isPropertyAccessExpression(node)) {
@@ -574,6 +556,9 @@ var importMetaRecognizer = (access, _ctx) => {
   if (keyword === void 0 || inner.getNameNode().getText() !== "meta") {
     return null;
   }
+  if (node.getName() === ENVIRONMENT_PROPERTY) {
+    return null;
+  }
   return [opaqueRuntimeRead(node.getText())];
 };
 var fileLocationRecognizer = (access, _ctx) => {
@@ -868,14 +853,13 @@ var streamWriteRecognizer = (call, ctx) => {
     type: "interaction",
     binding: ioBinding({ recognition: RECOGNITION2, target }),
     callee: callee.getText(),
-    groupId: callSiteId(written),
     interaction: {
       class: "stream-write",
       payload: payload.shape,
       serialized: payload.serialized
     }
   };
-  return [effect];
+  return [{ ...effect, groupId: callSiteKey(effect) }];
 };
 function targetOf(receiver, method, resolution) {
   const consoleStream = Object.hasOwn(CONSOLE_STREAMS, method) ? CONSOLE_STREAMS[method] : void 0;
@@ -904,11 +888,7 @@ function viaParameter(receiver, annotations, resolution) {
 function streamName(path) {
   return path.slice(path.lastIndexOf(".") + 1);
 }
-function callSiteId(call) {
-  const { line, column } = call.getSourceFile().getLineAndColumnAtPos(call.getStart());
-  return `${line}:${column}`;
-}
-var PACK_VERSION = "0.3.0";
+var PACK_VERSION = "0.4.0";
 var optionsSchema = z.object({
   /**
    * The kind of deployment that runtime-config reads such as
@@ -955,7 +935,7 @@ function nodeRuntimePack(options = {}) {
     argumentParsers: PARSE_ARGS,
     inputMapping: { type: "positionalParams", params: [] },
     invocationRecognizers: [schedulingRecognizer, streamWriteRecognizer],
-    environmentObjects: ["process.env"],
+    environmentObjects: [...ENVIRONMENT_OBJECTS],
     streamObjects: PROCESS_STREAMS,
     accessRecognizers: [
       // envRecognizer handles `process.env.X` and processRecognizer skips
@@ -973,7 +953,7 @@ var declares = {
   package: "@suss/runtime-node",
   dependencies: [],
   shippedWith: "typescript",
-  reads: "Node.js runtime primitives, scheduling and the `process` surface, each recorded as an interaction effect. A `process.env.X` read, or a key of a schema parsed against `process.env`, becomes a config-read interaction. A module-loading global becomes a metadata-read interaction. A `console` call or a write to `process.stdout` or `process.stderr` becomes a stream-write interaction on the stream it goes to."
+  reads: "Node.js runtime primitives, scheduling and the `process` surface, each recorded as an interaction effect. A `process.env.X` or `import.meta.env.X` read, or a key of a schema parsed against either, becomes a config-read interaction. A module-loading global becomes a metadata-read interaction. A `console` call or a write to `process.stdout` or `process.stderr` becomes a stream-write interaction on the stream it goes to."
 };
 var index_default = nodeRuntimePack;
 export {

package/dist/prisma.js

@@ -150,6 +150,55 @@ function textOf(file) {
     return "";
   }
 }
+function generatedClientInputs(walked) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const dir of new Set(walked.map((file) => path3.dirname(file)))) {
+    const root = projectRootOf(dir);
+    if (root !== null) {
+      roots.add(root);
+    }
+  }
+  const inputs = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const project = readProjectAt(root);
+    for (const file of project?.readFrom.keys() ?? []) {
+      inputs.add(file);
+    }
+    for (const dir of [...project?.dirs ?? [], ...defaultClientDirs(root)]) {
+      for (const file of clientTypeFiles(dir)) {
+        inputs.add(file);
+      }
+    }
+  }
+  return [...inputs].sort();
+}
+function defaultClientDirs(root) {
+  for (let dir = root; ; dir = path3.dirname(dir)) {
+    const client = path3.join(dir, "node_modules", ".prisma", "client");
+    if (fs3.existsSync(client)) {
+      return [client];
+    }
+    if (path3.dirname(dir) === dir) {
+      return [];
+    }
+  }
+}
+var CLIENT_TYPE_FILE = /(\.d\.[cm]?ts|\.[cm]?ts|\.prisma|^package\.json)$/;
+function clientTypeFiles(dir) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    const file = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      return entry.name === "runtime" || entry.name === "node_modules" ? [] : clientTypeFiles(file);
+    }
+    return CLIENT_TYPE_FILE.test(entry.name) ? [file] : [];
+  });
+}
 function isInGeneratedClient(filePath) {
   return generatedClientDirs(path3.dirname(filePath)).some(
     (dir) => filePath.startsWith(`${dir}${path3.sep}`)
@@ -774,6 +823,7 @@ function prismaFramework(options = {}) {
     // `prisma-client` generator writes no schema beside it.
     generatedModuleMarkers: [GENERATED_CLIENT_MARKER],
     generatedModuleDirs: generatedClientDirs,
+    discoveryInputs: generatedClientInputs,
     invocationRecognizers: [makeRecognizer(options)],
     // A tagged template is not an invocation, so the raw chain runs on
     // the access walk, which visits calls as well.