@jskit-ai/users-web 0.1.165 → 0.1.168

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/
+  );
+});