@runlot/api 0.1.0-rc.180 → 0.1.0-rc.181

package/dist/schema.d.ts

@@ -2568,9 +2568,10 @@ export interface paths {
         get: operations["getDatabase"];
         put?: never;
         /**
-         * Creates a new database after the previous one was deleted
-         * @description Every project has a database from the start; this creates a new, empty one after a
-         *     delete, and clears the turn-off so later deploys keep it. It returns the connection
+         * Creates the project's database
+         * @description A database is created when your app uses one; this creates it by name, whether the
+         *     project never had one or its database was deleted. A new database starts empty. It
+         *     also clears the turn-off, so later deploys keep it. It returns the connection
          *     details. Shortly afterwards
          *     the running worker picks up a connected `env.db`. No redeploy is needed.
          *
@@ -3867,13 +3868,16 @@ export interface paths {
         get: operations["getAuth"];
         put?: never;
         /**
-         * Turns login back on after it was turned off
+         * Turns login on
          * @description **This is idempotent** — calling it twice leaves the settings and login providers
          *     unchanged. Auth is either on or off; there is no "on but disabled" state.
          *
-         *     **A database is required.** Without one this returns 409 `database_required`, because
-         *     the end-user tables live inside the project's database. Every project has one unless it
-         *     was deleted, so you will see this only after a database delete.
+         *     **Login creates the database it needs.** The end-user tables live inside the
+         *     project's database, so a project without one gets it first, as if you had run
+         *     `runlot pg on`. Two cases are refused instead, each with a 409 that says why: the
+         *     project's database was deleted (`database_required`), or the live deployment's
+         *     `runlot.json` says `"database": false` (`database_disabled`). Create the database with
+         *     `POST …/database` (`runlot pg on`) and call this again.
          *
          *     Once enabled, the built-in login endpoints start serving shortly afterwards. As with
          *     `env.db` and `env.storage`, no redeploy is needed. Table initialization is idempotent,
@@ -9802,7 +9806,7 @@ export interface components {
         /** @description A deployment in the overview. Same shape as `Deployment`, including `actor`. */
         OverviewDeployment: components["schemas"]["Deployment"];
         OverviewDatabase: {
-            /** @description Whether the project has a database. Every project has one unless it was deleted. */
+            /** @description Whether the project has a database. One is created when the app uses it, or by `runlot pg on`. */
             granted: boolean;
             /**
              * Format: date-time
@@ -11785,6 +11789,24 @@ export interface components {
              *     while the class the worker exports has no objects under it.
              */
             migrations?: components["schemas"]["ManifestDurableObjectMigration"][];
+            /**
+             * @description Whether this code uses the project's database (`env.db`). A database is created
+             *     when your app uses one, not for every project.
+             *
+             *     - **absent** — unspecified. The deployment grants nothing on its account; if the
+             *       app calls `env.db` anyway, the database is created on that first call, and calls
+             *       made while it is being created reject with the retryable `DatabaseStarting`.
+             *     - **`true`** — the app uses a database, and the deployment creates it before the
+             *       new version is published. `runlot deploy` writes this when the build reaches a
+             *       database: an import of `@runlot/pg`, of a driver or ORM it routes to `env.db`, or
+             *       of `@runlot/auth`; a `migrations/NNNN_*.sql` file; or `env.db` / `env.DB` in the
+             *       project's own sources. A value set in your `runlot.json` wins over that guess.
+             *     - **`false`** — never create one. Neither the deployment nor a call creates it, and
+             *       `env.db` rejects with `DatabaseNotEnabled`. `runlot pg on` still creates one,
+             *       because it asks by name. Declaring `queues` with `false` is refused with a 400:
+             *       queue messages are kept in the database.
+             */
+            database?: boolean;
             /**
              * @description Declares email sending and receiving. When `true`, the worker receives
              *     `env.email`, and `export default { email() }` becomes the receiving handler.
@@ -20685,7 +20707,8 @@ export interface operations {
             404: components["responses"]["NotFound"];
             /**
              * @description `database_required` — this project's database was deleted.
-             *     Create a new one with `POST …/database` (`runlot pg on`).
+             *     `database_disabled` — `runlot.json` says `"database": false`.
+             *     Either way, create the database with `POST …/database` (`runlot pg on`) first.
              */
             409: {
                 headers: {