@netlify/agent-runner-cli 1.100.1 → 1.101.0

package/dist/skills/general-database/SKILL@netlifydb.md

@@ -1,16 +1,16 @@
 ---
 name: general-database
-description: Use this skill whenever the task involves storing, persisting, querying, or managing data — including CRUD operations, collections, records, user data, or any application state that needs to survive between requests. Covers both relational databases (Netlify DB) and key-value storage (Netlify Blobs).
+description: Use this skill whenever the task involves storing, persisting, querying, or managing data — including CRUD operations, collections, records, user data, or any application state that needs to survive between requests. Covers both relational databases (Netlify Database) and key-value storage (Netlify Blobs).
 ---
 
 # Data Storage on Netlify
 
-## Relational data: Netlify DB
+## Relational data: Netlify Database
 
-**Netlify DB** is the recommended solution for relational data storage. It provides a fully managed Postgres database
-with zero configuration — install the `@netlify/db` package, and a database is automatically provisioned for your site.
+**Netlify Database** is the recommended solution for relational data storage. It provides a fully managed Postgres database
+with zero configuration — install the `@netlify/database` package, and a database is automatically provisioned for your site.
 
-Use Netlify DB when you need:
+Use Netlify Database when you need:
 
 - Relational data (tables, joins, foreign keys)
 - SQL queries and filtering
@@ -19,25 +19,24 @@ Use Netlify DB when you need:
 
 There are two recommended approaches:
 
-- **Drizzle ORM** (recommended): Use Drizzle ORM with the native Netlify DB adapter for type-safe schema definitions
-  and a query builder. Install `@netlify/db`, `netlify-drizzle-orm-tests` (temporary package name — will become
-  `drizzle-orm` soon), and `drizzle-kit`.
-- **Native `@netlify/db` driver**: Use the `sql` tagged template literal for direct SQL queries. Install `@netlify/db`.
+- **Drizzle ORM** (recommended): Use Drizzle ORM with the native Netlify Database adapter for type-safe schema
+  definitions and a query builder. Install `@netlify/database`, `drizzle-orm@beta`, and `drizzle-kit@beta`. The
+  `@beta` dist-tag is required — the Netlify Database adapter only exists on the beta release line.
+- **Native `@netlify/database` driver**: Use the `sql` tagged template literal for direct SQL queries. Install `@netlify/database`.
 
 IMPORTANT: Any code that assumes a different database schema requires a corresponding migration file in
-`netlify/db/migrations/`. Without a migration, the database schema will not change and the application will break.
+`netlify/database/migrations/`. Without a migration, the database schema will not change and the application will break.
 
-See the **netlify-db** skill for complete setup instructions and usage examples.
+See the **netlify-database** skill for complete setup instructions and usage examples.
 
-## Key-value data: Netlify Blobs
+## Object storage: Netlify Blobs
 
-**Netlify Blobs** is the recommended solution for simple key-value storage.
+**Netlify Blobs** is the recommended solution for object storage.
 
 Use Netlify Blobs when you need:
 
 - File and image storage
 - JSON document persistence
 - Cache storage
-- Simple key-value data that doesn't require relational queries
 
 See the **netlify-blobs** skill for complete setup instructions and usage examples.

package/dist/skills/{netlify-db@netlifydb → netlify-database@netlifydb}/SKILL.md

@@ -1,37 +1,40 @@
 ---
-name: netlify-db
-description: Use Netlify DB for relational data storage with a fully managed Postgres database. Use when implementing data models with tables, relationships, SQL queries, transactions, or any data that benefits from a relational schema.
+name: netlify-database
+description: Use Netlify Database for relational data storage with a fully managed Postgres database. Use when implementing data models with tables, relationships, SQL queries, transactions, or any data that benefits from a relational schema.
 ---
 
-# Netlify DB
+# Netlify Database
 
-Netlify DB is a fully managed Postgres database built into the Netlify platform. It handles provisioning, migrations,
-and database branching automatically. There is no setup beyond installing the `@netlify/db` package.
+Netlify Database is a fully managed Postgres database built into the Netlify platform. It handles provisioning, migrations,
+and database branching automatically. There is no setup beyond installing the `@netlify/database` package.
 
-Prefer Netlify DB over Netlify Blobs when the data is relational or requires SQL queries, unless the user explicitly
+Prefer Netlify Database over Netlify Blobs when the data is relational or requires SQL queries, unless the user explicitly
 asks for a different storage solution.
 
-## CRITICAL: Temporary package name
+## CRITICAL: Use the `@beta` dist-tag for Drizzle
 
-The Drizzle ORM Netlify DB adapter has not yet been published to the main `drizzle-orm` package. Until it is, you MUST
-use the `netlify-drizzle-orm-tests` package instead of `drizzle-orm` for ALL Drizzle imports.
+The Netlify Database adapter for Drizzle ORM only exists on the `beta` release line of `drizzle-orm`. You MUST install
+both `drizzle-orm` and `drizzle-kit` from the `@beta` dist-tag — the default `latest` versions do not include the
+Netlify Database adapter and will fail.
 
 This affects:
-- `npm install` commands: use `netlify-drizzle-orm-tests` instead of `drizzle-orm`
-- ALL import statements: use `netlify-drizzle-orm-tests` and `netlify-drizzle-orm-tests/pg-core` and
-  `netlify-drizzle-orm-tests/netlify-db` instead of the `drizzle-orm` equivalents
+- `npm install` commands: always install `drizzle-orm@beta` and `drizzle-kit@beta` (never `drizzle-orm` or
+  `drizzle-kit` without the tag).
+- Import paths: use `drizzle-orm`, `drizzle-orm/pg-core`, and `drizzle-orm/netlify-db` as normal. No package
+  name rewriting is needed — the `@beta` tag only affects the installed version, not the imports.
 
-The `drizzle-kit` package is NOT affected — use the regular `drizzle-kit` package.
+If you forget the `@beta` tag, `drizzle-kit generate` will error with a message about being outdated, or the
+`drizzle-orm/netlify-db` import will fail to resolve.
 
 ## CRITICAL: Database schema changes always require migrations
 
 Any code change that assumes a different database schema (adding tables, adding columns, renaming fields, changing types,
-adding indexes, etc.) will only work if a corresponding migration exists in `netlify/db/migrations/`. Without a
+adding indexes, etc.) will only work if a corresponding migration exists in `netlify/database/migrations/`. Without a
 migration, the database schema will not change and the application will break at runtime.
 
-This applies regardless of whether you are using Drizzle ORM or the native `@netlify/db` driver:
+This applies regardless of whether you are using Drizzle ORM or the native `@netlify/database` driver:
 - **With Drizzle ORM**: Update the schema definition, then run `npx drizzle-kit generate`
-- **With native driver**: Write a new SQL migration file in `netlify/db/migrations/`
+- **With native driver**: Write a new SQL migration file in `netlify/database/migrations/`
 
 Never consider a schema change complete without a corresponding migration file.
 
@@ -43,8 +46,8 @@ generation.
 ### Step 1: Install packages
 
 ```bash
-npm install @netlify/db netlify-drizzle-orm-tests
-npm install -D drizzle-kit
+npm install @netlify/database drizzle-orm@beta
+npm install -D drizzle-kit@beta
 ```
 
 ### Step 2: Create the schema file
@@ -53,7 +56,7 @@ Create `db/schema.ts` at the project root. Define all your tables here using Dri
 
 ```typescript
 // db/schema.ts
-import { pgTable, serial, text, timestamp, integer } from "netlify-drizzle-orm-tests/pg-core";
+import { pgTable, serial, text, timestamp, integer } from "drizzle-orm/pg-core";
 
 export const users = pgTable("users", {
   id: serial().primaryKey(),
@@ -80,11 +83,11 @@ The Drizzle column variable names can be camelCase.
 
 ### Step 3: Create the database client
 
-Create `db/index.ts`. This file initializes the Drizzle client with the native Netlify DB adapter.
+Create `db/index.ts`. This file initializes the Drizzle client with the native Netlify Database adapter.
 
 ```typescript
 // db/index.ts
-import { drizzle } from "netlify-drizzle-orm-tests/netlify-db";
+import { drizzle } from "drizzle-orm/netlify-db";
 import * as schema from "./schema.js";
 
 export const db = drizzle({ schema });
@@ -94,8 +97,8 @@ The connection is configured automatically — no connection string needed.
 
 ### Step 4: Configure Drizzle Kit
 
-Create `drizzle.config.ts` at the project root. The `out` property MUST be set to `netlify/db/migrations` for Netlify
-to automatically apply migrations.
+Create `drizzle.config.ts` at the project root. The `out` property MUST be set to `netlify/database/migrations` for
+Netlify to automatically apply migrations.
 
 ```typescript
 // drizzle.config.ts
@@ -104,20 +107,7 @@ import { defineConfig } from "drizzle-kit";
 export default defineConfig({
   dialect: "postgresql",
   schema: "./db/schema.ts",
-  out: "netlify/db/migrations",
-});
-```
-
-Alternatively, use the helper:
-
-```typescript
-import { defineConfig } from "drizzle-kit";
-import { withNetlifyDB } from "@netlify/db/drizzle";
-
-export default defineConfig({
-  dialect: "postgresql",
-  schema: "./db/schema.ts",
-  ...withNetlifyDB(),
+  out: "netlify/database/migrations",
 });
 ```
 
@@ -129,7 +119,7 @@ Run this every time you change the schema:
 npx drizzle-kit generate
 ```
 
-This creates SQL migration files in `netlify/db/migrations/`. DO NOT manually edit the generated migration files.
+This creates SQL migration files in `netlify/database/migrations/`. DO NOT manually edit the generated migration files.
 DO NOT create the migrations directory manually — `drizzle-kit generate` creates it.
 
 ### Step 6: Use the database in functions
@@ -166,7 +156,7 @@ When adding columns, tables, or changing the schema in an existing project:
 
 1. Update the Drizzle schema definition with your changes
 2. Run `npx drizzle-kit generate` — this is REQUIRED, not optional
-3. Verify new migration files appear in `netlify/db/migrations/`
+3. Verify new migration files appear in `netlify/database/migrations/`
 4. Update any application code that uses the changed tables
 
 Do NOT skip step 2. The database will not reflect your schema changes without a generated migration.
@@ -174,7 +164,7 @@ Do NOT skip step 2. The database will not reflect your schema changes without a
 ### Drizzle ORM query reference
 
 ```typescript
-import { eq, desc, and, or, like, sql } from "netlify-drizzle-orm-tests";
+import { eq, desc, and, or, like, sql } from "drizzle-orm";
 import { db } from "./db/index.js";
 import { users, posts } from "./db/schema.js";
 
@@ -222,13 +212,13 @@ Use this when you prefer raw SQL or don't want Drizzle ORM.
 ### Install
 
 ```bash
-npm install @netlify/db
+npm install @netlify/database
 ```
 
 ### Query with `db.sql`
 
 ```typescript
-import { getDatabase } from "@netlify/db";
+import { getDatabase } from "@netlify/database";
 
 const db = getDatabase();
 
@@ -280,12 +270,12 @@ try {
 
 ### Write migrations manually
 
-When using the native driver, write SQL migration files by hand in `netlify/db/migrations/`.
+When using the native driver, write SQL migration files by hand in `netlify/database/migrations/`.
 
 Each migration is a SQL file named `<number>_<slug>.sql`:
 
 ```
-netlify/db/migrations/
+netlify/database/migrations/
 ├── 001_create-users.sql
 ├── 002_add-posts.sql
 └── 003_create-comments.sql
@@ -294,7 +284,7 @@ netlify/db/migrations/
 Example migration:
 
 ```sql
--- netlify/db/migrations/001_create-users.sql
+-- netlify/database/migrations/001_create-users.sql
 CREATE TABLE users (
   id SERIAL PRIMARY KEY,
   name TEXT NOT NULL,
@@ -312,7 +302,7 @@ Rules for migration names:
 ## Migrations: how they work
 
 IMPORTANT: You must NEVER apply migrations yourself. Your job is only to CREATE migration files — either by running
-`npx drizzle-kit generate` (when using Drizzle ORM) or by writing SQL files in `netlify/db/migrations/` (when using
+`npx drizzle-kit generate` (when using Drizzle ORM) or by writing SQL files in `netlify/database/migrations/` (when using
 the native driver). The Netlify platform applies migrations automatically at the right point in the deploy lifecycle.
 Do NOT run `drizzle-kit migrate`, `drizzle-kit push`, or execute migration SQL directly against the database.
 
@@ -321,7 +311,7 @@ Netlify applies migrations automatically during deploys:
 - **Production deploys:** Applied immediately before the deploy is published. A failure blocks publishing.
 - **Deploy previews:** Applied on every new deploy, immediately before it becomes available. A failure fails the deploy.
 
-Migrations MUST be in `netlify/db/migrations/` to be applied automatically.
+Migrations MUST be in `netlify/database/migrations/` to be applied automatically.
 
 Two formats are supported:
 1. SQL files directly in the directory (e.g. `001_create-users.sql`)
@@ -338,15 +328,16 @@ Drizzle Kit generates migrations in the subdirectory format. Both formats can co
 
 ## Common mistakes to avoid
 
-1. **Wrong migration output directory**: Drizzle Kit defaults to `drizzle/`. You MUST set `out: "netlify/db/migrations"`
-   in `drizzle.config.ts` or use `...withNetlifyDB()`. If migrations are in the wrong directory, they will not be
-   applied.
+1. **Wrong migration output directory**: Drizzle Kit defaults to `drizzle/`. You MUST set
+   `out: "netlify/database/migrations"` in `drizzle.config.ts`. If migrations are in the wrong directory, they will not
+   be applied.
 
-2. **Using `drizzle-orm` instead of `netlify-drizzle-orm-tests`**: The Netlify DB adapter is not yet in the main
-   `drizzle-orm` package. Use `netlify-drizzle-orm-tests` for all Drizzle imports.
+2. **Forgetting the `@beta` dist-tag**: The Netlify Database adapter only exists on `drizzle-orm@beta` and
+   `drizzle-kit@beta`. Installing `drizzle-orm` or `drizzle-kit` without the `@beta` tag pulls the `latest` releases,
+   which lack the adapter and will fail. Always install with `drizzle-orm@beta` and `drizzle-kit@beta`.
 
 3. **NEVER skip migration generation after schema changes**: Any code that assumes a different database schema requires
-   a corresponding migration in `netlify/db/migrations/`. With Drizzle ORM, run `npx drizzle-kit generate` after
+   a corresponding migration in `netlify/database/migrations/`. With Drizzle ORM, run `npx drizzle-kit generate` after
    updating the schema definition. With the native driver, write a SQL migration file. Schema changes alone do
    nothing — the migration files are what Netlify applies. The application WILL break without them.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/agent-runner-cli",
   "type": "module",
-  "version": "1.100.1",
+  "version": "1.101.0",
   "description": "CLI tool for running Netlify agents",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",