@cedarjs/api 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/cjs/validations/validations.js

@@ -1,351 +0,0 @@
-"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 validations_exports = {};
-__export(validations_exports, {
-  validate: () => validate,
-  validateUniqueness: () => validateUniqueness,
-  validateWith: () => validateWith,
-  validateWithSync: () => validateWithSync
-});
-module.exports = __toCommonJS(validations_exports);
-var import_client = require("@prisma/client");
-var import_pascalcase = __toESM(require("pascalcase"), 1);
-var ValidationErrors = __toESM(require("./errors.js"), 1);
-const VALIDATORS = {
-  // Requires that the given value is `null` or `undefined`
-  //
-  // `allowEmptyString`: if true, counts "" as being absent (does not throw)
-  //
-  // { absence: true }
-  // { absence: { allowEmptyString: true, message: '...' } }
-  absence: (value, name, options) => {
-    const absenceOptions = { allowEmptyString: false };
-    Object.assign(absenceOptions, options);
-    if (value === "") {
-      if (!absenceOptions.allowEmptyString) {
-        validationError("absence", name, options);
-      }
-    } else if (value != null) {
-      validationError("absence", name, options);
-    }
-  },
-  // Requires that the given field be `true` and nothing else, unless an array
-  // of valid values is included with an `in` option
-  //
-  // { acceptance: true }
-  // { acceptance: { in: ['true','1'], message: '...' } }
-  acceptance: (value, name, options) => {
-    let acceptedValues;
-    if (typeof options === "object") {
-      acceptedValues = options.in || [];
-    } else {
-      acceptedValues = [true];
-    }
-    if (!acceptedValues.includes(value)) {
-      validationError("acceptance", name, options);
-    }
-  },
-  // Requires that the given value be formatted like an email address. Uses a
-  // very simple regex which checks for at least 1 character that is not an @,
-  // then an @, then at least one character that isn't a period, then a period,
-  // then any character. There cannot be any spaces present.
-  //
-  // { email: true }
-  // { email: { message: '...' } }
-  email: (value, name, options) => {
-    const pattern = /^[^@\s]+@[^.\s]+\.[^\s]+$/;
-    if (!pattern.test(String(value))) {
-      validationError("email", name, options);
-    }
-  },
-  // Requires that the given value NOT be in the list of possible values
-  //
-  // { exclusion: ['foo', 'bar'] }
-  // { exclusion: { in: ['foo','bar'], message: '...' } }
-  exclusion: (value, name, options) => {
-    const [exclusionList, val] = prepareExclusionInclusion(value, options);
-    if (exclusionList.includes(val)) {
-      validationError("exclusion", name, options);
-    }
-  },
-  // Requires that the given value match a regular expression
-  //
-  // { format: /^foobar$/ }
-  // { format: { pattern: /^foobar$/, message: '...' } }
-  format: (value, name, options) => {
-    const pattern = options instanceof RegExp ? options : options.pattern;
-    if (pattern == null) {
-      throw new ValidationErrors.FormatValidationError(
-        name,
-        "No pattern for format validation"
-      );
-    }
-    if (!pattern.test(String(value))) {
-      validationError("format", name, options);
-    }
-  },
-  // Requires that the given value be in the list of possible values
-  //
-  // { inclusion: ['foo', 'bar'] }
-  // { inclusion: { in: ['foo','bar'], message: '...' } }
-  inclusion: (value, name, options) => {
-    const [inclusionList, val] = prepareExclusionInclusion(value, options);
-    if (!inclusionList.includes(val)) {
-      validationError("inclusion", name, options);
-    }
-  },
-  // Requires that the given string be a certain length:
-  //
-  // `min`: must be at least `min` characters
-  // `max`: must be no more than `max` characters
-  // `equal`: must be exactly `equal` characters
-  // `between`: an array consisting of the `min` and `max` length
-  //
-  // { length: { min: 4 } }
-  // { length: { min: 2, max: 16 } }
-  // { length: { between: [2, 16], message: '...' } }
-  length: (value, name, options) => {
-    const len = String(value).length;
-    if (options.min && len < options.min) {
-      validationError("minLength", name, options, { min: options.min });
-    }
-    if (options.max && len > options.max) {
-      validationError("maxLength", name, options, { max: options.max });
-    }
-    if (options.equal && len !== options.equal) {
-      validationError("equalLength", name, options, { equal: options.equal });
-    }
-    if (options.between && (len < options.between[0] || len > options.between[1])) {
-      validationError("betweenLength", name, options, {
-        min: options.between[0],
-        max: options.between[1]
-      });
-    }
-  },
-  // Requires that number value meets some criteria:
-  //
-  // `integer`: value must be an integer
-  // `lessThan`: value must be less than `lessThan`
-  // `lessThanOrEqual`: value must be less than or equal to `lessThanOrEqual`
-  // `greaterThan`: value must be greater than `greaterThan`
-  // `greaterThanOrEqual`: value must be greater than or equal to `greaterThanOrEqual`
-  // `equal`: value must equal `equal`
-  // `otherThan`: value must be anything other than `otherThan`
-  // `even`: value must be an even number
-  // `odd`: value must be an odd number
-  // `positive`: value must be a positive number
-  // `negative`: value must be a negative number
-  //
-  // { numericality: true }
-  // { numericality: { integer: true } }
-  // { numericality: { greaterThan: 3.5, message: '...' } }
-  numericality: (value, name, options) => {
-    if (typeof value !== "number") {
-      validationError("typeNumericality", name, options);
-    }
-    if (typeof options === "boolean") {
-      return;
-    } else {
-      if (options.integer && !Number.isInteger(value)) {
-        validationError("integerNumericality", name, options);
-      }
-      if (options.lessThan != null && value >= options.lessThan) {
-        validationError("lessThanNumericality", name, options, {
-          lessThan: options.lessThan
-        });
-      }
-      if (options.lessThanOrEqual != null && value > options.lessThanOrEqual) {
-        validationError("lessThanOrEqualNumericality", name, options, {
-          lessThanOrEqual: options.lessThanOrEqual
-        });
-      }
-      if (options.greaterThan != null && value <= options.greaterThan) {
-        validationError("greaterThanNumericality", name, options, {
-          greaterThan: options.greaterThan
-        });
-      }
-      if (options.greaterThanOrEqual != null && value < options.greaterThanOrEqual) {
-        validationError("greaterThanOrEqualNumericality", name, options, {
-          greaterThanOrEqual: options.greaterThanOrEqual
-        });
-      }
-      if (options.equal != null && value !== options.equal) {
-        validationError("equalNumericality", name, options, {
-          equal: options.equal
-        });
-      }
-      if (options.otherThan != null && value === options.otherThan) {
-        validationError("otherThanNumericality", name, options, {
-          otherThan: options.otherThan
-        });
-      }
-      if (options.even && value % 2 !== 0) {
-        validationError("evenNumericality", name, options);
-      }
-      if (options.odd && value % 2 !== 1) {
-        validationError("oddNumericality", name, options);
-      }
-      if (options.positive && value <= 0) {
-        validationError("positiveNumericality", name, options);
-      }
-      if (options.negative && value >= 0) {
-        validationError("negativeNumericality", name, options);
-      }
-    }
-  },
-  // Requires that the given value is not `null` or `undefined`. By default will
-  // consider an empty string to pass
-  //
-  // `allowEmptyString`: if set to `false` will throw an error if value is ""
-  // `allowNull`: if `true` will allow `null`
-  // `allowUndefined`: if `true` will allow `undefined`
-  //
-  // Default behavior is equivalent to:
-  //   { allowNull: false, allowUndefined: false, allowEmptyString: true }
-  //
-  // { presence: true }
-  // { presence: { allowEmptyString: false, message: '...' } }
-  presence: (value, name, options) => {
-    const presenceOptions = {
-      allowNull: false,
-      allowUndefined: false,
-      allowEmptyString: true
-    };
-    Object.assign(presenceOptions, options);
-    if (!presenceOptions.allowNull && value === null || !presenceOptions.allowUndefined && value === void 0 || !presenceOptions.allowEmptyString && value === "") {
-      validationError("presence", name, options);
-    }
-  },
-  custom: (_value, name, options) => {
-    try {
-      options.with();
-    } catch (e) {
-      const message = options.message || e.message || e;
-      validationError("custom", name, { message });
-    }
-  }
-};
-const fieldsToString = (fields) => {
-  const output = [];
-  for (const [key, _value] of Object.entries(fields)) {
-    output.push(key);
-  }
-  return output.join(", ");
-};
-const validationError = (type, name, options, substitutions = {}) => {
-  const errorClassName = `${(0, import_pascalcase.default)(
-    type
-  )}ValidationError`;
-  const ErrorClass = ValidationErrors[errorClassName];
-  const errorMessage = typeof options === "object" ? options.message : void 0;
-  throw new ErrorClass(name, errorMessage, substitutions);
-};
-const prepareExclusionInclusion = (value, options) => {
-  const inputList = Array.isArray(options) && options || options.in || [];
-  const caseSensitive = Array.isArray(options) ? true : options.caseSensitive ?? true;
-  return caseSensitive ? [inputList, value] : [
-    inputList.map((s) => s.toLowerCase()),
-    value.toLowerCase()
-  ];
-};
-function validate(value, labelOrRecipe, recipe) {
-  let label, validationRecipe;
-  if (typeof labelOrRecipe === "object") {
-    label = "";
-    validationRecipe = labelOrRecipe;
-  } else {
-    label = labelOrRecipe;
-    validationRecipe = recipe;
-  }
-  for (const [validator, options] of Object.entries(validationRecipe)) {
-    if (typeof options === "undefined") {
-      continue;
-    }
-    VALIDATORS[validator](value, label, options);
-  }
-}
-const validateWithSync = (func) => {
-  try {
-    func();
-  } catch (e) {
-    const message = e.message || e;
-    throw new ValidationErrors.ServiceValidationError(message);
-  }
-};
-const validateWith = async (func) => {
-  try {
-    await func();
-  } catch (e) {
-    const message = e.message || e;
-    throw new ValidationErrors.ServiceValidationError(message);
-  }
-};
-async function validateUniqueness(model, fields, optionsOrCallback, callback) {
-  const { $self, $scope, ...rest } = fields;
-  let options = {};
-  let validCallback;
-  let db = null;
-  if (typeof optionsOrCallback === "function") {
-    validCallback = optionsOrCallback;
-  } else {
-    options = optionsOrCallback;
-    validCallback = callback;
-  }
-  if (options.db) {
-    const { db: customDb, ...restOptions } = options;
-    options = restOptions;
-    db = customDb;
-  } else {
-    db = new import_client.PrismaClient();
-  }
-  const where = {
-    AND: [rest],
-    NOT: []
-  };
-  if ($scope) {
-    where.AND.push($scope);
-  }
-  if ($self) {
-    where.NOT.push($self);
-  }
-  return await db.$transaction(async (tx) => {
-    const found = await tx[model].findFirst({ where });
-    if (found) {
-      validationError("uniqueness", fieldsToString(fields), options);
-    }
-    return validCallback(tx);
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  validate,
-  validateUniqueness,
-  validateWith,
-  validateWithSync
-});

package/dist/cjs/webhooks/index.d.ts

@@ -1,77 +0,0 @@
-import type { APIGatewayProxyEvent } from 'aws-lambda';
-import type { VerifyOptions, SupportedVerifierTypes } from '../auth/verifiers/common.js';
-import { WebhookVerificationError, DEFAULT_WEBHOOK_SECRET } from '../auth/verifiers/index.js';
-export type { VerifyOptions, SupportedVerifierTypes };
-export { WebhookVerificationError, DEFAULT_WEBHOOK_SECRET };
-export declare const DEFAULT_WEBHOOK_SIGNATURE_HEADER = "RW-WEBHOOK-SIGNATURE";
-/**
- * Extracts signature from Lambda Event.
- *
- * @param {APIGatewayProxyEvent} event - The event that includes the request details, like headers
- * @param {string} signatureHeader - The name of header key that contains the signature; defaults to DEFAULT_WEBHOOK_SIGNATURE_HEADER
- * @return {string} - The signature found in the headers specified by signatureHeader
- *
- * @example
- *
- *    signatureFromEvent({ event: event })
- */
-export declare const signatureFromEvent: ({ event, signatureHeader, }: {
-    event: APIGatewayProxyEvent;
-    signatureHeader: string;
-}) => string;
-/**
- * Verifies event payload is signed with a valid webhook signature.
- *
- * @param {APIGatewayProxyEvent} event - The event that includes the body for the verification payload and request details, like headers.
- * @param {string} payload - If provided, the payload will be used to verify the signature instead of the event body.
- * @param {string} secret - The secret that will verify the signature according to the verifier type
- * @param {VerifyOptions} options - Options to specify the verifier type the header key that contains the signature, timestamp leeway.
- * @return {boolean | WebhookVerificationError} - Returns true if the signature is verified, or raises WebhookVerificationError.
- *
- * @example
- *
- *    verifyEvent({ event: event, options: {} })*
- */
-export declare const verifyEvent: (type: SupportedVerifierTypes, { event, payload, secret, options, }: {
-    event: APIGatewayProxyEvent;
-    payload?: string;
-    secret?: string;
-    options?: VerifyOptions | undefined;
-}) => boolean | WebhookVerificationError;
-/**
- * Standalone verification of webhook signature given a payload, secret, verifier type and options.
- *
- * @param {string} payload - Body content of the event
- * @param {string} secret - The secret that will verify the signature according to the verifier type
- * @param {string} signature - Signature that verifies that the event
- * @param {VerifyOptions} options - Options to specify the verifier type the header key that contains the signature, timestamp leeway.
- * @return {boolean | WebhookVerificationError} - Returns true if the signature is verified, or raises WebhookVerificationError.
- *
- * @example
- *
- *    verifySignature({ payload, secret, signature, options: {} })*
- */
-export declare const verifySignature: (type: SupportedVerifierTypes, { payload, secret, signature, options, }: {
-    payload: string | Record<string, unknown>;
-    secret: string;
-    signature: string;
-    options?: VerifyOptions | undefined;
-}) => boolean | WebhookVerificationError;
-/**
- * Signs a payload with a secret and verifier type method
- *
- * @param {string} payload - Body content of the event to sign
- * @param {string} secret - The secret that will verify the signature according to the verifier type
- * @param {VerifyOptions} options - Options to specify the verifier type the header key that contains the signature, timestamp leeway.
- * @return {string} - Returns signature
- *
- * @example
- *
- *    signPayload({ payload, secret, options: {} })*
- */
-export declare const signPayload: (type: SupportedVerifierTypes, { payload, secret, options, }: {
-    payload: string;
-    secret: string;
-    options?: VerifyOptions | undefined;
-}) => string;
-//# sourceMappingURL=index.d.ts.map

package/dist/cjs/webhooks/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,OAAO,KAAK,EACV,aAAa,EACb,sBAAsB,EACvB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAEL,wBAAwB,EACxB,sBAAsB,EAEvB,MAAM,4BAA4B,CAAA;AAEnC,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,CAAA;AACrD,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,CAAA;AAC3D,eAAO,MAAM,gCAAgC,yBAAyB,CAAA;AActE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,6BAGhC;IACD,KAAK,EAAE,oBAAoB,CAAA;IAC3B,eAAe,EAAE,MAAM,CAAA;CACxB,KAAG,MAGH,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GACtB,MAAM,sBAAsB,EAC5B,sCAKG;IACD,KAAK,EAAE,oBAAoB,CAAA;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACpC,KACA,OAAO,GAAG,wBAgCZ,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,GAC1B,MAAM,sBAAsB,EAC5B,0CAKG;IACD,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACpC,KACA,OAAO,GAAG,wBAIZ,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GACtB,MAAM,sBAAsB,EAC5B,+BAIG;IACD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACpC,KACA,MAIF,CAAA"}

package/dist/cjs/webhooks/index.js

@@ -1,102 +0,0 @@
-"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 webhooks_exports = {};
-__export(webhooks_exports, {
-  DEFAULT_WEBHOOK_SECRET: () => import_verifiers.DEFAULT_WEBHOOK_SECRET,
-  DEFAULT_WEBHOOK_SIGNATURE_HEADER: () => DEFAULT_WEBHOOK_SIGNATURE_HEADER,
-  WebhookVerificationError: () => import_verifiers.WebhookVerificationError,
-  signPayload: () => signPayload,
-  signatureFromEvent: () => signatureFromEvent,
-  verifyEvent: () => verifyEvent,
-  verifySignature: () => verifySignature
-});
-module.exports = __toCommonJS(webhooks_exports);
-var import_verifiers = require("../auth/verifiers/index.js");
-const DEFAULT_WEBHOOK_SIGNATURE_HEADER = "RW-WEBHOOK-SIGNATURE";
-const eventBody = (event) => {
-  if (event.isBase64Encoded) {
-    return Buffer.from(event.body || "", "base64").toString("utf-8");
-  } else {
-    return event.body || "";
-  }
-};
-const signatureFromEvent = ({
-  event,
-  signatureHeader = DEFAULT_WEBHOOK_SIGNATURE_HEADER
-}) => {
-  const header = signatureHeader.toLocaleLowerCase();
-  return event.headers[header];
-};
-const verifyEvent = (type, {
-  event,
-  payload,
-  secret = import_verifiers.DEFAULT_WEBHOOK_SECRET,
-  options
-}) => {
-  let body = "";
-  if (payload) {
-    body = payload;
-  } else {
-    body = eventBody(event);
-  }
-  let signature = signatureFromEvent({
-    event,
-    signatureHeader: options?.signatureHeader || DEFAULT_WEBHOOK_SIGNATURE_HEADER
-  });
-  if (options?.signatureTransformer) {
-    signature = options.signatureTransformer(signature);
-  }
-  if (options?.eventTimestamp) {
-    const timestamp = options?.currentTimestampOverride ?? Date.now();
-    const difference = Math.abs(timestamp - options?.eventTimestamp);
-    const tolerance = options?.tolerance ?? import_verifiers.DEFAULT_TOLERANCE;
-    if (difference > tolerance) {
-      throw new import_verifiers.WebhookVerificationError();
-    }
-  }
-  const { verify } = (0, import_verifiers.createVerifier)(type, options);
-  return verify({ payload: body, secret, signature });
-};
-const verifySignature = (type, {
-  payload,
-  secret = import_verifiers.DEFAULT_WEBHOOK_SECRET,
-  signature,
-  options
-}) => {
-  const { verify } = (0, import_verifiers.createVerifier)(type, options);
-  return verify({ payload, secret, signature });
-};
-const signPayload = (type, {
-  payload,
-  secret = import_verifiers.DEFAULT_WEBHOOK_SECRET,
-  options
-}) => {
-  const { sign } = (0, import_verifiers.createVerifier)(type, options);
-  return sign({ payload, secret });
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_WEBHOOK_SECRET,
-  DEFAULT_WEBHOOK_SIGNATURE_HEADER,
-  WebhookVerificationError,
-  signPayload,
-  signatureFromEvent,
-  verifyEvent,
-  verifySignature
-});