equipped 5.3.0 → 5.3.2

package/dist/types/{chunk-YTY3EFNB.js → chunk-BKDWUJRG.js}

@@ -19,12 +19,12 @@ __export(valleyed_exports, {
   withResponse: () => withResponse
 });
 import { AsyncLocalStorage } from "async_hooks";
-import { PipeError as PipeError2, v as v6 } from "valleyed";
+import { PipeError as PipeError2, v as v5 } from "valleyed";
 
 // src/instance/index.ts
 import pino from "pino";
 import { ulid } from "ulid";
-import { v as v5 } from "valleyed";
+import { v as v4 } from "valleyed";
 
 // src/errors/equippedError.ts
 var EquippedError = class extends Error {
@@ -51,7 +51,7 @@ import "@fastify/cors";
 import "cors";
 import { Server as SocketServer } from "socket.io";
 import supertest from "supertest";
-import { PipeError, v as v3 } from "valleyed";
+import { PipeError, v as v2 } from "valleyed";
 
 // src/server/openapi.ts
 import { convert } from "@openapi-contrib/json-schema-to-openapi-schema";
@@ -337,266 +337,6 @@ var openapi = (config) => {
   };
 };
 
-// src/utilities/authProviders.ts
-var authProviders_exports = {};
-__export(authProviders_exports, {
-  signinWithApple: () => signinWithApple,
-  signinWithFacebook: () => signinWithFacebook,
-  signinWithGoogle: () => signinWithGoogle
-});
-import axios from "axios";
-import jwt from "jsonwebtoken";
-import jwksClient from "jwks-rsa";
-var signinWithGoogle = async (idToken) => {
-  const authUrl = `https://oauth2.googleapis.com/tokeninfo?id_token=${idToken}`;
-  const { data } = await axios.get(authUrl).catch((err) => {
-    throw new EquippedError("Failed to sign in with google", { idToken }, err);
-  });
-  data.first_name = data.given_name;
-  data.last_name = data.family_name;
-  return data;
-};
-var signinWithApple = async (idToken) => {
-  try {
-    const APPLE_BASE = "https://appleid.apple.com";
-    const json = jwt.decode(idToken, { complete: true });
-    if (!json?.header) throw new EquippedError("Missing JWT header", { idToken, json });
-    const { kid, alg } = json.header;
-    const publicKey = await jwksClient({ jwksUri: `${APPLE_BASE}/auth/keys`, cache: true }).getSigningKey(kid).then((key) => key.getPublicKey()).catch(() => null);
-    if (!publicKey) throw new EquippedError("no publicKey", { idToken, publicKey, json });
-    const data = jwt.verify(idToken, publicKey, { algorithms: [alg] });
-    if (!data) throw new EquippedError("no data", { idToken, data });
-    if (data.iss !== APPLE_BASE) throw new EquippedError("iss doesnt match", { idToken, data });
-    if (data.exp * 1e3 < Date.now()) throw new EquippedError("expired idToken", { idToken, data });
-    return data;
-  } catch (err) {
-    throw new EquippedError("Failed to sign in with apple", { idToken }, err);
-  }
-};
-var signinWithFacebook = async (accessToken, fields = []) => {
-  fields = [.../* @__PURE__ */ new Set([...fields, "name", "picture", "email"])];
-  const { data } = await axios.request({
-    method: "get",
-    url: "https://graph.facebook.com/v15.0/me",
-    params: {
-      fields: fields.join(","),
-      access_token: accessToken
-    }
-  }).catch((err) => {
-    throw new EquippedError("Failed to sign in with facebook", { accessToken, fields }, err);
-  });
-  const isValidData = fields.every((key) => key in data);
-  if (!isValidData) throw new EquippedError("Incomplete scope for access token", { accessToken, fields, data });
-  data.email_verified = "true";
-  return data;
-};
-
-// src/utilities/configurable.ts
-import { v as v2 } from "valleyed";
-function configurable(pipeFn, base) {
-  const pipe = pipeFn();
-  v2.compile(pipe);
-  class Configurable extends base {
-    constructor(config, ...baseArgs) {
-      super(...baseArgs);
-      this.config = config;
-    }
-    static create(input, ...args) {
-      const r = v2.validate(pipe, input);
-      if (!r.valid) throw r.error;
-      return new this(r.value, ...args);
-    }
-  }
-  return Configurable;
-}
-if (void 0) {
-  const { describe, test, expect, expectTypeOf } = void 0;
-  const { v: v8 } = await null;
-  const testPipe = () => v8.object({
-    host: v8.string(),
-    port: v8.number()
-  });
-  class TestBase {
-    baseValue;
-    constructor() {
-      this.baseValue = "base";
-    }
-  }
-  class TestBaseWithArgs {
-    label;
-    constructor(label) {
-      this.label = label;
-    }
-  }
-  describe("configurable", () => {
-    test("validation runs in static create before constructor body executes", () => {
-      let constructorRan = false;
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          constructorRan = true;
-        }
-      }
-      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
-      expect(constructorRan).toBe(false);
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(constructorRan).toBe(true);
-    });
-    test("constructor receives validated value", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      let receivedConfig;
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          receivedConfig = this.config;
-        }
-      }
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
-    });
-    test("external new is a compile error", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      void (() => new MyClass({ host: "localhost", port: 3e3 }));
-    });
-    test("static Config resolves to PipeOutput<P> at the type level", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      expectTypeOf().toEqualTypeOf();
-      expect(MyClass.create).toBeTypeOf("function");
-    });
-    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        extra;
-        constructor(config, extra) {
-          super(config);
-          this.extra = extra;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
-      expect(instance.extra).toBe(42);
-      expectTypeOf(instance).toHaveProperty("extra");
-      expectTypeOf(instance.extra).toEqualTypeOf();
-      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
-    });
-    test("base-args forwarding works for non-zero-arg bases", () => {
-      const Wrapped = configurable(testPipe, TestBaseWithArgs);
-      class MyClass extends Wrapped {
-        constructor(config, label) {
-          super(config, label);
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
-      expect(instance.label).toBe("test-label");
-    });
-    test("config is accessible as protected readonly on instances", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        getHost() {
-          return this.config.host;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 });
-      expect(instance.getHost()).toBe("localhost");
-    });
-    test("accepts an abstract base class", () => {
-      class AbstractBase {
-      }
-      const Wrapped = configurable(testPipe, AbstractBase);
-      class Concrete extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        greet() {
-          return `hello from ${this.config.host}`;
-        }
-      }
-      const instance = Concrete.create({ host: "localhost", port: 3e3 });
-      expect(instance.greet()).toBe("hello from localhost");
-      expectTypeOf(instance).toHaveProperty("config");
-    });
-  });
-}
-
-// src/utilities/hash.ts
-var hash_exports = {};
-__export(hash_exports, {
-  compare: () => compare2,
-  hash: () => hash2
-});
-import * as bcrypt from "bcryptjs";
-var hash2 = async (password) => {
-  password = password.trim();
-  if (!password) return "";
-  return await bcrypt.hash(password, Instance.get().settings.utils.hashSaltRounds);
-};
-var compare2 = async (plainPassword, hashed) => {
-  plainPassword = plainPassword.trim();
-  if (!plainPassword && plainPassword === hashed) return true;
-  return await bcrypt.compare(plainPassword, hashed);
-};
-
-// src/utilities/json.ts
-var parseJSONValue = (data) => {
-  try {
-    if (data?.constructor?.name !== "String") return data;
-    return JSON.parse(data);
-  } catch {
-    return data;
-  }
-};
-function parseJSONObject(data) {
-  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, parseJSONValue(value)]));
-}
-
-// src/utilities/media.ts
-import { parseBuffer } from "music-metadata";
-var getMediaDuration = async (buffer) => {
-  try {
-    const meta = await parseBuffer(buffer);
-    return meta.format.duration ?? 0;
-  } catch {
-    return 0;
-  }
-};
-
-// src/utilities/random.ts
-var random_exports = {};
-__export(random_exports, {
-  number: () => number,
-  string: () => string
-});
-import crypto from "crypto";
-function string(length = 20) {
-  return crypto.randomBytes(length).toString("hex").slice(0, length);
-}
-function number(min = 0, max = 2 ** 48 - 1) {
-  return crypto.randomInt(min, max);
-}
-
-// src/utilities/retry.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var retry = async (cb, tries, waitTimeInMs) => {
-  if (tries <= 0) throw new EquippedError("out of tries", { tries, waitTimeInMs });
-  const result = await cb();
-  if (result.done === true) return result.value;
-  await sleep(waitTimeInMs);
-  return await retry(cb, tries - 1, waitTimeInMs);
-};
-
 // src/server/requests.ts
 var Request = class {
   ip;
@@ -625,8 +365,10 @@ var Request = class {
     this.params = params;
     this.cookies = cookies;
     this.headers = headers;
-    this.query = parseJSONObject(query);
-    this.body = Object.assign(parseJSONObject(body), files);
+    const hasFiles = Object.keys(files).length > 0;
+    const bodyFields = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    this.query = query;
+    this.body = hasFiles ? Object.assign({}, bodyFields, files) : body;
   }
   pipe(stream, opts = {}) {
     return new Response({ ...opts, piped: true, body: stream });
@@ -672,6 +414,83 @@ var Response = class {
     });
   }
 };
+if (void 0) {
+  const { describe, expect, test } = void 0;
+  describe("Request", () => {
+    test("preserves adapter-provided query and body values without JSON normalization", () => {
+      const query = {
+        count: "10",
+        active: "true",
+        filter: '{"name":"test"}',
+        quoted: '"value"'
+      };
+      const body = {
+        count: "10",
+        active: "false",
+        payload: '{"nested":true}',
+        quoted: '"value"'
+      };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query,
+        method: "post",
+        path: "/items",
+        headers: {},
+        files: {}
+      });
+      expect(request.query).toEqual(query);
+      expect(request.body).toEqual(body);
+    });
+    test("continues merging uploaded files into body fields without parsing string fields", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const body = { metadata: '{"alt":"avatar"}' };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ metadata: '{"alt":"avatar"}', avatar: [file] });
+    });
+    test("does not spread non-object body values when uploaded files are present", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const request = new Request({
+        ip: void 0,
+        body: "raw text body",
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ avatar: [file] });
+    });
+  });
+}
 
 // src/server/requests-auth-methods/base.ts
 import "http2";
@@ -709,7 +528,7 @@ var BaseApiKeyRequestAuthMethod = class extends BaseRequestAuthMethod {
 
 // src/server/requests-auth-methods/jwt.ts
 import cookie from "@fastify/cookie";
-import jwt2 from "jsonwebtoken";
+import jwt from "jsonwebtoken";
 var BaseJwtRequestAuthMethod = class extends BaseRequestAuthMethod {
   options;
   constructor(options) {
@@ -720,14 +539,14 @@ var BaseJwtRequestAuthMethod = class extends BaseRequestAuthMethod {
     return `${this.options.storagePrefix ?? ""}${userId}`;
   }
   async createToken(payload) {
-    const token = jwt2.sign(payload, this.options.signingKey, { expiresIn: this.options.storageTTL });
+    const token = jwt.sign(payload, this.options.signingKey, { expiresIn: this.options.storageTTL });
     await this.store(this.#getKey(payload.id), token, this.options.storageTTL);
     return token;
   }
   async parse(headers) {
     try {
       const token = await this.parseHeader(headers);
-      const user = jwt2.verify(token, this.options.signingKey);
+      const user = jwt.verify(token, this.options.signingKey);
       if (!user) throw new NotAuthenticatedError();
       if (this.options.enforceSingleSession) {
         const cachedToken = await this.retrieve(this.#getKey(user.id));
@@ -736,7 +555,7 @@ var BaseJwtRequestAuthMethod = class extends BaseRequestAuthMethod {
       return user;
     } catch (err) {
       if (err instanceof TokenExpired) throw err;
-      if (err instanceof jwt2.TokenExpiredError) throw new TokenExpired(void 0, err);
+      if (err instanceof jwt.TokenExpiredError) throw new TokenExpired(void 0, err);
       else throw new NotAuthenticatedError(void 0, err);
     }
   }
@@ -891,50 +710,50 @@ var SocketEmitter = class {
 };
 
 // src/server/adapters/base.ts
-var serverConfigPipe = () => v3.object({
-  port: v3.number(),
-  cors: v3.optional(
-    v3.object({
-      origin: v3.optional(v3.or([v3.array(v3.string()), v3.is(true)])),
-      methods: v3.optional(v3.array(v3.in(Object.values(Methods)))),
-      credentials: v3.optional(v3.boolean())
+var serverConfigPipe = () => v2.object({
+  port: v2.number(),
+  cors: v2.optional(
+    v2.object({
+      origin: v2.optional(v2.or([v2.array(v2.string()), v2.is(true)])),
+      methods: v2.optional(v2.array(v2.in(Object.values(Methods)))),
+      credentials: v2.optional(v2.boolean())
     })
   ),
-  eventBus: v3.optional(v3.instanceOf(EventBus)),
-  publicPath: v3.optional(v3.string()),
-  healthPath: v3.optional(v3.string()),
-  openapi: v3.defaults(
-    v3.object({
-      docsVersion: v3.defaults(v3.string(), "1.0.0"),
-      docsBaseUrl: v3.defaults(v3.array(v3.string()), ["/"]),
-      docsPath: v3.defaults(v3.string(), "/__docs")
+  eventBus: v2.optional(v2.instanceOf(EventBus)),
+  publicPath: v2.optional(v2.string()),
+  healthPath: v2.optional(v2.string()),
+  openapi: v2.defaults(
+    v2.object({
+      docsVersion: v2.defaults(v2.string(), "1.0.0"),
+      docsBaseUrl: v2.defaults(v2.array(v2.string()), ["/"]),
+      docsPath: v2.defaults(v2.string(), "/__docs")
     }),
     {}
   ),
-  requests: v3.defaults(
-    v3.object({
-      log: v3.defaults(v3.boolean(), true),
-      rateLimit: v3.defaults(
-        v3.object({
-          enabled: v3.defaults(v3.boolean(), false),
-          periodInMs: v3.defaults(v3.number(), 60 * 60 * 1e3),
-          limit: v3.defaults(v3.number(), 5e3)
+  requests: v2.defaults(
+    v2.object({
+      log: v2.defaults(v2.boolean(), true),
+      rateLimit: v2.defaults(
+        v2.object({
+          enabled: v2.defaults(v2.boolean(), false),
+          periodInMs: v2.defaults(v2.number(), 60 * 60 * 1e3),
+          limit: v2.defaults(v2.number(), 5e3)
         }),
         {}
       ),
-      slowdown: v3.defaults(
-        v3.object({
-          enabled: v3.defaults(v3.boolean(), false),
-          periodInMs: v3.defaults(v3.number(), 10 * 60 * 1e3),
-          delayAfter: v3.defaults(v3.number(), 2e3),
-          delayInMs: v3.defaults(v3.number(), 500)
+      slowdown: v2.defaults(
+        v2.object({
+          enabled: v2.defaults(v2.boolean(), false),
+          periodInMs: v2.defaults(v2.number(), 10 * 60 * 1e3),
+          delayAfter: v2.defaults(v2.number(), 2e3),
+          delayInMs: v2.defaults(v2.number(), 500)
         }),
         {}
       )
     }),
     {}
   ),
-  socketsAuthMethods: v3.defaults(v3.array(v3.instanceOf(BaseRequestAuthMethod)), [])
+  socketsAuthMethods: v2.defaults(v2.array(v2.instanceOf(BaseRequestAuthMethod)), [])
 });
 var rawResponseHandledSymbol = /* @__PURE__ */ Symbol("rawResponseHandled");
 var rawResponseHandled = Object.freeze({ [rawResponseHandledSymbol]: true });
@@ -955,7 +774,7 @@ function writeRawHandlerError(response, error) {
 var errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
   status: value,
   contentType: "application/json",
-  pipe: v3.meta(v3.array(v3.object({ message: v3.string(), field: v3.optional(v3.string()) })), {
+  pipe: v2.meta(v2.array(v2.object({ message: v2.string(), field: v2.optional(v2.string()) })), {
     $refId: `Errors.${key}Response`,
     description: `${key} Response`
   })
@@ -969,6 +788,7 @@ var Server = class {
   #queue = [];
   #routesByKey = /* @__PURE__ */ new Set();
   #started = false;
+  #beforeListenHandlers = [];
   #notFoundHandler = null;
   setup(httpServer, config) {
     this.#httpServer = httpServer;
@@ -1024,6 +844,11 @@ var Server = class {
     this.#notFoundHandler = handler;
     return this;
   }
+  onBeforeListen(handler) {
+    if (this.#started) throw new EquippedError("Cannot add before-listen handler after server has started", {});
+    this.#beforeListenHandlers.push(handler);
+    return this;
+  }
   test() {
     return supertest(this.#httpServer);
   }
@@ -1057,6 +882,7 @@ var Server = class {
       });
       return await this.handleResponse(res, response);
     });
+    for (const handler of this.#beforeListenHandlers) await handler({ httpServer: this.#httpServer, port: config.port });
     const started = await this.startServer(config.port);
     if (started) Instance.get().log.info(`${instance.id}(${app.name}) service listening on port ${config.port}`);
     return started;
@@ -1105,37 +931,37 @@ var Server = class {
       { key: "responseCookies", type: "response" }
     ];
     defs.forEach((def) => {
-      const pipe = schema[def.key] ?? v3.any();
+      const pipe = schema[def.key] ?? v2.any();
       if (def.skip) return;
       if (def.type === "request") {
         requestPipeDefs[def.key] = pipe;
-        jsonSchema.request[def.key] = v3.schema(pipe);
+        jsonSchema.request[def.key] = v2.schema(pipe);
       }
       if (def.type === "response") {
         const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
-        responsePipeDefs[def.key] = v3.any().pipe((input) => {
+        responsePipeDefs[def.key] = v2.any().pipe((input) => {
           const p = pipeRecords.find((rec) => rec.status === status)?.pipe;
           if (!p) throw PipeError.root(`schema not defined for status code: ${status}`, input);
-          const r = v3.validate(p, input);
+          const r = v2.validate(p, input);
           if (!r.valid) throw r.error;
           return r.value;
         });
         jsonSchema.response[def.key] = pipeRecords.map((record) => ({
           status: record.status,
           contentType: record.contentType,
-          schema: v3.schema(record.pipe)
+          schema: v2.schema(record.pipe)
         }));
       }
     });
-    const requestPipe = v3.object(requestPipeDefs);
-    v3.compile(requestPipe, { allErrors: true });
-    const responsePipe = v3.object(responsePipeDefs);
-    v3.compile(responsePipe, { allErrors: true });
+    const requestPipe = v2.object(requestPipeDefs);
+    v2.compile(requestPipe, { allErrors: true });
+    const responsePipe = v2.object(responsePipeDefs);
+    v2.compile(responsePipe, { allErrors: true });
     const validateRequest = async (request) => {
       if (!Object.keys(requestPipeDefs)) return request;
       const validity = requestLocalStorage.run(
         request,
-        () => v3.validate(requestPipe, {
+        () => v2.validate(requestPipe, {
           params: request.params,
           headers: request.headers,
           query: request.query,
@@ -1157,7 +983,7 @@ var Server = class {
       contentType = response.contentType;
       const validity = responseLocalStorage.run(
         response,
-        () => v3.validate(responsePipe, {
+        () => v2.validate(responsePipe, {
           responseHeaders: response.headers,
           responseCookies: Object.fromEntries(Object.entries(response.cookies).map(([key, val]) => [key, val.value])),
           response: response.body
@@ -1208,6 +1034,7 @@ if (void 0) {
   const testInstanceState = globalThis;
   class TestServer extends Server {
     handledResponse = null;
+    startedPorts = [];
     notFoundHandler = null;
     constructor() {
       super();
@@ -1252,7 +1079,8 @@ if (void 0) {
     registerNotFoundHandler(cb) {
       this.notFoundHandler = cb;
     }
-    async startServer() {
+    async startServer(port) {
+      this.startedPorts.push(port);
       return true;
     }
     async dispatchNotFound(path) {
@@ -1263,6 +1091,43 @@ if (void 0) {
       return { handledResponse: this.handledResponse, rawResponse };
     }
   }
+  describe("Server before-listen handlers", () => {
+    test("runs before-listen handlers before adapter listen in registration order", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      const calls = [];
+      let receivedServer = null;
+      server.onBeforeListen(({ httpServer, port }) => {
+        calls.push(`first:${port}`);
+        receivedServer = httpServer;
+        expect(server.startedPorts).toEqual([]);
+      }).onBeforeListen(({ httpServer, port }) => {
+        calls.push(`second:${port}`);
+        expect(httpServer).toBe(receivedServer);
+        expect(server.startedPorts).toEqual([]);
+      });
+      await server.start();
+      expect(calls).toEqual(["first:0", "second:0"]);
+      expect(receivedServer).toBeInstanceOf(http.Server);
+      expect(server.startedPorts).toEqual([0]);
+    });
+    test("rejects startup when a before-listen handler fails before adapter listen", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.onBeforeListen(async () => {
+        throw new Error("before-listen failed");
+      });
+      await expect(server.start()).rejects.toThrow("before-listen failed");
+      expect(server.startedPorts).toEqual([]);
+    });
+    test("rejects adding before-listen handlers after server startup", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      expect(() => server.onBeforeListen(() => {
+      })).toThrow("Cannot add before-listen handler after server has started");
+    });
+  });
   describe("Server not-found handler", () => {
     test("throws the default Equipped not-found error when no custom handler is set", async () => {
       ensureTestInstance();
@@ -1812,22 +1677,22 @@ if (void 0) {
 }
 
 // src/instance/settings.ts
-import { v as v4 } from "valleyed";
-var instanceSettingsPipe = () => v4.object({
-  app: v4.object({
-    name: v4.string()
+import { v as v3 } from "valleyed";
+var instanceSettingsPipe = () => v3.object({
+  app: v3.object({
+    name: v3.string()
   }),
-  log: v4.defaults(
-    v4.object({
-      level: v4.defaults(v4.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+  log: v3.defaults(
+    v3.object({
+      level: v3.defaults(v3.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
     }),
     {}
   ),
-  utils: v4.defaults(
-    v4.object({
-      hashSaltRounds: v4.defaults(v4.number(), 10),
-      paginationDefaultLimit: v4.defaults(v4.number(), 100),
-      maxFileUploadSizeInMb: v4.defaults(v4.number(), 500)
+  utils: v3.defaults(
+    v3.object({
+      hashSaltRounds: v3.defaults(v3.number(), 10),
+      paginationDefaultLimit: v3.defaults(v3.number(), 100),
+      maxFileUploadSizeInMb: v3.defaults(v3.number(), 500)
     }),
     {}
   )
@@ -1877,7 +1742,7 @@ var Instance = class _Instance {
     }
   }
   static envs(envsPipe) {
-    const envValidity = v5.validate(envsPipe, process.env);
+    const envValidity = v4.validate(envsPipe, process.env);
     if (!envValidity.valid) {
       _Instance.crash(
         new EquippedError(`Environment variables are not valid
@@ -1890,7 +1755,7 @@ ${envValidity.error.toString()}`, {
   }
   static create(settings) {
     if (_Instance.#instance) return _Instance.crash(new EquippedError("Instance has been initialized already", {}));
-    const settingsValidity = v5.validate(instanceSettingsPipe(), settings);
+    const settingsValidity = v4.validate(instanceSettingsPipe(), settings);
     if (!settingsValidity.valid) {
       _Instance.crash(
         new EquippedError(`Settings are not valid
@@ -1945,40 +1810,40 @@ ${settingsValidity.error.toString()}`, {
 };
 
 // src/validations/valleyed.ts
-var filePipe = (err) => v6.array(
-  v6.file(err).pipe((input) => {
+var filePipe = (err) => v5.array(
+  v5.file(err).pipe((input) => {
     const err2 = `is larger than allowed limit of ${Instance.get().settings.utils.maxFileUploadSizeInMb}mb`;
     const valid = input ? !input.isTruncated : true;
     if (valid) return input;
     throw PipeError2.root(err2, input);
   })
 );
-var incomingFile = (err) => v6.define(
-  v6.compile(
-    filePipe(err).pipe(v6.min(1, "no file provided")).pipe((files) => files[0])
+var incomingFile = (err) => v5.define(
+  v5.compile(
+    filePipe(err).pipe(v5.min(1, "no file provided")).pipe((files) => files[0])
   ),
   { schema: () => ({ type: "string", format: "binary" }) }
 );
-var incomingFiles = (err) => v6.define(v6.compile(filePipe(err)), {
+var incomingFiles = (err) => v5.define(v5.compile(filePipe(err)), {
   schema: () => ({ type: "string", format: "binary" })
 });
 var requestLocalStorage = new AsyncLocalStorage();
 var responseLocalStorage = new AsyncLocalStorage();
-var withRequest = (fn) => v6.define((input) => {
+var withRequest = (fn) => v5.define((input) => {
   const req = requestLocalStorage.getStore();
   if (!req) throw new Error("Request not found in context");
-  const validated = v6.validate(fn(req), input);
+  const validated = v5.validate(fn(req), input);
   return validated.valid ? validated.value : validated.error;
 });
-var withResponse = (fn) => v6.define((input) => {
+var withResponse = (fn) => v5.define((input) => {
   const res = responseLocalStorage.getStore();
   if (!res) throw new Error("Response not found in context");
-  const validated = v6.validate(fn(res), input);
+  const validated = v5.validate(fn(res), input);
   return validated.valid ? validated.value : validated.error;
 });
 
 // src/validations/index.ts
-import { v as v7 } from "valleyed";
+import { v as v6 } from "valleyed";
 function pipeErrorToValidationError(error) {
   const errorsObject = error.messages.reduce((acc, { path = "", message }) => {
     if (acc[path]) acc[path].messages.push(message);
@@ -1988,7 +1853,7 @@ function pipeErrorToValidationError(error) {
   return new ValidationError(Object.values(errorsObject));
 }
 function validate(pipe, value) {
-  const validity = v7.validate(pipe, value);
+  const validity = v6.validate(pipe, value);
   if (validity.valid) return validity.value;
   throw pipeErrorToValidationError(validity.error);
 }
@@ -2005,15 +1870,6 @@ export {
   makeResponseMiddleware,
   makeErrorMiddleware,
   Router,
-  authProviders_exports,
-  configurable,
-  hash_exports,
-  parseJSONValue,
-  parseJSONObject,
-  getMediaDuration,
-  random_exports,
-  sleep,
-  retry,
   Request,
   Response,
   BaseRequestAuthMethod,