feat: add Prisma provider

.oxfmtrc.json

@@ -17,6 +17,8 @@
     "**/*.mdx",
     "**/*.md",
     "**/.vendor/**",
+    "examples/prisma-tanstack-start/src/prisma/contract.d.ts",
+    "examples/prisma-tanstack-start/src/prisma/contract.json",
     "**/package.json"
   ]
 }

examples/prisma-compute-effect/README.md

@@ -0,0 +1,49 @@
+# Prisma Compute Effect
+
+Minimal Effect-native Prisma Compute service managed by Alchemy.
+
+This example is intentionally not a framework app. It shows the provider-native
+runtime path:
+
+- `Prisma.Project`
+- `Prisma.Branch`
+- `Prisma.Postgres`
+- `Prisma.Connection`
+- `Prisma.Compute(..., Effect.gen(...))`
+- `Prisma.Connection.bind(Connection)` inside the deployed runtime
+
+The deployed service responds on `/` and `/api/health` with JSON showing the
+bound database and connection IDs.
+
+## Deploy
+
+```sh
+export PRISMA_SERVICE_TOKEN="..."
+bun run deploy
+```
+
+`PRISMA_API_TOKEN` also works.
+
+## Check It
+
+```sh
+curl "$URL/"
+curl "$URL/api/health"
+```
+
+The response should include:
+
+```json
+{
+  "ok": true,
+  "mode": "effect-native",
+  "hasDatabaseUrl": true
+}
+```
+
+## Destroy
+
+```sh
+export PRISMA_SERVICE_TOKEN="..."
+bun run destroy
+```

examples/prisma-compute-effect/alchemy.run.ts

@@ -0,0 +1,142 @@
+import * as Alchemy from "alchemy";
+import * as Prisma from "alchemy/Prisma";
+import * as Effect from "effect/Effect";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+
+const region = "eu-west-3";
+const port = 3000;
+
+const serviceName =
+  process.env.PRISMA_EFFECT_SERVICE ?? "alchemy-prisma-compute-effect";
+const projectName = process.env.PRISMA_PROJECT ?? `${serviceName}-project`;
+const message =
+  process.env.PRISMA_EFFECT_MESSAGE ??
+  "hello from Effect-native Prisma Compute";
+
+const runtimeEnv = (key: string, fallback: string) =>
+  Effect.sync(() => process.env[key] ?? fallback);
+
+export const Project = Prisma.Project("Project", {
+  name: projectName,
+  createDatabase: false,
+  region,
+});
+
+export const MainBranch = Prisma.Branch(
+  "MainBranch",
+  Effect.gen(function* () {
+    const project = yield* Project;
+    return {
+      project,
+      gitName: "main",
+      isDefault: true,
+    };
+  }),
+);
+
+export const Postgres = Prisma.Postgres(
+  "Postgres",
+  Effect.gen(function* () {
+    const project = yield* Project;
+    const branch = yield* MainBranch;
+    return {
+      project,
+      name: "main",
+      region,
+      branchId: branch.branchId,
+      isDefault: true,
+    };
+  }),
+);
+
+export const Connection = Prisma.Connection(
+  "Connection",
+  Effect.gen(function* () {
+    const postgres = yield* Postgres;
+    return {
+      database: postgres,
+      name: "api",
+    };
+  }),
+);
+
+export const Api = Prisma.Compute(
+  "Api",
+  Effect.gen(function* () {
+    const project = yield* Project;
+    const branch = yield* MainBranch;
+    return {
+      project,
+      serviceName,
+      regionId: region,
+      branchId: branch.branchId,
+      main: import.meta.filename,
+      handler: "Api" as const,
+      port,
+      env: {
+        PRISMA_EFFECT_MESSAGE: message,
+        PRISMA_PROJECT_ID: project.projectId,
+        PRISMA_BRANCH_ID: branch.branchId,
+      },
+      destroyOldVersion: true,
+    };
+  }),
+  Effect.gen(function* () {
+    const db = yield* Prisma.Connection.bind(Connection);
+
+    return {
+      fetch: Effect.gen(function* () {
+        const request = yield* HttpServerRequest;
+        const url = new URL(request.url, "http://localhost");
+
+        if (url.pathname !== "/" && url.pathname !== "/api/health") {
+          return HttpServerResponse.text("Not found", { status: 404 });
+        }
+
+        if (request.method !== "GET") {
+          return HttpServerResponse.text("Method not allowed", { status: 405 });
+        }
+
+        const databaseUrl = yield* db.databaseUrl;
+        const response = {
+          ok: true,
+          mode: "effect-native",
+          message: yield* runtimeEnv("PRISMA_EFFECT_MESSAGE", message),
+          projectId: yield* runtimeEnv("PRISMA_PROJECT_ID", ""),
+          branchId: yield* runtimeEnv("PRISMA_BRANCH_ID", ""),
+          databaseId: yield* db.databaseId,
+          connectionId: yield* db.connectionId,
+          hasDatabaseUrl: databaseUrl !== undefined,
+        };
+
+        return yield* HttpServerResponse.json(response);
+      }),
+    };
+  }).pipe(Effect.provide(Prisma.ConnectionBindingLive)),
+);
+
+export default Alchemy.Stack(
+  "PrismaComputeEffect",
+  {
+    providers: Prisma.providers(),
+    state: Alchemy.localState(),
+  },
+  Effect.gen(function* () {
+    const project = yield* Project;
+    const branch = yield* MainBranch;
+    const postgres = yield* Postgres;
+    const connection = yield* Connection;
+    const api = yield* Api;
+
+    return {
+      projectId: project.projectId,
+      branchId: branch.branchId,
+      databaseId: postgres.databaseId,
+      connectionId: connection.connectionId,
+      computeServiceId: api.computeServiceId,
+      computeVersionId: api.computeVersionId,
+      url: api.url,
+    };
+  }),
+);

examples/prisma-compute-effect/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "prisma-compute-effect",
+  "version": "0.0.0",
+  "private": true,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alchemy-run/alchemy-effect.git",
+    "directory": "examples/prisma-compute-effect"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "deploy": "alchemy deploy",
+    "destroy": "alchemy destroy",
+    "tail": "alchemy tail"
+  },
+  "dependencies": {
+    "@effect/platform-bun": "catalog:",
+    "alchemy": "workspace:*",
+    "effect": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  }
+}

examples/prisma-compute-effect/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["alchemy.run.ts"],
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": ".",
+    "module": "Preserve",
+    "moduleResolution": "Bundler",
+    "target": "ESNext",
+    "types": ["node"]
+  },
+  "references": [
+    {
+      "path": "../../packages/alchemy/tsconfig.json"
+    }
+  ]
+}

examples/prisma-tanstack-start/.gitignore

@@ -0,0 +1,5 @@
+.alchemy
+.output
+dist
+node_modules
+tsconfig.tsbuildinfo

examples/prisma-tanstack-start/README.md

@@ -0,0 +1,102 @@
+# Prisma TanStack Start
+
+Minimal TanStack Start app with Prisma Next queries, Prisma Postgres, and
+Prisma Compute managed by Alchemy.
+
+## What It Creates
+
+- A Prisma project.
+- A `main` Prisma branch.
+- A Prisma Postgres database via `Prisma.Postgres(...)`.
+- A database connection with redacted connection strings.
+- A standalone Prisma environment variable for shared project config.
+- A Prisma Compute service.
+- A single Compute version built from TanStack Start's `.output` artifact.
+- Runtime env vars for database URLs, Prisma resource IDs, and app config.
+- A Prisma Next contract in `src/prisma/contract.prisma`.
+- Generated Prisma Next artifacts in `src/prisma/contract.json` and
+  `src/prisma/contract.d.ts`.
+- A seed script that inserts demo users/posts and server routes that query them
+  through `@prisma-next/postgres/runtime`.
+
+The app uses an explicit Compute build command:
+
+```sh
+bun run db:setup && bun run build
+```
+
+`db:setup` emits the Prisma Next contract, initializes the database shape, and
+seeds demo data before `vite build` writes the TanStack Start `.output` artifact.
+The Compute version starts `server/index.mjs` on port `3000`.
+
+## Local Dev
+
+```sh
+bun install
+bun run dev
+```
+
+`alchemy dev` starts a local Prisma Postgres with `@prisma/dev`, passes the same
+`DATABASE_URL`/`DIRECT_URL` env names used by deploy, runs `bun run db:setup`,
+and then starts Vite with `bun run dev:start`.
+
+Open `http://localhost:3000`.
+
+If port 3000 is busy:
+
+```sh
+PRISMA_TANSTACK_DEV_PORT=3011 bun run dev
+```
+
+## Prisma Next Workflow
+
+```sh
+bun run emit      # regenerate contract.json + contract.d.ts
+bun run db:init   # apply the contract to DATABASE_URL
+bun run seed      # refresh the demo rows
+bun run db:setup  # all of the above, in order
+```
+
+The Vite dev server also auto-emits the contract on edits. The explicit scripts
+remain the source of truth for deploys and CI so builds are reproducible.
+
+The runtime uses `pg`, so the example uses `Prisma.connectionEnv(connection)` to
+pass a direct `postgres://` connection string as `DATABASE_URL`/`DIRECT_URL`.
+The pooled `prisma+postgres://` URL is exported separately as
+`POOLED_DATABASE_URL` but is intentionally not used by
+`@prisma-next/postgres/runtime`.
+
+## Deploy
+
+```sh
+export PRISMA_SERVICE_TOKEN="..."
+bun run deploy
+```
+
+`PRISMA_API_TOKEN` also works. The deploy output prints the Compute URL.
+
+## Check It
+
+```sh
+curl "$URL/"
+curl "$URL/api/health"
+```
+
+The health response should include:
+
+```json
+{
+  "ok": true,
+  "counts": {
+    "users": 2,
+    "posts": 3
+  }
+}
+```
+
+## Destroy
+
+```sh
+export PRISMA_SERVICE_TOKEN="..."
+bun run destroy
+```