@xube/kit-aws-hooks 0.0.22

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBHOOK_TABLE_NAME_ENV_VAR = void 0;
+exports.WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";

package/dist/create.d.ts

@@ -0,0 +1,4 @@
+import { CreateWebhookForAccountRequest, CreateWebhookForAccountResponse } from "./schemas/create";
+import { XubeResponse } from "@xube/kit-request";
+import { XubeLog } from "@xube/kit-log";
+export declare const createWebhookForAccount: (request: CreateWebhookForAccountRequest, tableName: string, log?: XubeLog) => Promise<XubeResponse<CreateWebhookForAccountResponse>>;

package/dist/create.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookForAccount = void 0;
+const create_1 = require("./schemas/create");
+const kit_request_1 = require("@xube/kit-request");
+const kit_constants_1 = require("@xube/kit-constants");
+const generate_1 = require("./generate");
+const kit_aws_1 = require("@xube/kit-aws");
+const kit_log_1 = require("@xube/kit-log");
+const createWebhookForAccount = async (request, tableName, log = kit_log_1.XubeLog.getInstance()) => {
+    if (!(0, create_1.isCreateWebhookForAccountRequest)(request)) {
+        return new kit_request_1.XubeResponse({
+            statusCode: kit_constants_1.StatusCode.BadRequest,
+            error: `Webhook creation request did not have the expected structure.`,
+        });
+    }
+    const newWebhooks = (0, generate_1.generateWebhookItems)(request);
+    const putWebhookItems = [];
+    for (const webhook of newWebhooks) {
+        putWebhookItems.push((0, kit_aws_1.putItemInTable)(tableName, webhook));
+    }
+    const putItemResponses = await Promise.all(putWebhookItems);
+    const failedWebhooks = [];
+    const failedResponses = putItemResponses.filter((response, idx) => {
+        failedWebhooks.push(newWebhooks[idx]);
+        return response.hasFailed();
+    });
+    if (failedResponses.length) {
+        log.error(`Failed to save ${failedResponses} out or ${newWebhooks.length} to ddb.`);
+        log.info(`Failed webhooks: ${JSON.stringify(failedWebhooks, null, 2)}`);
+        return new kit_request_1.XubeResponse({
+            statusCode: failedResponses.length === newWebhooks.length
+                ? kit_constants_1.StatusCode.InternalError
+                : kit_constants_1.StatusCode.PartialSuccess,
+            error: `Failed to save the following webhooks to ddb:\n${JSON.stringify(failedWebhooks, null, 2)}`,
+        });
+    }
+    return new kit_request_1.XubeResponse({
+        statusCode: kit_constants_1.StatusCode.OK,
+        data: {
+            success: true,
+        },
+    });
+};
+exports.createWebhookForAccount = createWebhookForAccount;

package/dist/delete.js

@@ -0,0 +1 @@
+"use strict";

package/dist/generate.d.ts

@@ -0,0 +1,3 @@
+import { CreateWebhookForAccountRequest } from "./schemas/create";
+import { WebhookEndpointItem } from "./schemas/webhook";
+export declare const generateWebhookItems: (request: CreateWebhookForAccountRequest) => WebhookEndpointItem[];

package/dist/generate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWebhookItems = void 0;
+const keys_1 = require("./keys");
+const types_1 = require("./types");
+const generateWebhookItems = (request) => {
+    const webhookItems = [];
+    for (const endpoint of request.endpoints) {
+        for (const id of request.ids) {
+            webhookItems.push({
+                account: request.account,
+                ...endpoint,
+                id,
+                PK: (0, keys_1.getWebhookPartitionKey)(request.account),
+                SK: (0, keys_1.getWebhookSortKey)(id, request.type ?? types_1.WebhookTypes.data),
+            });
+        }
+    }
+    return webhookItems;
+};
+exports.generateWebhookItems = generateWebhookItems;

package/dist/get.d.ts

@@ -0,0 +1 @@
+export declare const getWebhooks: () => void;

package/dist/get.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebhooks = void 0;
+const getWebhooks = () => {
+};
+exports.getWebhooks = getWebhooks;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./schemas/create";
+export * from "./schemas/endpoint";
+export * from "./schemas/webhook";
+export * from "./constants";
+export * from "./create";
+export * from "./generate";
+export * from "./get";
+export * from "./keys";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas/create"), exports);
+__exportStar(require("./schemas/endpoint"), exports);
+__exportStar(require("./schemas/webhook"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./create"), exports);
+// export * from "./delete";
+__exportStar(require("./generate"), exports);
+__exportStar(require("./get"), exports);
+__exportStar(require("./keys"), exports);
+__exportStar(require("./types"), exports);

package/dist/keys.d.ts

@@ -0,0 +1,2 @@
+export declare const getWebhookPartitionKey: (account: string) => string;
+export declare const getWebhookSortKey: (id: string, type: string) => string;

package/dist/keys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebhookSortKey = exports.getWebhookPartitionKey = void 0;
+const getWebhookPartitionKey = (account) => {
+    return `ACCOUNT#${account}`;
+};
+exports.getWebhookPartitionKey = getWebhookPartitionKey;
+const getWebhookSortKey = (id, type) => {
+    return `HOOK#${id}#${type}`;
+};
+exports.getWebhookSortKey = getWebhookSortKey;

package/dist/schemas/create.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const CreateWebhookForAccountRequestSchema: z.ZodObject<{
+    account: z.ZodString;
+    ids: z.ZodArray<z.ZodString, "many">;
+    endpoints: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers: Record<string, string>;
+    }, {
+        url: string;
+        headers: Record<string, string>;
+    }>, "many">;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    type: z.ZodOptional<z.ZodNativeEnum<{
+        readonly data: "data";
+        readonly event: "event";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    headers: Record<string, string>;
+    account: string;
+    ids: string[];
+    endpoints: {
+        url: string;
+        headers: Record<string, string>;
+    }[];
+    type?: "data" | "event" | undefined;
+}, {
+    headers: Record<string, string>;
+    account: string;
+    ids: string[];
+    endpoints: {
+        url: string;
+        headers: Record<string, string>;
+    }[];
+    type?: "data" | "event" | undefined;
+}>;
+export type CreateWebhookForAccountRequest = z.infer<typeof CreateWebhookForAccountRequestSchema>;
+export declare const isCreateWebhookForAccountRequest: (obj: unknown) => obj is {
+    headers: Record<string, string>;
+    account: string;
+    ids: string[];
+    endpoints: {
+        url: string;
+        headers: Record<string, string>;
+    }[];
+    type?: "data" | "event" | undefined;
+};
+export declare const CreateWebhookForAccountResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+}, {
+    success: boolean;
+}>;
+export type CreateWebhookForAccountResponse = z.infer<typeof CreateWebhookForAccountResponseSchema>;
+export declare const CreateWebhookRequestSchema: z.ZodObject<{
+    ids: z.ZodString;
+    endpoints: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers: Record<string, string>;
+    }, {
+        url: string;
+        headers: Record<string, string>;
+    }>, "many">;
+    headers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">;
+}, "strip", z.ZodTypeAny, {
+    headers: Record<string, string>[];
+    ids: string;
+    endpoints: {
+        url: string;
+        headers: Record<string, string>;
+    }[];
+}, {
+    headers: Record<string, string>[];
+    ids: string;
+    endpoints: {
+        url: string;
+        headers: Record<string, string>;
+    }[];
+}>;
+export declare const CreateWebhookResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+}, {
+    success: boolean;
+}>;
+export type CreateWebhookResponse = z.infer<typeof CreateWebhookResponseSchema>;

package/dist/schemas/create.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateWebhookResponseSchema = exports.CreateWebhookRequestSchema = exports.CreateWebhookForAccountResponseSchema = exports.isCreateWebhookForAccountRequest = exports.CreateWebhookForAccountRequestSchema = void 0;
+const zod_1 = require("zod");
+const endpoint_1 = require("./endpoint");
+const types_1 = require("../types");
+exports.CreateWebhookForAccountRequestSchema = zod_1.z.object({
+    account: zod_1.z.string(),
+    ids: zod_1.z.array(zod_1.z.string()),
+    endpoints: zod_1.z.array(endpoint_1.HookEndpointSchema),
+    headers: endpoint_1.HookEndpointHeaderSchema,
+    type: types_1.WebhookTypesSchema.optional(),
+});
+const isCreateWebhookForAccountRequest = (obj) => {
+    exports.CreateWebhookForAccountRequestSchema.parse(obj);
+    return true;
+};
+exports.isCreateWebhookForAccountRequest = isCreateWebhookForAccountRequest;
+exports.CreateWebhookForAccountResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+});
+exports.CreateWebhookRequestSchema = zod_1.z.object({
+    ids: zod_1.z.string(),
+    endpoints: zod_1.z.array(endpoint_1.HookEndpointSchema),
+    headers: zod_1.z.array(endpoint_1.HookEndpointHeaderSchema),
+});
+exports.CreateWebhookResponseSchema = exports.CreateWebhookForAccountResponseSchema;

package/dist/schemas/endpoint.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const HookEndpointHeaderSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type HookEndpointHeader = z.infer<typeof HookEndpointHeaderSchema>;
+export declare const HookEndpointSchema: z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    headers: Record<string, string>;
+}, {
+    url: string;
+    headers: Record<string, string>;
+}>;
+export type HookEndpoint = z.infer<typeof HookEndpointSchema>;

package/dist/schemas/endpoint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookEndpointSchema = exports.HookEndpointHeaderSchema = void 0;
+const zod_1 = require("zod");
+exports.HookEndpointHeaderSchema = zod_1.z.record(zod_1.z.string());
+exports.HookEndpointSchema = zod_1.z.object({
+    url: zod_1.z.string().url(),
+    headers: exports.HookEndpointHeaderSchema,
+});

package/dist/schemas/webhook.d.ts

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

package/dist/schemas/webhook.js

@@ -0,0 +1,17 @@
+"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");
+exports.WebhookEndpointSchema = zod_1.z.object({
+    url: zod_1.z.string(),
+    headers: endpoint_1.HookEndpointHeaderSchema,
+    id: zod_1.z.string(),
+    account: zod_1.z.string(),
+});
+const isWebhookEndpoint = (obj) => exports.WebhookEndpointSchema.safeParse(obj).success;
+exports.isWebhookEndpoint = isWebhookEndpoint;
+exports.WebhookEndpointItemSchema = exports.WebhookEndpointSchema.merge(kit_aws_1.TableItemSchema);
+const isWebhookEndpointItem = (obj) => exports.WebhookEndpointItemSchema.safeParse(obj).success;
+exports.isWebhookEndpointItem = isWebhookEndpointItem;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const WebhookTypes: {
+    readonly data: "data";
+    readonly event: "event";
+};
+export declare const WebhookTypesSchema: z.ZodNativeEnum<{
+    readonly data: "data";
+    readonly event: "event";
+}>;
+export type WebhookType = z.infer<typeof WebhookTypesSchema>;

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookTypesSchema = exports.WebhookTypes = void 0;
+const zod_1 = require("zod");
+exports.WebhookTypes = {
+    data: "data",
+    event: "event",
+};
+exports.WebhookTypesSchema = zod_1.z.nativeEnum(exports.WebhookTypes);

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@xube/kit-aws-hooks",
+  "version": "0.0.22",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/XubeLtd/dev-kit.git"
+  },
+  "author": "Xube Pty Ltd",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/XubeLtd/dev-kit/issues"
+  },
+  "homepage": "https://github.com/XubeLtd/dev-kit#readme",
+  "devDependencies": {
+    "@xube/kit-build": "^0.0.22"
+  },
+  "dependencies": {
+    "@xube/kit-aws": "^0.0.22",
+    "@xube/kit-log": "^0.0.22",
+    "@xube/kit-request": "^0.0.22",
+    "zod": "^3.22.4"
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const WEBHOOK_TABLE_NAME_ENV_VAR = "WEBHOOK_TABLE_NAME";

package/src/create.ts

@@ -0,0 +1,64 @@
+import {
+  CreateWebhookForAccountRequest,
+  CreateWebhookForAccountResponse,
+  isCreateWebhookForAccountRequest,
+} from "./schemas/create";
+import { XubeResponse } from "@xube/kit-request";
+import { StatusCode } from "@xube/kit-constants";
+import { generateWebhookItems } from "./generate";
+import { putItemInTable } from "@xube/kit-aws";
+import { XubeLog } from "@xube/kit-log";
+import { WebhookEndpointItem } from "./schemas/webhook";
+
+export const createWebhookForAccount = async (
+  request: CreateWebhookForAccountRequest,
+  tableName: string,
+  log: XubeLog = XubeLog.getInstance()
+): Promise<XubeResponse<CreateWebhookForAccountResponse>> => {
+  if (!isCreateWebhookForAccountRequest(request)) {
+    return new XubeResponse({
+      statusCode: StatusCode.BadRequest,
+      error: `Webhook creation request did not have the expected structure.`,
+    });
+  }
+
+  const newWebhooks: WebhookEndpointItem[] = generateWebhookItems(request);
+
+  const putWebhookItems: Promise<XubeResponse<boolean>>[] = [];
+  for (const webhook of newWebhooks) {
+    putWebhookItems.push(putItemInTable(tableName, webhook));
+  }
+  const putItemResponses = await Promise.all(putWebhookItems);
+
+  const failedWebhooks: WebhookEndpointItem[] = [];
+
+  const failedResponses = putItemResponses.filter((response, idx) => {
+    failedWebhooks.push(newWebhooks[idx]);
+    return response.hasFailed();
+  });
+
+  if (failedResponses.length) {
+    log.error(
+      `Failed to save ${failedResponses} out or ${newWebhooks.length} to ddb.`
+    );
+    log.info(`Failed webhooks: ${JSON.stringify(failedWebhooks, null, 2)}`);
+    return new XubeResponse({
+      statusCode:
+        failedResponses.length === newWebhooks.length
+          ? StatusCode.InternalError
+          : StatusCode.PartialSuccess,
+      error: `Failed to save the following webhooks to ddb:\n${JSON.stringify(
+        failedWebhooks,
+        null,
+        2
+      )}`,
+    });
+  }
+
+  return new XubeResponse({
+    statusCode: StatusCode.OK,
+    data: {
+      success: true,
+    },
+  });
+};

package/src/generate.ts

@@ -0,0 +1,24 @@
+import { getWebhookPartitionKey, getWebhookSortKey } from "./keys";
+import { CreateWebhookForAccountRequest } from "./schemas/create";
+import { WebhookEndpoint, WebhookEndpointItem } from "./schemas/webhook";
+import { WebhookTypes } from "./types";
+
+export const generateWebhookItems = (
+  request: CreateWebhookForAccountRequest
+): WebhookEndpointItem[] => {
+  const webhookItems: WebhookEndpointItem[] = [];
+
+  for (const endpoint of request.endpoints) {
+    for (const id of request.ids) {
+      webhookItems.push({
+        account: request.account,
+        ...endpoint,
+        id,
+        PK: getWebhookPartitionKey(request.account),
+        SK: getWebhookSortKey(id, request.type ?? WebhookTypes.data),
+      });
+    }
+  }
+
+  return webhookItems;
+};

package/src/get.ts

@@ -0,0 +1,3 @@
+export const getWebhooks = () => {
+    
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./schemas/create"
+export * from "./schemas/endpoint"
+export * from "./schemas/webhook"
+export * from "./constants";
+export * from "./create";
+// export * from "./delete";
+export * from "./generate";
+export * from "./get";
+export * from "./keys";
+export * from "./types";

package/src/keys.ts

@@ -0,0 +1,7 @@
+export const getWebhookPartitionKey = (account: string) => {
+    return `ACCOUNT#${account}`;
+}
+
+export const getWebhookSortKey = (id: string, type: string) => {
+    return `HOOK#${id}#${type}`;
+}

package/src/schemas/create.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { HookEndpointHeaderSchema, HookEndpointSchema } from "./endpoint";
+import { WebhookTypesSchema } from "../types";
+
+export const CreateWebhookForAccountRequestSchema = z.object({
+  account: z.string(),
+  ids: z.array(z.string()),
+  endpoints: z.array(HookEndpointSchema),
+  headers: HookEndpointHeaderSchema,
+  type: WebhookTypesSchema.optional(),
+});
+export type CreateWebhookForAccountRequest = z.infer<
+  typeof CreateWebhookForAccountRequestSchema
+>;
+export const isCreateWebhookForAccountRequest = (
+  obj: unknown
+): obj is CreateWebhookForAccountRequest => {
+  CreateWebhookForAccountRequestSchema.parse(obj);
+  return true;
+};
+
+export const CreateWebhookForAccountResponseSchema = z.object({
+  success: z.boolean(),
+});
+export type CreateWebhookForAccountResponse = z.infer<
+  typeof CreateWebhookForAccountResponseSchema
+>;
+
+export const CreateWebhookRequestSchema = z.object({
+  ids: z.string(),
+  endpoints: z.array(HookEndpointSchema),
+  headers: z.array(HookEndpointHeaderSchema),
+});
+
+export const CreateWebhookResponseSchema =
+  CreateWebhookForAccountResponseSchema;
+export type CreateWebhookResponse = z.infer<typeof CreateWebhookResponseSchema>;

package/src/schemas/endpoint.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const HookEndpointHeaderSchema = z.record(z.string());
+export type HookEndpointHeader = z.infer<typeof HookEndpointHeaderSchema>;
+
+export const HookEndpointSchema = z.object({
+  url: z.string().url(),
+  headers: HookEndpointHeaderSchema,
+});
+export type HookEndpoint = z.infer<typeof HookEndpointSchema>;

package/src/schemas/webhook.ts

@@ -0,0 +1,21 @@
+import { TableItemSchema } from "@xube/kit-aws";
+import { z } from "zod";
+import { HookEndpointHeaderSchema } from "./endpoint";
+
+export const WebhookEndpointSchema = z.object({
+  url: z.string(),
+  headers: HookEndpointHeaderSchema,
+  id: z.string(),
+  account: z.string(),
+});
+export type WebhookEndpoint = z.infer<typeof WebhookEndpointSchema>;
+export const isWebhookEndpoint = (obj: unknown): obj is WebhookEndpoint =>
+  WebhookEndpointSchema.safeParse(obj).success;
+
+export const WebhookEndpointItemSchema =
+  WebhookEndpointSchema.merge(TableItemSchema);
+export type WebhookEndpointItem = z.infer<typeof WebhookEndpointItemSchema>;
+export const isWebhookEndpointItem = (
+  obj: unknown
+): obj is WebhookEndpointItem =>
+  WebhookEndpointItemSchema.safeParse(obj).success;

package/src/types.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const WebhookTypes = {
+    data: "data",
+    event: "event",
+} as const;
+
+
+export const WebhookTypesSchema = z.nativeEnum(WebhookTypes);
+export type WebhookType = z.infer<typeof WebhookTypesSchema>;

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../kit-build/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "exclude": ["**/*.test.ts", "**/*.mock.ts", "dist"],
+  "references": [
+    {
+      "path": "../kit-constants"
+    },
+    {
+      "path": "../kit-log"
+    },
+    {
+      "path": "../kit-request"
+    },
+    {
+      "path": "../kit-aws"
+    }
+  ]
+}