Merge pull request #2528 from kuzzleio/beta

Author: fmauNeko

CHANGELOG.md

@@ -1,3 +1,19 @@
+## [2.29.1-beta.2](https://github.com/kuzzleio/kuzzle/compare/v2.29.1-beta.1...v2.29.1-beta.2) (2024-03-22)
+
+
+### Bug Fixes
+
+* **global:** fix global types ([b4661b9](https://github.com/kuzzleio/kuzzle/commit/b4661b9e1e2d8c169d93e7a17f030338875faed0))
+* **ts:** export Kuzzle class so typedef is generated ([448c235](https://github.com/kuzzleio/kuzzle/commit/448c235ef3db8316f02b00d997a48a7e3a30784c))
+
+## [2.29.1-beta.1](https://github.com/kuzzleio/kuzzle/compare/v2.29.0...v2.29.1-beta.1) (2024-03-13)
+
+
+### Bug Fixes
+
+* **openapi:** remove dedicated components files as we need to generate it automaticaly ([a3036f6](https://github.com/kuzzleio/kuzzle/commit/a3036f6336c1c6e14eb874acde04976f3de1c1ed))
+* **settings:** elasticsearch default setting on imports collection ([228482a](https://github.com/kuzzleio/kuzzle/commit/228482af41b822c0e064286083811c9aca95e532))
+
 # [2.29.0](https://github.com/kuzzleio/kuzzle/compare/v2.28.0...v2.29.0) (2024-02-01)
 
 

docker/scripts/start-kuzzle-test.ts

@@ -262,6 +262,7 @@ app.hook.register("custom:event", async (name) => {
 let syncedHello = "World";
 let dynamicPipeId;
 
+app.openApi.definition.components = {}
 app.openApi.definition.components.LogisticObjects = {
   Item: {
     type: "object",

features/ServerController.feature

@@ -78,7 +78,6 @@ Feature: Server Controller
     When I successfully execute the action "server":"openapi"
     Then I should receive a response matching:
       | swagger                                 | "2.0"      |
-      | components.RequestPayload               | "_OBJECT_" |
       | paths./users/{_id}/_replace.put.tags[0] | "security" |
 
   @http
@@ -87,7 +86,6 @@ Feature: Server Controller
       | scope | "app" |
     Then I should receive a response matching:
       | paths./openapi-test/{company}/{objectType}/{_id}.post.tags[0] | "openapi-test" |
-      | components.LogisticObjects.Item                               | "_OBJECT_"     |
 
   # server:publicApi ========================================================================
   @development @http

lib/api/httpRoutes.js

@@ -23,22 +23,6 @@
 
 "use strict";
 
-const {
-  OpenApiDocumentCount,
-  OpenApiDocumentDeleteByQuery,
-  OpenApiDocumentDelete,
-  OpenApiDocumentScroll,
-  OpenApiDocumentExists,
-  OpenApiDocumentUpdate,
-  OpenApiDocumentReplace,
-  OpenApiDocumentGet,
-  OpenApiDocumentCreate,
-  OpenApiDocumentCreateOrReplace,
-  OpenApiDocumentValidate,
-  OpenApiSecurityUpsertUser,
-  OpenApiDocumentmCreateOrReplace,
-} = require("./openapi/components");
-
 const routes = [
   // GET (idempotent)
   { verb: "get", path: "/_me", controller: "auth", action: "getCurrentUser" },
@@ -242,7 +226,6 @@ const routes = [
     path: "/:index/:collection/:_id",
     controller: "document",
     action: "get",
-    openapi: OpenApiDocumentGet,
   },
   {
     verb: "get",
@@ -255,7 +238,6 @@ const routes = [
     path: "/:index/:collection/:_id/_exists",
     controller: "document",
     action: "exists",
-    openapi: OpenApiDocumentExists,
   },
   {
     verb: "post",
@@ -268,7 +250,6 @@ const routes = [
     path: "/_scroll/:scrollId",
     controller: "document",
     action: "scroll",
-    openapi: OpenApiDocumentScroll,
   },
 
   {
@@ -770,14 +751,12 @@ const routes = [
     path: "/:index/:collection/_count",
     controller: "document",
     action: "count",
-    openapi: OpenApiDocumentCount,
   },
   {
     verb: "post",
     path: "/:index/:collection/_create",
     controller: "document",
     action: "create",
-    openapi: OpenApiDocumentCreate,
   },
   {
     verb: "post",
@@ -832,7 +811,6 @@ const routes = [
     path: "/:index/:collection/_validate",
     controller: "document",
     action: "validate",
-    openapi: OpenApiDocumentValidate,
   },
 
   {
@@ -955,7 +933,6 @@ const routes = [
     path: "/users/:_id/_upsert",
     controller: "security",
     action: "upsertUser",
-    openapi: OpenApiSecurityUpsertUser,
   },
   {
     verb: "post",
@@ -1241,7 +1218,6 @@ const routes = [
     path: "/:index/:collection/:_id",
     controller: "document",
     action: "delete",
-    openapi: OpenApiDocumentDelete,
   },
   {
     verb: "delete",
@@ -1254,7 +1230,6 @@ const routes = [
     path: "/:index/:collection/_query",
     controller: "document",
     action: "deleteByQuery",
-    openapi: OpenApiDocumentDeleteByQuery,
   },
   {
     verb: "delete",
@@ -1421,21 +1396,18 @@ const routes = [
     path: "/:index/:collection/:_id",
     controller: "document",
     action: "createOrReplace",
-    openapi: OpenApiDocumentCreateOrReplace,
   },
   {
     verb: "put",
     path: "/:index/:collection/_mCreateOrReplace",
     controller: "document",
     action: "mCreateOrReplace",
-    openapi: OpenApiDocumentmCreateOrReplace,
   },
   {
     verb: "put",
     path: "/:index/:collection/:_id/_replace",
     controller: "document",
     action: "replace",
-    openapi: OpenApiDocumentReplace,
   },
   {
     verb: "put",
@@ -1458,7 +1430,6 @@ const routes = [
     path: "/:index/:collection/:_id/_update",
     controller: "document",
     action: "update",
-    openapi: OpenApiDocumentUpdate,
     deprecated: {
       since: "2.11.0",
       message: 'Use "document:update" route with PATCH instead of PUT',

lib/api/openapi/OpenApiManager.ts

@@ -19,22 +19,6 @@
  * limitations under the License.
  */
 
-import {
-  OpenApiPayloadsDefinitions,
-  OpenApiDocumentCountComponent,
-  OpenApiDocumentDeleteByQueryComponent,
-  OpenApiDocumentDeleteComponent,
-  OpenApiDocumentScrollComponent,
-  OpenApiDocumentExistsComponent,
-  OpenApiDocumentUpdateComponent,
-  OpenApiDocumentReplaceComponent,
-  OpenApiDocumentGetComponent,
-  OpenApiDocumentCreateOrReplaceComponent,
-  OpenApiDocumentCreateComponent,
-  OpenApiDocumentValidateComponent,
-  OpenApiSecurityUpsertUserComponent,
-  OpenApiDocumentmCreateOrReplaceComponent,
-} from "./components";
 import { OpenApiDefinition } from "../../types/OpenApiDefinition";
 import { version } from "../../../package.json";
 import { generateOpenApi } from "./openApiGenerator";
@@ -50,7 +34,6 @@ export class OpenApiManager {
         name: "Kuzzle team",
         url: "https://kuzzle.io",
         email: "support@kuzzle.io",
-        discord: "http://join.discord.kuzzle.io",
       },
       license: {
         name: "Apache 2",
@@ -62,40 +45,9 @@ export class OpenApiManager {
       description: "Kuzzle API Documentation",
       url: "https://docs.kuzzle.io/core/2/api/",
     },
-    servers: [
-      {
-        url: "https://{baseUrl}:{port}",
-        description: "Kuzzle Base Url",
-        variables: {
-          baseUrl: { default: "localhost" },
-          port: { default: 7512 },
-        },
-      },
-    ],
     tags: [],
     schemes: ["https", "http"],
     paths: {},
-    components: {
-      ...OpenApiPayloadsDefinitions,
-
-      document: {
-        ...OpenApiDocumentCountComponent,
-        ...OpenApiDocumentDeleteByQueryComponent,
-        ...OpenApiDocumentDeleteComponent,
-        ...OpenApiDocumentScrollComponent,
-        ...OpenApiDocumentExistsComponent,
-        ...OpenApiDocumentUpdateComponent,
-        ...OpenApiDocumentReplaceComponent,
-        ...OpenApiDocumentGetComponent,
-        ...OpenApiDocumentCreateOrReplaceComponent,
-        ...OpenApiDocumentCreateComponent,
-        ...OpenApiDocumentValidateComponent,
-      },
-      security: {
-        ...OpenApiSecurityUpsertUserComponent,
-        ...OpenApiDocumentmCreateOrReplaceComponent,
-      },
-    },
   };
   /* eslint-enable sort-keys */
 

lib/api/openapi/components/document/count.yaml

@@ -79,7 +79,7 @@ function generateParameters(route: JSONObject) {
         in: "path",
         name: m[1],
         required: true,
-        schema: { type: "string" },
+        type: "string",
       });
 
       m = routeUrlMatch.exec(route.path);

lib/api/openapi/components/document/create.yaml

@@ -425,6 +425,19 @@ const defaultConfig: KuzzleConfiguration = {
               },
             },
           },
+          imports: {
+            settings: {
+              // @deprecated : replace undefined by 1
+              number_of_shards: 1,
+              number_of_replicas: 1,
+            },
+            mappings: {
+              dynamic: "strict",
+              properties: {
+                hash: { type: "keyword" },
+              },
+            },
+          },
         },
       },
       maxScrollDuration: "1m",

lib/api/openapi/components/document/createOrReplace.yaml

@@ -33,15 +33,14 @@ export class BackendOpenApi extends ApplicationManager {
 
     /* eslint-disable sort-keys */
     this.definition = {
-      openapi: "3.0.0",
+      openapi: "3.1.0",
       info: {
         title: `${application.name} API`,
         description: `${application.name} HTTP API definition`,
         contact: {
           name: "Kuzzle team",
           url: "https://kuzzle.io",
           email: "support@kuzzle.io",
-          discord: "http://join.discord.kuzzle.io",
         },
         license: {
           name: "Apache 2",
@@ -53,20 +52,9 @@ export class BackendOpenApi extends ApplicationManager {
         description: "Kuzzle API Documentation",
         url: "https://docs.kuzzle.io/core/2/api/",
       },
-      servers: [
-        {
-          url: "https://{baseUrl}:{port}",
-          description: `${application.name} Base Url`,
-          variables: {
-            baseUrl: { default: "localhost" },
-            port: { default: 7512 },
-          },
-        },
-      ],
       tags: [],
       schemes: ["https", "http"],
       paths: {},
-      components: {},
     };
     /* eslint-enable sort-keys */
   }

lib/api/openapi/components/document/delete.yaml

@@ -626,6 +626,89 @@ class Kuzzle extends KuzzleEventEmitter {
     }
   }
 
+  private isConfigsEmpty(importConfig, supportConfig) {
+    if (
+      _.isEmpty(importConfig.mappings) &&
+      _.isEmpty(importConfig.profiles) &&
+      _.isEmpty(importConfig.roles) &&
+      _.isEmpty(importConfig.userMappings) &&
+      _.isEmpty(importConfig.users) &&
+      _.isEmpty(supportConfig.fixtures) &&
+      _.isEmpty(supportConfig.mappings) &&
+      _.isEmpty(supportConfig.securities)
+    ) {
+      return true;
+    }
+    return false;
+  }
+
+  private async persistHashedImport({
+    existingRedisHash,
+    existingESHash,
+    importPayloadHash,
+    type,
+  }) {
+    if (!existingRedisHash && !existingESHash) {
+      // If the import is not initialized in the redis cache and in the ES, we initialize it
+      this.log.info(`${type} import is not initialized, initializing...`);
+
+      await this.ask(
+        "core:storage:private:document:create",
+        "kuzzle",
+        "imports",
+        {
+          hash: importPayloadHash,
+        },
+        { id: `${BACKEND_IMPORT_KEY}:${type}` },
+      );
+      await this.ask(
+        "core:cache:internal:store",
+        `${BACKEND_IMPORT_KEY}:${type}`,
+        importPayloadHash,
+      );
+    } else if (existingRedisHash && !existingESHash) {
+      // If the import is initialized in the redis cache but not in the ES
+      // We initialize it in the ES
+      this.log.info(
+        `${type} import is not initialized in %kuzzle.imports, initializing...`,
+      );
+
+      const redisCache = await this.ask(
+        "core:cache:internal:get",
+        `${BACKEND_IMPORT_KEY}:${type}`,
+      );
+
+      await this.ask(
+        "core:storage:private:document:create",
+        "kuzzle",
+        "imports",
+        {
+          hash: redisCache,
+        },
+        { id: `${BACKEND_IMPORT_KEY}:${type}` },
+      );
+    } else if (!existingRedisHash && existingESHash) {
+      // If the import is initialized in the ES but not in the redis cache
+      // We initialize it in the redis cache
+      this.log.info(
+        `${type} import is not initialized in the redis cache, initializing...`,
+      );
+
+      const esDocument = await this.ask(
+        "core:storage:private:document:get",
+        "kuzzle",
+        "imports",
+        `${BACKEND_IMPORT_KEY}:${type}`,
+      );
+
+      await this.ask(
+        "core:cache:internal:store",
+        `${BACKEND_IMPORT_KEY}:${type}`,
+        esDocument._source.hash,
+      );
+    }
+  }
+
   /**
    * Load into the app several imports
    *
@@ -638,16 +721,7 @@ class Kuzzle extends KuzzleEventEmitter {
     toImport: ImportConfig = {},
     toSupport: SupportConfig = {},
   ): Promise<void> {
-    if (
-      _.isEmpty(toImport.mappings) &&
-      _.isEmpty(toImport.profiles) &&
-      _.isEmpty(toImport.roles) &&
-      _.isEmpty(toImport.userMappings) &&
-      _.isEmpty(toImport.users) &&
-      _.isEmpty(toSupport.fixtures) &&
-      _.isEmpty(toSupport.mappings) &&
-      _.isEmpty(toSupport.securities)
-    ) {
+    if (this.isConfigsEmpty(toImport, toSupport)) {
       return;
     }
 
@@ -676,31 +750,54 @@ class Kuzzle extends KuzzleEventEmitter {
         const importPayloadHash = sha256(stringify(importPayload));
         const mutex = new Mutex(`backend:import:${type}`, { timeout: 0 });
 
-        const existingHash = await this.ask(
+        const existingRedisHash = await this.ask(
           "core:cache:internal:get",
           `${BACKEND_IMPORT_KEY}:${type}`,
         );
 
-        const initialized = existingHash === importPayloadHash;
+        const existingESHash = await this.ask(
+          "core:storage:private:document:exist",
+          "kuzzle",
+          "imports",
+          `${BACKEND_IMPORT_KEY}:${type}`,
+        );
+
+        let initialized = false;
+
+        if (existingRedisHash) {
+          // Check if the import is already initialized inside the redis cache
+          initialized = existingRedisHash === importPayloadHash;
+        } else if (existingESHash) {
+          // Check if the import is already initialized inside the ES
+          const esDocument = await this.ask(
+            "core:storage:private:document:get",
+            "kuzzle",
+            "imports",
+            `${BACKEND_IMPORT_KEY}:${type}`,
+          );
+          initialized = esDocument._source.hash === importPayloadHash;
+        }
+
         const locked = await mutex.lock();
 
         await importMethod(
           { toImport, toSupport },
           {
             firstCall: !initialized && locked,
-            initialized,
+            initialized: initialized,
             locked,
           },
         );
 
-        if (!initialized && locked) {
+        if (locked) {
           lockedMutex.push(mutex);
 
-          await this.ask(
-            "core:cache:internal:store",
-            `${BACKEND_IMPORT_KEY}:${type}`,
+          await this.persistHashedImport({
+            existingESHash,
+            existingRedisHash,
             importPayloadHash,
-          );
+            type,
+          });
         }
       }
 
@@ -829,4 +926,5 @@ class Kuzzle extends KuzzleEventEmitter {
   }
 }
 
+export { Kuzzle };
 module.exports = Kuzzle;

lib/api/openapi/components/document/deleteByQuery.yaml

@@ -1,19 +1,22 @@
 import { Backend } from "../core/backend";
+import { Kuzzle } from "../kuzzle";
 
-/* eslint-disable @typescript-eslint/no-namespace */
+/**
+ * This file contains global type declarations for Kuzzle.
+ * We need to use `var` so Typescript extends the globalThis type.
+ * See https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#type-checking-for-globalthis
+ */
+
+/* eslint-disable no-var, vars-on-top */
 
 declare global {
-  namespace NodeJS {
-    interface Global {
-      kuzzle: any;
-      app: Backend;
-      NODE_ENV: string;
-    }
-  }
+  var app: Backend;
+  var kuzzle: Kuzzle;
+  var NODE_ENV: string;
 }
 
 global.NODE_ENV = process.env.NODE_ENV;
 
 export {};
 
-/* eslint-enable @typescript-eslint/no-namespace */
+/* eslint-enable no-var, vars-on-top*/

lib/api/openapi/components/document/exists.yaml

@@ -11,7 +11,6 @@ export type OpenApiDefinition = {
       name: string;
       url: string;
       email: string;
-      discord: string;
     };
     license: {
       name: string;
@@ -23,19 +22,11 @@ export type OpenApiDefinition = {
     description: string;
     url: string;
   };
-  servers: Array<{
-    url: string;
-    description: string;
-    variables: {
-      baseUrl: { default: string };
-      port: { default: number };
-    };
-  }>;
   tags: Array<{
     description: string;
     name: string;
   }>;
   schemes: string[];
   paths: JSONObject;
-  components: JSONObject;
+  components?: JSONObject;
 };

lib/api/openapi/components/document/get.yaml

@@ -317,6 +317,26 @@ export type StorageEngineElasticsearch = {
           };
         };
       };
+      imports: {
+        settings: {
+          /**
+           * @default 1
+           */
+          number_of_shards: number;
+
+          /**
+           * @default 1
+           */
+          number_of_replicas: number;
+        };
+
+        mappings: {
+          dynamic: "strict";
+          properties: {
+            hash: { type: "keyword" };
+          };
+        };
+      };
     };
   };
   maxScrollDuration: string;

lib/api/openapi/components/document/index.ts

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.29.0",
+  "version": "2.29.1-beta.2",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": "bin/start-kuzzle-server",
   "scripts": {

lib/api/openapi/components/document/mCreateOrReplace.yaml

@@ -37,20 +37,9 @@ describe("OpenApiManager", () => {
         description: "Kuzzle API Documentation",
         url: "https://docs.kuzzle.io/core/2/api/",
       },
-      servers: [
-        {
-          url: "https://{baseUrl}:{port}",
-          description: "Kuzzle Base Url",
-          variables: {
-            baseUrl: { default: "localhost" },
-            port: { default: 7512 },
-          },
-        },
-      ],
       tags: [],
       schemes: ["https", "http"],
       paths: {},
-      components: {},
     };
 
     pluginsRoutes = [

lib/api/openapi/components/document/replace.yaml

@@ -370,8 +370,11 @@ describe("/lib/kuzzle/kuzzle.js", () => {
     let mappingsPayload;
     let permissionsPayload;
     let fixturesPayload;
+    let userMappingsPayload;
 
     beforeEach(() => {
+      userMappingsPayload = { something: "here" };
+
       mappingsPayload = {
         toImport: {
           mappings: { something: "here" },
@@ -407,13 +410,13 @@ describe("/lib/kuzzle/kuzzle.js", () => {
         onExistingUsers: "skip",
         profiles: permissionsPayload.toImport.profiles,
         roles: permissionsPayload.toImport.roles,
-        userMappings: { something: "here" },
+        userMappings: userMappingsPayload,
         users: permissionsPayload.toImport.users,
       };
 
       toSupport = {
-        mappings: mappingsPayload.toSupport.mappings,
         fixtures: fixturesPayload.toSupport.fixtures,
+        mappings: mappingsPayload.toSupport.mappings,
         securities: permissionsPayload.toSupport.securities,
       };
 
@@ -576,5 +579,147 @@ describe("/lib/kuzzle/kuzzle.js", () => {
         ),
       ).be.rejectedWith({ id: "plugin.runtime.incompatible" });
     });
+
+    it("should ensure to persist hash of the importedPayload when nor Redis nor ES have a hash", async () => {
+      kuzzle.ask.withArgs("core:cache:internal:get").resolves(null);
+      kuzzle.ask
+        .withArgs("core:storage:private:document:exist")
+        .resolves(false);
+      kuzzle._waitForImportToFinish = sinon.stub().resolves();
+      kuzzle.persistHashedImport = sinon.stub().resolves();
+
+      await kuzzle.loadInitialState(toImport, {});
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: fixturesPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "fixtures",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: mappingsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "mappings",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: permissionsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "permissions",
+      });
+    });
+
+    it("should ensure to persist hash of the importedPayload when ES have a hash and not redis", async () => {
+      kuzzle.ask.withArgs("core:cache:internal:get").resolves(null);
+      kuzzle.ask.withArgs("core:storage:private:document:exist").resolves(true);
+      kuzzle.ask
+        .withArgs("core:storage:private:document:get")
+        .resolves({ _source: { hash: "123" } });
+      kuzzle._waitForImportToFinish = sinon.stub().resolves();
+      kuzzle.persistHashedImport = sinon.stub().resolves();
+
+      await kuzzle.loadInitialState(toImport, {});
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: true,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: fixturesPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "fixtures",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: true,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: mappingsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "mappings",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: true,
+        existingRedisHash: null,
+        importPayloadHash: sha256(
+          stringify({
+            toImport: permissionsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "permissions",
+      });
+    });
+
+    it("should ensure to persist hash of the importedPayload when Redis have a hash and not ES", async () => {
+      kuzzle.ask.withArgs("core:cache:internal:get").resolves("123");
+      kuzzle.ask
+        .withArgs("core:storage:private:document:exist")
+        .resolves(false);
+      kuzzle._waitForImportToFinish = sinon.stub().resolves();
+      kuzzle.persistHashedImport = sinon.stub().resolves();
+
+      await kuzzle.loadInitialState(toImport, {});
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: "123",
+        importPayloadHash: sha256(
+          stringify({
+            toImport: fixturesPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "fixtures",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: "123",
+        importPayloadHash: sha256(
+          stringify({
+            toImport: mappingsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "mappings",
+      });
+
+      should(kuzzle.persistHashedImport).calledWith({
+        existingESHash: false,
+        existingRedisHash: "123",
+        importPayloadHash: sha256(
+          stringify({
+            toImport: permissionsPayload.toImport,
+            toSupport: {},
+          }),
+        ),
+        type: "permissions",
+      });
+    });
   });
 });