@xube/kit-aws-hooks 0.0.33 → 0.0.34

package/dist/constants.d.ts

@@ -1 +1,2 @@
 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";

package/dist/constants.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEBHOOK_TABLE_NAME_ENV_VAR = void 0;
+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";

package/dist/create.js

@@ -15,6 +15,8 @@ const createWebhookForAccount = async (request, tableName, log = kit_log_1.XubeL
         });
     }
     const newWebhooks = (0, generate_1.generateWebhookItems)(request);
+    //TODO - These webhooks need to be added to the items if they already exist.
+    //For now they will just override any existing webhooks.
     const putWebhookItems = [];
     for (const webhook of newWebhooks) {
         putWebhookItems.push((0, kit_aws_1.putItemInTable)(tableName, webhook));

package/dist/generate.js

@@ -3,19 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateWebhookItems = void 0;
 const keys_1 = require("./keys");
 const types_1 = require("./types");
+const kit_aws_1 = require("@xube/kit-aws");
 const generateWebhookItems = (request) => {
-    const webhookItems = [];
+    const webhookItems = {};
     for (const endpoint of request.endpoints) {
         for (const id of request.ids) {
-            webhookItems.push({
-                account: request.account,
-                ...endpoint,
-                id,
+            const key = {
                 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);
+            if (!webhookItems[aggregateKey]) {
+                webhookItems[aggregateKey] = {
+                    account: request.account,
+                    endpoints: [endpoint],
+                    id,
+                    ...key,
+                };
+            }
+            else {
+                webhookItems[aggregateKey].endpoints.push(endpoint);
+            }
         }
     }
-    return webhookItems;
+    return Object.values(webhookItems);
 };
 exports.generateWebhookItems = generateWebhookItems;

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export * from "./create";
 export * from "./generate";
 export * from "./get";
 export * from "./keys";
+export * from "./send";
 export * from "./types";

package/dist/index.js

@@ -23,4 +23,5 @@ __exportStar(require("./create"), exports);
 __exportStar(require("./generate"), exports);
 __exportStar(require("./get"), exports);
 __exportStar(require("./keys"), exports);
+__exportStar(require("./send"), exports);
 __exportStar(require("./types"), exports);

package/dist/schemas/webhook.d.ts

@@ -1,55 +1,83 @@
 import { z } from "zod";
 export declare const WebhookEndpointSchema: z.ZodObject<{
-    url: z.ZodString;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    endpoints: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }>, "many">;
     id: z.ZodString;
     account: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
-    headers?: Record<string, string> | undefined;
 }, {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
-    headers?: Record<string, string> | undefined;
 }>;
 export type WebhookEndpoint = z.infer<typeof WebhookEndpointSchema>;
 export declare const isWebhookEndpoint: (obj: unknown) => obj is {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
-    headers?: Record<string, string> | undefined;
 };
 export declare const WebhookEndpointItemSchema: z.ZodObject<{
-    url: z.ZodString;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     account: z.ZodString;
+    endpoints: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }>, "many">;
+    id: z.ZodString;
     PK: z.ZodString;
     SK: z.ZodString;
-    id: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
     PK: string;
     SK: string;
-    headers?: Record<string, string> | undefined;
 }, {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
     PK: string;
     SK: string;
-    headers?: Record<string, string> | undefined;
 }>;
 export type WebhookEndpointItem = z.infer<typeof WebhookEndpointItemSchema>;
 export declare const isWebhookEndpointItem: (obj: unknown) => obj is {
-    url: string;
     account: string;
+    endpoints: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }[];
     id: string;
     PK: string;
     SK: string;
-    headers?: Record<string, string> | undefined;
 };

package/dist/schemas/webhook.js

@@ -5,8 +5,7 @@ const kit_aws_1 = require("@xube/kit-aws");
 const zod_1 = require("zod");
 const endpoint_1 = require("./endpoint");
 exports.WebhookEndpointSchema = zod_1.z.object({
-    url: zod_1.z.string(),
-    headers: endpoint_1.HookEndpointHeaderSchema.optional(),
+    endpoints: zod_1.z.array(endpoint_1.HookEndpointSchema),
     id: zod_1.z.string(),
     account: zod_1.z.string(),
 });

package/dist/send.d.ts

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

package/dist/send.js

@@ -0,0 +1,69 @@
+"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 sendDataToEndpoints = async (webhookTableName, indexName, items) => {
+    const endpointSends = [];
+    for (const item of items) {
+        const invertedWebhookKey = {
+            PK: (0, keys_1.getWebhookSortKey)(item.id, types_1.WebhookTypes.data),
+        };
+        const getWebhookEndpointsResponse = await (0, kit_aws_1.queryItemsFromTable)(webhookTableName, invertedWebhookKey, indexName);
+        if (getWebhookEndpointsResponse.hasFailed()) {
+            return getWebhookEndpointsResponse.switchXubeResponseType();
+        }
+        if (!getWebhookEndpointsResponse.data ||
+            !getWebhookEndpointsResponse.data.length) {
+            console.log(`No webhook endpoints found for webhook endpoint ${item.id} and type ${types_1.WebhookTypes.data}`);
+            continue;
+        }
+        const webhookEndpoints = getWebhookEndpointsResponse.data;
+        for (const webhookEndpoint of webhookEndpoints) {
+            if (!(0, webhook_1.isWebhookEndpoint)(webhookEndpoint)) {
+                console.log(`Webhook endpoint ${webhookEndpoint.id} is not a valid webhook endpoint`);
+                continue;
+            }
+            if (!webhookEndpoint.endpoints || !webhookEndpoint.endpoints.length) {
+                console.log(`No endpoints found for webhook endpoint ${webhookEndpoint.id}`);
+                continue;
+            }
+            for (const endpoint of webhookEndpoint.endpoints) {
+                endpointSends.push(fetch(endpoint.url, {
+                    body: JSON.stringify(item),
+                    headers: endpoint.headers,
+                    method: "POST",
+                }));
+            }
+        }
+    }
+    const responses = await Promise.all(endpointSends);
+    const failedEndpointSendUrls = [];
+    let failedResponseCount = 0;
+    for (const response of responses) {
+        if (!response.ok) {
+            failedEndpointSendUrls.push(response.url);
+            failedResponseCount++;
+        }
+    }
+    if (failedResponseCount == endpointSends.length) {
+        return new kit_request_1.XubeResponse({
+            statusCode: 500,
+            error: `Failed to send data to all endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
+        });
+    }
+    if (failedResponseCount) {
+        return new kit_request_1.XubeResponse({
+            statusCode: 207,
+            error: `Failed to send data to ${failedResponseCount} of ${endpointSends.length} endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
+        });
+    }
+    return new kit_request_1.XubeResponse({
+        statusCode: 200,
+        data: true,
+    });
+};
+exports.sendDataToEndpoints = sendDataToEndpoints;

package/package.json

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

package/src/constants.ts

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

package/src/create.ts

@@ -24,6 +24,9 @@ export const createWebhookForAccount = async (
 
   const newWebhooks: WebhookEndpointItem[] = generateWebhookItems(request);
 
+  //TODO - These webhooks need to be added to the items if they already exist.
+  //For now they will just override any existing webhooks.
+
   const putWebhookItems: Promise<XubeResponse<boolean>>[] = [];
   for (const webhook of newWebhooks) {
     putWebhookItems.push(putItemInTable(tableName, webhook));

package/src/generate.ts

@@ -2,23 +2,34 @@ import { getWebhookPartitionKey, getWebhookSortKey } from "./keys";
 import { CreateWebhookForAccountRequest } from "./schemas/create";
 import { WebhookEndpoint, WebhookEndpointItem } from "./schemas/webhook";
 import { WebhookTypes } from "./types";
+import { TableKey, getAggregateKeyFromTableKey } from "@xube/kit-aws";
 
 export const generateWebhookItems = (
   request: CreateWebhookForAccountRequest
 ): WebhookEndpointItem[] => {
-  const webhookItems: WebhookEndpointItem[] = [];
+  const webhookItems: Record<string, WebhookEndpointItem> = {};
 
   for (const endpoint of request.endpoints) {
     for (const id of request.ids) {
-      webhookItems.push({
-        account: request.account,
-        ...endpoint,
-        id,
+      const key: TableKey = {
         PK: getWebhookPartitionKey(request.account),
         SK: getWebhookSortKey(id, request.type ?? WebhookTypes.data),
-      });
+      };
+
+      const aggregateKey = getAggregateKeyFromTableKey(key);
+
+      if (!webhookItems[aggregateKey]) {
+        webhookItems[aggregateKey] = {
+          account: request.account,
+          endpoints: [endpoint],
+          id,
+          ...key,
+        };
+      } else {
+        webhookItems[aggregateKey].endpoints.push(endpoint);
+      }
     }
   }
 
-  return webhookItems;
+  return Object.values(webhookItems);
 };

package/src/index.ts

@@ -7,4 +7,5 @@ export * from "./create";
 export * from "./generate";
 export * from "./get";
 export * from "./keys";
+export * from "./send";
 export * from "./types";

package/src/schemas/webhook.ts

@@ -1,10 +1,9 @@
 import { TableItemSchema } from "@xube/kit-aws";
 import { z } from "zod";
-import { HookEndpointHeaderSchema } from "./endpoint";
+import { HookEndpointSchema } from "./endpoint";
 
 export const WebhookEndpointSchema = z.object({
-  url: z.string(),
-  headers: HookEndpointHeaderSchema.optional(),
+  endpoints: z.array(HookEndpointSchema),
   id: z.string(),
   account: z.string(),
 });

package/src/send.ts

@@ -0,0 +1,108 @@
+import {
+  PartialTableKey,
+  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";
+
+export const sendDataToEndpoints = async (
+  webhookTableName: string,
+  indexName: string,
+  items: TableItem[]
+): Promise<XubeResponse<boolean>> => {
+  const endpointSends: Promise<Response>[] = [];
+
+  for (const item of items) {
+    const invertedWebhookKey: PartialTableKey = {
+      PK: getWebhookSortKey(item.id, WebhookTypes.data),
+    };
+
+    const getWebhookEndpointsResponse = await queryItemsFromTable(
+      webhookTableName,
+      invertedWebhookKey,
+      indexName
+    );
+
+    if (getWebhookEndpointsResponse.hasFailed()) {
+      return getWebhookEndpointsResponse.switchXubeResponseType();
+    }
+
+    if (
+      !getWebhookEndpointsResponse.data ||
+      !getWebhookEndpointsResponse.data.length
+    ) {
+        console.log(
+            `No webhook endpoints found for webhook endpoint ${item.id} and type ${WebhookTypes.data}`
+        );
+      continue;
+    }
+
+    const webhookEndpoints: TableItem[] = getWebhookEndpointsResponse.data;
+
+    for (const webhookEndpoint of webhookEndpoints) {
+      if (!isWebhookEndpoint(webhookEndpoint)) {
+        console.log(
+          `Webhook endpoint ${webhookEndpoint.id} is not a valid webhook endpoint`
+        );
+        continue;
+      }
+
+      if (!webhookEndpoint.endpoints || !webhookEndpoint.endpoints.length) {
+        console.log(
+          `No endpoints found for webhook endpoint ${webhookEndpoint.id}`
+        );
+        continue;
+      }
+
+      for (const endpoint of webhookEndpoint.endpoints) {
+        endpointSends.push(
+          fetch(endpoint.url, {
+            body: JSON.stringify(item),
+            headers: endpoint.headers,
+            method: "POST",
+          })
+        );
+      }
+    }
+  }
+
+  const responses: Response[] = await Promise.all(endpointSends);
+
+  const failedEndpointSendUrls: string[] = [];
+  let failedResponseCount: number = 0;
+
+  for (const response of responses) {
+    if (!response.ok) {
+      failedEndpointSendUrls.push(response.url);
+      failedResponseCount++;
+    }
+  }
+
+  if (failedResponseCount == endpointSends.length) {
+    return new XubeResponse({
+      statusCode: 500,
+      error: `Failed to send data to all endpoints: ${JSON.stringify(
+        failedEndpointSendUrls,
+        null,
+        2
+      )}`,
+    });
+  }
+
+  if (failedResponseCount) {
+    return new XubeResponse({
+      statusCode: 207,
+      error: `Failed to send data to ${failedResponseCount} of ${
+        endpointSends.length
+      } endpoints: ${JSON.stringify(failedEndpointSendUrls, null, 2)}`,
+    });
+  }
+
+  return new XubeResponse({
+    statusCode: 200,
+    data: true,
+  });
+};