@redmix/api 0.0.1

package/dist/cache/index.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from '../logger';
+import type BaseClient from './clients/BaseClient';
+export { default as MemcachedClient } from './clients/MemcachedClient';
+export { default as RedisClient } from './clients/RedisClient';
+export { default as InMemoryClient } from './clients/InMemoryClient';
+export interface CreateCacheOptions {
+    logger?: Logger;
+    timeout?: number;
+    prefix?: string;
+    fields?: {
+        id: string;
+        updatedAt: string;
+    };
+}
+export interface CacheOptions {
+    expires?: number;
+}
+export interface CacheFindManyOptions<TFindManyArgs extends Record<string, unknown>> extends CacheOptions {
+    conditions?: TFindManyArgs;
+}
+export type CacheKey = string | string[];
+export type LatestQuery = Record<string, unknown>;
+type GenericDelegate = {
+    findMany: (...args: any) => any;
+    findFirst: (...args: any) => any;
+};
+export declare const cacheKeySeparator = "-";
+export declare const formatCacheKey: (key: CacheKey, prefix?: string) => string;
+export declare const createCache: (cacheClient: BaseClient, options?: CreateCacheOptions) => {
+    cache: <TResult>(key: CacheKey, input: () => TResult | Promise<TResult>, options?: CacheOptions) => Promise<any>;
+    cacheFindMany: <TDelegate extends GenericDelegate>(key: CacheKey, model: TDelegate, options?: CacheFindManyOptions<Parameters<TDelegate["findMany"]>[0]>) => Promise<any>;
+    cacheClient: BaseClient;
+    deleteCacheKey: (key: CacheKey) => Promise<any>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC,OAAO,KAAK,UAAU,MAAM,sBAAsB,CAAA;AAGlD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAEpE,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE;QACP,EAAE,EAAE,MAAM,CAAA;QACV,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;CACF;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,oBAAoB,CACnC,aAAa,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC7C,SAAQ,YAAY;IACpB,UAAU,CAAC,EAAE,aAAa,CAAA;CAC3B;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;AACxC,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEjD,KAAK,eAAe,GAAG;IACrB,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAA;IAC/B,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAA;CACjC,CAAA;AAQD,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC,eAAO,MAAM,cAAc,QAAS,QAAQ,WAAW,MAAM,WAkB5D,CAAA;AAMD,eAAO,MAAM,WAAW,gBACT,UAAU,YACb,kBAAkB;YAQP,OAAO,OACrB,QAAQ,SACN,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,YAC7B,YAAY,KACrB,OAAO,CAAC,GAAG,CAAC;oBAqDc,SAAS,SAAS,eAAe,OACvD,QAAQ,SACN,SAAS,YACP,oBAAoB,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;0BAgDlC,QAAQ;CA0B5C,CAAA"}

package/dist/cache/index.js

@@ -0,0 +1,171 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  InMemoryClient: () => import_InMemoryClient.default,
+  MemcachedClient: () => import_MemcachedClient.default,
+  RedisClient: () => import_RedisClient.default,
+  cacheKeySeparator: () => cacheKeySeparator,
+  createCache: () => createCache,
+  formatCacheKey: () => formatCacheKey
+});
+module.exports = __toCommonJS(cache_exports);
+var import_errors = require("./errors");
+var import_MemcachedClient = __toESM(require("./clients/MemcachedClient"));
+var import_RedisClient = __toESM(require("./clients/RedisClient"));
+var import_InMemoryClient = __toESM(require("./clients/InMemoryClient"));
+const DEFAULT_LATEST_FIELDS = { id: "id", updatedAt: "updatedAt" };
+const wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const cacheKeySeparator = "-";
+const formatCacheKey = (key, prefix) => {
+  let output;
+  if (Array.isArray(key)) {
+    output = key.join(cacheKeySeparator);
+  } else {
+    output = key;
+  }
+  if (prefix && !output.toString().match(new RegExp("^" + prefix + cacheKeySeparator))) {
+    output = `${prefix}${cacheKeySeparator}${output}`;
+  }
+  return output;
+};
+const serialize = (input) => {
+  return JSON.parse(JSON.stringify(input));
+};
+const createCache = (cacheClient, options) => {
+  const client = cacheClient;
+  const logger = options?.logger;
+  const timeout = options?.timeout || 1e3;
+  const prefix = options?.prefix;
+  const fields = options?.fields || DEFAULT_LATEST_FIELDS;
+  const cache = async (key, input, options2) => {
+    const cacheKey = formatCacheKey(key, prefix);
+    try {
+      const result = await Promise.race([
+        client.get(cacheKey),
+        wait(timeout).then(() => {
+          throw new import_errors.CacheTimeoutError();
+        })
+      ]);
+      if (result) {
+        logger?.debug(`[Cache] HIT key '${cacheKey}'`);
+        return result;
+      }
+    } catch (e) {
+      logger?.error(`[Cache] Error GET '${cacheKey}': ${e.message}`);
+      if (e instanceof import_errors.CacheTimeoutError && client.disconnect) {
+        logger?.error(`[Cache] Disconnecting current instance...`);
+        await client.disconnect();
+      }
+      return serialize(await input());
+    }
+    let data;
+    try {
+      data = await input();
+      await Promise.race([
+        client.set(cacheKey, data, options2 || {}),
+        wait(timeout).then(() => {
+          throw new import_errors.CacheTimeoutError();
+        })
+      ]);
+      logger?.debug(
+        `[Cache] MISS '${cacheKey}', SET ${JSON.stringify(data).length} bytes`
+      );
+      return serialize(data);
+    } catch (e) {
+      logger?.error(`[Cache] Error SET '${cacheKey}': ${e.message}`);
+      return serialize(data || await input());
+    }
+  };
+  const cacheFindMany = async (key, model, options2 = {}) => {
+    const { conditions, ...rest } = options2;
+    const cacheKey = formatCacheKey(key, prefix);
+    let latest, latestCacheKey;
+    const { PrismaClientValidationError } = await import("@prisma/client");
+    try {
+      latest = await model.findFirst({
+        ...conditions,
+        orderBy: { [fields.updatedAt]: "desc" },
+        select: { [fields.id]: true, [fields.updatedAt]: true }
+      });
+    } catch (e) {
+      if (e instanceof PrismaClientValidationError) {
+        logger?.error(
+          `[Cache] cacheFindMany error: model does not contain \`${fields.id}\` or \`${fields.updatedAt}\` fields`
+        );
+      } else {
+        logger?.error(`[Cache] cacheFindMany error: ${e.message}`);
+      }
+      return serialize(await model.findMany(conditions));
+    }
+    if (latest) {
+      latestCacheKey = `${cacheKey}${cacheKeySeparator}${latest.id}${cacheKeySeparator}${latest[fields.updatedAt].getTime()}`;
+    } else {
+      logger?.debug(
+        `[Cache] cacheFindMany: No data to cache for key \`${key}\`, skipping`
+      );
+      return serialize(await model.findMany(conditions));
+    }
+    return cache(latestCacheKey, () => model.findMany(conditions), rest);
+  };
+  const deleteCacheKey = async (key) => {
+    let result;
+    const cacheKey = formatCacheKey(key, prefix);
+    try {
+      await Promise.race([
+        result = client.del(cacheKey),
+        wait(timeout).then(() => {
+          throw new import_errors.CacheTimeoutError();
+        })
+      ]);
+      logger?.debug(`[Cache] DEL '${cacheKey}'`);
+      return result;
+    } catch (e) {
+      logger?.error(`[Cache] Error DEL '${cacheKey}': ${e.message}`);
+      return false;
+    }
+  };
+  return {
+    cache,
+    cacheFindMany,
+    cacheClient: client,
+    deleteCacheKey
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryClient,
+  MemcachedClient,
+  RedisClient,
+  cacheKeySeparator,
+  createCache,
+  formatCacheKey
+});

package/dist/cors.d.ts

@@ -0,0 +1,16 @@
+import type { PartialRequest } from './transforms';
+export type CorsConfig = {
+    origin?: boolean | string | string[];
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+export type CorsHeaders = Record<string, string>;
+export type CorsContext = ReturnType<typeof createCorsContext>;
+export declare function createCorsContext(cors: CorsConfig | undefined): {
+    shouldHandleCors(request: PartialRequest): boolean;
+    getRequestHeaders(request: PartialRequest): CorsHeaders;
+};
+//# sourceMappingURL=cors.d.ts.map

package/dist/cors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../src/cors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;IACpC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC3B,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAClC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAClC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAChD,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS;8BA6ChC,cAAc;+BAGb,cAAc,GAAG,WAAW;EAgC1D"}

package/dist/cors.js

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var cors_exports = {};
+__export(cors_exports, {
+  createCorsContext: () => createCorsContext
+});
+module.exports = __toCommonJS(cors_exports);
+var import_fetch = require("@whatwg-node/fetch");
+function createCorsContext(cors) {
+  const corsHeaders = new import_fetch.Headers();
+  if (cors) {
+    if (cors.methods) {
+      if (typeof cors.methods === "string") {
+        corsHeaders.set("access-control-allow-methods", cors.methods);
+      } else if (Array.isArray(cors.methods)) {
+        corsHeaders.set("access-control-allow-methods", cors.methods.join(","));
+      }
+    }
+    if (cors.allowedHeaders) {
+      if (typeof cors.allowedHeaders === "string") {
+        corsHeaders.set("access-control-allow-headers", cors.allowedHeaders);
+      } else if (Array.isArray(cors.allowedHeaders)) {
+        corsHeaders.set(
+          "access-control-allow-headers",
+          cors.allowedHeaders.join(",")
+        );
+      }
+    }
+    if (cors.exposedHeaders) {
+      if (typeof cors.exposedHeaders === "string") {
+        corsHeaders.set("access-control-expose-headers", cors.exposedHeaders);
+      } else if (Array.isArray(cors.exposedHeaders)) {
+        corsHeaders.set(
+          "access-control-expose-headers",
+          cors.exposedHeaders.join(",")
+        );
+      }
+    }
+    if (cors.credentials) {
+      corsHeaders.set("access-control-allow-credentials", "true");
+    }
+    if (typeof cors.maxAge === "number") {
+      corsHeaders.set("access-control-max-age", cors.maxAge.toString());
+    }
+  }
+  return {
+    shouldHandleCors(request) {
+      return request.method === "OPTIONS";
+    },
+    getRequestHeaders(request) {
+      const eventHeaders = new import_fetch.Headers(request.headers);
+      const requestCorsHeaders = new import_fetch.Headers(corsHeaders);
+      if (cors?.origin) {
+        const requestOrigin = eventHeaders.get("origin");
+        if (typeof cors.origin === "string") {
+          requestCorsHeaders.set("access-control-allow-origin", cors.origin);
+        } else if (requestOrigin && (typeof cors.origin === "boolean" || Array.isArray(cors.origin) && requestOrigin && cors.origin.includes(requestOrigin))) {
+          requestCorsHeaders.set("access-control-allow-origin", requestOrigin);
+        }
+        const requestAccessControlRequestHeaders = eventHeaders.get(
+          "access-control-request-headers"
+        );
+        if (!cors.allowedHeaders && requestAccessControlRequestHeaders) {
+          requestCorsHeaders.set(
+            "access-control-allow-headers",
+            requestAccessControlRequestHeaders
+          );
+        }
+      }
+      return Object.fromEntries(requestCorsHeaders.entries());
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCorsContext
+});

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class RedwoodError extends Error {
+    extensions: Record<string, any> | undefined;
+    constructor(message: string, extensions?: Record<string, any>);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;gBAC/B,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAQ9D"}

package/dist/errors.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var errors_exports = {};
+__export(errors_exports, {
+  RedwoodError: () => RedwoodError
+});
+module.exports = __toCommonJS(errors_exports);
+class RedwoodError extends Error {
+  extensions;
+  constructor(message, extensions) {
+    super(message);
+    this.name = "RedwoodError";
+    this.extensions = {
+      ...extensions,
+      code: extensions?.code || "REDWOODJS_ERROR"
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedwoodError
+});

package/dist/event.d.ts

@@ -0,0 +1,3 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+export declare const getEventHeader: (event: APIGatewayProxyEvent | Request, headerName: string) => string | null | undefined;
+//# sourceMappingURL=event.d.ts.map

package/dist/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../src/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAKtD,eAAO,MAAM,cAAc,UAClB,oBAAoB,GAAG,OAAO,cACzB,MAAM,8BAOnB,CAAA"}

package/dist/event.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var event_exports = {};
+__export(event_exports, {
+  getEventHeader: () => getEventHeader
+});
+module.exports = __toCommonJS(event_exports);
+var import_transforms = require("./transforms");
+const getEventHeader = (event, headerName) => {
+  if ((0, import_transforms.isFetchApiRequest)(event)) {
+    return event.headers.get(headerName);
+  }
+  return event.headers[headerName] || event.headers[headerName.toLowerCase()];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEventHeader
+});

package/dist/functions/fixtures/apiGatewayProxyEvent.fixture.d.ts

@@ -0,0 +1,4 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+export declare const mockedAPIGatewayProxyEvent: APIGatewayProxyEvent;
+export default mockedAPIGatewayProxyEvent;
+//# sourceMappingURL=apiGatewayProxyEvent.fixture.d.ts.map

package/dist/functions/fixtures/apiGatewayProxyEvent.fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiGatewayProxyEvent.fixture.d.ts","sourceRoot":"","sources":["../../../src/functions/fixtures/apiGatewayProxyEvent.fixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,eAAO,MAAM,0BAA0B,EAAE,oBA0CxC,CAAA;AAED,eAAe,0BAA0B,CAAA"}

package/dist/functions/fixtures/apiGatewayProxyEvent.fixture.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var apiGatewayProxyEvent_fixture_exports = {};
+__export(apiGatewayProxyEvent_fixture_exports, {
+  default: () => apiGatewayProxyEvent_fixture_default,
+  mockedAPIGatewayProxyEvent: () => mockedAPIGatewayProxyEvent
+});
+module.exports = __toCommonJS(apiGatewayProxyEvent_fixture_exports);
+const mockedAPIGatewayProxyEvent = {
+  body: "MOCKED_BODY",
+  headers: {},
+  multiValueHeaders: {},
+  httpMethod: "POST",
+  isBase64Encoded: false,
+  path: "/MOCK_PATH",
+  pathParameters: null,
+  queryStringParameters: null,
+  multiValueQueryStringParameters: null,
+  stageVariables: null,
+  requestContext: {
+    accountId: "MOCKED_ACCOUNT",
+    apiId: "MOCKED_API_ID",
+    authorizer: { name: "MOCKED_AUTHORIZER" },
+    protocol: "HTTP",
+    identity: {
+      accessKey: null,
+      accountId: null,
+      apiKey: null,
+      apiKeyId: null,
+      caller: null,
+      clientCert: null,
+      cognitoAuthenticationProvider: null,
+      cognitoAuthenticationType: null,
+      cognitoIdentityId: null,
+      cognitoIdentityPoolId: null,
+      principalOrgId: null,
+      sourceIp: "123.123.123.123",
+      user: null,
+      userAgent: null,
+      userArn: null
+    },
+    httpMethod: "POST",
+    path: "/MOCK_PATH",
+    stage: "MOCK_STAGE",
+    requestId: "MOCKED_REQUEST_ID",
+    requestTimeEpoch: 1,
+    resourceId: "MOCKED_RESOURCE_ID",
+    resourcePath: "MOCKED_RESOURCE_PATH"
+  },
+  resource: "MOCKED_RESOURCE"
+};
+var apiGatewayProxyEvent_fixture_default = mockedAPIGatewayProxyEvent;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mockedAPIGatewayProxyEvent
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './auth';
+export * from './errors';
+export * from './validations/validations';
+export * from './validations/errors';
+export * from './types';
+export * from './transforms';
+export * from './cors';
+export * from './event';
+export declare const prismaVersion: any;
+export declare const redwoodVersion: any;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,2BAA2B,CAAA;AACzC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,SAAS,CAAA;AAEvB,cAAc,cAAc,CAAA;AAC5B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AAIvB,eAAO,MAAM,aAAa,KAA8C,CAAA;AACxE,eAAO,MAAM,cAAc,KAAuB,CAAA"}

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  prismaVersion: () => prismaVersion,
+  redwoodVersion: () => redwoodVersion
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./auth"), module.exports);
+__reExport(index_exports, require("./errors"), module.exports);
+__reExport(index_exports, require("./validations/validations"), module.exports);
+__reExport(index_exports, require("./validations/errors"), module.exports);
+__reExport(index_exports, require("./types"), module.exports);
+__reExport(index_exports, require("./transforms"), module.exports);
+__reExport(index_exports, require("./cors"), module.exports);
+__reExport(index_exports, require("./event"), module.exports);
+const packageJson = require("../package.json");
+const prismaVersion = packageJson?.dependencies["@prisma/client"];
+const redwoodVersion = packageJson?.version;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prismaVersion,
+  redwoodVersion,
+  ...require("./auth"),
+  ...require("./errors"),
+  ...require("./validations/validations"),
+  ...require("./validations/errors"),
+  ...require("./types"),
+  ...require("./transforms"),
+  ...require("./cors"),
+  ...require("./event")
+});