@antelopejs/interface-dms-builder 0.0.1

package/docs/4.page-operations.md

@@ -0,0 +1,341 @@
+# Page Operations
+
+## Overview
+
+Page operations cover everything that lives in a page file: the pages themselves, the categories they hang from, and the block tree inside each page. Reads (`ListPages`, `ListCategories`, `GetPageStructure`) tell you what is there; mutations (`CreatePage`, `AddBlock`, `MoveBlock`, …) rewrite the source and return the staged `FileChange` list.
+
+Every mutation returns an `OpResult`, so branch on `ok` before touching `data`. The refs and shapes these operations trade in are described in [Addressing and Structure](./2.addressing-and-structure.md); the errors and warnings they return are described in [Results and Errors](./8.results-and-errors.md).
+
+## List Pages and Categories
+
+`ListPages` and `ListCategories` are plain reads: they return arrays, not an `OpResult`.
+
+```typescript
+import {
+  ListCategories,
+  ListPages,
+} from "@antelopejs/interface-dms-builder";
+
+const pages = await ListPages();
+const categories = await ListCategories();
+
+for (const page of pages) {
+  console.log(page.ref, page.displayName, page.filepath);
+}
+```
+
+## Read a Page's Structure
+
+`GetPageStructure(ref)` returns the page's metadata, its block tree and its queries, wrapped in an `OpResult<PageStructure>`. Being a read, its `changes` array is empty.
+
+```typescript
+import { GetPageStructure } from "@antelopejs/interface-dms-builder";
+
+const result = await GetPageStructure("/dashboard");
+if (!result.ok) {
+  throw new Error(`cannot read /dashboard: ${result.error.code}`);
+}
+
+const { page, blocks, queries, version } = result.data;
+```
+
+Keep `version`: passing it as `expectedVersion` on the next mutation turns the write into a conditional one.
+
+## Refresh the Source Index
+
+The builder keeps an index of the project's source. Mutations invalidate it themselves, so you only need `RefreshSourceIndex` after something *else* changed the files — a hand edit, a checkout, a generator run.
+
+```typescript
+import { RefreshSourceIndex } from "@antelopejs/interface-dms-builder";
+
+await RefreshSourceIndex();                       // source index and catalog
+await RefreshSourceIndex({ page: "/dashboard" }); // source index only
+```
+
+`RefreshScope` has a single field:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `page` | `PageRef` | Keep the cached catalog. Omit the scope entirely to drop the catalog as well. |
+
+The scope does not narrow the source index: it is invalidated in full either way, and naming a page only spares the catalog cache. Pass a page when you know the change was confined to page source and left the component catalog alone — it saves rescanning the catalog, not the project.
+
+Invalidating is not rescanning. The call only drops the cache; the cost lands on the next read, which rescans the project in full and memoizes the result. Two refreshes in a row therefore cost nothing extra, but refreshing before every read costs a full scan every time. The operation returns `void`, not an `OpResult`.
+
+## Create a Page
+
+`CreatePage(input)` writes a new page file, wires it into the nearest barrel, and returns the ref it assigned along with the file it created.
+
+```typescript
+import { CreatePage } from "@antelopejs/interface-dms-builder";
+
+const result = await CreatePage({
+  name: "revenue",
+  displayName: "Revenue",
+  category: "pages",
+  icon: "i-ph-chart-line",
+  description: "Monthly revenue overview",
+});
+if (result.ok) {
+  console.log(result.data.ref, result.data.filepath);
+}
+```
+
+`CreatePageInput`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | The page's route id/slug. Required. A duplicate fails with `duplicate_name`. |
+| `displayName` | `string` | The label shown in the menu. Required. |
+| `category` | `CategoryRef` | The category to attach to. Required, and it must already exist. |
+| `icon` | `string` | Icon name. |
+| `order` | `number` | Sort order within the category. |
+| `description` | `string` | The page's description. |
+| `permission` | `PagePermission` | The permission guarding the page. |
+| `dir` | `string` | Explicit folder, relative to the src root, overriding the default category-relative placement. |
+
+Without `dir`, the page lands at `<category-folder>/<name>/page.ts` when the category is declared in the project's source and has a barrel beside it, and at `src/<name>.ts` otherwise. With `dir`, it lands at `src/<dir>/<name>/page.ts`. Either way the nearest barrel above the file is wired, keeping a relative import chain up to `src/index.ts`. `dir` must stay inside the src tree; a `dir` that escapes it, or a project with no barrel to wire, fails with `unsupported`.
+
+```typescript
+import { CreatePage } from "@antelopejs/interface-dms-builder";
+
+await CreatePage({
+  name: "revenue",
+  displayName: "Revenue",
+  category: "pages",
+  dir: "reporting", // → src/reporting/revenue/page.ts
+});
+```
+
+## Configure a Page
+
+`ConfigurePage(ref, patch, opts?)` patches the page's metadata in place. The patch is a `Partial<EditablePageMeta>`; keys you leave out are untouched, and a key set to `undefined` is removed from the page's options.
+
+```typescript
+import { ConfigurePage } from "@antelopejs/interface-dms-builder";
+
+const result = await ConfigurePage("/revenue", {
+  displayName: "Monthly revenue",
+  order: 10,
+  hidden: false,
+});
+```
+
+### Move a Page Between Categories
+
+A page's category decides its route, so patching `category` moves the page rather than editing a field. `ConfigurePage` rewrites the `category` option and its import, moves the file to the directory beside the new category — where `CreatePage` would have put it — and moves the registration with it, so each directory's barrel still lists what it holds. Relative imports inside the page are re-anchored to its new location.
+
+The result carries the page's new `ref`, and a `route_changed` warning naming the old one. **Nothing redirects the old route**: links and bookmarks to it break.
+
+```typescript
+import { ConfigurePage } from "@antelopejs/interface-dms-builder";
+
+const moved = await ConfigurePage("/form/revenue", { category: "pages.reports" });
+if (moved.ok) {
+  console.log(moved.data.ref); // "/reports/revenue"
+  for (const warning of moved.warnings ?? []) {
+    console.log(warning.code, warning.message); // "route_changed", …
+  }
+}
+```
+
+The move is refused when the target category is unknown (`not_found`), when it is built-in or not declared in source so a page cannot reference it (`unsupported`), or when the destination already holds a page of that name (`duplicate_name`). A page whose options are not a plain object literal fails with `unsupported` too — the builder rewrites source, so it needs a literal to rewrite.
+
+`opts` is a `MutationOpts`, so `expectedVersion` makes the write conditional.
+
+## Delete a Page
+
+`DeletePage(ref, opts?)` removes the page file and unwires every import of it.
+
+```typescript
+import { DeletePage } from "@antelopejs/interface-dms-builder";
+
+const result = await DeletePage("/revenue", { expectedVersion: version });
+if (!result.ok && result.error.code === "stale") {
+  // Re-read the page and decide again.
+}
+```
+
+## Create a Category
+
+`CreateCategory(input)` declares a new category and registers it in the root barrel.
+
+```typescript
+import { CreateCategory } from "@antelopejs/interface-dms-builder";
+
+const result = await CreateCategory({
+  name: "reports",
+  displayName: "Reports",
+  parent: "pages",
+  icon: "i-ph-folder",
+  order: 3,
+});
+// result.data.ref === "pages.reports"
+```
+
+`CreateCategoryInput`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | The category's id segment. Required. A duplicate fails with `duplicate_name`. |
+| `displayName` | `string` | The label shown in the menu. Required. |
+| `parent` | `CategoryRef` | The parent category. Omit for a category under the root `pages`. |
+| `icon` | `string` | Icon name. |
+| `order` | `number` | Sort order among siblings. |
+
+A `parent` that does not exist fails with `not_found`.
+
+## Configure a Category
+
+`ConfigureCategory(ref, patch)` patches an existing category. It takes no options argument.
+
+```typescript
+import { ConfigureCategory } from "@antelopejs/interface-dms-builder";
+
+await ConfigureCategory("pages.reports", {
+  displayName: "Reporting",
+  order: 1,
+});
+```
+
+Two refusals, both `unsupported`: re-parenting (a patch carrying `parent`), and a category that is built in or otherwise not declared in editable source.
+
+## Delete a Category
+
+`DeleteCategory(ref)` removes the category declaration, and deletes its file when nothing but imports is left in it.
+
+```typescript
+import { DeleteCategory } from "@antelopejs/interface-dms-builder";
+
+const result = await DeleteCategory("pages.reports");
+if (!result.ok && result.error.code === "referential_integrity") {
+  console.log("still in use by", result.error.blockedBy);
+}
+```
+
+A category that still holds pages or child categories fails with `referential_integrity`, and `blockedBy` lists the refs standing in the way. Empty it first.
+
+## Add a Block
+
+`AddBlock(input, opts?)` emits a factory call into the page and returns the `BlockPath` of the new block.
+
+```typescript
+import { AddBlock } from "@antelopejs/interface-dms-builder";
+
+const result = await AddBlock({
+  page: "/revenue",
+  name: "total",
+  type: "KpiCard",
+  config: {
+    title: "Total revenue",
+    icon: "i-ph-currency-eur",
+  },
+});
+if (result.ok) {
+  console.log(result.data.path); // "/revenue#total"
+}
+```
+
+`AddBlockInput`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `page` | `PageRef` | The page to add to. Required. |
+| `name` | `string` | The block's name, unique among its siblings. Required. A duplicate fails with `duplicate_name`. |
+| `type` | `string` | A `BlockTypeDescriptor.type` from the catalog. Required. An unknown type fails with `unsupported`. |
+| `config` | `Record<string, unknown>` | The factory's options object. Required. |
+| `parent` | `BlockPath` | The container to nest under. Omit to add a top-level block. |
+| `slot` | `string` | The slot within the parent container. |
+| `index` | `number` | Position among siblings. Defaults to appending. |
+| `controller` | `ResourceRef` | The resource whose DataAPI class is the leading argument, for controller-leading block types. |
+
+`config` is plain JSON by default; values that are not literals — a DataType instance, a reference to a generated class — use the sentinel encodings in [Value Encodings](./7.values.md).
+
+Nesting requires an editable container: a `parent` that resolves to an opaque block fails with `opaque_target`, and one that does not resolve at all fails with `not_found`. An out-of-range `index` is clamped, and the result carries an `index_clamped` warning.
+
+Controller-leading types (catalog `controllerArg: true`, e.g. `TableView`) require `controller`; passing it for any other type is rejected. Both mismatches fail with `invalid_config`.
+
+```typescript
+import { AddBlock } from "@antelopejs/interface-dms-builder";
+
+await AddBlock({
+  page: "/products",
+  name: "table",
+  type: "TableView",
+  controller: "product", // emitted as the imported productDataAPI class
+  config: { caption: "Products" },
+});
+```
+
+## Configure a Block
+
+`ConfigureBlock(path, patch, opts?)` rewrites a block's options object. By default the patch merges: listed keys are replaced, unlisted keys survive, and a key set to `undefined` is removed.
+
+```typescript
+import { ConfigureBlock } from "@antelopejs/interface-dms-builder";
+
+await ConfigureBlock("/revenue#total", {
+  title: "Revenue (net)",
+  description: undefined, // removes the option
+});
+```
+
+`ConfigureBlockOpts` extends `MutationOpts`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `replace` | `boolean` | Replace the whole options object instead of merging into it. |
+| `expectedVersion` | `string` | The `PageStructure.version` you last read. A mismatch fails with `stale`. |
+
+```typescript
+import { ConfigureBlock } from "@antelopejs/interface-dms-builder";
+
+await ConfigureBlock(
+  "/revenue#total",
+  { title: "Revenue" },
+  { replace: true, expectedVersion: version },
+);
+```
+
+An opaque block fails with `opaque_target`: the builder can read it but not rewrite it.
+
+## Move a Block
+
+`MoveBlock(path, dest, opts?)` moves a child block within its container or into another one.
+
+```typescript
+import { MoveBlock } from "@antelopejs/interface-dms-builder";
+
+await MoveBlock("/revenue#grid/row/total", {
+  parent: "/revenue#grid/footer",
+  index: 0,
+});
+```
+
+`MoveDest`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `parent` | `BlockPath` | The destination container. |
+| `slot` | `string` | The slot within the destination container. |
+| `index` | `number` | Position among the destination's children. Required. |
+
+The move is a child-into-container operation: the path must address a nested block, and `dest.parent` must name a container. Anything else — a top-level block, a destination without a `parent` — fails with `unsupported`. An out-of-range `index` is clamped with an `index_clamped` warning, and a destination that is opaque or missing fails with `opaque_target` or `not_found`.
+
+## Remove a Block
+
+`RemoveBlock(path, opts?)` deletes a block. A top-level block is removed as a static member; a nested one is dropped from its parent's `.child()` chain.
+
+```typescript
+import { RemoveBlock } from "@antelopejs/interface-dms-builder";
+
+const result = await RemoveBlock("/revenue#grid/row/total");
+if (result.ok) {
+  console.log(result.changes.map((change) => change.path));
+}
+```
+
+## Next Steps
+
+- [Resources](./5.resources.md) - Generate the tables and DataAPI controllers a page reads from
+- [Drafts and Preview](./9.drafts-and-preview.md) - Write a page's whole block tree in one transaction

package/docs/5.resources.md

@@ -0,0 +1,276 @@
+# Resources
+
+## Overview
+
+A resource is the data half of a DMS feature: a database `Table`, a `DataController` exposing it over HTTP, and the model that binds them. `CreateResource` writes all of it into a `<name>/` folder — `database.ts`, `data-api.ts` and an `index.ts` barrel — and wires the nearest barrel above so the project keeps a relative import chain to `src/index.ts`.
+
+You describe a resource in semantic terms: each field carries a DataType and a set of aspects such as *searchable* or *sortable*, and the engine maps those to the paired decorator stacks on the table and the controller. You never write a decorator yourself, and you never name one in a request.
+
+A resource is also what a controller-leading block points at: `AddBlock` with `controller: "<ref>"` emits the resource's DataAPI class as the block's leading argument, as described in [Page Operations](./4.page-operations.md).
+
+## Address a Resource and a Field
+
+`ResourceRef` is the resource's name in kebab form — `"product"`, `"order-line"`. It is what `CreateResource` returns, what `ListResources` reports, and what every other resource operation takes.
+
+`FieldPath` addresses one field within a resource: `<resourceRef>#<fieldName>`, e.g. `product#price`. `AddField` returns the path it created.
+
+```typescript
+import type {
+  FieldPath,
+  ResourceRef,
+} from "@antelopejs/interface-dms-builder";
+
+const resource: ResourceRef = "product";
+const field: FieldPath = "product#price";
+```
+
+## Create a Resource
+
+```typescript
+import { CreateResource } from "@antelopejs/interface-dms-builder";
+
+const result = await CreateResource({
+  name: "product",
+  displayName: "Product",
+  fields: [
+    {
+      name: "title",
+      dataType: { $dataType: "string" },
+      label: "Title",
+      required: true,
+      searchable: true,
+      sortable: true,
+    },
+    {
+      name: "price",
+      dataType: { $dataType: "number" },
+      sortable: true,
+      filterable: true,
+    },
+  ],
+});
+if (result.ok) {
+  console.log(result.data.ref, result.data.files.dataApi);
+}
+```
+
+`CreateResourceInput`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | The resource name. Required, and it must contain at least one alphanumeric character. A duplicate fails with `duplicate_name`. |
+| `fields` | `FieldSpec[]` | The resource's fields. Required. |
+| `displayName` | `string` | A human-readable name for the resource. |
+| `schema` | `string` | The database schema. Defaults to the DMS core schema, `CORE_SCHEMA_NAME` (`dms-core`). |
+| `seeds` | `Record<string, unknown>[]` | Rows to seed as a fixture. Each row must supply its own `_id`. |
+| `location` | `ResourceLocation` | Where the generated folder goes. Omit for `src/<name>/`. |
+| `routes` | `ResourceRoute[]` | Which DataAPI routes to expose. Omit for the full set. Must be non-empty when provided. |
+
+The names the engine derives from `name` are predictable: `product` yields a `Product` table class, a `ProductModel`, a `productDataAPI` controller on the route `/api/product`, and a `products` table.
+
+## Describe a Field
+
+`FieldSpec` is a `FieldAspects` plus the field's `name`. The name is immutable — renaming a field is `RemoveField` followed by `AddField`.
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | The field name. Rejected with `invalid_config` when it is one of the catalog's `reservedFieldNames`. |
+| `dataType` | `DataTypeValue` | The field's DataType, e.g. `{ $dataType: "string" }`. Required. |
+| `label` | `string` | Column header label. Defaults to the field name. |
+| `listable` | `boolean` | Selected and listed by the DataAPI. Default `true`. |
+| `searchable` | `boolean` | Included in full-text search. |
+| `sortable` | `boolean` | Sortable in the table view. |
+| `filterable` | `boolean` | Column-filterable in the table view. |
+| `access` | `"read" \| "readwrite"` | Field access mode. Default `"readwrite"`. |
+| `required` | `boolean` | Whether the field is required. Default `false`, which makes the field optional. |
+| `indexed` | `boolean` | Whether the table column is indexed. |
+| `order` | `number` | Display order of the column. |
+
+`dataType` takes a `DataTypeValue` sentinel, not a bare string; the ids come from the catalog's `dataTypes`. See [Value Encodings](./7.values.md) and [Catalog](./3.catalog.md).
+
+## Choose the Exposed Routes
+
+`ResourceRoute` names one group of DataAPI endpoints. Passing a subset lets a resource serve only what it needs — a singleton edit form wants `["get", "edit"]` and nothing else. An omitted route's HTTP endpoint is simply not registered.
+
+| Route | What it exposes |
+| --- | --- |
+| `list` | The paginated listing (`list` + `count`). |
+| `get` | Read a single row. |
+| `create` | Create a row. |
+| `edit` | Update a row. |
+| `delete` | Delete a row. |
+| `select` | Option lists for relation pickers that reference this resource. |
+| `archive` | Soft delete and undo (`archive` + `restore`). |
+| `export` | The export endpoints (`exportStart` / `exportStatus` / `exportDownload`). |
+
+```typescript
+import { CreateResource } from "@antelopejs/interface-dms-builder";
+
+await CreateResource({
+  name: "site-settings",
+  fields: [{ name: "title", dataType: { $dataType: "string" } }],
+  routes: ["get", "edit"],
+});
+```
+
+An empty array, or a name that is not one of the eight, fails with `invalid_config`.
+
+## Place the Generated Files
+
+`ResourceLocation` decides which folder the `<name>/` folder lands in. The nearest ancestor barrel to the resolved folder is the one that gets wired, with the root barrel as the fallback.
+
+| Form | Where the resource lands |
+| --- | --- |
+| omitted | `src/<name>/` |
+| `"reporting/data"` | `src/reporting/data/<name>/` — an explicit folder relative to the src root, which must stay inside the src tree. |
+| `{ category: "pages.reports" }` | The source folder of that category, mirroring page placement. A root category falls back to the src root. |
+| `{ page: "/revenue" }` | Inside that page's feature folder, so the page imports `./<name>/data-api`. |
+
+```typescript
+import { CreateResource } from "@antelopejs/interface-dms-builder";
+
+await CreateResource({
+  name: "revenue-entry",
+  fields: [{ name: "amount", dataType: { $dataType: "number" } }],
+  location: { page: "/revenue" },
+});
+```
+
+A `dir` string that escapes the src tree, an unknown category and an unknown page all fail with `invalid_config`.
+
+## Add, Configure and Remove a Field
+
+`AddField(ref, field, opts?)` appends a field to both generated files and returns its `FieldPath`.
+
+```typescript
+import { AddField } from "@antelopejs/interface-dms-builder";
+
+const result = await AddField("product", {
+  name: "sku",
+  dataType: { $dataType: "string" },
+  label: "SKU",
+  indexed: true,
+  searchable: true,
+});
+if (result.ok) {
+  console.log(result.data.path); // "product#sku"
+}
+```
+
+A name already present on the table or the controller fails with `duplicate_name`; a reserved name fails with `invalid_config`.
+
+`ConfigureField(path, patch, opts?)` reads the field's current aspects, merges your `Partial<FieldAspects>` over them, and rewrites both declarations from the result. Aspects you leave out keep their current value.
+
+```typescript
+import { ConfigureField } from "@antelopejs/interface-dms-builder";
+
+await ConfigureField("product#price", {
+  filterable: true,
+  order: 2,
+});
+```
+
+A field whose decorator stack the builder could not reverse — a hand-edited one, or one carrying a decorator the builder does not know — is opaque, and configuring it fails with `opaque_target`.
+
+`RemoveField(path, opts?)` drops the field from both files.
+
+```typescript
+import { RemoveField } from "@antelopejs/interface-dms-builder";
+
+await RemoveField("product#sku");
+```
+
+All three take a `MutationOpts`, whose `expectedVersion` is checked against the resource's version — a hash of both generated files.
+
+## List Resources
+
+`ListResources()` returns a `ResourceSummary[]` directly, without an `OpResult` wrapper.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `ref` | `ResourceRef` | The resource's ref. |
+| `className` | `string` | The generated table class name. |
+| `tableName` | `string` | The database table name. |
+| `route` | `string` | The DataAPI's base route. |
+| `fieldCount` | `number` | How many fields the resource has. |
+| `files` | `{ database: string; dataApi: string }` | The two source files. |
+
+```typescript
+import { ListResources } from "@antelopejs/interface-dms-builder";
+
+const resources = await ListResources();
+const refs = resources.map((resource) => resource.ref);
+```
+
+## Read a Resource's Structure
+
+`GetResourceStructure(ref)` returns an `OpResult<ResourceStructure>`. Like the other reads, its `changes` array is empty.
+
+```typescript
+import { GetResourceStructure } from "@antelopejs/interface-dms-builder";
+
+const result = await GetResourceStructure("product");
+if (result.ok) {
+  const editable = result.data.fields.filter((field) => !field.opaque);
+}
+```
+
+`ResourceStructure`:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `ref` | `ResourceRef` | The resource's ref. |
+| `className` | `string` | The generated table class name. |
+| `tableName` | `string` | The database table name. |
+| `route` | `string` | The DataAPI's base route. |
+| `schema` | `string` | The database schema the table is registered in. |
+| `files` | `ResourceFiles` | The resource's three files. |
+| `fields` | `ResourceFieldStructure[]` | The fields, in declaration order. |
+| `routes` | `ResourceRoute[]` | The exposed routes when the resource serves a subset; omitted when it serves the full set. Best-effort: absent for a hand-edited route map the engine could not map back to semantic names. |
+| `version` | `string` | A content hash of both generated files. |
+
+`ResourceFiles` names the three paths a resource is composed of: `database`, `dataApi` and `index`.
+
+`ResourceFieldStructure` is a `Partial<FieldAspects>` plus:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | The field name. Always present. |
+| `opaque` | `boolean` | `true` when the field's decorator stack could not be reversed. |
+| `opaqueReason` | `string` | Why it is opaque, e.g. an unsupported decorator or a missing `@Column` stack. Set when `opaque === true`. |
+
+A cleanly-reversed field carries its aspects; an opaque one carries only `name` and `opaqueReason`. Read `opaque` before offering a field for editing.
+
+## Delete a Resource
+
+`DeleteResource(ref, opts?)` deletes the three generated files, unwires every import of them, removes the folder if it is now empty, and — by default — clears the resource's database table so a later resource reusing the name re-seeds cleanly instead of inheriting stale documents.
+
+```typescript
+import { DeleteResource } from "@antelopejs/interface-dms-builder";
+
+const result = await DeleteResource("product");
+if (result.ok) {
+  for (const warning of result.warnings ?? []) {
+    console.log(warning.code, warning.message);
+  }
+}
+```
+
+`DeleteResourceOpts` extends `MutationOpts`:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `keepData` | `boolean` | Leave the resource's table data in place instead of deleting every row. |
+| `expectedVersion` | `string` | The `ResourceStructure.version` you last read. A mismatch fails with `stale`. |
+
+When the rows cannot be dropped, the operation still succeeds and attaches a `data_not_dropped` warning naming the reason — the source is gone, the data may not be.
+
+```typescript
+import { DeleteResource } from "@antelopejs/interface-dms-builder";
+
+await DeleteResource("product", { keepData: true });
+```
+
+## Next Steps
+
+- [Queries](./6.queries.md) - Derive counts and aggregates from a resource and serve them from a page