@sqrzro/server 2.0.0-bz.12 → 2.0.0-bz.13

package/dist/cache.js

@@ -1,46 +1,8 @@
-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 = {
+import {
   getFromCache,
   setToCache
-});
+} from "./chunk-GOSRKBZX.js";
+export {
+  getFromCache,
+  setToCache
+};

package/dist/chunk-7XG6NQUS.js

@@ -0,0 +1,268 @@
+// src/forms/ValidationService.ts
+import Joi from "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/ValidationError.ts
+var ValidationError = class extends Error {
+  constructor(messages2) {
+    super(JSON.stringify(messages2));
+    this.name = "ValidationError";
+  }
+};
+var ValidationError_default = ValidationError;
+
+// src/forms/ValidationService.ts
+function validate() {
+  return Joi;
+}
+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 Joi.ValidationError) {
+      return [null, transformErrors(err)];
+    }
+    if (err instanceof Error) {
+      return [null, err];
+    }
+    return [null, new Error("Unknown validation error occured")];
+  }
+}
+function createSchema(schema) {
+  return Joi.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];
+}
+
+export {
+  ValidationError_default,
+  validate,
+  validateSchema,
+  createSchema,
+  extendSchema,
+  submitForm
+};

package/dist/chunk-ALBKLI2J.js

@@ -0,0 +1,30 @@
+// src/url/URLService.ts
+import { headers } from "next/headers";
+function getOrigin() {
+  const origin = headers().get("x-origin");
+  if (origin) {
+    return origin;
+  }
+  const proto = headers().get("x-forwarded-proto");
+  const host = headers().get("x-forwarded-host");
+  if (proto && host) {
+    return `${proto}://${host}`;
+  }
+  throw new Error("No origin could be determined");
+}
+function getURL(pathname) {
+  const origin = getOrigin();
+  if (!pathname) {
+    return origin;
+  }
+  const isSecure = origin.startsWith("https://");
+  const protocol = isSecure ? "https://" : "http://";
+  const originWithoutProtocol = origin.replace(/^https?:\/\//u, "");
+  const cleanURL = `${originWithoutProtocol}/${pathname}`.replace(/\/+/gu, "/");
+  return `${protocol}${cleanURL}`;
+}
+
+export {
+  getOrigin,
+  getURL
+};

package/dist/chunk-G4EG2ECB.js

@@ -0,0 +1,47 @@
+// src/database/schema.ts
+import { integer, pgEnum, pgSchema, text, timestamp } from "drizzle-orm/pg-core";
+var DEFAULT_ROLE = 10;
+var mfaType = pgEnum("mfaType", ["TOTP", "HARDWARE"]);
+var scope = pgEnum("scope", ["ANON", "MFA", "AUTHED"]);
+var authSchema = pgSchema("auth");
+var authUserTable = authSchema.table("user_credentials", {
+  id: text("id").primaryKey(),
+  email: text("email").notNull().unique(),
+  password: text("password"),
+  role: integer("role").notNull().default(DEFAULT_ROLE)
+});
+var authSessionTable = authSchema.table("sessions", {
+  id: text("id").primaryKey(),
+  userId: text("userId").notNull().references(() => authUserTable.id),
+  scope: scope("scope").notNull().default("ANON"),
+  expiresAt: timestamp("expiresAt").notNull()
+});
+var authResetTable = authSchema.table("resets", {
+  id: text("id").primaryKey(),
+  userId: text("userId").notNull().references(() => authUserTable.id),
+  expiresAt: timestamp("expiresAt").notNull()
+});
+var authMFATable = authSchema.table("mfas", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  userId: text("userId").notNull().references(() => authUserTable.id),
+  type: mfaType("type").notNull().default("TOTP"),
+  secret: text("secret").notNull(),
+  verifiedAt: timestamp("verifiedAt")
+});
+var authClientTable = authSchema.table("client_credentials", {
+  id: text("id").primaryKey(),
+  alias: text("alias").notNull().unique(),
+  secret: text("secret").notNull().unique()
+});
+
+export {
+  mfaType,
+  scope,
+  authSchema,
+  authUserTable,
+  authSessionTable,
+  authResetTable,
+  authMFATable,
+  authClientTable
+};

package/dist/chunk-GOSRKBZX.js

@@ -0,0 +1,20 @@
+// src/cache/CacheService.ts
+import { createClient } from "redis";
+async function getClient() {
+  const client = 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);
+}
+
+export {
+  getFromCache,
+  setToCache
+};