appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
import { t } from "../ui";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { Edit3, Plus, RefreshCw, Save, Trash2, X } from "lucide-react";
import { useMemo, useState } from "react";
import {
  collectionBatch,
  collectionRow,
  type CollectionRow,
} from "../collection-draft";
import type { FormValue } from "../field-values";
import type { AppStructRegistry } from "../generated/registry";
import type { CollectionResponse } from "../generated/client";
import { resourceQueryKeys } from "../query";
import { RelationValue, useRelationRecords } from "../relations";
import {
  canAccessRule,
  canAccessResource,
  errorMessage,
  fieldErrors,
  isSemanticCompanion,
  useResourceActor,
  type CollectionDefinition,
  type ResourceDefinition,
} from "../resource";
import { FieldControl, UnsavedChangesGuard } from "./ResourceForm";
import { formatFieldValue } from "./ResourceList";

export function AggregateEditor({
  parent,
  child,
  definition,
  id,
  resources,
  registry,
}: {
  parent: ResourceDefinition;
  child: ResourceDefinition;
  definition: CollectionDefinition;
  id: string;
  resources: ResourceDefinition[];
  registry?: AppStructRegistry;
}) {
  const queryClient = useQueryClient();
  const actor = useResourceActor();
  const queryKey = [
    ...resourceQueryKeys.detail(parent.id, id),
    "collection",
    definition.name,
  ];
  const query = useQuery({
    queryKey,
    queryFn: ({ signal }) =>
      parent.api.collection!(id, definition.name, { signal }),
  });
  const [baseline, setBaseline] = useState<CollectionResponse>();
  const [rows, setRows] = useState<CollectionRow[]>([]);
  const [editing, setEditing] = useState(false);
  const [errors, setErrors] = useState<Record<string, string>>({});
  const data = baseline && editing ? baseline : query.data;
  const fields = child.fields.filter(
    (field) =>
      !field.readOnly &&
      !field.primaryKey &&
      field.name !== definition.relation &&
      canAccessRule(field.readAccess ?? { mode: "public" }, actor) &&
      canAccessRule(field.writeAccess ?? { mode: "public" }, actor),
  );
  const visible = child.fields.filter(
    (field) =>
      !field.primaryKey &&
      field.name !== definition.relation &&
      !isSemanticCompanion(field, child.fields) &&
      canAccessRule(field.readAccess ?? { mode: "public" }, actor),
  );
  const aggregateRows = useMemo(() => data?.rows ?? [], [data]);
  const relations = useRelationRecords(resources, aggregateRows, visible);
  const draft = collectionBatch(rows, baseline?.rows ?? [], child, fields);
  const allowed =
    data &&
    canAccessResource(parent, "update", actor, data.parent) &&
    (!parent.workflow ||
      definition.states.includes(String(data.parent[parent.workflow.field])));
  const save = useMutation({
    mutationFn: () =>
      parent.api.saveCollection!(
        id,
        definition.name,
        Number(baseline!.parent.revision),
        draft.batch,
      ),
    onSuccess: async (result) => {
      setEditing(false);
      setBaseline(undefined);
      setErrors({});
      queryClient.setQueryData(queryKey, result);
      queryClient.setQueryData(
        resourceQueryKeys.detail(parent.id, id),
        result.parent,
      );
      await Promise.all([
        queryClient.invalidateQueries({
          queryKey: resourceQueryKeys.all(parent.id),
        }),
        queryClient.invalidateQueries({
          queryKey: resourceQueryKeys.all(child.id),
        }),
      ]);
    },
    onError: (error) =>
      setErrors(
        Object.fromEntries(
          Object.entries(fieldErrors(error)).map(([key, value]) => [
            key.replace(/^(creates|updates)\./, ""),
            value,
          ]),
        ),
      ),
  });
  function begin(result: CollectionResponse) {
    setBaseline(result);
    setRows(result.rows.map((record) => collectionRow(fields, child, record)));
    setErrors({});
    save.reset();
    setEditing(true);
  }
  function change(key: string, name: string, value: FormValue) {
    setRows((current) =>
      current.map((row) =>
        row.key === key
          ? { ...row, values: { ...row.values, [name]: value } }
          : row,
      ),
    );
    setErrors((current) => {
      const next = { ...current };
      delete next[`${key}.${name}`];
      return next;
    });
  }
  async function reload() {
    const result = await query.refetch();
    if (result.data && !result.error) begin(result.data);
  }
  return (
    <section className="aggregate-section" aria-label={child.label}>
      <UnsavedChangesGuard
        enabled={editing && draft.dirty && !save.isPending}
      />
      <div className="section-heading">
        <h2>{child.label}</h2>
        {!editing && allowed && (
          <button className="secondary-button" onClick={() => begin(data!)}>
            <Edit3 size={16} /> {t("Edit lines")}
          </button>
        )}
      </div>
      {(query.error || save.error) && (
        <div className="alert" role="alert">
          {errorMessage(save.error ?? query.error)}
        </div>
      )}
      {query.isPending && <p role="status">{t("Loading...")}</p>}
      {editing ? (
        <form
          onSubmit={(event) => {
            event.preventDefault();
            setErrors(draft.errors);
            if (!Object.keys(draft.errors).length && draft.dirty) save.mutate();
          }}
        >
          <fieldset className="aggregate-fields" disabled={save.isPending}>
            {rows.map((row, index) => {
              const canUpdate =
                !row.record ||
                canAccessRule(child.access.update, actor, row.record);
              return (
                <fieldset className="aggregate-row" key={row.key}>
                  <legend>
                    {t("Line")}
                    {index + 1}
                  </legend>
                  <fieldset
                    className="aggregate-row-fields"
                    disabled={!canUpdate}
                  >
                    {fields
                      .filter((field) => !isSemanticCompanion(field, fields))
                      .map((field) => {
                        const companion =
                          field.semantic?.kind === "money"
                            ? fields.find(
                                (candidate) =>
                                  candidate.name ===
                                  field.semantic!.currencyField,
                              )
                            : undefined;
                        return (
                          <FieldControl
                            key={field.name}
                            idPrefix={`${definition.name}-${row.key}-`}
                            field={field}
                            resources={resources}
                            registry={registry}
                            value={row.values[field.name]}
                            error={errors[`${row.key}.${field.name}`]}
                            onBlur={() => {}}
                            onChange={(value) =>
                              change(row.key, field.name, value)
                            }
                            companion={
                              companion
                                ? {
                                    field: companion,
                                    value: row.values[companion.name],
                                    error:
                                      errors[`${row.key}.${companion.name}`],
                                    onBlur() {},
                                    onChange: (value) =>
                                      change(row.key, companion.name, value),
                                  }
                                : undefined
                            }
                          />
                        );
                      })}
                  </fieldset>
                  {(!row.record ||
                    canAccessRule(child.access.delete, actor, row.record)) && (
                    <button
                      type="button"
                      className="icon-button danger"
                      aria-label={t("Remove line {0}", { "0": index + 1 })}
                      title={t("Remove line {0}", { "0": index + 1 })}
                      onClick={() =>
                        setRows((current) =>
                          current.filter((item) => item.key !== row.key),
                        )
                      }
                    >
                      <Trash2 size={16} />
                    </button>
                  )}
                </fieldset>
              );
            })}
            <div className="aggregate-actions">
              {canAccessRule(child.access.create, actor) && (
                <button
                  type="button"
                  className="secondary-button"
                  disabled={rows.length >= definition.maxItems}
                  onClick={() =>
                    setRows((current) => [
                      ...current,
                      collectionRow(fields, child),
                    ])
                  }
                >
                  <Plus size={16} /> {t("Add line")}
                </button>
              )}
              <button
                type="submit"
                className="primary-button"
                disabled={!draft.dirty}
              >
                <Save size={16} />{" "}
                {save.isPending ? "Saving..." : t("Save lines")}
              </button>
              <button
                type="button"
                className="secondary-button"
                disabled={query.isFetching}
                onClick={() => void reload()}
              >
                <RefreshCw size={16} /> {t("Reload")}
              </button>
              <button
                type="button"
                className="secondary-button"
                onClick={() => {
                  setEditing(false);
                  save.reset();
                }}
              >
                <X size={16} /> {t("Cancel")}
              </button>
            </div>
          </fieldset>
        </form>
      ) : (
        data && (
          <div className="table-frame">
            <table>
              <thead>
                <tr>
                  {visible.map((field) => (
                    <th key={field.name}>{field.label}</th>
                  ))}
                </tr>
              </thead>
              <tbody>
                {data.rows.map((record) => (
                  <tr key={String(record[child.primaryKey])}>
                    {visible.map((field) => (
                      <td key={field.name}>
                        {field.relation ? (
                          <RelationValue
                            field={field}
                            value={record[field.name]}
                            resources={resources}
                            records={relations}
                          />
                        ) : (
                          formatFieldValue(record, field)
                        )}
                      </td>
                    ))}
                  </tr>
                ))}
                {!data.rows.length && (
                  <tr>
                    <td colSpan={visible.length}> {t("No lines")} </td>
                  </tr>
                )}
              </tbody>
            </table>
          </div>
        )
      )}
    </section>
  );
}