@anzusystems/common-admin 1.47.0-beta.dev-1790143991 → 2.0.0-rc.1

package/dist/domains/anzuUser/composables/anzuUserActions.d.ts

@@ -0,0 +1,143 @@
+import { Ref } from 'vue';
+import { AxiosClientFn } from '../../api/utils/client';
+import { FilterConfig, FilterData } from '../../filters/composables/filterFactory';
+import { Pagination } from '../../api/composables/pagination';
+import { AnzuUser } from '../../../shared/types/AnzuUser';
+import { IntegerId } from '../../../shared/types/common';
+export interface AnzuUserActionsParams {
+    client: AxiosClientFn;
+    system: string;
+    entity?: string;
+    /**
+     * i18n scope for a server-side validation failure, which is a different question from which
+     * backend answered. `AnzuApiValidationError` builds `<system>.<entity>.model.<field>` keys, so
+     * the pair has to name the namespace the *labels* live under. It defaults to `common` +
+     * `anzuUser`, which is where the shared form's own fields are; an admin whose form carries
+     * system fields as well passes its own pair, and keeps the base keys beside them.
+     */
+    validationSystem?: string;
+    validationEntity?: string;
+    endPoint?: string;
+    /** Vuelidate scope, when the page collects its fields under one of its own. */
+    validationScope?: string | symbol;
+}
+/**
+ * Per instance, like every other actions composable here. The admins' versions kept their loading
+ * flags at module scope.
+ */
+export declare const useAnzuUserActions: (params: AnzuUserActionsParams) => {
+    isDirty: import('vue').ComputedRef<boolean>;
+    /** Takes the record as it stands as the new baseline; the page calls it after it seeds one. */
+    markPristine: () => void;
+    anzuUserList: Ref<{
+        enabled: boolean;
+        locale: import('../../../lib').LanguageCode | null;
+        roles: string[];
+        permissionGroups: IntegerId[];
+        permissions: import('../../../lib').Permissions;
+        resolvedPermissions: import('../../../lib').Permissions;
+        _resourceName: string;
+        _system: string;
+        createdAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedBy: import('../../../shared/types/common').IntegerIdNullable;
+        createdBy: import('../../../shared/types/common').IntegerIdNullable;
+        id?: import('../../../shared/types/common').IntegerIdNullable | undefined;
+        email: string;
+        person: {
+            firstName: string;
+            lastName: string;
+            fullName: string;
+        };
+        avatar: {
+            color: string;
+            text: string;
+        };
+    }[], AnzuUser[] | {
+        enabled: boolean;
+        locale: import('../../../lib').LanguageCode | null;
+        roles: string[];
+        permissionGroups: IntegerId[];
+        permissions: import('../../../lib').Permissions;
+        resolvedPermissions: import('../../../lib').Permissions;
+        _resourceName: string;
+        _system: string;
+        createdAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedBy: import('../../../shared/types/common').IntegerIdNullable;
+        createdBy: import('../../../shared/types/common').IntegerIdNullable;
+        id?: import('../../../shared/types/common').IntegerIdNullable | undefined;
+        email: string;
+        person: {
+            firstName: string;
+            lastName: string;
+            fullName: string;
+        };
+        avatar: {
+            color: string;
+            text: string;
+        };
+    }[]>;
+    loadingAnzuUserList: Ref<boolean, boolean>;
+    datatableHiddenColumns: Ref<string[], string[]>;
+    fetchAnzuUserList: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>) => Promise<void>;
+    cancelAnzuUserList: () => void;
+    anzuUser: Ref<{
+        enabled: boolean;
+        locale: import('../../../lib').LanguageCode | null;
+        roles: string[];
+        permissionGroups: IntegerId[];
+        permissions: import('../../../lib').Permissions;
+        resolvedPermissions: import('../../../lib').Permissions;
+        _resourceName: string;
+        _system: string;
+        createdAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedBy: import('../../../shared/types/common').IntegerIdNullable;
+        createdBy: import('../../../shared/types/common').IntegerIdNullable;
+        id?: import('../../../shared/types/common').IntegerIdNullable | undefined;
+        email: string;
+        person: {
+            firstName: string;
+            lastName: string;
+            fullName: string;
+        };
+        avatar: {
+            color: string;
+            text: string;
+        };
+    }, AnzuUser | {
+        enabled: boolean;
+        locale: import('../../../lib').LanguageCode | null;
+        roles: string[];
+        permissionGroups: IntegerId[];
+        permissions: import('../../../lib').Permissions;
+        resolvedPermissions: import('../../../lib').Permissions;
+        _resourceName: string;
+        _system: string;
+        createdAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedAt: import('../../../shared/types/common').DatetimeUTC;
+        modifiedBy: import('../../../shared/types/common').IntegerIdNullable;
+        createdBy: import('../../../shared/types/common').IntegerIdNullable;
+        id?: import('../../../shared/types/common').IntegerIdNullable | undefined;
+        email: string;
+        person: {
+            firstName: string;
+            lastName: string;
+            fullName: string;
+        };
+        avatar: {
+            color: string;
+            text: string;
+        };
+    }>;
+    loadingAnzuUser: Ref<boolean, boolean>;
+    fetchAnzuUser: (id: IntegerId, options?: {
+        signal?: AbortSignal;
+    }) => Promise<boolean | undefined>;
+    createAnzuUser: () => Promise<AnzuUser | null>;
+    updateAnzuUser: () => Promise<boolean>;
+    loadingCreateAnzuUser: Ref<boolean, boolean>;
+    loadingUpdateAnzuUser: Ref<boolean, boolean>;
+    resetAnzuUserStore: (system?: string | undefined, resourceName?: string | undefined) => void;
+};

package/dist/domains/anzuUser/composables/anzuUserActions.js

@@ -0,0 +1,100 @@
+import { isNull as e, isUndefined as t } from "../../../shared/utils/common.js";
+import { AnzuFatalError as n } from "../../../shared/error/AnzuFatalError.js";
+import { useAlerts as r } from "../../system/composables/alerts.js";
+import { handleRecordLoadError as i } from "../../system/composables/recordPage.js";
+import { syncUserAndTimeTracking as a } from "../../../shared/utils/userAndTimeTracking.js";
+import { ANZU_USER_ENDPOINT as o, ANZU_USER_ENTITY as s, useAnzuUserApi as c } from "../api/anzuUserApi.js";
+import { useAnzuUserOneStore as l } from "../store/anzuUserStore.js";
+import { computed as u, nextTick as d, ref as f } from "vue";
+import p from "@vuelidate/core";
+import { storeToRefs as m } from "pinia";
+//#region src/domains/anzuUser/composables/anzuUserActions.ts
+var h = 0, g = (g) => {
+	let { client: _, system: v, entity: y = s, endPoint: b = o } = g, { showErrorsDefault: x, showRecordWas: S, showValidationError: C } = r(), { useFetchAnzuUserList: w, useFetchAnzuUser: T, useCreateAnzuUser: E, useUpdateAnzuUser: D } = c({
+		client: _,
+		system: v,
+		entity: y,
+		validationSystem: g.validationSystem,
+		validationEntity: g.validationEntity,
+		endPoint: b
+	}), { execute: O, abort: k } = w(), A = f([]), j = f(!1), M = f([]), N = 0, P = async (e, t, n) => {
+		let r = ++N;
+		j.value = !0;
+		try {
+			let i = await O(e, t, n);
+			if (r !== N) return;
+			A.value = i;
+		} catch (e) {
+			if (r !== N) return;
+			A.value = [], x(e);
+		} finally {
+			r === N && (j.value = !1);
+		}
+	}, F = () => {
+		N++, k();
+	}, I = l(), { anzuUser: L, loadingAnzuUser: R } = m(I), z = f(""), B = () => {
+		z.value = JSON.stringify(I.anzuUser);
+	}, V = u(() => z.value !== "" && z.value !== JSON.stringify(L.value)), H = async (e, t = {}) => {
+		let n = ++h, r = () => h === n;
+		I.setLoadingAnzuUser(!0);
+		try {
+			let { execute: n } = T(), i = await n({
+				urlParams: { id: e },
+				signal: t.signal
+			});
+			return r() ? (I.setAnzuUser(i), await d(), B(), !0) : void 0;
+		} catch (e) {
+			return r() ? (I.reset(v), z.value = "", !i(e) && void 0) : void 0;
+		} finally {
+			r() && I.setLoadingAnzuUser(!1);
+		}
+	}, U = g.validationScope ? p({}, {}, { $scope: g.validationScope }) : p(), W = f(!1), G = async () => {
+		try {
+			if (W.value = !0, U.value.$touch(), U.value.$invalid) return C(), null;
+			let { execute: e } = E(), t = await e({ body: I.anzuUser });
+			return S("created"), B(), t;
+		} catch (e) {
+			return x(e), null;
+		} finally {
+			W.value = !1;
+		}
+	}, K = f(!1);
+	return {
+		isDirty: V,
+		markPristine: B,
+		anzuUserList: A,
+		loadingAnzuUserList: j,
+		datatableHiddenColumns: M,
+		fetchAnzuUserList: P,
+		cancelAnzuUserList: F,
+		anzuUser: L,
+		loadingAnzuUser: R,
+		fetchAnzuUser: H,
+		createAnzuUser: G,
+		updateAnzuUser: async () => {
+			try {
+				if (K.value = !0, U.value.$touch(), U.value.$invalid) return C(), !1;
+				let r = I.anzuUser.id;
+				if (e(r) || t(r)) throw new n(void 0, "[useAnzuUserActions] update called on a record with no id.");
+				let { execute: i } = D(), o = await i({
+					urlParams: { id: r },
+					body: I.anzuUser
+				});
+				return a(I.anzuUser, o), S("updated"), B(), !0;
+			} catch (e) {
+				return x(e), !1;
+			} finally {
+				K.value = !1;
+			}
+		},
+		loadingCreateAnzuUser: W,
+		loadingUpdateAnzuUser: K,
+		resetAnzuUserStore: (...e) => {
+			h++, I.reset(...e);
+		}
+	};
+};
+//#endregion
+export { g as useAnzuUserActions };
+
+//# sourceMappingURL=anzuUserActions.js.map

package/dist/domains/anzuUser/composables/anzuUserActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anzuUserActions.js","names":["useVuelidate","fetchGeneration","useAnzuUserActions","ANZU_USER_ENTITY","ANZU_USER_ENDPOINT","params","useAlerts","useAnzuUserApi","executeList","abortList","useFetchAnzuUserList","anzuUserList","ref","loadingAnzuUserList","datatableHiddenColumns","listGeneration","fetchAnzuUserList","token","items","pagination","filterData","filterConfig","error","showErrorsDefault","cancelAnzuUserList","anzuUserOneStore","useAnzuUserOneStore","storeToRefs","pristine","snapshot","isDirty","computed","anzuUser","fetchAnzuUser","generation","isLatest","useFetchAnzuUser","res","execute","options","nextTick","system","v$","loadingCreateAnzuUser","createAnzuUser","showValidationError","useCreateAnzuUser","created","showRecordWas","loadingUpdateAnzuUser","id","isNull","isUndefined","AnzuFatalError","useUpdateAnzuUser","syncUserAndTimeTracking","args"],"sources":["../../../../src/domains/anzuUser/composables/anzuUserActions.ts"],"sourcesContent":["import { computed, nextTick, ref, type Ref } from 'vue'\nimport { storeToRefs } from 'pinia'\nimport useVuelidate from '@vuelidate/core'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport { handleRecordLoadError } from '@/domains/system/composables/recordPage'\nimport type { AxiosClientFn } from '@/domains/api/utils/client'\nimport type { FilterConfig, FilterData } from '@/domains/filters/composables/filterFactory'\nimport type { Pagination } from '@/domains/api/composables/pagination'\nimport { ANZU_USER_ENDPOINT, ANZU_USER_ENTITY, useAnzuUserApi } from '@/domains/anzuUser/api/anzuUserApi'\nimport { useAnzuUserOneStore } from '@/domains/anzuUser/store/anzuUserStore'\nimport type { AnzuUser } from '@/shared/types/AnzuUser'\nimport type { IntegerId } from '@/shared/types/common'\nimport { AnzuFatalError } from '@/shared/error/AnzuFatalError'\nimport { isNull, isUndefined } from '@/shared/utils/common'\nimport { syncUserAndTimeTracking } from '@/shared/utils/userAndTimeTracking'\n\nexport interface AnzuUserActionsParams {\n  client: AxiosClientFn\n  system: string\n  entity?: string\n  /**\n   * i18n scope for a server-side validation failure, which is a different question from which\n   * backend answered. `AnzuApiValidationError` builds `<system>.<entity>.model.<field>` keys, so\n   * the pair has to name the namespace the *labels* live under. It defaults to `common` +\n   * `anzuUser`, which is where the shared form's own fields are; an admin whose form carries\n   * system fields as well passes its own pair, and keeps the base keys beside them.\n   */\n  validationSystem?: string\n  validationEntity?: string\n  endPoint?: string\n  /** Vuelidate scope, when the page collects its fields under one of its own. */\n  validationScope?: string | symbol\n}\n\n// The record store is one for every page and every system, and a request is not aborted when its page\n// goes: only the latest fetch may write the record, or reset it on failure. A store reset (a page's\n// teardown, a create page's mount) counts as newer too.\nlet fetchGeneration = 0\n\n/**\n * Per instance, like every other actions composable here. The admins' versions kept their loading\n * flags at module scope.\n */\nexport const useAnzuUserActions = (params: AnzuUserActionsParams) => {\n  const { client, system, entity = ANZU_USER_ENTITY, endPoint = ANZU_USER_ENDPOINT } = params\n\n  const { showErrorsDefault, showRecordWas, showValidationError } = useAlerts()\n  const { useFetchAnzuUserList, useFetchAnzuUser, useCreateAnzuUser, useUpdateAnzuUser } = useAnzuUserApi({\n    client,\n    system,\n    entity,\n    validationSystem: params.validationSystem,\n    validationEntity: params.validationEntity,\n    endPoint,\n  })\n\n  const { execute: executeList, abort: abortList } = useFetchAnzuUserList()\n\n  const anzuUserList = ref<AnzuUser[]>([])\n  const loadingAnzuUserList = ref(false)\n  const datatableHiddenColumns = ref<Array<string>>([])\n\n  let listGeneration = 0\n\n  const fetchAnzuUserList = async (\n    pagination: Ref<Pagination>,\n    filterData: FilterData<any>,\n    filterConfig: FilterConfig<any>\n  ) => {\n    const token = ++listGeneration\n    loadingAnzuUserList.value = true\n    try {\n      const items = await executeList(pagination, filterData, filterConfig)\n      if (token !== listGeneration) return\n      anzuUserList.value = items\n    } catch (error) {\n      if (token !== listGeneration) return\n      anzuUserList.value = []\n      showErrorsDefault(error)\n    } finally {\n      if (token === listGeneration) loadingAnzuUserList.value = false\n    }\n  }\n\n  const cancelAnzuUserList = () => {\n    listGeneration++\n    abortList()\n  }\n\n  const anzuUserOneStore = useAnzuUserOneStore()\n  const { anzuUser, loadingAnzuUser } = storeToRefs(anzuUserOneStore)\n\n  /**\n   * What the server last said, so the page can tell whether anything has been edited.\n   *\n   * A page needs this for two things that look cosmetic and are not: the dot on the owning tab,\n   * and the guard that asks before leaving. Switching a tab is not navigation -- the form stays\n   * mounted and dirty -- so the moment the operator does leave is through a button inside a panel,\n   * and by then nothing else remembers there was unsaved work.\n   */\n  const pristine = ref<string>('')\n  const snapshot = () => {\n    pristine.value = JSON.stringify(anzuUserOneStore.anzuUser)\n  }\n\n  const isDirty = computed(() => pristine.value !== '' && pristine.value !== JSON.stringify(anzuUser.value))\n\n  /**\n   * `true` once loaded, `false` when the page should leave (`handleRecordLoadError`), `undefined`\n   * when a newer fetch took over or the request was stopped.\n   */\n  const fetchAnzuUser = async (id: IntegerId, options: { signal?: AbortSignal } = {}): Promise<boolean | undefined> => {\n    const generation = ++fetchGeneration\n    const isLatest = () => fetchGeneration === generation\n    anzuUserOneStore.setLoadingAnzuUser(true)\n    try {\n      const { execute } = useFetchAnzuUser()\n      const res = await execute({ urlParams: { id }, signal: options.signal })\n      if (!isLatest()) return undefined\n      anzuUserOneStore.setAnzuUser(res)\n      // After the form has settled, not before it. The derived fields recompute in a watcher, and\n      // a baseline taken ahead of that would make an account whose stored full name is empty read\n      // as edited the instant it opens -- an unsaved dot and a leave prompt before anyone typed.\n      await nextTick()\n      snapshot()\n      return true\n    } catch (error) {\n      // A newer fetch owns the record now, possibly another page's: leave it alone.\n      if (!isLatest()) return undefined\n      // Not the previous record: Save would PUT it back to its own id from a page opened for another.\n      anzuUserOneStore.reset(system)\n      pristine.value = ''\n      return handleRecordLoadError(error) ? false : undefined\n    } finally {\n      if (isLatest()) anzuUserOneStore.setLoadingAnzuUser(false)\n    }\n  }\n\n  // Collects whatever the form's children registered. With a scope it collects only that scope,\n  // which is how an app keeps its own system fields in a separate one.\n  const v$ = params.validationScope ? useVuelidate({}, {}, { $scope: params.validationScope }) : useVuelidate()\n\n  const loadingCreateAnzuUser = ref(false)\n  /**\n   * The body is the store's record, which the library factory built: `roles: []` and\n   * `enabled: false`. That matters -- a hand-assembled body of base fields would have the backend\n   * fill in `ROLE_USER`, and the account would exist with a role nobody granted.\n   */\n  const createAnzuUser = async (): Promise<AnzuUser | null> => {\n    try {\n      loadingCreateAnzuUser.value = true\n      v$.value.$touch()\n      if (v$.value.$invalid) {\n        showValidationError()\n        return null\n      }\n      const { execute } = useCreateAnzuUser()\n      const created = await execute({ body: anzuUserOneStore.anzuUser })\n      showRecordWas('created')\n      snapshot()\n      return created\n    } catch (error) {\n      showErrorsDefault(error)\n      return null\n    } finally {\n      loadingCreateAnzuUser.value = false\n    }\n  }\n\n  const loadingUpdateAnzuUser = ref(false)\n  /**\n   * Sends the whole record the preceding GET returned, with only the edited fields changed.\n   *\n   * That is the write invariant, and it is not a style preference: an omitted field is destructive\n   * rather than neutral. `UserDto` defaults `roles` to `[ROLE_USER]`, `enabled` to `true` and both\n   * permission collections to empty, and the manager writes all four unconditionally -- so a body\n   * carrying only the metadata resets roles, wipes grants, detaches groups and switches a disabled\n   * account back on.\n   */\n  const updateAnzuUser = async (): Promise<boolean> => {\n    try {\n      loadingUpdateAnzuUser.value = true\n      v$.value.$touch()\n      if (v$.value.$invalid) {\n        showValidationError()\n        return false\n      }\n      const id = anzuUserOneStore.anzuUser.id\n      if (isNull(id) || isUndefined(id)) {\n        throw new AnzuFatalError(undefined, '[useAnzuUserActions] update called on a record with no id.')\n      }\n      const { execute } = useUpdateAnzuUser()\n      const res = await execute({\n        urlParams: { id },\n        body: anzuUserOneStore.anzuUser,\n      })\n      // Before the snapshot: `isDirty` compares the whole record, so tracking written after it would\n      // mark the form as unsaved.\n      syncUserAndTimeTracking(anzuUserOneStore.anzuUser, res)\n      showRecordWas('updated')\n      snapshot()\n      return true\n    } catch (error) {\n      showErrorsDefault(error)\n      return false\n    } finally {\n      loadingUpdateAnzuUser.value = false\n    }\n  }\n\n  return {\n    isDirty,\n    /** Takes the record as it stands as the new baseline; the page calls it after it seeds one. */\n    markPristine: snapshot,\n    anzuUserList,\n    loadingAnzuUserList,\n    datatableHiddenColumns,\n    fetchAnzuUserList,\n    cancelAnzuUserList,\n    anzuUser,\n    loadingAnzuUser,\n    fetchAnzuUser,\n    createAnzuUser,\n    updateAnzuUser,\n    loadingCreateAnzuUser,\n    loadingUpdateAnzuUser,\n    resetAnzuUserStore: (...args: Parameters<typeof anzuUserOneStore.reset>) => {\n      fetchGeneration++\n      anzuUserOneStore.reset(...args)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/domains/anzuUser/composables/anzuUserValidations.d.ts

@@ -0,0 +1,217 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { BaseUser } from '../../../shared/types/AnzuUser';
+export interface UserMetadataValidationOptions {
+    /**
+     * The system's profile (`requiredMetadata` on its descriptor). `false` requires only the
+     * e-mail; `true` also requires first name, last name, full name, avatar text and avatar colour.
+     * It applies the same way to creating and to editing -- within a system it is one rule.
+     */
+    required: MaybeRefOrGetter<boolean>;
+    /** Whether the id is a field at all. When it is, and this is a create, it is required. */
+    idInput: MaybeRefOrGetter<boolean>;
+    isEdit: MaybeRefOrGetter<boolean>;
+    /** Scope key, so an owning form can validate its own fields alongside the app's system fields. */
+    scope?: string | symbol | false;
+}
+/**
+ * The `BaseUserDto` rules, per profile.
+ *
+ * The lengths come from the backend constraints (`email` 256, first/last 120, full 242, avatar
+ * text 2-3). The backend requires only the e-mail; the front end is deliberately stricter, and
+ * `requiredMetadata` is what says by how much.
+ */
+export declare function useUserMetadataValidation(user: Ref<BaseUser>, options: UserMetadataValidationOptions): {
+    v$: Ref<import('@vuelidate/core').Validation<{
+        user: {
+            id: {
+                required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+            } | {
+                required?: undefined;
+            };
+            email: {
+                required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                email: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            person: {
+                firstName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+                lastName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+                fullName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+            };
+            avatar: {
+                color: {
+                    hexColor: any;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    hexColor: any;
+                    required?: undefined;
+                };
+                text: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+            };
+        };
+    }, {
+        user: Ref<BaseUser, BaseUser>;
+    }>, import('@vuelidate/core').Validation<{
+        user: {
+            id: {
+                required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+            } | {
+                required?: undefined;
+            };
+            email: {
+                required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                email: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            person: {
+                firstName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+                lastName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+                fullName: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+            };
+            avatar: {
+                color: {
+                    hexColor: any;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    hexColor: any;
+                    required?: undefined;
+                };
+                text: {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required: import('@vuelidate/core').ValidationRuleWithoutParams<any>;
+                } | {
+                    minLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        min: number;
+                    }, any>;
+                    maxLength: import('@vuelidate/core').ValidationRuleWithParams<{
+                        max: number;
+                    }, any>;
+                    required?: undefined;
+                };
+            };
+        };
+    }, {
+        user: Ref<BaseUser, BaseUser>;
+    }>>;
+};

package/dist/domains/anzuUser/composables/anzuUserValidations.js

@@ -0,0 +1,50 @@
+import { useValidate as e } from "../../../shared/validators/vuelidate/useValidate.js";
+import { computed as t, toValue as n } from "vue";
+import r from "@vuelidate/core";
+//#region src/domains/anzuUser/composables/anzuUserValidations.ts
+function i(i, a) {
+	let { email: o, hexColor: s, maxLength: c, minLength: l, required: u } = e(), d = t(() => {
+		let e = n(a.required) ? { required: u } : {};
+		return { user: {
+			id: n(a.idInput) && !n(a.isEdit) ? { required: u } : {},
+			email: {
+				required: u,
+				email: o,
+				maxLength: c(256)
+			},
+			person: {
+				firstName: {
+					...e,
+					minLength: l(2),
+					maxLength: c(120)
+				},
+				lastName: {
+					...e,
+					minLength: l(2),
+					maxLength: c(120)
+				},
+				fullName: {
+					...e,
+					minLength: l(3),
+					maxLength: c(242)
+				}
+			},
+			avatar: {
+				color: {
+					...e,
+					hexColor: s
+				},
+				text: {
+					...e,
+					minLength: l(2),
+					maxLength: c(3)
+				}
+			}
+		} };
+	});
+	return { v$: r(d, { user: i }, a.scope === void 0 ? void 0 : { $scope: a.scope }) };
+}
+//#endregion
+export { i as useUserMetadataValidation };
+
+//# sourceMappingURL=anzuUserValidations.js.map

package/dist/domains/anzuUser/composables/anzuUserValidations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anzuUserValidations.js","names":["useVuelidate","useUserMetadataValidation","useValidate","rules","computed","requiredWhenProfileSays","toValue","options","maxLength","minLength"],"sources":["../../../../src/domains/anzuUser/composables/anzuUserValidations.ts"],"sourcesContent":["import useVuelidate from '@vuelidate/core'\nimport { computed, toValue, type MaybeRefOrGetter, type Ref } from 'vue'\nimport { useValidate } from '@/shared/validators/vuelidate/useValidate'\nimport type { BaseUser } from '@/shared/types/AnzuUser'\n\nexport interface UserMetadataValidationOptions {\n  /**\n   * The system's profile (`requiredMetadata` on its descriptor). `false` requires only the\n   * e-mail; `true` also requires first name, last name, full name, avatar text and avatar colour.\n   * It applies the same way to creating and to editing -- within a system it is one rule.\n   */\n  required: MaybeRefOrGetter<boolean>\n  /** Whether the id is a field at all. When it is, and this is a create, it is required. */\n  idInput: MaybeRefOrGetter<boolean>\n  isEdit: MaybeRefOrGetter<boolean>\n  /** Scope key, so an owning form can validate its own fields alongside the app's system fields. */\n  scope?: string | symbol | false\n}\n\n/**\n * The `BaseUserDto` rules, per profile.\n *\n * The lengths come from the backend constraints (`email` 256, first/last 120, full 242, avatar\n * text 2-3). The backend requires only the e-mail; the front end is deliberately stricter, and\n * `requiredMetadata` is what says by how much.\n */\nexport function useUserMetadataValidation(user: Ref<BaseUser>, options: UserMetadataValidationOptions) {\n  const { email, hexColor, maxLength, minLength, required } = useValidate()\n\n  const rules = computed(() => {\n    // Read inside the computed, not once at setup: the \"not found anywhere\" dialog switches the\n    // target system under a mounted form, and a profile captured at mount would go on applying the\n    // first system's rules to all the others.\n    const requiredWhenProfileSays = toValue(options.required) ? { required } : {}\n\n    return {\n      user: {\n        // Only on a create, and only where the id is typed at all: on an edit it is a primary key\n        // being displayed, and in cms the backend resolves it from SSO.\n        id: toValue(options.idInput) && !toValue(options.isEdit) ? { required } : {},\n        email: {\n          required,\n          email,\n          maxLength: maxLength(256),\n        },\n        person: {\n          firstName: { ...requiredWhenProfileSays, minLength: minLength(2), maxLength: maxLength(120) },\n          lastName: { ...requiredWhenProfileSays, minLength: minLength(2), maxLength: maxLength(120) },\n          fullName: { ...requiredWhenProfileSays, minLength: minLength(3), maxLength: maxLength(242) },\n        },\n        avatar: {\n          // Shape, not length: `minLength(7)` lets `#GGGGGG` through and the server rejects it.\n          // The rule passes an empty value, so a profile that does not require a colour still saves.\n          color: { ...requiredWhenProfileSays, hexColor },\n          text: { ...requiredWhenProfileSays, minLength: minLength(2), maxLength: maxLength(3) },\n        },\n      },\n    }\n  })\n\n  const v$ = useVuelidate(rules, { user }, options.scope === undefined ? undefined : { $scope: options.scope })\n\n  return {\n    v$,\n  }\n}\n"],"mappings":";;;;AA0BA,SAAgBC,EAA0B,GAAqB,GAAwC;CACrG,IAAM,EAAE,UAAO,aAAU,cAAW,cAAW,gBAAaC,EAAY,GAElEC,IAAQC,QAAe;EAI3B,IAAMC,IAA0BC,EAAQC,EAAQ,QAAQ,IAAI,EAAE,YAAS,IAAI,CAAC;EAE5E,OAAO,EACL,MAAM;GAGJ,IAAID,EAAQC,EAAQ,OAAO,KAAK,CAACD,EAAQC,EAAQ,MAAM,IAAI,EAAE,YAAS,IAAI,CAAC;GAC3E,OAAO;IACL;IACA;IACA,WAAWC,EAAU,GAAG;GAC1B;GACA,QAAQ;IACN,WAAW;KAAE,GAAGH;KAAyB,WAAWI,EAAU,CAAC;KAAG,WAAWD,EAAU,GAAG;IAAE;IAC5F,UAAU;KAAE,GAAGH;KAAyB,WAAWI,EAAU,CAAC;KAAG,WAAWD,EAAU,GAAG;IAAE;IAC3F,UAAU;KAAE,GAAGH;KAAyB,WAAWI,EAAU,CAAC;KAAG,WAAWD,EAAU,GAAG;IAAE;GAC7F;GACA,QAAQ;IAGN,OAAO;KAAE,GAAGH;KAAyB;IAAS;IAC9C,MAAM;KAAE,GAAGA;KAAyB,WAAWI,EAAU,CAAC;KAAG,WAAWD,EAAU,CAAC;IAAE;GACvF;EACF,EACF;CACF,CAAC;CAID,OAAO,EACL,IAHSR,EAAaG,GAAO,EAAE,QAAK,GAAGI,EAAQ,UAAU,KAAA,IAAY,KAAA,IAAY,EAAE,QAAQA,EAAQ,MAAM,CAGzG,EACF;AACF"}

package/dist/domains/anzuUser/composables/cachedAnzuUsers.d.ts

@@ -0,0 +1,27 @@
+import { AxiosClientFn } from '../../api/utils/client';
+import { AnzuUser, AnzuUserMinimal } from '../../../shared/types/AnzuUser';
+export interface CachedAnzuUsersParams {
+    client: AxiosClientFn;
+    system: string;
+    entity?: string;
+    endPoint?: string;
+}
+/**
+ * Users of one backend, read from its `/adm/v1/anzu-user` (every backend has it), for an admin that has
+ * no user cache of its own for that backend. Returns the names the admins' own `useCachedUsers()` use,
+ * so it plugs into `createUserAndTimeTrackingFields` as it is.
+ */
+export declare const useCachedAnzuUsers: (params: CachedAnzuUsersParams) => {
+    cachedUsers: import('vue').Ref<Map<number, import('../../cached/composables/defineCached').CachedItem<AnzuUserMinimal>>, Map<number, import('../../cached/composables/defineCached').CachedItem<AnzuUserMinimal>>>;
+    fetchCachedUsers: () => import('@vueuse/shared').Promisify<Promise<AnzuUser[]>>;
+    immediateFetchCachedUsers: () => Promise<AnzuUser[]>;
+    addToCachedUsers: (...args: import('../../cached/composables/defineCached').AddToCachedArgs<number>) => void;
+    addManualToCachedUsers: (data: AnzuUser) => void;
+    addManualMinimalToCachedUsers: (data: AnzuUserMinimal) => void;
+    hasCachedUser: (id: number | null | undefined) => boolean;
+    getCachedUser: (id: number | null | undefined) => import('../../cached/composables/defineCached').CachedItem<AnzuUserMinimal> | undefined;
+    isLoadedCachedUser: (id: number | null | undefined) => boolean;
+    clearCachedUsers: () => void;
+};
+/** Test seam. Registries are module state and would otherwise leak between cases. */
+export declare const resetCachedAnzuUserRegistries: () => void;

package/dist/domains/anzuUser/composables/cachedAnzuUsers.js

@@ -0,0 +1,49 @@
+import { defineCached as e } from "../../cached/composables/defineCached.js";
+import { useAnzuUserApi as t } from "../api/anzuUserApi.js";
+//#region src/domains/anzuUser/composables/cachedAnzuUsers.ts
+var n = /* @__PURE__ */ new Map(), r = (e) => ({
+	id: e.id ?? 0,
+	email: e.email,
+	person: e.person,
+	avatar: e.avatar
+}), i = (e) => ({
+	id: e,
+	email: "",
+	person: {
+		firstName: "",
+		lastName: "",
+		fullName: ""
+	},
+	avatar: {
+		color: "",
+		text: ""
+	}
+}), a = (n) => {
+	let { useFetchAnzuUserListByIds: a } = t(n);
+	return e(r, i, (e) => a().execute(e), "id", 1e3, { retryNotFound: !1 });
+}, o = (e) => {
+	let t = {
+		client: e.client,
+		system: e.system,
+		entity: e.entity ?? "anzuUser",
+		endPoint: e.endPoint ?? "/adm/v1/anzu-user"
+	}, r = n.get(t.system);
+	r || (r = a(t), n.set(t.system, r));
+	let { cache: i, fetch: o, immediateFetch: s, add: c, addManual: l, addManualMinimal: u, has: d, get: f, isLoaded: p, clear: m } = r;
+	return {
+		cachedUsers: i,
+		fetchCachedUsers: o,
+		immediateFetchCachedUsers: s,
+		addToCachedUsers: c,
+		addManualToCachedUsers: l,
+		addManualMinimalToCachedUsers: u,
+		hasCachedUser: d,
+		getCachedUser: f,
+		isLoadedCachedUser: p,
+		clearCachedUsers: m
+	};
+};
+//#endregion
+export { o as useCachedAnzuUsers };
+
+//# sourceMappingURL=cachedAnzuUsers.js.map

package/dist/domains/anzuUser/composables/cachedAnzuUsers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedAnzuUsers.js","names":["registries","mapFullToMinimal","user","mapIdToMinimal","buildRegistry","useAnzuUserApi","params","defineCached","useFetchAnzuUserListByIds","ids","useCachedAnzuUsers","resolved","registry","cache","fetch","immediateFetch","add","addManual","addManualMinimal","has","get","isLoaded","clear"],"sources":["../../../../src/domains/anzuUser/composables/cachedAnzuUsers.ts"],"sourcesContent":["import { defineCached } from '@/domains/cached/composables/defineCached'\nimport type { AxiosClientFn } from '@/domains/api/utils/client'\nimport { ANZU_USER_ENDPOINT, ANZU_USER_ENTITY, useAnzuUserApi } from '@/domains/anzuUser/api/anzuUserApi'\nimport type { IntegerId } from '@/shared/types/common'\nimport type { AnzuUser, AnzuUserMinimal } from '@/shared/types/AnzuUser'\n\nexport interface CachedAnzuUsersParams {\n  client: AxiosClientFn\n  system: string\n  entity?: string\n  endPoint?: string\n}\n\ntype Registry = ReturnType<typeof buildRegistry>\n\n/**\n * One cache per system, not one shared by all of them.\n *\n * Every backend keeps its own user table. Ids come from the central login and agree across them, but\n * a user who exists in one backend need not exist in another -- the system accounts of sms-gateway\n * live only there. An admin over several backends that resolved all of them against one table would\n * draw some users as unknown, which is what admin-inhouse did with the weather cache.\n */\nconst registries = new Map<string, Registry>()\n\nconst mapFullToMinimal = (user: AnzuUser): AnzuUserMinimal => ({\n  id: user.id ?? 0,\n  email: user.email,\n  person: user.person,\n  avatar: user.avatar,\n})\n\nconst mapIdToMinimal = (id: IntegerId): AnzuUserMinimal => ({\n  id,\n  email: '',\n  person: { firstName: '', lastName: '', fullName: '' },\n  avatar: { color: '', text: '' },\n})\n\nconst buildRegistry = (params: Required<CachedAnzuUsersParams>) => {\n  const { useFetchAnzuUserListByIds } = useAnzuUserApi(params)\n\n  return defineCached<IntegerId, AnzuUser, AnzuUserMinimal>(\n    mapFullToMinimal,\n    mapIdToMinimal,\n    (ids: IntegerId[]) => useFetchAnzuUserListByIds().execute(ids),\n    'id',\n    1000,\n    // A user missing from the table stays missing: a system user of another backend would otherwise\n    // be asked for on every page that shows it.\n    { retryNotFound: false }\n  )\n}\n\n/**\n * Users of one backend, read from its `/adm/v1/anzu-user` (every backend has it), for an admin that has\n * no user cache of its own for that backend. Returns the names the admins' own `useCachedUsers()` use,\n * so it plugs into `createUserAndTimeTrackingFields` as it is.\n */\nexport const useCachedAnzuUsers = (params: CachedAnzuUsersParams) => {\n  const resolved = {\n    client: params.client,\n    system: params.system,\n    entity: params.entity ?? ANZU_USER_ENTITY,\n    endPoint: params.endPoint ?? ANZU_USER_ENDPOINT,\n  }\n\n  let registry = registries.get(resolved.system)\n  if (!registry) {\n    registry = buildRegistry(resolved)\n    registries.set(resolved.system, registry)\n  }\n\n  const { cache, fetch, immediateFetch, add, addManual, addManualMinimal, has, get, isLoaded, clear } = registry\n\n  return {\n    cachedUsers: cache,\n    fetchCachedUsers: fetch,\n    immediateFetchCachedUsers: immediateFetch,\n    addToCachedUsers: add,\n    addManualToCachedUsers: addManual,\n    addManualMinimalToCachedUsers: addManualMinimal,\n    hasCachedUser: has,\n    getCachedUser: get,\n    isLoadedCachedUser: isLoaded,\n    clearCachedUsers: clear,\n  }\n}\n\n/** Test seam. Registries are module state and would otherwise leak between cases. */\nexport const resetCachedAnzuUserRegistries = () => {\n  registries.clear()\n}\n"],"mappings":";;;AAuBA,IAAMA,oBAAa,IAAI,IAAsB,GAEvCC,KAAoB,OAAqC;CAC7D,IAAIC,EAAK,MAAM;CACf,OAAOA,EAAK;CACZ,QAAQA,EAAK;CACb,QAAQA,EAAK;AACf,IAEMC,KAAkB,OAAoC;CAC1D;CACA,OAAO;CACP,QAAQ;EAAE,WAAW;EAAI,UAAU;EAAI,UAAU;CAAG;CACpD,QAAQ;EAAE,OAAO;EAAI,MAAM;CAAG;AAChC,IAEMC,KAAiB,MAA4C;CACjE,IAAM,EAAE,iCAA8BC,EAAeC,CAAM;CAE3D,OAAOC,EACLN,GACAE,IACC,MAAqBK,EAA0B,CAAC,CAAC,QAAQC,CAAG,GAC7D,MACA,KAGA,EAAE,eAAe,GAAM,CACzB;AACF,GAOaC,KAAsB,MAAkC;CACnE,IAAMC,IAAW;EACf,QAAQL,EAAO;EACf,QAAQA,EAAO;EACf,QAAQA,EAAO,UAAA;EACf,UAAUA,EAAO,YAAA;CACnB,GAEIM,IAAWZ,EAAW,IAAIW,EAAS,MAAM;CAC7C,AAAKC,MACH,IAAWR,EAAcO,CAAQ,GACjCX,EAAW,IAAIW,EAAS,QAAQC,CAAQ;CAG1C,IAAM,EAAE,UAAO,UAAO,mBAAgB,QAAK,cAAW,qBAAkB,QAAK,QAAK,aAAU,aAAUA;CAEtG,OAAO;EACL,aAAaC;EACb,kBAAkBC;EAClB,2BAA2BC;EAC3B,kBAAkBC;EAClB,wBAAwBC;EACxB,+BAA+BC;EAC/B,eAAeC;EACf,eAAeC;EACf,oBAAoBC;EACpB,kBAAkBC;CACpB;AACF"}