# Configuration (/docs/compute/configuration)

> For the complete Prisma documentation index, see [llms.txt](https://www.prisma.io/docs/llms.txt). A markdown version of any docs page is available by appending `.md` to its URL.

Declare your deployable app in a typed prisma.compute.ts file so deploys are reproducible and monorepos work, without re-passing flags every time.

Location: Compute > Configuration

`prisma.compute.ts` is an optional, committed file that declares what you deploy. [`app deploy`](https://www.prisma.io/docs/compute/cli-reference#app) already works with zero config (it detects your framework and builds), so reach for a config file when you want one of these:

* **Reproducible deploys.** Pin the framework, port, and build settings so every deploy (yours, a teammate's, or [deploy-on-push](https://www.prisma.io/docs/compute/github)) does the same thing without re-passing flags.
* **A monorepo.** Declare several apps in one repository and deploy them together, or one at a time.
* **Type safety.** Catch a typo'd field or an invalid framework in your editor, before you deploy.

The file is read by `app deploy` and `app build`. It never selects your project, branch, or production; those stay explicit. It also does not configure a database; that stays on the [`--db` flag](https://www.prisma.io/docs/compute/cli-reference#app-deploy-options).

## A minimal config [#a-minimal-config]

Export a single `app` with `defineComputeConfig`:

```ts title="prisma.compute.ts"
import { defineComputeConfig } from "@prisma/compute-sdk/config";

export default defineComputeConfig({
  app: {
    framework: "hono",
    entry: "src/index.ts",
    httpPort: 8080,
  },
});
```

Every field is optional. An empty `app: {}` is valid and defers entirely to detection. The values you do set become the defaults for `app deploy`; explicit flags still win over them.

> [!NOTE]
> `defineComputeConfig` is an identity helper that gives the file full type checking. The CLI resolves the import when it reads your config, so the file works without a local install. To get editor types, add the package as a dev dependency:
> 
> 
>   
> 
>   #### bun

>     ```bash
>     bun add --dev @prisma/compute-sdk
>     ```
>
> 
>   #### pnpm

>     ```bash
>     pnpm add -D @prisma/compute-sdk
>     ```
>
> 
>   #### yarn

>     ```bash
>     yarn add --dev @prisma/compute-sdk
>     ```
>
> 
>   #### npm

>     ```bash
>     npm install -D @prisma/compute-sdk
>     ```
>
> 
> 
> JavaScript configs work too: a plain `export default { app: { ... } }` from `prisma.compute.js`/`.mjs`/`.cjs` is valid, just without the type checking. So is a static `prisma.compute.json` with the same shape; it may include a `$schema` field for editor tooling, which is ignored at load time.

## App fields [#app-fields]

Each app accepts these fields. All are optional.

| Field       | Type                                       | Description                                                                                                                        |
| ----------- | ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| `name`      | `string`                                   | The deployed app name. Defaults to the `apps` key, then to inference from `package.json`.                                          |
| `region`    | region name                                | Region for a newly created app; existing apps keep their region. See [Regions](#regions).                                          |
| `root`      | `string`                                   | The app directory, relative to the config file. Defaults to the config file's directory.                                           |
| `framework` | framework name                             | One of `nextjs`, `nuxt`, `astro`, `hono`, `nestjs`, `tanstack-start`, `custom`, `bun`. Defaults to detection.                      |
| `entry`     | `string`                                   | Entrypoint path for `bun` and `hono` apps, relative to the app root. Setting it with any other framework is a configuration error. |
| `httpPort`  | `number`                                   | The port your app listens on. Defaults to the framework's default.                                                                 |
| `env`       | `string` or `{ file, vars }`               | Environment inputs for the deploy. See [Environment](#environment).                                                                |
| `build`     | `{ command, outputDirectory, entrypoint }` | Build settings. See [Build settings](#build-settings).                                                                             |

```ts title="prisma.compute.ts"
import { defineComputeConfig } from "@prisma/compute-sdk/config";

export default defineComputeConfig({
  app: {
    name: "api",
    framework: "hono",
    entry: "src/index.ts",
    httpPort: 8080,
  },
});
```

### Regions [#regions]

`region` is one of `us-east-1`, `us-west-1`, `eu-west-3`, `eu-central-1`, `ap-northeast-1`, or `ap-southeast-1`. It applies only when a deploy creates the app; an app that already exists keeps its current region.

A top-level `region` (next to `app` or `apps`) sets the default for every app in the config; a per-app `region` overrides it.

### Environment [#environment]

`env` is either a dotenv file path, or an object with file path(s) and inline variables:

```ts title="prisma.compute.ts"
export default defineComputeConfig({
  app: {
    // Shorthand: a single dotenv file.
    env: ".env",
  },
});
```

```ts title="prisma.compute.ts"
export default defineComputeConfig({
  app: {
    env: {
      file: [".env", ".env.production"],
      vars: { LOG_LEVEL: "info" },
    },
  },
});
```

File paths resolve from the config file's directory. Any `--env` flag you pass on the command line **replaces** the config's env inputs entirely; they do not merge.

> [!NOTE]
> `prisma.compute.ts` is committed to your repository, so keep secrets out of inline `vars`. For real secrets and your database connection string, use scoped [environment variables](https://www.prisma.io/docs/compute/environment-variables) instead.

### Build settings [#build-settings]

A `build` block lets you own how an app is built:

```ts title="prisma.compute.ts"
export default defineComputeConfig({
  app: {
    framework: "nextjs",
    build: {
      command: "pnpm run build",
      outputDirectory: ".next/standalone",
    },
  },
});
```

* Every field is optional. A field you set overrides the framework default; a field you omit is inferred.
* `command: null` skips the build step entirely.
* `entrypoint` names the built artifact's entry file, relative to `outputDirectory` when one is set (otherwise to the app root). For `hono` and `bun` apps it's required whenever you set `outputDirectory`, and setting both `entry` and a differing `build.entrypoint` is a configuration error.
* A `build` block works with every framework. With the `custom` framework it's required, and must set both `outputDirectory` and `entrypoint`.

Without a `build` block, the CLI infers everything (running your `package.json` build script when there is one, otherwise the framework default) and shows you what it chose during the deploy.

## Where the file lives [#where-the-file-lives]

`app deploy` reads the **nearest** config file, searching from your current directory up to the repository or workspace root (the closest ancestor with a `.git`, `pnpm-workspace.yaml`, `bun.lock`, `bun.lockb`, or a `workspaces` field). Discovery never escapes the repository.

Per directory, exactly one of `prisma.compute.ts`, `prisma.compute.mts`, `prisma.compute.js`, `prisma.compute.mjs`, `prisma.compute.cjs`, or `prisma.compute.json` may exist.

The config file's directory is treated as the project directory: the [`.prisma/local.json`](https://www.prisma.io/docs/compute/getting-started#link-an-existing-project) project pin lives there, and paths in the config (`root`, `env.file`) resolve from there. That means the config means the same thing no matter which subdirectory you run the command from.

## Monorepos [#monorepos]

Use `apps` instead of `app` to declare several apps in one repository, keyed by a target name:

```ts title="prisma.compute.ts"
import { defineComputeConfig } from "@prisma/compute-sdk/config";

export default defineComputeConfig({
  apps: {
    api: {
      root: "apps/api",
      framework: "hono",
      entry: "src/index.ts",
    },
    web: {
      root: "apps/web",
      framework: "nextjs",
    },
  },
});
```

All the apps live in one project, deploying to the same branch. From here:

* **Deploy everything** with a bare `app deploy`, which deploys every app in order. This is the default when no target is named or inferred:

  
    

#### bun

```bash
bunx @prisma/cli@latest app deploy
```

#### pnpm

```bash
pnpm dlx @prisma/cli@latest app deploy
```

#### yarn

```bash
yarn dlx @prisma/cli@latest app deploy
```

#### npm

```bash
npx @prisma/cli@latest app deploy
```
  

* **Deploy one app** by naming its target, or by running from inside its `root` (the deepest matching root wins):

  
    

#### bun

```bash
bunx @prisma/cli@latest app deploy api
```

#### pnpm

```bash
pnpm dlx @prisma/cli@latest app deploy api
```

#### yarn

```bash
yarn dlx @prisma/cli@latest app deploy api
```

#### npm

```bash
npx @prisma/cli@latest app deploy api
```
  

  
    

#### bun

```bash
cd apps/api && bun x @prisma/cli@latest app deploy
```

#### pnpm

```bash
cd apps/api && pnpm dlx @prisma/cli@latest app deploy
```

#### yarn

```bash
cd apps/api && yarn dlx @prisma/cli@latest app deploy
```

#### npm

```bash
cd apps/api && npx @prisma/cli@latest app deploy
```
  

When you deploy everything at once, per-app flags like `--framework` or `--entry` are rejected as ambiguous. Pass a target to apply them to one app. Project- and branch-level flags (`--branch`, `--db`, `--prod`, `--yes`) apply to the whole run.

`app build` always targets a single app in a multi-app config. Unlike `deploy`, it has no all-apps form, so pass a target or run from inside the app's `root`.

## How config and flags interact [#how-config-and-flags-interact]

Config values are deploy **defaults**. Explicit flags always win:

* `--framework`, `--entry`, and `--http-port` override their config value.
* Any `--env` flag replaces the config's env inputs entirely.
* `--app` and `PRISMA_APP_ID` outrank the config's app `name` for app selection.

The config never sets your project, branch, or production target; those are always resolved the same way, [from the directory's project link and your Git branch](https://www.prisma.io/docs/compute/cli-reference#app-deploy-options). Settings that did come from the file are labeled `set by prisma.compute.ts` in the deploy output, so you can always see where a value came from.

A config that fails to load or validate stops the deploy before any remote work, with a clear message pointing at the field to fix.

## What's next [#whats-next]

* [CLI reference](https://www.prisma.io/docs/compute/cli-reference): every command, flag, and error code.
* [Deploy your first app](https://www.prisma.io/docs/prisma-compute/deploy): the end-to-end quickstart.
* [Environment variables](https://www.prisma.io/docs/compute/environment-variables): scoped configuration, secrets, and your database connection string.
* [GitHub integration](https://www.prisma.io/docs/compute/github): deploy-on-push, including monorepos.

## Related pages

- [`@prisma/cli`](https://www.prisma.io/docs/compute/getting-started): Deploy your first app to Prisma Compute with the @prisma/cli beta package, then learn the variations you'll need next.
- [`Alchemy`](https://www.prisma.io/docs/compute/alchemy): Provision Prisma Postgres and deploy applications to Prisma Compute in one TypeScript stack.
- [`Branching`](https://www.prisma.io/docs/compute/branching): Branches are isolated environments that map to your Git branches, so preview work never touches production.
- [`CLI reference`](https://www.prisma.io/docs/compute/cli-reference): Every @prisma/cli command, flag, environment variable, and error code for Prisma Compute.
- [`Deployments`](https://www.prisma.io/docs/compute/deployments): Build, deploy, inspect, promote, and roll back app deployments on Prisma Compute.