Separating out accessing sqlite storage from kv

storage. Fixing links to accommodate this change

Author: Oxyjun

public/_redirects

@@ -401,7 +401,7 @@
 /durable-objects/api/websockets/ /durable-objects/features/websockets/ 301
 /durable-objects/best-practices/ /durable-objects/features/ 301
 /durable-objects/best-practices/create-durable-object-stubs-and-send-requests/ /durable-objects/features/create-durable-object-stubs-and-send-requests/ 301
-/durable-objects/best-practices/access-durable-objects-storage/ /durable-objects/features/access-durable-objects-storage/ 301
+/durable-objects/best-practices/access-durable-objects-storage/ /durable-objects/features/access-sqlite-storage/ 301
 /durable-objects/best-practices/error-handling/ /durable-objects/features/error-handling/ 301
 /durable-objects/best-practices/websockets/ /durable-objects/features/websockets/ 301
 /durable-objects/platform/data-location/ /durable-objects/reference/data-location/ 301

src/content/docs/durable-objects/api/sql-storage.mdx

@@ -38,7 +38,7 @@ SQL API methods accessed with `ctx.storage.sql` are only allowed on [Durable Obj
 :::
 
 :::note[Writing to indexes or virtual tables]
-When writing data, every index counts as an additional row. However, indexes may be beneficial for read-heavy use cases. Refer to [Index for SQLite Durable Objects](/durable-objects/features/access-durable-objects-storage/#index-for-sqlite-durable-objects).
+When writing data, every index counts as an additional row. However, indexes may be beneficial for read-heavy use cases. Refer to [Index for SQLite Durable Objects](/durable-objects/features/access-sqlite-storage/#index-for-sqlite-durable-objects).
 
 Writing data to [SQLite virtual tables](https://www.sqlite.org/vtab.html) also counts towards rows written.
 :::

src/content/docs/durable-objects/api/storage-api.mdx

@@ -52,15 +52,15 @@ export class Counter extends DurableObject {
 ## Methods
 
 :::note[SQLite in Durable Objects]
-SQLite-backed Durable Objects can have a private, embedded SQLite database. When deploying a new Durable Object class, users can [use a SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) to access the [SQL API](/durable-objects/api/sql-storage/#exec).
+SQLite-backed Durable Objects can have a private, embedded SQLite database. When deploying a new Durable Object class, users can [use a SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) to access the [SQL API](/durable-objects/api/sql-storage/#exec).
 
 Otherwise, a Durable Object class has a key-value storage backend.
 :::
 
 The Durable Object Storage API comes with several methods, including key-value (KV) API, SQL API, and point-in-time-recovery (PITR) API.
 
 - Durable Object classes with the default, key-value storage backend can use KV API.
-- Durable Object classes with the [SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) can use KV API, SQL API, and PITR API. KV API methods like `get()`, `put()`, `delete()`, or `list()` store data in a hidden SQLite table.
+- Durable Object classes with the [SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) can use KV API, SQL API, and PITR API. KV API methods like `get()`, `put()`, `delete()`, or `list()` store data in a hidden SQLite table.
 
 Each method is implicitly wrapped inside a transaction, such that its results are atomic and isolated from all other storage operations, even when accessing multiple key-value pairs.
 
@@ -110,7 +110,7 @@ Each method is implicitly wrapped inside a transaction, such that its results ar
 
 - <code>deleteAll(options <Type text="Object" /> <MetaInfo text="optional" />)</code>: <Type text="Promise" />
 
-  - Deletes all stored data, effectively deallocating all storage used by the Durable Object. For Durable Objects with a key-value storage backend, `deleteAll()` removes all keys and associated values for an individual Durable Object. For Durable Objects with a [SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend), `deleteAll()` removes the entire contents of a Durable Object's private SQLite database, including both SQL data and key-value data.
+  - Deletes all stored data, effectively deallocating all storage used by the Durable Object. For Durable Objects with a key-value storage backend, `deleteAll()` removes all keys and associated values for an individual Durable Object. For Durable Objects with a [SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend), `deleteAll()` removes the entire contents of a Durable Object's private SQLite database, including both SQL data and key-value data.
   - For Durable Objects with a key-value storage backend, an in-progress `deleteAll()` operation can fail, which may leave a subset of data undeleted. Durable Objects with a SQLite storage backend do not have a partial `deleteAll()` issue because `deleteAll()` operations are atomic (all or nothing).
   - `deleteAll()` does not proactively delete [Alarms](/durable-objects/api/alarms/). Use [`deleteAlarm()`](/durable-objects/api/alarms/#deletealarm) to delete an alarm.
 
@@ -203,13 +203,13 @@ The `put()` method returns a `Promise`, but most applications can discard this p
 
   - Provides access to the `put()`, `get()`, `delete()` and `list()` methods documented above to run in the current transaction context. In order to get transactional behavior within a transaction closure, you must call the methods on the `txn` Object instead of on the top-level `ctx.storage` Object.<br/><br/>Also supports a `rollback()` function that ensures any changes made during the transaction will be rolled back rather than committed. After `rollback()` is called, any subsequent operations on the `txn` Object will fail with an exception. `rollback()` takes no parameters and returns nothing to the caller.
 
-  * When using [the SQLite-backed storage engine](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend), the `txn` object is obsolete. Any storage operations performed directly on the `ctx.storage` object, including SQL queries using [`ctx.storage.sql.exec()`](/durable-objects/api/sql-storage/#exec), will be considered part of the transaction.
+  * When using [the SQLite-backed storage engine](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend), the `txn` object is obsolete. Any storage operations performed directly on the `ctx.storage` object, including SQL queries using [`ctx.storage.sql.exec()`](/durable-objects/api/sql-storage/#exec), will be considered part of the transaction.
 
 ### `transactionSync`
 
 - `transactionSync(callback)`: <Type text='any' />
 
-  - Only available when using [the SQLite-backed storage engine](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend).
+  - Only available when using [the SQLite-backed storage engine](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend).
 
   - Invokes `callback()` wrapped in a transaction, and returns its result.
 

src/content/docs/durable-objects/features/access-durable-objects-storage.mdx renamed to src/content/docs/durable-objects/features/access-sqlite-storage.mdx

@@ -46,7 +46,7 @@ Durable Objects have limits.
 
 ## SQLite Durable Object SQL limits
 
-For Durable Object classes with [SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) these SQL limits apply:
+For Durable Object classes with [SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) these SQL limits apply:
 
 | SQL                                                      | Limit                                           |
 | -------------------------------------------------------- | ----------------------------------------------- |

src/content/docs/durable-objects/platform/limits.mdx

@@ -12,13 +12,13 @@ languages:
 
 import { Render, PackageManagers, Details, WranglerConfig } from "~/components";
 
-In this tutorial, you will learn how to build a seat reservation app using Durable Objects. This app will allow users to book a seat for a flight. The app will be written in TypeScript and will use the new [SQLite storage backend in Durable Object](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) to store the data.
+In this tutorial, you will learn how to build a seat reservation app using Durable Objects. This app will allow users to book a seat for a flight. The app will be written in TypeScript and will use the new [SQLite storage backend in Durable Object](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) to store the data.
 
 Using Durable Objects, you can write reusable code that can handle coordination and state management for multiple clients. Moreover, writing data to SQLite in Durable Objects is synchronous and uses local disks, therefore all queries are executed with great performance. You can learn more about SQLite storage in Durable Objects in the [SQLite in Durable Objects blog post](https://blog.cloudflare.com/sqlite-in-durable-objects).
 
 :::note[SQLite in Durable Objects]
 
-SQLite in Durable Objects is currently in beta. You can learn more about the limitations of SQLite in Durable Objects in the [SQLite in Durable Objects documentation](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend).
+SQLite in Durable Objects is currently in beta. You can learn more about the limitations of SQLite in Durable Objects in the [SQLite in Durable Objects documentation](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend).
 
 :::
 

src/content/docs/durable-objects/tutorials/build-a-seat-booking-app/index.mdx

@@ -27,7 +27,7 @@ entries:
 
   - term: "Storage Backend"
     general_definition: |-
-      By default, a Durable Object class can use Storage API that leverages a key-value storage backend. New Durable Object classes can opt-in to using a [SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend).
+      By default, a Durable Object class can use Storage API that leverages a key-value storage backend. New Durable Object classes can opt-in to using a [SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend).
 
   - term: "Storage API"
     general_definition: |-

src/content/glossary/durable-objects.yaml

@@ -4,7 +4,7 @@
 
 ## SQL in Durable Objects vs D1
 
-Cloudflare Workers offers a SQLite-backed serverless database product - [D1](/d1/). How should you compare [SQLite in Durable Objects](/durable-objects/features/access-durable-objects-storage/#sql-storage) and D1?
+Cloudflare Workers offers a SQLite-backed serverless database product - [D1](/d1/). How should you compare [SQLite in Durable Objects](/durable-objects/features/access-sqlite-storage/) and D1?
 
 **D1 is a managed database product.**
 

src/content/partials/durable-objects/durable-objects-vs-d1.mdx

@@ -16,17 +16,17 @@ entries:
   - publish_date: "2024-10-07"
     title: Alarms re-enabled in (beta) SQLite-backed Durable Object classes
     description: |-
-      The issue identified with [alarms](/durable-objects/api/alarms/) in [beta Durable Object classes with a SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) has been resolved and alarms have been re-enabled.
+      The issue identified with [alarms](/durable-objects/api/alarms/) in [beta Durable Object classes with a SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) has been resolved and alarms have been re-enabled.
 
   - publish_date: "2024-09-27"
     title: Alarms disabled in (beta) SQLite-backed Durable Object classes
     description: |-
-      An issue was identified with [alarms](/durable-objects/api/alarms/) in [beta Durable Object classes with a SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend). Alarms have been temporarily disabled for only SQLite-backed Durable Objects while a fix is implemented. Alarms in Durable Objects with default, key-value storage backend are unaffected and continue to operate.
+      An issue was identified with [alarms](/durable-objects/api/alarms/) in [beta Durable Object classes with a SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend). Alarms have been temporarily disabled for only SQLite-backed Durable Objects while a fix is implemented. Alarms in Durable Objects with default, key-value storage backend are unaffected and continue to operate.
 
   - publish_date: "2024-09-26"
     title: (Beta) SQLite storage backend & SQL API available on new Durable Object classes
     description: |-
-      The new beta version of Durable Objects is available where each Durable Object has a private, embedded SQLite database. When deploying a new Durable Object class, users can [opt-in to a SQLite storage backend](/durable-objects/features/access-durable-objects-storage/#sqlite-storage-backend) in order to access new [SQL API](/durable-objects/api/sql-storage/#exec) and [point-in-time-recovery API](/durable-objects/api/sql-storage/#point-in-time-recovery), part of Durable Objects Storage API.
+      The new beta version of Durable Objects is available where each Durable Object has a private, embedded SQLite database. When deploying a new Durable Object class, users can [opt-in to a SQLite storage backend](/durable-objects/features/access-sqlite-storage/#sqlite-storage-backend) in order to access new [SQL API](/durable-objects/api/sql-storage/#exec) and [point-in-time-recovery API](/durable-objects/api/sql-storage/#point-in-time-recovery), part of Durable Objects Storage API.
 
       You cannot enable a SQLite storage backend on an existing, deployed Durable Object class. Automatic migration of deployed classes from their key-value storage backend to SQLite storage backend will be available in the future.