foldkit-crud 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Glenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,287 @@
+# foldkit-crud
+
+The screens that create, read, update and delete, assembled from parts an
+application already has. They are for any such screen, a user editing their own
+post as much as a back office, and they draw nothing. An
+**editor** joins a [`foldkit-form`](../form/README.md) form, the
+[`foldkit-remote`](../remote/README.md) mutation its value feeds, and the
+[`foldkit-entity`](../entity/README.md) Entity they share. A **list** joins a
+Remote query and an Entity Selection, a **detail** reads one Entity through a
+Selection, and a **remover** deletes through a mutation with a yes in between.
+
+> **Status:** an editor (edit and create), a list, a detail, and a remover. All
+> are headless, as the form is. [`examples/entity`](../../examples/entity) draws
+> them and runs in a browser.
+
+## What it owns
+
+An editor adds no state system and no runtime. It is the glue between three
+things that each already own their part:
+
+| Fact | Owner |
+| --- | --- |
+| The drafts and whether they are valid | the form |
+| The current values, and whether a save is pending, applied, or failed | Remote, in its store |
+| What to load, and how a loaded value becomes input values | the form's input (`Entity.selectFor`, `Entity.valuesFor`) |
+| Which id is being edited, whether it has been shown, which save is this editor's | the editor, in its slice of the parent Model |
+| What happens after a save (navigate, close, toast) | the application, reading `status` |
+
+Nothing is generated from an Entity alone. An editor exists because you named a
+form and a mutation; an Entity with neither has no editor.
+
+## Mental model
+
+```text
+open(id)
+   |  the members the form writes become a requirement, like a Surface's
+   v
+Remote fetches ──► the value arrives ──► sync fills the form, once
+   |
+   v
+the user edits ──► Submitted ──► the form hands over a decoded value
+   |
+   v
+onOut ──► Data.mutate ──► Remote settles it ──► status: Saving ─► Saved / SaveFailed
+```
+
+`status` is derived, not stored: it reads the editor's slice, Remote's mutation
+state, and the loaded value, so it cannot disagree with them.
+
+## Install
+
+```sh
+pnpm add effect foldkit foldkit-crud foldkit-bundle foldkit-entity foldkit-form foldkit-remote foldkit-surface
+```
+
+## Example
+
+`EditPostForm` is a `Form.make` result and `EditPostMutation` a Remote mutation
+over the same input struct, as in [`examples/entity`](../../examples/entity).
+
+```ts
+import { Crud } from 'foldkit-crud'
+import { Bundle } from 'foldkit-bundle'
+import { defineMessageUnion } from 'foldkit/message'
+import { Remote, type RemoteClient } from 'foldkit-remote'
+import { Surface } from 'foldkit-surface'
+
+const Editor = Crud.editor('PostEditor', { form: EditPostForm, mutation: EditPostMutation })
+
+// The editor is a Submodel of the page: a Model field and a Message variant.
+const Slot = Bundle.declare(Editor.bundle, 'editor')
+const Model = Schema.Struct({ remote: Remote.Model, ...Slot.fields })
+const Message = defineMessageUnion({ ...Remote.messages, ...Slot.cases })
+
+const App = Surface.application({ Model, Message })
+const Data = Remote.make({
+  model: App.model.remote,
+  entities: Object.values(Blog),
+  mutations: [EditPostMutation],
+})
+
+// Where it lives: its slice of the Model, and the domain it saves through.
+const PostEditor = Editor.at({ data: Data, model: App.model.editor })
+
+const Page = Bundle.parent({ Model, Message }).withServices<RemoteClient>()
+const Placed = Page.at(Slot, { onOut: PostEditor.onOut })
+const placements = Page.assemble(Placed)
+
+const update = PostEditor.after(
+  placements.update((model, message) =>
+    Remote.reduces(message) ? { model: Data.reduce(model, message) } : { model },
+  ),
+)
+
+const subscriptions = Data.subscriptions({ editor: PostEditor.active })
+```
+
+- `Crud.editor` checks that the form's value is the mutation's input. Declaring
+  the input struct once and giving it to both is what makes that true.
+- `Editor.bundle` wraps the form's Bundle. Its Messages are the form's own, so a
+  view dispatches `EditPostForm.Message.Changed(...)` exactly as before.
+- `Editor.at` needs the editor's slice as a `ModelRef` (`App.model.editor`) and
+  the bound Remote domain. It returns the pieces that need the parent:
+  - `onOut` for the placement: a valid submit becomes `Data.mutate`, and the
+    editor remembers the request id.
+  - `active`, an `ActiveSurface` for `Data.subscriptions`: while an id is open,
+    what the form writes is fetched and retained like any Surface's requirement.
+  - `after(update)`: wraps `update` so `sync` runs after every Message.
+  - `sync`, the Step itself, if you compose `update` another way.
+  - `status(model)`, and `saveError(model)` while it is `SaveFailed`.
+- The save is a Command that needs `RemoteClient`, so the parent scope names it
+  with `withServices<RemoteClient>()`.
+
+### Drawing it
+
+The editor wraps the form's Model, so it takes the form's view, lifted:
+
+```ts
+import { FormView } from 'foldkit-mixins-form'
+
+const Slot = Bundle.declare(
+  Editor.bundle.pipe(
+    Bundle.withView(Crud.editorView(FormView.submodel(EditPostForm, FormView.define(EditPostForm)))),
+  ),
+  'editor',
+)
+
+// where the page draws it:
+Placed.view(model, h, { options: pickers(model), submitLabel: 'Save' })
+```
+
+`Crud.editorView` works on any Submodel view of the form that takes view
+inputs; `foldkit-crud` itself stays headless.
+
+### Opening it
+
+`open`, `blank`, and `close` are helpers of the placement, so they are Update
+Steps to use from your own `update`:
+
+```ts
+Placed.helpers.open('p2') // edit p2: the form empties, then fills when the value arrives
+Placed.helpers.blank() // a new one: nothing to load, editing at once
+Placed.helpers.close()
+```
+
+One editor serves one form. A create form and an edit form usually differ (the
+edit input has an `id`), so they are two editors; `blank` is for the one whose
+form creates.
+
+## Status
+
+| Status | When |
+| --- | --- |
+| `Closed` | nothing is open |
+| `Loading` | an id is open and its current values have not arrived |
+| `NotFound` | it is gone: the server answered without it, a mutation deleted it, or a live event did. This outranks a save that landed |
+| `LoadFailed` | reading it failed to decode |
+| `Editing` | the form is showing, with no save in progress or just settled |
+| `Saving` | this editor's mutation is pending |
+| `Saved` | it was applied |
+| `SaveFailed` | it failed; the drafts are kept, and `saveError(model)` says why |
+
+An edit after a save returns to `Editing`: the last save no longer describes what
+is in the form.
+
+## Behaviour worth knowing
+
+- **The form is filled once.** When the value is read again (a refresh, a live
+  update) the drafts are left alone, so nothing the user typed is overwritten.
+  Opening the same or another id empties the form and fills it again.
+- **What is loaded is what the form writes**, with each relation as a ref. A key
+  the form marks `Entity.unmapped` is not loaded and starts empty.
+- **An invalid submit starts no mutation.** The form emits nothing until every
+  key passes the input's schema and its checks. The form's Commands are the
+  editor's, so a check the form starts runs.
+
+## Lists
+
+A list is one query and one Selection: the query decides which rows, the
+Selection what to show of each. The pages live in Remote, so a list holds no
+state of its own and is not a Bundle.
+
+```ts
+const Authors = Crud.list('Authors', {
+  query: AuthorsQuery, // Query.make('Authors', { Input: { search }, Result: Query.connection(Blog.Author) })
+  selection: Entity.select(Blog.Author, { id: true, name: true }),
+  pageSize: 25,
+  // How a row reads as a choice, for a list that feeds relation pickers.
+  choice: { value: row => row.id, label: row => row.name },
+})
+
+const AuthorList = Authors.at({
+  data: Data,
+  // The query's input as the Model has it; `undefined` while the list is not shown.
+  input: model => (model.search === null ? undefined : { search: model.search }),
+})
+
+const subscriptions = Data.subscriptions({ authors: AuthorList.active })
+```
+
+- `Authors.columns` is the selected members in the Selection's order, each with
+  its `key`, `member`, and a `label` found the way a form finds one: the schema's
+  `title`, else `Form.label` metadata, else the key.
+- `AuthorList.page(model)` is a `RemoteData` of the page: `items` typed by the
+  Selection, `hasNext`, `hasPrevious`.
+- `AuthorList.more(model)` is the Command that loads the next page onto this one,
+  or `undefined` when there is none. Return it from `update`.
+- `AuthorList.active` makes the page and its rows a requirement while `input`
+  gives a value, so Remote fetches and retains them. Another input is another
+  connection.
+
+### A relation picker's choices
+
+A form names a relation's target Entity and leaves listing it to you, because a
+relationship existing is no licence to read a table. A list is that licence: a
+query you declared and your server authorizes. A list with a `choice` offers its
+loaded rows as choices, and `Crud.options` hands each picker of a form the list
+over its target:
+
+```ts
+const pickers = Crud.options(EditPostForm, [AuthorList])
+
+Placed.view(model, h, { options: pickers(model) }) // with foldkit-mixins-form
+```
+
+`pickers(model)` is keyed by the form's keys: `{ authorId: [{ value, label }, …] }`.
+A list is matched to a picker by Entity, so one author list serves `authorId`
+and `editorId` alike. A picker whose target no list is over, or whose list has no `choice`, throws
+when `Crud.options` is called, not when the form is drawn. `AuthorList.choices(model)`
+is one list's choices on its own. Both are empty until the page is loaded, and
+hold only the rows loaded so far.
+
+## Deleting
+
+A remover is a mutation with a yes in between. Like the editor it is a Bundle,
+because which id is being asked about is state.
+
+```ts
+const Remover = Crud.remover('PostRemover', {
+  mutation: DeletePostMutation,
+  input: id => ({ id }), // the mutation's input for an id
+})
+const RemoveSlot = Bundle.declare(Remover.bundle, 'remover')
+// ...spread RemoveSlot.fields and RemoveSlot.cases into the page's Model and Message...
+
+const PostRemover = Remover.at({ data: Data, model: App.model.remover })
+const RemoveForm = Page.at(RemoveSlot, { onOut: PostRemover.onOut })
+```
+
+- `RemoveForm.helpers.ask(id)` asks; nothing is deleted yet. `dismiss()` clears it.
+- `Remover.Message.Confirmed()` and `Cancelled()` are the yes and the no. A yes
+  with nothing asked does nothing.
+- `PostRemover.status(model)` is `Idle`, `Confirming`, `Deleting`, `Deleted`, or
+  `DeleteFailed`; `target(model)` is the id for the confirmation's words, and
+  `error(model)` says why a delete failed.
+
+The server's mutation says what is gone, with `deleted` in its outcome, and
+names no list. Remote then knows the entity absent: it leaves every list and
+relation it was in with no refetch, a detail of it reads `NotFound`, and an
+editor open on it reports `NotFound`.
+
+## Detail
+
+One Entity through a Selection, for a page that shows it. Like a list it holds no
+state.
+
+```ts
+const PostDetail = Crud.detail('PostDetail', { selection: PostPage }).at({
+  data: Data,
+  id: model => model.shownPostId ?? undefined, // `undefined` while none is shown
+})
+
+PostDetail.value(model) // RemoteData of the Selection's value
+```
+
+`Crud.detail(...).fields` lists the selected members with their labels, as a
+list's `columns` does, and `PostDetail.active` makes the value a requirement
+while an id is shown.
+
+## Limits
+
+- A list has no sorting, filtering, or selection state of its own: those are the
+  query's input, which your Model holds.
+- Headless. Draw the editor with `Crud.editorView` over a
+  [`foldkit-mixins-form`](../mixins-form/README.md) view, or from
+  `EditPostForm.controls`. [`examples/entity`](../../examples/entity) draws a
+  list and an editor, and runs in a browser.

package/dist/index.d.mts

@@ -0,0 +1,318 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import { AnyEntity, EntityInput, EntityMember, Selection } from "foldkit-entity";
+import { FormControl, Submitted } from "foldkit-form";
+import * as Submodel from "foldkit/submodel";
+import { MutationDescriptor, MutationStatus, Page, QueryDescriptor, RemoteClient, RemoteData, RemoteError, RemoteMessage } from "foldkit-remote";
+import { ModelRef, Projection } from "foldkit-surface";
+import { Command } from "foldkit/command";
+import * as Update from "foldkit/update";
+//#region src/index.d.ts
+/** The parts of a `Form.make` result an editor wraps. */
+export interface EditableForm<Name extends string, FormModel, FormMessage, Value, E extends AnyEntity, Fields extends Schema.Struct.Fields, Members, R = never> {
+  readonly bundle: {
+    readonly name: Name;
+    readonly Model: Schema.Codec<FormModel, unknown>;
+    readonly Message: Schema.Codec<FormMessage, unknown>;
+    readonly update: (model: FormModel, message: FormMessage, args: void) => Update.ReturnWithOutMessage<FormModel, FormMessage, Submitted<Value>, R>;
+  };
+  readonly input: EntityInput<E, Fields, Members>;
+  readonly initial: FormModel;
+  readonly fill: (model: FormModel, values: Partial<Value>) => {
+    readonly model: FormModel;
+  };
+}
+/**
+ * An editor's slice of the parent Model. `target` is the id being edited, or
+ * `null` for a new one; `filled` is whether the loaded value has been shown;
+ * `requestId` is the save in progress or last settled.
+ */
+export interface EditorModel<FormModel> {
+  readonly form: FormModel;
+  readonly mode: 'closed' | 'new' | 'edit';
+  readonly target: string | null;
+  readonly filled: boolean;
+  readonly requestId: string | null;
+}
+/**
+ * A remover's slice of the parent Model: the id it was asked to delete and is
+ * waiting on a yes for, and the delete in progress or last settled.
+ */
+export interface RemoverModel {
+  readonly target: string | null;
+  readonly requestId: string | null;
+}
+/** A remover's out Message: the user said yes to deleting `id`. */
+export interface ConfirmedRemoval {
+  readonly _tag: 'Confirmed';
+  readonly id: string;
+}
+export type RemoverStatus = 'Idle' |
+/** Asked to delete an id, and waiting for a yes or a no. */
+'Confirming' | 'Deleting' | 'Deleted' | 'DeleteFailed';
+export type EditorStatus = 'Closed' |
+/** Editing an id whose current values have not arrived. */
+'Loading' | 'NotFound' | 'LoadFailed' | 'Editing' | 'Saving' | 'Saved' | 'SaveFailed';
+/** The parts of a bound Remote domain an editor uses. */
+export interface DomainLike<Root> {
+  mutate(model: Root, mutation: any, input: any): {
+    readonly model: Root;
+    readonly requestId: string;
+    readonly command: Command<RemoteMessage, never, RemoteClient>;
+  };
+  get(selection: any, id: string): Projection<Root, RemoteData<any>>;
+  query(query: any, input: any, options: any): Projection<Root, RemoteData<Page<any>>>;
+  next(model: Root, projection: any): {
+    readonly query: string;
+  } | undefined;
+  fetch(ref: any): Command<RemoteMessage, never, RemoteClient>;
+  mutation(model: Root, requestId: string): MutationStatus;
+  readonly contract: {
+    readonly owner?: object | undefined;
+  };
+}
+type Step<Root> = Update.Step<Root, RemoteMessage, RemoteClient>;
+/** One thing a relation picker offers. */
+export interface Choice {
+  readonly value: string;
+  readonly label: string;
+}
+/** One column of a list, or one line of a detail: a member the Selection reads. */
+export interface ListColumn<Key extends string = string> {
+  readonly key: Key;
+  /** The schema's `title` annotation, else `Form.label` metadata, else the key. */
+  readonly label: string;
+  readonly member: EntityMember;
+}
+export declare const Crud: {
+  /**
+   * One Entity read through a Selection, for a page that shows it. Like a list
+   * it holds no state: the value is Remote's and the id is the application's.
+   */
+  detail: <const Name extends string, EntityName extends string, Members, Row>(name: Name, config: {
+    readonly selection: Selection<EntityName, Members, Schema.Constraint & {
+      readonly Type: Row;
+    }>;
+  }) => {
+    name: Name;
+    /** The selected members in the Selection's order, each with its label. */
+    fields: readonly ListColumn<keyof Members & string>[];
+    /** The detail where it lives: `id` is the one shown, or `undefined` while none is. */
+    at: <Root>(where: {
+      readonly data: DomainLike<Root>;
+      readonly id: (root: Root) => string | undefined;
+    }) => {
+      /** For `Data.subscriptions`: the value is fetched and retained while an id is shown. */
+      active: {
+        name: Name;
+        owner: object;
+        projectionOf: (root: Root) => Projection<Root, RemoteData<any>> | undefined;
+      };
+      value: (root: Root) => RemoteData<Row>;
+    };
+  };
+  /**
+   * Deleting through one mutation, with a yes in between: asked, confirmed,
+   * deleted. What the mutation's input is for an id is `input`'s to say.
+   */
+  remover: <const Name extends string, Input>(name: Name, config: {
+    readonly mutation: MutationDescriptor<string, Input, any>;
+    readonly input: (id: string) => Input;
+  }) => {
+    bundle: Bundle.Bundle<Name, void, RemoverModel, {
+      readonly _tag: "Confirmed";
+    } | {
+      readonly _tag: "Cancelled";
+    }, ConfirmedRemoval, never, never, void, {}, {
+      /** Asks whether to delete `id`. Nothing is deleted until `Confirmed`. */
+      ask: (_: RemoverModel, id: string) => {
+        model: {
+          target: string;
+          requestId: null;
+        };
+      };
+      dismiss: () => {
+        model: RemoverModel;
+      };
+    }>;
+    /** The remover's Messages, for the yes and the no of a confirmation. */
+    Message: import("foldkit/message").MessageUnion<{
+      readonly Confirmed: {};
+      readonly Cancelled: {};
+    }>;
+    at: <Root>(where: {
+      readonly data: DomainLike<Root>;
+      readonly model: ModelRef<Root, RemoverModel>;
+    }) => {
+      /** For the placement: a yes becomes the mutation, and its request is remembered. */
+      onOut: (confirmed: ConfirmedRemoval) => Step<Root>;
+      /** The id being asked about or deleted, for the words of a confirmation. */
+      target: (root: Root) => string | null;
+      status: (root: Root) => RemoverStatus;
+      /** Why the last delete failed, while `status` is `DeleteFailed`. */
+      error: (root: Root) => RemoteError | undefined;
+    };
+  };
+  /**
+   * A list over one query: which rows to show is the query's, what to show of
+   * each is the Selection's. The pages live in Remote; the list holds no state.
+   */
+  list: <const Name extends string, EntityName extends string, Members, Row, Input>(name: Name, config: {
+    readonly query: QueryDescriptor<string, Input, any>;
+    readonly selection: Selection<EntityName, Members, Schema.Constraint & {
+      readonly Type: Row;
+    }>;
+    /** How many rows a page holds. Default 25. */
+    readonly pageSize?: number;
+    /**
+     * How a row reads as a choice in a relation picker: its id, and the words
+     * that identify it to a person. Give it to a list that feeds pickers.
+     */
+    readonly choice?: {
+      readonly value: (row: Row) => string;
+      readonly label: (row: Row) => string;
+    };
+  }) => {
+    name: Name;
+    /** The selected members in the Selection's order, each with its label. */
+    columns: readonly ListColumn<keyof Members & string>[];
+    /**
+     * The list where it lives. `input` is the query's input as the Model has
+     * it (filters, a search term), or `undefined` while the list is not shown.
+     */
+    at: <Root>(where: {
+      readonly data: DomainLike<Root>;
+      readonly input: (root: Root) => Input | undefined;
+    }) => {
+      /** For `Data.subscriptions`: the page and its rows are fetched and retained while shown. */
+      active: {
+        name: Name;
+        owner: object;
+        projectionOf: (root: Root) => Projection<Root, RemoteData<Page<any>>> | undefined;
+      };
+      page: (root: Root) => RemoteData<Page<Row>>;
+      /** The Command that loads the next page onto this one, or `undefined` when there is none. */
+      more: (root: Root) => Command<RemoteMessage, never, RemoteClient> | undefined;
+      name: Name;
+      /** The Entity the rows are of, which is how a picker finds the list for its target. */
+      entity: AnyEntity;
+      /** Whether the list was given a `choice`, so its rows can be a picker's choices. */
+      offersChoices: boolean;
+      /**
+       * The loaded rows as a picker's choices, read through `choice`. Listing a
+       * relation's target is this query, which the application chose and the
+       * server authorizes; nothing is read because a relation exists.
+       */
+      choices: (root: Root) => ReadonlyArray<Choice>;
+    };
+  };
+  /**
+   * A form's Submodel view as the view of the editor that wraps it, for
+   * `Bundle.withView`: the editor's Messages are the form's, and its Model holds
+   * the form's under `form`.
+   *
+   * ```ts
+   * Editor.bundle.pipe(Bundle.withView(Crud.editorView(FormView.submodel(form, view))))
+   * ```
+   */
+  editorView: <FormModel, Message, ViewInputs>(view: Submodel.View<FormModel, Message, ViewInputs>) => Submodel.View<EditorModel<FormModel>, Message, ViewInputs>;
+  /**
+   * The choices of every relation picker in a form, from the lists of their
+   * targets: `foldkit-mixins-form`'s `options`, keyed by the form's keys. A
+   * picker whose target no list here is over is a wiring mistake, reported now.
+   */
+  options: <Key extends string, Root>(form: {
+    readonly controls: ReadonlyArray<FormControl<Key>>;
+  }, lists: ReadonlyArray<{
+    readonly name: string;
+    readonly entity: AnyEntity;
+    readonly offersChoices: boolean;
+    readonly choices: (root: Root) => ReadonlyArray<Choice>;
+  }>) => ((root: Root) => { readonly [K in Key]?: ReadonlyArray<Choice>; });
+  /**
+   * An editor for one form and the mutation its value feeds. The form's value
+   * must be the mutation's input, which is what declaring the input once and
+   * giving it to both guarantees.
+   */
+  editor: <const Name extends string, FormName extends string, FormModel, FormMessage extends {
+    readonly _tag: string;
+  }, Value, E extends AnyEntity, Fields extends Schema.Struct.Fields, Members, R = never>(name: Name, config: {
+    readonly form: EditableForm<FormName, FormModel, FormMessage, Value, E, Fields, Members, R>;
+    readonly mutation: MutationDescriptor<string, Value, any>;
+  }) => {
+    bundle: Bundle.Bundle<Name, void, EditorModel<FormModel>, FormMessage, Submitted<Value>, R, never, void, {}, {
+      /** Edits `id`: the form is emptied, and filled once the current values arrive. */
+      open: (_: EditorModel<FormModel>, id: string) => {
+        model: {
+          mode: "edit";
+          target: string;
+          form: FormModel;
+          filled: boolean;
+          requestId: string | null;
+        };
+      };
+      /** A blank form for a new one: nothing to load. */
+      blank: () => {
+        model: {
+          mode: "new";
+          filled: boolean;
+          form: FormModel;
+          target: string | null;
+          requestId: string | null;
+        };
+      };
+      close: () => {
+        model: EditorModel<FormModel>;
+      };
+    }>;
+    /** What the editor loads before it shows the form: every member the form writes. */
+    selection: Selection<E["name"], import("foldkit-entity").WrittenSpec<Members>, Schema.Struct<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> | import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends import("foldkit-entity").SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
+      readonly items: Schema.$Array<S_1>;
+      readonly hasNext: Schema.Boolean;
+      readonly hasPrevious: Schema.Boolean;
+    }> : C extends "many" ? Schema.$Array<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint> ? S_2 : Schema.Struct<{
+      readonly entity: Schema.Literal<Target["name"]>;
+      readonly id: Schema.String;
+    }>> : Optional extends true ? Schema.NullOr<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint> ? S_2 : Schema.Struct<{
+      readonly entity: Schema.Literal<Target["name"]>;
+      readonly id: Schema.String;
+    }>> : T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint> ? S_2 : Schema.Struct<{
+      readonly entity: Schema.Literal<Target["name"]>;
+      readonly id: Schema.String;
+    }> : never : never : never : never : never; }>>;
+    /**
+     * The editor where it lives: `model` is its slice of the parent Model (the
+     * field it was declared at), and `data` the Remote domain that registers the
+     * mutation and the Entity.
+     */
+    at: <Root>(where: {
+      readonly data: DomainLike<Root>;
+      readonly model: ModelRef<Root, EditorModel<FormModel>>;
+    }) => {
+      /** For the placement: a valid submit becomes the mutation, and its request is remembered. */
+      onOut: (submitted: Submitted<Value>) => Step<Root>;
+      /**
+       * For `Data.subscriptions`: while an id is being edited, what it loads is
+       * a requirement like any Surface's, so Remote fetches and retains it.
+       */
+      active: {
+        name: Name;
+        owner: object;
+        projectionOf: (root: Root) => Projection<Root, RemoteData<any>> | undefined;
+      };
+      sync: Update.Step<Root, never, never>;
+      /**
+       * Wraps the application's `update` so `sync` runs after every Message:
+       * the value may arrive with any of them.
+       */
+      after: <Message, Result extends {
+        readonly model: Root;
+      }>(update: (model: Root, message: Message) => Result) => (model: Root, message: Message) => Result;
+      /** Why the last save failed, while `status` is `SaveFailed`. */
+      saveError: (root: Root) => RemoteError | undefined;
+      status: (root: Root) => EditorStatus;
+    };
+  };
+};
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,371 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import { Entity } from "foldkit-entity";
+import { Form } from "foldkit-form";
+import { defineMessageUnion } from "foldkit/message";
+import * as Submodel from "foldkit/submodel";
+//#region src/index.ts
+/**
+* `foldkit-crud` — management screens assembled from parts an application
+* already has.
+*
+* An editor joins a `foldkit-form` form, the Remote mutation its value feeds,
+* and the Entity they share: it loads what the form writes, shows it, turns a
+* valid submit into the mutation, and says how that went. Everything it makes is
+* ordinary Foldkit: a Bundle, an ActiveSurface, Update Steps. Nothing is
+* generated from an Entity alone; each capability is declared.
+*/
+const columnLabel = (key, member) => {
+	const title = member._tag === "Relation" ? void 0 : Schema.resolveAnnotations(member.schema)?.title;
+	return typeof title === "string" ? title : Form.labelOf(member) ?? key;
+};
+/** The selected members in the Selection's order, each with its label. */
+const columnsOf = (selection) => {
+	const members = selection.entity.members;
+	return Object.keys(selection.members).map((key) => ({
+		key,
+		label: columnLabel(key, members[key]),
+		member: members[key]
+	}));
+};
+const RemoverMessage = defineMessageUnion({
+	Confirmed: {},
+	Cancelled: {}
+});
+const idle = {
+	target: null,
+	requestId: null
+};
+const Crud = {
+	/**
+	* One Entity read through a Selection, for a page that shows it. Like a list
+	* it holds no state: the value is Remote's and the id is the application's.
+	*/
+	detail: (name, config) => ({
+		name,
+		/** The selected members in the Selection's order, each with its label. */
+		fields: columnsOf(config.selection),
+		/** The detail where it lives: `id` is the one shown, or `undefined` while none is. */
+		at: (where) => {
+			const projectionOf = (root) => {
+				const id = where.id(root);
+				return id === void 0 ? void 0 : where.data.get(config.selection, id);
+			};
+			return {
+				/** For `Data.subscriptions`: the value is fetched and retained while an id is shown. */
+				active: {
+					name,
+					owner: where.data.contract.owner ?? {},
+					projectionOf
+				},
+				value: (root) => projectionOf(root)?.read(root) ?? { _tag: "Initial" }
+			};
+		}
+	}),
+	/**
+	* Deleting through one mutation, with a yes in between: asked, confirmed,
+	* deleted. What the mutation's input is for an id is `input`'s to say.
+	*/
+	remover: (name, config) => {
+		return {
+			bundle: Bundle.make(name, {
+				Model: Schema.Struct({
+					target: Schema.NullOr(Schema.String),
+					requestId: Schema.NullOr(Schema.String)
+				}),
+				Message: RemoverMessage,
+				init: () => ({ model: idle }),
+				update: (model, message) => message._tag === "Cancelled" || model.target === null ? { model: idle } : {
+					model,
+					outMessage: {
+						_tag: "Confirmed",
+						id: model.target
+					}
+				},
+				helpers: {
+					/** Asks whether to delete `id`. Nothing is deleted until `Confirmed`. */
+					ask: (_, id) => ({ model: {
+						target: id,
+						requestId: null
+					} }),
+					dismiss: () => ({ model: idle })
+				}
+			}),
+			/** The remover's Messages, for the yes and the no of a confirmation. */
+			Message: RemoverMessage,
+			at: (where) => {
+				const { data, model: slice } = where;
+				const outcome = (root) => {
+					const { requestId } = slice.get(root);
+					return requestId === null ? { _tag: "Unknown" } : data.mutation(root, requestId);
+				};
+				return {
+					/** For the placement: a yes becomes the mutation, and its request is remembered. */
+					onOut: (confirmed) => (root) => {
+						const started = data.mutate(root, config.mutation, config.input(confirmed.id));
+						return {
+							model: slice.set(started.model, {
+								target: confirmed.id,
+								requestId: started.requestId
+							}),
+							commands: [started.command]
+						};
+					},
+					/** The id being asked about or deleted, for the words of a confirmation. */
+					target: (root) => slice.get(root).target,
+					status: (root) => {
+						const { target } = slice.get(root);
+						const deleting = outcome(root);
+						return deleting._tag === "Pending" ? "Deleting" : deleting._tag === "Applied" ? "Deleted" : deleting._tag === "Failed" ? "DeleteFailed" : target === null ? "Idle" : "Confirming";
+					},
+					/** Why the last delete failed, while `status` is `DeleteFailed`. */
+					error: (root) => {
+						const deleting = outcome(root);
+						return deleting._tag === "Failed" ? deleting.error : void 0;
+					}
+				};
+			}
+		};
+	},
+	/**
+	* A list over one query: which rows to show is the query's, what to show of
+	* each is the Selection's. The pages live in Remote; the list holds no state.
+	*/
+	list: (name, config) => {
+		const { query, selection, pageSize = 25, choice } = config;
+		return {
+			name,
+			/** The selected members in the Selection's order, each with its label. */
+			columns: columnsOf(selection),
+			/**
+			* The list where it lives. `input` is the query's input as the Model has
+			* it (filters, a search term), or `undefined` while the list is not shown.
+			*/
+			at: (where) => {
+				const { data, input } = where;
+				const projectionOf = (root) => {
+					const value = input(root);
+					return value === void 0 ? void 0 : data.query(query, value, {
+						select: selection,
+						first: pageSize
+					});
+				};
+				const page = (root) => projectionOf(root)?.read(root) ?? { _tag: "Initial" };
+				return {
+					/** For `Data.subscriptions`: the page and its rows are fetched and retained while shown. */
+					active: {
+						name,
+						owner: data.contract.owner ?? {},
+						projectionOf
+					},
+					page,
+					/** The Command that loads the next page onto this one, or `undefined` when there is none. */
+					more: (root) => {
+						const projection = projectionOf(root);
+						const next = projection === void 0 ? void 0 : data.next(root, projection);
+						return next === void 0 ? void 0 : data.fetch(next);
+					},
+					name,
+					/** The Entity the rows are of, which is how a picker finds the list for its target. */
+					entity: selection.entity,
+					/** Whether the list was given a `choice`, so its rows can be a picker's choices. */
+					offersChoices: choice !== void 0,
+					/**
+					* The loaded rows as a picker's choices, read through `choice`. Listing a
+					* relation's target is this query, which the application chose and the
+					* server authorizes; nothing is read because a relation exists.
+					*/
+					choices: (root) => {
+						if (choice === void 0) throw new Error(`Crud list "${name}": give it a "choice" to use its rows in a picker`);
+						const read = page(root);
+						return read._tag === "Ready" || read._tag === "Refreshing" ? read.value.items.map((row) => ({
+							value: choice.value(row),
+							label: choice.label(row)
+						})) : [];
+					}
+				};
+			}
+		};
+	},
+	/**
+	* A form's Submodel view as the view of the editor that wraps it, for
+	* `Bundle.withView`: the editor's Messages are the form's, and its Model holds
+	* the form's under `form`.
+	*
+	* ```ts
+	* Editor.bundle.pipe(Bundle.withView(Crud.editorView(FormView.submodel(form, view))))
+	* ```
+	*/
+	editorView: (view) => Submodel.defineView(((model, inputs, h) => view(model.form, inputs, h))),
+	/**
+	* The choices of every relation picker in a form, from the lists of their
+	* targets: `foldkit-mixins-form`'s `options`, keyed by the form's keys. A
+	* picker whose target no list here is over is a wiring mistake, reported now.
+	*/
+	options: (form, lists) => {
+		const pickers = form.controls.flatMap(({ key, control }) => {
+			if (control._tag !== "RelationOne" && control._tag !== "RelationMany") return [];
+			const list = lists.find((candidate) => Entity.same(candidate.entity, control.target));
+			if (list === void 0) throw new Error(`Crud.options: "${key}" picks a ${control.target.name}, and no list given is over ${control.target.name}`);
+			if (!list.offersChoices) throw new Error(`Crud.options: "${key}" would pick from list "${list.name}", which has no "choice"`);
+			return [[key, list]];
+		});
+		return (root) => Object.fromEntries(pickers.map(([key, list]) => [key, list.choices(root)]));
+	},
+	/**
+	* An editor for one form and the mutation its value feeds. The form's value
+	* must be the mutation's input, which is what declaring the input once and
+	* giving it to both guarantees.
+	*/
+	editor: (name, config) => {
+		const { form, mutation } = config;
+		const closed = {
+			form: form.initial,
+			mode: "closed",
+			target: null,
+			filled: false,
+			requestId: null
+		};
+		const Model = Schema.Struct({
+			form: form.bundle.Model,
+			mode: Schema.Literals([
+				"closed",
+				"new",
+				"edit"
+			]),
+			target: Schema.NullOr(Schema.String),
+			filled: Schema.Boolean,
+			requestId: Schema.NullOr(Schema.String)
+		});
+		const bundle = Bundle.make(name, {
+			Model,
+			Message: form.bundle.Message,
+			init: () => ({ model: closed }),
+			update: (model, message) => {
+				const next = form.bundle.update(model.form, message, void 0);
+				const requestId = message._tag === "Changed" ? null : model.requestId;
+				const edited = {
+					model: {
+						...model,
+						form: next.model,
+						requestId
+					},
+					...next.commands === void 0 ? {} : { commands: next.commands }
+				};
+				return next.outMessage === void 0 ? edited : {
+					...edited,
+					outMessage: next.outMessage
+				};
+			},
+			helpers: {
+				/** Edits `id`: the form is emptied, and filled once the current values arrive. */
+				open: (_, id) => ({ model: {
+					...closed,
+					mode: "edit",
+					target: id
+				} }),
+				/** A blank form for a new one: nothing to load. */
+				blank: () => ({ model: {
+					...closed,
+					mode: "new",
+					filled: true
+				} }),
+				close: () => ({ model: closed })
+			}
+		});
+		const current = Entity.selectFor(form.input);
+		return {
+			bundle,
+			/** What the editor loads before it shows the form: every member the form writes. */
+			selection: current,
+			/**
+			* The editor where it lives: `model` is its slice of the parent Model (the
+			* field it was declared at), and `data` the Remote domain that registers the
+			* mutation and the Entity.
+			*/
+			at: (where) => {
+				const { data, model: slice } = where;
+				const loaded = (root) => {
+					const { mode, target } = slice.get(root);
+					return mode === "edit" && target !== null ? data.get(current, target).read(root) : void 0;
+				};
+				/** Shows the loaded value once, the first time it is there. Later refreshes leave the drafts alone. */
+				const sync = (root) => {
+					const editor = slice.get(root);
+					const read = loaded(root);
+					if (editor.filled || read === void 0) return { model: root };
+					if (read._tag !== "Ready" && read._tag !== "Refreshing") return { model: root };
+					const values = Entity.valuesFor(form.input, read.value);
+					return { model: slice.set(root, {
+						...editor,
+						form: form.fill(editor.form, values).model,
+						filled: true
+					}) };
+				};
+				const saveOf = (root) => {
+					const { requestId } = slice.get(root);
+					return requestId === null ? { _tag: "Unknown" } : data.mutation(root, requestId);
+				};
+				return {
+					/** For the placement: a valid submit becomes the mutation, and its request is remembered. */
+					onOut: (submitted) => (root) => {
+						const started = data.mutate(root, mutation, submitted.value);
+						const editor = slice.get(started.model);
+						return {
+							model: slice.set(started.model, {
+								...editor,
+								requestId: started.requestId
+							}),
+							commands: [started.command]
+						};
+					},
+					/**
+					* For `Data.subscriptions`: while an id is being edited, what it loads is
+					* a requirement like any Surface's, so Remote fetches and retains it.
+					*/
+					active: {
+						name,
+						owner: data.contract.owner ?? {},
+						projectionOf: (root) => {
+							const { mode, target } = slice.get(root);
+							return mode === "edit" && target !== null ? data.get(current, target) : void 0;
+						}
+					},
+					sync,
+					/**
+					* Wraps the application's `update` so `sync` runs after every Message:
+					* the value may arrive with any of them.
+					*/
+					after: (update) => (model, message) => {
+						const next = update(model, message);
+						return {
+							...next,
+							model: sync(next.model).model
+						};
+					},
+					/** Why the last save failed, while `status` is `SaveFailed`. */
+					saveError: (root) => {
+						const save = saveOf(root);
+						return save._tag === "Failed" ? save.error : void 0;
+					},
+					status: (root) => {
+						const editor = slice.get(root);
+						if (editor.mode === "closed") return "Closed";
+						const read = loaded(root);
+						if (read?._tag === "NotFound") return "NotFound";
+						const save = saveOf(root);
+						if (save._tag === "Pending") return "Saving";
+						if (save._tag === "Failed") return "SaveFailed";
+						if (save._tag === "Applied") return "Saved";
+						if (editor.filled) return "Editing";
+						return read?._tag === "Failed" ? "LoadFailed" : "Loading";
+					}
+				};
+			}
+		};
+	}
+};
+//#endregion
+export { Crud };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-crud` — management screens assembled from parts an application\n * already has.\n *\n * An editor joins a `foldkit-form` form, the Remote mutation its value feeds,\n * and the Entity they share: it loads what the form writes, shows it, turns a\n * valid submit into the mutation, and says how that went. Everything it makes is\n * ordinary Foldkit: a Bundle, an ActiveSurface, Update Steps. Nothing is\n * generated from an Entity alone; each capability is declared.\n */\nimport { Schema } from 'effect'\nimport { Bundle } from 'foldkit-bundle'\nimport {\n  Entity,\n  type AnyEntity,\n  type EntityInput,\n  type EntityMember,\n  type Selection,\n} from 'foldkit-entity'\nimport { Form, type FormControl, type Submitted } from 'foldkit-form'\nimport type {\n  MutationDescriptor,\n  Page,\n  QueryDescriptor,\n  MutationStatus,\n  RemoteClient,\n  RemoteData,\n  RemoteError,\n  RemoteMessage,\n} from 'foldkit-remote'\nimport type { ActiveSurface, ModelRef, Projection } from 'foldkit-surface'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type { Html, HtmlBuilder } from 'foldkit/html'\nimport * as Submodel from 'foldkit/submodel'\nimport type * as Update from 'foldkit/update'\n\n/** The parts of a `Form.make` result an editor wraps. */\nexport interface EditableForm<\n  Name extends string,\n  FormModel,\n  FormMessage,\n  Value,\n  E extends AnyEntity,\n  Fields extends Schema.Struct.Fields,\n  Members,\n  R = never,\n> {\n  readonly bundle: {\n    readonly name: Name\n    readonly Model: Schema.Codec<FormModel, unknown>\n    readonly Message: Schema.Codec<FormMessage, unknown>\n    readonly update: (\n      model: FormModel,\n      message: FormMessage,\n      args: void,\n    ) => Update.ReturnWithOutMessage<FormModel, FormMessage, Submitted<Value>, R>\n  }\n  readonly input: EntityInput<E, Fields, Members>\n  readonly initial: FormModel\n  readonly fill: (model: FormModel, values: Partial<Value>) => { readonly model: FormModel }\n}\n\n/**\n * An editor's slice of the parent Model. `target` is the id being edited, or\n * `null` for a new one; `filled` is whether the loaded value has been shown;\n * `requestId` is the save in progress or last settled.\n */\nexport interface EditorModel<FormModel> {\n  readonly form: FormModel\n  readonly mode: 'closed' | 'new' | 'edit'\n  readonly target: string | null\n  readonly filled: boolean\n  readonly requestId: string | null\n}\n\n/**\n * A remover's slice of the parent Model: the id it was asked to delete and is\n * waiting on a yes for, and the delete in progress or last settled.\n */\nexport interface RemoverModel {\n  readonly target: string | null\n  readonly requestId: string | null\n}\n\n/** A remover's out Message: the user said yes to deleting `id`. */\nexport interface ConfirmedRemoval {\n  readonly _tag: 'Confirmed'\n  readonly id: string\n}\n\nexport type RemoverStatus =\n  | 'Idle'\n  /** Asked to delete an id, and waiting for a yes or a no. */\n  | 'Confirming'\n  | 'Deleting'\n  | 'Deleted'\n  | 'DeleteFailed'\n\nexport type EditorStatus =\n  | 'Closed'\n  /** Editing an id whose current values have not arrived. */\n  | 'Loading'\n  | 'NotFound'\n  | 'LoadFailed'\n  | 'Editing'\n  | 'Saving'\n  | 'Saved'\n  | 'SaveFailed'\n\n/** The parts of a bound Remote domain an editor uses. */\nexport interface DomainLike<Root> {\n  // Method syntax: the descriptors are checked where the editor is made, not here.\n  mutate(\n    model: Root,\n    mutation: any,\n    input: any,\n  ): {\n    readonly model: Root\n    readonly requestId: string\n    readonly command: Command<RemoteMessage, never, RemoteClient>\n  }\n  get(selection: any, id: string): Projection<Root, RemoteData<any>>\n  query(query: any, input: any, options: any): Projection<Root, RemoteData<Page<any>>>\n  next(model: Root, projection: any): { readonly query: string } | undefined\n  fetch(ref: any): Command<RemoteMessage, never, RemoteClient>\n  mutation(model: Root, requestId: string): MutationStatus\n  readonly contract: { readonly owner?: object | undefined }\n}\n\ntype Step<Root> = Update.Step<Root, RemoteMessage, RemoteClient>\n\n/** One thing a relation picker offers. */\nexport interface Choice {\n  readonly value: string\n  readonly label: string\n}\n\n/** One column of a list, or one line of a detail: a member the Selection reads. */\nexport interface ListColumn<Key extends string = string> {\n  readonly key: Key\n  /** The schema's `title` annotation, else `Form.label` metadata, else the key. */\n  readonly label: string\n  readonly member: EntityMember\n}\n\nconst columnLabel = (key: string, member: EntityMember): string => {\n  const title =\n    member._tag === 'Relation'\n      ? undefined\n      : Schema.resolveAnnotations(member.schema as Schema.Top)?.title\n  return typeof title === 'string' ? title : (Form.labelOf(member) ?? key)\n}\n\n/** The selected members in the Selection's order, each with its label. */\nconst columnsOf = <Members>(\n  selection: Selection<string, Members, Schema.Constraint>,\n): ReadonlyArray<ListColumn<keyof Members & string>> => {\n  const members: Readonly<Record<string, EntityMember>> = selection.entity.members\n  return Object.keys(selection.members as object).map(key => ({\n    key: key as keyof Members & string,\n    label: columnLabel(key, members[key]!),\n    member: members[key]!,\n  }))\n}\n\nconst RemoverMessage = defineMessageUnion({ Confirmed: {}, Cancelled: {} })\ntype RemoverMessage = typeof RemoverMessage.Type\n\nconst idle: RemoverModel = { target: null, requestId: null }\n\nexport const Crud = {\n  /**\n   * One Entity read through a Selection, for a page that shows it. Like a list\n   * it holds no state: the value is Remote's and the id is the application's.\n   */\n  detail: <const Name extends string, EntityName extends string, Members, Row>(\n    name: Name,\n    config: {\n      readonly selection: Selection<EntityName, Members, Schema.Constraint & { readonly Type: Row }>\n    },\n  ) => ({\n    name,\n    /** The selected members in the Selection's order, each with its label. */\n    fields: columnsOf(config.selection),\n\n    /** The detail where it lives: `id` is the one shown, or `undefined` while none is. */\n    at: <Root>(where: {\n      readonly data: DomainLike<Root>\n      readonly id: (root: Root) => string | undefined\n    }) => {\n      const projectionOf = (root: Root) => {\n        const id = where.id(root)\n        return id === undefined ? undefined : where.data.get(config.selection, id)\n      }\n      return {\n        /** For `Data.subscriptions`: the value is fetched and retained while an id is shown. */\n        active: {\n          name,\n          owner: where.data.contract.owner ?? {},\n          projectionOf,\n        } satisfies ActiveSurface<Root>,\n        value: (root: Root): RemoteData<Row> =>\n          projectionOf(root)?.read(root) ?? { _tag: 'Initial' },\n      }\n    },\n  }),\n\n  /**\n   * Deleting through one mutation, with a yes in between: asked, confirmed,\n   * deleted. What the mutation's input is for an id is `input`'s to say.\n   */\n  remover: <const Name extends string, Input>(\n    name: Name,\n    config: {\n      readonly mutation: MutationDescriptor<string, Input, any>\n      readonly input: (id: string) => Input\n    },\n  ) => {\n    const bundle = Bundle.make(name, {\n      Model: Schema.Struct({\n        target: Schema.NullOr(Schema.String),\n        requestId: Schema.NullOr(Schema.String),\n      }) as unknown as Schema.Codec<RemoverModel, unknown>,\n      Message: RemoverMessage,\n      init: () => ({ model: idle }),\n      update: (model: RemoverModel, message: RemoverMessage) =>\n        message._tag === 'Cancelled' || model.target === null\n          ? { model: idle }\n          : { model, outMessage: { _tag: 'Confirmed', id: model.target } as ConfirmedRemoval },\n      helpers: {\n        /** Asks whether to delete `id`. Nothing is deleted until `Confirmed`. */\n        ask: (_: RemoverModel, id: string) => ({ model: { target: id, requestId: null } }),\n        dismiss: () => ({ model: idle }),\n      },\n    })\n\n    return {\n      bundle,\n      /** The remover's Messages, for the yes and the no of a confirmation. */\n      Message: RemoverMessage,\n\n      at: <Root>(where: {\n        readonly data: DomainLike<Root>\n        readonly model: ModelRef<Root, RemoverModel>\n      }) => {\n        const { data, model: slice } = where\n        const outcome = (root: Root): MutationStatus => {\n          const { requestId } = slice.get(root)\n          return requestId === null ? { _tag: 'Unknown' } : data.mutation(root, requestId)\n        }\n        return {\n          /** For the placement: a yes becomes the mutation, and its request is remembered. */\n          onOut:\n            (confirmed: ConfirmedRemoval): Step<Root> =>\n            root => {\n              const started = data.mutate(root, config.mutation, config.input(confirmed.id))\n              return {\n                model: slice.set(started.model, {\n                  target: confirmed.id,\n                  requestId: started.requestId,\n                }),\n                commands: [started.command],\n              }\n            },\n\n          /** The id being asked about or deleted, for the words of a confirmation. */\n          target: (root: Root): string | null => slice.get(root).target,\n\n          status: (root: Root): RemoverStatus => {\n            const { target } = slice.get(root)\n            const deleting = outcome(root)\n            return deleting._tag === 'Pending'\n              ? 'Deleting'\n              : deleting._tag === 'Applied'\n                ? 'Deleted'\n                : deleting._tag === 'Failed'\n                  ? 'DeleteFailed'\n                  : target === null\n                    ? 'Idle'\n                    : 'Confirming'\n          },\n\n          /** Why the last delete failed, while `status` is `DeleteFailed`. */\n          error: (root: Root): RemoteError | undefined => {\n            const deleting = outcome(root)\n            return deleting._tag === 'Failed' ? deleting.error : undefined\n          },\n        }\n      },\n    }\n  },\n\n  /**\n   * A list over one query: which rows to show is the query's, what to show of\n   * each is the Selection's. The pages live in Remote; the list holds no state.\n   */\n  list: <const Name extends string, EntityName extends string, Members, Row, Input>(\n    name: Name,\n    config: {\n      readonly query: QueryDescriptor<string, Input, any>\n      readonly selection: Selection<EntityName, Members, Schema.Constraint & { readonly Type: Row }>\n      /** How many rows a page holds. Default 25. */\n      readonly pageSize?: number\n      /**\n       * How a row reads as a choice in a relation picker: its id, and the words\n       * that identify it to a person. Give it to a list that feeds pickers.\n       */\n      readonly choice?: {\n        readonly value: (row: Row) => string\n        readonly label: (row: Row) => string\n      }\n    },\n  ) => {\n    const { query, selection, pageSize = 25, choice } = config\n    const columns = columnsOf(selection)\n\n    return {\n      name,\n      /** The selected members in the Selection's order, each with its label. */\n      columns,\n\n      /**\n       * The list where it lives. `input` is the query's input as the Model has\n       * it (filters, a search term), or `undefined` while the list is not shown.\n       */\n      at: <Root>(where: {\n        readonly data: DomainLike<Root>\n        readonly input: (root: Root) => Input | undefined\n      }) => {\n        const { data, input } = where\n        const projectionOf = (root: Root) => {\n          const value = input(root)\n          return value === undefined\n            ? undefined\n            : data.query(query, value, { select: selection, first: pageSize })\n        }\n        const page = (root: Root): RemoteData<Page<Row>> =>\n          projectionOf(root)?.read(root) ?? { _tag: 'Initial' }\n\n        return {\n          /** For `Data.subscriptions`: the page and its rows are fetched and retained while shown. */\n          active: {\n            name,\n            owner: data.contract.owner ?? {},\n            projectionOf,\n          } satisfies ActiveSurface<Root>,\n\n          page,\n\n          /** The Command that loads the next page onto this one, or `undefined` when there is none. */\n          more: (root: Root): Command<RemoteMessage, never, RemoteClient> | undefined => {\n            const projection = projectionOf(root)\n            const next = projection === undefined ? undefined : data.next(root, projection)\n            return next === undefined ? undefined : data.fetch(next)\n          },\n\n          name,\n          /** The Entity the rows are of, which is how a picker finds the list for its target. */\n          entity: selection.entity as AnyEntity,\n          /** Whether the list was given a `choice`, so its rows can be a picker's choices. */\n          offersChoices: choice !== undefined,\n\n          /**\n           * The loaded rows as a picker's choices, read through `choice`. Listing a\n           * relation's target is this query, which the application chose and the\n           * server authorizes; nothing is read because a relation exists.\n           */\n          choices: (root: Root): ReadonlyArray<Choice> => {\n            if (choice === undefined)\n              throw new Error(`Crud list \"${name}\": give it a \"choice\" to use its rows in a picker`)\n            const read = page(root)\n            return read._tag === 'Ready' || read._tag === 'Refreshing'\n              ? read.value.items.map(row => ({\n                  value: choice.value(row),\n                  label: choice.label(row),\n                }))\n              : []\n          },\n        }\n      },\n    }\n  },\n\n  /**\n   * A form's Submodel view as the view of the editor that wraps it, for\n   * `Bundle.withView`: the editor's Messages are the form's, and its Model holds\n   * the form's under `form`.\n   *\n   * ```ts\n   * Editor.bundle.pipe(Bundle.withView(Crud.editorView(FormView.submodel(form, view))))\n   * ```\n   */\n  editorView: <FormModel, Message, ViewInputs>(\n    view: Submodel.View<FormModel, Message, ViewInputs>,\n  ): Submodel.View<EditorModel<FormModel>, Message, ViewInputs> =>\n    Submodel.defineView<EditorModel<FormModel>, Message, ViewInputs>(((\n      model: EditorModel<FormModel>,\n      inputs: ViewInputs,\n      h: HtmlBuilder<Message>,\n    ): Html =>\n      (view as (model: FormModel, inputs: ViewInputs, h: HtmlBuilder<Message>) => Html)(\n        model.form,\n        inputs,\n        h,\n      )) as never),\n\n  /**\n   * The choices of every relation picker in a form, from the lists of their\n   * targets: `foldkit-mixins-form`'s `options`, keyed by the form's keys. A\n   * picker whose target no list here is over is a wiring mistake, reported now.\n   */\n  options: <Key extends string, Root>(\n    form: { readonly controls: ReadonlyArray<FormControl<Key>> },\n    lists: ReadonlyArray<{\n      readonly name: string\n      readonly entity: AnyEntity\n      readonly offersChoices: boolean\n      readonly choices: (root: Root) => ReadonlyArray<Choice>\n    }>,\n  ): ((root: Root) => { readonly [K in Key]?: ReadonlyArray<Choice> }) => {\n    const pickers = form.controls.flatMap(({ key, control }) => {\n      if (control._tag !== 'RelationOne' && control._tag !== 'RelationMany') return []\n      const list = lists.find(candidate => Entity.same(candidate.entity, control.target))\n      if (list === undefined)\n        throw new Error(\n          `Crud.options: \"${key}\" picks a ${control.target.name}, and no list given is over ${control.target.name}`,\n        )\n      if (!list.offersChoices)\n        throw new Error(\n          `Crud.options: \"${key}\" would pick from list \"${list.name}\", which has no \"choice\"`,\n        )\n      return [[key, list] as const]\n    })\n    return root =>\n      Object.fromEntries(pickers.map(([key, list]) => [key, list.choices(root)])) as {\n        readonly [K in Key]?: ReadonlyArray<Choice>\n      }\n  },\n\n  /**\n   * An editor for one form and the mutation its value feeds. The form's value\n   * must be the mutation's input, which is what declaring the input once and\n   * giving it to both guarantees.\n   */\n  editor: <\n    const Name extends string,\n    FormName extends string,\n    FormModel,\n    FormMessage extends { readonly _tag: string },\n    Value,\n    E extends AnyEntity,\n    Fields extends Schema.Struct.Fields,\n    Members,\n    R = never,\n  >(\n    name: Name,\n    config: {\n      readonly form: EditableForm<FormName, FormModel, FormMessage, Value, E, Fields, Members, R>\n      readonly mutation: MutationDescriptor<string, Value, any>\n    },\n  ) => {\n    type Model = EditorModel<FormModel>\n    const { form, mutation } = config\n\n    const closed: Model = {\n      form: form.initial,\n      mode: 'closed',\n      target: null,\n      filled: false,\n      requestId: null,\n    }\n    const Model = Schema.Struct({\n      form: form.bundle.Model,\n      mode: Schema.Literals(['closed', 'new', 'edit']),\n      target: Schema.NullOr(Schema.String),\n      filled: Schema.Boolean,\n      requestId: Schema.NullOr(Schema.String),\n    }) as unknown as Schema.Codec<Model, unknown>\n\n    // The editor's Messages are the form's own: it adds state around the form,\n    // not a second vocabulary.\n    const bundle = Bundle.make(name, {\n      Model,\n      Message: form.bundle.Message,\n      init: () => ({ model: closed }),\n      update: (model: Model, message: FormMessage) => {\n        const next = form.bundle.update(model.form, message, undefined)\n        // An edit after a save starts a new round; the last save no longer describes the form.\n        const requestId = message._tag === 'Changed' ? null : model.requestId\n        // The form's Commands are the editor's: a check the form started has to run.\n        const edited = {\n          model: { ...model, form: next.model, requestId },\n          ...(next.commands === undefined ? {} : { commands: next.commands }),\n        }\n        return next.outMessage === undefined ? edited : { ...edited, outMessage: next.outMessage }\n      },\n      helpers: {\n        /** Edits `id`: the form is emptied, and filled once the current values arrive. */\n        open: (_: Model, id: string) => ({\n          model: { ...closed, mode: 'edit' as const, target: id },\n        }),\n        /** A blank form for a new one: nothing to load. */\n        blank: () => ({ model: { ...closed, mode: 'new' as const, filled: true } }),\n        close: () => ({ model: closed }),\n      },\n    })\n\n    const current = Entity.selectFor(form.input)\n\n    return {\n      bundle,\n      /** What the editor loads before it shows the form: every member the form writes. */\n      selection: current,\n\n      /**\n       * The editor where it lives: `model` is its slice of the parent Model (the\n       * field it was declared at), and `data` the Remote domain that registers the\n       * mutation and the Entity.\n       */\n      at: <Root>(where: {\n        readonly data: DomainLike<Root>\n        readonly model: ModelRef<Root, Model>\n      }) => {\n        const { data, model: slice } = where\n        const loaded = (root: Root): RemoteData<any> | undefined => {\n          const { mode, target } = slice.get(root)\n          return mode === 'edit' && target !== null\n            ? data.get(current, target).read(root)\n            : undefined\n        }\n\n        /** Shows the loaded value once, the first time it is there. Later refreshes leave the drafts alone. */\n        const sync: Update.Step<Root, never, never> = root => {\n          const editor = slice.get(root)\n          const read = loaded(root)\n          if (editor.filled || read === undefined) return { model: root }\n          if (read._tag !== 'Ready' && read._tag !== 'Refreshing') return { model: root }\n          const values = Entity.valuesFor(form.input, read.value) as Partial<Value>\n          return {\n            model: slice.set(root, {\n              ...editor,\n              form: form.fill(editor.form, values).model,\n              filled: true,\n            }),\n          }\n        }\n\n        const saveOf = (root: Root): MutationStatus => {\n          const { requestId } = slice.get(root)\n          return requestId === null ? { _tag: 'Unknown' } : data.mutation(root, requestId)\n        }\n\n        return {\n          /** For the placement: a valid submit becomes the mutation, and its request is remembered. */\n          onOut:\n            (submitted: Submitted<Value>): Step<Root> =>\n            root => {\n              const started = data.mutate(root, mutation, submitted.value)\n              const editor = slice.get(started.model)\n              return {\n                model: slice.set(started.model, { ...editor, requestId: started.requestId }),\n                commands: [started.command],\n              }\n            },\n\n          /**\n           * For `Data.subscriptions`: while an id is being edited, what it loads is\n           * a requirement like any Surface's, so Remote fetches and retains it.\n           */\n          active: {\n            name,\n            owner: data.contract.owner ?? {},\n            projectionOf: root => {\n              const { mode, target } = slice.get(root)\n              return mode === 'edit' && target !== null ? data.get(current, target) : undefined\n            },\n          } satisfies ActiveSurface<Root>,\n\n          sync,\n\n          /**\n           * Wraps the application's `update` so `sync` runs after every Message:\n           * the value may arrive with any of them.\n           */\n          after:\n            <Message, Result extends { readonly model: Root }>(\n              update: (model: Root, message: Message) => Result,\n            ) =>\n            (model: Root, message: Message): Result => {\n              const next = update(model, message)\n              return { ...next, model: sync(next.model).model }\n            },\n\n          /** Why the last save failed, while `status` is `SaveFailed`. */\n          saveError: (root: Root): RemoteError | undefined => {\n            const save = saveOf(root)\n            return save._tag === 'Failed' ? save.error : undefined\n          },\n\n          status: (root: Root): EditorStatus => {\n            const editor = slice.get(root)\n            if (editor.mode === 'closed') return 'Closed'\n            // Gone outranks everything: a save that landed describes a thing that no longer exists.\n            const read = loaded(root)\n            if (read?._tag === 'NotFound') return 'NotFound'\n            const save = saveOf(root)\n            if (save._tag === 'Pending') return 'Saving'\n            if (save._tag === 'Failed') return 'SaveFailed'\n            if (save._tag === 'Applied') return 'Saved'\n            if (editor.filled) return 'Editing'\n            return read?._tag === 'Failed' ? 'LoadFailed' : 'Loading'\n          },\n        }\n      },\n    }\n  },\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "foldkit-crud",
+  "version": "0.1.0",
+  "description": "Create, read, update and delete screens for Foldkit Plus, assembled from a form, a Remote operation, and the Entity they share. Each capability is declared, never implied.",
+  "keywords": [
+    "foldkit",
+    "effect",
+    "crud",
+    "admin",
+    "form",
+    "remote",
+    "typescript"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Patrick Glenn <doeixd@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doeixd/foldkit-plus.git",
+    "directory": "packages/crud"
+  },
+  "homepage": "https://github.com/doeixd/foldkit-plus/tree/main/packages/crud#readme",
+  "bugs": {
+    "url": "https://github.com/doeixd/foldkit-plus/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "foldkit-bundle": "0.2.0",
+    "foldkit-entity": "0.1.0",
+    "foldkit-form": "0.1.0",
+    "foldkit-remote": "0.4.0",
+    "foldkit-surface": "0.3.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.112",
+    "foldkit": "^0.158.2"
+  },
+  "devDependencies": {
+    "effect": "4.0.0-rc.112",
+    "foldkit": "0.158.2",
+    "tsdown": "^0.23.0",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -b"
+  }
+}