@suss/packs 0.34.0 → 0.34.1

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,
@@ -16,8 +16,50 @@ import {
 } from "@suss/recognize";
 import fs from "fs";
 import path from "path";
-import { getSchema } from "@mrleebo/prisma-ast";
+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",
@@ -30,22 +72,40 @@ var CONFIG_FILES = [
 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 [];
+    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 fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
 }
 function isInGeneratedClient(filePath) {
   return generatedClientDirs(path.dirname(filePath)).some(
@@ -171,10 +231,11 @@ function packageJsonSchema(root) {
     return null;
   }
 }
-function outputDirsIn(schemaFile) {
+function outputDirsIn(schema) {
+  const schemaFile = schema.file;
   let list;
   try {
-    list = getSchema(fs.readFileSync(schemaFile, "utf8")).list;
+    list = getSchema2(schema.text).list;
   } catch {
     return [];
   }
@@ -219,9 +280,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 +292,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 +335,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,
@@ -614,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,
@@ -628,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",
@@ -648,7 +734,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])
   };
 }