@gnosticdev/highlevel-sdk/dist/cjs/webhooks.js

SDK for the HighLevel API

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/v2/webhooks.ts
var webhooks_exports = {};
__export(webhooks_exports, {
  WebhooksClient: () => WebhooksClient,
  createWebhooksClient: () => createWebhooksClient
});
module.exports = __toCommonJS(webhooks_exports);

// src/lib/errors.ts
var HighLevelSDKErrorCodes = {
  INVALID_AUTH_HEADER: "INVALID_AUTH_HEADER",
  INVALID_AUTH_TYPE: "INVALID_AUTH_TYPE",
  NO_HANDLER_REGISTERED: "NO_HANDLER_REGISTERED",
  INVALID_WEBHOOK_PAYLOAD: "INVALID_WEBHOOK_PAYLOAD",
  API_KEY_REQUIRED: "API_KEY_REQUIRED"
};
var ERROR_MESSAGES = {
  [HighLevelSDKErrorCodes.INVALID_AUTH_HEADER]: 'Authorization header must start with "Bearer "',
  [HighLevelSDKErrorCodes.INVALID_AUTH_TYPE]: "Invalid authentication type provided",
  [HighLevelSDKErrorCodes.NO_HANDLER_REGISTERED]: "No handler registered for webhook event: {event}",
  [HighLevelSDKErrorCodes.INVALID_WEBHOOK_PAYLOAD]: "Invalid webhook payload",
  [HighLevelSDKErrorCodes.API_KEY_REQUIRED]: "apiKey is required"
};
var HighLevelSDKError = class extends Error {
  static {
    __name(this, "HighLevelSDKError");
  }
  constructor(message, options) {
    const finalMessage = options?.event ? ERROR_MESSAGES[message].replace("{event}", options.event) : ERROR_MESSAGES[message];
    super(finalMessage, options);
    this.name = "HighLevelSDKError";
    this.cause = HighLevelSDKErrorCodes[message];
  }
};

// src/v2/webhooks.ts
var WebhooksClient = class {
  static {
    __name(this, "WebhooksClient");
  }
  // Use keyof webhooks instead of string to ensure type safety
  handlers = /* @__PURE__ */ new Map();
  /**
   * Register a handler for a specific webhook event
   *
   * @example
   * ```ts
   * const webhooks = new WebhooksClient()
   *
   * webhooks.on('ContactCreate', async (payload) => {
   *   // payload is fully typed as ContactCreate schema
   *   const { firstName, lastName, email } = payload
   *   await db.contacts.create({ firstName, lastName, email })
   * })
   * ```
   */
  on(event, handler) {
    this.handlers.set(event, handler);
    return this;
  }
  /**
   * Validate and handle an incoming webhook payload
   *
   * @example
   * ```ts
   * app.post('/webhooks/:event', async (ctx) => {
   *   try {
   *     await webhooks.handle(ctx.params.event, ctx.request.body)
   *     return ctx.status(200).end()
   *   } catch (error) {
   *     return ctx.status(400).json({ error: error.message })
   *   }
   * })
   * ```
   */
  async handle(event, payload) {
    const handler = this.handlers.get(event);
    if (!handler) {
      throw new HighLevelSDKError("NO_HANDLER_REGISTERED", { event });
    }
    if (!payload || typeof payload !== "object") {
      throw new HighLevelSDKError("INVALID_WEBHOOK_PAYLOAD");
    }
    await handler(payload);
  }
  /**
   * Get the TypeScript type for a webhook payload
   * Useful for type checking in your IDE
   *
   * @example
   * ```ts
   * const webhooks = new WebhooksClient()
   *
   * const contactType = webhooks.type<'ContactCreate'>()
   * // contactType is fully typed as ContactCreate schema
   * ```
   */
  type() {
    return {};
  }
};
function createWebhooksClient() {
  return new WebhooksClient();
}
__name(createWebhooksClient, "createWebhooksClient");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  WebhooksClient,
  createWebhooksClient
});