@redmix/api 0.0.1

package/dist/validations/validations.js

@@ -0,0 +1,351 @@
+"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"));
+var ValidationErrors = __toESM(require("./errors"));
+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/webhooks/index.d.ts

@@ -0,0 +1,76 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+import type { VerifyOptions, SupportedVerifierTypes } from '../auth/verifiers';
+import { WebhookVerificationError } from '../auth/verifiers';
+export { VerifyOptions, WebhookVerificationError, DEFAULT_WEBHOOK_SECRET, SupportedVerifierTypes, } from '../auth/verifiers';
+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/webhooks/index.d.ts.map

@@ -0,0 +1 @@
+{"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,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC9E,OAAO,EAEL,wBAAwB,EAGzB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,mBAAmB,CAAA;AAE1B,eAAO,MAAM,gCAAgC,yBAAyB,CAAA;AActE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,gCAG5B;IACD,KAAK,EAAE,oBAAoB,CAAA;IAC3B,eAAe,EAAE,MAAM,CAAA;CACxB,KAAG,MAGH,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,SAChB,sBAAsB,wCAMzB;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,SACpB,sBAAsB,4CAMzB;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,SAChB,sBAAsB,iCAKzB;IACD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACpC,KACA,MAIF,CAAA"}

package/dist/webhooks/index.js

@@ -0,0 +1,107 @@
+"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_verifiers2.DEFAULT_WEBHOOK_SECRET,
+  DEFAULT_WEBHOOK_SIGNATURE_HEADER: () => DEFAULT_WEBHOOK_SIGNATURE_HEADER,
+  SupportedVerifierTypes: () => import_verifiers2.SupportedVerifierTypes,
+  VerifyOptions: () => import_verifiers2.VerifyOptions,
+  WebhookVerificationError: () => import_verifiers2.WebhookVerificationError,
+  signPayload: () => signPayload,
+  signatureFromEvent: () => signatureFromEvent,
+  verifyEvent: () => verifyEvent,
+  verifySignature: () => verifySignature
+});
+module.exports = __toCommonJS(webhooks_exports);
+var import_verifiers = require("../auth/verifiers");
+var import_verifiers2 = require("../auth/verifiers");
+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,
+  SupportedVerifierTypes,
+  VerifyOptions,
+  WebhookVerificationError,
+  signPayload,
+  signatureFromEvent,
+  verifyEvent,
+  verifySignature
+});

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@redmix/api",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redmix-run/redmix.git",
+    "directory": "packages/api"
+  },
+  "license": "MIT",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./cache": {
+      "types": "./dist/cache/index.d.ts",
+      "default": "./dist/cache/index.js"
+    },
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "default": "./dist/logger/index.js"
+    },
+    "./webhooks": {
+      "types": "./dist/webhooks/index.d.ts",
+      "default": "./dist/webhooks/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "redwood": "./dist/bins/redwood.js",
+    "rw": "./dist/bins/redwood.js",
+    "rwfw": "./dist/bins/rwfw.js",
+    "tsc": "./dist/bins/tsc.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts && yarn build:types",
+    "build:pack": "yarn pack -o redmix-api.tgz",
+    "build:types": "tsc --build --verbose ./tsconfig.json",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build\"",
+    "check:attw": "yarn rw-fwtools-attw",
+    "check:package": "concurrently npm:check:attw yarn:publint",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@prisma/client": "5.20.0",
+    "@whatwg-node/fetch": "0.9.21",
+    "cookie": "0.7.2",
+    "humanize-string": "2.1.0",
+    "jsonwebtoken": "9.0.2",
+    "pascalcase": "1.0.0",
+    "pino": "9.4.0",
+    "title-case": "3.0.3"
+  },
+  "devDependencies": {
+    "@redmix/framework-tools": "0.0.1",
+    "@types/aws-lambda": "8.10.145",
+    "@types/jsonwebtoken": "9.0.8",
+    "@types/memjs": "1",
+    "@types/pascalcase": "1.0.3",
+    "@types/split2": "4.2.3",
+    "concurrently": "8.2.2",
+    "memjs": "1.3.2",
+    "publint": "0.3.11",
+    "redis": "4.7.0",
+    "split2": "4.2.0",
+    "ts-toolbelt": "9.6.0",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "memjs": "1.3.2",
+    "redis": "4.7.0"
+  },
+  "peerDependenciesMeta": {
+    "memjs": {
+      "optional": true
+    },
+    "redis": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "688027c97502c500ebbede9cdc7cc51545a8dcf3"
+}