@jskit-ai/users-web 0.1.165 → 0.1.166

package/package.descriptor.mjs

@@ -3,7 +3,7 @@ import { HOME_COG_OUTLET } from "./src/shared/toolsOutletContracts.js";
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-web",
-  version: "0.1.165",
+  version: "0.1.166",
   kind: "runtime",
   description: "Users web module: account/profile UI plus shared users web widgets.",
   dependsOn: [
@@ -287,9 +287,9 @@ export default Object.freeze({
       runtime: {
         "@mdi/js": "^7.4.47",
         "@jskit-ai/http-runtime": "0.1.146",
-        "@jskit-ai/realtime": "0.1.144",
+        "@jskit-ai/realtime": "0.1.145",
         "@jskit-ai/kernel": "0.1.147",
-        "@jskit-ai/shell-web": "0.1.148",
+        "@jskit-ai/shell-web": "0.1.149",
         "@jskit-ai/uploads-image-web": "0.1.123",
         "@jskit-ai/users-core": "0.1.161"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-web",
-  "version": "0.1.165",
+  "version": "0.1.166",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -22,6 +22,7 @@
     "./client/composables/useCommand": "./src/client/composables/useCommand.js",
     "./client/composables/useCrudAddEdit": "./src/client/composables/records/useCrudAddEdit.js",
     "./client/composables/useCrudAddEditScreen": "./src/client/composables/useCrudAddEditScreen.js",
+    "./client/composables/useCrudDeleteAction": "./src/client/composables/useCrudDeleteAction.js",
     "./client/composables/useCrudListBulkActions": "./src/client/composables/useCrudListBulkActions.js",
     "./client/composables/useCrudListRowActions": "./src/client/composables/useCrudListRowActions.js",
     "./client/composables/crudLookupFieldRuntime": "./src/client/composables/crud/crudLookupFieldRuntime.js",
@@ -49,8 +50,8 @@
     "@mdi/js": "^7.4.47",
     "@jskit-ai/http-runtime": "0.1.146",
     "@jskit-ai/kernel": "0.1.147",
-    "@jskit-ai/realtime": "0.1.144",
-    "@jskit-ai/shell-web": "0.1.148",
+    "@jskit-ai/realtime": "0.1.145",
+    "@jskit-ai/shell-web": "0.1.149",
     "@jskit-ai/uploads-image-web": "0.1.123",
     "@jskit-ai/users-core": "0.1.161"
   },

package/src/client/components/CrudViewScreen.vue

@@ -50,6 +50,7 @@ const resolvedDescription = computed(() =>
         >
           Back to {{ resourcePluralTitle }}
         </v-btn>
+        <slot name="actions" :screen="screen" :view="view" />
         <v-btn
           v-if="editLocation"
           color="primary"

package/src/client/composables/crud/crudJsonApiTransportSupport.js

@@ -90,6 +90,14 @@ function inferCrudJsonApiTransport(resource = null, { mode = "", operationName =
     });
   }
 
+  if (normalizedMode === "delete") {
+    return Object.freeze({
+      kind: "jsonapi-resource",
+      responseType: resourceType,
+      responseKind: "record"
+    });
+  }
+
   if (normalizedMode === "add-edit") {
     return Object.freeze({
       kind: "jsonapi-resource",

package/src/client/composables/crud/crudSchemaFormHelpers.js

@@ -69,12 +69,20 @@ function toTimeInputValue(value) {
     return "";
   }
 
-  const twentyFourHourMatch = normalized.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/u);
+  const twentyFourHourMatch = normalized.match(/^(\d{1,2}):(\d{2})(?::(\d{2})(\.\d+)?)?$/u);
   if (twentyFourHourMatch) {
     const hours = Number(twentyFourHourMatch[1]);
     const minutes = Number(twentyFourHourMatch[2]);
-    if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
-      return `${padDateTimePart(hours)}:${padDateTimePart(minutes)}`;
+    const seconds = Number(twentyFourHourMatch[3] || 0);
+    if (
+      hours >= 0 && hours <= 23 &&
+      minutes >= 0 && minutes <= 59 &&
+      seconds >= 0 && seconds <= 59
+    ) {
+      const secondsValue = twentyFourHourMatch[3]
+        ? `:${padDateTimePart(seconds)}${twentyFourHourMatch[4] || ""}`
+        : "";
+      return `${padDateTimePart(hours)}:${padDateTimePart(minutes)}${secondsValue}`;
     }
     return normalized;
   }
@@ -103,16 +111,30 @@ function toDateTimeLocalInputValue(value) {
     return "";
   }
 
+  const sourceText = typeof value === "string" ? value.trim() : "";
+  const sourceFraction = sourceText.match(/T\d{2}:\d{2}:\d{2}\.(\d+)/u)?.[1] || "";
   const date = value instanceof Date ? value : new Date(value);
   if (Number.isNaN(date.getTime())) {
     return String(value);
   }
 
-  return [
+  const minuteValue = [
     date.getFullYear(),
     padDateTimePart(date.getMonth() + 1),
     padDateTimePart(date.getDate())
   ].join("-") + `T${padDateTimePart(date.getHours())}:${padDateTimePart(date.getMinutes())}`;
+  if (sourceFraction && !/^0+$/u.test(sourceFraction)) {
+    return `${minuteValue}:${padDateTimePart(date.getSeconds())}.${sourceFraction}`;
+  }
+
+  const milliseconds = date.getMilliseconds();
+  if (milliseconds > 0) {
+    return `${minuteValue}:${padDateTimePart(date.getSeconds())}.${String(milliseconds).padStart(3, "0")}`;
+  }
+  if (date.getSeconds() > 0) {
+    return `${minuteValue}:${padDateTimePart(date.getSeconds())}`;
+  }
+  return minuteValue;
 }
 
 function toDateInputValue(value) {
@@ -146,7 +168,31 @@ function toDateInputValue(value) {
   return normalized;
 }
 
-function toIsoUtcDateTimeValue(value) {
+function applyDateTimePrecision(isoValue, temporalPrecision) {
+  if (!Number.isInteger(temporalPrecision) || temporalPrecision < 0) {
+    return isoValue;
+  }
+
+  const match = String(isoValue || "").match(/^(.*?)(?:\.(\d+))?Z$/u);
+  if (!match?.[2]) {
+    return isoValue;
+  }
+
+  const fraction = match[2];
+  if (fraction.length <= temporalPrecision) {
+    return isoValue;
+  }
+
+  const excess = fraction.slice(temporalPrecision);
+  if (!/^0+$/u.test(excess)) {
+    return isoValue;
+  }
+
+  const retained = fraction.slice(0, temporalPrecision);
+  return `${match[1]}${retained ? `.${retained}` : ""}Z`;
+}
+
+function toIsoUtcDateTimeValue(value, temporalPrecision) {
   const normalized = String(value ?? "").trim();
   if (!normalized) {
     return "";
@@ -157,7 +203,12 @@ function toIsoUtcDateTimeValue(value) {
     return normalized;
   }
 
-  return date.toISOString();
+  const sourceFraction = normalized.match(/T\d{2}:\d{2}:\d{2}\.(\d+)/u)?.[1] || "";
+  const dateIsoValue = date.toISOString();
+  const preciseIsoValue = sourceFraction
+    ? dateIsoValue.replace(/\.\d{3}Z$/u, `.${sourceFraction}Z`)
+    : dateIsoValue;
+  return applyDateTimePrecision(preciseIsoValue, temporalPrecision);
 }
 
 function resolveFormFieldInitialValue(field = {}) {
@@ -278,7 +329,7 @@ function buildCrudFormPayload(fields = [], model = {}) {
     }
 
     if (fieldFormat === "date-time") {
-      const normalizedValue = toIsoUtcDateTimeValue(rawValue);
+      const normalizedValue = toIsoUtcDateTimeValue(rawValue, field.temporalPrecision);
       if (!normalizedValue) {
         if (clearAsNull) {
           payload[fieldKey] = null;

package/src/client/composables/useCrudDeleteAction.js

@@ -0,0 +1,160 @@
+import { computed, proxyRefs, ref, unref } from "vue";
+import { useRouter } from "vue-router";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveCrudJsonApiTransport } from "./crud/crudJsonApiTransportSupport.js";
+import { toQueryErrorMessage } from "./support/errorMessageHelpers.js";
+import { useCommand } from "./useCommand.js";
+
+function requireCrudDeleteOperation(resource = null) {
+  const operation = resource?.operations?.delete;
+  if (!operation || typeof operation !== "object" || Array.isArray(operation)) {
+    throw new TypeError("useCrudDeleteAction requires resource.operations.delete.");
+  }
+  if (normalizeText(operation.method).toUpperCase() !== "DELETE") {
+    throw new TypeError("useCrudDeleteAction requires resource.operations.delete.method to be DELETE.");
+  }
+  return operation;
+}
+
+function requireCrudViewScreen(screen = null) {
+  if (!screen || typeof screen !== "object" || typeof screen?.view?.resolveParams !== "function") {
+    throw new TypeError("useCrudDeleteAction requires a useCrudViewScreen() result.");
+  }
+  return screen;
+}
+
+function resolveDeleteApiSuffix(screen, apiUrlTemplate = "") {
+  const template = normalizeText(unref(apiUrlTemplate));
+  return template ? normalizeText(screen.view.resolveParams(template)) : "";
+}
+
+function resolveListLocation(screen) {
+  return unref(screen?.listLocation) || null;
+}
+
+function useCrudDeleteAction({
+  screen = null,
+  resource = null,
+  resourceNamespace = "",
+  apiUrlTemplate = "",
+  access = "auto",
+  client = null,
+  router: routerOverride = null,
+  fallbackDeleteError = "Unable to delete record."
+} = {}) {
+  const resolvedScreen = requireCrudViewScreen(screen);
+  const deleteOperation = requireCrudDeleteOperation(resource);
+  const namespace = normalizeText(resourceNamespace, {
+    fallback: resource?.namespace
+  });
+  if (!namespace) {
+    throw new TypeError("useCrudDeleteAction requires resourceNamespace or resource.namespace.");
+  }
+
+  const activeRouter = routerOverride || useRouter();
+  if (!activeRouter || typeof activeRouter.push !== "function") {
+    throw new TypeError("useCrudDeleteAction requires an installed Vue Router.");
+  }
+
+  const isOpen = ref(false);
+  const error = ref("");
+  const deleteApiSuffix = computed(() => resolveDeleteApiSuffix(resolvedScreen, apiUrlTemplate));
+
+  async function handleDeleteSuccess(_response, context = {}) {
+    await context?.queryClient?.invalidateQueries?.({
+      queryKey: ["ui-generator", namespace]
+    });
+
+    const listLocation = resolveListLocation(resolvedScreen);
+    if (!listLocation) {
+      throw new Error("Deleted the record, but the generated list route is unavailable.");
+    }
+
+    isOpen.value = false;
+    await activeRouter.push(listLocation);
+  }
+
+  function handleDeleteError(cause) {
+    error.value = toQueryErrorMessage(
+      cause,
+      fallbackDeleteError,
+      "Unable to delete record."
+    );
+  }
+
+  const command = useCommand({
+    access,
+    apiSuffix: deleteApiSuffix,
+    writeMethod: deleteOperation.method,
+    client,
+    transport: resolveCrudJsonApiTransport(undefined, resource, {
+      mode: "delete"
+    }),
+    placementSource: `ui-generator.${namespace}.view.delete`,
+    fallbackRunError: fallbackDeleteError,
+    onRunSuccess: handleDeleteSuccess,
+    onRunError: handleDeleteError,
+    suppressSuccessMessage: true
+  });
+
+  const isDeleting = computed(() => Boolean(command.isRunning));
+  const canDelete = computed(() => {
+    const view = resolvedScreen.view;
+    return Boolean(
+      command.canRun &&
+      deleteApiSuffix.value &&
+      resolveListLocation(resolvedScreen) &&
+      unref(view.recordId) &&
+      unref(view.record) &&
+      !unref(view.isLoading) &&
+      !unref(view.isNotFound)
+    );
+  });
+
+  function request() {
+    if (!canDelete.value) {
+      return false;
+    }
+    error.value = "";
+    isOpen.value = true;
+    return true;
+  }
+
+  function cancel() {
+    if (isDeleting.value) {
+      return false;
+    }
+    error.value = "";
+    isOpen.value = false;
+    return true;
+  }
+
+  async function confirm() {
+    if (!isOpen.value || !canDelete.value || isDeleting.value) {
+      return null;
+    }
+
+    error.value = "";
+    try {
+      return await command.run();
+    } catch {
+      return null;
+    }
+  }
+
+  return proxyRefs({
+    isOpen,
+    isDeleting,
+    canDelete,
+    error,
+    request,
+    cancel,
+    confirm
+  });
+}
+
+export {
+  requireCrudDeleteOperation,
+  resolveDeleteApiSuffix,
+  useCrudDeleteAction
+};

package/src/client/index.js

@@ -11,6 +11,7 @@ export {
   normalizeCrudApiAccess,
   resolveCrudHttpClient
 } from "./composables/crud/crudHttpClientSupport.js";
+export { useCrudDeleteAction } from "./composables/useCrudDeleteAction.js";
 
 const clientProviders = Object.freeze([UsersWebClientProvider]);
 

package/test/crudJsonApiTransportSupport.test.js

@@ -69,6 +69,19 @@ test("inferCrudJsonApiTransport infers record request/response transport for CRU
   );
 });
 
+test("inferCrudJsonApiTransport infers record response transport for CRUD delete", () => {
+  assert.deepEqual(
+    inferCrudJsonApiTransport(resource, {
+      mode: "delete"
+    }),
+    {
+      kind: "jsonapi-resource",
+      responseType: "pets",
+      responseKind: "record"
+    }
+  );
+});
+
 test("inferCrudLookupJsonApiTransport infers collection transport from lookup namespace", () => {
   assert.deepEqual(
     inferCrudLookupJsonApiTransport({

package/test/crudScreenComponents.test.js

@@ -45,6 +45,7 @@ test("CRUD screen components own generated list/view/form chrome centrally", asy
   assert.match(viewSource, /generated-ui-screen generated-ui-screen--operator ui-generator-view-element/);
   assert.match(viewSource, /ui-generator-view-panel/);
   assert.match(viewSource, /@click="view\.refresh"/);
+  assert.match(viewSource, /<slot name="actions" :screen="screen" :view="view" \/>/);
   assert.match(viewSource, /<slot name="before-fields"/);
   assert.match(viewSource, /<slot name="fields"/);
   assert.match(viewSource, /<slot name="after-fields"/);
@@ -87,13 +88,15 @@ test("CRUD screen composables are importable package APIs", async () => {
     viewModule,
     addEditModule,
     rowActionsModule,
-    rowActionsRuntimeModule
+    rowActionsRuntimeModule,
+    deleteActionModule
   ] = await Promise.all([
     import("@jskit-ai/users-web/client/composables/useCrudListScreen"),
     import("@jskit-ai/users-web/client/composables/useCrudViewScreen"),
     import("@jskit-ai/users-web/client/composables/useCrudAddEditScreen"),
     import("@jskit-ai/users-web/client/rowActions"),
-    import("@jskit-ai/users-web/client/composables/useCrudListRowActions")
+    import("@jskit-ai/users-web/client/composables/useCrudListRowActions"),
+    import("@jskit-ai/users-web/client/composables/useCrudDeleteAction")
   ]);
 
   assert.equal(typeof listModule.useCrudListScreen, "function");
@@ -101,4 +104,5 @@ test("CRUD screen composables are importable package APIs", async () => {
   assert.equal(typeof addEditModule.useCrudAddEditScreen, "function");
   assert.equal(typeof rowActionsModule.defineCrudListRowActions, "function");
   assert.equal(typeof rowActionsRuntimeModule.useCrudListRowActions, "function");
+  assert.equal(typeof deleteActionModule.useCrudDeleteAction, "function");
 });

package/test/exportsContract.test.js

@@ -33,6 +33,7 @@ test("users-web exports are explicit and aligned with production/template usage"
       "./client/composables/useView",
       "./client/composables/useCrudAddEdit",
       "./client/composables/useCrudAddEditScreen",
+      "./client/composables/useCrudDeleteAction",
       "./client/composables/useCrudListBulkActions",
       "./client/composables/useCrudListRowActions",
       "./client/composables/useCrudListFilterLookups",

package/test/useCrudAddEdit.test.js

@@ -108,6 +108,29 @@ test("buildCrudFormPayload and applyCrudPayloadToForm round-trip date-time field
   assert.equal(form.scheduledAt, "2024-01-02T03:04");
 });
 
+test("date-time form values honor strict temporal precision without losing fractional tails", () => {
+  const noFraction = buildCrudFormPayload(
+    [{ key: "scheduledAt", type: "string", format: "date-time", temporalPrecision: 0 }],
+    { scheduledAt: "2024-01-02T03:04" }
+  );
+  assert.match(noFraction.scheduledAt, /T\d{2}:\d{2}:00Z$/u);
+  assert.doesNotMatch(noFraction.scheduledAt, /\.000Z$/u);
+
+  const microseconds = buildCrudFormPayload(
+    [{ key: "scheduledAt", type: "string", format: "date-time", temporalPrecision: 6 }],
+    { scheduledAt: "2024-01-02T03:04:05.123456" }
+  );
+  assert.match(microseconds.scheduledAt, /T\d{2}:\d{2}:05\.123456Z$/u);
+
+  const form = reactive({ scheduledAt: "" });
+  applyCrudPayloadToForm(
+    [{ key: "scheduledAt", type: "string", format: "date-time", temporalPrecision: 6 }],
+    form,
+    { scheduledAt: "2024-01-02T03:04:05.123456Z" }
+  );
+  assert.match(form.scheduledAt, /T\d{2}:\d{2}:05\.123456$/u);
+});
+
 test("applyCrudPayloadToForm normalizes date values for HTML date inputs", () => {
   const fields = [
     { key: "publishedOn", type: "string", format: "date" },
@@ -137,7 +160,7 @@ test("applyCrudPayloadToForm normalizes date values for HTML date inputs", () =>
   });
 });
 
-test("buildCrudFormPayload normalizes time fields to canonical HH:MM", () => {
+test("buildCrudFormPayload preserves strict time precision", () => {
   const fields = [
     { key: "fromTime", type: "string", format: "time" },
     { key: "toTime", type: "string", format: "time" }
@@ -150,7 +173,7 @@ test("buildCrudFormPayload normalizes time fields to canonical HH:MM", () => {
 
   assert.deepEqual(payload, {
     fromTime: "18:13",
-    toTime: "18:45"
+    toTime: "18:45:00"
   });
 });
 
@@ -224,7 +247,7 @@ test("buildCrudFormPayload preserves nullable booleans while keeping non-nullabl
   );
 });
 
-test("applyCrudPayloadToForm normalizes time fields for form inputs", () => {
+test("applyCrudPayloadToForm preserves strict time values for form inputs", () => {
   const fields = [
     { key: "fromTime", type: "string", format: "time" },
     { key: "toTime", type: "string", format: "time" }
@@ -240,11 +263,34 @@ test("applyCrudPayloadToForm normalizes time fields for form inputs", () => {
   });
 
   assert.deepEqual(form, {
-    fromTime: "18:13",
+    fromTime: "18:13:00",
     toTime: "18:45"
   });
 });
 
+test("strict temporal form values round-trip seconds and fractions", () => {
+  const fields = [
+    { key: "fromTime", type: "string", format: "time", temporalPrecision: 6 },
+    { key: "scheduledAt", type: "string", format: "date-time", temporalPrecision: 3 }
+  ];
+  const form = reactive({
+    fromTime: "",
+    scheduledAt: ""
+  });
+
+  applyCrudPayloadToForm(fields, form, {
+    fromTime: "18:13:14.123456",
+    scheduledAt: "2026-08-13T07:08:09.123Z"
+  });
+
+  assert.equal(form.fromTime, "18:13:14.123456");
+  assert.match(form.scheduledAt, /^2026-08-13T\d{2}:\d{2}:09\.123$/u);
+  assert.deepEqual(buildCrudFormPayload(fields, form), {
+    fromTime: "18:13:14.123456",
+    scheduledAt: "2026-08-13T07:08:09.123Z"
+  });
+});
+
 test("applyCrudPayloadToForm maps payload values into reactive form model", () => {
   const form = reactive({
     name: "",

package/test/useCrudDeleteAction.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
+import { createSSRApp, h, nextTick, ref } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { createMemoryHistory, createRouter } from "vue-router";
+import {
+  requireCrudDeleteOperation,
+  useCrudDeleteAction
+} from "../src/client/composables/useCrudDeleteAction.js";
+
+const deleteResource = Object.freeze({
+  namespace: "notes",
+  operations: Object.freeze({
+    delete: Object.freeze({
+      method: "DELETE"
+    })
+  })
+});
+
+function createTestRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: "/notes", component: { render: () => h("div") } },
+      { path: "/notes/:noteId", component: { render: () => h("div") } }
+    ]
+  });
+}
+
+function createScreen() {
+  return Object.freeze({
+    view: Object.freeze({
+      recordId: ref("42"),
+      record: ref({ id: "42", title: "Keep it simple" }),
+      isLoading: ref(false),
+      isNotFound: ref(false),
+      resolveParams(template = "") {
+        return String(template || "").replace(":noteId", "42");
+      }
+    }),
+    listLocation: ref({ path: "/notes" })
+  });
+}
+
+async function renderDeleteAction({ client, queryClient = new QueryClient() } = {}) {
+  const router = createTestRouter();
+  await router.push("/notes/42");
+  await router.isReady();
+
+  let deleteAction = null;
+  const app = createSSRApp({
+    setup() {
+      deleteAction = useCrudDeleteAction({
+        screen: createScreen(),
+        resource: deleteResource,
+        resourceNamespace: "notes",
+        apiUrlTemplate: "/notes/:noteId",
+        client
+      });
+      return () => h("div");
+    }
+  });
+  app.use(router);
+  app.use(VueQueryPlugin, { queryClient });
+  await renderToString(app);
+
+  return { deleteAction, queryClient, router };
+}
+
+test("useCrudDeleteAction confirms one DELETE, invalidates CRUD state, and returns to the list", async () => {
+  const requests = [];
+  const invalidations = [];
+  let finishRequest = null;
+  const queryClient = new QueryClient();
+  queryClient.invalidateQueries = async function invalidateQueries(options = {}) {
+    invalidations.push(options);
+  };
+  const pendingRequest = new Promise((resolve) => {
+    finishRequest = resolve;
+  });
+  const client = {
+    async request(path, options = {}) {
+      requests.push({ path, options });
+      return pendingRequest;
+    }
+  };
+  const { deleteAction, router } = await renderDeleteAction({ client, queryClient });
+
+  assert.equal(deleteAction.canDelete, true);
+  assert.equal(deleteAction.request(), true);
+  assert.equal(deleteAction.isOpen, true);
+
+  const confirmation = deleteAction.confirm();
+  await nextTick();
+  assert.equal(deleteAction.isDeleting, true);
+  assert.equal(requests.length, 1);
+  assert.match(requests[0].path, /\/notes\/42$/);
+  assert.equal(requests[0].options.method, "DELETE");
+  assert.equal(Object.hasOwn(requests[0].options, "body"), false);
+
+  finishRequest(null);
+  await confirmation;
+
+  assert.equal(deleteAction.isDeleting, false);
+  assert.equal(deleteAction.isOpen, false);
+  assert.equal(router.currentRoute.value.path, "/notes");
+  assert.deepEqual(invalidations, [
+    { queryKey: ["ui-generator", "notes"] }
+  ]);
+});
+
+test("useCrudDeleteAction keeps the record dialog open with useful error feedback", async () => {
+  const client = {
+    async request() {
+      throw new Error("Delete service unavailable.");
+    }
+  };
+  const { deleteAction, router } = await renderDeleteAction({ client });
+
+  deleteAction.request();
+  await deleteAction.confirm();
+
+  assert.equal(deleteAction.isOpen, true);
+  assert.equal(deleteAction.isDeleting, false);
+  assert.equal(deleteAction.error, "Delete service unavailable.");
+  assert.equal(router.currentRoute.value.path, "/notes/42");
+});
+
+test("useCrudDeleteAction rejects resources without the canonical DELETE operation", () => {
+  assert.throws(
+    () => requireCrudDeleteOperation({ operations: {} }),
+    /requires resource\.operations\.delete/
+  );
+  assert.throws(
+    () => requireCrudDeleteOperation({ operations: { delete: { method: "POST" } } }),
+    /method to be DELETE/
+  );
+});