prisma 8.0.0-rc.3-dev.54 → 8.0.0-rc.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/sender.js CHANGED
@@ -1,6 +1,6 @@
1
1
  import { t as isParentToSenderPayload } from "./payload-B88Qvzxk-CrtTXSOe.js";
2
- import { readFileSync } from "node:fs";
3
2
  import { join } from "node:path";
3
+ import { readFileSync } from "node:fs";
4
4
  import { determineAgent } from "@vercel/detect-agent";
5
5
  //#region ../cli-telemetry/dist/sender.js
6
6
  /**
package/package.json CHANGED
@@ -1,16 +1,21 @@
1
1
  {
2
2
  "name": "prisma",
3
- "version": "8.0.0-rc.3-dev.54",
3
+ "version": "8.0.0-rc.30",
4
4
  "description": "The Prisma CLI: one binary for the ORM, Composer, and the Prisma Developer Platform.",
5
5
  "type": "module",
6
6
  "bin": {
7
7
  "prisma": "./dist/prisma.js"
8
8
  },
9
9
  "exports": {
10
- "./package.json": "./package.json"
10
+ "./package.json": "./package.json",
11
+ "./config": {
12
+ "types": "./dist/config.d.ts",
13
+ "import": "./dist/config.js"
14
+ }
11
15
  },
12
16
  "files": [
13
17
  "dist",
18
+ "skills",
14
19
  "README.md",
15
20
  "LICENSE"
16
21
  ],
@@ -18,7 +23,7 @@
18
23
  "access": "public"
19
24
  },
20
25
  "engines": {
21
- "node": ">=22.18.0"
26
+ "node": "^22.18.0 || ^24.11.0 || >=26.0.0"
22
27
  },
23
28
  "keywords": [
24
29
  "prisma",
@@ -38,28 +43,32 @@
38
43
  },
39
44
  "license": "Apache-2.0",
40
45
  "dependencies": {
41
- "@prisma/cli-engine": "0.1.1",
42
- "@prisma/composer-cli": "0.6.0-dev.23",
43
- "@prisma/compute-sdk": "0.39.0",
44
- "@prisma/credentials-store": "^7.8.0",
45
- "@prisma/management-api-sdk": "1.55.0",
46
- "@prisma/orm-toolchain": "8.0.0-rc.2-dev.1",
46
+ "@manypkg/tools": "^2.1.2",
47
+ "@prisma/cli-engine": "0.9.0",
48
+ "@prisma/composer-cli": "0.36.0",
49
+ "@prisma/compute-sdk": "0.43.0",
50
+ "@prisma/management-api-sdk": "1.80.0",
51
+ "@prisma/orm-toolchain": "8.0.0-rc.22",
47
52
  "@vercel/detect-agent": "^1.2.3",
48
53
  "better-result": "^2.9.2",
54
+ "cross-spawn": "^7.0.6",
49
55
  "dotenv": "^17.4.2",
50
56
  "execa": "^9.6.1",
51
57
  "open": "^11.0.0"
52
58
  },
53
59
  "devDependencies": {
54
- "@prisma/cli": "8.0.0-rc.3-dev.54",
55
- "@repo/cli-telemetry": "8.0.0-rc.3-dev.54",
56
- "@repo/tsconfig": "8.0.0-rc.3-dev.54",
60
+ "@prisma/cli": "8.0.0-rc.30",
61
+ "@prisma/credentials-store": "^7.8.0",
62
+ "@repo/cli-telemetry": "8.0.0-rc.30",
63
+ "@repo/tsconfig": "8.0.0-rc.30",
57
64
  "@types/node": "^22.19.19",
58
65
  "tsdown": "^0.21.10",
59
- "typescript": "^6.0.3"
66
+ "typescript": "^6.0.3",
67
+ "vitest": "^4.1.8"
60
68
  },
61
69
  "scripts": {
62
70
  "build": "tsdown",
63
- "typecheck": "tsc --noEmit"
71
+ "typecheck": "tsc --noEmit",
72
+ "test": "vitest run"
64
73
  }
65
74
  }
@@ -0,0 +1,450 @@
1
+ ---
2
+ name: prisma-platform-core-concepts
3
+ metadata:
4
+ library: "prisma"
5
+ library_version: "8.0.0-rc.30"
6
+ version: 2026.9.2
7
+ description: >-
8
+ Use when hosting, deploying, or operating an app on the Prisma Platform:
9
+ projects, branches, preview environments, services and their versions,
10
+ Prisma Postgres databases, object-store buckets, environment variables,
11
+ custom domains, logs, or the GitHub integration. Triggers on "Prisma
12
+ Platform", "Prisma Compute", "Prisma Postgres", "Prisma Storage",
13
+ "preview environment", `prisma deploy`, `prisma dev`, `prisma auth`,
14
+ `prisma project`, `prisma branch`, `prisma service`, `prisma postgres`,
15
+ `prisma bucket`, `prisma git`, `prisma.config.ts`, promote, rollback.
16
+ ---
17
+
18
+ # Prisma Platform core concepts
19
+
20
+ > **Isolated infrastructure for every branch.**
21
+
22
+ The Prisma Platform moves fast, and your training data about it is very
23
+ likely outdated. This skill ships inside the installed `prisma` package, so
24
+ it describes the exact version this project has: treat it as the source of
25
+ truth over anything you remember about Prisma hosting. If
26
+ `metadata.library_version` in this file's frontmatter does not match the
27
+ project's installed `prisma` package, run `prisma skills sync` and re-read.
28
+ Fuller documentation for everything here lives at prisma.io/docs; consult it
29
+ when a concept needs more depth than this file carries.
30
+
31
+ This file shares the platform's structures, hierarchies, relationships, and
32
+ workflows. It is not a CLI reference: commands appear only where a workflow
33
+ needs them. To learn a command surface, run `prisma --help`, or
34
+ `prisma <group> --help` for any group named below; pass `--json` for
35
+ machine-readable output. Without it, a piped command prints plain data lines,
36
+ not JSON. The data contract, migrations, and
37
+ queries belong to the `prisma-orm-core-concepts` skill; declaring services
38
+ and modules in code belongs to `prisma-composer-core-concepts`.
39
+
40
+ ## The stack
41
+
42
+ One CLI, `prisma`, fronts a set of products designed to be used together:
43
+
44
+ | Product | What it is | Concepts live in |
45
+ | --- | --- | --- |
46
+ | Prisma ORM (Prisma 8) | Data contract, typed queries, migrations | `prisma-orm-core-concepts` |
47
+ | Prisma Composer | The app declaration: services, databases, buckets, wiring | `prisma-composer-core-concepts` |
48
+ | Prisma Compute | Hosting: runs your services next to your data | this skill |
49
+ | Prisma Postgres | Managed PostgreSQL | this skill |
50
+ | Prisma Storage | S3-compatible object storage | this skill |
51
+
52
+ **Every deployed app is a Composer app.** Your server code plus a declaration
53
+ (`module.ts`) naming its services, databases, and buckets. The declaration is
54
+ the source of truth: deploying converges the platform to it, re-deploying
55
+ applies only the difference, and removing a resource from the module removes
56
+ it from the platform on the next deploy. There is no separate provisioning
57
+ step and no connection strings to wire by hand; Composer injects them.
58
+
59
+ ## Project setup
60
+
61
+ `prisma init` prepares local configuration and copies this skill from the
62
+ installed `prisma` package into the configured agent directories. Database
63
+ provisioning and deployment are separate choices. Keep the project's existing
64
+ database and hosting setup unless the user wants to change it.
65
+
66
+ For a Prisma Composer (Early Access) app deployed to Prisma Compute, install
67
+ the app's dependencies:
68
+
69
+ ```sh
70
+ npm install prisma @prisma/composer @prisma/composer-prisma-cloud
71
+ ```
72
+
73
+ `@prisma/composer` is what the module declaration imports;
74
+ `@prisma/composer-prisma-cloud` is the Prisma Cloud target and brings
75
+ `@prisma/orm-postgres` with it. The sibling skills travel inside these
76
+ packages (`prisma-composer-core-concepts` in `@prisma/composer`,
77
+ `prisma-orm-core-concepts` in `@prisma/orm-postgres`), so they appear after
78
+ this install plus `prisma skills sync`, not before.
79
+
80
+ One config file, `prisma.config.ts`, configures the CLI and every product
81
+ it runs. Each top-level key is a section owned by one product, and this CLI
82
+ recognises exactly three: `orm`, `composer`, and `skills`. The composed
83
+ shape:
84
+
85
+ ```ts
86
+ import { definePrismaConfig } from "prisma/config";
87
+ import { defineConfig as composer } from "@prisma/composer/config";
88
+ import { nodeBuild } from "@prisma/composer/node/control";
89
+ import {
90
+ prismaCloud,
91
+ prismaState,
92
+ } from "@prisma/composer-prisma-cloud/control";
93
+ import { defineConfig as orm } from "@prisma/orm-postgres/config";
94
+
95
+ export default definePrismaConfig({
96
+ composer: composer({
97
+ entry: "./module.ts",
98
+ extensions: [prismaCloud(), nodeBuild()],
99
+ state: prismaState(),
100
+ }),
101
+ orm: orm({ contract: "./src/prisma/contract.prisma" }),
102
+ skills: { agents: ["claude"] },
103
+ });
104
+ ```
105
+
106
+ `dev` and `deploy` read the `composer` section and nothing else; what goes
107
+ in it belongs to `prisma-composer-core-concepts`. A separate
108
+ `prisma-composer.config.ts` is no longer read, and the old setup is refused,
109
+ never silently ignored: `CONFIG.SECTION_MISSING` when no loaded
110
+ `prisma.config.ts` declares a `composer` section, `CONFIG.FIELD_RETIRED`
111
+ when the section still has `configPath`, and `CONFIG.FILE_RETIRED` when a
112
+ `prisma-composer.config.*` sits next to the declaring `prisma.config.ts`.
113
+ All three arrive under the CLI's `CLI.CONFIG_SECTION_INVALID`. For
114
+ `CONFIG.SECTION_MISSING`, write the section. For the other two, move the
115
+ old file's `extensions` and `state` into the section, then delete the
116
+ `configPath` field or the old file.
117
+
118
+ ## The resource model
119
+
120
+ 1. **Workspace**: the account boundary. Members, billing, and projects live
121
+ here; the `auth` group manages which one you act in.
122
+ 2. **Project**: one product or codebase. Its region is chosen at creation and
123
+ is immutable afterwards; every resource in the project inherits it.
124
+ 3. **Branch**: the isolation boundary, named after a git branch. A branch is
125
+ an environment: it owns its own services, its own databases, its own
126
+ buckets, and its own environment-variable overrides.
127
+ 4. Inside a branch: **services** (HTTP apps, deployed as versions),
128
+ **databases**, and **buckets**.
129
+
130
+ The first branch of a project is the **production** branch. Every branch
131
+ after it is a **preview** branch. Production and previews differ in exactly
132
+ two ways: which environment-variable class they resolve (see below), and
133
+ lifecycle (previews can be reclaimed and torn down; production cannot).
134
+
135
+ A CLI invocation resolves its project from a directory binding, created when
136
+ a project is created from or linked to the directory and stored in the
137
+ gitignored `.prisma/local.json`. Resource commands take flags to target
138
+ another project or branch explicitly.
139
+
140
+ ## Branches are preview environments
141
+
142
+ There is no separate "preview environment" object to create or configure. The
143
+ branch is the environment, and branches come into being by deploying to them:
144
+
145
+ 1. **Push a git branch** (with the GitHub integration connected and the
146
+ deploy workflow in the repository): the workflow builds and deploys, and
147
+ the platform creates the branch environment on the fly.
148
+ 2. **Deploy an environment from the CLI**: `prisma deploy --environment pr-42`
149
+ creates a branch named `pr-42` and deploys the identical app graph into
150
+ it. An environment name must be a valid git ref name; an invalid name is
151
+ a hard error.
152
+
153
+ A preview branch that needs a database gets a fresh, empty one, wired in as a
154
+ branch-scoped `DATABASE_URL`. Preview work can never touch production data
155
+ unless you explicitly point it there. Schema comes from your committed
156
+ migrations; data does not follow from production.
157
+
158
+ Preview lifecycle rules:
159
+
160
+ 1. Deleting the upstream git branch tears the whole environment down:
161
+ services, versions, and databases, including their data.
162
+ 2. An idle, unpinned preview branch can be reclaimed automatically. Pinning a
163
+ preview exempts it from idle reclamation, but not from teardown when its
164
+ git branch is deleted.
165
+ 3. The production branch is never reclaimed or torn down this way.
166
+
167
+ ## Two ways to deploy
168
+
169
+ **GitHub (recommended).** Two pieces, both required: the Prisma GitHub App
170
+ connected to the repository, and a GitHub Actions workflow in the repository
171
+ that runs `prisma/cloud-deploy-action`. The platform does not build on push.
172
+ The workflow builds in the repository's own Actions and deploys with a
173
+ short-lived credential exchanged from the run's OIDC token; the connection
174
+ is what authorises that exchange, and it also tears a preview down when its
175
+ git branch is deleted. Importing the repository in the Console opens a setup
176
+ pull request that adds the workflow. `prisma git connect` only creates the
177
+ connection, so a repository connected from the CLI adds the workflow itself.
178
+ The minimal `.github/workflows/prisma-deploy.yml`:
179
+
180
+ ```yaml
181
+ name: prisma-deploy
182
+ on:
183
+ push:
184
+ permissions:
185
+ contents: read
186
+ id-token: write
187
+ jobs:
188
+ deploy:
189
+ if: github.ref_type == 'branch'
190
+ runs-on: ubuntu-latest
191
+ steps:
192
+ - uses: actions/checkout@v4
193
+ - uses: actions/setup-node@v4
194
+ with:
195
+ node-version: 24
196
+ - uses: oven-sh/setup-bun@v2
197
+ - uses: prisma/cloud-deploy-action@v1
198
+ with:
199
+ build-command: npm run build
200
+ ```
201
+
202
+ From then on, every push of a branch that carries the workflow file runs
203
+ it; GitHub reads workflows from the pushed commit, so a branch created
204
+ before the file was added deploys nothing until it contains the file. A
205
+ push to the default branch deploys production; a push to any other branch
206
+ creates or updates that branch's preview environment, so previews come free
207
+ with every branch.
208
+ Opening a pull request does not itself deploy anything; previews track
209
+ branch pushes. A connected repository without the workflow gets branch
210
+ bookkeeping and preview teardown from the platform, and no builds.
211
+
212
+ **CLI.** `prisma deploy` deploys production directly; add `--environment <name>`
213
+ for a preview. It deploys the entry file named by `entry` in the `composer`
214
+ section of `prisma.config.ts`; `--entry <path>` overrides it. `prisma deploy
215
+ list` (same `--environment`) lists each deployed node's address, kind, platform ID
216
+ and URL. Authenticate once with `prisma auth login`
217
+ (interactive), or set `PRISMA_SERVICE_TOKEN` (plus `PRISMA_WORKSPACE_ID`
218
+ when the token can see more than one workspace) for CI and other headless
219
+ runs. The first deploy creates the project, named after your module; the
220
+ name must be unique in the workspace, and `--name` deploys under a different
221
+ one.
222
+
223
+ Before deploying, configure the Composer root module and the `composer`
224
+ section in `prisma.config.ts`, then build the app. A new project also needs
225
+ a region in `prismaCloud({ region: ... })` or `PRISMA_REGION`. The
226
+ [deployment guide](https://www.prisma.io/docs/composer/deploying) covers
227
+ these prerequisites; running `prisma init` alone does not prepare a
228
+ deployable app.
229
+
230
+ Both paths converge the same declaration, so they are mutually idempotent:
231
+ a repo can be connected to GitHub and still be deployed from the CLI.
232
+
233
+ ## Services and versions
234
+
235
+ A **service** is an HTTP app inside a branch, reachable at a stable URL.
236
+ Every deploy of a service creates a new immutable **version**; exactly one
237
+ version is live behind the stable URL at a time. Versions can be inspected,
238
+ started, stopped, and deleted individually, and a version's logs can be read
239
+ or followed; the `service` group covers all of it.
240
+
241
+ Two movements between versions matter:
242
+
243
+ 1. **Promote** takes a version to production by rebuilding it with
244
+ production-class environment variables. A version built on a preview
245
+ branch never carries preview configuration into production.
246
+ 2. **Rollback** points production back at a previous version. A stopped
247
+ target is started and health-checked before traffic switches, so rollback
248
+ is zero-downtime.
249
+
250
+ **Custom domains** attach to a service's production branch only. The
251
+ workflow: add the domain, create the CNAME record the platform reports, and
252
+ wait for DNS verification and certificate provisioning; a verification that
253
+ failed on missing DNS is retried after the record exists.
254
+
255
+ ## The Compute runtime
256
+
257
+ Services run on Bun, next to their Prisma Postgres database. There is no
258
+ container image to author and no platform emulator to install locally.
259
+
260
+ The runtime has no global `Temporal` (stock Node 24 lacks one too). Code
261
+ that reads an ORM `DateTime` column compiles and deploys, then throws on
262
+ the first read. Either add the `temporal-polyfill` dependency and
263
+ `import 'temporal-polyfill/full/global'` at the service entry, or use the
264
+ `*String` column types such as `TimestamptzString`.
265
+
266
+ An idle service **sleeps**: the platform snapshots its memory after a short
267
+ period of inactivity and resumes it from the snapshot on the next request.
268
+ Request handling is unaffected, but background work outside the request
269
+ lifecycle (`setTimeout`, `setInterval`, floating promises) can be
270
+ interrupted mid-flight. The `@prisma/compute` package provides the two
271
+ keep-awake primitives:
272
+
273
+ 1. `waitUntil(promise, { signal })` keeps the instance awake until the
274
+ promise settles.
275
+ 2. `using guard = new KeepAwakeGuard({ signal })` holds the instance awake
276
+ for a scope; call `.release()` in a `finally` block where `using` is
277
+ unavailable.
278
+
279
+ Pass `AbortSignal.timeout(ms)` as a cost bound: the signal releases the
280
+ guard, it does not cancel your work. Do not build schedulers on `setInterval`
281
+ inside a service; sleeping makes them silently unreliable.
282
+
283
+ ## Prisma Postgres
284
+
285
+ To your application, a Prisma Postgres database is a regular PostgreSQL
286
+ database behind a connection string: any client works, including Prisma ORM,
287
+ psql, Kysely, and Drizzle. On top of plain PostgreSQL each database has
288
+ built-in connection pooling (no PgBouncer to run) and, on paid plans,
289
+ automated backups: a snapshot each day the database has activity.
290
+
291
+ Databases usually come from deploying a module that declares one. They can
292
+ also be created directly, in which case the connection URL prints exactly
293
+ once. Additional connection strings can be minted and rotated per database;
294
+ every secret is shown exactly once at creation, and no later read reveals
295
+ it. On paid plans, backups are automated, listable, and restorable.
296
+ Per-database usage metrics are queryable; the `postgres` group covers all of
297
+ it.
298
+
299
+ A database outside any project comes from the separate
300
+ [`create-db` tool](https://www.prisma.io/docs/postgres/npx-create-db):
301
+ `npx create-db@latest` needs no account and prints a connection string and a
302
+ claim URL. The database is deleted after 24 hours unless claimed; claiming it
303
+ with a Prisma account keeps it for free. Give the user the claim URL itself
304
+ and the deletion time: opening that URL is the only way to keep the database.
305
+ Use it when the user has no Prisma account or project yet. When the project
306
+ is on the platform, create the database in the project with the `postgres`
307
+ group, or declare it in the module, instead.
308
+
309
+ ## Object storage
310
+
311
+ Buckets are S3-compatible object stores that live inside the project,
312
+ optionally associated with a branch (the project's default branch when
313
+ omitted). A bucket cannot be renamed.
314
+
315
+ Access keys are bucket-scoped credentials with a role of `read` or
316
+ `read_write`. Creating one prints the access key id, secret, endpoint, and
317
+ provider bucket name exactly once; a lost secret is revoked and re-created,
318
+ never recovered. The `bucket` group manages both buckets and their keys.
319
+
320
+ On Compute, Bun's built-in S3 client picks up `S3_ENDPOINT`, `S3_BUCKET`,
321
+ `S3_ACCESS_KEY_ID`, and `S3_SECRET_ACCESS_KEY` from the environment, so a
322
+ bucket declared in the module needs no client configuration. Locally, a
323
+ Composer-declared bucket gets a local stand-in with the same S3 surface;
324
+ code written against it runs unchanged on the platform.
325
+
326
+ ## Environment variables
327
+
328
+ Configuration has two independent axes:
329
+
330
+ | Axis | Values | Meaning |
331
+ | --- | --- | --- |
332
+ | Class | `production`, `preview` | Which branches resolve it: production-class values reach the production branch, preview-class values reach every preview |
333
+ | Scope | project template, branch override | A template applies to all branches of its class; an override pins a value to one named preview branch |
334
+
335
+ Rules that bite:
336
+
337
+ 1. Branch overrides exist only for the preview class. Production
338
+ configuration is always the project template; there is no way to give one
339
+ production deploy a special value.
340
+ 2. Values are write-only. Listing shows names and scopes, never values, and
341
+ no API returns them. To change a value you replace it.
342
+ 3. Variables resolve at deploy time from the branch's class. You never pass
343
+ environment variables as part of a deploy.
344
+ 4. Templates, per-branch overrides, and wholesale dotenv import are all
345
+ managed through the `project env` group.
346
+ 5. `DATABASE_URL` is managed for you when the module declares a database:
347
+ previews get their own fresh database's URL, production gets the
348
+ production database's. Only set it yourself for databases the platform
349
+ does not manage.
350
+
351
+ ## Local development
352
+
353
+ The local stack is real, fast, and needs no cloud credentials. Prefer it
354
+ over deploying whenever you want to show the user a change or verify your
355
+ own work:
356
+
357
+ 1. Build the app exactly as you would for deploy, then run
358
+ `prisma dev` (it runs the config's `entry`, like deploy). It provisions a local Prisma Postgres database,
359
+ applies the schema, creates local stand-ins for declared buckets, starts
360
+ the services, and prints a local URL. It watches built output and
361
+ restarts a service when its build changes.
362
+ 2. Exercise the running app directly (for example with
363
+ `curl "$(prisma dev url gateway)"`, with your service's name in place of
364
+ `gateway`) instead of reasoning about what the
365
+ code would do. `prisma dev url <node>` prints one node's local URL: a
366
+ service's HTTP URL, a database's connection string, or a bucket's S3
367
+ address. Use `prisma dev --detach` to start the app and get your shell
368
+ back.
369
+ 3. Stopping `dev` (Ctrl-C, or `prisma dev stop`) leaves local databases,
370
+ buckets, and their data in place; the next run is a warm start. `--fresh`
371
+ wipes this app's local instances and data first. `prisma emulator list`
372
+ shows every local instance on the machine.
373
+ 4. Deploying is the same pipeline pointed at the platform: switching from
374
+ local to hosted is a configuration change, not a code change. Reach for
375
+ `prisma deploy --environment <name>` only when you need a shareable URL or
376
+ platform behaviour (sleeping, real DNS, production-like config).
377
+ 5. For pure frontend iteration the framework's own dev server also works;
378
+ the Composer local stack is what mirrors the deployed wiring.
379
+
380
+ Windows is not supported for the local stack yet.
381
+
382
+ ## Failure modes quick reference
383
+
384
+ 1. **A secret you need was shown once and is gone.** By design: database
385
+ URLs, connection strings, and bucket keys print exactly once at creation.
386
+ Rotate or re-create; do not hunt for a read path, none exists.
387
+ 2. **Deploy refuses the module name.** Module names are workspace-unique.
388
+ Deploy under `--name <other>`, or delete the conflicting project.
389
+ 3. **A preview environment vanished.** Its git branch was deleted, or it
390
+ sat idle unpinned and was reclaimed. Push or deploy the branch again to
391
+ re-create it; the database starts empty again.
392
+ 4. **Background work never ran in production.** The service slept.
393
+ Wrap the work in `waitUntil` or a `KeepAwakeGuard`, or move it out of the
394
+ service.
395
+ 5. **A custom domain stays unverified.** The CNAME to the reported target
396
+ must exist first. Fix DNS, then retry the verification.
397
+ 6. **Production shows a stale value after an environment-variable change.**
398
+ Variables are resolved at deploy time. Re-deploy (or promote) so the new
399
+ value is picked up.
400
+ 7. **An environment name is rejected.** Environment names must be valid git
401
+ ref names; rename it.
402
+ 8. **A resource disappeared from the platform after a deploy.** It was
403
+ removed from `module.ts`; the module is the source of truth and deploy
404
+ converges to it. Restore the declaration and re-deploy.
405
+ 9. **`dev` or `deploy` rejects the app graph (`COMPOSE.GRAPH_INVALID`) over
406
+ a name.** Resource ids declared in the module (`provision()` ids,
407
+ `compute({ name })`) allow `[A-Za-z0-9]` only. A hyphenated id passes
408
+ authoring and typecheck, then fails here. Module and project names do
409
+ accept hyphens, so never derive a resource id from them.
410
+ 10. **A deployed service errors on its first timestamp read
411
+ (`RUNTIME.TEMPORAL_UNAVAILABLE`).** The runtime has no global
412
+ `Temporal`; see the Compute runtime section for the polyfill.
413
+ 11. **The repository is connected, but a push built nothing.** The platform
414
+ does not build on push; the repository's own workflow does. Make sure
415
+ `.github/workflows/prisma-deploy.yml` exists on the pushed branch and
416
+ that a run appears under the repository's Actions tab. A connected
417
+ repository with no workflow records the branch and deploys nothing, and
418
+ no error is raised anywhere.
419
+
420
+ ## What the platform doesn't do yet
421
+
422
+ Name the gap instead of inventing an API:
423
+
424
+ 1. **No branch create or delete from the CLI.** The `branch` group only
425
+ lists. Branches are created by pushing or by deploying an environment,
426
+ and removed by deleting the upstream git branch; there is no CLI teardown
427
+ verb for an environment yet.
428
+ 2. **No build retry.** A failed build is finished; the retry is the next
429
+ push or the next deploy.
430
+ 3. **No reading environment-variable values back**, anywhere. This is a
431
+ security stance, not a missing feature, but agents look for it often
432
+ enough to name here.
433
+ 4. **No bucket rename** and no bucket-to-branch re-association after
434
+ creation; re-create instead.
435
+ 5. **No build on push without a workflow.** The GitHub connection authorises
436
+ deploys and tears previews down; it never starts a build. The
437
+ `prisma/cloud-deploy-action` workflow is the build.
438
+
439
+ For anything else missing, run the nearest group with `--help` before
440
+ concluding it does not exist, and route requests with `prisma feedback`
441
+ rather than guessing.
442
+
443
+ ## Related skills
444
+
445
+ Everything inside the app is owned by the siblings: the data contract,
446
+ queries, and migrations by `prisma-orm-core-concepts` (and
447
+ `prisma-orm-migrations`), and the declaration of services, modules, wiring,
448
+ and testing seams by `prisma-composer-core-concepts`. The skills install
449
+ together via `prisma skills sync`; when a task crosses from platform
450
+ resources into app code, switch skills instead of guessing.
@@ -1,23 +0,0 @@
1
- import path from "node:path";
2
- import { detectComputeAppFromDirectory } from "@prisma/compute-sdk/config/directory";
3
- //#region ../cli/src/lib/app/deploy-framework.ts
4
- /** Reads the directory's package.json and framework config to name the
5
- * framework a deploy would use, or null when none is recognised. */
6
- async function detectDeployFramework(cwd, signal) {
7
- const detected = await detectComputeAppFromDirectory({
8
- appPath: cwd,
9
- signal
10
- });
11
- if (!detected) return null;
12
- let annotation = "detected from package.json";
13
- if (detected.configFile?.standaloneOutput) annotation = "standalone output detected";
14
- else if (detected.configFile) annotation = `detected from ${path.basename(detected.configFile.path)}`;
15
- return {
16
- key: detected.framework,
17
- buildType: detected.buildType,
18
- displayName: detected.frameworkName,
19
- annotation
20
- };
21
- }
22
- //#endregion
23
- export { detectDeployFramework };