DO cleanup, adding table of APIs in storage-api.

Author: Oxyjun

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

@@ -15,19 +15,8 @@ import {
 
 The Durable Object Storage API allows <GlossaryTooltip term="Durable Object">Durable Objects</GlossaryTooltip> to access transactional and strongly consistent storage. A Durable Object's attached storage is private to its unique instance and cannot be accessed by other objects.
 
-:::note[Scope of Durable Object storage]
-Note that Durable Object storage is scoped by individual <GlossaryTooltip term="Durable Object">Durable Objects</GlossaryTooltip>.
-
-- An account can have many Durable Object <GlossaryTooltip term="namespace">namespaces</GlossaryTooltip>.
-- A namespace can have many Durable Objects.
-
-However, storage is scoped per individual Durable Object.
-:::
-
 <Render file="storage-intro-text"/>
 
-JavaScript is a single-threaded and event-driven programming language. This means that JavaScript runtimes, by default, allow requests to interleave with each other which can lead to concurrency bugs. The Durable Objects runtime uses a combination of <GlossaryTooltip term="input gate">input gates</GlossaryTooltip> and <GlossaryTooltip term="output gate">output gates</GlossaryTooltip> to avoid this type of concurrency bug when performing storage operations.
-
 The following code snippet shows you how to store and retrieve data using the Durable Object Storage API.
 
 <TypeScriptExample>
@@ -49,8 +38,21 @@ export class Counter extends DurableObject {
 ```
 </TypeScriptExample>
 
+JavaScript is a single-threaded and event-driven programming language. This means that JavaScript runtimes, by default, allow requests to interleave with each other which can lead to concurrency bugs. The Durable Objects runtime uses a combination of <GlossaryTooltip term="input gate">input gates</GlossaryTooltip> and <GlossaryTooltip term="output gate">output gates</GlossaryTooltip> to avoid this type of concurrency bug when performing storage operations.
+
+:::note[Scope of Durable Object storage]
+Note that Durable Object storage is scoped by individual <GlossaryTooltip term="Durable Object">Durable Objects</GlossaryTooltip>.
+
+- An account can have many Durable Object <GlossaryTooltip term="namespace">namespaces</GlossaryTooltip>.
+- A namespace can have many Durable Objects.
+
+However, storage is scoped per individual Durable Object.
+:::
+
 ## SQL API
 
+<Render file="do-sqlite-storage-no-bill-note"/>
+
 The `SqlStorage` interface encapsulates methods that modify the SQLite database embedded within a Durable Object. The `SqlStorage` interface is accessible via the [`sql` property](/durable-objects/api/storage-api/#) of `DurableObjectStorage` class.
 
 For example, using `sql.exec()`, a user can create a table, then insert rows into the table.

src/content/docs/durable-objects/best-practices/access-durable-objects-storage.mdx

@@ -14,10 +14,16 @@ A Durable Object's [in-memory state](/durable-objects/reference/in-memory-state/
 
 ## Access storage
 
-We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. [Key-value storage backend](/durable-objects/reference/durable-objects-migrations/#create-durable-object-class -with-key-value-storage) remains for backwards compatibility, and a migration path from key-value storage to SQL storage for existing Durable Object classes will be offered in the future.
+We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend.
 
 [Storage API methods](/durable-objects/api/storage-api/#methods) are available on `ctx.storage` parameter passed to the Durable Object constructor. Storage API has SQL APIs and key-value APIs. Only Durable Object classes with a SQLite storage backend can access SQL API.
 
+<Render file="do-sqlite-storage-no-bill-note"/>
+
+:::note[Key-value storage]
+[Key-value storage backend](/durable-objects/reference/durable-objects-migrations/#create-durable-object-class-with-key-value-storage) remains for backwards compatibility, and a migration path from key-value storage to SQL storage for existing Durable Object classes will be offered in the future.
+:::
+
 ### Create SQLite-backed Durable Object class
 
 Use `new_sqlite_classes` on the migration in your Worker's Wrangler file:

src/content/docs/durable-objects/reference/durable-objects-migrations.mdx

@@ -75,7 +75,7 @@ new_sqlite_classes = ["DurableObjectAClass"]
 
 ### Create Durable Object class with key-value storage
 
-We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. Key-value storage backend remains for backwards compatibility. 
+We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. Key-value storage backend remains for backwards compatibility.
 
 Use `new_classes` on the migration in your Worker's Wrangler file:
 
@@ -130,7 +130,7 @@ To delete a Durable Object binding `DEPRECATED_OBJECT`, your `wrangler.toml / wr
 
 [[migrations]]
 tag = "v3" # Should be unique for each entry
-deleted_classes = ["DeprecatedObjectClass"] # Array of new classes
+deleted_classes = ["DeprecatedObjectClass"] # Array of deleted classes
 ```
 </WranglerConfig>
 </Details>

src/content/partials/durable-objects/do-sqlite-storage-no-bill-note.mdx

@@ -0,0 +1,7 @@
+---
+{}
+---
+
+:::note[Storage billing on Durable Objects with SQLite storage backend]
+Storage billing is not yet enabled for Durable Object classes using SQLite storage backend. SQLite-backed Durable Objects will incur [charges for requests and duration](/durable-objects/platform/pricing/#compute-billing). Storage billing for Durable Objects using SQLite storage backend will be enabled at a later date with advance notice with the following pricing.
+:::

src/content/partials/durable-objects/durable-objects-pricing.mdx

@@ -2,7 +2,7 @@
 {}
 ---
 
-import { Markdown, GlossaryTooltip, Details, AnchorHeading } from "~/components";
+import {Render, Markdown, GlossaryTooltip, Details, AnchorHeading } from "~/components";
 
 { props.product === "durable-objects" && <><AnchorHeading title="Compute billing" depth={2}/></> }
 { props.product === "workers" && <><AnchorHeading title="Compute billing" depth={3}/></> }
@@ -52,9 +52,7 @@ The [Durable Objects Storage API](/durable-objects/api/storage-api) is only acce
 { props.product === "durable-objects" && <><AnchorHeading title="SQLite storage backend" depth={3}/></> }
 { props.product === "workers" && <><AnchorHeading title="SQLite storage backend" depth={4}/></> }
 
-:::note
-Storage billing is not yet enabled for Durable Object classes using SQLite storage backend. SQLite-backed Durable Objects will incur [charges for requests and duration](/durable-objects/platform/pricing/#compute-billing). Storage billing for Durable Objects using SQLite storage backend will be enabled at a later date with advance notice with the following pricing.
-:::
+<Render file="do-sqlite-storage-no-bill-note"/>
 
 |                               | Workers Free plan         | Workers Paid plan                                         |
 | ----------------------------- | ------------------------- | --------------------------------------------------------- |

src/content/partials/durable-objects/storage-intro-text.mdx

@@ -9,4 +9,15 @@ The Durable Object Storage API comes with several methods, including [SQL API](/
 - Durable Objects gain access to a persistent KV Durable Object Storage API via the `DurableObjectStorage` interface and accessed by the `DurableObjectState::storage` property. This is frequently accessed via `this.ctx.storage` when the `ctx` parameter passed to the Durable Object constructor.
 - Durable Object classes with the key-value storage backend can only use KV API.
 
-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.
+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.
+
+| Type of storage API | SQLite backed Durable Object | KV backed Durable Object |
+| ------------------- | ---------------------------- | ------------------------ |
+| SQL API             | ✅                           | ❌                       |
+| PITR API            | ✅                           | ❌                       |
+| KV API              | ✅                           | ✅                       |
+| Alarms API          | ✅                           | ✅                       |
+
+:::note[Recommended SQLite-backed Durable Object]
+We recommend using SQLite-backed Durable Object over key-value backed Durable Object. SQLite-backed Durable Objects allow you to store more types of data (such as tables), and offers Point In Time Recovery API which can restore a the Durable Object's embedded SQLite database contents (both SQL data and key-value data) to any point in the past 30 days.
+:::