@xube/kit-aws-hooks 0.0.46 → 0.0.48

package/dist/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";
 export declare const WEBHOOK_TABLE_INVERTED_INDEX_NAME_ENV_VAR = "WEBHOOK_TABLE_INVERTED_INDEX_NAME";
+export declare const WEBHOOK_TYPE = "webhook";

package/dist/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEBHOOK_TABLE_INVERTED_INDEX_NAME_ENV_VAR = exports.WEBHOOK_TABLE_NAME_ENV_VAR = void 0;
+exports.WEBHOOK_TYPE = exports.WEBHOOK_TABLE_INVERTED_INDEX_NAME_ENV_VAR = exports.WEBHOOK_TABLE_NAME_ENV_VAR = void 0;
 exports.WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";
 exports.WEBHOOK_TABLE_INVERTED_INDEX_NAME_ENV_VAR = "WEBHOOK_TABLE_INVERTED_INDEX_NAME";
+exports.WEBHOOK_TYPE = "webhook";

package/dist/generate.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateWebhookItems = void 0;
+const kit_aws_schema_1 = require("@xube/kit-aws-schema");
 const keys_1 = require("./keys");
 const types_1 = require("./types");
-const kit_aws_1 = require("@xube/kit-aws");
+const constants_1 = require("./constants");
 const generateWebhookItems = (request) => {
     const webhookItems = {};
     for (const endpoint of request.endpoints) {
@@ -12,9 +13,13 @@ const generateWebhookItems = (request) => {
                 PK: (0, keys_1.getWebhookPartitionKey)(request.account),
                 SK: (0, keys_1.getWebhookSortKey)(id, request.type ?? types_1.WebhookTypes.data),
             };
-            const aggregateKey = (0, kit_aws_1.getAggregateKeyFromTableKey)(key);
+            const aggregateKey = (0, kit_aws_schema_1.getAggregateKeyFromTableKey)(key);
+            const time = new Date().getTime();
             if (!webhookItems[aggregateKey]) {
                 webhookItems[aggregateKey] = {
+                    s: time / 1000,
+                    us: time % 1000,
+                    type: constants_1.WEBHOOK_TYPE,
                     account: request.account,
                     endpoints: [endpoint],
                     id,

package/dist/schemas/webhook.d.ts

@@ -49,35 +49,47 @@ export declare const WebhookEndpointItemSchema: z.ZodObject<{
         headers?: Record<string, string> | undefined;
     }>, "many">;
     id: z.ZodString;
+    type: z.ZodString;
+    s: z.ZodNumber;
+    us: z.ZodOptional<z.ZodNumber>;
     PK: z.ZodString;
     SK: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    type: string;
     account: string;
     endpoints: {
         url: string;
         headers?: Record<string, string> | undefined;
     }[];
     id: string;
+    s: number;
     PK: string;
     SK: string;
+    us?: number | undefined;
 }, {
+    type: string;
     account: string;
     endpoints: {
         url: string;
         headers?: Record<string, string> | undefined;
     }[];
     id: string;
+    s: number;
     PK: string;
     SK: string;
+    us?: number | undefined;
 }>;
 export type WebhookEndpointItem = z.infer<typeof WebhookEndpointItemSchema>;
 export declare const isWebhookEndpointItem: (obj: unknown) => obj is {
+    type: string;
     account: string;
     endpoints: {
         url: string;
         headers?: Record<string, string> | undefined;
     }[];
     id: string;
+    s: number;
     PK: string;
     SK: string;
+    us?: number | undefined;
 };

package/dist/schemas/webhook.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isWebhookEndpointItem = exports.WebhookEndpointItemSchema = exports.isWebhookEndpoint = exports.WebhookEndpointSchema = void 0;
-const kit_aws_1 = require("@xube/kit-aws");
 const zod_1 = require("zod");
 const endpoint_1 = require("./endpoint");
+const kit_aws_schema_1 = require("@xube/kit-aws-schema");
 exports.WebhookEndpointSchema = zod_1.z.object({
     endpoints: zod_1.z.array(endpoint_1.HookEndpointSchema),
     id: zod_1.z.string(),
@@ -11,6 +11,6 @@ exports.WebhookEndpointSchema = zod_1.z.object({
 });
 const isWebhookEndpoint = (obj) => exports.WebhookEndpointSchema.safeParse(obj).success;
 exports.isWebhookEndpoint = isWebhookEndpoint;
-exports.WebhookEndpointItemSchema = exports.WebhookEndpointSchema.merge(kit_aws_1.TableItemSchema);
+exports.WebhookEndpointItemSchema = exports.WebhookEndpointSchema.merge(kit_aws_schema_1.TableItemSchema);
 const isWebhookEndpointItem = (obj) => exports.WebhookEndpointItemSchema.safeParse(obj).success;
 exports.isWebhookEndpointItem = isWebhookEndpointItem;

package/dist/send.d.ts

@@ -1,4 +1,4 @@
-import { TableItem } from "@xube/kit-aws";
 import { XubeResponse } from "@xube/kit-request";
 import { XubeLog } from "@xube/kit-log";
+import { TableItem } from "@xube/kit-aws-schema";
 export declare const sendDataToEndpoints: (webhookTableName: string, indexName: string, items: TableItem[], log?: XubeLog) => Promise<XubeResponse<boolean>>;

package/dist/send.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDataToEndpoints = void 0;
-const kit_aws_1 = require("@xube/kit-aws");
 const keys_1 = require("./keys");
 const types_1 = require("./types");
 const kit_request_1 = require("@xube/kit-request");
 const webhook_1 = require("./schemas/webhook");
 const kit_constants_1 = require("@xube/kit-constants");
 const kit_log_1 = require("@xube/kit-log");
+const kit_aws_1 = require("@xube/kit-aws");
+const kit_aws_schema_1 = require("@xube/kit-aws-schema");
+const transform_1 = require("./transform");
 const sendDataToEndpoints = async (webhookTableName, indexName, items, log = kit_log_1.XubeLog.getInstance()) => {
     const endpointSends = [];
     log.info(`Sending data to endpoints based on ${items.length} items.}`);
@@ -17,7 +19,7 @@ const sendDataToEndpoints = async (webhookTableName, indexName, items, log = kit
         };
         log.info(`Searching for webhooks with key: ${JSON.stringify(invertedWebhookKey)}`);
         const getWebhookEndpointsResponse = await (0, kit_aws_1.queryItemsFromTable)(webhookTableName, invertedWebhookKey, indexName, {
-            partitionKey: kit_aws_1.SORT_KEY,
+            partitionKey: kit_aws_schema_1.SORT_KEY,
         });
         if (getWebhookEndpointsResponse.hasFailed()) {
             log.error(`Failed to get webhook endpoints for webhook endpoint ${item.id} and type ${types_1.WebhookTypes.data}`);
@@ -31,6 +33,8 @@ const sendDataToEndpoints = async (webhookTableName, indexName, items, log = kit
         }
         log.info(`Found webhook endpoint ${JSON.stringify(invertedWebhookKey)} for id: ${item.id}`);
         const webhookEndpoints = getWebhookEndpointsResponse.data;
+        log.info(`Found ${webhookEndpoints.length} webhook endpoints.`);
+        log.info(`Webhook endpoints: ${JSON.stringify(webhookEndpoints, null, 2)}`);
         for (const webhookEndpoint of webhookEndpoints) {
             if (!(0, webhook_1.isWebhookEndpoint)(webhookEndpoint)) {
                 console.log(`Webhook endpoint ${webhookEndpoint.id} is not a valid webhook endpoint`);
@@ -41,9 +45,10 @@ const sendDataToEndpoints = async (webhookTableName, indexName, items, log = kit
                 continue;
             }
             log.info(`Preparing to send data to endpoints: ${JSON.stringify(webhookEndpoint.endpoints, null, 2)}`);
+            const timeSeries = (0, transform_1.getTimeSeriesDataFromData)(items);
             for (const endpoint of webhookEndpoint.endpoints) {
                 endpointSends.push(fetch(endpoint.url, {
-                    body: JSON.stringify(item),
+                    body: JSON.stringify(timeSeries),
                     headers: endpoint.headers,
                     method: "POST",
                 }));
@@ -62,19 +67,19 @@ const sendDataToEndpoints = async (webhookTableName, indexName, items, log = kit
         }
         if (failedResponseCount == endpointSends.length) {
             return new kit_request_1.XubeResponse({
-                statusCode: 500,
+                statusCode: kit_constants_1.StatusCode.InternalError,
                 error: `Failed to send data to all endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
             });
         }
         if (failedResponseCount) {
             return new kit_request_1.XubeResponse({
-                statusCode: 207,
+                statusCode: kit_constants_1.StatusCode.PartialSuccess,
                 error: `Failed to send data to ${failedResponseCount} of ${endpointSends.length} endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
             });
         }
         log.info(`Successfully sent data to all endpoints.`);
         return new kit_request_1.XubeResponse({
-            statusCode: 200,
+            statusCode: kit_constants_1.StatusCode.OK,
             data: true,
         });
     }

package/dist/transform.d.ts

@@ -0,0 +1,18 @@
+import { TableItem } from "@xube/kit-aws-schema";
+export declare const stageDataForSend: (items: TableItem[]) => void;
+export declare const getTimeSeriesDataFromData: (items: TableItem[]) => {
+    data: (string | number | boolean | import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">)[];
+    m: {
+        id: string;
+        trigger: "data" | "event";
+        source: "device" | "component" | "platform";
+    };
+    v: string;
+    t0: string;
+    dtt: "s" | "us" | "ms" | "m" | "h" | "d";
+    dt: number;
+    dataT?: import("zod").objectOutputType<{
+        i: import("zod").ZodNumber;
+        dt: import("zod").ZodNumber;
+    }, import("zod").ZodTypeAny, "passthrough">[] | undefined;
+}[];

package/dist/transform.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeSeriesDataFromData = exports.stageDataForSend = void 0;
+const kit_data_schema_1 = require("@xube/kit-data-schema");
+const kit_data_schema_2 = require("@xube/kit-data-schema");
+const stageDataForSend = (items) => {
+    const timeSeries = (0, exports.getTimeSeriesDataFromData)(items);
+};
+exports.stageDataForSend = stageDataForSend;
+const getTimeSeriesDataFromData = (items) => {
+    const timeSeriesEntriesById = {};
+    const previousMicroSecondsSinceEpochById = {};
+    for (const item of items) {
+        if (!(0, kit_data_schema_1.isReadingV1)(item)) {
+            console.log(`${item.type} is not a currently supported type.`);
+            continue;
+        }
+        const microsSinceEpoch = microsecondsSinceEpoch(item.s, item?.us ?? 0);
+        if (!timeSeriesEntriesById[item.id]) {
+            timeSeriesEntriesById[item.id] = {
+                v: "1",
+                m: {
+                    id: item.id,
+                    trigger: kit_data_schema_2.DATA_TYPE,
+                    source: "device",
+                },
+                t0: isoDateTimeWithMicroseconds(microsSinceEpoch),
+                dtt: "ms",
+                dt: 0,
+                dataT: [],
+                data: [item.data],
+            };
+        }
+        else {
+            const timeSeriesEntry = timeSeriesEntriesById[item.id];
+            timeSeriesEntry.data.push(item.data);
+            const timeDifference = Math.floor((microsSinceEpoch - previousMicroSecondsSinceEpochById?.[item.id]) /
+                getDivisorByTimeUnit(timeSeriesEntry.dtt));
+            if (timeDifference !== timeSeriesEntry.dt) {
+                if (!timeSeriesEntry.dataT) {
+                    timeSeriesEntry.dataT = [];
+                }
+                else {
+                    timeSeriesEntry.dataT.push({
+                        i: timeSeriesEntry.data.length - 1,
+                        dt: microsSinceEpoch - previousMicroSecondsSinceEpochById?.[item.id],
+                    });
+                }
+            }
+        }
+        previousMicroSecondsSinceEpochById[item.id] = microsSinceEpoch;
+    }
+    return Object.values(timeSeriesEntriesById);
+};
+exports.getTimeSeriesDataFromData = getTimeSeriesDataFromData;
+function getDivisorByTimeUnit(timeUnit) {
+    switch (timeUnit) {
+        case "us":
+            return 1;
+        case "ms":
+            return 1000;
+        case "s":
+            return 1000000;
+        case "m":
+            return 60000000;
+        case "h":
+            return 3600000000;
+        case "d":
+            return 86400000000;
+        default:
+            throw new Error("Invalid time unit");
+    }
+}
+function microsecondsSinceEpoch(s, us) {
+    return s * 1000000 + us;
+}
+function isoDateTimeWithMicroseconds(microsecondsSinceEpoch) {
+    const milliseconds = Math.floor(microsecondsSinceEpoch / 1000);
+    const microseconds = microsecondsSinceEpoch % 1000;
+    const date = new Date(milliseconds);
+    const year = date.getUTCFullYear();
+    const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+    const day = date.getUTCDate().toString().padStart(2, "0");
+    const hours = date.getUTCHours().toString().padStart(2, "0");
+    const minutes = date.getUTCMinutes().toString().padStart(2, "0");
+    const seconds = date.getUTCSeconds().toString().padStart(2, "0");
+    const millisecondsStr = date
+        .getUTCMilliseconds()
+        .toString()
+        .padStart(3, "0");
+    const microsecondsStr = microseconds.toString().padStart(3, "0");
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${millisecondsStr}${microsecondsStr}Z`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xube/kit-aws-hooks",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -17,12 +17,15 @@
   },
   "homepage": "https://github.com/XubeLtd/dev-kit#readme",
   "devDependencies": {
-    "@xube/kit-build": "^0.0.46"
+    "@xube/kit-build": "^0.0.48"
   },
   "dependencies": {
-    "@xube/kit-aws": "^0.0.46",
-    "@xube/kit-log": "^0.0.46",
-    "@xube/kit-request": "^0.0.46",
+    "@xube/kit-aws": "^0.0.48",
+    "@xube/kit-aws-schema": "^0.0.48",
+    "@xube/kit-data-schema": "^0.0.48",
+    "@xube/kit-log": "^0.0.48",
+    "@xube/kit-request": "^0.0.48",
+    "@xube/kit-schema": "^0.0.48",
     "zod": "^3.22.4"
   }
 }

package/src/constants.ts

@@ -1,3 +1,5 @@
 export const WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";
 export const WEBHOOK_TABLE_INVERTED_INDEX_NAME_ENV_VAR =
   "WEBHOOK_TABLE_INVERTED_INDEX_NAME";
+
+export const WEBHOOK_TYPE = "webhook";

package/src/generate.ts

@@ -1,8 +1,9 @@
+import { TableKey, getAggregateKeyFromTableKey } from "@xube/kit-aws-schema";
 import { getWebhookPartitionKey, getWebhookSortKey } from "./keys";
 import { CreateWebhookForAccountRequest } from "./schemas/create";
-import { WebhookEndpoint, WebhookEndpointItem } from "./schemas/webhook";
+import { WebhookEndpointItem } from "./schemas/webhook";
 import { WebhookTypes } from "./types";
-import { TableKey, getAggregateKeyFromTableKey } from "@xube/kit-aws";
+import { WEBHOOK_TYPE } from "./constants";
 
 export const generateWebhookItems = (
   request: CreateWebhookForAccountRequest
@@ -18,11 +19,17 @@ export const generateWebhookItems = (
 
       const aggregateKey = getAggregateKeyFromTableKey(key);
 
+      const time = new Date().getTime();
+
       if (!webhookItems[aggregateKey]) {
         webhookItems[aggregateKey] = {
+          s: time / 1000,
+          us: time % 1000,
+          type: WEBHOOK_TYPE,
           account: request.account,
           endpoints: [endpoint],
           id,
+
           ...key,
         };
       } else {

package/src/schemas/webhook.ts

@@ -1,6 +1,6 @@
-import { TableItemSchema } from "@xube/kit-aws";
 import { z } from "zod";
 import { HookEndpointSchema } from "./endpoint";
+import { TableItemSchema } from "@xube/kit-aws-schema";
 
 export const WebhookEndpointSchema = z.object({
   endpoints: z.array(HookEndpointSchema),

package/src/send.ts

@@ -1,10 +1,14 @@
-import { PARTITION_KEY, PartialTableKey, SORT_KEY, TableItem, queryItemsFromTable } from "@xube/kit-aws";
 import { getWebhookSortKey } from "./keys";
 import { WebhookTypes } from "./types";
 import { XubeResponse } from "@xube/kit-request";
 import { isWebhookEndpoint } from "./schemas/webhook";
 import { StatusCode } from "@xube/kit-constants";
 import { XubeLog } from "@xube/kit-log";
+import { TableItem } from "@xube/kit-aws-schema";
+import { PartialTableKey } from "@xube/kit-aws-schema";
+import { queryItemsFromTable } from "@xube/kit-aws";
+import { SORT_KEY } from "@xube/kit-aws-schema";
+import { getTimeSeriesDataFromData } from "./transform";
 
 export const sendDataToEndpoints = async (
   webhookTableName: string,
@@ -60,6 +64,9 @@ export const sendDataToEndpoints = async (
 
     const webhookEndpoints: TableItem[] = getWebhookEndpointsResponse.data;
 
+    log.info(`Found ${webhookEndpoints.length} webhook endpoints.`);
+    log.info(`Webhook endpoints: ${JSON.stringify(webhookEndpoints, null, 2)}`);
+
     for (const webhookEndpoint of webhookEndpoints) {
       if (!isWebhookEndpoint(webhookEndpoint)) {
         console.log(
@@ -83,10 +90,12 @@ export const sendDataToEndpoints = async (
         )}`
       );
 
+      const timeSeries = getTimeSeriesDataFromData(items);
+
       for (const endpoint of webhookEndpoint.endpoints) {
         endpointSends.push(
           fetch(endpoint.url, {
-            body: JSON.stringify(item),
+            body: JSON.stringify(timeSeries),
             headers: endpoint.headers,
             method: "POST",
           })
@@ -110,7 +119,7 @@ export const sendDataToEndpoints = async (
 
     if (failedResponseCount == endpointSends.length) {
       return new XubeResponse({
-        statusCode: 500,
+        statusCode: StatusCode.InternalError,
         error: `Failed to send data to all endpoints: ${JSON.stringify(
           failedEndpointSendUrls,
           null,
@@ -121,7 +130,7 @@ export const sendDataToEndpoints = async (
 
     if (failedResponseCount) {
       return new XubeResponse({
-        statusCode: 207,
+        statusCode: StatusCode.PartialSuccess,
         error: `Failed to send data to ${failedResponseCount} of ${
           endpointSends.length
         } endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
@@ -131,7 +140,7 @@ export const sendDataToEndpoints = async (
     log.info(`Successfully sent data to all endpoints.`);
 
     return new XubeResponse({
-      statusCode: 200,
+      statusCode: StatusCode.OK,
       data: true,
     });
   } catch (e) {

package/src/transform.ts

@@ -0,0 +1,107 @@
+import { TableItem } from "@xube/kit-aws-schema";
+import { isReadingV1 } from "@xube/kit-data-schema";
+import { DATA_TYPE } from "@xube/kit-data-schema";
+import { TimeSeries, TimeSeriesEntry, TimeUnit } from "@xube/kit-schema";
+
+export const stageDataForSend = (items: TableItem[]) => {
+  const timeSeries = getTimeSeriesDataFromData(items);
+};
+
+export const getTimeSeriesDataFromData = (items: TableItem[]): TimeSeries => {
+  const timeSeriesEntriesById: Record<string, TimeSeriesEntry> = {};
+  const previousMicroSecondsSinceEpochById: Record<string, number> = {};
+
+  for (const item of items) {
+    if (!isReadingV1(item)) {
+      console.log(`${item.type} is not a currently supported type.`);
+      continue;
+    }
+
+    const microsSinceEpoch = microsecondsSinceEpoch(item.s, item?.us ?? 0);
+
+    if (!timeSeriesEntriesById[item.id]) {
+      timeSeriesEntriesById[item.id] = {
+        v: "1",
+        m: {
+          id: item.id,
+          trigger: DATA_TYPE,
+          source: "device",
+        },
+        t0: isoDateTimeWithMicroseconds(microsSinceEpoch),
+        dtt: "ms",
+        dt: 0,
+        dataT: [],
+        data: [item.data],
+      };
+    } else {
+      const timeSeriesEntry = timeSeriesEntriesById[item.id];
+
+      timeSeriesEntry.data.push(item.data);
+
+      const timeDifference = Math.floor(
+        (microsSinceEpoch - previousMicroSecondsSinceEpochById?.[item.id]) /
+          getDivisorByTimeUnit(timeSeriesEntry.dtt)
+      );
+
+      if (timeDifference !== timeSeriesEntry.dt) {
+        if (!timeSeriesEntry.dataT) {
+          timeSeriesEntry.dataT = [];
+        } else {
+          timeSeriesEntry.dataT.push({
+            i: timeSeriesEntry.data.length - 1,
+            dt:
+              microsSinceEpoch - previousMicroSecondsSinceEpochById?.[item.id],
+          });
+        }
+      }
+    }
+
+    previousMicroSecondsSinceEpochById[item.id] = microsSinceEpoch;
+  }
+
+  return Object.values(timeSeriesEntriesById);
+};
+
+function getDivisorByTimeUnit(timeUnit: TimeUnit): number {
+  switch (timeUnit) {
+    case "us":
+      return 1;
+    case "ms":
+      return 1000;
+    case "s":
+      return 1000000;
+    case "m":
+      return 60000000;
+    case "h":
+      return 3600000000;
+    case "d":
+      return 86400000000;
+    default:
+      throw new Error("Invalid time unit");
+  }
+}
+
+function microsecondsSinceEpoch(s: number, us: number): number {
+  return s * 1000000 + us;
+}
+
+function isoDateTimeWithMicroseconds(microsecondsSinceEpoch: number): string {
+  const milliseconds = Math.floor(microsecondsSinceEpoch / 1000);
+  const microseconds = microsecondsSinceEpoch % 1000;
+
+  const date = new Date(milliseconds);
+
+  const year: number = date.getUTCFullYear();
+  const month: string = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+  const day: string = date.getUTCDate().toString().padStart(2, "0");
+  const hours: string = date.getUTCHours().toString().padStart(2, "0");
+  const minutes: string = date.getUTCMinutes().toString().padStart(2, "0");
+  const seconds: string = date.getUTCSeconds().toString().padStart(2, "0");
+  const millisecondsStr: string = date
+    .getUTCMilliseconds()
+    .toString()
+    .padStart(3, "0");
+  const microsecondsStr: string = microseconds.toString().padStart(3, "0");
+
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${millisecondsStr}${microsecondsStr}Z`;
+}

package/tsconfig.json

@@ -13,10 +13,19 @@
       "path": "../kit-log"
     },
     {
-      "path": "../kit-request"
+      "path": "../kit-schema"
+    },
+    {
+      "path": "../kit-aws-schema"
+    },
+    {
+      "path": "../kit-data-schema"
     },
     {
       "path": "../kit-aws"
+    },
+    {
+      "path": "../kit-request"
     }
   ]
 }