@sqrzro/server 2.0.0-bz.10 → 2.0.0-bz.11

package/dist/cache.d.ts

@@ -0,0 +1,4 @@
+declare function getFromCache(key: string): Promise<string | null>;
+declare function setToCache(key: string, value: string): Promise<void>;
+
+export { getFromCache, setToCache };

package/dist/cache.js

@@ -0,0 +1,46 @@
+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);
+
+// src/cache/index.ts
+var cache_exports = {};
+__export(cache_exports, {
+  getFromCache: () => getFromCache,
+  setToCache: () => setToCache
+});
+module.exports = __toCommonJS(cache_exports);
+
+// src/cache/CacheService.ts
+var import_redis = require("redis");
+async function getClient() {
+  const client = (0, import_redis.createClient)();
+  await client.connect();
+  return client;
+}
+async function getFromCache(key) {
+  const client = await getClient();
+  return client.get(key);
+}
+async function setToCache(key, value) {
+  const client = await getClient();
+  await client.set(key, value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFromCache,
+  setToCache
+});

package/dist/forms.d.ts

@@ -0,0 +1,46 @@
+import { Errorable } from '@sqrzro/interfaces';
+import Joi from 'joi';
+
+declare class ValidationError extends Error {
+    constructor(messages: Record<string, string>);
+}
+
+interface SubmitFormArgs<F extends object> {
+    formData: F;
+    onSuccess?: (model: F) => Promise<void> | void;
+    onValidationError?: (error: ValidationError) => void;
+    request?: Joi.ObjectSchema<F>;
+}
+interface SubmitFormArgsWithFn<F extends object, M> extends Omit<SubmitFormArgs<F>, 'onSuccess'> {
+    fn: (data: F) => Promise<M | null>;
+    onSuccess?: (model: M) => Promise<void> | void;
+}
+declare function submitForm<F extends object>(args: SubmitFormArgs<F>): Promise<Errorable<F>>;
+declare function submitForm<F extends object, M>(args: SubmitFormArgsWithFn<F, M>): Promise<Errorable<M>>;
+
+interface ImageValidationConfig {
+    maxSize?: number;
+    types?: string[];
+}
+declare function validateImage(image: File | null, config?: ImageValidationConfig): Promise<Errorable<File>>;
+
+declare function validate(): typeof Joi;
+type ValidationCustomHelpers<V = any> = Joi.CustomHelpers<V>;
+type ValidationExternalHelpers<V = any> = Joi.ExternalHelpers<V>;
+type ValidationErrorReport = Joi.ErrorReport;
+/**
+ * This function takes FormData and a schema. It then attempts to transform the FormData into an
+ * object that matches `T`. This is because the FormData object is not typed and we want to be able
+ * to validate it properly typed.
+ *
+ * Once transformed, the object is validated against the schema. This will result in either a
+ * properly typed `T` object or an array of validation errors.
+ * @param formData
+ * @param validation
+ * @returns
+ */
+declare function validateSchema<T>(formData: T, validation: Joi.ObjectSchema<T>): Promise<Errorable<T>>;
+declare function createSchema<T>(schema: Joi.SchemaMap<T, true>): Joi.ObjectSchema<T>;
+declare function extendSchema<T, U extends T>(schema: Joi.ObjectSchema<T>, appends: Joi.PartialSchemaMap<U>): Joi.ObjectSchema<U>;
+
+export { type ValidationCustomHelpers, type ValidationErrorReport, type ValidationExternalHelpers, createSchema, extendSchema, submitForm, validate, validateImage, validateSchema };

package/dist/forms.js

@@ -0,0 +1,327 @@
+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);
+
+// src/forms/index.ts
+var forms_exports = {};
+__export(forms_exports, {
+  createSchema: () => createSchema,
+  extendSchema: () => extendSchema,
+  submitForm: () => submitForm,
+  validate: () => validate,
+  validateImage: () => validateImage,
+  validateSchema: () => validateSchema
+});
+module.exports = __toCommonJS(forms_exports);
+
+// src/forms/ValidationError.ts
+var ValidationError = class extends Error {
+  constructor(messages2) {
+    super(JSON.stringify(messages2));
+    this.name = "ValidationError";
+  }
+};
+var ValidationError_default = ValidationError;
+
+// src/forms/ValidationService.ts
+var import_joi = __toESM(require("joi"));
+
+// src/forms/lang.ts
+var messages = {
+  "alternatives.all": "",
+  "alternatives.any": "",
+  "alternatives.match": "",
+  "alternatives.one": "",
+  "alternatives.types": "",
+  "any.custom": "",
+  "any.default": "",
+  "any.failover": "",
+  "any.invalid": "",
+  "any.only": "",
+  "any.ref": "",
+  "any.required": "{{#label}} is required",
+  "any.unknown": "",
+  "array.base": "",
+  "array.excludes": "",
+  "array.includesRequiredBoth": "",
+  "array.includesRequiredKnowns": "",
+  "array.includesRequiredUnknowns": "",
+  "array.includes": "",
+  "array.length": "",
+  "array.max": "",
+  "array.min": "",
+  "array.orderedLength": "",
+  "array.sort": "",
+  "array.sort.mismatching": "",
+  "array.sort.unsupported": "",
+  "array.sparse": "",
+  "array.unique": "",
+  "array.hasKnown": "",
+  "array.hasUnknown": "",
+  "binary.base": "",
+  "binary.length": "",
+  "binary.max": "",
+  "binary.min": "",
+  "boolean.base": "",
+  "date.base": "",
+  "date.format": "",
+  "date.greater": "",
+  "date.less": "",
+  "date.max": "",
+  "date.min": "",
+  "date.strict": "",
+  "function.arity": "",
+  "function.class": "",
+  "function.maxArity": "",
+  "function.minArity": "",
+  "number.base": "{{#label}} should be a number",
+  "number.greater": "",
+  "number.infinity": "",
+  "number.integer": "",
+  "number.less": "",
+  "number.max": "",
+  "number.min": "{{#label}} should be greater than or equal to {{#limit}}",
+  "number.multiple": "",
+  "number.negative": "",
+  "number.port": "",
+  "number.positive": "",
+  "number.precision": "",
+  "number.unsafe": "",
+  "object.unknown": "",
+  "object.and": "",
+  "object.assert": "",
+  "object.base": "",
+  "object.length": "",
+  "object.max": "",
+  "object.min": "",
+  "object.missing": "",
+  "object.nand": "",
+  "object.pattern.match": "",
+  "object.refType": "",
+  "object.regex": "",
+  "object.rename.multiple": "",
+  "object.rename.override": "",
+  "object.schema": "",
+  "object.instance": "",
+  "object.with": "",
+  "object.without": "",
+  "object.xor": "",
+  "object.oxor": "",
+  "string.alphanum": "",
+  "string.base64": "",
+  "string.base": "",
+  "string.creditCard": "",
+  "string.dataUri": "",
+  "string.domain": "",
+  "string.email": "",
+  "string.empty": "{{#label}} is required",
+  "string.guid": "",
+  "string.hexAlign": "",
+  "string.hex": "",
+  "string.hostname": "",
+  "string.ipVersion": "",
+  "string.ip": "",
+  "string.isoDate": "",
+  "string.isoDuration": "",
+  "string.length": "",
+  "string.lowercase": "",
+  "string.max": "",
+  "string.min": "",
+  "string.normalize": "",
+  "string.pattern.base": "",
+  "string.pattern.name": "",
+  "string.pattern.invert.base": "",
+  "string.pattern.invert.name": "",
+  "string.token": "",
+  "string.trim": "",
+  "string.uppercase": "",
+  "string.uri": "",
+  "string.uriCustomScheme": "",
+  "string.uriRelativeOnly": "",
+  "symbol.base": "",
+  "symbol.map": ""
+};
+var lang_default = messages;
+
+// src/forms/ValidationService.ts
+function validate() {
+  return import_joi.default;
+}
+function getErrorMessages() {
+  return Object.entries(lang_default).reduce((acc, [key, value]) => {
+    if (!value) {
+      return acc;
+    }
+    return {
+      ...acc,
+      [key]: value
+    };
+  }, {});
+}
+function transformErrors(error) {
+  const messages2 = error.details.reduce(
+    (acc, cur) => ({
+      ...acc,
+      [cur.path.join(".")]: cur.message.replace(/"/gu, "")
+    }),
+    {}
+  );
+  return new ValidationError_default(messages2);
+}
+async function validateSchema(formData, validation) {
+  try {
+    const validated = await validation.validateAsync(formData, {
+      abortEarly: false,
+      messages: getErrorMessages()
+    });
+    return [validated, null];
+  } catch (err) {
+    if (err instanceof import_joi.default.ValidationError) {
+      return [null, transformErrors(err)];
+    }
+    if (err instanceof Error) {
+      return [null, err];
+    }
+    return [null, new Error("Unknown validation error occured")];
+  }
+}
+function createSchema(schema) {
+  return import_joi.default.object(schema);
+}
+function extendSchema(schema, appends) {
+  return schema.append(appends);
+}
+
+// src/forms/FormService.ts
+function serializeError(err) {
+  return {
+    cause: err.cause,
+    message: err.message,
+    name: err.name,
+    stack: err.stack
+  };
+}
+function hasFn(args) {
+  return Boolean(Object.prototype.hasOwnProperty.call(args, "fn"));
+}
+async function submitForm(args) {
+  let data = { ...args.formData };
+  if (args.request) {
+    const [validated, validationError] = await validateSchema(args.formData, args.request);
+    if (validationError !== null) {
+      if (validationError instanceof ValidationError_default) {
+        args.onValidationError?.(validationError);
+      }
+      return [null, serializeError(validationError)];
+    }
+    data = validated;
+  }
+  if (!hasFn(args)) {
+    try {
+      await args.onSuccess?.(data);
+    } catch (err) {
+      if (err instanceof Error) {
+        return [null, serializeError(err)];
+      }
+      return [
+        null,
+        serializeError(
+          new Error("The submitForm onSuccess function encountered an unknown error")
+        )
+      ];
+    }
+    return [data, null];
+  }
+  let model = null;
+  try {
+    model = await args.fn(data);
+  } catch (err) {
+    if (err instanceof ValidationError_default) {
+      args.onValidationError?.(err);
+      return [null, serializeError(err)];
+    }
+    if (err instanceof Error) {
+      return [null, serializeError(err)];
+    }
+    return [
+      null,
+      serializeError(
+        new Error("The function supplied to submitForm encountered an unknown error")
+      )
+    ];
+  }
+  if (!model) {
+    return [
+      null,
+      serializeError(
+        new Error("No model has been returned from the function supplied to submitForm")
+      )
+    ];
+  }
+  try {
+    await args.onSuccess?.(model);
+  } catch (err) {
+    if (err instanceof Error) {
+      return [null, serializeError(err)];
+    }
+    return [
+      null,
+      serializeError(
+        new Error("The submitForm onSuccess function encountered an unknown error")
+      )
+    ];
+  }
+  return [model, null];
+}
+
+// src/forms/ImageService.ts
+var DEFAULT_TYPES = ["image/png", "image/jpeg", "image/jpg"];
+var DEFAULT_MAX_SIZE = 5242880;
+async function validateImage(image, config) {
+  if (!image) {
+    return Promise.resolve([null, new Error("IMAGE_UNDEFINED")]);
+  }
+  if (!(image instanceof File)) {
+    return Promise.resolve([null, new Error("IMAGE_NOT_VALID")]);
+  }
+  if (!(config?.types || DEFAULT_TYPES).includes(image.type)) {
+    return Promise.resolve([null, new Error("IMAGE_TYPE_NOT_VALID")]);
+  }
+  if (image.size > (config?.maxSize || DEFAULT_MAX_SIZE)) {
+    return Promise.resolve([null, new Error("IMAGE_TOO_HEAVY")]);
+  }
+  return Promise.resolve([image, null]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSchema,
+  extendSchema,
+  submitForm,
+  validate,
+  validateImage,
+  validateSchema
+});

package/dist/{lists/ListService.d.ts → lists.d.ts}

@@ -1,4 +1,5 @@
-import type { Errorable } from '@sqrzro/interfaces';
+import { Errorable } from '@sqrzro/interfaces';
+
 interface PaginationArgs {
     skip: number;
     take: number;
@@ -12,5 +13,6 @@ interface GetListArgs<T> {
     fn: (args: FindManyArgs) => Promise<T[]>;
     searchParams?: Record<string, string>;
 }
-export declare function getList<T>({ allowedFilters, fn, searchParams, }: GetListArgs<T>): Promise<Errorable<T[]>>;
-export {};
+declare function getList<T>({ allowedFilters, fn, searchParams, }: GetListArgs<T>): Promise<Errorable<T[]>>;
+
+export { getList };

package/dist/lists.js

@@ -0,0 +1,61 @@
+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);
+
+// src/lists/index.ts
+var lists_exports = {};
+__export(lists_exports, {
+  getList: () => getList
+});
+module.exports = __toCommonJS(lists_exports);
+
+// src/lists/ListService.ts
+var import_utility = require("@sqrzro/utility");
+var DEFAULT_SORT = "id";
+var DEFAULT_DIR = "asc";
+var DEFAULT_PAGE = 1;
+var DEFAULT_LIMIT = 10;
+function createPaginationArgs(page) {
+  return { skip: (page - 1) * DEFAULT_LIMIT, take: DEFAULT_LIMIT };
+}
+function createFindManyArgs(searchParams, allowedFilters = []) {
+  const { dir, page, sort, ...filters } = searchParams || {};
+  return {
+    ...createPaginationArgs(page ? parseInt(page, 10) : DEFAULT_PAGE),
+    orderBy: { [sort || DEFAULT_SORT]: dir || DEFAULT_DIR },
+    where: (0, import_utility.getFromObject)(filters, allowedFilters)
+  };
+}
+async function getList({
+  allowedFilters,
+  fn,
+  searchParams
+}) {
+  try {
+    const args = createFindManyArgs(searchParams, allowedFilters);
+    return [await fn(args), null];
+  } catch (err) {
+    if (err instanceof Error) {
+      return [null, err];
+    }
+    return [null, new Error("[getList] An unknown error occurred")];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getList
+});

package/dist/mail.d.ts

@@ -0,0 +1,12 @@
+type MailFn<T extends object> = () => Promise<{
+    subject: string;
+    template: (data: T) => React.ReactElement;
+}>;
+declare function createMail<T extends object>(subject: string, template: (data: T) => React.ReactElement): Promise<MailFn<T>>;
+declare function getMail<T extends object>(mail: MailFn<T>, data: T): Promise<{
+    subject: string;
+    html: string;
+}>;
+declare function sendMail<T extends object>(mail: Promise<MailFn<T>>, data: T, to: string): Promise<boolean>;
+
+export { createMail, getMail, sendMail };

package/dist/mail.js

@@ -0,0 +1,97 @@
+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);
+
+// src/mail/index.ts
+var mail_exports = {};
+__export(mail_exports, {
+  createMail: () => createMail,
+  getMail: () => getMail,
+  sendMail: () => sendMail
+});
+module.exports = __toCommonJS(mail_exports);
+
+// src/mail/MailService.ts
+async function createMail(subject, template) {
+  return Promise.resolve(async () => Promise.resolve({ subject, template }));
+}
+async function getMail(mail, data) {
+  const { subject, template } = await mail();
+  const ReactDOMServer = (await import("react-dom/server")).default;
+  return {
+    subject,
+    html: ReactDOMServer.renderToStaticMarkup(template(data))
+  };
+}
+function getSenderDetails() {
+  if (!process.env.MAIL_FROM) {
+    throw new Error("Mail from address has not been set");
+  }
+  const matches = /^(?<name>[^<]+)<(?<email>[^>]+)>$/u.exec(process.env.MAIL_FROM);
+  if (!matches?.groups?.name || !matches?.groups?.email) {
+    throw new Error(
+      'Mail from address is not the correct format. It should be "Name <email>".'
+    );
+  }
+  return {
+    email: matches.groups.email.trim(),
+    name: matches.groups.name.trim()
+  };
+}
+async function sendMail(mail, data, to) {
+  if (!process.env.MAIL_API_URL) {
+    throw new Error("Mail URL has not been set");
+  }
+  if (!process.env.MAIL_API_KEY) {
+    throw new Error("Mail API key has not been set");
+  }
+  const from = getSenderDetails();
+  const { subject, html } = await getMail(await mail, data);
+  try {
+    const response = await fetch(process.env.MAIL_API_URL, {
+      method: "POST",
+      headers: { "Api-Token": process.env.MAIL_API_KEY, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        from,
+        html,
+        subject,
+        to: [{ email: to }]
+      })
+    });
+    const json = await response.json();
+    return json.success;
+  } catch (err) {
+    console.log("err", err);
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMail,
+  getMail,
+  sendMail
+});

package/dist/middleware.d.ts

@@ -1,3 +1,5 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-export declare function handleMiddleware(request: NextRequest, nextFn?: () => NextResponse): Promise<NextResponse>;
+import { NextRequest, NextResponse } from 'next/server';
+
+declare function handleMiddleware(request: NextRequest, nextFn?: () => NextResponse): Promise<NextResponse>;
+
+export { handleMiddleware };