Support for Prisma 7

[nameer]

Overview

Prisma 7 is released with added features. Is there a plan to support prisma 7?

[laimonassutkus]

UP!

[div-cowboy]

Problem

When upgrading to Prisma 7 with a custom output path, @shopify/shopify-app-session-storage-prisma fails because it expects PrismaClient at the default location (@prisma/client), but Prisma 7 generates the client at your custom path.

Error you might see:

Cannot find module '@prisma/client' or its corresponding type declarations

Solution

Create symlinks from the default Prisma client location to your custom output directory. Here's how:

1. Configure Custom Output in Schema

// prisma/schema.prisma
generator client {
  provider = "prisma-client"
  output   = "./generated"  // Your custom output path
}

2. Update TypeScript Path Alias

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./*"]
    }
  }
}

3. Import from Custom Path in Your Code

// app/db.server.ts
import { PrismaClient } from "@/prisma/generated/client"; // Use your custom path

// ... rest of your setup
export default prisma;

4. Create Symlink Script

Create scripts/link-prisma-client.js:

#!/usr/bin/env node
import {
  existsSync,
  symlinkSync,
  unlinkSync,
  mkdirSync,
  readlinkSync,
  lstatSync,
  rmSync,
  readdirSync,
} from "fs";
import { dirname, resolve, relative } from "path";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const projectRoot = resolve(__dirname, "..");
const customClientPath = resolve(projectRoot, "prisma", "generated");

// Find @prisma/client/.prisma/client directory (works with npm/yarn/pnpm)
let prismaClientDotPrismaPath = null;
const directPath = resolve(
  projectRoot,
  "node_modules",
  "@prisma",
  "client",
  ".prisma",
  "client",
);

if (existsSync(directPath)) {
  prismaClientDotPrismaPath = directPath;
} else {
  // For pnpm, search in .pnpm directory
  const pnpmDir = resolve(projectRoot, "node_modules", ".pnpm");
  if (existsSync(pnpmDir)) {
    const entries = readdirSync(pnpmDir);
    for (const entry of entries) {
      if (entry.includes("@prisma+client")) {
        const candidatePath = resolve(
          pnpmDir,
          entry,
          "node_modules",
          ".prisma",
          "client",
        );
        if (existsSync(candidatePath)) {
          prismaClientDotPrismaPath = candidatePath;
          break;
        }
      }
    }
  }
}

if (!prismaClientDotPrismaPath) {
  console.warn("⚠ Could not find @prisma/client/.prisma/client directory");
  process.exit(0);
}

const defaultClientPath = resolve(prismaClientDotPrismaPath, "default");
const browserClientPath = resolve(prismaClientDotPrismaPath, "index-browser");

// Create symlinks
function createSymlink(symlinkPath, targetPath, description) {
  const parentDir = dirname(symlinkPath);
  if (!existsSync(parentDir)) {
    mkdirSync(parentDir, { recursive: true });
  }

  try {
    const stats = lstatSync(symlinkPath);
    if (stats.isSymbolicLink()) {
      const currentTarget = readlinkSync(symlinkPath);
      const resolvedCurrent = resolve(dirname(symlinkPath), currentTarget);
      const resolvedTarget = resolve(targetPath);
      if (
        resolvedCurrent.replace(/\/+$/, "") ===
        resolvedTarget.replace(/\/+$/, "")
      ) {
        console.log(`✓ Symlink already correct: ${description}`);
        return; // Already correct
      }
      unlinkSync(symlinkPath);
    } else {
      rmSync(symlinkPath, { recursive: true, force: true });
    }
  } catch (e) {
    // File doesn't exist, that's fine
  }

  const relativePath = relative(parentDir, targetPath);
  try {
    symlinkSync(relativePath, symlinkPath, "dir");
    console.log(`✓ Created symlink: ${description}`);
  } catch (error) {
    if (error.code === "EEXIST" && existsSync(symlinkPath)) {
      rmSync(symlinkPath, { recursive: true, force: true });
      symlinkSync(relativePath, symlinkPath, "dir");
      console.log(`✓ Created symlink: ${description}`);
    } else {
      throw error;
    }
  }
}

if (existsSync(customClientPath)) {
  createSymlink(defaultClientPath, customClientPath, "default");
  createSymlink(browserClientPath, customClientPath, "index-browser");
} else {
  console.warn(
    `⚠ Custom Prisma client not found at ${customClientPath}. Run 'prisma generate' first.`,
  );
}

5. Add to package.json Scripts

{
  "scripts": {
    "postinstall": "node scripts/link-prisma-client.js",
    "setup": "prisma generate && node scripts/link-prisma-client.js && prisma migrate deploy",
    "prisma:generate": "prisma generate && node scripts/link-prisma-client.js"
  }
}

6. (Optional) Patch for Edge Cases

If symlinks don't resolve correctly in some environments, create scripts/patch-prisma-client.js:

#!/usr/bin/env node
import { readFile, writeFile } from "fs/promises";
import { existsSync } from "fs";
import { join, dirname, resolve } from "path";
import { fileURLToPath } from "url";
import { glob } from "glob";

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const projectRoot = join(__dirname, "..");

async function patchPrismaClient() {
  const patterns = [
    join(projectRoot, "node_modules", "**", "@prisma", "client", "default.js"),
    join(
      projectRoot,
      "node_modules",
      "**",
      "@prisma",
      "client",
      "index-browser.js",
    ),
  ];
  const allFiles = await Promise.all(
    patterns.map((pattern) => glob(pattern, { absolute: true })),
  );
  const files = [...new Set(allFiles.flat())];

  for (const filePath of files) {
    const isBrowser = filePath.endsWith("index-browser.js");
    const symlinkName = isBrowser ? "index-browser" : "default";
    const targetFile = isBrowser ? "index-browser.js" : "index.js";

    const content = await readFile(filePath, "utf8");
    if (content.includes("PATCHED_FOR_PRISMA_7")) {
      continue; // Already patched
    }

    const patchedContent = `// PATCHED_FOR_PRISMA_7 - Custom output path support
const path = require('path');
const fs = require('fs');

const symlinkPath = path.join(__dirname, '.prisma/client/${symlinkName}');
let clientPath;
try {
  if (fs.existsSync(symlinkPath)) {
    const resolved = fs.realpathSync(symlinkPath);
    clientPath = path.join(resolved, '${targetFile}');
  } else {
    clientPath = path.join(process.cwd(), 'prisma/generated/${targetFile}');
  }
} catch (e) {
  clientPath = path.join(process.cwd(), 'prisma/generated/${targetFile}');
}

if (!fs.existsSync(clientPath)) {
  throw new Error('Cannot find Prisma client. Make sure to run: node scripts/link-prisma-client.js');
}

module.exports = require(clientPath);
`;

    await writeFile(filePath, patchedContent, "utf8");
  }
}

patchPrismaClient().catch(() => {
  // Silently fail - patching is optional
});

Then add to your generate script:

{
  "scripts": {
    "prisma:generate": "prisma generate && node scripts/link-prisma-client.js && node scripts/patch-prisma-client.js"
  }
}

How It Works

1. prisma generate creates the client at your custom path (prisma/generated/)
2. link-prisma-client.js creates symlinks from @prisma/client/.prisma/client/default → prisma/generated/
3. @shopify/shopify-app-session-storage-prisma finds PrismaClient at the expected default location via the symlink
4. Your application code imports from the custom path for type safety

Result

✅ Prisma 7 works with custom output paths
✅ Shopify session storage adapter works without modification
✅ Works across package managers (npm, yarn, pnpm)
✅ Automated via postinstall scripts

Additional Notes

• Type imports: You can continue importing types from @prisma/client (TypeScript resolves them), but for consistency, consider using @/prisma/generated/client for types as well.

• CommonJS wrappers: If you encounter issues with require() calls, you may need to create CommonJS wrapper files in your generated directory. The symlink approach above should work for most cases.

• Testing: After setup, verify it works:

  npm run prisma:generate
  # Then test your app - session storage should work

[towheduldev]

I copied
node_modules\@shopify\shopify-app-session-storage-prisma\dist\esm\prisma.mjs
and pasted it somewhere like
/app/shopify-app-session-storage-prisma.js

Then I went to package.json and replaced
"@shopify/shopify-app-session-storage-prisma": "^8.0.8"
with
"@shopify/shopify-app-session-storage": "^4.0.4",

After that I went to shopify.server.js and changed the import path for PrismaSessionStorage to
import { PrismaSessionStorage } from "./shopify-app-session-storage-prisma";

Finally, I went to the file I created (shopify-app-session-storage-prisma.js) and updated this:
import { Prisma } from '@prisma/client';
with
import { Prisma } from "../../prisma/generated/client"; // the path where I generated my prisma client

Now it works. I am not the smartest person here, but the package had MIT license and was small enough, so I thought it won't be a problem, as I do not have to worry about production now.