midwinter/dist/validation.mjs

A next-gen middleware engine built for the WinterCG environments.

import './chunk-BEENSAMV.mjs';
import { Midwinter } from './chunk-WXZQARCU.mjs';
import { parse } from 'schema-shift';

var cached = (fn) => {
  let called = false;
  let result;
  return async () => {
    if (called) return result;
    result = await fn();
    called = true;
    return result;
  };
};
var parseQuery = (req, opts) => {
  const url = new URL(req.url);
  if (opts.parseQueryString) {
    const result = opts.parseQueryString(url);
    return opts.Query ? parse(opts.Query, result) : result;
  }
  const map = {};
  for (const [key, value] of url.searchParams.entries()) {
    map[key] = value;
  }
  return opts.Query ? parse(opts.Query, map) : map;
};
var parseParams = (req, opts) => {
  const url = new URL(req.url);
  const map = {};
  if (opts.path == null) {
    if (opts.Params) {
      console.warn(
        "Unable to parse params: could not find a `path` for this request handler."
      );
    }
    return map;
  }
  const patternParts = opts.path?.split("/");
  const PathParts = url.pathname.split("/");
  for (let i = 0; i <= patternParts.length; i++) {
    const pattern = patternParts[i];
    const Path = PathParts[i];
    if (pattern == null || Path == null) break;
    if (pattern.startsWith(":")) {
      map[pattern.slice(1)] = Path;
    }
  }
  return opts.Params ? parse(opts.Params, map) : map;
};
var parseBody = async (_req, opts) => {
  const req = _req.clone();
  const contentType = req.headers.get("content-type");
  if (opts.Body) {
    const data = await req.json();
    return parse(opts.Body, data);
  }
  if (contentType === "application/json") {
    return req.json();
  }
  if (contentType?.startsWith("text/")) {
    return req.text();
  }
  return req.body;
};
var parseHeaders = (req, opts) => {
  const map = {};
  for (const [key, value] of req.headers.entries()) {
    map[key] = value;
  }
  return opts.Headers ? parse(opts.Headers, map) : map;
};
var getCachedParsers = (req, opts) => {
  return {
    query: cached(() => parseQuery(req, opts)),
    params: cached(() => parseParams(req, opts)),
    headers: cached(() => parseHeaders(req, opts)),
    body: cached(() => parseBody(req, opts))
  };
};
var makeParseFn = (req, opts) => {
  const parsers = getCachedParsers(req, opts);
  const parse3 = async (key) => {
    if (key) {
      return parsers[key]();
    }
    const [_query, _params, _headers, _body] = await Promise.all([
      parsers.query(),
      parsers.params(),
      parsers.headers(),
      parsers.body()
    ]);
    return {
      query: _query,
      params: _params,
      headers: _headers,
      body: _body
    };
  };
  return parse3;
};
var init = (opts) => {
  const { parseQueryString } = opts ?? {};
  return {
    valid(opts2) {
      return new Midwinter(opts2).use(
        async (req, _, meta) => {
          const parse3 = makeParseFn(req, {
            ...opts2,
            path: meta.path ? String(meta.path) : void 0,
            parseQueryString
          });
          return { ...await parse3() };
        }
      );
    },
    validLazy(opts2) {
      return new Midwinter(opts2).use(
        (req, _, meta) => {
          return {
            parse: makeParseFn(req, {
              ...opts2,
              path: meta.path ? String(meta.path) : void 0,
              parseQueryString
            })
          };
        }
      );
    },
    // Can't be bothered fixing this
    // @ts-expect-error
    output(handler, opts2) {
      return async (req, ctx, meta) => {
        const data = await handler(req, ctx, meta);
        if (data instanceof Response) {
          return data;
        }
        const outData = meta.Output ? await parse(meta.Output, data) : data;
        return Response.json(outData ?? null, opts2);
      };
    }
  };
};

export { init };