@everysk/apps-sdk 0.1.0-beta.0

package/dist/hooks/portfolio/useFetchPortfolio.d.ts

@@ -0,0 +1,210 @@
+import type { Portfolio } from "../../types/portfolio.d.ts";
+import type { FetchEntityParams } from "../../types/entityQuery.d.ts";
+export type FetchPortfolioProps<TData = Portfolio, TSelected = TData> = FetchEntityParams<TData, TSelected>;
+/**
+ * useFetchPortfolio
+ *
+ * Data-fetching hook built on TanStack Query to retrieve a single portfolio by ID.
+ *
+ * It also:
+ * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+ * - triggers an error alert via `useAppAlert` whenever `query.error` is present
+ *
+ * Important notes:
+ * - Always returns a single `Portfolio` object.
+ *
+ * Parameters (FetchPortfolioProps):
+ * @param {string} id
+ *   Portfolio identifier (required).
+ *
+ * @param {string} workspace
+ *   Workspace the portfolio belongs to (required by `getPortfolio`).
+ *
+ * @param {EntityQueryOptions<Portfolio>} [queryOptions=defaultQueryOptions]
+ *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * Returns:
+ * @returns {object}
+ *   TanStack Query's `query` object extended with:
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * Tip:
+ * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:
+ *   ```ts
+ *   const fetch = useFetchPortfolio({ id: "pf-123", workspace: "ws-1" });
+ *   usePortfolioMutations({ queryKey: fetch.queryKey });
+ *   ```
+ *
+ * Example:
+ * ```ts
+ * const { data, isLoading } = useFetchPortfolio({
+ *   id: "pf-123",
+ *   workspace: "ws-1",
+ * });
+ * // data -> Portfolio
+ * ```
+ */
+export declare const useFetchPortfolio: ({ id, workspace, queryOptions }: FetchPortfolioProps) => {
+    queryKey: string[];
+    data: Portfolio;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Portfolio;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Portfolio;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchPortfolio.d.ts.map

package/dist/hooks/portfolio/useFetchPortfolio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchPortfolio.d.ts","sourceRoot":"","sources":["../../../src/hooks/portfolio/useFetchPortfolio.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,SAAS,EAAE,SAAS,GAAG,KAAK,IAAI,iBAAiB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAQ5G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,iBAAiB,GAAI,iCAAuD,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC3G,CAAC"}

package/dist/hooks/portfolio/useFetchPortfolio.js

@@ -0,0 +1,85 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { getPortfolio } from "../../api/portfolio.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/portfolio/useFetchPortfolio.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchPortfolio
+*
+* Data-fetching hook built on TanStack Query to retrieve a single portfolio by ID.
+*
+* It also:
+* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+* - triggers an error alert via `useAppAlert` whenever `query.error` is present
+*
+* Important notes:
+* - Always returns a single `Portfolio` object.
+*
+* Parameters (FetchPortfolioProps):
+* @param {string} id
+*   Portfolio identifier (required).
+*
+* @param {string} workspace
+*   Workspace the portfolio belongs to (required by `getPortfolio`).
+*
+* @param {EntityQueryOptions<Portfolio>} [queryOptions=defaultQueryOptions]
+*   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+*
+* Returns:
+* @returns {object}
+*   TanStack Query's `query` object extended with:
+*   - `queryKey`: the cache key used by React Query
+*
+* Tip:
+* - The returned `queryKey` can be reused by mutation hooks for cache invalidation:
+*   ```ts
+*   const fetch = useFetchPortfolio({ id: "pf-123", workspace: "ws-1" });
+*   usePortfolioMutations({ queryKey: fetch.queryKey });
+*   ```
+*
+* Example:
+* ```ts
+* const { data, isLoading } = useFetchPortfolio({
+*   id: "pf-123",
+*   workspace: "ws-1",
+* });
+* // data -> Portfolio
+* ```
+*/
+var useFetchPortfolio = ({ id, workspace, queryOptions = defaultQueryOptions }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const queryKey = [
+		"portfolio",
+		id,
+		workspace
+	];
+	const query = useQuery({
+		queryKey,
+		queryFn: async () => {
+			return (await getPortfolio(api, id, workspace)).portfolio;
+		},
+		...queryOptions ?? {}
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return {
+		...query,
+		queryKey
+	};
+};
+//#endregion
+export { useFetchPortfolio };
+
+//# sourceMappingURL=useFetchPortfolio.js.map

package/dist/hooks/portfolio/useFetchPortfolio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchPortfolio.js","names":[],"sources":["../../../src/hooks/portfolio/useFetchPortfolio.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { Portfolio } from \"@/types/portfolio\";\nimport { getPortfolio } from \"@/api/portfolio\";\nimport type { EntityQueryOptions, FetchEntityParams } from \"@/types/entityQuery\";\n\nexport type FetchPortfolioProps<TData = Portfolio, TSelected = TData> = FetchEntityParams<TData, TSelected>;\n\nconst defaultQueryOptions: EntityQueryOptions<Portfolio> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0\n}\n\n/**\n * useFetchPortfolio\n *\n * Data-fetching hook built on TanStack Query to retrieve a single portfolio by ID.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * Important notes:\n * - Always returns a single `Portfolio` object.\n *\n * Parameters (FetchPortfolioProps):\n * @param {string} id\n *   Portfolio identifier (required).\n *\n * @param {string} workspace\n *   Workspace the portfolio belongs to (required by `getPortfolio`).\n *\n * @param {EntityQueryOptions<Portfolio>} [queryOptions=defaultQueryOptions]\n *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * Returns:\n * @returns {object}\n *   TanStack Query's `query` object extended with:\n *   - `queryKey`: the cache key used by React Query\n *\n * Tip:\n * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:\n *   ```ts\n *   const fetch = useFetchPortfolio({ id: \"pf-123\", workspace: \"ws-1\" });\n *   usePortfolioMutations({ queryKey: fetch.queryKey });\n *   ```\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchPortfolio({\n *   id: \"pf-123\",\n *   workspace: \"ws-1\",\n * });\n * // data -> Portfolio\n * ```\n */\nexport const useFetchPortfolio = ({ id, workspace, queryOptions = defaultQueryOptions }: FetchPortfolioProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\n        \"portfolio\",\n        id,\n        workspace\n    ];\n\n    const query = useQuery<Portfolio>({\n        queryKey,\n        queryFn: async () => {\n            const response = await getPortfolio(api, id, workspace);\n            return response.portfolio;\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAWA,IAAM,sBAAqD;CACvD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,qBAAqB,EAAE,IAAI,WAAW,eAAe,0BAA+C;CAE7G,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EACb;EACA;EACA;CACJ;CAEA,MAAM,QAAQ,SAAoB;EAC9B;EACA,SAAS,YAAY;GAEjB,QAAO,MADgB,aAAa,KAAK,IAAI,SAAS,EAAA,CACtC;EACpB;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}

package/dist/hooks/portfolio/useFetchPortfolios.d.ts

@@ -0,0 +1,60 @@
+import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
+import type { FetchEntitiesParams } from "../../types/entityQuery.d.ts";
+import type { Portfolio, PortfolioListResponse } from "../../types/portfolio.d.ts";
+type PageToken = string | null;
+type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<PortfolioListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export type FetchInfinitePortfolioProps = FetchEntitiesParams<Portfolio[], InfiniteOptions<Portfolio[]>> & {
+    pageSize?: number;
+};
+/**
+ * useFetchInfinitePortfolios
+ *
+ * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+ * portfolios with cursor-based pagination.
+ *
+ * It also:
+ * - flattens all pages into a single `Portfolio[]` via `select`
+ *
+ * Important notes:
+ * - `query.data` returns a flat `Portfolio[]` (all pages merged).
+ *
+ * Parameters (FetchInfinitePortfolioProps):
+ * @param {FilterClause[]} [filters=[]]
+ *   Filters applied to every page request. Must include a `workspace` filter.
+ *
+ * @param {string[]} [order=[]]
+ *   Sorting applied to every page request.
+ *
+ * @param {string} [projection=""]
+ *   Single field to project: `"field"` returns only that field (others come back null),
+ *   `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+ *
+ * @param {number} [pageSize=10]
+ *   Number of portfolios to fetch per page.
+ *
+ * @param {InfiniteOptions<Portfolio[]>} [queryOptions]
+ *   TanStack Query options passed through to `useInfiniteQuery`
+ *   (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * Returns:
+ * @returns {object}
+ *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * Example:
+ * ```ts
+ * const { query } = useFetchInfinitePortfolios({
+ *   filters: [{ field: "workspace", value: "ws-1" }],
+ *   pageSize: 20,
+ * });
+ *
+ * // Flat list of all fetched portfolios
+ * const portfolios = query.data ?? [];
+ * ```
+ */
+export declare function useFetchPortfolios({ filters, order, projection, pageSize, queryOptions }: FetchInfinitePortfolioProps): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<Portfolio[], Error>;
+    queryKey: unknown[];
+};
+export {};
+//# sourceMappingURL=useFetchPortfolios.d.ts.map

package/dist/hooks/portfolio/useFetchPortfolios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchPortfolios.d.ts","sourceRoot":"","sources":["../../../src/hooks/portfolio/useFetchPortfolios.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAC9B,uBAAuB,CAAC,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EACjF,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CACnE,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG;IACvG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,OAAY,EAAE,KAAU,EAAE,UAAe,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;EAoCzI"}

package/dist/hooks/portfolio/useFetchPortfolios.js

@@ -0,0 +1,89 @@
+import { useAxios } from "../useAxios.js";
+import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { listPortfolios } from "../../api/portfolio.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/portfolio/useFetchPortfolios.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchInfinitePortfolios
+*
+* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+* portfolios with cursor-based pagination.
+*
+* It also:
+* - flattens all pages into a single `Portfolio[]` via `select`
+*
+* Important notes:
+* - `query.data` returns a flat `Portfolio[]` (all pages merged).
+*
+* Parameters (FetchInfinitePortfolioProps):
+* @param {FilterClause[]} [filters=[]]
+*   Filters applied to every page request. Must include a `workspace` filter.
+*
+* @param {string[]} [order=[]]
+*   Sorting applied to every page request.
+*
+* @param {string} [projection=""]
+*   Single field to project: `"field"` returns only that field (others come back null),
+*   `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+*
+* @param {number} [pageSize=10]
+*   Number of portfolios to fetch per page.
+*
+* @param {InfiniteOptions<Portfolio[]>} [queryOptions]
+*   TanStack Query options passed through to `useInfiniteQuery`
+*   (e.g., enabled, staleTime, gcTime, etc.).
+*
+* Returns:
+* @returns {object}
+*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+*   - `queryKey`: the cache key used by React Query
+*
+* Example:
+* ```ts
+* const { query } = useFetchInfinitePortfolios({
+*   filters: [{ field: "workspace", value: "ws-1" }],
+*   pageSize: 20,
+* });
+*
+* // Flat list of all fetched portfolios
+* const portfolios = query.data ?? [];
+* ```
+*/
+function useFetchPortfolios({ filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = buildQueryKey(["portfolios"], filters);
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				const queryFilter = buildQueryObject({
+					filters,
+					order,
+					projection,
+					pageSize,
+					pageToken: pageParam ?? void 0
+				});
+				return await listPortfolios(api, queryFilter);
+			},
+			select: (data) => data.pages.flatMap((p) => p.portfolios),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchPortfolios };
+
+//# sourceMappingURL=useFetchPortfolios.js.map

package/dist/hooks/portfolio/useFetchPortfolios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchPortfolios.js","names":[],"sources":["../../../src/hooks/portfolio/useFetchPortfolios.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listPortfolios } from \"@/api/portfolio\";\nimport type { FetchEntitiesParams } from \"@/types/entityQuery\";\nimport type { Portfolio, PortfolioListResponse } from \"@/types/portfolio\";\nimport { buildQueryKey, buildQueryObject } from \"@/api/entityQuery\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<\n    UseInfiniteQueryOptions<PortfolioListResponse, Error, TData, QueryKey, PageToken>,\n    \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\"\n>;\n\nexport type FetchInfinitePortfolioProps = FetchEntitiesParams<Portfolio[], InfiniteOptions<Portfolio[]>> & {\n    pageSize?: number;\n};\n\nconst defaultQueryOptions: InfiniteOptions<Portfolio[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchInfinitePortfolios\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * portfolios with cursor-based pagination.\n *\n * It also:\n * - flattens all pages into a single `Portfolio[]` via `select`\n *\n * Important notes:\n * - `query.data` returns a flat `Portfolio[]` (all pages merged).\n *\n * Parameters (FetchInfinitePortfolioProps):\n * @param {FilterClause[]} [filters=[]]\n *   Filters applied to every page request. Must include a `workspace` filter.\n *\n * @param {string[]} [order=[]]\n *   Sorting applied to every page request.\n *\n * @param {string} [projection=\"\"]\n *   Single field to project: `\"field\"` returns only that field (others come back null),\n *   `\"-field\"` returns every field except that one. One field only — lists 500. Omitted when empty.\n *\n * @param {number} [pageSize=10]\n *   Number of portfolios to fetch per page.\n *\n * @param {InfiniteOptions<Portfolio[]>} [queryOptions]\n *   TanStack Query options passed through to `useInfiniteQuery`\n *   (e.g., enabled, staleTime, gcTime, etc.).\n *\n * Returns:\n * @returns {object}\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { query } = useFetchInfinitePortfolios({\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n *   pageSize: 20,\n * });\n *\n * // Flat list of all fetched portfolios\n * const portfolios = query.data ?? [];\n * ```\n */\nexport function useFetchPortfolios({ filters = [], order = [], projection = \"\", pageSize = 10, queryOptions }: FetchInfinitePortfolioProps) {\n    const { api } = useAxios();\n\n    const queryKey = buildQueryKey([\"portfolios\"], filters);\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<Portfolio[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<PortfolioListResponse, Error, Portfolio[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            const queryFilter = buildQueryObject({\n                filters,\n                order,\n                projection,\n                pageSize,\n                pageToken: pageParam ?? undefined,\n            });\n\n            return await listPortfolios(api, queryFilter);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.portfolios),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}"],"mappings":";;;;;;AAoBA,IAAM,sBAAoD;CACtD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,mBAAmB,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,GAAG,aAAa,IAAI,WAAW,IAAI,gBAA6C;CACxI,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW,cAAc,CAAC,YAAY,GAAG,OAAO;CAEtD,MAAM,qBAAqB,eAA6C;EACpE,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAwBlB,OAAO;EACH,OAvBU,iBAAiF;GAC3F;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,MAAM,cAAc,iBAAiB;KACjC;KACA;KACA;KACA;KACA,WAAW,aAAa,KAAA;IAC5B,CAAC;IAED,OAAO,MAAM,eAAe,KAAK,WAAW;GAChD;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU;GAExD,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}

package/dist/hooks/portfolio/usePortfolioMutations.d.ts

@@ -0,0 +1,171 @@
+import type { Portfolio } from "../../types/portfolio.d.ts";
+type CreatePortfolioProps = {
+    data: Partial<Portfolio>;
+};
+type UpdatePortfolioProps = {
+    id: string;
+    data: Partial<Portfolio>;
+};
+type DeletePortfolioProps = {
+    id: string;
+    workspace: string;
+};
+type UsePortfolioMutationsProps = {
+    queryKey?: unknown[];
+};
+/**
+ * usePortfolioMutations
+ *
+ * Mutation hook built on TanStack Query to perform Portfolio write operations:
+ * - create a portfolio (POST)
+ * - update a portfolio (PUT)
+ * - delete a portfolio (DELETE)
+ *
+ * It also:
+ * - optionally invalidates a target query cache key after successful mutations
+ * - displays success/error alerts via `useAppAlert`
+ *
+ * Important notes:
+ * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchPortfolio`.
+ * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run
+ *   mutations and show alerts, but it will NOT invalidate any cached queries.
+ * - `remove` requires a `workspace` parameter because the underlying API helper `deletePortfolio(api, id, workspace)`
+ *   expects it as a query param.
+ *
+ * Parameters (UsePortfolioMutationsProps):
+ * @param {unknown[]} [queryKey]
+ *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`
+ *  (e.g., portfolio list/detail) so UI data is refreshed automatically after a write.
+ *
+ *  Tip:
+ *  - If you're using `useFetchPortfolio`, you can pass its returned `queryKey` directly:
+ *    `const fetch = useFetchPortfolio(...);`
+ *    `usePortfolioMutations({ queryKey: fetch.queryKey });`
+ *
+ * Mutations:
+ * - `create`:
+ *   - mutationFn: `createPortfolio(api, data)`
+ *   - variables: `{ data: Partial<Portfolio> }`
+ *   - success message: "Portfolio created successfully."
+ *   - error message: "We couldn't create the portfolio. Please review your inputs and try again." (fallback)
+ *
+ * - `update`:
+ *   - mutationFn: `updatePortfolio(api, id, data)`
+ *   - variables: `{ id: string; data: Partial<Portfolio> }`
+ *   - success message: "Portfolio updated successfully."
+ *   - error message: "We couldn't update the portfolio. Please try again." (fallback)
+ *
+ * - `remove`:
+ *   - mutationFn: `deletePortfolio(api, id, workspace)`
+ *   - variables: `{ id: string; workspace: string }`
+ *   - success message: "Portfolio deleted successfully."
+ *   - error message: "We couldn't delete the portfolio. Please try again." (fallback)
+ *
+ * Return value:
+ * @returns {object}
+ *  Returns an object with the three TanStack Query mutation results:
+ *  - `create`: UseMutationResult<Portfolio, Error, CreatePortfolioProps, unknown>
+ *  - `update`: UseMutationResult<Portfolio, Error, UpdatePortfolioProps, unknown>
+ *  - `remove`: UseMutationResult<Portfolio, Error, DeletePortfolioProps, unknown>
+ *
+ * Each mutation includes standard TanStack Query helpers:
+ * - `mutate(variables, options?)`
+ * - `mutateAsync(variables, options?)`
+ * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.
+ *
+ * Examples:
+ *
+ * 1) Invalidate a portfolio list query after mutations:
+ * ```ts
+ * const { create, update, remove } = usePortfolioMutations({ queryKey: ["portfolio"] });
+ *
+  * // Create (minimal example - other Security fields omitted for brevity)
+ * create.mutate({
+ *   data: {
+ *     name: "My Portfolio",
+ *     description: "Test portfolio",
+ *     base_currency: "USD",
+ *     date: "2026-01-08",
+ *     workspace: "ws-1",
+ *     securities: [
+ *       {
+ *         id: "sec-1",
+ *         ticker: "AAPL",
+ *         symbol: "AAPL",
+ *         name: "Apple Inc.",
+ *         currency: "USD",
+ *         quantity: 10,
+ *         market_price: 200,
+ *         market_value: 2000,
+ *         market_value_in_base: 2000,
+ *         fx_rate: 1,
+ *         instrument_type: "Equity",
+ *         instrument_class: "Equity",
+ *         asset_class: "Equity",
+ *         exchange: "NASDAQ",
+ *         status: "active",
+ *         // Other fields are nullable in the Security type and can be omitted here for documentation purposes.
+ *       } as Security,
+ *     ],
+ *   }
+ * });
+ *
+ * // Update (partial)
+ * update.mutate({
+ *   id: "pf-123",
+ *   data: {
+ *     name: "Renamed Portfolio",
+ *     tags: ["tag-1", "tag-2"],
+ *     check_securities: true,
+ *   }
+ * });
+ *
+ * // Delete
+ * remove.mutate({ id: "pf-123", workspace: "ws-1" });
+ * ```
+ *
+ * 2) Using async/await with `mutateAsync`:
+ * ```ts
+ * const { create } = usePortfolioMutations({ queryKey: ["portfolio"] });
+ *
+ * await create.mutateAsync({
+ *   data: {
+ *     name: "My Portfolio",
+ *     base_currency: "USD",
+ *     date: "2026-01-08",
+ *     workspace: "ws-1",
+ *     securities: [],
+ *   }
+ * });
+ * ```
+ *
+ * 3) Without cache invalidation (no queryKey):
+ * ```ts
+ * const { update } = usePortfolioMutations({});
+ *
+ * update.mutate({
+ *   id: "pf-123",
+ *   data: { description: "Updated description" }
+ * });
+ * // Mutation still runs and alerts are shown, but cached queries are not invalidated.
+ * ```
+ *
+ * 4) Using `useFetchPortfolio` queryKey for automatic invalidation:
+ * ```ts
+ * const fetch = useFetchPortfolio({
+ *   id: null,
+ *   filters: [{ field: "workspace", value: "ws-1" }],
+ * });
+ *
+ * const { remove } = usePortfolioMutations({ queryKey: fetch.queryKey });
+ *
+ * await remove.mutateAsync({ id: "pf-123", workspace: "ws-1" });
+ * ```
+ */
+export declare const usePortfolioMutations: ({ queryKey }: UsePortfolioMutationsProps) => {
+    create: import("@tanstack/react-query").UseMutationResult<Portfolio, unknown, CreatePortfolioProps, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<Portfolio, unknown, UpdatePortfolioProps, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<Portfolio, unknown, DeletePortfolioProps, unknown>;
+};
+export {};
+//# sourceMappingURL=usePortfolioMutations.d.ts.map

package/dist/hooks/portfolio/usePortfolioMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePortfolioMutations.d.ts","sourceRoot":"","sources":["../../../src/hooks/portfolio/usePortfolioMutations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,KAAK,oBAAoB,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAC9B,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoJG;AAEH,eAAO,MAAM,qBAAqB,GAAI,cAAc,0BAA0B;;;;CAuE7E,CAAC"}