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

package/dist/domains/log/composables/logActions.d.ts

@@ -0,0 +1,132 @@
+import { Ref } from 'vue';
+import { AxiosClientFn } from '../../api/utils/client';
+import { FilterConfig, FilterData } from '../../filters/composables/filterFactory';
+import { Pagination } from '../../api/composables/pagination';
+import { LogPaths, LogTypeType } from './logType';
+import { Log } from '../types/Log';
+interface LogActionsParams {
+    client: AxiosClientFn;
+    system: string;
+    logPaths: LogPaths;
+    type: LogTypeType;
+    /**
+     * Lets an ancestor own the flag, the way `usePagination` takes an external pagination ref --
+     * the card that shows the spinner sits above the table that does the fetching.
+     */
+    loading?: Ref<boolean>;
+}
+/**
+ * Everything here is per instance, unlike the module-level refs the admins used to keep: the
+ * views are remounted on every system/type change, and a `finally` belonging to the instance
+ * that just went away would otherwise clear the new one's loading flag.
+ */
+export declare function useLogListActions(params: LogActionsParams): {
+    listItems: Ref<{
+        id: string;
+        message: string;
+        datetime: import('../../../lib').DatetimeUTC;
+        levelName: import('../valueObject/LogLevel').LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: import('../../../lib').IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    }[], Log[] | {
+        id: string;
+        message: string;
+        datetime: import('../../../lib').DatetimeUTC;
+        levelName: import('../valueObject/LogLevel').LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: import('../../../lib').IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    }[]>;
+    listLoading: Ref<boolean, boolean>;
+    datatableHiddenColumns: Ref<string[], string[]>;
+    fetchList: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>) => Promise<void>;
+    cancel: () => void;
+};
+export declare function useLogDetailActions(params: LogActionsParams): {
+    log: Ref<{
+        id: string;
+        message: string;
+        datetime: import('../../../lib').DatetimeUTC;
+        levelName: import('../valueObject/LogLevel').LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: import('../../../lib').IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    } | null, Log | {
+        id: string;
+        message: string;
+        datetime: import('../../../lib').DatetimeUTC;
+        levelName: import('../valueObject/LogLevel').LogLevelType;
+        context: {
+            appVersion: string;
+            appSystem: string;
+            requestOriginAppVersion: string;
+            path: string;
+            method: string;
+            contextId: string;
+            userId: import('../../../lib').IntegerIdNullable;
+            resourceName: string;
+            resourceIds: string[];
+            ip: string;
+            response: string;
+            content?: string | undefined;
+            params: string;
+            httpStatus: number;
+        };
+        _resourceName: string;
+        _system: string;
+        _type: string;
+    } | null>;
+    detailLoading: Ref<boolean, boolean>;
+    fetchData: (id: string) => Promise<boolean | undefined>;
+    cancel: () => void;
+};
+export {};

package/dist/domains/log/composables/logActions.js

@@ -0,0 +1,62 @@
+import { useAlerts as e } from "../../system/composables/alerts.js";
+import { handleRecordLoadError as t } from "../../system/composables/recordPage.js";
+import { useFetchLog as n, useFetchLogList as r } from "../api/logApi.js";
+import { ref as i } from "vue";
+//#region src/domains/log/composables/logActions.ts
+function a(t) {
+	let { showErrorsDefault: n } = e(), { execute: a, abort: o } = r(t), s = i([]), c = t.loading ?? i(!1), l = i([]), u = 0, d = (e) => e === u;
+	return {
+		listItems: s,
+		listLoading: c,
+		datatableHiddenColumns: l,
+		fetchList: async (e, t, r) => {
+			let o = ++u;
+			c.value = !0;
+			let l = i({ ...e.value });
+			try {
+				let n = await a(l, t, r);
+				if (!d(o)) return;
+				s.value = n, e.value = {
+					...e.value,
+					hasNextPage: l.value.hasNextPage,
+					currentViewCount: l.value.currentViewCount,
+					totalCount: l.value.totalCount
+				};
+			} catch (e) {
+				if (!d(o)) return;
+				s.value = [], n(e);
+			} finally {
+				d(o) && (c.value = !1);
+			}
+		},
+		cancel: () => {
+			u++, o();
+		}
+	};
+}
+function o(e) {
+	let { execute: r, abort: a } = n(e), o = i(null), s = e.loading ?? i(!1), c = 0, l = (e) => e === c;
+	return {
+		log: o,
+		detailLoading: s,
+		fetchData: async (e) => {
+			let n = ++c;
+			s.value = !0;
+			try {
+				let t = await r({ urlParams: { id: e } });
+				return l(n) ? (o.value = t, !0) : void 0;
+			} catch (e) {
+				return l(n) ? (o.value = null, !t(e) && void 0) : void 0;
+			} finally {
+				l(n) && (s.value = !1);
+			}
+		},
+		cancel: () => {
+			c++, a();
+		}
+	};
+}
+//#endregion
+export { o as useLogDetailActions, a as useLogListActions };
+
+//# sourceMappingURL=logActions.js.map

package/dist/domains/log/composables/logActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logActions.js","names":["useLogListActions","useAlerts","useFetchLogList","params","listItems","ref","listLoading","datatableHiddenColumns","generation","isCurrent","token","scratch","pagination","items","execute","filterData","filterConfig","error","showErrorsDefault","abort","useLogDetailActions","useFetchLog","log","detailLoading","res"],"sources":["../../../../src/domains/log/composables/logActions.ts"],"sourcesContent":["import { ref, type Ref } from 'vue'\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 { useFetchLog, useFetchLogList } from '@/domains/log/api/logApi'\nimport type { LogPaths, LogTypeType } from '@/domains/log/composables/logType'\nimport type { Log } from '@/domains/log/types/Log'\n\ninterface LogActionsParams {\n  client: AxiosClientFn\n  system: string\n  logPaths: LogPaths\n  type: LogTypeType\n  /**\n   * Lets an ancestor own the flag, the way `usePagination` takes an external pagination ref --\n   * the card that shows the spinner sits above the table that does the fetching.\n   */\n  loading?: Ref<boolean>\n}\n\n/**\n * Everything here is per instance, unlike the module-level refs the admins used to keep: the\n * views are remounted on every system/type change, and a `finally` belonging to the instance\n * that just went away would otherwise clear the new one's loading flag.\n */\nexport function useLogListActions(params: LogActionsParams) {\n  const { showErrorsDefault } = useAlerts()\n  const { execute, abort } = useFetchLogList(params)\n\n  const listItems = ref<Log[]>([])\n  const listLoading = params.loading ?? ref(false)\n  const datatableHiddenColumns = ref<Array<string>>([])\n\n  // Aborting is not enough on its own: axios rejects a cancelled request with `CanceledError`,\n  // which is an axios error rather than a `DOMException` named `AbortError`, so it slips past the\n  // helper's swallow and arrives here as a normal failure. Without this token the user would get\n  // an error alert for an action they took themselves.\n  let generation = 0\n  const isCurrent = (token: number) => token === generation\n\n  const fetchList = async (\n    pagination: Ref<Pagination>,\n    filterData: FilterData<any>,\n    filterConfig: FilterConfig<any>\n  ) => {\n    const token = ++generation\n    listLoading.value = true\n    // `execute` writes the counts into the ref it is handed, inside the call -- before\n    // anything out here could decide to discard them. It gets a copy, and the counts are\n    // committed to the real one only if this call is still the current one.\n    const scratch = ref<Pagination>({ ...pagination.value })\n    try {\n      const items = await execute(scratch, filterData, filterConfig)\n      if (!isCurrent(token)) return\n      listItems.value = items\n      // Reading the scratch ref is the whole point -- these are the counts the helper just wrote\n      // into it, and this is the one moment they are known to belong to the current request.\n      /* eslint-disable vue/no-ref-object-reactivity-loss */\n      pagination.value = {\n        ...pagination.value,\n        hasNextPage: scratch.value.hasNextPage,\n        currentViewCount: scratch.value.currentViewCount,\n        totalCount: scratch.value.totalCount,\n      }\n      /* eslint-enable vue/no-ref-object-reactivity-loss */\n    } catch (error) {\n      if (!isCurrent(token)) return\n      // A failed fetch must not leave the previous type's rows on screen under the new url.\n      listItems.value = []\n      showErrorsDefault(error)\n    } finally {\n      if (isCurrent(token)) listLoading.value = false\n    }\n  }\n\n  /** Invalidates whatever is in flight, then cancels it. Order matters: the token first. */\n  const cancel = () => {\n    generation++\n    abort()\n  }\n\n  return {\n    listItems,\n    listLoading,\n    datatableHiddenColumns,\n    fetchList,\n    cancel,\n  }\n}\n\nexport function useLogDetailActions(params: LogActionsParams) {\n  const { execute, abort } = useFetchLog(params)\n\n  const log = ref<Log | null>(null)\n  const detailLoading = params.loading ?? ref(false)\n\n  let generation = 0\n  const isCurrent = (token: number) => token === generation\n\n  /** `true` once loaded, `false` when the page should leave, `undefined` when superseded or stopped. */\n  const fetchData = async (id: string): Promise<boolean | undefined> => {\n    const token = ++generation\n    detailLoading.value = true\n    try {\n      const res = await execute({ urlParams: { id } })\n      if (!isCurrent(token)) return undefined\n      log.value = res\n      return true\n    } catch (error) {\n      if (!isCurrent(token)) return undefined\n      log.value = null\n      return handleRecordLoadError(error) ? false : undefined\n    } finally {\n      if (isCurrent(token)) detailLoading.value = false\n    }\n  }\n\n  const cancel = () => {\n    generation++\n    abort()\n  }\n\n  return {\n    log,\n    detailLoading,\n    fetchData,\n    cancel,\n  }\n}\n"],"mappings":";;;;;AA2BA,SAAgBA,EAAkB,GAA0B;CAC1D,IAAM,EAAE,yBAAsBC,EAAU,GAClC,EAAE,YAAS,aAAUC,EAAgBC,CAAM,GAE3CC,IAAYC,EAAW,CAAC,CAAC,GACzBC,IAAcH,EAAO,WAAWE,EAAI,EAAK,GACzCE,IAAyBF,EAAmB,CAAC,CAAC,GAMhDG,IAAa,GACXC,KAAa,MAAkBC,MAAUF;CA2C/C,OAAO;EACL;EACA;EACA;EACA,kBA5CA,GACA,GACA,MACG;GACH,IAAME,IAAQ,EAAEF;GAChB,EAAY,QAAQ;GAIpB,IAAMG,IAAUN,EAAgB,EAAE,GAAGO,EAAW,MAAM,CAAC;GACvD,IAAI;IACF,IAAMC,IAAQ,MAAMC,EAAQH,GAASI,GAAYC,CAAY;IAC7D,IAAI,CAACP,EAAUC,CAAK,GAAG;IAKvB,AAJA,EAAU,QAAQG,GAIlB,EAAW,QAAQ;KACjB,GAAGD,EAAW;KACd,aAAaD,EAAQ,MAAM;KAC3B,kBAAkBA,EAAQ,MAAM;KAChC,YAAYA,EAAQ,MAAM;IAC5B;GAEF,SAASM,GAAO;IACd,IAAI,CAACR,EAAUC,CAAK,GAAG;IAGvB,AADA,EAAU,QAAQ,CAAC,GACnBQ,EAAkBD,CAAK;GACzB,UAAU;IACR,AAAIR,EAAUC,CAAK,MAAG,EAAY,QAAQ;GAC5C;EACF;EAaE,cAVmB;GAEnB,AADA,KACAS,EAAM;EACR;CAQA;AACF;AAEA,SAAgBC,EAAoB,GAA0B;CAC5D,IAAM,EAAE,YAAS,aAAUC,EAAYlB,CAAM,GAEvCmB,IAAMjB,EAAgB,IAAI,GAC1BkB,IAAgBpB,EAAO,WAAWE,EAAI,EAAK,GAE7CG,IAAa,GACXC,KAAa,MAAkBC,MAAUF;CAyB/C,OAAO;EACL;EACA;EACA,kBAzBuB,MAA6C;GACpE,IAAME,IAAQ,EAAEF;GAChB,EAAc,QAAQ;GACtB,IAAI;IACF,IAAMgB,IAAM,MAAMV,EAAQ,EAAE,WAAW,EAAE,MAAG,EAAE,CAAC;IAG/C,OAFKL,EAAUC,CAAK,KACpB,EAAI,QAAQc,GACL,MAFgB;GAGzB,SAASP,GAAO;IAGd,OAFKR,EAAUC,CAAK,KACpB,EAAI,QAAQ,MACL,GAAsBO,CAAK,KAAY,KAAA,KAFvB;GAGzB,UAAU;IACR,AAAIR,EAAUC,CAAK,MAAG,EAAc,QAAQ;GAC9C;EACF;EAWE,cATmB;GAEnB,AADA,KACAS,EAAM;EACR;CAOA;AACF"}

package/dist/domains/log/composables/logType.d.ts

@@ -0,0 +1,43 @@
+import { ValueObjectOption } from '../../../shared/types/ValueObject';
+/**
+ * The two log stores every anzu backend exposes. This is a runtime value on purpose: the router
+ * guard validates the `:type` path segment before any component mounts, and a bare TypeScript
+ * type is erased by then. It is the single source of the valid set -- the dropdown iterates the
+ * same object the guard checks against, so the two cannot drift apart.
+ */
+export declare const LogType: {
+    readonly App: "app";
+    readonly Audit: "audit";
+};
+export type LogTypeType = (typeof LogType)[keyof typeof LogType];
+export declare const LogTypeDefault: "app";
+export declare const isLogType: (value: unknown) => value is LogTypeType;
+/**
+ * Full paths per type, not a segment appended to a shared prefix: brick exposes its app log at
+ * `/adm/v1/log/journal` rather than `/adm/v1/log/app`, and nothing says the next backend will
+ * differ in the same place.
+ */
+export type LogPaths = Record<LogTypeType, string>;
+export declare const DEFAULT_LOG_PATHS: LogPaths;
+export declare function useLogType(): {
+    logTypeOptions: import('vue').Ref<{
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[], ValueObjectOption<LogTypeType>[] | {
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[]>;
+    getLogTypeOption: (value: LogTypeType) => {
+        value: LogTypeType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    } | undefined;
+};

package/dist/domains/log/composables/logType.js

@@ -0,0 +1,23 @@
+import { ref as e } from "vue";
+//#region src/domains/log/composables/logType.ts
+var t = {
+	App: "app",
+	Audit: "audit"
+}, n = t.App, r = (e) => Object.values(t).includes(e), i = {
+	app: "/adm/v1/log/app",
+	audit: "/adm/v1/log/audit"
+};
+function a() {
+	let n = e(Object.values(t).map((e) => ({
+		value: e,
+		title: e
+	})));
+	return {
+		logTypeOptions: n,
+		getLogTypeOption: (e) => n.value.find((t) => t.value === e)
+	};
+}
+//#endregion
+export { i as DEFAULT_LOG_PATHS, t as LogType, n as LogTypeDefault, r as isLogType, a as useLogType };
+
+//# sourceMappingURL=logType.js.map

package/dist/domains/log/composables/logType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logType.js","names":["LogType","LogTypeDefault","isLogType","value","DEFAULT_LOG_PATHS","useLogType","logTypeOptions","ref","item"],"sources":["../../../../src/domains/log/composables/logType.ts"],"sourcesContent":["import { ref } from 'vue'\nimport type { ValueObjectOption } from '@/shared/types/ValueObject'\n\n/**\n * The two log stores every anzu backend exposes. This is a runtime value on purpose: the router\n * guard validates the `:type` path segment before any component mounts, and a bare TypeScript\n * type is erased by then. It is the single source of the valid set -- the dropdown iterates the\n * same object the guard checks against, so the two cannot drift apart.\n */\nexport const LogType = {\n  App: 'app',\n  Audit: 'audit',\n} as const\nexport type LogTypeType = (typeof LogType)[keyof typeof LogType]\nexport const LogTypeDefault = LogType.App\n\nexport const isLogType = (value: unknown): value is LogTypeType => Object.values(LogType).includes(value as LogTypeType)\n\n/**\n * Full paths per type, not a segment appended to a shared prefix: brick exposes its app log at\n * `/adm/v1/log/journal` rather than `/adm/v1/log/app`, and nothing says the next backend will\n * differ in the same place.\n */\nexport type LogPaths = Record<LogTypeType, string>\n\nexport const DEFAULT_LOG_PATHS: LogPaths = {\n  app: '/adm/v1/log/app',\n  audit: '/adm/v1/log/audit',\n}\n\nexport function useLogType() {\n  // Raw `app` / `audit` titles, as every admin shows them today. `common.log.filter.type` is the\n  // select's own label, not a per-option name -- one translation cannot title two options.\n  const logTypeOptions = ref<ValueObjectOption<LogTypeType>[]>(\n    Object.values(LogType).map((value) => ({ value, title: value }))\n  )\n\n  const getLogTypeOption = (value: LogTypeType) => {\n    return logTypeOptions.value.find((item) => item.value === value)\n  }\n\n  return {\n    logTypeOptions,\n    getLogTypeOption,\n  }\n}\n"],"mappings":";;AASA,IAAaA,IAAU;CACrB,KAAK;CACL,OAAO;AACT,GAEaC,IAAiBD,EAAQ,KAEzBE,KAAa,MAAyC,OAAO,OAAOF,CAAO,CAAC,CAAC,SAASG,CAAoB,GAS1GC,IAA8B;CACzC,KAAK;CACL,OAAO;AACT;AAEA,SAAgBC,IAAa;CAG3B,IAAMC,IAAiBC,EACrB,OAAO,OAAOP,CAAO,CAAC,CAAC,KAAK,OAAW;EAAE;EAAO,OAAOG;CAAM,EAAE,CACjE;CAMA,OAAO;EACL;EACA,mBANwB,MACjBG,EAAe,MAAM,MAAM,MAASE,EAAK,UAAUL,CAAK;CAMjE;AACF"}

package/dist/domains/log/filter/logFilter.d.ts

@@ -0,0 +1,141 @@
+import { FilterConfig, FilterData } from '../../filters/composables/filterFactory';
+import { LogTypeType } from '../composables/logType';
+import { DatetimeUTC } from '../../../shared/types/common';
+export interface LogTimeWindow {
+    from: DatetimeUTC;
+    to: DatetimeUTC;
+}
+/**
+ * A factory rather than a constant, because `defaultTimeWindow` cannot be expressed as a seeded
+ * value: what makes the window always reach the query is `mandatory` plus `default` on the two
+ * interval fields, and both are read out of this array when `createFilter` runs.
+ */
+declare const logFilterFields: (window: LogTimeWindow | undefined) => ({
+    name: "levelName";
+    variant: "in";
+    default: never[];
+    type?: undefined;
+    apiName?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "id";
+    default: null;
+    type: "string";
+    variant?: undefined;
+    apiName?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "contextId";
+    apiName: string;
+    default: null;
+    type: "string";
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "message";
+    variant: "startsWith";
+    default: null;
+    type: "string";
+    render: {
+        skip: true;
+    };
+    apiName?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "appVersion";
+    variant: "startsWith";
+    apiName: string;
+    default: null;
+    type: "string";
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "userId";
+    apiName: string;
+    default: null;
+    type: "integer";
+    variant?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "resourceName";
+    apiName: string;
+    default: null;
+    type: "string";
+    variant?: undefined;
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "resourceIds";
+    apiName: string;
+    variant: "in";
+    default: never[];
+    type: "string";
+    render?: undefined;
+    related?: undefined;
+    mandatory?: undefined;
+    exclude?: undefined;
+} | {
+    name: "datetimeFrom";
+    apiName: string;
+    type: "timeInterval";
+    related: string;
+    default: string | null;
+    mandatory: boolean;
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    exclude?: undefined;
+} | {
+    name: "datetimeTo";
+    apiName: string;
+    type: "timeInterval";
+    exclude: true;
+    default: string | null;
+    mandatory: boolean;
+    render: {
+        skip: true;
+    };
+    variant?: undefined;
+    related?: undefined;
+})[];
+type LogFilterFields = ReturnType<typeof logFilterFields>;
+export interface LogFilter {
+    filterConfig: FilterConfig<LogFilterFields>;
+    filterData: FilterData<LogFilterFields>;
+}
+export declare function useLogFilter(system: string, window: LogTimeWindow | undefined): LogFilter;
+/**
+ * Called on every mount, not only when the type changes. The registry hands back the same
+ * `filterConfig` the previous visit left behind, so these flags still describe whichever type was
+ * open last. Landing straight on an `app` url after an audit visit -- a link, a bookmark, F5 --
+ * would otherwise send that visit's `resourceName` to the app endpoint.
+ *
+ * Three flags, not two -- `FiltersSelected` hides a chip on `render.selected`, so without the
+ * third one the bar would advertise a filter that is not being applied, and its close button
+ * would destroy the very value this approach exists to keep.
+ */
+export declare const applyLogTypeVisibility: (filter: LogFilter, type: LogTypeType) => void;
+/** For tests and for anything that needs a clean slate; nothing in the views calls it. */
+export declare const resetLogFilterRegistry: () => void;
+export {};

package/dist/domains/log/filter/logFilter.js

@@ -0,0 +1,100 @@
+import { isDefined as e } from "../../../shared/utils/common.js";
+import { createFilter as t, createFilterStore as n } from "../../filters/composables/filterFactory.js";
+import { LogType as r } from "../composables/logType.js";
+//#region src/domains/log/filter/logFilter.ts
+var i = ["resourceName", "resourceIds"], a = (t) => [
+	{
+		name: "levelName",
+		variant: "in",
+		default: []
+	},
+	{
+		name: "id",
+		default: null,
+		type: "string"
+	},
+	{
+		name: "contextId",
+		apiName: "context.contextId",
+		default: null,
+		type: "string",
+		render: { skip: !0 }
+	},
+	{
+		name: "message",
+		variant: "startsWith",
+		default: null,
+		type: "string",
+		render: { skip: !0 }
+	},
+	{
+		name: "appVersion",
+		variant: "startsWith",
+		apiName: "context.appVersion",
+		default: null,
+		type: "string"
+	},
+	{
+		name: "userId",
+		apiName: "context.userId",
+		default: null,
+		type: "integer"
+	},
+	{
+		name: "resourceName",
+		apiName: "context.resourceName",
+		default: null,
+		type: "string"
+	},
+	{
+		name: "resourceIds",
+		apiName: "context.resourceIds",
+		variant: "in",
+		default: [],
+		type: "string"
+	},
+	{
+		name: "datetimeFrom",
+		apiName: "datetime",
+		type: "timeInterval",
+		related: "datetimeTo",
+		default: t?.from ?? null,
+		mandatory: e(t),
+		render: { skip: !0 }
+	},
+	{
+		name: "datetimeTo",
+		apiName: "datetime",
+		type: "timeInterval",
+		exclude: !0,
+		default: t?.to ?? null,
+		mandatory: e(t),
+		render: { skip: !0 }
+	}
+], o = /* @__PURE__ */ new Map();
+function s(e, r) {
+	let i = o.get(e);
+	if (i) {
+		if (r) {
+			let { fields: e } = i.filterConfig;
+			i.filterData.datetimeFrom === e.datetimeFrom.default && (i.filterData.datetimeFrom = r.from), i.filterData.datetimeTo === e.datetimeTo.default && (i.filterData.datetimeTo = r.to), e.datetimeFrom.default = r.from, e.datetimeTo.default = r.to;
+		}
+		return i;
+	}
+	let s = a(r), c = t(s, n(s), {
+		system: "common",
+		subject: "log"
+	});
+	return o.set(e, c), c;
+}
+var c = (e, t) => {
+	let n = t !== r.Audit;
+	i.forEach((t) => {
+		let r = e.filterConfig.fields[t];
+		r.exclude = n, r.render.skip = n, r.render.selected = !n;
+	});
+};
+//#endregion
+export { c as applyLogTypeVisibility, s as useLogFilter };
+
+//# sourceMappingURL=logFilter.js.map

package/dist/domains/log/filter/logFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFilter.js","names":["AUDIT_ONLY_FIELDS","logFilterFields","window","isDefined","registry","useLogFilter","existing","system","fields","created","createFilter","createFilterStore","applyLogTypeVisibility","hide","type","LogType","field","filter","name"],"sources":["../../../../src/domains/log/filter/logFilter.ts"],"sourcesContent":["import {\n  createFilter,\n  createFilterStore,\n  type FilterConfig,\n  type FilterData,\n  type MakeFilterOption,\n} from '@/domains/filters/composables/filterFactory'\nimport { LOG_ENTITY } from '@/domains/log/api/logApi'\nimport { LogType, type LogTypeType } from '@/domains/log/composables/logType'\nimport type { DatetimeUTC } from '@/shared/types/common'\nimport { isDefined } from '@/shared/utils/common'\n\nexport interface LogTimeWindow {\n  from: DatetimeUTC\n  to: DatetimeUTC\n}\n\n/**\n * Fields that only make sense for the audit store. Switching to `app` hides them and keeps them\n * out of the query -- it never clears them, so a value typed here survives a round trip through\n * `app` and is still there when the user comes back.\n */\nconst AUDIT_ONLY_FIELDS = ['resourceName', 'resourceIds'] as const\n\n/**\n * A factory rather than a constant, because `defaultTimeWindow` cannot be expressed as a seeded\n * value: what makes the window always reach the query is `mandatory` plus `default` on the two\n * interval fields, and both are read out of this array when `createFilter` runs.\n */\nconst logFilterFields = (window: LogTimeWindow | undefined) =>\n  [\n    { name: 'levelName' as const, variant: 'in', default: [] },\n    { name: 'id' as const, default: null, type: 'string' },\n    // Both drawn by hand in the `#search` slot of `ALogFilter`; without `skip` they would appear\n    // a second time in the \"more\" panel.\n    {\n      name: 'contextId' as const,\n      apiName: 'context.contextId',\n      default: null,\n      type: 'string',\n      render: { skip: true },\n    },\n    { name: 'message' as const, variant: 'startsWith', default: null, type: 'string', render: { skip: true } },\n    {\n      name: 'appVersion' as const,\n      variant: 'startsWith',\n      apiName: 'context.appVersion',\n      default: null,\n      type: 'string',\n    },\n    { name: 'userId' as const, apiName: 'context.userId', default: null, type: 'integer' },\n    { name: 'resourceName' as const, apiName: 'context.resourceName', default: null, type: 'string' },\n    {\n      name: 'resourceIds' as const,\n      apiName: 'context.resourceIds',\n      variant: 'in',\n      default: [],\n      type: 'string',\n    },\n    // Both rendered by hand in the `#search` slot of `ALogFilter`; without `skip` they would be\n    // drawn a second time in the \"more\" panel, where `FilterDetailItem` has no case for\n    // `timeInterval` and falls through to `AFilterEmpty`, which prints the bare field name.\n    {\n      name: 'datetimeFrom' as const,\n      apiName: 'datetime',\n      type: 'timeInterval',\n      related: 'datetimeTo',\n      default: window?.from ?? null,\n      mandatory: isDefined(window),\n      render: { skip: true },\n    },\n    {\n      name: 'datetimeTo' as const,\n      apiName: 'datetime',\n      type: 'timeInterval',\n      exclude: true,\n      default: window?.to ?? null,\n      mandatory: isDefined(window),\n      render: { skip: true },\n    },\n  ] satisfies readonly MakeFilterOption[]\n\ntype LogFilterFields = ReturnType<typeof logFilterFields>\n\nexport interface LogFilter {\n  filterConfig: FilterConfig<LogFilterFields>\n  filterData: FilterData<LogFilterFields>\n}\n\n/**\n * Keyed by system, so `/weather/logs` and `/brick/logs` cannot overwrite each other's values --\n * and deliberately *not* by type, so everything the two stores share (context id, level, time\n * range, user, message) survives a switch between app and audit. That carry-over is the whole\n * reason this is one view instead of two pages.\n *\n * Module level, so the values outlive the component: `createFilterStore` is only a factory, and\n * one created in `setup()` would die with the instance that made it.\n */\nconst registry = new Map<string, LogFilter>()\n\nexport function useLogFilter(system: string, window: LogTimeWindow | undefined): LogFilter {\n  const existing = registry.get(system)\n  if (existing) {\n    if (window) {\n      const { fields } = existing.filterConfig\n      // A value still at the old default was never chosen by the user, so it moves with the window.\n      if (existing.filterData.datetimeFrom === fields.datetimeFrom.default)\n        existing.filterData.datetimeFrom = window.from\n      if (existing.filterData.datetimeTo === fields.datetimeTo.default) existing.filterData.datetimeTo = window.to\n      fields.datetimeFrom.default = window.from\n      fields.datetimeTo.default = window.to\n    }\n    return existing\n  }\n\n  const fields = logFilterFields(window)\n  const created = createFilter(fields, createFilterStore(fields), {\n    system: 'common',\n    subject: LOG_ENTITY,\n  })\n  registry.set(system, created)\n\n  return created\n}\n\n/**\n * Called on every mount, not only when the type changes. The registry hands back the same\n * `filterConfig` the previous visit left behind, so these flags still describe whichever type was\n * open last. Landing straight on an `app` url after an audit visit -- a link, a bookmark, F5 --\n * would otherwise send that visit's `resourceName` to the app endpoint.\n *\n * Three flags, not two -- `FiltersSelected` hides a chip on `render.selected`, so without the\n * third one the bar would advertise a filter that is not being applied, and its close button\n * would destroy the very value this approach exists to keep.\n */\nexport const applyLogTypeVisibility = (filter: LogFilter, type: LogTypeType): void => {\n  const hide = type !== LogType.Audit\n\n  AUDIT_ONLY_FIELDS.forEach((name) => {\n    const field = filter.filterConfig.fields[name]\n    field.exclude = hide\n    field.render.skip = hide\n    field.render.selected = !hide\n  })\n}\n\n/** For tests and for anything that needs a clean slate; nothing in the views calls it. */\nexport const resetLogFilterRegistry = (): void => {\n  registry.clear()\n}\n"],"mappings":";;;;AAsBA,IAAMA,IAAoB,CAAC,gBAAgB,aAAa,GAOlDC,KAAmB,MACvB;CACE;EAAE,MAAM;EAAsB,SAAS;EAAM,SAAS,CAAC;CAAE;CACzD;EAAE,MAAM;EAAe,SAAS;EAAM,MAAM;CAAS;CAGrD;EACE,MAAM;EACN,SAAS;EACT,SAAS;EACT,MAAM;EACN,QAAQ,EAAE,MAAM,GAAK;CACvB;CACA;EAAE,MAAM;EAAoB,SAAS;EAAc,SAAS;EAAM,MAAM;EAAU,QAAQ,EAAE,MAAM,GAAK;CAAE;CACzG;EACE,MAAM;EACN,SAAS;EACT,SAAS;EACT,SAAS;EACT,MAAM;CACR;CACA;EAAE,MAAM;EAAmB,SAAS;EAAkB,SAAS;EAAM,MAAM;CAAU;CACrF;EAAE,MAAM;EAAyB,SAAS;EAAwB,SAAS;EAAM,MAAM;CAAS;CAChG;EACE,MAAM;EACN,SAAS;EACT,SAAS;EACT,SAAS,CAAC;EACV,MAAM;CACR;CAIA;EACE,MAAM;EACN,SAAS;EACT,MAAM;EACN,SAAS;EACT,SAASC,GAAQ,QAAQ;EACzB,WAAWC,EAAUD,CAAM;EAC3B,QAAQ,EAAE,MAAM,GAAK;CACvB;CACA;EACE,MAAM;EACN,SAAS;EACT,MAAM;EACN,SAAS;EACT,SAASA,GAAQ,MAAM;EACvB,WAAWC,EAAUD,CAAM;EAC3B,QAAQ,EAAE,MAAM,GAAK;CACvB;AACF,GAkBIE,oBAAW,IAAI,IAAuB;AAE5C,SAAgBC,EAAa,GAAgB,GAA8C;CACzF,IAAMC,IAAWF,EAAS,IAAIG,CAAM;CACpC,IAAID,GAAU;EACZ,IAAIJ,GAAQ;GACV,IAAM,EAAE,cAAWI,EAAS;GAM5B,AAJIA,EAAS,WAAW,iBAAiBE,EAAO,aAAa,YAC3D,EAAS,WAAW,eAAeN,EAAO,OACxCI,EAAS,WAAW,eAAeE,EAAO,WAAW,YAAS,EAAS,WAAW,aAAaN,EAAO,KAC1G,EAAO,aAAa,UAAUA,EAAO,MACrC,EAAO,WAAW,UAAUA,EAAO;EACrC;EACA,OAAOI;CACT;CAEA,IAAME,IAASP,EAAgBC,CAAM,GAC/BO,IAAUC,EAAaF,GAAQG,EAAkBH,CAAM,GAAG;EAC9D,QAAQ;EACR,SAAA;CACF,CAAC;CAGD,OAFAJ,EAAS,IAAIG,GAAQE,CAAO,GAErBA;AACT;AAYA,IAAaG,KAA0B,GAAmB,MAA4B;CACpF,IAAMC,IAAOC,MAASC,EAAQ;CAE9B,EAAkB,SAAS,MAAS;EAClC,IAAMC,IAAQC,EAAO,aAAa,OAAOC;EAGzC,AAFA,EAAM,UAAUL,GAChB,EAAM,OAAO,OAAOA,GACpB,EAAM,OAAO,WAAW,CAACA;CAC3B,CAAC;AACH"}

package/dist/domains/log/types/Log.d.ts

@@ -0,0 +1,27 @@
+import { LogLevelType } from '../valueObject/LogLevel';
+import { DatetimeUTC, IntegerIdNullable } from '../../../shared/types/common';
+export interface Log {
+    id: string;
+    message: string;
+    datetime: DatetimeUTC;
+    levelName: LogLevelType;
+    context: {
+        appVersion: string;
+        appSystem: string;
+        requestOriginAppVersion: string;
+        path: string;
+        method: string;
+        contextId: string;
+        userId: IntegerIdNullable;
+        resourceName: string;
+        resourceIds: string[];
+        ip: string;
+        response: string;
+        content?: string;
+        params: string;
+        httpStatus: number;
+    };
+    _resourceName: string;
+    _system: string;
+    _type: string;
+}

package/dist/domains/log/valueObject/LogLevel.d.ts

@@ -0,0 +1,34 @@
+import { ValueObjectOption } from '../../../shared/types/ValueObject';
+export declare const LogLevel: {
+    readonly Debug: "DEBUG";
+    readonly Info: "INFO";
+    readonly Notice: "NOTICE";
+    readonly Warning: "WARNING";
+    readonly Error: "ERROR";
+    readonly Critical: "CRITICAL";
+    readonly Alert: "ALERT";
+    readonly Emergency: "EMERGENCY";
+};
+export type LogLevelType = (typeof LogLevel)[keyof typeof LogLevel];
+export declare function useLogLevel(): {
+    logLevelOptions: import('vue').Ref<{
+        value: LogLevelType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[], ValueObjectOption<LogLevelType>[] | {
+        value: LogLevelType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    }[]>;
+    getLogLevelOption: (value: LogLevelType) => {
+        value: LogLevelType;
+        title: string;
+        color?: string | undefined;
+        active?: false | undefined;
+        subtitle?: string | undefined;
+    } | undefined;
+};

package/dist/domains/log/valueObject/LogLevel.js

@@ -0,0 +1,64 @@
+import { ref as e } from "vue";
+//#region src/domains/log/valueObject/LogLevel.ts
+var t = {
+	Debug: "DEBUG",
+	Info: "INFO",
+	Notice: "NOTICE",
+	Warning: "WARNING",
+	Error: "ERROR",
+	Critical: "CRITICAL",
+	Alert: "ALERT",
+	Emergency: "EMERGENCY"
+};
+function n() {
+	let n = e([
+		{
+			value: t.Debug,
+			title: t.Debug,
+			color: "blue-grey lighten-5"
+		},
+		{
+			value: t.Info,
+			title: t.Info,
+			color: "blue-grey lighten-3"
+		},
+		{
+			value: t.Notice,
+			title: t.Notice,
+			color: "amber lighten-4"
+		},
+		{
+			value: t.Warning,
+			title: t.Warning,
+			color: "amber"
+		},
+		{
+			value: t.Error,
+			title: t.Error,
+			color: "red"
+		},
+		{
+			value: t.Critical,
+			title: t.Critical,
+			color: "red accent-4"
+		},
+		{
+			value: t.Alert,
+			title: t.Alert,
+			color: "pink"
+		},
+		{
+			value: t.Emergency,
+			title: t.Emergency,
+			color: "ping darken-4"
+		}
+	]);
+	return {
+		logLevelOptions: n,
+		getLogLevelOption: (e) => n.value.find((t) => t.value === e)
+	};
+}
+//#endregion
+export { t as LogLevel, n as useLogLevel };
+
+//# sourceMappingURL=LogLevel.js.map