@jskit-ai/http-web 0.1.1

package/src/client/support/crudListDateFilterSupport.js

@@ -0,0 +1,91 @@
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/u;
+
+function parseDateOnlyValue(value = "") {
+  const match = DATE_ONLY_PATTERN.exec(String(value || "").trim());
+  if (!match) {
+    return null;
+  }
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(0);
+  date.setHours(12, 0, 0, 0);
+  date.setFullYear(year, month - 1, day);
+
+  if (
+    date.getFullYear() !== year ||
+    date.getMonth() !== month - 1 ||
+    date.getDate() !== day
+  ) {
+    return null;
+  }
+
+  return date;
+}
+
+function formatDateOnlyValue(value = null) {
+  const source = Array.isArray(value) ? value[0] : value;
+  const date = source instanceof Date
+    ? source
+    : parseDateOnlyValue(source);
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  const year = date.getFullYear();
+  if (year < 0 || year > 9999) {
+    return "";
+  }
+
+  return [
+    String(year).padStart(4, "0"),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0")
+  ].join("-");
+}
+
+function formatDateOnlyDisplay(value = "", { locale = undefined } = {}) {
+  const date = parseDateOnlyValue(value);
+  if (!date) {
+    return "";
+  }
+
+  try {
+    return new Intl.DateTimeFormat(locale || undefined, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }).format(date);
+  } catch {
+    return formatDateOnlyValue(date);
+  }
+}
+
+function formatCrudListDateFilterChipLabel(filter = {}, rawValue, { locale = undefined } = {}) {
+  if (filter.type === "date") {
+    const dateLabel = formatDateOnlyDisplay(rawValue, { locale }) || String(rawValue || "");
+    return dateLabel ? `${filter.label}: ${dateLabel}` : "";
+  }
+
+  if (filter.type !== "dateRange") {
+    return "";
+  }
+
+  const from = formatDateOnlyDisplay(rawValue?.from, { locale }) || String(rawValue?.from || "");
+  const to = formatDateOnlyDisplay(rawValue?.to, { locale }) || String(rawValue?.to || "");
+  if (from && to) {
+    return `${filter.label}: ${from} to ${to}`;
+  }
+  if (from) {
+    return `${filter.label}: from ${from}`;
+  }
+  return to ? `${filter.label}: to ${to}` : "";
+}
+
+export {
+  parseDateOnlyValue,
+  formatDateOnlyValue,
+  formatDateOnlyDisplay,
+  formatCrudListDateFilterChipLabel
+};

package/test/addEditUiRuntime.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import { createAddEditUiRuntime } from "../src/client/composables/runtime/addEditUiRuntime.js";
+
+test("createAddEditUiRuntime resolves api/list/cancel paths from route params", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "addressId",
+    routeParams: ref({
+      contactId: "7",
+      addressId: "42"
+    }),
+    routePath: ref("/contacts/7/addresses/new"),
+    apiUrlTemplate: "/crud/contacts/:contactId/addresses/:addressId",
+    viewUrlTemplate: "../:addressId",
+    listUrlTemplate: ".."
+  });
+
+  assert.equal(runtime.recordId.value, "42");
+  assert.equal(runtime.apiSuffix.value, "/crud/contacts/7/addresses/42");
+  assert.equal(runtime.listUrl.value, "/contacts/7/addresses");
+  assert.equal(runtime.cancelUrl.value, "/contacts/7/addresses/42");
+  assert.equal(runtime.resolveParams("../:addressId"), "/contacts/7/addresses/42");
+});
+
+test("createAddEditUiRuntime resolves view urls for saved payload ids with nested params", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "addressId",
+    routeParams: ref({
+      contactId: "7"
+    }),
+    viewUrlTemplate: "/contacts/:contactId/addresses/:addressId"
+  });
+
+  assert.equal(runtime.resolveSavedViewUrl({ id: 99 }), "/contacts/7/addresses/99");
+});
+
+test("createAddEditUiRuntime keeps nested child routes stable when the saved child id matches a parent id", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "addressId",
+    routeParams: ref({
+      workspaceSlug: "tonymobily",
+      contactId: "1"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId"]),
+    routePath: ref("/w/tonymobily/admin/contacts/1/addresses/new"),
+    viewUrlTemplate: "../:addressId",
+    listUrlTemplate: ".."
+  });
+
+  assert.equal(runtime.listUrl.value, "/w/tonymobily/admin/contacts/1/addresses");
+  assert.equal(runtime.resolveSavedViewUrl({ id: 1 }), "/w/tonymobily/admin/contacts/1/addresses/1");
+});
+
+test("createAddEditUiRuntime resolves edit-page relative list and cancel links", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "addressId",
+    routeParams: ref({
+      contactId: "7",
+      addressId: "42"
+    }),
+    routePath: ref("/contacts/7/addresses/42/edit"),
+    viewUrlTemplate: "..",
+    listUrlTemplate: "../.."
+  });
+
+  assert.equal(runtime.listUrl.value, "/contacts/7/addresses");
+  assert.equal(runtime.cancelUrl.value, "/contacts/7/addresses/42");
+});
+
+test("createAddEditUiRuntime resolves nested edit links from the record scope", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "petId",
+    routeParams: ref({
+      workspaceSlug: "dogandgroom",
+      contactId: "541841",
+      petId: "715528"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528/edit/advanced"),
+    viewUrlTemplate: "..",
+    listUrlTemplate: "../.."
+  });
+
+  assert.equal(runtime.cancelUrl.value, "/w/dogandgroom/admin/contacts/541841/pets/715528");
+  assert.equal(runtime.listUrl.value, "/w/dogandgroom/admin/contacts/541841/pets");
+});
+
+test("createAddEditUiRuntime supports custom saved-record selector", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "addressId",
+    routeParams: ref({
+      contactId: "7"
+    }),
+    viewUrlTemplate: "/contacts/:contactId/addresses/:addressId",
+    saveRecordIdSelector: (payload = {}) => payload.uuid
+  });
+
+  assert.equal(runtime.resolveSavedViewUrl({ uuid: "abc-123" }), "/contacts/7/addresses/abc-123");
+});
+
+test("createAddEditUiRuntime validates route parameter names", () => {
+  assert.throws(
+    () =>
+      createAddEditUiRuntime({
+        recordIdParam: "record-id"
+      }),
+    /recordIdParam "record-id" is invalid/
+  );
+});

package/test/crudBindingSupport.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import {
+  CRUD_BINDING_MODE_ROUTE,
+  CRUD_BINDING_MODE_MERGE,
+  CRUD_BINDING_MODE_EXPLICIT,
+  CRUD_BINDING_MODE_NONE,
+  normalizeCrudBindingMode,
+  resolveCrudBoundValues
+} from "../src/client/composables/crud/crudBindingSupport.js";
+
+test("normalizeCrudBindingMode defaults invalid values to route", () => {
+  assert.equal(normalizeCrudBindingMode(""), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("unknown"), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("merge"), CRUD_BINDING_MODE_MERGE);
+  assert.equal(normalizeCrudBindingMode("explicit"), CRUD_BINDING_MODE_EXPLICIT);
+  assert.equal(normalizeCrudBindingMode("none"), CRUD_BINDING_MODE_NONE);
+});
+
+test("resolveCrudBoundValues returns route values in route mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "route",
+      values: {
+        contactId: "22"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11"
+  });
+});
+
+test("resolveCrudBoundValues merges explicit values over route values in merge mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "merge",
+      values: {
+        contactId: "22",
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "22",
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues uses only explicit values in explicit mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "explicit",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues disables automatic binding in none mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "none",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {});
+});
+
+test("resolveCrudBoundValues unwraps reactive binding config and values", () => {
+  const values = resolveCrudBoundValues({
+    binding: ref({
+      mode: "merge",
+      values: ref({
+        serviceId: "4"
+      })
+    }),
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11",
+    serviceId: "4"
+  });
+});

package/test/crudHttpClientSupport.test.js

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  normalizeCrudApiAccess,
+  resolveCrudHttpClient
+} from "../src/client/composables/crud/crudHttpClientSupport.js";
+import {
+  __testables as crudListScreenTestables
+} from "../src/client/composables/useCrudListScreen.js";
+
+test("resolveCrudHttpClient injects per-request CSRF opt-out for public resources", async () => {
+  const calls = [];
+  const configuredClient = {
+    async request(url, options) {
+      calls.push([url, options]);
+      return { ok: true };
+    }
+  };
+  const client = resolveCrudHttpClient({ apiAccess: "public" }, {
+    client: configuredClient
+  });
+
+  for (const method of ["POST", "PATCH", "DELETE"]) {
+    await client.request("/api/books/1", {
+      method,
+      csrf: true
+    });
+  }
+
+  assert.deepEqual(
+    calls.map(([url, options]) => [url, options.method, options.csrf]),
+    [
+      ["/api/books/1", "POST", false],
+      ["/api/books/1", "PATCH", false],
+      ["/api/books/1", "DELETE", false]
+    ]
+  );
+});
+
+test("resolveCrudHttpClient preserves the configured client for authenticated resources", () => {
+  const configuredClient = {
+    request() {}
+  };
+
+  assert.equal(
+    resolveCrudHttpClient({ apiAccess: "authenticated" }, { client: configuredClient }),
+    configuredClient
+  );
+  assert.equal(
+    resolveCrudHttpClient({}, { client: configuredClient }),
+    configuredClient
+  );
+  assert.equal(normalizeCrudApiAccess(""), "authenticated");
+  assert.throws(
+    () => resolveCrudHttpClient({ apiAccess: "always" }, { client: configuredClient }),
+    /apiAccess must be one of: authenticated, public/
+  );
+});
+
+test("CRUD list row and bulk action context carries the resource-aware client", () => {
+  const records = {
+    reload() {}
+  };
+  const client = {
+    request() {}
+  };
+
+  assert.deepEqual(
+    crudListScreenTestables.buildCrudListActionContext(records, client),
+    {
+      records,
+      reload: records.reload,
+      client
+    }
+  );
+});

package/test/crudJsonApiTransportSupport.test.js

@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createSchema } from "json-rest-schema";
+import {
+  inferCrudJsonApiTransport,
+  inferCrudLookupJsonApiTransport,
+  resolveCrudJsonApiTransport,
+  resolveLookupFieldMap
+} from "../src/client/composables/crud/crudJsonApiTransportSupport.js";
+
+const resource = {
+  namespace: "pets",
+  contract: {
+    lookup: {
+      containerKey: "lookups"
+    }
+  },
+  operations: {
+    view: {
+      output: {
+        schema: createSchema({
+          id: {
+            type: "string",
+            required: true
+          },
+          contactId: {
+            type: "string",
+            required: true,
+            belongsTo: "contacts",
+            as: "contact"
+          },
+          breedId: {
+            type: "string",
+            nullable: true,
+            belongsTo: "breeds",
+            as: "breed"
+          }
+        })
+      }
+    }
+  }
+};
+
+test("inferCrudJsonApiTransport infers collection transport for CRUD lists", () => {
+  assert.deepEqual(
+    inferCrudJsonApiTransport(resource, {
+      mode: "list"
+    }),
+    {
+      kind: "jsonapi-resource",
+      responseType: "pets",
+      responseKind: "collection"
+    }
+  );
+});
+
+test("inferCrudJsonApiTransport infers record request/response transport for CRUD add/edit", () => {
+  assert.deepEqual(
+    inferCrudJsonApiTransport(resource, {
+      mode: "add-edit",
+      operationName: "patch"
+    }),
+    {
+      kind: "jsonapi-resource",
+      requestType: "pets",
+      responseType: "pets",
+      responseKind: "record"
+    }
+  );
+});
+
+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({
+      namespace: "services"
+    }),
+    {
+      kind: "jsonapi-resource",
+      responseType: "services",
+      responseKind: "collection"
+    }
+  );
+});
+
+test("inferCrudLookupJsonApiTransport infers collection transport from lookup apiPath", () => {
+  assert.deepEqual(
+    inferCrudLookupJsonApiTransport({
+      apiPath: "/contact-roles"
+    }),
+    {
+      kind: "jsonapi-resource",
+      responseType: "contact-roles",
+      responseKind: "collection"
+    }
+  );
+});
+
+test("inferCrudLookupJsonApiTransport returns null without a lookup namespace", () => {
+  assert.equal(
+    inferCrudLookupJsonApiTransport({}),
+    null
+  );
+});
+
+test("resolveLookupFieldMap derives lookup aliases from the shared CRUD resource", () => {
+  assert.deepEqual(resolveLookupFieldMap(resource), {
+    breed: "breedId",
+    contact: "contactId"
+  });
+});
+
+test("resolveCrudJsonApiTransport infers and enriches JSON:API transport from the resource", () => {
+  assert.deepEqual(
+    resolveCrudJsonApiTransport(undefined, resource, {
+      mode: "list"
+    }),
+    {
+      kind: "jsonapi-resource",
+      responseType: "pets",
+      responseKind: "collection",
+      lookupContainerKey: "lookups",
+      lookupFieldMap: {
+        breed: "breedId",
+        contact: "contactId"
+      }
+    }
+  );
+});
+
+test("resolveCrudJsonApiTransport infers record request/response transport for CRUD add/edit", () => {
+  assert.deepEqual(
+    resolveCrudJsonApiTransport(undefined, resource, {
+      mode: "add-edit",
+      operationName: "patch"
+    }),
+    {
+      kind: "jsonapi-resource",
+      requestType: "pets",
+      responseType: "pets",
+      responseKind: "record",
+      lookupContainerKey: "lookups",
+      lookupFieldMap: {
+        breed: "breedId",
+        contact: "contactId"
+      }
+    }
+  );
+});
+
+test("resolveCrudJsonApiTransport rejects explicit CRUD transport overrides", () => {
+  assert.throws(
+    () =>
+      resolveCrudJsonApiTransport(
+        {
+          kind: "jsonapi-resource",
+          responseType: "pets",
+          responseKind: "record"
+        },
+        resource,
+        {
+          mode: "view"
+        }
+      ),
+    /do not accept explicit transport/
+  );
+});

package/test/crudListBulkActionSurface.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_DIR = path.resolve(TEST_DIRECTORY, "..");
+
+test("CrudListBulkActionSurface stays adaptive and runtime-owned", async () => {
+  const source = await readFile(
+    path.join(PACKAGE_DIR, "src", "client", "components", "CrudListBulkActionSurface.vue"),
+    "utf8"
+  );
+
+  assert.match(source, /defineProps/);
+  assert.match(source, /useDisplay/);
+  assert.match(source, /v-if="shouldRender"/);
+  assert.match(source, /selectedCount/);
+  assert.match(source, /hasActions/);
+  assert.match(source, /hasSelection/);
+  assert.match(source, /v-menu/);
+  assert.match(source, /Bulk actions/);
+  assert.match(source, /min-height:\s*48px/);
+  assert.doesNotMatch(source, /useCrudList\(/);
+  assert.doesNotMatch(source, /apiSuffix|repository|server/);
+});

package/test/crudListDateFilterSupport.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+import {
+  parseDateOnlyValue,
+  formatDateOnlyValue,
+  formatDateOnlyDisplay,
+  formatCrudListDateFilterChipLabel
+} from "../src/client/support/crudListDateFilterSupport.js";
+
+test("date filter picker values round-trip through the YYYY-MM-DD contract", () => {
+  const parsed = parseDateOnlyValue("2026-04-18");
+
+  assert.ok(parsed instanceof Date);
+  assert.equal(parsed.getFullYear(), 2026);
+  assert.equal(parsed.getMonth(), 3);
+  assert.equal(parsed.getDate(), 18);
+  assert.equal(formatDateOnlyValue(parsed), "2026-04-18");
+  assert.equal(formatDateOnlyValue([new Date(2026, 4, 9)]), "2026-05-09");
+  assert.equal(formatDateOnlyValue("2026-11-03"), "2026-11-03");
+});
+
+test("date filter parsing rejects impossible calendar dates", () => {
+  assert.equal(parseDateOnlyValue("2026-02-29"), null);
+  assert.ok(parseDateOnlyValue("2028-02-29") instanceof Date);
+  assert.equal(parseDateOnlyValue("04/18/2026"), null);
+  assert.equal(parseDateOnlyValue(""), null);
+  assert.equal(formatDateOnlyValue(new Date("invalid")), "");
+});
+
+test("date filter display and chip labels are locale-aware without exposing Date strings", () => {
+  assert.equal(formatDateOnlyDisplay("2026-04-18", { locale: "en-US" }), "Apr 18, 2026");
+  assert.equal(formatDateOnlyDisplay("2026-04-18", { locale: "en-GB" }), "18 Apr 2026");
+  assert.equal(
+    formatCrudListDateFilterChipLabel(
+      { type: "date", label: "Submitted" },
+      "2026-04-18",
+      { locale: "en-US" }
+    ),
+    "Submitted: Apr 18, 2026"
+  );
+  assert.equal(
+    formatCrudListDateFilterChipLabel(
+      { type: "dateRange", label: "Arrival" },
+      { from: "2026-05-04", to: "2026-05-10" },
+      { locale: "en-US" }
+    ),
+    "Arrival: May 4, 2026 to May 10, 2026"
+  );
+  assert.equal(
+    formatCrudListDateFilterChipLabel(
+      { type: "dateRange", label: "Arrival" },
+      { from: "", to: "2026-05-10" },
+      { locale: "en-US" }
+    ),
+    "Arrival: to May 10, 2026"
+  );
+});
+
+test("date-only conversion does not shift across time zones", () => {
+  const supportModuleUrl = new URL(
+    "../src/client/support/crudListDateFilterSupport.js",
+    import.meta.url
+  ).href;
+  const script = `
+    import { parseDateOnlyValue, formatDateOnlyValue } from ${JSON.stringify(supportModuleUrl)};
+    const parsed = parseDateOnlyValue("2026-01-01");
+    process.stdout.write(JSON.stringify({
+      value: formatDateOnlyValue(parsed),
+      year: parsed.getFullYear(),
+      month: parsed.getMonth(),
+      day: parsed.getDate()
+    }));
+  `;
+
+  for (const timezone of ["UTC", "America/Los_Angeles", "Pacific/Kiritimati"]) {
+    const result = spawnSync(process.execPath, ["--input-type=module", "--eval", script], {
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        TZ: timezone
+      }
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(JSON.parse(result.stdout), {
+      value: "2026-01-01",
+      year: 2026,
+      month: 0,
+      day: 1
+    }, timezone);
+  }
+});