@norbix.ai/react-redux 1.11.0 → 1.12.0

package/README.md

@@ -515,11 +515,11 @@ may call — list, aliases / versions, a call by hand, a sample envelope for a
 local run, and the last runs of a trigger or task. The five function hooks
 need `@norbix.ai/ts` 4.19.0.
 
-| Area            | Hooks                                                                                                                                                                                                                                                                                  | Cache tag                                                                                             |
-| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| Module switch   | `useEnableCodeModuleMutation`, `useDisableCodeModuleMutation`                                                                                                                                                                                                                          | invalidates `Account`, `Projects`, `Code`                                                             |
+| Area            | Hooks                                                                                                                                                                                                                                        | Cache tag                                                                                             |
+| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| Module switch   | `useEnableCodeModuleMutation`, `useDisableCodeModuleMutation`                                                                                                                                                                                | invalidates `Account`, `Projects`, `Code`                                                             |
 | Integrations    | `useGetCodeIntegrationsQuery`, `useGetCodeIntegrationQuery`, `useSaveCodeIntegrationMutation`, `useDeleteCodeIntegrationMutation`, `useEnableCodeIntegrationMutation`, `useDisableCodeIntegrationMutation`, `useTestCodeIntegrationMutation` | provides / invalidates `CodeIntegrations/LIST` and `CodeIntegrations/<id>`; `test` touches nothing    |
-| Cloud functions | `useGetCodeFunctionsQuery`, `useGetCodeFunctionQualifiersQuery`, `useGetCodeFunctionEventSampleQuery`, `useGetCodeFunctionRunsQuery`, `useInvokeCodeFunctionMutation`                                                                                                                  | provides `CodeFunctions/LIST`, `CodeFunctions/SAMPLE`, `CodeFunctions/RUNS`; `invoke` touches nothing |
+| Cloud functions | `useGetCodeFunctionsQuery`, `useGetCodeFunctionQualifiersQuery`, `useGetCodeFunctionEventSampleQuery`, `useGetCodeFunctionRunsQuery`, `useInvokeCodeFunctionMutation`                                                                        | provides `CodeFunctions/LIST`, `CodeFunctions/SAMPLE`, `CodeFunctions/RUNS`; `invoke` touches nothing |
 
 ```tsx
 const integrationId = 'int_6rBACnEaxQ0x1jTiHtAuWV';
@@ -544,6 +544,29 @@ The function side — parsing the envelope your function receives — is
 `parseFunctionEvent` in the core SDK (`docs/code-functions.md`), not a hook.
 Full method reference: the core SDK's `docs/hub/code.md`.
 
+## Code — marketplace
+
+The marketplace methods of `hub.code` have hooks too, 1:1 with
+`norbix.hub.code` (gateway contract `Code.Marketplace.md` §14): the catalog of
+listings, the installed connections (`int_…`) with their secrets, token
+mappings and validation test, the vendor function catalog, and the functions
+added on a connection (`func_…`). Every tag is of type `CodeMarketplace`.
+
+| Area        | Hooks                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Cache tag (`CodeMarketplace/…`)                                                              |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| Catalog     | `useGetMarketplaceListingsQuery`, `useGetMarketplaceListingQuery`, `useGetMarketplaceListingFunctionTokensQuery`                                                                                                                                                                                                                                                                                                                                                                                 | provides `LISTINGS`                                                                          |
+| Connections | `useGetMarketplaceIntegrationsQuery`, `useGetMarketplaceIntegrationQuery`, `useSaveMarketplaceIntegrationMutation`, `useDeleteMarketplaceIntegrationMutation`, `useEnableMarketplaceIntegrationMutation`, `useDisableMarketplaceIntegrationMutation`, `useReplaceMarketplaceIntegrationSecretsMutation`, `useRevealMarketplaceIntegrationSecretsMutation`, `useSetMarketplaceIntegrationTokenMappingsMutation`, `useTestMarketplaceIntegrationMutation`, `useGetMarketplaceFunctionCatalogQuery` | `INTEGRATIONS`, `<integrationViewId>`, `CATALOG:<integrationViewId>`; reveal touches nothing |
+| Functions   | `useGetMarketplaceFunctionsQuery`, `useGetMarketplaceFunctionQuery`, `useSaveMarketplaceFunctionMutation`, `useDeleteMarketplaceFunctionMutation`, `useEnableMarketplaceFunctionMutation`, `useDisableMarketplaceFunctionMutation`, `useGetMarketplaceFunctionTokensQuery`, `useInvokeMarketplaceFunctionMutation`, `useGetMarketplaceFunctionRunsQuery`                                                                                                                                         | `FUNCTIONS:<integrationViewId>`, `<functionViewId>`, `RUNS`; invoke touches nothing          |
+
+Revealing secrets is a mutation on purpose: a query would keep the clear values
+in the store's cache.
+
+```tsx
+const { data: listings } = useGetMarketplaceListingsQuery({ search: 'slack' });
+const [invoke] = useInvokeMarketplaceFunctionMutation();
+await invoke({ functionViewId: 'func_4hT2b9QkLm3XcT1yRfGh7a', payload: { text: 'Order shipped' } });
+```
+
 ## Working with terms
 
 A **taxonomy** is a named tree of **terms** (labels). A term can have one parent (a clean hierarchy) or several parents (the same item under many categories). There is one read hook per scenario — pick the one that matches what you want:

package/dist/index.cjs

@@ -1523,6 +1523,122 @@ var hubLogs = (b) => ({
   })
 });
 
+// src/hooks/hub/marketplace.ts
+var hubCodeMarketplace = (b) => {
+  const callHC = (norbix) => norbix.hub.code;
+  const T = "CodeMarketplace";
+  const integrationId = (arg) => arg?.integrationViewId ?? arg?.IntegrationViewId ?? "CURRENT";
+  const functionId = (arg) => arg?.functionViewId ?? arg?.FunctionViewId ?? "CURRENT";
+  const listings = [{ type: T, id: "LISTINGS" }];
+  const integration = (arg) => [
+    { type: T, id: "INTEGRATIONS" },
+    { type: T, id: integrationId(arg) }
+  ];
+  const functions = (arg) => [
+    { type: T, id: `FUNCTIONS:${integrationId(arg)}` },
+    { type: T, id: functionId(arg) }
+  ];
+  return {
+    // ---- Catalog ----
+    getMarketplaceListings: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceListings(args),
+      providesTags: listings
+    }),
+    getMarketplaceListing: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceListing(args),
+      providesTags: listings
+    }),
+    getMarketplaceListingFunctionTokens: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceListingFunctionTokens(args),
+      providesTags: listings
+    }),
+    // ---- Connections ----
+    getMarketplaceIntegrations: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceIntegrations(args),
+      providesTags: [{ type: T, id: "INTEGRATIONS" }]
+    }),
+    getMarketplaceIntegration: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceIntegration(args),
+      providesTags: (_res, _err, arg) => [{ type: T, id: integrationId(arg) }]
+    }),
+    saveMarketplaceIntegration: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).saveMarketplaceIntegration(args),
+      invalidatesTags: [{ type: T, id: "INTEGRATIONS" }]
+    }),
+    deleteMarketplaceIntegration: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).deleteMarketplaceIntegration(args),
+      invalidatesTags: (_res, _err, arg) => [
+        ...integration(arg),
+        { type: T, id: `FUNCTIONS:${integrationId(arg)}` }
+      ]
+    }),
+    enableMarketplaceIntegration: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).enableMarketplaceIntegration(args),
+      invalidatesTags: (_res, _err, arg) => integration(arg)
+    }),
+    disableMarketplaceIntegration: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).disableMarketplaceIntegration(args),
+      invalidatesTags: (_res, _err, arg) => integration(arg)
+    }),
+    replaceMarketplaceIntegrationSecrets: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).replaceMarketplaceIntegrationSecrets(args),
+      invalidatesTags: (_res, _err, arg) => [{ type: T, id: integrationId(arg) }]
+    }),
+    revealMarketplaceIntegrationSecrets: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).revealMarketplaceIntegrationSecrets(args)
+    }),
+    setMarketplaceIntegrationTokenMappings: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).setMarketplaceIntegrationTokenMappings(args),
+      invalidatesTags: (_res, _err, arg) => [{ type: T, id: integrationId(arg) }]
+    }),
+    testMarketplaceIntegration: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).testMarketplaceIntegration(args),
+      invalidatesTags: (_res, _err, arg) => [{ type: T, id: integrationId(arg) }]
+    }),
+    getMarketplaceFunctionCatalog: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceFunctionCatalog(args),
+      providesTags: (_res, _err, arg) => [{ type: T, id: `CATALOG:${integrationId(arg)}` }]
+    }),
+    // ---- Functions on a connection ----
+    getMarketplaceFunctions: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceFunctions(args),
+      providesTags: (_res, _err, arg) => [{ type: T, id: `FUNCTIONS:${integrationId(arg)}` }]
+    }),
+    getMarketplaceFunction: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceFunction(args),
+      providesTags: (_res, _err, arg) => [{ type: T, id: functionId(arg) }]
+    }),
+    saveMarketplaceFunction: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).saveMarketplaceFunction(args),
+      invalidatesTags: (_res, _err, arg) => functions(arg)
+    }),
+    deleteMarketplaceFunction: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).deleteMarketplaceFunction(args),
+      invalidatesTags: (_res, _err, arg) => functions(arg)
+    }),
+    enableMarketplaceFunction: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).enableMarketplaceFunction(args),
+      invalidatesTags: (_res, _err, arg) => functions(arg)
+    }),
+    disableMarketplaceFunction: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).disableMarketplaceFunction(args),
+      invalidatesTags: (_res, _err, arg) => functions(arg)
+    }),
+    getMarketplaceFunctionTokens: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceFunctionTokens(args),
+      providesTags: (_res, _err, arg) => [{ type: T, id: functionId(arg) }]
+    }),
+    invokeMarketplaceFunction: b.mutation({
+      query: (args) => (norbix) => callHC(norbix).invokeMarketplaceFunction(args)
+    }),
+    // ---- Last runs (core SDK 4.21.0) ----
+    getMarketplaceFunctionRuns: b.query({
+      query: (args) => (norbix) => callHC(norbix).getMarketplaceFunctionRuns(args),
+      providesTags: [{ type: T, id: "RUNS" }]
+    })
+  };
+};
+
 // src/hooks/hub/membership.ts
 var hubMembership = (b) => ({
   disableMembership: b.mutation({
@@ -2337,6 +2453,7 @@ function buildEndpoints(builder) {
     ...hubAi(builder),
     ...hubApikeys(builder),
     ...hubCode(builder),
+    ...hubCodeMarketplace(builder),
     ...hubMembership(builder),
     ...hubDatabase(builder),
     ...hubFiles(builder),