@norbix.ai/react-redux 0.1.1 → 1.0.0

package/README.md

@@ -150,6 +150,7 @@ A *curated* set of hooks for the most common endpoints. Every hook is end-to-end
 | `useGetApiKeysQuery` | `api.apikeys.getApiKeys` | provides `ApiKey/LIST` |
 | `useRegenerateApiKeysMutation` | `api.apikeys.regenerateApiKeys` | invalidates `ApiKey/LIST` |
 | `useGetPublicFileQuery` | `api.files.getPublicFile` | provides `Files/PUBLIC:<publicId>` |
+| `useTestFilesIntegrationApiMutation` | `api.files.testFilesIntegration` | invalidates `Files` + `FilesIntegrations` |
 
 ### Hub surface — `norbix.hub.*`
 
@@ -213,6 +214,31 @@ on the page. `useGetPublicFileQuery` caches under its own
 making a file private again invalidates `Files`, a different tag, so call
 `refetch()` if a stale entry would matter to you.
 
+## Testing a files integration
+
+Two hooks run the same live probe against a files integration — upload a
+small file, read it, list the folder, delete the file — and answer one item
+per step (`UploadFile`, `GetFile`, `GetAllFiles`, `DeleteFile`) with `result`
+`OK`, `FAILED` or `NOT_TESTED`:
+
+| Hook | Wraps | Route | Use it from |
+|---|---|---|---|
+| `useTestFilesIntegrationApiMutation` | `api.files.testFilesIntegration` | `POST /{version}/files/{filesIntegrationId}/test` | your app, with an API key or a user session (needs `files:create`) |
+| `useTestFilesIntegrationMutation` | `hub.files.testFilesIntegration` | `POST /{version}/files/integrations/test` | a dashboard, signed in to the Hub |
+
+```tsx
+const [testIntegration, { data, isLoading }] = useTestFilesIntegrationApiMutation();
+
+await testIntegration({ filesIntegrationId: 'nbin_1' });
+const failed = data?.items?.filter((i) => i.result !== 'OK');
+```
+
+The API one carries the `Api` suffix because both live in one endpoint map
+(like `useDeleteFileApiMutation`). It invalidates `Files` — the probe writes to
+the storage, and a failed delete step leaves its file behind — and
+`FilesIntegrations`, because the gateway records the last test result on the
+integration.
+
 ## 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:
@@ -782,6 +808,37 @@ If your app currently calls Norbix via `fetchBaseQuery({ baseUrl })` + a custom
 4. **Remove** the custom error interceptor — `createNorbixBaseQuery` already maps `NorbixError` to `SerializedNorbixError` with `code`, `status`, `message`, `fieldErrors`. Consume those in your error UI instead.
 5. **Keep** the same tag taxonomy — the package exports the full set (`Account`, `Projects`, `Regions`, `MembershipUsers`, `DatabaseSchemas`, ... 59 in total), so existing `providesTags` keep working.
 
+## Errors
+
+A failed call lands in the Redux state as a plain `SerializedNorbixError`:
+
+```ts
+const { error } = useGetFileInfoQuery({ filesIntegrationId, path });
+if (error) {
+  // httpStatus / errorCode / errors are the names every Norbix SDK uses.
+  // status / code / fieldErrors are the same values, kept for older code.
+  console.log(error.httpStatus, error.errorCode, error.message);
+  error.errors.forEach((e) => console.log(e.errorCode, e.fieldName, e.message));
+}
+```
+
+The message and the error code are the gateway's own. `@norbix.ai/ts` reads
+them out of `responseStatus.errors[]`, where the gateway puts them, and this
+package copies them into the store unchanged — it does not parse bodies
+itself.
+
+### Breaking change — a refused call now lands as an error
+
+The gateway answers a business refusal (an unknown id, a rule that says no)
+with **HTTP 200** and `responseStatus.isSuccess = false`. Until now such an
+answer arrived as `{ data }` and your components rendered it as a success.
+With the fixed `@norbix.ai/ts` it arrives as `{ error }` with `httpStatus` 200
+and the gateway's message and error code.
+
+If a component checked `data.responseStatus.isSuccess` itself, read `error`
+instead. This needs `@norbix.ai/ts` **2.0.0 or newer** — the version that
+carries the fix.
+
 ## How it works under the hood
 
 `createNorbixApi(getClient)` returns an RTK Query API. Its `baseQuery` is a thin wrapper that calls a closure you pass at endpoint definition time:

package/dist/index.cjs

@@ -10,18 +10,27 @@ var jsxRuntime = require('react/jsx-runtime');
 function serializeNorbixError(err) {
   if (err && typeof err === "object") {
     const e = err;
+    const status = typeof e.status === "number" ? e.status : typeof e.httpStatus === "number" ? e.httpStatus : 0;
+    const code = e.code ?? e.errorCode;
+    const list = Array.isArray(e.fieldErrors) ? e.fieldErrors : Array.isArray(e.errors) ? e.errors : [];
     return {
-      status: typeof e.status === "number" ? e.status : 0,
-      code: e.code,
+      status,
+      httpStatus: status,
+      code,
+      errorCode: code,
       message: e.message ?? "Unknown Norbix error",
-      fieldErrors: Array.isArray(e.fieldErrors) ? e.fieldErrors : [],
+      fieldErrors: list,
+      errors: list,
       url: e.url
     };
   }
+  const message = typeof err === "string" ? err : "Unknown Norbix error";
   return {
     status: 0,
-    message: typeof err === "string" ? err : "Unknown Norbix error",
-    fieldErrors: []
+    httpStatus: 0,
+    message,
+    fieldErrors: [],
+    errors: []
   };
 }
 
@@ -38,9 +47,12 @@ function createNorbixBaseQuery(getClient) {
       return {
         error: {
           status: 0,
+          httpStatus: 0,
           code: "NORBIX_NO_CLIENT",
+          errorCode: "NORBIX_NO_CLIENT",
           message: "No Norbix client available. Did you forget <NorbixProvider>?",
-          fieldErrors: []
+          fieldErrors: [],
+          errors: []
         }
       };
     }
@@ -276,6 +288,36 @@ var apiFiles = (b) => ({
     providesTags: (_res, _err, arg) => [
       { type: "Files", id: `PUBLIC:${arg?.publicId ?? "unknown"}` }
     ]
+  }),
+  /**
+   * Runs a live probe against a files integration with the caller's own API
+   * key or session: uploads a small file, reads it, lists the folder and
+   * deletes the file again. Answers one item per step (`UploadFile`,
+   * `GetFile`, `GetAllFiles`, `DeleteFile`) with `result` `OK`, `FAILED` or
+   * `NOT_TESTED`, plus the step's `errors`. Needs the `files:create`
+   * permission, because the probe writes to the storage.
+   *
+   * Wraps `api.files.testFilesIntegration`
+   * (`POST /{version}/files/{filesIntegrationId}/test`). This is NOT the
+   * dashboard endpoint `hub.files.testFilesIntegration`
+   * (`POST /{version}/files/integrations/test`), whose hook is
+   * `useTestFilesIntegrationMutation`. Both live in one flat endpoint map,
+   * so this one carries the `Api` suffix — the same way `deleteFileApi` and
+   * `downloadFileApi` do — otherwise the Hub one, spread later, would
+   * silently replace it. Hook: `useTestFilesIntegrationApiMutation`.
+   *
+   * A mutation, like every other write in this file, so its answer is never
+   * served from cache. It invalidates:
+   * - `Files`, like its write neighbours: the probe uploads and deletes a
+   *   real file in the storage `listFiles` reads, and if the delete step
+   *   fails the probe file stays behind;
+   * - `FilesIntegrations`: the gateway records the outcome on the
+   *   integration (last test time, success, errors), which
+   *   `getFilesIntegration(s)` return.
+   */
+  testFilesIntegrationApi: b.mutation({
+    query: (args) => (norbix) => norbix.api.files.testFilesIntegration(args),
+    invalidatesTags: ["Files", "FilesIntegrations"]
   })
 });