@norbix.ai/react-redux 1.7.0 → 1.8.1

package/README.md

@@ -183,6 +183,78 @@ A _curated_ set of hooks for the most common endpoints. Every hook is end-to-end
 
 > **Need a hook we don't ship?** Two options. (1) Drop down to the SDK with `useNorbix()` for a one-off call. (2) Add a new file under `src/hooks/api/` or `src/hooks/hub/`, follow the pattern of the others, and open a PR.
 
+### Database — records, trees, bundle, imports — `norbix.hub.database` / `norbix.api.database`
+
+Every `hub.database` method (73) and every `api.database` method (22) of `@norbix.ai/ts` has a hook; Hub hooks keep the SDK method name. The rows below are the ones added for `@norbix.ai/ts` >= 4.9.0.
+
+| Hook                                          | SDK method                                      | Cache                                                              |
+| --------------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------ |
+| `useFindRecordsQuery`                         | `hub.database.findRecords`                      | provides `DatabaseRecords/<collectionName>`                        |
+| `useFindOneRecordQuery`                       | `hub.database.findOneRecord`                    | provides `DatabaseRecords/<collectionName>`                        |
+| `useCountRecordsQuery`                        | `hub.database.countRecords`                     | provides `DatabaseRecords/<collectionName>`                        |
+| `useDistinctRecordValuesQuery`                | `hub.database.distinctRecordValues`             | provides `DatabaseRecords/<collectionName>`                        |
+| `useAggregateRecordsMutation`                 | `hub.database.aggregateRecords`                 | — (never cached)                                                   |
+| `useExecuteRecordsAggregateMutation`          | `hub.database.executeRecordsAggregate`          | — (never cached)                                                   |
+| `useGetCollectionIndexesQuery`                | `hub.database.getCollectionIndexes`             | provides `DatabaseCollections/<collectionName>`                    |
+| `useInsertRecordMutation`                     | `hub.database.insertRecord`                     | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useInsertManyRecordsMutation`                | `hub.database.insertManyRecords`                | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useUpdateOneRecordMutation`                  | `hub.database.updateOneRecord`                  | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useUpdateManyRecordsMutation`                | `hub.database.updateManyRecords`                | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useReplaceRecordMutation`                    | `hub.database.replaceRecord`                    | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useDeleteRecordMutation`                     | `hub.database.deleteRecord`                     | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useDeleteManyRecordsMutation`                | `hub.database.deleteManyRecords`                | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useChangeRecordResponsibilityMutation`       | `hub.database.changeRecordResponsibility`       | invalidates `DatabaseRecords/<collectionName>`                     |
+| `useSeedCollectionRecordsMutation`            | `hub.database.seedCollectionRecords`            | invalidates `DatabaseRecords`                                      |
+| `useGetDatabaseTaxonomyTreeQuery`             | `hub.database.getDatabaseTaxonomyTree`          | provides `DatabaseTaxonomies` + `DatabaseTaxonomyTerms`            |
+| `useGetDatabaseTaxonomyTermTreeQuery`         | `hub.database.getDatabaseTaxonomyTermTree`      | provides `DatabaseTaxonomyTerms/<taxonomyName>`                    |
+| `useGetDatabaseMergedTermTreeQuery`           | `hub.database.getDatabaseMergedTermTree`        | provides `DatabaseTaxonomyTerms/<taxonomyName>`                    |
+| `useApplyDatabaseSchemaBundleMutation`        | `hub.database.applyDatabaseSchemaBundle`        | invalidates `DatabaseSchemas` + taxonomies + terms                 |
+| `useUpdateDatabaseSchemaEmbedMutation`        | `hub.database.updateDatabaseSchemaEmbed`        | invalidates `DatabaseSchemas`                                      |
+| `useGetDatabaseSchemaListSettingsQuery`       | `hub.database.getDatabaseSchemaListSettings`    | provides `DatabaseSchemas`                                         |
+| `useUpdateDatabaseSchemaListSettingsMutation` | `hub.database.updateDatabaseSchemaListSettings` | invalidates `DatabaseSchemas`                                      |
+| `useGetCollectionImportsQuery`                | `hub.database.getCollectionImports`             | provides `DatabaseImports`                                         |
+| `useGetCollectionImportQuery`                 | `hub.database.getCollectionImport`              | provides `DatabaseImports`                                         |
+| `useCreateCollectionImportMutation`           | `hub.database.createCollectionImport`           | invalidates `DatabaseImports` + `DatabaseRecords/<collectionName>` |
+| `useDeleteCollectionImportMutation`           | `hub.database.deleteCollectionImport`           | invalidates `DatabaseImports`                                      |
+| `useAnalyzeImportFileMutation`                | `hub.database.analyzeImportFile`                | —                                                                  |
+| `useRequestImportUploadUrlMutation`           | `hub.database.requestImportUploadUrl`           | —                                                                  |
+| `useFindOwnQuery`                             | `api.database.findOwn`                          | provides `DatabaseCollections/<collectionName>`                    |
+| `useFindMergedTermTreeQuery`                  | `api.database.findMergedTermTree`               | provides `DatabaseTaxonomyTerms/<taxonomyName>`                    |
+
+### Module switches send `PUT` (core SDK 4.10.0)
+
+The module enable / disable hooks were always mutations, so nothing changes in your code. From `@norbix.ai/ts` 4.10.0 they send `PUT` instead of `GET` on the wire, matching the gateway:
+
+| Hooks                                                         | Route                                                | Cache                    |
+| ------------------------------------------------------------- | ---------------------------------------------------- | ------------------------ |
+| `useEnableDatabaseMutation`, `useDisableDatabaseMutation`     | `PUT /{version}/database/enable\|disable`            | invalidates `Database`   |
+| `useEnableFilesMutation`, `useDisableFilesMutation`           | `PUT /{version}/files/enable\|disable`               | invalidates `Files`      |
+| `useEnableLoggingMutation`, `useDisableLoggingMutation`       | `PUT /{version}/logs/enable\|disable`                | invalidates `Logs`       |
+| `useEnablePaymentsMutation`, `useDisablePaymentsMutation`     | `PUT /{version}/payments/enable\|disable`            | invalidates `Payments`   |
+| `useEnableMembershipMutation`, `useDisableMembershipMutation` | `PUT /{version}/membership/enable\|disable`          | invalidates `Membership` |
+| `useEnableEmailMutation`, `useDisableEmailMutation`           | `PUT /{version}/notifications/email/enable\|disable` | invalidates `Emails`     |
+| `useEnableSmsMutation`, `useDisableSmsMutation`               | `PUT /{version}/notifications/sms/enable\|disable`   | invalidates `Sms`        |
+| `useEnablePushMutation`, `useDisablePushMutation`             | `PUT /{version}/notifications/push/enable\|disable`  | invalidates `Push`       |
+
+The gateway still answers the old `GET` on these paths for now (it logs a deprecation warning) and will drop it after gateway 0.2, so upgrade the core SDK before then. The scheduler switch moved to `PUT` earlier (core SDK 4.6.0). The code module (`hub.code`) has no hooks in this package yet; call `useNorbix().hub.code.enableCode(...)` directly.
+
+### Schemas per environment
+
+`useGetDatabaseSchemasQuery` returns only the schemas of the environment the request targets: the `env` argument, or else the client's environment (`norbix.setEnvironment(...)`, sent as the `norbix-env` header), or `PROD` when neither is set. Each row carries `env`. The schema list settings (`useGetDatabaseSchemaListSettingsQuery` / `useUpdateDatabaseSchemaListSettingsMutation`) are stored per environment too.
+
+RTK Query keys its cache by endpoint + arguments, and the client's environment is not an argument. So either pass `env` in the arguments — each environment then has its own cache entry — or reset the cache when you switch:
+
+```tsx
+// Per call: TEST and PROD cache apart.
+const { data } = useGetDatabaseSchemasQuery({ env: 'TEST' });
+
+// Or switch the whole client and drop what was cached for the old environment.
+norbix.setEnvironment('TEST');
+dispatch(norbixApi.util.invalidateTags(['DatabaseSchemas']));
+```
+
+The paging cursors of the schema list (`startingAfter` / `endingBefore`) are schema view ids (`sch_…`). A cursor saved against an older gateway will not match; start the list again from the first page.
+
 ### End-user AI chat — `norbix.api.ai`
 
 For a signed-in project user. `useStartEndUserChatTurnMutation` answers at once with a `turnId`; the answer streams on the user's SSE channel `ai-chat:{projectId}:{authId}` — open it with `norbix.aiChat({ authId })` from `@norbix.ai/ts` (a foreign channel is refused with 403 `AiChatChannelRefused`, no retry). Needs `@norbix.ai/ts` >= 4.3.0.

package/dist/index.cjs

@@ -183,25 +183,47 @@ var apiDatabase = (b) => ({
   findCollection: b.query({
     query: (args) => (norbix) => norbix.api.database.find(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   findOne: b.query({
     query: (args) => (norbix) => norbix.api.database.findOne(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
+    ]
+  }),
+  // Only the records the caller is responsible for (owner-scoped find).
+  findOwn: b.query({
+    query: (args) => (norbix) => norbix.api.database.findOwn(args),
+    providesTags: (_res, _err, arg) => [
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   countCollection: b.query({
     query: (args) => (norbix) => norbix.api.database.count(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   distinct: b.query({
     query: (args) => (norbix) => norbix.api.database.distinct(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   aggregate: b.mutation({
@@ -214,69 +236,102 @@ var apiDatabase = (b) => ({
   insertOne: b.mutation({
     query: (args) => (norbix) => norbix.api.database.insertOne(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   insertMany: b.mutation({
     query: (args) => (norbix) => norbix.api.database.insertMany(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   updateOne: b.mutation({
     query: (args) => (norbix) => norbix.api.database.updateOne(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   updateMany: b.mutation({
     query: (args) => (norbix) => norbix.api.database.updateMany(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   replaceOne: b.mutation({
     query: (args) => (norbix) => norbix.api.database.replaceOne(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   deleteOne: b.mutation({
     query: (args) => (norbix) => norbix.api.database.deleteOne(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   deleteMany: b.mutation({
     query: (args) => (norbix) => norbix.api.database.deleteMany(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   changeResponsibility: b.mutation({
     query: (args) => (norbix) => norbix.api.database.changeResponsibility(args),
     invalidatesTags: (_res, _err, arg) => [
-      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
     ]
   }),
   // ---- Taxonomies (read-only on api; admin lives in hub.database) ----
   findTerms: b.query({
     query: (args) => (norbix) => norbix.api.database.findTerms(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+      {
+        type: "DatabaseTaxonomyTerms",
+        id: arg?.taxonomyName ?? "ANY"
+      }
     ]
   }),
   findTermsChildren: b.query({
     query: (args) => (norbix) => norbix.api.database.findTermsChildren(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+      {
+        type: "DatabaseTaxonomyTerms",
+        id: arg?.taxonomyName ?? "ANY"
+      }
     ]
   }),
   // Whole term tree of a taxonomy (or a sub-tree from a root term) in one call.
   findTermTree: b.query({
     query: (args) => (norbix) => norbix.api.database.findTermTree(args),
     providesTags: (_res, _err, arg) => [
-      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+      {
+        type: "DatabaseTaxonomyTerms",
+        id: arg?.taxonomyName ?? "ANY"
+      }
     ]
   }),
   // Single-parent taxonomy structure tree (Countries → Cities), optionally with terms.
@@ -284,6 +339,16 @@ var apiDatabase = (b) => ({
     query: (args) => (norbix) => norbix.api.database.findTaxonomyTree(args),
     providesTags: () => [{ type: "DatabaseTaxonomyTerms", id: "ANY" }]
   }),
+  // One tree across related taxonomies (Countries + Cities: each country with its cities).
+  findMergedTermTree: b.query({
+    query: (args) => (norbix) => norbix.api.database.findMergedTermTree(args),
+    providesTags: (_res, _err, arg) => [
+      {
+        type: "DatabaseTaxonomyTerms",
+        id: arg?.taxonomyName ?? "ANY"
+      }
+    ]
+  }),
   // ---- Schemas (read-only mirror; full CRUD lives in hub.database) ----
   getApiDatabaseSchema: b.query({
     query: (args) => (norbix) => norbix.api.database.getDatabaseSchema(args),
@@ -873,6 +938,18 @@ var hubApikeys = (b) => ({
 });
 
 // src/hooks/hub/database.ts
+var recordsTag = (arg) => [
+  {
+    type: "DatabaseRecords",
+    id: arg?.collectionName ?? "ANY"
+  }
+];
+var termsTag = (arg) => [
+  {
+    type: "DatabaseTaxonomyTerms",
+    id: arg?.taxonomyName ?? "ANY"
+  }
+];
 var hubDatabase = (b) => ({
   disableDatabase: b.mutation({
     query: (args) => (norbix) => norbix.hub.database.disableDatabase(args),
@@ -1049,6 +1126,134 @@ var hubDatabase = (b) => ({
   testDatabaseAggregate: b.mutation({
     query: (args) => (norbix) => norbix.hub.database.testDatabaseAggregate(args),
     invalidatesTags: ["DatabaseAggregates"]
+  }),
+  // ---- Records (Hub data browser: same operations as api.database, admin-scoped) ----
+  findRecords: b.query({
+    query: (args) => (norbix) => norbix.hub.database.findRecords(args),
+    providesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  findOneRecord: b.query({
+    query: (args) => (norbix) => norbix.hub.database.findOneRecord(args),
+    providesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  countRecords: b.query({
+    query: (args) => (norbix) => norbix.hub.database.countRecords(args),
+    providesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  distinctRecordValues: b.query({
+    query: (args) => (norbix) => norbix.hub.database.distinctRecordValues(args),
+    providesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  // Aggregations run a pipeline on demand: mutations, so the answer is never served from cache.
+  aggregateRecords: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.aggregateRecords(args)
+  }),
+  executeRecordsAggregate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.executeRecordsAggregate(args)
+  }),
+  getCollectionIndexes: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getCollectionIndexes(args),
+    providesTags: (_res, _err, arg) => [
+      {
+        type: "DatabaseCollections",
+        id: arg?.collectionName ?? "ANY"
+      }
+    ]
+  }),
+  insertRecord: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.insertRecord(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  insertManyRecords: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.insertManyRecords(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  updateOneRecord: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateOneRecord(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  updateManyRecords: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateManyRecords(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  replaceRecord: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.replaceRecord(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  deleteRecord: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteRecord(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  deleteManyRecords: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteManyRecords(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  changeRecordResponsibility: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.changeRecordResponsibility(args),
+    invalidatesTags: (_res, _err, arg) => recordsTag(arg)
+  }),
+  // Seeds several collections at once (`collections` is a JSON map), so every record list is stale.
+  seedCollectionRecords: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.seedCollectionRecords(args),
+    invalidatesTags: ["DatabaseRecords"]
+  }),
+  // ---- Taxonomy trees ----
+  getDatabaseTaxonomyTree: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseTaxonomyTree(args),
+    providesTags: ["DatabaseTaxonomies", "DatabaseTaxonomyTerms"]
+  }),
+  getDatabaseTaxonomyTermTree: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseTaxonomyTermTree(args),
+    providesTags: (_res, _err, arg) => termsTag(arg)
+  }),
+  // One tree across related taxonomies (Countries + Cities: each country with its cities).
+  getDatabaseMergedTermTree: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseMergedTermTree(args),
+    providesTags: (_res, _err, arg) => termsTag(arg)
+  }),
+  // ---- Schema bundle, embed and list settings ----
+  // A bundle can create schemas, taxonomies and terms in one call.
+  applyDatabaseSchemaBundle: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.applyDatabaseSchemaBundle(args),
+    invalidatesTags: ["DatabaseSchemas", "DatabaseTaxonomies", "DatabaseTaxonomyTerms"]
+  }),
+  updateDatabaseSchemaEmbed: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateDatabaseSchemaEmbed(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchemaListSettings: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchemaListSettings(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  updateDatabaseSchemaListSettings: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateDatabaseSchemaListSettings(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  // ---- Collection imports (CSV) ----
+  getCollectionImports: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getCollectionImports(args),
+    providesTags: ["DatabaseImports"]
+  }),
+  getCollectionImport: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getCollectionImport(args),
+    providesTags: ["DatabaseImports"]
+  }),
+  // An import writes records into the target collection.
+  createCollectionImport: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.createCollectionImport(args),
+    invalidatesTags: (_res, _err, arg) => [{ type: "DatabaseImports" }, ...recordsTag(arg)]
+  }),
+  deleteCollectionImport: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteCollectionImport(args),
+    invalidatesTags: ["DatabaseImports"]
+  }),
+  // Reads the uploaded file and suggests a column mapping; saves nothing.
+  analyzeImportFile: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.analyzeImportFile(args)
+  }),
+  // Returns a one-time signed upload URL; saves nothing.
+  requestImportUploadUrl: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.requestImportUploadUrl(args)
   })
 });