@suss/packs 0.34.0 → 0.35.0

package/dist/prisma.js

@@ -6,7 +6,7 @@ import {
 } from "ts-morph";
 import { z } from "zod";
 import { receiverTypesOf, writtenNodeOf } from "@suss/adapter-typescript";
-import { storageBinding } from "@suss/behavioral-ir";
+import { storageBinding as storageBinding2 } from "@suss/behavioral-ir";
 import { scopeOption, storageSystemOption } from "@suss/extractor";
 import {
   compile,
@@ -14,10 +14,95 @@ import {
   declaredBy,
   sqlStatements
 } from "@suss/recognize";
+import fs3 from "fs";
+import path3 from "path";
+import { getSchema as getSchema2 } from "@mrleebo/prisma-ast";
+import { ts } from "ts-morph";
+
+// ../contract/prisma/dist/index.js
 import fs from "fs";
 import path from "path";
 import { getSchema } from "@mrleebo/prisma-ast";
-import { ts } from "ts-morph";
+import { storageBinding } from "@suss/behavioral-ir";
+import { defaultProjectRoot, pathInProject } from "@suss/behavioral-ir/files";
+var PROVIDER_TO_SYSTEM = {
+  postgresql: "postgresql",
+  postgres: "postgresql",
+  mysql: "mysql",
+  sqlite: "sqlite"
+};
+function prismaSchemaFiles(schemaPath) {
+  const stat = statOf(schemaPath);
+  if (stat?.isDirectory() === true) {
+    return prismaFilesIn(schemaPath, true);
+  }
+  if (stat?.isFile() !== true) {
+    return [];
+  }
+  const beside = prismaFilesIn(path.dirname(schemaPath), false).flatMap(
+    (file) => {
+      const list = schemaListOf(file);
+      return list === null ? [] : [{ file, list }];
+    }
+  );
+  const datasources = beside.filter(
+    ({ list }) => list.some(isDatasource)
+  ).length;
+  const given = path.resolve(schemaPath);
+  return datasources === 1 && beside.some(({ file }) => path.resolve(file) === given) ? beside.map(({ file }) => file) : [schemaPath];
+}
+function statOf(file) {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+}
+function prismaFilesIn(dir, below) {
+  return fs.readdirSync(dir, { recursive: below, encoding: "utf8" }).filter((name) => name.endsWith(".prisma")).map((name) => path.join(dir, name)).filter((file) => statOf(file)?.isFile() === true).sort();
+}
+function schemaListOf(file) {
+  try {
+    return getSchema(fs.readFileSync(file, "utf8")).list;
+  } catch {
+    return null;
+  }
+}
+function isDatasource(node) {
+  return node.type === "datasource";
+}
+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",
@@ -25,43 +110,61 @@ var CONFIG_FILES = [
   "prisma.config.js",
   "prisma.config.mjs",
   "prisma.config.cjs",
-  path.join(".config", "prisma.ts")
+  path3.join(".config", "prisma.ts")
 ];
-var DEFAULT_SCHEMAS = [path.join("prisma", "schema.prisma"), "schema.prisma"];
+var DEFAULT_SCHEMAS = [path3.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 [];
+    return null;
   }
   const known = readProjects.get(root);
   if (known !== void 0 && unchanged(known.readFrom)) {
-    return known.dirs;
+    return known;
   }
   const schemaFiles = schemaFilesOf(root);
   const readFrom = /* @__PURE__ */ new Map();
   for (const file of [...projectFilesOf(root), ...schemaFiles]) {
     readFrom.set(file, changedAt(file));
   }
-  const dirs = schemaFiles.flatMap(outputDirsIn);
-  readProjects.set(root, { dirs, readFrom });
-  return dirs;
+  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 fs3.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
 }
 function isInGeneratedClient(filePath) {
-  return generatedClientDirs(path.dirname(filePath)).some(
-    (dir) => filePath.startsWith(`${dir}${path.sep}`)
+  return generatedClientDirs(path3.dirname(filePath)).some(
+    (dir) => filePath.startsWith(`${dir}${path3.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))
+    path3.join(root, "package.json"),
+    ...CONFIG_FILES.map((name) => path3.join(root, name)),
+    ...DEFAULT_SCHEMAS.map((name) => path3.join(root, name))
   ];
 }
 function changedAt(file) {
   try {
-    return fs.statSync(file).mtimeMs;
+    return fs3.statSync(file).mtimeMs;
   } catch {
     return -1;
   }
@@ -85,12 +188,12 @@ function projectRootOf(fromDir) {
   return root;
 }
 function findProjectRoot(fromDir) {
-  let dir = path.resolve(fromDir);
+  let dir = path3.resolve(fromDir);
   while (true) {
-    if (fs.existsSync(path.join(dir, "package.json")) || configFileIn(dir) !== null) {
+    if (fs3.existsSync(path3.join(dir, "package.json")) || configFileIn(dir) !== null) {
       return dir;
     }
-    const parent = path.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -99,41 +202,31 @@ function findProjectRoot(fromDir) {
 }
 function configFileIn(dir) {
   for (const name of CONFIG_FILES) {
-    const candidate = path.join(dir, name);
-    if (fs.existsSync(candidate)) {
+    const candidate = path3.join(dir, name);
+    if (fs3.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function schemaFilesOf(root) {
-  const stated = [configuredSchema(root), packageJsonSchema(root)];
+  const manifest = manifestOf(root);
+  const stated = [
+    configuredSchema(root),
+    packageJsonSchema(root, manifest),
+    generateScriptSchema(root, manifest)
+  ];
   for (const schema of [
     ...stated.filter((one) => one !== null),
-    ...DEFAULT_SCHEMAS.map((name) => path.join(root, name))
+    ...DEFAULT_SCHEMAS.map((name) => path3.join(root, name))
   ]) {
-    const files = prismaFilesAt(schema);
+    const files = prismaSchemaFiles(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) {
@@ -141,7 +234,7 @@ function configuredSchema(root) {
   }
   const source = ts.createSourceFile(
     config,
-    fs.readFileSync(config, "utf8"),
+    fs3.readFileSync(config, "utf8"),
     ts.ScriptTarget.Latest
   );
   let found = null;
@@ -156,25 +249,36 @@ function configuredSchema(root) {
     ts.forEachChild(node, visit);
   };
   visit(source);
-  return found === null ? null : path.resolve(root, found);
+  return found === null ? null : path3.resolve(root, found);
 }
-function packageJsonSchema(root) {
-  const file = path.join(root, "package.json");
-  if (!fs.existsSync(file)) {
-    return null;
-  }
+function manifestOf(root) {
   try {
-    const manifest = JSON.parse(fs.readFileSync(file, "utf8"));
-    const schema = manifest.prisma?.schema;
-    return typeof schema === "string" ? path.resolve(root, schema) : null;
+    return JSON.parse(
+      fs3.readFileSync(path3.join(root, "package.json"), "utf8")
+    );
   } catch {
     return null;
   }
 }
-function outputDirsIn(schemaFile) {
+function packageJsonSchema(root, manifest) {
+  const schema = manifest?.prisma?.schema;
+  return typeof schema === "string" ? path3.resolve(root, schema) : null;
+}
+var GENERATE_SCHEMA_FLAG = /\bprisma\s+generate\b[^&|;]*?--schema(?:=|\s+)(["']?)([^\s"'&|;]+)\1/;
+function generateScriptSchema(root, manifest) {
+  for (const script of Object.values(manifest?.scripts ?? {})) {
+    const match = typeof script === "string" ? GENERATE_SCHEMA_FLAG.exec(script) : null;
+    if (match?.[2] !== void 0) {
+      return path3.resolve(root, match[2]);
+    }
+  }
+  return null;
+}
+function outputDirsIn(schema) {
+  const schemaFile = schema.file;
   let list;
   try {
-    list = getSchema(fs.readFileSync(schemaFile, "utf8")).list;
+    list = getSchema2(schema.text).list;
   } catch {
     return [];
   }
@@ -182,7 +286,7 @@ function outputDirsIn(schemaFile) {
   for (const block of list) {
     const output = generatorOutput(block);
     if (output !== null) {
-      dirs.push(path.resolve(path.dirname(schemaFile), output));
+      dirs.push(path3.resolve(path3.dirname(schemaFile), output));
     }
   }
   return dirs;
@@ -219,9 +323,9 @@ var PRISMA_WRITE_METHODS = /* @__PURE__ */ new Set([
 ]);
 var optionsSchema = z.object({
   /**
-   * The storage system the calls target, `"postgresql"` when unset. It
-   * has to match the `storageSystem` on the schema reader's summaries,
-   * or the calls do not pair.
+   * 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(),
   /**
@@ -231,10 +335,18 @@ var optionsSchema = z.object({
   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;
@@ -266,7 +378,7 @@ 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,
@@ -352,7 +464,7 @@ function nestedReads(optionsArg) {
   collectRelations(optionsArg, [], found);
   return found;
 }
-function collectRelations(shape, path3, found) {
+function collectRelations(shape, path32, found) {
   const select = readObjectArg(shape.fields.select);
   if (select !== null) {
     for (const [name, value] of Object.entries(select.fields)) {
@@ -360,7 +472,7 @@ function collectRelations(shape, path3, found) {
       if (nested === null) {
         continue;
       }
-      recordRelation(name, nested, path3, found);
+      recordRelation(name, nested, path32, found);
     }
   }
   const include = readObjectArg(shape.fields.include);
@@ -370,14 +482,14 @@ function collectRelations(shape, path3, found) {
   for (const [name, value] of Object.entries(include.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
-      found.push({ relationPath: [...path3, name], fields: ["*"] });
+      found.push({ relationPath: [...path32, name], fields: ["*"] });
       continue;
     }
-    recordRelation(name, nested, path3, found);
+    recordRelation(name, nested, path32, found);
   }
 }
-function recordRelation(name, nested, path3, found) {
-  const relationPath = [...path3, name];
+function recordRelation(name, nested, path32, found) {
+  const relationPath = [...path32, name];
   found.push({ relationPath, fields: extractFields(nested, "read") });
   collectRelations(nested, relationPath, found);
 }
@@ -431,13 +543,13 @@ function nestedWrites(optionsArg) {
   }
   return found;
 }
-function collectNestedWrites(row, path3, found) {
+function collectNestedWrites(row, path32, found) {
   for (const [field, value] of Object.entries(row.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
       continue;
     }
-    const relationPath = [...path3, field];
+    const relationPath = [...path32, field];
     for (const [operation, payload] of Object.entries(nested.fields)) {
       const does = NESTED_OPERATIONS.get(operation);
       if (does === void 0) {
@@ -614,8 +726,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,
@@ -628,8 +739,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",
@@ -648,7 +777,7 @@ function prismaFramework(options = {}) {
     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])
   };
 }