@uniformdev/mesh-edgehancer-sdk 19.121.0 → 19.122.1-alpha.0

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import * as zod from 'zod';
 import { z } from 'zod';
 import { DataType, DataSource } from '@uniformdev/canvas';
+import { NextApiRequest, NextApiResponse } from 'next';
 
 /**
  * The context we are fetching the data resource in:
@@ -292,6 +293,45 @@ type ResolveBatchIdsResult<TID> = {
  */
 declare function resolveBatchFetchIds<TID>(batch: readonly RequestEdgehancerDataResourceContext[], resolveBatchItemIdFn: (dataResource: RequestEdgehancerDataResourceContext) => TID | undefined): ResolveBatchIdsResult<TID>;
 
+type InvalidationResponse = {
+    status: number;
+    text: string;
+};
+declare abstract class APIError extends Error {
+    abstract readonly status: number;
+    abstract readonly statusText: string;
+}
+declare class BadRequestError extends APIError {
+    status: number;
+    statusText: string;
+    constructor(message?: string);
+}
+declare class ForbiddenError extends APIError {
+    status: number;
+    statusText: string;
+    constructor(message?: string);
+}
+
+type Purger = {
+    purgeAllCachesForDataType(): Promise<InvalidationResponse>;
+    purgeBySurrogateKeys(surrogateKeys: string[]): Promise<InvalidationResponse>;
+};
+declare const createPurger: ({ invalidationEndpointUrl }: {
+    invalidationEndpointUrl: URL;
+}) => Purger;
+
+type Handler = (args: {
+    request: NextApiRequest;
+    purger: Purger;
+}) => Promise<InvalidationResponse>;
+declare const handleWebhookRequest: (req: NextApiRequest, res: NextApiResponse, handler: Handler) => Promise<void>;
+
+declare function getParam(query: NextApiRequest['query'], paramName: string): string | null;
+declare function getRequiredParam(query: NextApiRequest['query'], paramName: string): string;
+declare function validateParams(req: NextApiRequest): {
+    invalidationEndpointUrl: URL;
+};
+
 declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
     id: z.ZodString;
     displayName: z.ZodString;
@@ -820,4 +860,4 @@ declare function getDataResourceQueryString({ parameters, url }: EdgehancerMerge
 /** Gets the HTTP headers for a data resource */
 declare function getDataResourceHeaders({ headers }: EdgehancerMergedDataType): Headers;
 
-export { type ConvertBatchResultsToEdgehancerResultOptions, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerMergedDataType, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, convertBatchResultsToEdgehancerResult, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds };
+export { APIError, BadRequestError, type ConvertBatchResultsToEdgehancerResultOptions, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerMergedDataType, ForbiddenError, type InvalidationResponse, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type Purger, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, convertBatchResultsToEdgehancerResult, createPurger, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, getParam, getRequiredParam, handleWebhookRequest, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds, validateParams };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as zod from 'zod';
 import { z } from 'zod';
 import { DataType, DataSource } from '@uniformdev/canvas';
+import { NextApiRequest, NextApiResponse } from 'next';
 
 /**
  * The context we are fetching the data resource in:
@@ -292,6 +293,45 @@ type ResolveBatchIdsResult<TID> = {
  */
 declare function resolveBatchFetchIds<TID>(batch: readonly RequestEdgehancerDataResourceContext[], resolveBatchItemIdFn: (dataResource: RequestEdgehancerDataResourceContext) => TID | undefined): ResolveBatchIdsResult<TID>;
 
+type InvalidationResponse = {
+    status: number;
+    text: string;
+};
+declare abstract class APIError extends Error {
+    abstract readonly status: number;
+    abstract readonly statusText: string;
+}
+declare class BadRequestError extends APIError {
+    status: number;
+    statusText: string;
+    constructor(message?: string);
+}
+declare class ForbiddenError extends APIError {
+    status: number;
+    statusText: string;
+    constructor(message?: string);
+}
+
+type Purger = {
+    purgeAllCachesForDataType(): Promise<InvalidationResponse>;
+    purgeBySurrogateKeys(surrogateKeys: string[]): Promise<InvalidationResponse>;
+};
+declare const createPurger: ({ invalidationEndpointUrl }: {
+    invalidationEndpointUrl: URL;
+}) => Purger;
+
+type Handler = (args: {
+    request: NextApiRequest;
+    purger: Purger;
+}) => Promise<InvalidationResponse>;
+declare const handleWebhookRequest: (req: NextApiRequest, res: NextApiResponse, handler: Handler) => Promise<void>;
+
+declare function getParam(query: NextApiRequest['query'], paramName: string): string | null;
+declare function getRequiredParam(query: NextApiRequest['query'], paramName: string): string;
+declare function validateParams(req: NextApiRequest): {
+    invalidationEndpointUrl: URL;
+};
+
 declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
     id: z.ZodString;
     displayName: z.ZodString;
@@ -820,4 +860,4 @@ declare function getDataResourceQueryString({ parameters, url }: EdgehancerMerge
 /** Gets the HTTP headers for a data resource */
 declare function getDataResourceHeaders({ headers }: EdgehancerMergedDataType): Headers;
 
-export { type ConvertBatchResultsToEdgehancerResultOptions, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerMergedDataType, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, convertBatchResultsToEdgehancerResult, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds };
+export { APIError, BadRequestError, type ConvertBatchResultsToEdgehancerResultOptions, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerMergedDataType, ForbiddenError, type InvalidationResponse, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type Purger, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, convertBatchResultsToEdgehancerResult, createPurger, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, getParam, getRequiredParam, handleWebhookRequest, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds, validateParams };

package/dist/index.esm.js

@@ -52,6 +52,156 @@ function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
   return result;
 }
 
+// src/cache-purging-webhooks/purge.ts
+var logger = console;
+var createPurger = ({ invalidationEndpointUrl }) => {
+  logger.log(`[createPurger] call`, {
+    invalidationEndpointUrl: invalidationEndpointUrl.toString()
+  });
+  const purgeAllCachesForDataType = async () => {
+    logger.log(`[purgeAllCachesForDataType] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString()
+    });
+    const res = await fetch(invalidationEndpointUrl, {
+      method: "GET"
+    });
+    return {
+      status: res.status,
+      text: await res.text()
+    };
+  };
+  const purgeBySurrogateKeys = async (surrogateKeys) => {
+    logger.log(`[purgeBySurrogateKeys] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+      surrogateKeys
+    });
+    const body = {
+      surrogateKeys: surrogateKeys.filter((x) => x)
+    };
+    if (body.surrogateKeys.length > 0) {
+      const res = await fetch(invalidationEndpointUrl, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return {
+        status: res.status,
+        text: await res.text()
+      };
+    } else {
+      logger.log(`[purgeBySurrogateKeys] No surrogate keys found.`, {
+        invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+        surrogateKeys
+      });
+      return {
+        status: 200,
+        text: "No surrogate keys found."
+      };
+    }
+  };
+  return { purgeAllCachesForDataType, purgeBySurrogateKeys };
+};
+
+// src/cache-purging-webhooks/shared.ts
+var APIError = class extends Error {
+};
+var BadRequestError = class _BadRequestError extends APIError {
+  constructor(message = "Invalid request received") {
+    super(message);
+    this.status = 400;
+    this.statusText = "Bad Request";
+    Object.setPrototypeOf(this, _BadRequestError.prototype);
+  }
+};
+var ForbiddenError = class _ForbiddenError extends APIError {
+  constructor(message = "This action is forbidden") {
+    super(message);
+    this.status = 403;
+    this.statusText = "Forbidden";
+    Object.setPrototypeOf(this, _ForbiddenError.prototype);
+  }
+};
+
+// src/cache-purging-webhooks/utils.ts
+function getParam(query, paramName) {
+  const values = query[paramName];
+  if (!values) {
+    return null;
+  } else if (typeof values === "string") {
+    return values;
+  } else if (values.length === 1) {
+    return values[0];
+  } else {
+    throw new BadRequestError(`Multiple values for ${paramName} found in request parameters`);
+  }
+}
+function getRequiredParam(query, paramName) {
+  const value = getParam(query, paramName);
+  if (!value) {
+    throw new BadRequestError(`${paramName} not found in request parameters`);
+  }
+  return value;
+}
+function validateParams(req) {
+  const edgeApiHost = getParam(req.query, "edgeApiHost");
+  if (edgeApiHost) {
+    if (!isAllowedEdgeApiHost(edgeApiHost)) {
+      throw new ForbiddenError(`Edge API hostname is not allowed: ${edgeApiHost}`);
+    }
+  }
+  const projectId = getRequiredParam(req.query, "projectId");
+  const dataTypeId = getRequiredParam(req.query, "dataTypeId");
+  const purgeKey = getRequiredParam(req.query, "purgeKey");
+  const invalidationEndpointUrl = new URL(`https://${edgeApiHost || "uniform.global"}/api/v1/invalidation`);
+  invalidationEndpointUrl.searchParams.set("projectId", projectId);
+  invalidationEndpointUrl.searchParams.set("dataTypeId", dataTypeId);
+  invalidationEndpointUrl.searchParams.set("purgeKey", purgeKey);
+  return { invalidationEndpointUrl };
+}
+function isAllowedEdgeApiHost(edgeApiHost) {
+  if (["uniform.global", "canary.uniform.global"].includes(edgeApiHost)) {
+    return true;
+  }
+  if (edgeApiHost.endsWith(".uniform.rocks")) {
+    return true;
+  }
+  return false;
+}
+
+// src/cache-purging-webhooks/handleWebhookRequest.ts
+var ALLOWED_METHODS = ["POST"];
+var logger2 = console;
+var handleWebhookRequest = async (req, res, handler) => {
+  try {
+    logger2.log(`request`, {
+      url: req.url,
+      method: req.method
+    });
+    if (!ALLOWED_METHODS.includes(req.method || "")) {
+      throw new BadRequestError(`Expected ${ALLOWED_METHODS.join(" or ")} but was called with ${req.method}`);
+    }
+    const { invalidationEndpointUrl } = validateParams(req);
+    const purger = createPurger({ invalidationEndpointUrl });
+    const { status, text } = await handler({
+      request: req,
+      purger
+    });
+    res.status(status).send(text);
+  } catch (err) {
+    if (err instanceof APIError) {
+      logger2.error(`APIError: [${err.status} ${err.statusText}] ${err.message}`);
+      res.status(err.status).json({
+        type: err.statusText,
+        errorMessage: err.message
+      });
+    } else {
+      logger2.error(`Error`, err);
+      res.status(500).json({
+        errorMessage: err.message || "Unknown error"
+      });
+    }
+  }
+};
+
 // src/fetchUtils.ts
 function getDataResourceAsRequest(data) {
   var _a;
@@ -178,17 +328,25 @@ var requestEdgehancerResultSchema = z3.strictObject({
   results: z3.array(requestEdgehancerDataResourceResolutionResultSchema)
 });
 export {
+  APIError,
+  BadRequestError,
+  ForbiddenError,
   convertBatchResultsToEdgehancerResult,
+  createPurger,
   dataResourceSchema,
   edgehancerMergedDataTypeSchema,
   getDataResourceAsRequest,
   getDataResourceHeaders,
   getDataResourceQueryString,
   getDataResourceUrl,
+  getParam,
+  getRequiredParam,
+  handleWebhookRequest,
   mergedDataTypeSchema,
   preRequestEdgehancerDataResourceResultSchema,
   preRequestEdgehancerResultSchema,
   requestEdgehancerDataResourceResolutionResultSchema,
   requestEdgehancerResultSchema,
-  resolveBatchFetchIds
+  resolveBatchFetchIds,
+  validateParams
 };

package/dist/index.js

@@ -20,19 +20,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  APIError: () => APIError,
+  BadRequestError: () => BadRequestError,
+  ForbiddenError: () => ForbiddenError,
   convertBatchResultsToEdgehancerResult: () => convertBatchResultsToEdgehancerResult,
+  createPurger: () => createPurger,
   dataResourceSchema: () => dataResourceSchema,
   edgehancerMergedDataTypeSchema: () => edgehancerMergedDataTypeSchema,
   getDataResourceAsRequest: () => getDataResourceAsRequest,
   getDataResourceHeaders: () => getDataResourceHeaders,
   getDataResourceQueryString: () => getDataResourceQueryString,
   getDataResourceUrl: () => getDataResourceUrl,
+  getParam: () => getParam,
+  getRequiredParam: () => getRequiredParam,
+  handleWebhookRequest: () => handleWebhookRequest,
   mergedDataTypeSchema: () => mergedDataTypeSchema,
   preRequestEdgehancerDataResourceResultSchema: () => preRequestEdgehancerDataResourceResultSchema,
   preRequestEdgehancerResultSchema: () => preRequestEdgehancerResultSchema,
   requestEdgehancerDataResourceResolutionResultSchema: () => requestEdgehancerDataResourceResolutionResultSchema,
   requestEdgehancerResultSchema: () => requestEdgehancerResultSchema,
-  resolveBatchFetchIds: () => resolveBatchFetchIds
+  resolveBatchFetchIds: () => resolveBatchFetchIds,
+  validateParams: () => validateParams
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -90,6 +98,156 @@ function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
   return result;
 }
 
+// src/cache-purging-webhooks/purge.ts
+var logger = console;
+var createPurger = ({ invalidationEndpointUrl }) => {
+  logger.log(`[createPurger] call`, {
+    invalidationEndpointUrl: invalidationEndpointUrl.toString()
+  });
+  const purgeAllCachesForDataType = async () => {
+    logger.log(`[purgeAllCachesForDataType] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString()
+    });
+    const res = await fetch(invalidationEndpointUrl, {
+      method: "GET"
+    });
+    return {
+      status: res.status,
+      text: await res.text()
+    };
+  };
+  const purgeBySurrogateKeys = async (surrogateKeys) => {
+    logger.log(`[purgeBySurrogateKeys] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+      surrogateKeys
+    });
+    const body = {
+      surrogateKeys: surrogateKeys.filter((x) => x)
+    };
+    if (body.surrogateKeys.length > 0) {
+      const res = await fetch(invalidationEndpointUrl, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return {
+        status: res.status,
+        text: await res.text()
+      };
+    } else {
+      logger.log(`[purgeBySurrogateKeys] No surrogate keys found.`, {
+        invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+        surrogateKeys
+      });
+      return {
+        status: 200,
+        text: "No surrogate keys found."
+      };
+    }
+  };
+  return { purgeAllCachesForDataType, purgeBySurrogateKeys };
+};
+
+// src/cache-purging-webhooks/shared.ts
+var APIError = class extends Error {
+};
+var BadRequestError = class _BadRequestError extends APIError {
+  constructor(message = "Invalid request received") {
+    super(message);
+    this.status = 400;
+    this.statusText = "Bad Request";
+    Object.setPrototypeOf(this, _BadRequestError.prototype);
+  }
+};
+var ForbiddenError = class _ForbiddenError extends APIError {
+  constructor(message = "This action is forbidden") {
+    super(message);
+    this.status = 403;
+    this.statusText = "Forbidden";
+    Object.setPrototypeOf(this, _ForbiddenError.prototype);
+  }
+};
+
+// src/cache-purging-webhooks/utils.ts
+function getParam(query, paramName) {
+  const values = query[paramName];
+  if (!values) {
+    return null;
+  } else if (typeof values === "string") {
+    return values;
+  } else if (values.length === 1) {
+    return values[0];
+  } else {
+    throw new BadRequestError(`Multiple values for ${paramName} found in request parameters`);
+  }
+}
+function getRequiredParam(query, paramName) {
+  const value = getParam(query, paramName);
+  if (!value) {
+    throw new BadRequestError(`${paramName} not found in request parameters`);
+  }
+  return value;
+}
+function validateParams(req) {
+  const edgeApiHost = getParam(req.query, "edgeApiHost");
+  if (edgeApiHost) {
+    if (!isAllowedEdgeApiHost(edgeApiHost)) {
+      throw new ForbiddenError(`Edge API hostname is not allowed: ${edgeApiHost}`);
+    }
+  }
+  const projectId = getRequiredParam(req.query, "projectId");
+  const dataTypeId = getRequiredParam(req.query, "dataTypeId");
+  const purgeKey = getRequiredParam(req.query, "purgeKey");
+  const invalidationEndpointUrl = new URL(`https://${edgeApiHost || "uniform.global"}/api/v1/invalidation`);
+  invalidationEndpointUrl.searchParams.set("projectId", projectId);
+  invalidationEndpointUrl.searchParams.set("dataTypeId", dataTypeId);
+  invalidationEndpointUrl.searchParams.set("purgeKey", purgeKey);
+  return { invalidationEndpointUrl };
+}
+function isAllowedEdgeApiHost(edgeApiHost) {
+  if (["uniform.global", "canary.uniform.global"].includes(edgeApiHost)) {
+    return true;
+  }
+  if (edgeApiHost.endsWith(".uniform.rocks")) {
+    return true;
+  }
+  return false;
+}
+
+// src/cache-purging-webhooks/handleWebhookRequest.ts
+var ALLOWED_METHODS = ["POST"];
+var logger2 = console;
+var handleWebhookRequest = async (req, res, handler) => {
+  try {
+    logger2.log(`request`, {
+      url: req.url,
+      method: req.method
+    });
+    if (!ALLOWED_METHODS.includes(req.method || "")) {
+      throw new BadRequestError(`Expected ${ALLOWED_METHODS.join(" or ")} but was called with ${req.method}`);
+    }
+    const { invalidationEndpointUrl } = validateParams(req);
+    const purger = createPurger({ invalidationEndpointUrl });
+    const { status, text } = await handler({
+      request: req,
+      purger
+    });
+    res.status(status).send(text);
+  } catch (err) {
+    if (err instanceof APIError) {
+      logger2.error(`APIError: [${err.status} ${err.statusText}] ${err.message}`);
+      res.status(err.status).json({
+        type: err.statusText,
+        errorMessage: err.message
+      });
+    } else {
+      logger2.error(`Error`, err);
+      res.status(500).json({
+        errorMessage: err.message || "Unknown error"
+      });
+    }
+  }
+};
+
 // src/fetchUtils.ts
 function getDataResourceAsRequest(data) {
   var _a;
@@ -217,17 +375,25 @@ var requestEdgehancerResultSchema = import_zod3.z.strictObject({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIError,
+  BadRequestError,
+  ForbiddenError,
   convertBatchResultsToEdgehancerResult,
+  createPurger,
   dataResourceSchema,
   edgehancerMergedDataTypeSchema,
   getDataResourceAsRequest,
   getDataResourceHeaders,
   getDataResourceQueryString,
   getDataResourceUrl,
+  getParam,
+  getRequiredParam,
+  handleWebhookRequest,
   mergedDataTypeSchema,
   preRequestEdgehancerDataResourceResultSchema,
   preRequestEdgehancerResultSchema,
   requestEdgehancerDataResourceResolutionResultSchema,
   requestEdgehancerResultSchema,
-  resolveBatchFetchIds
+  resolveBatchFetchIds,
+  validateParams
 });

package/dist/index.mjs

@@ -52,6 +52,156 @@ function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
   return result;
 }
 
+// src/cache-purging-webhooks/purge.ts
+var logger = console;
+var createPurger = ({ invalidationEndpointUrl }) => {
+  logger.log(`[createPurger] call`, {
+    invalidationEndpointUrl: invalidationEndpointUrl.toString()
+  });
+  const purgeAllCachesForDataType = async () => {
+    logger.log(`[purgeAllCachesForDataType] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString()
+    });
+    const res = await fetch(invalidationEndpointUrl, {
+      method: "GET"
+    });
+    return {
+      status: res.status,
+      text: await res.text()
+    };
+  };
+  const purgeBySurrogateKeys = async (surrogateKeys) => {
+    logger.log(`[purgeBySurrogateKeys] call`, {
+      invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+      surrogateKeys
+    });
+    const body = {
+      surrogateKeys: surrogateKeys.filter((x) => x)
+    };
+    if (body.surrogateKeys.length > 0) {
+      const res = await fetch(invalidationEndpointUrl, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return {
+        status: res.status,
+        text: await res.text()
+      };
+    } else {
+      logger.log(`[purgeBySurrogateKeys] No surrogate keys found.`, {
+        invalidationEndpointUrl: invalidationEndpointUrl.toString(),
+        surrogateKeys
+      });
+      return {
+        status: 200,
+        text: "No surrogate keys found."
+      };
+    }
+  };
+  return { purgeAllCachesForDataType, purgeBySurrogateKeys };
+};
+
+// src/cache-purging-webhooks/shared.ts
+var APIError = class extends Error {
+};
+var BadRequestError = class _BadRequestError extends APIError {
+  constructor(message = "Invalid request received") {
+    super(message);
+    this.status = 400;
+    this.statusText = "Bad Request";
+    Object.setPrototypeOf(this, _BadRequestError.prototype);
+  }
+};
+var ForbiddenError = class _ForbiddenError extends APIError {
+  constructor(message = "This action is forbidden") {
+    super(message);
+    this.status = 403;
+    this.statusText = "Forbidden";
+    Object.setPrototypeOf(this, _ForbiddenError.prototype);
+  }
+};
+
+// src/cache-purging-webhooks/utils.ts
+function getParam(query, paramName) {
+  const values = query[paramName];
+  if (!values) {
+    return null;
+  } else if (typeof values === "string") {
+    return values;
+  } else if (values.length === 1) {
+    return values[0];
+  } else {
+    throw new BadRequestError(`Multiple values for ${paramName} found in request parameters`);
+  }
+}
+function getRequiredParam(query, paramName) {
+  const value = getParam(query, paramName);
+  if (!value) {
+    throw new BadRequestError(`${paramName} not found in request parameters`);
+  }
+  return value;
+}
+function validateParams(req) {
+  const edgeApiHost = getParam(req.query, "edgeApiHost");
+  if (edgeApiHost) {
+    if (!isAllowedEdgeApiHost(edgeApiHost)) {
+      throw new ForbiddenError(`Edge API hostname is not allowed: ${edgeApiHost}`);
+    }
+  }
+  const projectId = getRequiredParam(req.query, "projectId");
+  const dataTypeId = getRequiredParam(req.query, "dataTypeId");
+  const purgeKey = getRequiredParam(req.query, "purgeKey");
+  const invalidationEndpointUrl = new URL(`https://${edgeApiHost || "uniform.global"}/api/v1/invalidation`);
+  invalidationEndpointUrl.searchParams.set("projectId", projectId);
+  invalidationEndpointUrl.searchParams.set("dataTypeId", dataTypeId);
+  invalidationEndpointUrl.searchParams.set("purgeKey", purgeKey);
+  return { invalidationEndpointUrl };
+}
+function isAllowedEdgeApiHost(edgeApiHost) {
+  if (["uniform.global", "canary.uniform.global"].includes(edgeApiHost)) {
+    return true;
+  }
+  if (edgeApiHost.endsWith(".uniform.rocks")) {
+    return true;
+  }
+  return false;
+}
+
+// src/cache-purging-webhooks/handleWebhookRequest.ts
+var ALLOWED_METHODS = ["POST"];
+var logger2 = console;
+var handleWebhookRequest = async (req, res, handler) => {
+  try {
+    logger2.log(`request`, {
+      url: req.url,
+      method: req.method
+    });
+    if (!ALLOWED_METHODS.includes(req.method || "")) {
+      throw new BadRequestError(`Expected ${ALLOWED_METHODS.join(" or ")} but was called with ${req.method}`);
+    }
+    const { invalidationEndpointUrl } = validateParams(req);
+    const purger = createPurger({ invalidationEndpointUrl });
+    const { status, text } = await handler({
+      request: req,
+      purger
+    });
+    res.status(status).send(text);
+  } catch (err) {
+    if (err instanceof APIError) {
+      logger2.error(`APIError: [${err.status} ${err.statusText}] ${err.message}`);
+      res.status(err.status).json({
+        type: err.statusText,
+        errorMessage: err.message
+      });
+    } else {
+      logger2.error(`Error`, err);
+      res.status(500).json({
+        errorMessage: err.message || "Unknown error"
+      });
+    }
+  }
+};
+
 // src/fetchUtils.ts
 function getDataResourceAsRequest(data) {
   var _a;
@@ -178,17 +328,25 @@ var requestEdgehancerResultSchema = z3.strictObject({
   results: z3.array(requestEdgehancerDataResourceResolutionResultSchema)
 });
 export {
+  APIError,
+  BadRequestError,
+  ForbiddenError,
   convertBatchResultsToEdgehancerResult,
+  createPurger,
   dataResourceSchema,
   edgehancerMergedDataTypeSchema,
   getDataResourceAsRequest,
   getDataResourceHeaders,
   getDataResourceQueryString,
   getDataResourceUrl,
+  getParam,
+  getRequiredParam,
+  handleWebhookRequest,
   mergedDataTypeSchema,
   preRequestEdgehancerDataResourceResultSchema,
   preRequestEdgehancerResultSchema,
   requestEdgehancerDataResourceResolutionResultSchema,
   requestEdgehancerResultSchema,
-  resolveBatchFetchIds
+  resolveBatchFetchIds,
+  validateParams
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/mesh-edgehancer-sdk",
-  "version": "19.121.0",
+  "version": "19.122.1-alpha.0+03f737f1b5",
   "description": "Uniform Mesh Edgehancer SDK",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./dist/index.js",
@@ -28,12 +28,18 @@
     "/dist"
   ],
   "dependencies": {
-    "@uniformdev/canvas": "19.121.0",
+    "@uniformdev/canvas": "19.122.1-alpha.0+03f737f1b5",
     "tsafe": "1.6.5",
     "zod": "3.22.4"
   },
+  "devDependencies": {
+    "next": "13.4.12"
+  },
+  "peerDependencies": {
+    "next": ">13"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4bab305415aa38c7d473a08c15bcd78fcb7d8d88"
+  "gitHead": "03f737f1b507886971bc90dde2367d1bf85f5edf"
 }