@anzusystems/common-admin 1.49.0 → 2.0.0-rc.10

package/dist/domains/anzuUser/utils/userSystemState.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Four independent axes, one derived state.
+ * Collapsing them early conflated "no access" with "no account" and offered Create in unreadable systems.
+ */
+export declare const UserSystemLoad: {
+    readonly Idle: "idle";
+    readonly Loading: "loading";
+    readonly Loaded: "loaded";
+    readonly Error: "error";
+};
+export type UserSystemLoadType = (typeof UserSystemLoad)[keyof typeof UserSystemLoad];
+export declare const UserSystemPresence: {
+    readonly Present: "present";
+    readonly Absent: "absent";
+    readonly Unknown: "unknown";
+};
+export type UserSystemPresenceType = (typeof UserSystemPresence)[keyof typeof UserSystemPresence];
+export declare const UserSystemAccess: {
+    readonly Ok: "ok";
+    readonly Forbidden: "forbidden";
+    readonly Unauthenticated: "unauthenticated";
+    readonly Unavailable: "unavailable";
+    readonly ConfigDisabled: "configDisabled";
+};
+export type UserSystemAccessType = (typeof UserSystemAccess)[keyof typeof UserSystemAccess];
+/**
+ * `enabled` is an axis so "here and on" and "here and off" can be told apart.
+ * Ownership is not an axis; the descriptor's `manage` decides the button.
+ */
+export interface UserSystemAxes {
+    load: UserSystemLoadType;
+    presence: UserSystemPresenceType;
+    access: UserSystemAccessType;
+    enabled: boolean | 'unknown';
+}
+export declare const UserSystemState: {
+    /** Nothing has been asked yet, or the answer is still on its way. */
+    readonly Loading: "loading";
+    readonly Enabled: "enabled";
+    readonly Disabled: "disabled";
+    readonly Absent: "absent";
+    readonly Forbidden: "forbidden";
+    readonly Unavailable: "unavailable";
+    readonly ConfigDisabled: "configDisabled";
+};
+export type UserSystemStateType = (typeof UserSystemState)[keyof typeof UserSystemState];
+export declare const emptyUserSystemAxes: () => UserSystemAxes;
+/**
+ * Order matters. Config-disabled wins over everything.
+ * Access is checked before presence because a forbidden record is not an absent one.
+ */
+export declare const resolveUserSystemState: (axes: UserSystemAxes) => UserSystemStateType;
+/**
+ * 401 is its own case: an expired session must not show as "no account here" (decision 16).
+ * The caller retries through its refresh hook first; this receives the verdict.
+ * 422 has no case: a detail GET does not validate. A 422 belongs to the write log.
+ */
+export declare const classifyProbeStatus: (status: number | null) => Pick<UserSystemAxes, "presence" | "access">;
+/**
+ * Whether every relevant system answered authoritatively that the account does not exist.
+ * Account creation is offered only then. An unreadable record is not a missing one, and
+ * an AnzuUser cannot be deleted, so a duplicate created on a guess cannot be undone.
+ */
+export declare const isAuthoritativelyAbsent: (axes: UserSystemAxes) => boolean;
+/** A system a bulk action may act on: it answered, the account is there, and access was granted. */
+export declare const isActionable: (axes: UserSystemAxes) => boolean;

package/dist/domains/anzuUser/utils/userSystemState.js

@@ -0,0 +1,54 @@
+// src/domains/anzuUser/utils/userSystemState.ts
+var e = {
+	Idle: "idle",
+	Loading: "loading",
+	Loaded: "loaded",
+	Error: "error"
+}, t = {
+	Present: "present",
+	Absent: "absent",
+	Unknown: "unknown"
+}, n = {
+	Ok: "ok",
+	Forbidden: "forbidden",
+	Unauthenticated: "unauthenticated",
+	Unavailable: "unavailable",
+	ConfigDisabled: "configDisabled"
+}, r = {
+	Loading: "loading",
+	Enabled: "enabled",
+	Disabled: "disabled",
+	Absent: "absent",
+	Forbidden: "forbidden",
+	Unavailable: "unavailable",
+	ConfigDisabled: "configDisabled"
+}, i = () => ({
+	load: e.Idle,
+	presence: t.Unknown,
+	access: n.Ok,
+	enabled: "unknown"
+}), a = (i) => i.access === n.ConfigDisabled ? r.ConfigDisabled : i.access === n.Forbidden ? r.Forbidden : i.access === n.Unauthenticated || i.access === n.Unavailable ? r.Unavailable : i.load === e.Idle || i.load === e.Loading ? r.Loading : i.presence === t.Absent ? r.Absent : i.presence === t.Unknown ? r.Unavailable : i.enabled === !0 ? r.Enabled : r.Disabled, o = (e) => e === null ? {
+	presence: t.Unknown,
+	access: n.Unavailable
+} : e === 404 ? {
+	presence: t.Absent,
+	access: n.Ok
+} : e === 403 ? {
+	presence: t.Unknown,
+	access: n.Forbidden
+} : e === 401 ? {
+	presence: t.Unknown,
+	access: n.Unauthenticated
+} : e >= 500 ? {
+	presence: t.Unknown,
+	access: n.Unavailable
+} : e >= 200 && e < 300 ? {
+	presence: t.Present,
+	access: n.Ok
+} : {
+	presence: t.Unknown,
+	access: n.Unavailable
+}, s = (r) => r.load === e.Loaded && r.presence === t.Absent && r.access === n.Ok, c = (r) => r.load === e.Loaded && r.presence === t.Present && r.access === n.Ok;
+export { n as UserSystemAccess, e as UserSystemLoad, t as UserSystemPresence, r as UserSystemState, o as classifyProbeStatus, i as emptyUserSystemAxes, c as isActionable, s as isAuthoritativelyAbsent, a as resolveUserSystemState };
+
+//# sourceMappingURL=userSystemState.js.map

package/dist/domains/anzuUser/utils/userSystemState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userSystemState.js","names":["UserSystemLoad","UserSystemPresence","UserSystemAccess","UserSystemState","emptyUserSystemAxes","resolveUserSystemState","axes","classifyProbeStatus","status","isAuthoritativelyAbsent","isActionable"],"sources":["../../../../src/domains/anzuUser/utils/userSystemState.ts"],"sourcesContent":["/**\n * Four independent axes, one derived state.\n * Collapsing them early conflated \"no access\" with \"no account\" and offered Create in unreadable systems.\n */\nexport const UserSystemLoad = {\n  Idle: 'idle',\n  Loading: 'loading',\n  Loaded: 'loaded',\n  Error: 'error',\n} as const\nexport type UserSystemLoadType = (typeof UserSystemLoad)[keyof typeof UserSystemLoad]\n\nexport const UserSystemPresence = {\n  Present: 'present',\n  Absent: 'absent',\n  Unknown: 'unknown',\n} as const\nexport type UserSystemPresenceType = (typeof UserSystemPresence)[keyof typeof UserSystemPresence]\n\nexport const UserSystemAccess = {\n  Ok: 'ok',\n  Forbidden: 'forbidden',\n  Unauthenticated: 'unauthenticated',\n  Unavailable: 'unavailable',\n  ConfigDisabled: 'configDisabled',\n} as const\nexport type UserSystemAccessType = (typeof UserSystemAccess)[keyof typeof UserSystemAccess]\n\n/**\n * `enabled` is an axis so \"here and on\" and \"here and off\" can be told apart.\n * Ownership is not an axis; the descriptor's `manage` decides the button.\n */\nexport interface UserSystemAxes {\n  load: UserSystemLoadType\n  presence: UserSystemPresenceType\n  access: UserSystemAccessType\n  enabled: boolean | 'unknown'\n}\n\nexport const UserSystemState = {\n  /** Nothing has been asked yet, or the answer is still on its way. */\n  Loading: 'loading',\n  Enabled: 'enabled',\n  Disabled: 'disabled',\n  Absent: 'absent',\n  Forbidden: 'forbidden',\n  Unavailable: 'unavailable',\n  ConfigDisabled: 'configDisabled',\n} as const\nexport type UserSystemStateType = (typeof UserSystemState)[keyof typeof UserSystemState]\n\nexport const emptyUserSystemAxes = (): UserSystemAxes => ({\n  load: UserSystemLoad.Idle,\n  presence: UserSystemPresence.Unknown,\n  access: UserSystemAccess.Ok,\n  enabled: 'unknown',\n})\n\n/**\n * Order matters. Config-disabled wins over everything.\n * Access is checked before presence because a forbidden record is not an absent one.\n */\nexport const resolveUserSystemState = (axes: UserSystemAxes): UserSystemStateType => {\n  if (axes.access === UserSystemAccess.ConfigDisabled) return UserSystemState.ConfigDisabled\n  if (axes.access === UserSystemAccess.Forbidden) return UserSystemState.Forbidden\n  if (axes.access === UserSystemAccess.Unauthenticated || axes.access === UserSystemAccess.Unavailable) {\n    return UserSystemState.Unavailable\n  }\n  if (axes.load === UserSystemLoad.Idle || axes.load === UserSystemLoad.Loading) return UserSystemState.Loading\n  if (axes.presence === UserSystemPresence.Absent) return UserSystemState.Absent\n  if (axes.presence === UserSystemPresence.Unknown) return UserSystemState.Unavailable\n  return axes.enabled === true ? UserSystemState.Enabled : UserSystemState.Disabled\n}\n\n/**\n * 401 is its own case: an expired session must not show as \"no account here\" (decision 16).\n * The caller retries through its refresh hook first; this receives the verdict.\n * 422 has no case: a detail GET does not validate. A 422 belongs to the write log.\n */\nexport const classifyProbeStatus = (status: number | null): Pick<UserSystemAxes, 'presence' | 'access'> => {\n  if (status === null) {\n    // A timeout, a network failure, or anything that never reached a status.\n    return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n  }\n  if (status === 404) return { presence: UserSystemPresence.Absent, access: UserSystemAccess.Ok }\n  if (status === 403) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Forbidden }\n  if (status === 401) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unauthenticated }\n  if (status >= 500) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n  if (status >= 200 && status < 300) return { presence: UserSystemPresence.Present, access: UserSystemAccess.Ok }\n  return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n}\n\n/**\n * Whether every relevant system answered authoritatively that the account does not exist.\n * Account creation is offered only then. An unreadable record is not a missing one, and\n * an AnzuUser cannot be deleted, so a duplicate created on a guess cannot be undone.\n */\nexport const isAuthoritativelyAbsent = (axes: UserSystemAxes): boolean =>\n  axes.load === UserSystemLoad.Loaded &&\n  axes.presence === UserSystemPresence.Absent &&\n  axes.access === UserSystemAccess.Ok\n\n/** A system a bulk action may act on: it answered, the account is there, and access was granted. */\nexport const isActionable = (axes: UserSystemAxes): boolean =>\n  axes.load === UserSystemLoad.Loaded &&\n  axes.presence === UserSystemPresence.Present &&\n  axes.access === UserSystemAccess.Ok\n"],"mappings":";AAIA,IAAaA,IAAiB;CAC5B,MAAM;CACN,SAAS;CACT,QAAQ;CACR,OAAO;AACT,GAGaC,IAAqB;CAChC,SAAS;CACT,QAAQ;CACR,SAAS;AACX,GAGaC,IAAmB;CAC9B,IAAI;CACJ,WAAW;CACX,iBAAiB;CACjB,aAAa;CACb,gBAAgB;AAClB,GAcaC,IAAkB;CAE7B,SAAS;CACT,SAAS;CACT,UAAU;CACV,QAAQ;CACR,WAAW;CACX,aAAa;CACb,gBAAgB;AAClB,GAGaC,WAA6C;CACxD,MAAMJ,EAAe;CACrB,UAAUC,EAAmB;CAC7B,QAAQC,EAAiB;CACzB,SAAS;AACX,IAMaG,KAA0B,MACjCC,EAAK,WAAWJ,EAAiB,iBAAuBC,EAAgB,iBACxEG,EAAK,WAAWJ,EAAiB,YAAkBC,EAAgB,YACnEG,EAAK,WAAWJ,EAAiB,mBAAmBI,EAAK,WAAWJ,EAAiB,cAChFC,EAAgB,cAErBG,EAAK,SAASN,EAAe,QAAQM,EAAK,SAASN,EAAe,UAAgBG,EAAgB,UAClGG,EAAK,aAAaL,EAAmB,SAAeE,EAAgB,SACpEG,EAAK,aAAaL,EAAmB,UAAgBE,EAAgB,cAClEG,EAAK,YAAY,KAAOH,EAAgB,UAAUA,EAAgB,UAQ9DI,KAAuB,MAC9BC,MAAW,OAEN;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAY,IAElFM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAQ,QAAQC,EAAiB;AAAG,IAC1FM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAU,IAClGM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAgB,IACxGM,KAAU,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAY,IACnGM,KAAU,OAAOA,IAAS,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAG,IACvG;CAAE,UAAUD,EAAmB;CAAS,QAAQC,EAAiB;AAAY,GAQzEO,KAA2B,MACtCH,EAAK,SAASN,EAAe,UAC7BM,EAAK,aAAaL,EAAmB,UACrCK,EAAK,WAAWJ,EAAiB,IAGtBQ,KAAgB,MAC3BJ,EAAK,SAASN,EAAe,UAC7BM,EAAK,aAAaL,EAAmB,WACrCK,EAAK,WAAWJ,EAAiB"}

package/dist/domains/anzuUser/utils/userTabs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The one tab that is not a system.
+ * Its own module because `<script setup>` cannot export, and both the shell and the pages reading `?tab=` need it.
+ */
+export declare const OTHER_SYSTEMS_TAB = "__otherSystems";

package/dist/domains/anzuUser/utils/userTabs.js

@@ -0,0 +1,5 @@
+// src/domains/anzuUser/utils/userTabs.ts
+var e = "__otherSystems";
+export { e as OTHER_SYSTEMS_TAB };
+
+//# sourceMappingURL=userTabs.js.map

package/dist/domains/anzuUser/utils/userTabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userTabs.js","names":["OTHER_SYSTEMS_TAB"],"sources":["../../../../src/domains/anzuUser/utils/userTabs.ts"],"sourcesContent":["/**\n * The one tab that is not a system.\n * Its own module because `<script setup>` cannot export, and both the shell and the pages reading `?tab=` need it.\n */\nexport const OTHER_SYSTEMS_TAB = '__otherSystems'\n"],"mappings":";AAIA,IAAaA,IAAoB"}

package/dist/domains/api/composables/defineApiClient.d.ts

@@ -0,0 +1,28 @@
+import { AxiosInstance, AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse, CreateAxiosDefaults, InternalAxiosRequestConfig } from 'axios';
+type RequestUse = Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>['use']>;
+type ResponseUse = Parameters<AxiosInterceptorManager<AxiosResponse>['use']>;
+export interface ApiClientRequestInterceptor {
+    onFulfilled?: RequestUse[0];
+    onRejected?: RequestUse[1];
+    options?: RequestUse[2];
+}
+export interface ApiClientResponseInterceptor {
+    onFulfilled?: ResponseUse[0];
+    onRejected?: ResponseUse[1];
+}
+export interface ApiClientSetup {
+    /** The instance's defaults; nothing is added to them. */
+    config: CreateAxiosDefaults;
+    request?: ApiClientRequestInterceptor[];
+    response?: ApiClientResponseInterceptor[];
+}
+/**
+ * Returns a lazily created singleton axios client whose interceptors are registered once.
+ * Registering outside the guard stacks a copy of every interceptor per call.
+ * `setup` runs on the first call, not at module load. Env config is empty until loaded, and interceptors come from
+ * modules in an import cycle with the client (refresh calls the auth api), so they may not be initialized at load time.
+ */
+export declare function defineApiClient(setup: () => ApiClientSetup): () => AxiosInstance;
+/** A `runWhen` that leaves out requests to urls starting with one of `prefixes` (the auth endpoints). */
+export declare const skipUrlPrefixes: (...prefixes: string[]) => (config: AxiosRequestConfig) => boolean;
+export {};

package/dist/domains/api/composables/defineApiClient.js

@@ -0,0 +1,19 @@
+import { isNull as e } from "../../../shared/utils/common.js";
+import t from "axios";
+// src/domains/api/composables/defineApiClient.ts
+function n(n) {
+	let r = null;
+	return () => {
+		if (e(r)) {
+			let { config: e, request: i = [], response: a = [] } = n(), o = t.create(e);
+			for (let { onFulfilled: e, onRejected: t, options: n } of i) o.interceptors.request.use(e, t, n);
+			for (let { onFulfilled: e, onRejected: t } of a) o.interceptors.response.use(e, t);
+			r = o;
+		}
+		return r;
+	};
+}
+var r = (...e) => (t) => !e.some((e) => t.url?.startsWith(e) ?? !1);
+export { n as defineApiClient, r as skipUrlPrefixes };
+
+//# sourceMappingURL=defineApiClient.js.map

package/dist/domains/api/composables/defineApiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineApiClient.js","names":["axios","defineApiClient","instance","isNull","setup","created","config","request","onFulfilled","onRejected","options","response","skipUrlPrefixes","prefixes","prefix"],"sources":["../../../../src/domains/api/composables/defineApiClient.ts"],"sourcesContent":["import axios, {\n  type AxiosInstance,\n  type AxiosInterceptorManager,\n  type AxiosRequestConfig,\n  type AxiosResponse,\n  type CreateAxiosDefaults,\n  type InternalAxiosRequestConfig,\n} from 'axios'\nimport { isNull } from '@/shared/utils/common'\n\n// axios's own handler types, which it does not export.\ntype RequestUse = Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>['use']>\ntype ResponseUse = Parameters<AxiosInterceptorManager<AxiosResponse>['use']>\n\nexport interface ApiClientRequestInterceptor {\n  onFulfilled?: RequestUse[0]\n  onRejected?: RequestUse[1]\n  options?: RequestUse[2]\n}\n\nexport interface ApiClientResponseInterceptor {\n  onFulfilled?: ResponseUse[0]\n  onRejected?: ResponseUse[1]\n}\n\nexport interface ApiClientSetup {\n  /** The instance's defaults; nothing is added to them. */\n  config: CreateAxiosDefaults\n  request?: ApiClientRequestInterceptor[]\n  response?: ApiClientResponseInterceptor[]\n}\n\n/**\n * Returns a lazily created singleton axios client whose interceptors are registered once.\n * Registering outside the guard stacks a copy of every interceptor per call.\n * `setup` runs on the first call, not at module load. Env config is empty until loaded, and interceptors come from\n * modules in an import cycle with the client (refresh calls the auth api), so they may not be initialized at load time.\n */\nexport function defineApiClient(setup: () => ApiClientSetup): () => AxiosInstance {\n  let instance: AxiosInstance | null = null\n  return () => {\n    if (isNull(instance)) {\n      const { config, request = [], response = [] } = setup()\n      const created = axios.create(config)\n      for (const { onFulfilled, onRejected, options } of request) {\n        created.interceptors.request.use(onFulfilled, onRejected, options)\n      }\n      for (const { onFulfilled, onRejected } of response) {\n        created.interceptors.response.use(onFulfilled, onRejected)\n      }\n      instance = created\n    }\n    return instance\n  }\n}\n\n/** A `runWhen` that leaves out requests to urls starting with one of `prefixes` (the auth endpoints). */\nexport const skipUrlPrefixes =\n  (...prefixes: string[]) =>\n  (config: AxiosRequestConfig): boolean =>\n    !prefixes.some((prefix) => config.url?.startsWith(prefix) ?? false)\n"],"mappings":";;;AAsCA,SAAgBC,EAAgB,GAAkD;CAChF,IAAIC,IAAiC;CACrC,aAAa;EACX,IAAIC,EAAOD,CAAQ,GAAG;GACpB,IAAM,EAAE,WAAQ,aAAU,CAAC,GAAG,cAAW,CAAC,MAAME,EAAM,GAChDC,IAAUL,EAAM,OAAOM,CAAM;GACnC,KAAK,IAAM,EAAE,gBAAa,eAAY,gBAAaC,GACjD,EAAQ,aAAa,QAAQ,IAAIC,GAAaC,GAAYC,CAAO;GAEnE,KAAK,IAAM,EAAE,gBAAa,mBAAgBC,GACxC,EAAQ,aAAa,SAAS,IAAIH,GAAaC,CAAU;GAE3D,IAAWJ;EACb;EACA,OAAOH;CACT;AACF;AAGA,IAAaU,KACV,GAAGC,OACH,MACC,CAACA,EAAS,MAAM,MAAWP,EAAO,KAAK,WAAWQ,CAAM,KAAK,EAAK"}

package/dist/domains/api/composables/pagination.d.ts

@@ -0,0 +1,23 @@
+import { DatatableSortBy } from '../../filters/datatable/utils/datatableColumns';
+import { SortOrderType } from '../types/SortOrder';
+import { Ref } from 'vue';
+export interface Pagination {
+    sortBy: DatatableSortBy;
+    page: number;
+    rowsPerPage: number;
+    rowsNumber: number;
+    hasNextPage: null | boolean;
+    currentViewCount: number;
+    totalCount: number;
+}
+interface PaginationOptions {
+    rowsPerPage: number;
+}
+export declare function usePagination(sortKey: string | null, sortOrder?: SortOrderType, options?: Partial<PaginationOptions>, externalPaginationRef?: Ref<Pagination>): UsePaginationReturnType;
+interface UsePaginationReturnType {
+    pagination: Ref<Pagination>;
+    setSortBy: (sortBy: DatatableSortBy) => void;
+    setPage: (page: number) => void;
+    incrementPage: () => number;
+}
+export {};

package/dist/domains/api/composables/pagination.js

@@ -0,0 +1,62 @@
+import { SortOrder as e } from "../types/SortOrder.js";
+import { isNull as t, isString as n, isUndefined as r } from "../../../shared/utils/common.js";
+import { ref as i } from "vue";
+// src/domains/api/composables/pagination.ts
+var a = () => ({ rowsPerPage: 25 });
+function o(o, s = e.Desc, c = {}, l) {
+	let u = {
+		...a(),
+		...c
+	}, d = l ?? i({
+		sortBy: t(o) ? null : {
+			key: o,
+			order: s
+		},
+		page: 1,
+		rowsPerPage: u.rowsPerPage,
+		rowsNumber: 0,
+		hasNextPage: null,
+		currentViewCount: 0,
+		totalCount: 0
+	});
+	function f(e, i) {
+		if (n(e)) {
+			d.value = {
+				...d.value,
+				sortBy: {
+					key: e,
+					order: i
+				}
+			};
+			return;
+		}
+		let a = e;
+		t(a) || r(a) ? d.value = {
+			...d.value,
+			sortBy: a
+		} : d.value = {
+			...d.value,
+			sortBy: {
+				key: a.key,
+				order: a.order
+			}
+		};
+	}
+	return {
+		pagination: d,
+		setSortBy: f,
+		setPage: (e) => {
+			d.value = {
+				...d.value,
+				page: e
+			};
+		},
+		incrementPage: () => (d.value = {
+			...d.value,
+			page: d.value.page + 1
+		}, d.value.page)
+	};
+}
+export { o as usePagination };
+
+//# sourceMappingURL=pagination.js.map

package/dist/domains/api/composables/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","names":["createDefaultPaginationOptions","usePagination","SortOrder","mergedOptions","options","pagination","externalPaginationRef","ref","isNull","sortKey","sortOrder","setSortBy","isString","arg1","arg2","sortBy","isUndefined"],"sources":["../../../../src/domains/api/composables/pagination.ts"],"sourcesContent":["import { type DatatableSortBy } from '@/domains/filters/datatable/utils/datatableColumns'\nimport { SortOrder, type SortOrderType } from '@/domains/api/types/SortOrder'\nimport { type Ref, ref } from 'vue'\nimport { isNull, isString, isUndefined } from '@/shared/utils/common'\n\nexport interface Pagination {\n  sortBy: DatatableSortBy\n  page: number\n  rowsPerPage: number\n  rowsNumber: number\n  hasNextPage: null | boolean\n  currentViewCount: number\n  totalCount: number\n}\n\ninterface PaginationOptions {\n  rowsPerPage: number\n}\n\nconst createDefaultPaginationOptions = () => {\n  return {\n    rowsPerPage: 25,\n  }\n}\n\nexport function usePagination(\n  sortKey: string | null,\n  sortOrder: SortOrderType = SortOrder.Desc,\n  options: Partial<PaginationOptions> = {},\n  externalPaginationRef?: Ref<Pagination>\n): UsePaginationReturnType {\n  const mergedOptions = { ...createDefaultPaginationOptions(), ...options }\n\n  const pagination =\n    externalPaginationRef ??\n    ref<Pagination>({\n      sortBy: isNull(sortKey) ? null : { key: sortKey, order: sortOrder },\n      page: 1,\n      rowsPerPage: mergedOptions.rowsPerPage,\n      rowsNumber: 0,\n      hasNextPage: null,\n      currentViewCount: 0,\n      totalCount: 0,\n    })\n\n  /**\n   * Update sorting for the datatable.\n   * Supported call variants:\n   * 1) setSortBy(sortBy: DatatableSortBy) — pass a DatatableSortBy object\n   * 2) setSortBy(sortKey: string, sortOrder: SortOrderType) — pass key and order separately\n   */\n  function setSortBy(sortBy: DatatableSortBy): void\n  function setSortBy(sortKey: string, sortOrder: SortOrderType): void\n  function setSortBy(arg1: DatatableSortBy | string, arg2?: SortOrderType): void {\n    if (isString(arg1)) {\n      pagination.value = {\n        ...pagination.value,\n        sortBy: { key: arg1, order: arg2 as SortOrderType },\n      }\n      return\n    }\n\n    const sortBy = arg1\n    if (isNull(sortBy) || isUndefined(sortBy)) {\n      pagination.value = { ...pagination.value, sortBy }\n      return\n    }\n    pagination.value = { ...pagination.value, sortBy: { key: sortBy.key, order: sortBy.order } }\n  }\n\n  const setPage = (page: number) => {\n    pagination.value = { ...pagination.value, page }\n  }\n\n  const incrementPage = () => {\n    pagination.value = { ...pagination.value, page: pagination.value.page + 1 }\n    return pagination.value.page\n  }\n\n  return {\n    pagination,\n    setSortBy,\n    setPage,\n    incrementPage,\n  }\n}\n\ninterface UsePaginationReturnType {\n  pagination: Ref<Pagination>\n  setSortBy: (sortBy: DatatableSortBy) => void\n  setPage: (page: number) => void\n  incrementPage: () => number\n}\n"],"mappings":";;;;AAmBA,IAAMA,WACG,EACL,aAAa,GACf;AAGF,SAAgBC,EACd,GACA,IAA2BC,EAAU,MACrC,IAAsC,CAAC,GACvC,GACyB;CACzB,IAAMC,IAAgB;EAAE,GAAGH,EAA+B;EAAG,GAAGI;CAAQ,GAElEC,IACJC,KACAC,EAAgB;EACd,QAAQC,EAAOC,CAAO,IAAI,OAAO;GAAE,KAAKA;GAAS,OAAOC;EAAU;EAClE,MAAM;EACN,aAAaP,EAAc;EAC3B,YAAY;EACZ,aAAa;EACb,kBAAkB;EAClB,YAAY;CACd,CAAC;CAUH,SAASQ,EAAU,GAAgC,GAA4B;EAC7E,IAAIC,EAASC,CAAI,GAAG;GAClB,EAAW,QAAQ;IACjB,GAAGR,EAAW;IACd,QAAQ;KAAE,KAAKQ;KAAM,OAAOC;IAAsB;GACpD;GACA;EACF;EAEA,IAAMC,IAASF;EACf,AAAIL,EAAOO,CAAM,KAAKC,EAAYD,CAAM,IACtC,EAAW,QAAQ;GAAE,GAAGV,EAAW;GAAO;EAAO,IAGnD,EAAW,QAAQ;GAAE,GAAGA,EAAW;GAAO,QAAQ;IAAE,KAAKU,EAAO;IAAK,OAAOA,EAAO;GAAM;EAAE;CAC7F;CAWA,OAAO;EACL;EACA;EACA,UAZe,MAAiB;GAChC,EAAW,QAAQ;IAAE,GAAGV,EAAW;IAAO;GAAK;EACjD;EAWE,sBARA,EAAW,QAAQ;GAAE,GAAGA,EAAW;GAAO,MAAMA,EAAW,MAAM,OAAO;EAAE,GACnEA,EAAW,MAAM;CAQ1B;AACF"}

package/dist/domains/api/composables/request.d.ts

@@ -0,0 +1,49 @@
+import { AxiosClientFn } from '../utils/client';
+import { AxiosRequestConfig } from 'axios';
+import { Ref } from 'vue';
+/**
+ * Whether the response carries a body.
+ * axios returns `''` when no bytes arrived, so a 204 and a body-less 200
+ * both arrive as `''`. `0` and `false` are real values and count as a body.
+ * `null` is treated as absent too, because the response type excludes `null`.
+ */
+export declare const hasBody: (res: {
+    data: unknown;
+}) => boolean;
+/**
+ * Strips the helper-owned keys from the caller's `options` at runtime.
+ * The type forbids them, but without this `data` survived the
+ * spread when no body was passed, which allowed a body on a GET.
+ */
+declare const HELPER_OWNED: readonly ["method", "url", "data", "signal"];
+export declare const ownedByHelper: <T extends object>(options: T) => Omit<T, (typeof HELPER_OWNED)[number]>;
+/**
+ * The url as axios actually requests it, rendered by axios itself. An approximation
+ * renders arrays, nested objects and dates differently from the wire.
+ * `undefined` in gives `undefined` out. A call that failed before it had a url has none, and
+ * axios would answer with the client root. An empty string is a real root url and is rendered.
+ * Prefers the config axios kept on the error or response, since it reflects merging and
+ * interceptor rewrites. It is rendered through a defaults-free instance, because `getUri`
+ * merges instance defaults under the config. Only the rebuild goes through the client.
+ * Never throws. It runs inside the catch, and a client without `getUri` (a
+ * stub or mock) must not replace the original error with a `TypeError`.
+ */
+export declare const requestedUrl: (client: AxiosClientFn, url: string | undefined, options?: AxiosRequestConfig, failure?: unknown, dispatched?: AxiosRequestConfig) => string | undefined;
+export type Abortable = {
+    /** Runs one call with a signal of its own, registered so `abort()` can reach it. */
+    run: <T>(fn: (signal: AbortSignal, generation: number) => Promise<T>, external?: AbortSignal) => Promise<T>;
+    /** Stops every call this instance still has in flight. */
+    abort: () => void;
+    /** The generation a call starts in; a stale one must not write to state the caller can see. */
+    generation: () => number;
+    loading: Ref<boolean>;
+};
+export type AbortableOptions = {
+    /**
+     * Each call supersedes the previous one. The abort happens before the new
+     * call registers, so the latest call always wins regardless of interleaving.
+     */
+    cancelPrevious?: boolean;
+};
+export declare const createAbortable: (options?: AbortableOptions) => Abortable;
+export {};

package/dist/domains/api/composables/request.js

@@ -0,0 +1,54 @@
+import { isNull as e, isString as t, isUndefined as n } from "../../../shared/utils/common.js";
+import { ref as r } from "vue";
+import i from "axios";
+// src/domains/api/composables/request.ts
+var a = (t) => !n(t.data) && !e(t.data) && t.data !== "", o = [
+	"method",
+	"url",
+	"data",
+	"signal"
+], s = (e) => {
+	let t = { ...e };
+	for (let e of o) delete t[e];
+	return t;
+}, c, l = () => c ??= i.create(), u = (e, r, a = {}, o, c) => {
+	if (!n(r)) try {
+		let u = (i.isAxiosError(o) ? o.config : void 0) ?? c, d = n(u) ? e().getUri({
+			...s(a),
+			url: r
+		}) : l().getUri(u);
+		return t(d) ? d : r;
+	} catch {
+		return r;
+	}
+}, d = (e = {}) => {
+	let { cancelPrevious: t = !1 } = e, n = /* @__PURE__ */ new Set(), i = 0, a = r(!1), o = () => {
+		a.value = n.size > 0;
+	}, s = () => {
+		n.forEach((e) => e.abort()), n.clear();
+	};
+	return {
+		run: async (e, r) => {
+			t && s(), i += 1;
+			let a = new AbortController();
+			n.add(a), o();
+			let c = () => a.abort();
+			r && (r.aborted ? a.abort() : r.addEventListener("abort", c, { once: !0 }));
+			try {
+				return await e(a.signal, i);
+			} catch (e) {
+				throw a.abort(), e;
+			} finally {
+				r?.removeEventListener("abort", c), n.delete(a), o();
+			}
+		},
+		abort: () => {
+			i += 1, s(), o();
+		},
+		generation: () => i,
+		loading: a
+	};
+};
+export { d as createAbortable, a as hasBody, s as ownedByHelper, u as requestedUrl };
+
+//# sourceMappingURL=request.js.map

package/dist/domains/api/composables/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","names":["axios","hasBody","isUndefined","res","isNull","HELPER_OWNED","ownedByHelper","rest","options","key","rendererInstance","renderer","requestedUrl","url","sent","failure","dispatched","built","client","isString","createAbortable","controllers","generation","loading","ref","syncLoading","abortAll","controller","cancelPrevious","relay","external","fn","err"],"sources":["../../../../src/domains/api/composables/request.ts"],"sourcesContent":["import type { AxiosClientFn } from '@/domains/api/utils/client'\nimport axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios'\nimport { isNull, isString, isUndefined } from '@/shared/utils/common'\nimport { ref, type Ref } from 'vue'\n\n/**\n * Whether the response carries a body.\n * axios returns `''` when no bytes arrived, so a 204 and a body-less 200\n * both arrive as `''`. `0` and `false` are real values and count as a body.\n * `null` is treated as absent too, because the response type excludes `null`.\n */\nexport const hasBody = (res: { data: unknown }): boolean =>\n  !isUndefined(res.data) && !isNull(res.data) && res.data !== ''\n\n/**\n * Strips the helper-owned keys from the caller's `options` at runtime.\n * The type forbids them, but without this `data` survived the\n * spread when no body was passed, which allowed a body on a GET.\n */\nconst HELPER_OWNED = ['method', 'url', 'data', 'signal'] as const\n\nexport const ownedByHelper = <T extends object>(options: T): Omit<T, (typeof HELPER_OWNED)[number]> => {\n  const rest = { ...options } as Record<string, unknown>\n  for (const key of HELPER_OWNED) delete rest[key]\n\n  return rest as Omit<T, (typeof HELPER_OWNED)[number]>\n}\n\n/**\n * Renders a config axios kept. It has no `baseURL` or `params`\n * of its own, so the output is only what the config carries.\n * Created lazily so importing the library does not create an axios instance.\n * Consumers that mock axios and count `create` calls would see an extra one.\n */\nlet rendererInstance: AxiosInstance | undefined\nconst renderer = (): AxiosInstance => (rendererInstance ??= axios.create())\n\n/**\n * The url as axios actually requests it, rendered by axios itself. An approximation\n * renders arrays, nested objects and dates differently from the wire.\n * `undefined` in gives `undefined` out. A call that failed before it had a url has none, and\n * axios would answer with the client root. An empty string is a real root url and is rendered.\n * Prefers the config axios kept on the error or response, since it reflects merging and\n * interceptor rewrites. It is rendered through a defaults-free instance, because `getUri`\n * merges instance defaults under the config. Only the rebuild goes through the client.\n * Never throws. It runs inside the catch, and a client without `getUri` (a\n * stub or mock) must not replace the original error with a `TypeError`.\n */\nexport const requestedUrl = (\n  client: AxiosClientFn,\n  url: string | undefined,\n  options: AxiosRequestConfig = {},\n  failure?: unknown,\n  dispatched?: AxiosRequestConfig\n): string | undefined => {\n  if (isUndefined(url)) return undefined\n\n  try {\n    const sent = (axios.isAxiosError(failure) ? failure.config : undefined) ?? dispatched\n    const built: unknown = isUndefined(sent)\n      ? client().getUri({ ...ownedByHelper(options), url })\n      : renderer().getUri(sent)\n\n    // A stub can answer with anything. The declared type says string, so it has to be one.\n    return isString(built) ? built : url\n  } catch {\n    return url\n  }\n}\n\nexport type Abortable = {\n  /** Runs one call with a signal of its own, registered so `abort()` can reach it. */\n  run: <T>(fn: (signal: AbortSignal, generation: number) => Promise<T>, external?: AbortSignal) => Promise<T>\n  /** Stops every call this instance still has in flight. */\n  abort: () => void\n  /** The generation a call starts in; a stale one must not write to state the caller can see. */\n  generation: () => number\n  loading: Ref<boolean>\n}\n\nexport type AbortableOptions = {\n  /**\n   * Each call supersedes the previous one. The abort happens before the new\n   * call registers, so the latest call always wins regardless of interleaving.\n   */\n  cancelPrevious?: boolean\n}\n\nexport const createAbortable = (options: AbortableOptions = {}): Abortable => {\n  const { cancelPrevious = false } = options\n  const controllers = new Set<AbortController>()\n  let generation = 0\n\n  /**\n   * Derived from the in-flight set, not counted, so it is safe with `cancelPrevious`.\n   * A caller-cleared `finally` flag would turn off when the superseded call ends. Here\n   * the old controller leaves the set as the new one joins, so the value never dips.\n   */\n  const loading = ref(false)\n  const syncLoading = () => {\n    loading.value = controllers.size > 0\n  }\n\n  const abortAll = () => {\n    controllers.forEach((controller) => controller.abort())\n    controllers.clear()\n  }\n\n  const run = async <T>(\n    fn: (signal: AbortSignal, generation: number) => Promise<T>,\n    external?: AbortSignal\n  ): Promise<T> => {\n    // Before the new controller is registered, or the abort would take the new call with it.\n    if (cancelPrevious) abortAll()\n\n    generation += 1\n    const controller = new AbortController()\n    controllers.add(controller)\n    syncLoading()\n\n    // The external signal is relayed, not passed through, because `abort()` can only reach controllers this set owns.\n    const relay = () => controller.abort()\n    if (external) {\n      if (external.aborted) controller.abort()\n      else external.addEventListener('abort', relay, { once: true })\n    }\n\n    try {\n      return await fn(controller.signal, generation)\n    } catch (err: unknown) {\n      // One call can have several requests under its signal (the batch\n      // sends a page set at once). When one fails, abort the rest now.\n      // The `finally` below drops the controller from the set, so a later `abort()` could no longer reach them.\n      controller.abort()\n      throw err\n    } finally {\n      external?.removeEventListener('abort', relay)\n      controllers.delete(controller)\n      syncLoading()\n    }\n  }\n\n  return {\n    run,\n    abort: () => {\n      // Bumped so a call already on its way back cannot write to the caller's state afterwards.\n      generation += 1\n      abortAll()\n      syncLoading()\n    },\n    generation: () => generation,\n    loading,\n  }\n}\n"],"mappings":";;;;AAWA,IAAaC,KAAW,MACtB,CAACC,EAAYC,EAAI,IAAI,KAAK,CAACC,EAAOD,EAAI,IAAI,KAAKA,EAAI,SAAS,IAOxDE,IAAe;CAAC;CAAU;CAAO;CAAQ;AAAQ,GAE1CC,KAAmC,MAAuD;CACrG,IAAMC,IAAO,EAAE,GAAGC,EAAQ;CAC1B,KAAK,IAAMC,KAAOJ,GAAc,OAAOE,EAAKE;CAE5C,OAAOF;AACT,GAQIG,GACEC,UAAiC,MAAqBX,EAAM,OAAO,GAa5DY,KACX,GACA,GACA,IAA8B,CAAC,GAC/B,GACA,MACuB;CACvB,IAAI,GAAYC,CAAG,GAEnB,IAAI;EACF,IAAMC,KAAQd,EAAM,aAAae,CAAO,IAAIA,EAAQ,SAAS,KAAA,MAAcC,GACrEC,IAAiBf,EAAYY,CAAI,IACnCI,EAAO,CAAC,CAAC,OAAO;GAAE,GAAGZ,EAAcE,CAAO;GAAG;EAAI,CAAC,IAClDG,EAAS,CAAC,CAAC,OAAOG,CAAI;EAG1B,OAAOK,EAASF,CAAK,IAAIA,IAAQJ;CACnC,QAAQ;EACN,OAAOA;CACT;AACF,GAoBaO,KAAmB,IAA4B,CAAC,MAAiB;CAC5E,IAAM,EAAE,oBAAiB,OAAUZ,GAC7Ba,oBAAc,IAAI,IAAqB,GACzCC,IAAa,GAOXC,IAAUC,EAAI,EAAK,GACnBC,UAAoB;EACxB,EAAQ,QAAQJ,EAAY,OAAO;CACrC,GAEMK,UAAiB;EAErB,AADAL,EAAY,SAAS,MAAeM,EAAW,MAAM,CAAC,GACtDN,EAAY,MAAM;CACpB;CAoCA,OAAO;EACL,YAlCA,GACA,MACe;GAIf,AAFIO,KAAgBF,EAAS,GAE7B,KAAc;GACd,IAAMC,IAAa,IAAI,gBAAgB;GAEvC,AADAN,EAAY,IAAIM,CAAU,GAC1BF,EAAY;GAGZ,IAAMI,UAAcF,EAAW,MAAM;GACrC,AAAIG,MACEA,EAAS,UAASH,EAAW,MAAM,IAClCG,EAAS,iBAAiB,SAASD,GAAO,EAAE,MAAM,GAAK,CAAC;GAG/D,IAAI;IACF,OAAO,MAAME,EAAGJ,EAAW,QAAQL,CAAU;GAC/C,SAASU,GAAc;IAKrB,MADAL,EAAW,MAAM,GACXK;GACR,UAAU;IAGR,AAFAF,GAAU,oBAAoB,SAASD,CAAK,GAC5CR,EAAY,OAAOM,CAAU,GAC7BF,EAAY;GACd;EACF;EAIE,aAAa;GAIX,AAFA,KAAc,GACdC,EAAS,GACTD,EAAY;EACd;EACA,kBAAkBH;EAClB;CACF;AACF"}

package/dist/domains/api/composables/useApiFetchByIds.d.ts

@@ -0,0 +1,43 @@
+import { UrlParams } from '../utils/apiHelper';
+import { AxiosRequestConfig } from 'axios';
+import { DocId, IntegerId } from '../../../shared/types/common';
+import { Ref } from 'vue';
+import { AxiosClientFn } from '../utils/client';
+export type UseApiFetchByIdsParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    /** i18n scope for field-level validation failures; defaults to `system` / `entity`. */
+    validationSystem?: string;
+    validationEntity?: string;
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    isSearchApi?: boolean;
+    field?: string;
+    cancelPrevious?: boolean;
+};
+export type FetchByIdsParams = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
+};
+/**
+ * Ids per request. A cache drains all queued ids at once, and a thousand ids in
+ * a query string exceed the default 8 KB proxy request line limit, giving a 414.
+ */
+export declare const FETCH_BY_IDS_BATCH_SIZE = 100;
+export declare const useApiFetchByIds: <T>(params: UseApiFetchByIdsParams) => UseApiFetchByIdsReturnType<T>;
+export type UseApiFetchByIdsReturnType<T> = {
+    execute: (ids: DocId[] | IntegerId[], params?: FetchByIdsParams) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight. Unlike a caller-cleared
+     * `finally` flag, it does not dip when `cancelPrevious` supersedes a call.
+     * It covers only this helper's work. Keep your own flag if it also spans follow-up fetches or mapping.
+     * It belongs to the instance. A factory that builds one per call cannot
+     * expose `loading`, `abort` or `cancelPrevious`, so hoist the instance first.
+     */
+    loading: Ref<boolean>;
+};

package/dist/domains/api/composables/useApiFetchByIds.js

@@ -0,0 +1,60 @@
+import { AnzuFatalError as e } from "../../../shared/error/AnzuFatalError.js";
+import { AnzuApiResponseCodeError as t } from "../../../shared/error/AnzuApiResponseCodeError.js";
+import { replaceUrlParameters as n } from "../utils/apiHelper.js";
+import { isValidHTTPStatus as r } from "../utils/response.js";
+import "../../../shared/statusCodes.js";
+import { isDefined as i, isUndefined as a } from "../../../shared/utils/common.js";
+import { useApiQueryBuilder as o } from "./useApiQueryBuilder.js";
+import { mapApiError as s, report as c } from "../utils/apiErrors.js";
+import { createAbortable as l, hasBody as u, ownedByHelper as d, requestedUrl as f } from "./request.js";
+import { readListBody as p } from "../utils/listBody.js";
+var m = (e, t, n = "id") => {
+	let { querySetLimit: r, querySetOffset: i, querySetOrder: a, queryBuild: s, queryAddFilter: c, queryAdd: l } = o(), u = e.length;
+	return r(u), i(1, u), a(n, !1), t ? l(n, e.join(",")) : c("in", n, e.join(",")), s();
+}, h = (o) => {
+	let { client: h, system: g, entity: _, validationSystem: v, validationEntity: y, urlTemplate: b, urlParams: x, options: S = {}, isSearchApi: C = !1, field: w = "id", cancelPrevious: T = !1 } = o, E = l({ cancelPrevious: T }), D = async (o, l) => {
+		let { urlTemplate: T, urlParams: D, signal: O } = l, k, A;
+		try {
+			let s = await E.run((t) => {
+				let r = i(T) ? T : b;
+				if (a(r)) throw new e(void 0, "Url template is undefined");
+				let s = i(D) ? D : x, c = (a(s) ? r : n(r, s)) + m(o, C, w), l = h();
+				return k = c, l.get(c, {
+					...d(S),
+					signal: t
+				});
+			}, O);
+			A = s.config;
+			let c = () => f(h, k, S, void 0, A);
+			if (!r(s.status)) throw new t(s.status);
+			if (s.status === 204) return [];
+			if (!u(s)) throw new t(s.status, void 0, "Expected a response body, url: " + c());
+			return p(s.data, s.status, c()).items;
+		} catch (e) {
+			let t = {
+				system: g,
+				entity: _,
+				validationSystem: v,
+				validationEntity: y,
+				url: f(h, k, S, e, A)
+			};
+			throw c(s(e, t), t);
+		}
+	};
+	return {
+		execute: async (e, t = {}) => {
+			if (e.length <= 100) return D(e, t);
+			let n = [];
+			for (let r = 0; r < e.length; r += 100) {
+				let i = e.slice(r, r + 100);
+				n.push(...await D(i, t));
+			}
+			return n;
+		},
+		abort: E.abort,
+		loading: E.loading
+	};
+};
+export { h as useApiFetchByIds };
+
+//# sourceMappingURL=useApiFetchByIds.js.map

package/dist/domains/api/composables/useApiFetchByIds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiFetchByIds.js","names":["generateByIdsApiQuery","useApiQueryBuilder","limit","ids","querySetLimit","querySetOffset","querySetOrder","field","isSearchApi","queryAdd","queryAddFilter","queryBuild","useApiFetchByIds","params","abortable","createAbortable","executeBatch","urlTemplateOverride","urlParamsOverride","fetchParams","url","dispatched","res","template","isDefined","urlTemplate","isUndefined","AnzuFatalError","resolvedParams","urlParams","requestUrl","replaceUrlParameters","instance","client","ownedByHelper","options","abortSignal","signal","asSent","requestedUrl","isValidHTTPStatus","AnzuApiResponseCodeError","hasBody","readListBody","err","context","report","mapApiError","items","start","batch"],"sources":["../../../../src/domains/api/composables/useApiFetchByIds.ts"],"sourcesContent":["import { AnzuFatalError } from '@/shared/error/AnzuFatalError'\nimport { AnzuApiResponseCodeError } from '@/shared/error/AnzuApiResponseCodeError'\nimport { replaceUrlParameters, type UrlParams } from '@/domains/api/utils/apiHelper'\nimport { isValidHTTPStatus } from '@/domains/api/utils/response'\nimport type { AxiosRequestConfig } from 'axios'\nimport { HTTP_STATUS_NO_CONTENT } from '@/shared/statusCodes'\nimport type { DocId, IntegerId } from '@/shared/types/common'\nimport { isDefined, isUndefined } from '@/shared/utils/common'\nimport type { Ref } from 'vue'\nimport type { AxiosClientFn } from '@/domains/api/utils/client'\nimport { useApiQueryBuilder } from '@/domains/api/composables/useApiQueryBuilder'\nimport { mapApiError, report } from '@/domains/api/utils/apiErrors'\nimport { createAbortable, hasBody, ownedByHelper, requestedUrl } from '@/domains/api/composables/request'\nimport { readListBody } from '@/domains/api/utils/listBody'\n\nexport type UseApiFetchByIdsParams = {\n  client: AxiosClientFn\n  system: string\n  entity: string\n  /** i18n scope for field-level validation failures; defaults to `system` / `entity`. */\n  validationSystem?: string\n  validationEntity?: string\n  urlTemplate?: string\n  urlParams?: UrlParams\n  options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>\n  isSearchApi?: boolean\n  field?: string\n  cancelPrevious?: boolean\n}\n\nexport type FetchByIdsParams = {\n  urlTemplate?: string\n  urlParams?: UrlParams\n  /** Stops this one call, leaving the instance's other calls alone. */\n  signal?: AbortSignal\n}\n\n/**\n * Ids per request. A cache drains all queued ids at once, and a thousand ids in\n * a query string exceed the default 8 KB proxy request line limit, giving a 414.\n */\nexport const FETCH_BY_IDS_BATCH_SIZE = 100\n\nconst generateByIdsApiQuery = (ids: IntegerId[] | DocId[], isSearchApi: boolean, field = 'id'): string => {\n  const { querySetLimit, querySetOffset, querySetOrder, queryBuild, queryAddFilter, queryAdd } = useApiQueryBuilder()\n  const limit = ids.length\n  querySetLimit(limit)\n  querySetOffset(1, limit)\n  querySetOrder(field, false)\n  if (isSearchApi) queryAdd(field, ids.join(','))\n  else queryAddFilter('in', field, ids.join(','))\n\n  return queryBuild()\n}\n\nexport const useApiFetchByIds = <T>(params: UseApiFetchByIdsParams): UseApiFetchByIdsReturnType<T> => {\n  const {\n    client,\n    system,\n    entity,\n    validationSystem,\n    validationEntity,\n    urlTemplate,\n    urlParams,\n    options = {},\n    isSearchApi = false,\n    field = 'id',\n    cancelPrevious = false,\n  } = params\n  const abortable = createAbortable({ cancelPrevious })\n\n  const executeBatch = async (ids: DocId[] | IntegerId[], fetchParams: FetchByIdsParams): Promise<T[]> => {\n    const { urlTemplate: urlTemplateOverride, urlParams: urlParamsOverride, signal } = fetchParams\n\n    // Assigned inside `run` once a url exists. It stays undefined\n    // before that, so a failure before dispatch reports no url.\n    let url: string | undefined\n    // The config axios used, kept for failures raised after reading the response. Those carry\n    // no config, and a rebuild would describe the request as the client would send it now.\n    let dispatched: AxiosRequestConfig | undefined\n\n    try {\n      const res = await abortable.run((abortSignal) => {\n        // Derived inside `run` because `run` opens the generation and, with `cancelPrevious`, stops the\n        // previous call. Work done before it could leave the predecessor running if this call never dispatches.\n        // Inside the try so a missing template raises the same error class as other failures.\n        const template = isDefined(urlTemplateOverride) ? urlTemplateOverride : urlTemplate\n        if (isUndefined(template)) throw new AnzuFatalError(undefined, 'Url template is undefined')\n\n        const resolvedParams = isDefined(urlParamsOverride) ? urlParamsOverride : urlParams\n        const baseUrl = isUndefined(resolvedParams) ? template : replaceUrlParameters(template, resolvedParams)\n        const requestUrl = baseUrl + generateByIdsApiQuery(ids, isSearchApi, field)\n        const instance = client()\n\n        // Recorded last, when nothing before the call can throw. A failing\n        // client factory means no request happened, so no url is reported.\n        url = requestUrl\n\n        return instance.get(requestUrl, { ...ownedByHelper(options), signal: abortSignal })\n      }, signal)\n\n      dispatched = res.config\n      // The url the report names, so the message and context agree when an interceptor rewrote the request.\n      const asSent = () => requestedUrl(client, url, options, undefined, dispatched)\n      if (!isValidHTTPStatus(res.status)) throw new AnzuApiResponseCodeError(res.status)\n\n      // Nothing matched the ids -- an empty answer, not a broken one.\n      if (res.status === HTTP_STATUS_NO_CONTENT) return []\n\n      if (!hasBody(res)) {\n        throw new AnzuApiResponseCodeError(res.status, undefined, 'Expected a response body, url: ' + asSent())\n      }\n\n      return readListBody<T>(res.data, res.status, asSent()).items\n    } catch (err: unknown) {\n      // Built once and shared by both, as in the batch.\n      const context = {\n        system,\n        entity,\n        validationSystem,\n        validationEntity,\n        url: requestedUrl(client, url, options, err, dispatched),\n      }\n\n      throw report(mapApiError(err, context), context)\n    }\n  }\n\n  // Batches run sequentially. In parallel, `cancelPrevious` would make each\n  // batch stop the one before it. A failed batch fails the whole call.\n  const execute = async (ids: DocId[] | IntegerId[], fetchParams: FetchByIdsParams = {}): Promise<T[]> => {\n    if (ids.length <= FETCH_BY_IDS_BATCH_SIZE) return executeBatch(ids, fetchParams)\n    const items: T[] = []\n    for (let start = 0; start < ids.length; start += FETCH_BY_IDS_BATCH_SIZE) {\n      const batch = ids.slice(start, start + FETCH_BY_IDS_BATCH_SIZE) as DocId[] | IntegerId[]\n      items.push(...(await executeBatch(batch, fetchParams)))\n    }\n    return items\n  }\n\n  return { execute, abort: abortable.abort, loading: abortable.loading }\n}\n\nexport type UseApiFetchByIdsReturnType<T> = {\n  execute: (ids: DocId[] | IntegerId[], params?: FetchByIdsParams) => Promise<T[]>\n  abort: () => void\n  /**\n   * True while this instance has a request in flight. Unlike a caller-cleared\n   * `finally` flag, it does not dip when `cancelPrevious` supersedes a call.\n   * It covers only this helper's work. Keep your own flag if it also spans follow-up fetches or mapping.\n   * It belongs to the instance. A factory that builds one per call cannot\n   * expose `loading`, `abort` or `cancelPrevious`, so hoist the instance first.\n   */\n  loading: Ref<boolean>\n}\n"],"mappings":";;;;;;;;;;AA2CA,IAAMA,KAAyB,GAA4B,GAAsB,IAAQ,SAAiB;CACxG,IAAM,EAAE,kBAAe,mBAAgB,kBAAe,eAAY,mBAAgB,gBAAaC,EAAmB,GAC5GC,IAAQC,EAAI;CAOlB,OANAC,EAAcF,CAAK,GACnBG,EAAe,GAAGH,CAAK,GACvBI,EAAcC,GAAO,EAAK,GACtBC,IAAaC,EAASF,GAAOJ,EAAI,KAAK,GAAG,CAAC,IACzCO,EAAe,MAAMH,GAAOJ,EAAI,KAAK,GAAG,CAAC,GAEvCQ,EAAW;AACpB,GAEaC,KAAuB,MAAkE;CACpG,IAAM,EACJ,WACA,WACA,WACA,qBACA,qBACA,gBACA,cACA,aAAU,CAAC,GACX,iBAAc,IACd,WAAQ,MACR,oBAAiB,OACfC,GACEC,IAAYC,EAAgB,EAAE,kBAAe,CAAC,GAE9CC,IAAe,OAAO,GAA4B,MAAgD;EACtG,IAAM,EAAE,aAAaC,GAAqB,WAAWC,GAAmB,cAAWC,GAI/EC,GAGAC;EAEJ,IAAI;GACF,IAAMC,IAAM,MAAMR,EAAU,KAAK,MAAgB;IAI/C,IAAMS,IAAWC,EAAUP,CAAmB,IAAIA,IAAsBQ;IACxE,IAAIC,EAAYH,CAAQ,GAAG,MAAM,IAAII,EAAe,KAAA,GAAW,2BAA2B;IAE1F,IAAMC,IAAiBJ,EAAUN,CAAiB,IAAIA,IAAoBW,GAEpEC,KADUJ,EAAYE,CAAc,IAAIL,IAAWQ,EAAqBR,GAAUK,CAAc,KACzE5B,EAAsBG,GAAKK,GAAaD,CAAK,GACpEyB,IAAWC,EAAO;IAMxB,OAFA,IAAMH,GAECE,EAAS,IAAIF,GAAY;KAAE,GAAGI,EAAcC,CAAO;KAAG,QAAQC;IAAY,CAAC;GACpF,GAAGC,CAAM;GAET,IAAaf,EAAI;GAEjB,IAAMgB,UAAeC,EAAaN,GAAQb,GAAKe,GAAS,KAAA,GAAWd,CAAU;GAC7E,IAAI,CAACmB,EAAkBlB,EAAI,MAAM,GAAG,MAAM,IAAImB,EAAyBnB,EAAI,MAAM;GAGjF,IAAIA,EAAI,WAAA,KAAmC,OAAO,CAAC;GAEnD,IAAI,CAACoB,EAAQpB,CAAG,GACd,MAAM,IAAImB,EAAyBnB,EAAI,QAAQ,KAAA,GAAW,oCAAoCgB,EAAO,CAAC;GAGxG,OAAOK,EAAgBrB,EAAI,MAAMA,EAAI,QAAQgB,EAAO,CAAC,CAAC,CAAC;EACzD,SAASM,GAAc;GAErB,IAAMC,IAAU;IACd;IACA;IACA;IACA;IACA,KAAKN,EAAaN,GAAQb,GAAKe,GAASS,GAAKvB,CAAU;GACzD;GAEA,MAAMyB,EAAOC,EAAYH,GAAKC,CAAO,GAAGA,CAAO;EACjD;CACF;CAcA,OAAO;EAAE,gBAVc,GAA4B,IAAgC,CAAC,MAAoB;GACtG,IAAI1C,EAAI,UAAA,KAAmC,OAAOa,EAAab,GAAKgB,CAAW;GAC/E,IAAM6B,IAAa,CAAC;GACpB,KAAK,IAAIC,IAAQ,GAAGA,IAAQ9C,EAAI,QAAQ,KAAA,KAAkC;IACxE,IAAM+C,IAAQ/C,EAAI,MAAM8C,GAAOA,IAAA,GAA+B;IAC9D,EAAM,KAAK,GAAI,MAAMjC,EAAakC,GAAO/B,CAAW,CAAE;GACxD;GACA,OAAO6B;EACT;EAEkB,OAAOlC,EAAU;EAAO,SAASA,EAAU;CAAQ;AACvE"}

package/dist/domains/api/composables/useApiFetchItems.d.ts

@@ -0,0 +1,62 @@
+import { UrlParams } from '../utils/apiHelper';
+import { AxiosRequestConfig } from 'axios';
+import { Ref } from 'vue';
+import { AxiosClientFn } from '../utils/client';
+/** Which of the two shapes a list arrives in. */
+export type ItemsShape = 'envelope' | 'array';
+export type UseApiFetchItemsParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    /** i18n scope for field-level validation failures; defaults to `system` / `entity`. */
+    validationSystem?: string;
+    validationEntity?: string;
+    /**
+     * The full url including the query, already built by the caller.
+     * `urlParams` are substituted into the path only. A placeholder in the query
+     * is sent as is. Put the value in the query or pass it via `options.params`.
+     */
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: Omit<AxiosRequestConfig, 'method' | 'url' | 'data' | 'signal'>;
+    cancelPrevious?: boolean;
+    /**
+     * Defaults to `GET`.
+     * Other verbs exist because a filter too big for a url goes out
+     * as a POST, and a mutation can answer with the changed list.
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    /**
+     * Defaults to `'envelope'`, the fleet norm.
+     * The reader refuses an undeclared shape, so a forgotten `'array'` fails on the first run.
+     */
+    shape?: ItemsShape;
+};
+export type FetchItemsParams<B = never> = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    /** `null` omits the body, as everywhere in this family. */
+    body?: B;
+    /** Stops this one call, leaving the instance's other calls alone. */
+    signal?: AbortSignal;
+};
+/**
+ * Fetches a list from an endpoint whose query the caller already built, without pagination.
+ * Replaces `useApiRequest<ApiResponseList<T[]>>` reads, which never checked that `data`
+ * is an array. `useApiFetchList` needs pagination and filter config these calls lack.
+ * `shape` is declared, and the reader refuses the other shape, so a wrong declaration fails loudly.
+ * Writes no metadata. Use `useApiFetchList` for user-driven paging and `useApiFetchListBatch` to read all pages.
+ */
+export declare const useApiFetchItems: <T, B = never>(params: UseApiFetchItemsParams) => UseApiFetchItemsReturnType<T, B>;
+export type UseApiFetchItemsReturnType<T, B = never> = {
+    execute: (params?: FetchItemsParams<B>) => Promise<T[]>;
+    abort: () => void;
+    /**
+     * True while this instance has a request in flight. Unlike a caller-cleared
+     * `finally` flag, it does not dip when `cancelPrevious` supersedes a call.
+     * It covers only this helper's work. Keep your own flag if it also spans follow-up fetches or mapping.
+     * It belongs to the instance. A factory that builds one per call cannot
+     * expose `loading`, `abort` or `cancelPrevious`, so hoist the instance first.
+     */
+    loading: Ref<boolean>;
+};