@suss/packs 0.33.1 → 0.34.1

package/dist/prisma.js

@@ -1,11 +1,12 @@
 // ../framework/prisma/dist/index.js
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import {
   Node as N
 } from "ts-morph";
 import { z } from "zod";
-import { storageBinding } from "@suss/behavioral-ir";
+import { receiverTypesOf, writtenNodeOf } from "@suss/adapter-typescript";
+import { storageBinding as storageBinding2 } from "@suss/behavioral-ir";
 import { scopeOption, storageSystemOption } from "@suss/extractor";
 import {
   compile,
@@ -13,6 +14,252 @@ import {
   declaredBy,
   sqlStatements
 } from "@suss/recognize";
+import fs from "fs";
+import path from "path";
+import { getSchema as getSchema2 } from "@mrleebo/prisma-ast";
+import { ts } from "ts-morph";
+
+// ../contract/prisma/dist/index.js
+import { getSchema } from "@mrleebo/prisma-ast";
+import { storageBinding } from "@suss/behavioral-ir";
+var PROVIDER_TO_SYSTEM = {
+  postgresql: "postgresql",
+  postgres: "postgresql",
+  mysql: "mysql",
+  sqlite: "sqlite"
+};
+function prismaStorageSystem(source) {
+  try {
+    return storageSystemIn(getSchema(source).list);
+  } catch {
+    return null;
+  }
+}
+function storageSystemIn(list) {
+  for (const node of list) {
+    if (node.type !== "datasource") {
+      continue;
+    }
+    const provider = readProviderString(node);
+    if (provider !== null && provider in PROVIDER_TO_SYSTEM) {
+      return PROVIDER_TO_SYSTEM[provider];
+    }
+  }
+  return null;
+}
+function readProviderString(ds) {
+  for (const a of ds.assignments) {
+    if (a.key !== "provider") {
+      continue;
+    }
+    if (typeof a.value === "string") {
+      return a.value.replace(/^"|"$/g, "");
+    }
+  }
+  return null;
+}
+
+// ../framework/prisma/dist/index.js
+var CONFIG_FILES = [
+  "prisma.config.ts",
+  "prisma.config.mts",
+  "prisma.config.cts",
+  "prisma.config.js",
+  "prisma.config.mjs",
+  "prisma.config.cjs",
+  path.join(".config", "prisma.ts")
+];
+var DEFAULT_SCHEMAS = [path.join("prisma", "schema.prisma"), "schema.prisma"];
+var readProjects = /* @__PURE__ */ new Map();
+function generatedClientDirs(fromDir) {
+  return readProjectAt(fromDir)?.dirs ?? [];
+}
+function schemaStorageSystem(fromDir) {
+  return readProjectAt(fromDir)?.storageSystem ?? null;
+}
+function readProjectAt(fromDir) {
+  const root = projectRootOf(fromDir);
+  if (root === null) {
+    return null;
+  }
+  const known = readProjects.get(root);
+  if (known !== void 0 && unchanged(known.readFrom)) {
+    return known;
+  }
+  const schemaFiles = schemaFilesOf(root);
+  const readFrom = /* @__PURE__ */ new Map();
+  for (const file of [...projectFilesOf(root), ...schemaFiles]) {
+    readFrom.set(file, changedAt(file));
+  }
+  const sources = schemaFiles.map((file) => ({ file, text: textOf(file) }));
+  const project = {
+    dirs: sources.flatMap(outputDirsIn),
+    storageSystem: sources.map(({ text }) => prismaStorageSystem(text)).find((system) => system !== null) ?? null,
+    readFrom
+  };
+  readProjects.set(root, project);
+  return project;
+}
+function textOf(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function isInGeneratedClient(filePath) {
+  return generatedClientDirs(path.dirname(filePath)).some(
+    (dir) => filePath.startsWith(`${dir}${path.sep}`)
+  );
+}
+function projectFilesOf(root) {
+  return [
+    path.join(root, "package.json"),
+    ...CONFIG_FILES.map((name) => path.join(root, name)),
+    ...DEFAULT_SCHEMAS.map((name) => path.join(root, name))
+  ];
+}
+function changedAt(file) {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+function unchanged(readFrom) {
+  for (const [file, at] of readFrom) {
+    if (changedAt(file) !== at) {
+      return false;
+    }
+  }
+  return true;
+}
+var rootsByDir = /* @__PURE__ */ new Map();
+function projectRootOf(fromDir) {
+  const known = rootsByDir.get(fromDir);
+  if (known !== void 0) {
+    return known;
+  }
+  const root = findProjectRoot(fromDir);
+  rootsByDir.set(fromDir, root);
+  return root;
+}
+function findProjectRoot(fromDir) {
+  let dir = path.resolve(fromDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, "package.json")) || configFileIn(dir) !== null) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function configFileIn(dir) {
+  for (const name of CONFIG_FILES) {
+    const candidate = path.join(dir, name);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function schemaFilesOf(root) {
+  const stated = [configuredSchema(root), packageJsonSchema(root)];
+  for (const schema of [
+    ...stated.filter((one) => one !== null),
+    ...DEFAULT_SCHEMAS.map((name) => path.join(root, name))
+  ]) {
+    const files = prismaFilesAt(schema);
+    if (files.length > 0) {
+      return files;
+    }
+  }
+  return [];
+}
+function prismaFilesAt(schemaPath) {
+  let stat;
+  try {
+    stat = fs.statSync(schemaPath);
+  } catch {
+    return [];
+  }
+  if (stat.isFile()) {
+    return [schemaPath];
+  }
+  if (!stat.isDirectory()) {
+    return [];
+  }
+  return fs.readdirSync(schemaPath, { recursive: true, encoding: "utf8" }).filter((name) => name.endsWith(".prisma")).map((name) => path.join(schemaPath, name)).sort();
+}
+function configuredSchema(root) {
+  const config = configFileIn(root);
+  if (config === null) {
+    return null;
+  }
+  const source = ts.createSourceFile(
+    config,
+    fs.readFileSync(config, "utf8"),
+    ts.ScriptTarget.Latest
+  );
+  let found = null;
+  const visit = (node) => {
+    if (found !== null) {
+      return;
+    }
+    if (ts.isPropertyAssignment(node) && node.name.getText(source) === "schema" && ts.isStringLiteralLike(node.initializer)) {
+      found = node.initializer.text;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return found === null ? null : path.resolve(root, found);
+}
+function packageJsonSchema(root) {
+  const file = path.join(root, "package.json");
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  try {
+    const manifest = JSON.parse(fs.readFileSync(file, "utf8"));
+    const schema = manifest.prisma?.schema;
+    return typeof schema === "string" ? path.resolve(root, schema) : null;
+  } catch {
+    return null;
+  }
+}
+function outputDirsIn(schema) {
+  const schemaFile = schema.file;
+  let list;
+  try {
+    list = getSchema2(schema.text).list;
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const block of list) {
+    const output = generatorOutput(block);
+    if (output !== null) {
+      dirs.push(path.resolve(path.dirname(schemaFile), output));
+    }
+  }
+  return dirs;
+}
+function generatorOutput(block) {
+  const generator = block;
+  if (generator.type !== "generator") {
+    return null;
+  }
+  for (const assignment of generator.assignments ?? []) {
+    if (assignment.type === "assignment" && assignment.key === "output" && typeof assignment.value === "string") {
+      return assignment.value.replace(/^"|"$/g, "");
+    }
+  }
+  return null;
+}
 var PRISMA_READ_METHODS = /* @__PURE__ */ new Set([
   "findUnique",
   "findFirst",
@@ -33,23 +280,30 @@ var PRISMA_WRITE_METHODS = /* @__PURE__ */ new Set([
 ]);
 var optionsSchema = z.object({
   /**
-   * Storage system the recognized calls target. Must match the
-   * `storageSystem` on schema-reader provider summaries; otherwise
-   * pairing keys won't match. Defaults to `"postgresql"` since that's
-   * the dominant Prisma deployment.
+   * The storage system the calls target. When unset, the project
+   * schema's datasource decides, then `"postgresql"`. The README says
+   * why it has to match the schema reader's summaries.
    */
   storageSystem: storageSystemOption.optional(),
   /**
-   * Scope label that must match the schema reader's scope. Defaults
-   * to `"default"` to align with `prismaSchemaToSummaries`'s default.
+   * Has to match the schema reader's scope. It is `"default"` when
+   * unset, the same default `prismaSchemaToSummaries` uses.
    */
   scope: scopeOption.optional()
 }).strict();
 function makeRecognizer(opts) {
-  const storageSystem = opts.storageSystem ?? "postgresql";
   const scope = opts.scope ?? "default";
-  return (call, ctx) => recognizePrismaCall(call, ctx, storageSystem, scope);
+  return (call, ctx) => recognizePrismaCall(
+    call,
+    ctx,
+    storageSystemFor(opts, call.getSourceFile()),
+    scope
+  );
+}
+function storageSystemFor(opts, file) {
+  return opts.storageSystem ?? schemaStorageSystem(path2.dirname(file.getFilePath())) ?? DEFAULT_STORAGE_SYSTEM;
 }
+var DEFAULT_STORAGE_SYSTEM = "postgresql";
 function recognizePrismaCall(call, ctx, storageSystem, scope) {
   const callNode = call;
   const recognizerCtx = ctx;
@@ -68,7 +322,7 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
     return null;
   }
   const receiverExpr = delegateExpr.getExpression();
-  if (!isPrismaClientReceiver(receiverExpr)) {
+  if (!isPrismaClientReceiver(receiverExpr, recognizerCtx.resolution)) {
     return null;
   }
   const delegateName = delegateExpr.getName();
@@ -81,26 +335,31 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
   const optionsArg = readObjectArg(argsShape[0]);
   const fields = extractFields(optionsArg, kind);
   const selector = extractSelector(optionsArg);
-  const binding = storageBinding({
+  const binding = storageBinding2({
     recognition: "@suss/framework-prisma",
     storageSystem,
     scope,
     container: tableName
   });
   const callee = callNode.getExpression().getText();
+  const access = {
+    type: "interaction",
+    binding,
+    callee,
+    interaction: {
+      class: "storage-access",
+      kind,
+      fields,
+      ...selector !== null ? { selector } : {},
+      operation: method
+    }
+  };
+  statePayloadSlots(recognizerCtx.ops, access, {
+    fields: kind === "write" ? fields : [],
+    selector: selector ?? []
+  });
   return [
-    {
-      type: "interaction",
-      binding,
-      callee,
-      interaction: {
-        class: "storage-access",
-        kind,
-        fields,
-        ...selector !== null ? { selector } : {},
-        operation: method
-      }
-    },
+    access,
     ...nestedReads(optionsArg).map(
       (nested) => ({
         type: "interaction",
@@ -126,15 +385,34 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
           fields: nested.fields,
           relationPath: nested.relationPath,
           ...nested.relationKey === true ? { relationKey: true } : {},
-          // What reaches the other model is the nested operation, so
-          // that is what the effect records. The outer method belongs
-          // to the model in the binding.
+          // The outer method acts on the model in the binding. The model
+          // across the relation gets the nested operation.
           operation: nested.operation
         }
       })
     )
   ];
 }
+function statePayloadSlots(ops, effect, columns) {
+  const options = ops?.statesSlots === void 0 ? null : ops.valueAt(0);
+  if (ops === void 0 || options === null) {
+    return;
+  }
+  const slots = [
+    ...slotsUnder(options, ["where"], "selector", columns.selector),
+    ...slotsUnder(options, WRITE_PAYLOAD_KEYS, "field", columns.fields)
+  ];
+  if (slots.length > 0) {
+    ops.statesSlots?.(effect, slots);
+  }
+}
+function slotsUnder(options, keys, slot, columns) {
+  return keys.flatMap(
+    (key) => (options.property(key)?.entries("nothing") ?? []).flatMap(
+      (entry) => entry.key !== null && columns.includes(entry.key) ? [{ slot, name: entry.key, value: entry.value }] : []
+    )
+  );
+}
 function nestedReads(optionsArg) {
   if (optionsArg === null) {
     return [];
@@ -143,7 +421,7 @@ function nestedReads(optionsArg) {
   collectRelations(optionsArg, [], found);
   return found;
 }
-function collectRelations(shape, path2, found) {
+function collectRelations(shape, path3, found) {
   const select = readObjectArg(shape.fields.select);
   if (select !== null) {
     for (const [name, value] of Object.entries(select.fields)) {
@@ -151,7 +429,7 @@ function collectRelations(shape, path2, found) {
       if (nested === null) {
         continue;
       }
-      recordRelation(name, nested, path2, found);
+      recordRelation(name, nested, path3, found);
     }
   }
   const include = readObjectArg(shape.fields.include);
@@ -161,14 +439,14 @@ function collectRelations(shape, path2, found) {
   for (const [name, value] of Object.entries(include.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
-      found.push({ relationPath: [...path2, name], fields: ["*"] });
+      found.push({ relationPath: [...path3, name], fields: ["*"] });
       continue;
     }
-    recordRelation(name, nested, path2, found);
+    recordRelation(name, nested, path3, found);
   }
 }
-function recordRelation(name, nested, path2, found) {
-  const relationPath = [...path2, name];
+function recordRelation(name, nested, path3, found) {
+  const relationPath = [...path3, name];
   found.push({ relationPath, fields: extractFields(nested, "read") });
   collectRelations(nested, relationPath, found);
 }
@@ -222,13 +500,13 @@ function nestedWrites(optionsArg) {
   }
   return found;
 }
-function collectNestedWrites(row, path2, found) {
+function collectNestedWrites(row, path3, found) {
   for (const [field, value] of Object.entries(row.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
       continue;
     }
-    const relationPath = [...path2, field];
+    const relationPath = [...path3, field];
     for (const [operation, payload] of Object.entries(nested.fields)) {
       const does = NESTED_OPERATIONS.get(operation);
       if (does === void 0) {
@@ -279,29 +557,51 @@ function fieldsOfRows(read) {
   }
   return out.size === 0 ? ["*"] : [...out];
 }
-function isPrismaClientReceiver(node) {
-  return extendsPrismaClient(node.getType(), /* @__PURE__ */ new Set());
+function isPrismaClientReceiver(node, resolution) {
+  if (receiverTypesOf(node).some(
+    (type) => declaredByPrisma(type) || extendsImportedClient(type, resolution)
+  )) {
+    return true;
+  }
+  return node.getType().isAny() && madeFromImportedClient(node, resolution);
 }
-function extendsPrismaClient(type, seen) {
-  if (seen.has(type)) {
+function madeFromImportedClient(node, resolution) {
+  if (resolution === void 0) {
     return false;
   }
-  seen.add(type);
-  const declarations = type.getSymbol()?.getDeclarations() ?? [];
-  if (declarations.some(
-    (declaration) => isPrismaClientPath(declaration.getSourceFile().getFilePath())
-  )) {
+  if (importedAsClient(node, resolution)) {
     return true;
   }
-  return type.getBaseTypes().some((base) => extendsPrismaClient(base, seen));
+  const written = writtenNodeOf(node, resolution);
+  return written !== null && written !== node && importedAsClient(written, resolution);
+}
+function importedAsClient(value, resolution) {
+  return resolution.importOriginsOf(value, clientModulesFor(value)).some((origin) => origin.path.join(".") === CLIENT_CLASS);
+}
+function clientModulesFor(value) {
+  return [
+    CLIENT_MODULE,
+    ...generatedClientDirs(path2.dirname(value.getSourceFile().getFilePath()))
+  ];
+}
+function declaredByPrisma(type) {
+  return type.declaredIn.some((filePath) => isPrismaClientPath(filePath));
+}
+var CLIENT_MODULE = "@prisma/client";
+var CLIENT_CLASS = "PrismaClient";
+function extendsImportedClient(type, resolution) {
+  if (resolution === void 0) {
+    return false;
+  }
+  return type.extendsWritten.some((base) => importedAsClient(base, resolution));
 }
 var GENERATED_CLIENT_MARKER = "schema.prisma";
 function isPrismaClientPath(filePath) {
   if (filePath.includes("/@prisma/client/") || filePath.includes("/.prisma/client/")) {
     return true;
   }
-  const beside = path.join(path.dirname(filePath), GENERATED_CLIENT_MARKER);
-  return fs.existsSync(beside);
+  const beside = path2.join(path2.dirname(filePath), GENERATED_CLIENT_MARKER);
+  return fs2.existsSync(beside) || isInGeneratedClient(filePath);
 }
 function capitalizeFirst(name) {
   if (name.length === 0) {
@@ -383,8 +683,7 @@ function extractSelector(optionsArg) {
   return keys.length > 0 ? keys : null;
 }
 var STATEMENT = { statement: { at: 0 } };
-function rawStatements(options) {
-  const provider = options.storageSystem ?? "postgresql";
+function rawStatements(options, provider) {
   return sqlStatements({
     system: provider,
     dialect: provider,
@@ -397,8 +696,26 @@ function rawStatements(options) {
     $executeRawUnsafe: STATEMENT
   }).example('prisma.$queryRawUnsafe("SELECT id, email FROM users")');
 }
+function rawRecognizer(options) {
+  const bySystem = /* @__PURE__ */ new Map();
+  return (call, ctx) => {
+    const system = storageSystemFor(options, call.getSourceFile());
+    let recognizer = bySystem.get(system);
+    if (recognizer === void 0) {
+      recognizer = compile(
+        rawStatements(options, system).declared,
+        "@suss/framework-prisma"
+      );
+      bySystem.set(system, recognizer);
+    }
+    return recognizer(call, ctx);
+  };
+}
 function prismaFramework(options = {}) {
-  const raw = rawStatements(options);
+  const raw = rawStatements(
+    options,
+    options.storageSystem ?? DEFAULT_STORAGE_SYSTEM
+  );
   return {
     name: "prisma",
     protocol: "in-process",
@@ -406,16 +723,18 @@ function prismaFramework(options = {}) {
     discovery: [],
     terminals: [],
     inputMapping: { type: "positionalParams", params: [] },
-    // Skip files that don't import from @prisma/client: the
-    // recognizer's type-resolution check would reject them anyway.
+    // The type check would reject every call in a file that does not
+    // import `@prisma/client`, so those files are skipped.
     requiresImport: ["@prisma/client"],
     // A generator with its own `output` puts the client in the project,
-    // where the only way to reach it is a relative path.
+    // where the only way to reach it is a relative path. Prisma 7's
+    // `prisma-client` generator writes no schema beside it.
     generatedModuleMarkers: [GENERATED_CLIENT_MARKER],
+    generatedModuleDirs: generatedClientDirs,
     invocationRecognizers: [makeRecognizer(options)],
     // A tagged template is not an invocation, so the raw chain runs on
     // the access walk, which visits calls as well.
-    accessRecognizers: [compile(raw.declared, "@suss/framework-prisma")],
+    accessRecognizers: [rawRecognizer(options)],
     declarations: declarationsIn([raw])
   };
 }
@@ -423,7 +742,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-prisma",
   dependencies: [{ ecosystem: "npm", name: "@prisma/client" }],
-  reads: "Prisma client calls, emits storage-access interactions per read / write."
+  reads: "Prisma client calls. Each read and each write becomes a storage-access interaction."
 };
 var index_default = prismaFramework;
 export {

package/dist/pytest.d.ts

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

package/dist/pytest.js

@@ -0,0 +1,81 @@
+// ../framework/pytest/dist/index.js
+import path from "path";
+import { z } from "zod";
+var optionsSchema = z.object({
+  /**
+   * The test files to read, matched on whole path segments from the
+   * end. `suss extract --intent` fills it in from the tests the PRDs
+   * list, so a run reads those files and no others. Left out, every
+   * file pytest would collect is read.
+   */
+  files: z.array(z.string().min(1)).optional()
+}).strict();
+var SHARED_FIXTURE_FILE = "conftest.py";
+function pytestFramework(options = {}) {
+  return {
+    name: "pytest",
+    protocol: "in-process",
+    discovery: [],
+    // A test's fixtures can come from a conftest.py in any directory
+    // above it, so an edit to one has to re-read the tests below it.
+    discoveryInputs: (files) => files.filter((file) => path.basename(file) === SHARED_FIXTURE_FILE),
+    tests: [
+      {
+        filePatterns: ["test_*.py", "*_test.py"],
+        functionPrefix: "test",
+        classPrefix: "Test",
+        caseBaseClasses: [
+          "unittest.TestCase",
+          "unittest.IsolatedAsyncioTestCase"
+        ],
+        setUp: {
+          module: ["setup_module"],
+          function: ["setup_function"],
+          testClass: ["setup_class", "setup_method"],
+          caseClass: ["setUpClass", "setUp", "asyncSetUp"]
+        },
+        usesFixtureMarkers: ["pytest.mark.usefixtures"],
+        fixtureDecorators: ["pytest.fixture"],
+        fixtureNameKeyword: "name",
+        autouseKeyword: "autouse",
+        sharedFixtureFiles: [SHARED_FIXTURE_FILE],
+        skipDecorators: [
+          "pytest.mark.skip",
+          "pytest.mark.skipif",
+          "pytest.mark.xfail",
+          "unittest.skip",
+          "unittest.skipIf",
+          "unittest.skipUnless",
+          "unittest.expectedFailure"
+        ],
+        markerVariable: "pytestmark",
+        reservedParameters: ["self", "cls", "request"],
+        mocks: {
+          patchers: [
+            "unittest.mock.patch",
+            "unittest.mock.patch.object",
+            "mock.patch",
+            "mock.patch.object"
+          ],
+          fixturePatchers: [
+            { fixture: "mocker", methods: ["patch", "patch.object"] },
+            { fixture: "monkeypatch", methods: ["setattr"] }
+          ]
+        },
+        ...options.files !== void 0 ? { files: options.files } : {}
+      }
+    ]
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-pytest",
+  dependencies: [],
+  reads: "pytest tests (Python), named by their node ids, so a PRD scenario can say which test covers it."
+};
+var index_default = pytestFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};