@ynput/ayon-frontend-shared 0.3.8 → 0.3.10

package/dist/shared/src/api/queries/versions/getVersionsProducts.es.js

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as C } from "../../generated/graphql.es.js";
+import { api as T } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -23,6 +23,7 @@ import "../../generated/operations.es.js";
 import "../../generated/products.es.js";
 import "../../generated/projectDashboard.es.js";
 import "../../generated/projects.es.js";
+import "../../generated/projectFolders.es.js";
 import "../../generated/reviewables.es.js";
 import "../../generated/services.es.js";
 import "../../generated/system.es.js";
@@ -36,55 +37,84 @@ import "../../generated/workfiles.es.js";
 import "../../generated/ynputCloud.es.js";
 import "../../generated/grouping.es.js";
 import "../../generated/views.es.js";
-import { provideTagsForProductsResult as F, transformProductsResponse as Q, provideTagsForVersionsResult as N, transformVersionsResponse as G, parseGQLErrorMessage as V, provideTagsForProductsInfinite as q, provideTagsForVersionsInfinite as w } from "./getVersionsProductsUtils.es.js";
-const R = C.enhanceEndpoints({
+import { provideTagsForProductsResult as k, transformProductsResponse as O, provideTagsForVersionsResult as x, transformVersionsResponse as w, parseGQLErrorMessage as b, provideTagsForProductsInfinite as Q, provideTagsForVersionsInfinite as q } from "./getVersionsProductsUtils.es.js";
+import "lodash";
+import "react-toastify";
+import "uuid";
+import I from "../../../util/pubsub.es.js";
+function G(y, e, i, a) {
+  for (let t = 0; t < y.length; t++) {
+    const s = e[i], l = y[t][i];
+    if (a ? s > l : s < l)
+      return t;
+  }
+  return y.length;
+}
+function N(y, e, i, a, t, s) {
+  for (const l of y) {
+    const c = l[a], n = c.findIndex((o) => o.id === e);
+    if (n !== -1) {
+      i ? c[n] = i : c.splice(n, 1);
+      return;
+    }
+  }
+  if (i && y.length > 0) {
+    const l = y[0][a], c = G(l, i, t, s);
+    l.splice(c, 0, i);
+  }
+}
+function A(y, e, i) {
+  const a = y.findIndex((t) => t.id === e);
+  return a !== -1 ? i ? (y[a] = i, { index: a, action: "updated" }) : (y.splice(a, 1), { index: a, action: "deleted" }) : i ? (y.push(i), { index: y.length - 1, action: "added" }) : { index: -1, action: "none" };
+}
+const F = T.enhanceEndpoints({
   endpoints: {
     // used by both stacked and non-stacked views
     GetVersions: {
-      transformResponse: G,
-      providesTags: N
+      transformResponse: w,
+      providesTags: x
     },
     // used by getVersionsByProducts only
     GetVersionsByProductId: {
-      transformResponse: G,
-      providesTags: N
+      transformResponse: w,
+      providesTags: x
     },
     // used by getProductsInfinite only
     GetProducts: {
-      transformResponse: Q,
-      providesTags: F
+      transformResponse: O,
+      providesTags: k
     }
   }
-}), I = 250, T = 1e3, O = 10, B = R.injectEndpoints({
-  endpoints: (E) => ({
+}), V = 250, E = 1e3, j = 10, B = F.injectEndpoints({
+  endpoints: (y) => ({
     // enhance GetVersions with an infinite query
-    getVersionsInfinite: E.infiniteQuery(
+    getVersionsInfinite: y.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (p, g, c, s) => {
-            const e = p.pageInfo;
-            if (!(!(c.desc ? e?.hasPreviousPage : e?.hasNextPage) || !e?.endCursor))
+          getNextPageParam: (e, i, a, t) => {
+            const s = e.pageInfo;
+            if (!(!(a.desc ? s?.hasPreviousPage : s?.hasNextPage) || !s?.endCursor))
               return {
-                cursor: e?.endCursor,
-                desc: c.desc
+                cursor: s?.endCursor,
+                desc: a.desc
               };
           }
         },
-        queryFn: async ({ queryArg: p, pageParam: g }, c) => {
+        queryFn: async ({ queryArg: e, pageParam: i }, a) => {
           try {
-            const { sortBy: s, desc: e, folderIds: d, ...u } = p, { cursor: l } = g, o = {
-              ...u
+            const { sortBy: t, desc: s, folderIds: l, ...c } = e, { cursor: n } = i, o = {
+              ...c
             };
-            s ? (o.sortBy = s, e ? (o.before = l || void 0, o.last = I) : (o.after = l || void 0, o.first = I)) : (o.after = l || void 0, o.first = I), d && d.length && (o.folderIds = d);
-            const r = await c.dispatch(
-              R.endpoints.GetVersions.initiate(o, {
+            t ? (o.sortBy = t, s ? (o.before = n || void 0, o.last = V) : (o.after = n || void 0, o.first = V)) : (o.after = n || void 0, o.first = V), l && l.length && (o.folderIds = l);
+            const r = await a.dispatch(
+              F.endpoints.GetVersions.initiate(o, {
                 forceRefetch: !0
               })
             );
             if (r.error) throw r.error;
-            const a = {
+            const u = {
               versions: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -94,108 +124,180 @@ const R = C.enhanceEndpoints({
               }
             };
             return {
-              data: r.data || a
+              data: r.data || u
             };
-          } catch (s) {
-            return console.error("Error in getVersionsInfiniteQuery queryFn:", s), {
+          } catch (t) {
+            return console.error("Error in getVersionsInfiniteQuery queryFn:", t), {
               error: {
                 status: "FETCH_ERROR",
-                error: V(s.message)
+                error: b(t.message)
               }
             };
           }
         },
-        providesTags: w
+        providesTags: q,
+        // Subscribes to version entity changes and updates cache accordingly
+        // Handles: create, update, delete operations
+        onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
+          const s = I.subscribe("entity.version", async (l, c) => {
+            try {
+              const n = c.summary?.entityId;
+              if (!n) return;
+              const o = await t(
+                F.endpoints.GetVersions.initiate(
+                  {
+                    projectName: e.projectName,
+                    versionFilter: e.versionFilter,
+                    productFilter: e.productFilter,
+                    taskFilter: e.taskFilter,
+                    folderIds: e.folderIds?.length ? e.folderIds : void 0,
+                    versionIds: [n],
+                    first: 1
+                  },
+                  {
+                    forceRefetch: !0
+                  }
+                )
+              );
+              if (o.error) return;
+              i((r) => {
+                const u = o.data?.versions?.[0];
+                N(
+                  r.pages,
+                  n,
+                  u,
+                  "versions",
+                  e.sortBy || "createdAt",
+                  e.desc || !1
+                );
+              });
+            } catch {
+            }
+          });
+          await a, I.unsubscribe(s);
+        }
       }
     ),
     // custom query function that fetches versions by multiple parent ids -not infinite and gets 1000 versions max
-    getVersionsByProducts: E.query({
-      queryFn: async (p, { dispatch: g, forced: c }) => {
-        const { productIds: s = [], desc: e, ...d } = p, u = async (f, n) => {
-          const i = {
-            ...d,
-            productIds: [f]
+    getVersionsByProducts: y.query({
+      queryFn: async (e, { dispatch: i, forced: a }) => {
+        const { productIds: t = [], desc: s, ...l } = e, c = async (d, p) => {
+          const f = {
+            ...l,
+            productIds: [d]
           };
-          return e ? (n && (i.before = n), i.last = T) : (n && (i.after = n), i.first = T), g(
-            R.endpoints.GetVersionsByProductId.initiate(i, {
-              forceRefetch: c
+          return s ? (p && (f.before = p), f.last = E) : (p && (f.after = p), f.first = E), i(
+            F.endpoints.GetVersionsByProductId.initiate(f, {
+              forceRefetch: a
             })
           );
-        }, l = s.map((f) => u(f)), o = await Promise.allSettled(l), r = [], a = [];
-        for (let f = 0; f < o.length; f++) {
-          const n = o[f], i = s[f];
-          if (n.status === "rejected") {
-            console.error(`Error fetching versions for product ${i}:`, n.reason), a.push({ productId: i, error: V(n.reason) });
+        }, n = t.map((d) => c(d)), o = await Promise.allSettled(n), r = [], u = [];
+        for (let d = 0; d < o.length; d++) {
+          const p = o[d], f = t[d];
+          if (p.status === "rejected") {
+            console.error(`Error fetching versions for product ${f}:`, p.reason), u.push({ productId: f, error: b(p.reason) });
             continue;
           }
-          const m = n.value;
-          if (m.error) {
-            console.error(`Error fetching versions for product ${i}:`, m.error), a.push({
-              productId: i,
+          const v = p.value;
+          if (v.error) {
+            console.error(`Error fetching versions for product ${f}:`, v.error), u.push({
+              productId: f,
               // @ts-expect-error - message
-              error: V(m.error?.message || "Unknown error")
+              error: b(v.error?.message || "Unknown error")
             });
             continue;
           }
-          if (!m.data) continue;
-          r.push(...m.data.versions);
-          let t = m.data.pageInfo, P = 1;
-          for (; t && P < O; ) {
-            const v = e ? t.hasPreviousPage : t.hasNextPage, y = t.endCursor;
-            if (!v || !y) break;
-            const h = await u(i, y);
-            if (h.error) {
+          if (!v.data) continue;
+          r.push(...v.data.versions);
+          let h = v.data.pageInfo, m = 1;
+          for (; h && m < j; ) {
+            const R = s ? h.hasPreviousPage : h.hasNextPage, g = h.endCursor;
+            if (!R || !g) break;
+            const P = await c(f, g);
+            if (P.error) {
               console.error(
-                `Error fetching versions page ${P + 1} for product ${i}:`,
-                h.error
-              ), a.push({ productId: i, error: h.error });
+                `Error fetching versions page ${m + 1} for product ${f}:`,
+                P.error
+              ), u.push({ productId: f, error: P.error });
               break;
             }
-            if (!h.data) break;
-            r.push(...h.data.versions), t = h.data.pageInfo, P++;
+            if (!P.data) break;
+            r.push(...P.data.versions), h = P.data.pageInfo, m++;
           }
         }
-        return a.length > 0 && console.warn(
-          `Partial success: ${a.length} of ${s.length} products failed to fetch versions`,
-          a
+        return u.length > 0 && console.warn(
+          `Partial success: ${u.length} of ${t.length} products failed to fetch versions`,
+          u
         ), {
           data: {
             versions: r,
             pageInfo: void 0,
             // pageInfo is undefined as we've flattened multiple queries
-            errors: a.length > 0 ? a : void 0
+            errors: u.length > 0 ? u : void 0
           }
         };
       },
-      providesTags: N
+      // Subscribes to version entity changes for expanded products
+      // Only updates versions that belong to currently expanded products
+      onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
+        const s = I.subscribe("entity.version", async (l, c) => {
+          try {
+            const n = c.summary?.entityId, o = c.summary?.parentId;
+            if (!n || !o || !e.productIds.includes(o)) return;
+            const r = await t(
+              F.endpoints.GetVersions.initiate(
+                {
+                  projectName: e.projectName,
+                  productIds: [o],
+                  versionIds: [n],
+                  versionFilter: e.versionFilter,
+                  taskFilter: e.taskFilter,
+                  first: 1,
+                  ...e.featuredOnly && { featuredOnly: e.featuredOnly },
+                  ...e.hasReviewables !== void 0 && { hasReviewables: e.hasReviewables }
+                },
+                { forceRefetch: !0 }
+              )
+            );
+            if (r.error) return;
+            i((u) => {
+              const d = r.data?.versions?.[0];
+              A(u.versions, n, d);
+            });
+          } catch {
+          }
+        });
+        await a, I.unsubscribe(s);
+      },
+      providesTags: x
     }),
     // enhance GetProducts with an infinite query
-    getProductsInfinite: E.infiniteQuery(
+    getProductsInfinite: y.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (p, g, c, s) => {
-            const e = p.pageInfo;
-            if (!(!(c.desc ? e?.hasPreviousPage : e?.hasNextPage) || !e?.endCursor))
+          getNextPageParam: (e, i, a, t) => {
+            const s = e.pageInfo;
+            if (!(!(a.desc ? s?.hasPreviousPage : s?.hasNextPage) || !s?.endCursor))
               return {
-                cursor: e?.endCursor,
-                desc: c.desc
+                cursor: s?.endCursor,
+                desc: a.desc
               };
           }
         },
-        queryFn: async ({ queryArg: p, pageParam: g }, c) => {
-          let s;
+        queryFn: async ({ queryArg: e, pageParam: i }, a) => {
+          let t;
           try {
-            const { sortBy: e, desc: d, folderIds: u, ...l } = p, { cursor: o } = g, r = {
-              ...l
+            const { sortBy: s, desc: l, folderIds: c, ...n } = e, { cursor: o } = i, r = {
+              ...n
             };
-            if (e ? (r.sortBy = e, d ? (r.before = o || void 0, r.last = I) : (r.after = o || void 0, r.first = I)) : (r.after = o || void 0, r.first = I), u && u.length && (r.folderIds = u), s = await c.dispatch(
-              R.endpoints.GetProducts.initiate(r, {
+            if (s ? (r.sortBy = s, l ? (r.before = o || void 0, r.last = V) : (r.after = o || void 0, r.first = V)) : (r.after = o || void 0, r.first = V), c && c.length && (r.folderIds = c), t = await a.dispatch(
+              F.endpoints.GetProducts.initiate(r, {
                 forceRefetch: !0
               })
-            ), s.error) throw s.error;
-            const a = {
+            ), t.error) throw t.error;
+            const u = {
               products: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -205,107 +307,217 @@ const R = C.enhanceEndpoints({
               }
             };
             return {
-              data: s.data || a
+              data: t.data || u
             };
-          } catch (e) {
-            return console.error("Error in getProductsInfiniteQuery queryFn:", e), {
+          } catch (s) {
+            return console.error("Error in getProductsInfiniteQuery queryFn:", s), {
               error: {
                 status: "FETCH_ERROR",
-                error: V(e.message)
+                error: b(s.message)
               }
             };
           }
         },
-        providesTags: q
+        providesTags: Q,
+        // Subscribes to product entity changes and updates cache accordingly
+        // Handles: create, update, delete operations
+        // Often triggered together with version changes (new product + version)
+        onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
+          const s = async (n) => {
+            const o = {
+              projectName: e.projectName,
+              productIds: [n],
+              productFilter: e.productFilter,
+              versionFilter: e.versionFilter,
+              taskFilter: e.taskFilter,
+              folderIds: e.folderIds?.length ? e.folderIds : void 0,
+              first: 1
+            }, r = await t(
+              F.endpoints.GetProducts.initiate(o, {
+                forceRefetch: !0
+              })
+            );
+            r.error || i((u) => {
+              const d = r.data?.products?.[0];
+              N(
+                u.pages,
+                n,
+                d,
+                "products",
+                e.sortBy || "createdAt",
+                e.desc || !1
+              );
+            });
+          }, l = I.subscribe(
+            "entity.product",
+            async (n, o) => {
+              try {
+                const r = o.summary?.entityId;
+                if (!r) return;
+                await s(r);
+              } catch {
+              }
+            }
+          ), c = I.subscribe(
+            "entity.version",
+            async (n, o) => {
+              try {
+                const r = o.summary?.parentId;
+                if (!r) return;
+                let u = !1;
+                if (i((d) => {
+                  u = d.pages.some(
+                    (p) => p.products.some((f) => f.id === r)
+                  );
+                }), !u) return;
+                await s(r);
+              } catch {
+              }
+            }
+          );
+          await a, I.unsubscribe(l), I.unsubscribe(c);
+        }
       }
     ),
     // Grouped versions query - fetches versions for multiple group filters
-    getGroupedVersionsList: E.query({
+    getGroupedVersionsList: y.query({
       queryFn: async ({
-        projectName: p,
-        groups: g,
-        groupFilterKey: c = "versionFilter",
-        versionFilter: s,
+        projectName: e,
+        groups: i,
+        groupFilterKey: a = "versionFilter",
+        versionFilter: t,
         // most of the time overridden by group filters
-        productFilter: e,
-        taskFilter: d,
-        folderIds: u,
-        desc: l,
+        productFilter: s,
+        taskFilter: l,
+        folderIds: c,
+        desc: n,
         sortBy: o,
         featuredOnly: r,
-        hasReviewables: a
-      }, f) => {
+        hasReviewables: u
+      }, d) => {
         try {
-          const n = [];
-          for (const t of g) {
-            const P = t.count || 500, v = {
-              projectName: p,
+          const p = [];
+          for (const h of i) {
+            const m = h.count || 500, R = {
+              projectName: e,
               // base filters
-              productFilter: e,
-              taskFilter: d,
-              versionFilter: s,
+              productFilter: s,
+              taskFilter: l,
+              versionFilter: t,
               // specific group filter
-              [c]: t.filter,
-              folderIds: u?.length ? u : void 0,
+              [a]: h.filter,
+              folderIds: c?.length ? c : void 0,
               sortBy: o,
               featuredOnly: r,
-              hasReviewables: a,
+              hasReviewables: u,
               // @ts-expect-error - group param used later on
-              group: t.value
+              group: h.value
             };
-            l ? v.last = P : v.first = P;
-            const y = f.dispatch(
-              R.endpoints.GetVersions.initiate(v, {
+            n ? R.last = m : R.first = m;
+            const g = d.dispatch(
+              F.endpoints.GetVersions.initiate(R, {
                 forceRefetch: !0
               })
             );
-            n.push(y);
+            p.push(g);
           }
-          const i = await Promise.all(n), m = [];
-          for (const t of i) {
-            if (t.error) throw t.error;
-            const P = t.originalArgs?.group, v = t.data?.pageInfo?.hasNextPage || t.data?.pageInfo?.hasPreviousPage || !1, y = t.data?.versions.map((h, _, x) => ({
-              ...h,
+          const f = await Promise.all(p), v = [];
+          for (const h of f) {
+            if (h.error) throw h.error;
+            const m = h.originalArgs?.group, R = h.data?.pageInfo?.hasNextPage || h.data?.pageInfo?.hasPreviousPage || !1, g = h.data?.versions.map((P, C, _) => ({
+              ...P,
               groups: [
                 {
-                  value: P,
-                  hasNextPage: _ === x.length - 1 && v ? P : void 0
+                  value: m,
+                  hasNextPage: C === _.length - 1 && R ? m : void 0
                 }
               ]
             })) || [];
-            m.push(...y);
+            v.push(...g);
           }
           return {
             data: {
-              versions: m
+              versions: v
             }
           };
-        } catch (n) {
-          return console.error("Error in getGroupedVersionsList queryFn:", n), {
+        } catch (p) {
+          return console.error("Error in getGroupedVersionsList queryFn:", p), {
             error: {
               status: "FETCH_ERROR",
-              error: V(n.message)
+              error: b(p.message)
             }
           };
         }
       },
-      providesTags: N
+      providesTags: x,
+      // Subscribes to version entity changes and updates cache accordingly
+      // Handles: create, update, delete operations for grouped versions view
+      onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
+        const s = I.subscribe("entity.version", async (l, c) => {
+          try {
+            const n = c.summary?.entityId;
+            if (!n) return;
+            const o = {
+              projectName: e.projectName,
+              versionFilter: e.versionFilter,
+              productFilter: e.productFilter,
+              taskFilter: e.taskFilter,
+              folderIds: e.folderIds?.length ? e.folderIds : void 0,
+              versionIds: [n],
+              first: 1,
+              ...e.featuredOnly && { featuredOnly: e.featuredOnly },
+              ...e.hasReviewables !== void 0 && { hasReviewables: e.hasReviewables }
+            }, r = [];
+            let u = null;
+            for (const d of e.groups) {
+              const f = (await t(
+                F.endpoints.GetVersions.initiate(
+                  {
+                    ...o,
+                    [e.groupFilterKey]: d.filter,
+                    // group-specific filter
+                    versionIds: [n]
+                  },
+                  { forceRefetch: !0 }
+                  // Force fresh data to detect group membership changes
+                )
+              )).data?.versions?.[0];
+              f && (r.push({ value: d.value, hasNextPage: void 0 }), u = f);
+            }
+            i((d) => {
+              const p = d.versions.findIndex((v) => v.id === n), f = p !== -1;
+              if (r.length === 0)
+                f && d.versions.splice(p, 1);
+              else if (u)
+                if (f) {
+                  const v = d.versions[p].groups || [], h = v.map((g) => g.value).sort(), m = r.map((g) => g.value).sort();
+                  h.length !== m.length || h.some((g, P) => g !== m[P]) ? d.versions[p] = { ...u, groups: r } : d.versions[p] = { ...u, groups: v };
+                } else {
+                  const v = { ...u, groups: r }, h = e.sortBy || "createdAt", m = G(d.versions, v, h, e.desc || !1);
+                  d.versions.splice(m, 0, v);
+                }
+            });
+          } catch {
+          }
+        });
+        await a, I.unsubscribe(s);
+      }
     })
   })
-}), { useGetVersionsQuery: Re } = R, {
-  useGetVersionsInfiniteInfiniteQuery: Ve,
-  useGetVersionsByProductsQuery: Ee,
-  useGetProductsInfiniteInfiniteQuery: Ne,
-  useGetGroupedVersionsListQuery: Ge
+}), { useGetVersionsQuery: Ce } = F, {
+  useGetVersionsInfiniteInfiniteQuery: _e,
+  useGetVersionsByProductsQuery: Te,
+  useGetProductsInfiniteInfiniteQuery: ke,
+  useGetGroupedVersionsListQuery: Oe
 } = B;
 export {
-  I as VP_INFINITE_QUERY_COUNT,
-  R as enhancedVersionsPageApi,
+  V as VP_INFINITE_QUERY_COUNT,
+  F as enhancedVersionsPageApi,
   B as injectedVersionsPageApi,
-  Ge as useGetGroupedVersionsListQuery,
-  Ne as useGetProductsInfiniteQuery,
-  Ee as useGetVersionsByProductsQuery,
-  Ve as useGetVersionsInfiniteQuery,
-  Re as useGetVersionsQuery
+  Oe as useGetGroupedVersionsListQuery,
+  ke as useGetProductsInfiniteQuery,
+  Te as useGetVersionsByProductsQuery,
+  _e as useGetVersionsInfiniteQuery,
+  Ce as useGetVersionsQuery
 };
 //# sourceMappingURL=getVersionsProducts.es.js.map