@niledatabase/server 5.0.0-alpha.3 → 5.0.0-alpha.4

package/dist/express.js

@@ -1,1433 +0,0 @@
-'use strict';
-
-require('dotenv/config');
-
-// src/api/utils/routes/index.ts
-var NILEDB_API_URL = process.env.NILEDB_API_URL;
-var DEFAULT_PREFIX = "/api";
-var appRoutes = (prefix = DEFAULT_PREFIX) => ({
-  SIGNIN: `${prefix}${"/auth/signin" /* SIGNIN */}`,
-  PROVIDERS: `${prefix}${"/auth/providers" /* PROVIDERS */}`,
-  SESSION: `${prefix}${"/auth/session" /* SESSION */}`,
-  CSRF: `${prefix}${"/auth/csrf" /* CSRF */}`,
-  CALLBACK: `${prefix}${"/auth/callback" /* CALLBACK */}`,
-  SIGNOUT: `${prefix}${"/auth/signout" /* SIGNOUT */}`,
-  ERROR: `${prefix}/auth/error`,
-  VERIFY_REQUEST: `${prefix}/auth/verify-request`,
-  VERIFY_EMAIL: `${prefix}${"/auth/verify-email" /* VERIFY_EMAIL */}`,
-  PASSWORD_RESET: `${prefix}${"/auth/reset-password" /* PASSWORD_RESET */}`,
-  ME: `${prefix}${"/me" /* ME */}`,
-  USERS: `${prefix}${"/users" /* USERS */}`,
-  USER_TENANTS: `${prefix}${"/users/{userId}/tenants" /* USER_TENANTS */}`,
-  TENANTS: `${prefix}${"/tenants" /* TENANTS */}`,
-  TENANT: `${prefix}${"/tenants/{tenantId}" /* TENANT */}`,
-  TENANT_USER: `${prefix}${"/tenants/{tenantId}/users/{userId}" /* TENANT_USER */}`,
-  TENANT_USERS: `${prefix}${"/tenants/{tenantId}/users" /* TENANT_USERS */}`,
-  SIGNUP: `${prefix}${"/signup" /* SIGNUP */}`,
-  LOG: `${prefix}/_log`
-});
-var apiRoutes = (config) => ({
-  ME: makeRestUrl(config, "/me"),
-  USERS: (qp) => makeRestUrl(config, "/users", qp),
-  USER: (userId) => makeRestUrl(config, `/users/${userId}`),
-  TENANTS: makeRestUrl(config, "/tenants"),
-  TENANT: (tenantId) => makeRestUrl(config, `/tenants/${tenantId}`),
-  SIGNUP: makeRestUrl(config, "/signup"),
-  TENANT_USERS: (tenantId) => makeRestUrl(config, `/tenants/${tenantId}/users`),
-  TENANT_USER: makeRestUrl(
-    config,
-    `/tenants/${config.tenantId}/users/${config.userId}`
-  ),
-  USER_TENANTS: (userId) => makeRestUrl(config, `/users/${userId}/tenants`)
-});
-var proxyRoutes = (config) => ({
-  SIGNIN: makeRestUrl(config, "/auth/signin" /* SIGNIN */),
-  PROVIDERS: makeRestUrl(config, "/auth/providers" /* PROVIDERS */),
-  SESSION: makeRestUrl(config, "/auth/session" /* SESSION */),
-  CSRF: makeRestUrl(config, "/auth/csrf" /* CSRF */),
-  CALLBACK: makeRestUrl(config, "/auth/callback" /* CALLBACK */),
-  SIGNOUT: makeRestUrl(config, "/auth/signout" /* SIGNOUT */),
-  ERROR: makeRestUrl(config, "/auth/error"),
-  VERIFY_REQUEST: makeRestUrl(config, "/auth/verify-request"),
-  PASSWORD_RESET: makeRestUrl(config, "/auth/reset-password" /* PASSWORD_RESET */),
-  VERIFY_EMAIL: makeRestUrl(config, "/auth/verify-email" /* VERIFY_EMAIL */)
-});
-function filterNullUndefined(obj) {
-  if (!obj) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([, value]) => value !== null && value !== void 0
-    )
-  );
-}
-function makeRestUrl(config, path, qp) {
-  const url = config.apiUrl || NILEDB_API_URL;
-  if (!url) {
-    throw new Error(
-      "An API url is required. Set it via NILEDB_API_URL. Was auto configuration run?"
-    );
-  }
-  const params = new URLSearchParams(
-    filterNullUndefined(qp)
-  );
-  const strParams = params.toString();
-  return `${[url, path.substring(1, path.length)].join("/")}${strParams ? `?${strParams}` : ""}`;
-}
-function urlMatches(requestUrl, route17) {
-  const url = new URL(requestUrl);
-  return url.pathname.startsWith(route17);
-}
-function isUUID(value) {
-  if (!value) {
-    return false;
-  }
-  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5|7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-  return regex.test(value);
-}
-
-// src/utils/Logger.ts
-var red = "\x1B[31m";
-var yellow = "\x1B[38;2;255;255;0m";
-var purple = "\x1B[38;2;200;160;255m";
-var orange = "\x1B[38;2;255;165;0m";
-var reset = "\x1B[0m";
-var baseLogger = (config, ...params) => ({
-  info(message, meta) {
-    if (config?.debug) {
-      console.info(
-        `${orange}[niledb]${reset}${purple}[DEBUG]${reset}${params.join(
-          ""
-        )}${reset} ${message}`,
-        meta ? `${JSON.stringify(meta)}` : ""
-      );
-    }
-  },
-  debug(message, meta) {
-    if (config?.debug) {
-      console.debug(
-        `${orange}[niledb]${reset}${purple}[DEBUG]${reset}${params.join(
-          ""
-        )}${reset} ${message}`,
-        meta ? `${JSON.stringify(meta)}` : ""
-      );
-    }
-  },
-  warn(message, meta) {
-    if (config?.debug) {
-      console.warn(
-        `${orange}[niledb]${reset}${yellow}[WARN]${reset}${params.join(
-          ""
-        )}${reset} ${message}`,
-        meta ? JSON.stringify(meta) : ""
-      );
-    }
-  },
-  error(message, meta) {
-    console.error(
-      `${orange}[niledb]${reset}${red}[ERROR]${reset}${params.join(
-        ""
-      )}${red} ${message}`,
-      meta ? meta : "",
-      `${reset}`
-    );
-  }
-});
-function Logger(config, ...params) {
-  const base = baseLogger(config, params);
-  const info = config?.logger?.info ?? base.info;
-  const debug = config?.logger?.debug ?? base.debug;
-  const warn = config?.logger?.warn ?? base.warn;
-  const error = config?.logger?.error ?? base.error;
-  return { info, warn, error, debug };
-}
-function matchesLog(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.LOG);
-}
-
-// src/utils/constants.ts
-var X_NILE_TENANT = "nile-tenant-id";
-var X_NILE_ORIGIN = "nile-origin";
-var X_NILE_SECURECOOKIES = "nile-secure-cookies";
-
-// src/api/utils/request.ts
-async function request(url, _init, config) {
-  const { debug, info, error } = Logger(config, "[REQUEST]");
-  const { request: request2, ...init } = _init;
-  const requestUrl = new URL(request2.url);
-  const updatedHeaders = new Headers({});
-  if (request2.headers.get("cookie")) {
-    updatedHeaders.set("cookie", String(request2.headers.get("cookie")));
-  }
-  if (request2.headers.get(X_NILE_TENANT)) {
-    updatedHeaders.set(
-      X_NILE_TENANT,
-      String(request2.headers.get(X_NILE_TENANT))
-    );
-  }
-  if (config.secureCookies != null) {
-    updatedHeaders.set(X_NILE_SECURECOOKIES, String(config.secureCookies));
-  } else {
-    updatedHeaders.set(
-      X_NILE_SECURECOOKIES,
-      process.env.NODE_ENV === "production" ? "true" : "false"
-    );
-  }
-  updatedHeaders.set("host", requestUrl.host);
-  if (config.callbackUrl) {
-    const cbUrl = new URL(config.callbackUrl);
-    debug(`Obtained origin from config.callbackUrl ${config.callbackUrl}`);
-    updatedHeaders.set(X_NILE_ORIGIN, cbUrl.origin);
-  } else if (config.origin) {
-    debug(`Obtained origin from config.origin ${config.origin}`);
-    updatedHeaders.set(X_NILE_ORIGIN, config.origin);
-  } else {
-    const passedOrigin = request2.headers.get(X_NILE_ORIGIN);
-    if (passedOrigin) {
-      updatedHeaders.set(X_NILE_ORIGIN, passedOrigin);
-    } else {
-      const reqOrigin = config.routePrefix !== DEFAULT_PREFIX ? `${requestUrl.origin}${config.routePrefix}` : requestUrl.origin;
-      updatedHeaders.set(X_NILE_ORIGIN, reqOrigin);
-      debug(`Obtained origin from request ${reqOrigin}`);
-    }
-  }
-  const params = { ...init };
-  if (params.method?.toLowerCase() === "post" || params.method?.toLowerCase() === "put") {
-    try {
-      updatedHeaders.set("content-type", "application/json");
-      const initBody = await new Response(_init.request.clone().body).json();
-      const requestBody = await new Response(request2.clone().body).json();
-      params.body = JSON.stringify(initBody ?? requestBody);
-    } catch (e) {
-      updatedHeaders.set("content-type", "application/x-www-form-urlencoded");
-      const initBody = await new Response(_init.request.clone().body).text();
-      const requestBody = await new Response(request2.clone().body).text();
-      params.body = initBody ?? requestBody;
-    }
-  }
-  params.headers = updatedHeaders;
-  const fullUrl = `${url}${requestUrl.search}`;
-  if (config.debug) {
-    params.headers.set("request-id", crypto.randomUUID());
-    params.cache = "no-store";
-  }
-  try {
-    const res = await fetch(fullUrl, {
-      ...params
-    }).catch((e) => {
-      error("An error has occurred in the fetch", {
-        message: e.message,
-        stack: e.stack
-      });
-      return new Response(
-        "An unexpected (most likely configuration) problem has occurred",
-        { status: 500 }
-      );
-    });
-    const loggingRes = typeof res?.clone === "function" ? res?.clone() : null;
-    info(`[${params.method ?? "GET"}] ${fullUrl}`, {
-      status: res?.status,
-      statusText: res?.statusText,
-      text: await loggingRes?.text()
-    });
-    return res;
-  } catch (e) {
-    if (e instanceof Error) {
-      error("An error has occurred in the fetch", {
-        message: e.message,
-        stack: e.stack
-      });
-    }
-    return new Response(
-      "An unexpected (most likely configuration) problem has occurred",
-      { status: 500 }
-    );
-  }
-}
-
-// src/api/utils/auth.ts
-async function auth(req, config) {
-  const { info, error } = Logger(config, "[nileauth]");
-  info("checking auth");
-  const sessionUrl = `${config.apiUrl}/auth/session`;
-  info(`using session ${sessionUrl}`);
-  req.headers.delete("content-length");
-  const res = await request(sessionUrl, { request: req }, config);
-  if (!res) {
-    info("no session found");
-    return void 0;
-  }
-  info("session active");
-  try {
-    const session = await new Response(res.body).json();
-    if (Object.keys(session).length === 0) {
-      return void 0;
-    }
-    return session;
-  } catch (e) {
-    error(e);
-    return void 0;
-  }
-}
-
-// src/api/routes/me/index.ts
-var key = "ME";
-async function route(request2, config) {
-  const url = apiRoutes(config)[key];
-  if (request2.method === "GET") {
-    return await GET(url, { request: request2 }, config);
-  }
-  if (request2.method === "PUT") {
-    return await PUT(url, { request: request2 }, config);
-  }
-  if (request2.method === "DELETE") {
-    const session = await auth(request2, config);
-    if (!session) {
-      return new Response(null, { status: 401 });
-    }
-    return await DELETE(url, { request: request2 }, config);
-  }
-  return new Response("method not allowed", { status: 405 });
-}
-function matches(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key]);
-}
-async function DELETE(url, init, config) {
-  init.method = "DELETE";
-  return await request(url, init, config);
-}
-async function PUT(url, init, config) {
-  init.method = "PUT";
-  return await request(url, init, config);
-}
-async function GET(url, init, config) {
-  const res = await request(url, init, config);
-  return res;
-}
-
-// src/utils/fetch.ts
-function getTokenFromCookie(headers, cookieKey) {
-  const cookie = headers.get("cookie")?.split("; ");
-  const _cookies = {};
-  if (cookie) {
-    for (const parts of cookie) {
-      const cookieParts = parts.split("=");
-      const _cookie = cookieParts.slice(1).join("=");
-      const name = cookieParts[0];
-      _cookies[name] = _cookie;
-    }
-  }
-  if (cookie) {
-    for (const parts of cookie) {
-      const cookieParts = parts.split("=");
-      const _cookie = cookieParts.slice(1).join("=");
-      const name = cookieParts[0];
-      _cookies[name] = _cookie;
-    }
-  }
-  {
-    return _cookies[cookieKey];
-  }
-}
-function getTenantFromHttp(headers, config) {
-  const cookieTenant = getTokenFromCookie(headers, X_NILE_TENANT);
-  return cookieTenant ?? headers?.get(X_NILE_TENANT) ?? config?.tenantId;
-}
-
-// src/api/routes/users/POST.ts
-async function POST(config, init) {
-  init.body = init.request.body;
-  init.method = "POST";
-  const yurl = new URL(init.request.url);
-  const tenantId = yurl.searchParams.get("tenantId");
-  const newTenantName = yurl.searchParams.get("newTenantName");
-  const tenant = tenantId ?? getTenantFromHttp(init.request.headers);
-  const url = apiRoutes(config).USERS({ tenantId: tenant, newTenantName });
-  return await request(url, init, config);
-}
-
-// src/api/routes/users/GET.ts
-async function GET2(config, init, log) {
-  const yurl = new URL(init.request.url);
-  const tenantId = yurl.searchParams.get("tenantId");
-  const tenant = tenantId ?? getTenantFromHttp(init.request.headers);
-  if (!tenant) {
-    log("[GET] No tenant id provided.");
-    return new Response(null, { status: 404 });
-  }
-  const url = apiRoutes(config).TENANT_USERS(tenant);
-  init.method = "GET";
-  return await request(url, init, config);
-}
-
-// src/api/routes/users/[userId]/PUT.ts
-async function PUT2(config, session, init) {
-  if (!session) {
-    return new Response(null, { status: 401 });
-  }
-  init.body = init.request.body;
-  init.method = "PUT";
-  const [userId] = new URL(init.request.url).pathname.split("/").reverse();
-  const url = apiRoutes(config).USER(userId);
-  return await request(url, init, config);
-}
-
-// src/api/routes/users/index.ts
-var key2 = "USERS";
-async function route2(request2, config) {
-  const { info } = Logger(
-    { ...config, debug: config.debug },
-    `[ROUTES][${key2}]`
-  );
-  const session = await auth(request2, config);
-  switch (request2.method) {
-    case "GET":
-      return await GET2(config, { request: request2 }, info);
-    case "POST":
-      return await POST(config, { request: request2 });
-    case "PUT":
-      return await PUT2(config, session, { request: request2 });
-    default:
-      return new Response("method not allowed", { status: 405 });
-  }
-}
-function matches2(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key2]);
-}
-
-// src/api/routes/tenants/[tenantId]/users/GET.ts
-async function GET3(config, init) {
-  const yurl = new URL(init.request.url);
-  const [, tenantId] = yurl.pathname.split("/").reverse();
-  const url = `${apiRoutes(config).TENANT_USERS(tenantId)}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/users/POST.ts
-async function POST2(config, session, init) {
-  const yurl = new URL(init.request.url);
-  const [, tenantId] = yurl.pathname.split("/").reverse();
-  init.body = JSON.stringify({ email: session.email });
-  init.method = "POST";
-  const url = apiRoutes(config).TENANT_USERS(tenantId);
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/users/index.ts
-var key3 = "TENANT_USERS";
-async function route3(request2, config) {
-  const { info } = Logger(
-    { ...config, debug: config.debug },
-    `[ROUTES][${key3}]`
-  );
-  const session = await auth(request2, config);
-  if (!session) {
-    info("401");
-    return new Response(null, { status: 401 });
-  }
-  const yurl = new URL(request2.url);
-  const [, tenantId] = yurl.pathname.split("/").reverse();
-  if (!tenantId) {
-    info("No tenant id found in path");
-    return new Response(null, { status: 404 });
-  }
-  switch (request2.method) {
-    case "GET":
-      return await GET3(config, { request: request2 });
-    case "POST":
-      return await POST2(config, session, { request: request2 });
-    default:
-      return new Response("method not allowed", { status: 405 });
-  }
-}
-function matches3(configRoutes, request2) {
-  const url = new URL(request2.url);
-  const [userId, possibleTenantId, tenantId] = url.pathname.split("/").reverse();
-  let route17 = configRoutes[key3].replace("{tenantId}", tenantId).replace("{userId}", userId);
-  if (userId === "users") {
-    route17 = configRoutes[key3].replace("{tenantId}", possibleTenantId);
-  }
-  return urlMatches(request2.url, route17);
-}
-
-// src/api/routes/tenants/GET.ts
-async function GET4(config, session, init) {
-  let url = `${apiRoutes(config).USER_TENANTS(session.id)}`;
-  if (typeof session === "object" && "user" in session && session.user) {
-    url = `${apiRoutes(config).USER_TENANTS(session.user.id)}`;
-  }
-  const res = await request(url, init, config);
-  return res;
-}
-
-// src/api/routes/tenants/[tenantId]/GET.ts
-async function GET5(config, init, log) {
-  const yurl = new URL(init.request.url);
-  const [tenantId] = yurl.pathname.split("/").reverse();
-  if (!tenantId) {
-    log("[GET] No tenant id provided.");
-    return new Response(null, { status: 404 });
-  }
-  init.method = "GET";
-  const url = `${apiRoutes(config).TENANT(tenantId)}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/DELETE.ts
-async function DELETE2(config, init) {
-  const yurl = new URL(init.request.url);
-  const [tenantId] = yurl.pathname.split("/").reverse();
-  if (!tenantId) {
-    return new Response(null, { status: 404 });
-  }
-  init.method = "DELETE";
-  const url = `${apiRoutes(config).TENANT(tenantId)}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/PUT.ts
-async function PUT3(config, init) {
-  const yurl = new URL(init.request.url);
-  const [tenantId] = yurl.pathname.split("/").reverse();
-  if (!tenantId) {
-    return new Response(null, { status: 404 });
-  }
-  init.body = init.request.body;
-  init.method = "PUT";
-  const url = `${apiRoutes(config).TENANT(tenantId)}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/POST.ts
-async function POST3(config, init) {
-  init.body = init.request.body;
-  init.method = "POST";
-  const url = `${apiRoutes(config).TENANTS}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/index.ts
-var key4 = "TENANTS";
-async function route4(request2, config) {
-  const { info } = Logger(
-    { ...config, debug: config.debug },
-    `[ROUTES][${key4}]`
-  );
-  const session = await auth(request2, config);
-  if (!session) {
-    info("401");
-    return new Response(null, { status: 401 });
-  }
-  const [possibleTenantId] = request2.url.split("/").reverse();
-  switch (request2.method) {
-    case "GET":
-      if (isUUID(possibleTenantId)) {
-        return await GET5(config, { request: request2 }, info);
-      }
-      return await GET4(config, session, { request: request2 });
-    case "POST":
-      return await POST3(config, { request: request2 });
-    case "DELETE":
-      return await DELETE2(config, { request: request2 });
-    case "PUT":
-      return await PUT3(config, { request: request2 });
-    default:
-      return new Response("method not allowed", { status: 405 });
-  }
-}
-function matches4(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key4]);
-}
-
-// src/api/routes/auth/signin.ts
-var key5 = "SIGNIN";
-async function route5(req, config) {
-  let url = proxyRoutes(config)[key5];
-  const init = {
-    method: req.method,
-    headers: req.headers
-  };
-  if (req.method === "POST") {
-    const [provider] = new URL(req.url).pathname.split("/").reverse();
-    url = `${proxyRoutes(config)[key5]}/${provider}`;
-  }
-  const passThroughUrl = new URL(req.url);
-  const params = new URLSearchParams(passThroughUrl.search);
-  url = `${url}${params.toString() !== "" ? `?${params.toString()}` : ""}`;
-  const res = await request(url, { ...init, request: req }, config);
-  return res;
-}
-function matches5(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key5]);
-}
-
-// src/api/routes/auth/session.ts
-async function route6(req, config) {
-  return request(
-    proxyRoutes(config).SESSION,
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-}
-function matches6(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.SESSION);
-}
-
-// src/api/routes/auth/providers.ts
-async function route7(req, config) {
-  return request(
-    proxyRoutes(config).PROVIDERS,
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-}
-function matches7(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.PROVIDERS);
-}
-
-// src/api/routes/auth/csrf.ts
-async function route8(req, config) {
-  return request(
-    proxyRoutes(config).CSRF,
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-}
-function matches8(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.CSRF);
-}
-
-// src/api/routes/auth/callback.ts
-var key6 = "CALLBACK";
-async function route9(req, config) {
-  const { error } = Logger(
-    { ...config, debug: config.debug },
-    `[ROUTES][${key6}]`
-  );
-  const [provider] = new URL(req.url).pathname.split("/").reverse();
-  try {
-    const passThroughUrl = new URL(req.url);
-    const params = new URLSearchParams(passThroughUrl.search);
-    const url = `${proxyRoutes(config)[key6]}/${provider}${params.toString() !== "" ? `?${params.toString()}` : ""}`;
-    const res = await request(
-      url,
-      {
-        request: req,
-        method: req.method
-      },
-      config
-    ).catch((e) => {
-      error("an error as occurred", e);
-    });
-    const location = res?.headers.get("location");
-    if (location) {
-      return new Response(res?.body, {
-        status: 302,
-        headers: res?.headers
-      });
-    }
-    return new Response(res?.body, {
-      status: res?.status,
-      headers: res?.headers
-    });
-  } catch (e) {
-    error(e);
-  }
-  return new Response("An unexpected error has occurred.", { status: 400 });
-}
-function matches9(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.CALLBACK);
-}
-
-// src/api/routes/auth/signout.ts
-var key7 = "SIGNOUT";
-async function route10(request2, config) {
-  let url = proxyRoutes(config)[key7];
-  const init = {
-    method: request2.method
-  };
-  if (request2.method === "POST") {
-    init.body = request2.body;
-    const [provider] = new URL(request2.url).pathname.split("/").reverse();
-    url = `${proxyRoutes(config)[key7]}${provider !== "signout" ? `/${provider}` : ""}`;
-  }
-  const res = await request(url, { ...init, request: request2 }, config);
-  return res;
-}
-function matches10(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key7]);
-}
-
-// src/api/routes/auth/error.ts
-var key8 = "ERROR";
-async function route11(req, config) {
-  return request(
-    proxyRoutes(config)[key8],
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-}
-function matches11(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key8]);
-}
-
-// src/api/routes/auth/verify-request.ts
-var key9 = "VERIFY_REQUEST";
-async function route12(req, config) {
-  return request(
-    proxyRoutes(config)[key9],
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-}
-function matches12(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key9]);
-}
-
-// src/api/routes/auth/password-reset.ts
-var key10 = "PASSWORD_RESET";
-async function route13(req, config) {
-  const url = proxyRoutes(config)[key10];
-  const res = await request(
-    url,
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-  const location = res?.headers.get("location");
-  if (location) {
-    return new Response(res?.body, {
-      status: 302,
-      headers: res?.headers
-    });
-  }
-  return new Response(res?.body, {
-    status: res?.status,
-    headers: res?.headers
-  });
-}
-function matches13(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes.PASSWORD_RESET);
-}
-
-// src/api/routes/auth/verify-email.ts
-var key11 = "VERIFY_EMAIL";
-async function route14(req, config) {
-  const url = proxyRoutes(config)[key11];
-  const res = await request(
-    url,
-    {
-      method: req.method,
-      request: req
-    },
-    config
-  );
-  const location = res?.headers.get("location");
-  if (location) {
-    return new Response(res?.body, {
-      status: 302,
-      headers: res?.headers
-    });
-  }
-  return new Response(res?.body, {
-    status: res?.status,
-    headers: res?.headers
-  });
-}
-function matches14(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key11]);
-}
-
-// src/api/handlers/GET.ts
-function GETTER(configRoutes, config) {
-  const { info, warn } = Logger(config, "[GET MATCHER]");
-  return async function GET6(req) {
-    if (matches(configRoutes, req)) {
-      info("matches me");
-      return route(req, config);
-    }
-    if (matches3(configRoutes, req)) {
-      info("matches tenant users");
-      return route3(req, config);
-    }
-    if (matches2(configRoutes, req)) {
-      info("matches users");
-      return route2(req, config);
-    }
-    if (matches4(configRoutes, req)) {
-      info("matches tenants");
-      return route4(req, config);
-    }
-    if (matches6(configRoutes, req)) {
-      info("matches session");
-      return route6(req, config);
-    }
-    if (matches5(configRoutes, req)) {
-      info("matches signin");
-      return route5(req, config);
-    }
-    if (matches7(configRoutes, req)) {
-      info("matches providers");
-      return route7(req, config);
-    }
-    if (matches8(configRoutes, req)) {
-      info("matches csrf");
-      return route8(req, config);
-    }
-    if (matches13(configRoutes, req)) {
-      info("matches password reset");
-      return route13(req, config);
-    }
-    if (matches9(configRoutes, req)) {
-      info("matches callback");
-      return route9(req, config);
-    }
-    if (matches10(configRoutes, req)) {
-      info("matches signout");
-      return route10(req, config);
-    }
-    if (matches12(configRoutes, req)) {
-      info("matches verify-request");
-      return route12(req, config);
-    }
-    if (matches14(configRoutes, req)) {
-      info("matches verify-email");
-      return route14(req, config);
-    }
-    if (matches11(configRoutes, req)) {
-      info("matches error");
-      return route11(req, config);
-    }
-    warn(`No GET routes matched ${req.url}`);
-    return new Response(null, { status: 404 });
-  };
-}
-
-// src/api/routes/signup/POST.ts
-async function POST4(config, init) {
-  init.body = init.request.body;
-  init.method = "POST";
-  const url = `${apiRoutes(config).SIGNUP}`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/signup/index.tsx
-var key12 = "SIGNUP";
-async function route15(request2, config) {
-  switch (request2.method) {
-    case "POST":
-      return await POST4(config, { request: request2 });
-    default:
-      return new Response("method not allowed", { status: 405 });
-  }
-}
-function matches15(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key12]);
-}
-
-// src/api/handlers/POST.ts
-function POSTER(configRoutes, config) {
-  const { info, warn, error } = Logger(config, "[POST MATCHER]");
-  return async function POST5(req) {
-    if (matchesLog(configRoutes, req)) {
-      try {
-        const json = await req.clone().json();
-        error(req.body && json);
-      } catch {
-        error(await req.text());
-      }
-      return new Response(null, { status: 200 });
-    }
-    if (matches3(configRoutes, req)) {
-      info("matches tenant users");
-      return route3(req, config);
-    }
-    if (matches15(configRoutes, req)) {
-      info("matches signup");
-      return route15(req, config);
-    }
-    if (matches2(configRoutes, req)) {
-      info("matches users");
-      return route2(req, config);
-    }
-    if (matches4(configRoutes, req)) {
-      info("matches tenants");
-      return route4(req, config);
-    }
-    if (matches6(configRoutes, req)) {
-      info("matches session");
-      return route6(req, config);
-    }
-    if (matches5(configRoutes, req)) {
-      info("matches signin");
-      return route5(req, config);
-    }
-    if (matches13(configRoutes, req)) {
-      info("matches password reset");
-      return route13(req, config);
-    }
-    if (matches7(configRoutes, req)) {
-      info("matches providers");
-      return route7(req, config);
-    }
-    if (matches8(configRoutes, req)) {
-      info("matches csrf");
-      return route8(req, config);
-    }
-    if (matches9(configRoutes, req)) {
-      info("matches callback");
-      return route9(req, config);
-    }
-    if (matches10(configRoutes, req)) {
-      info("matches signout");
-      return route10(req, config);
-    }
-    if (matches14(configRoutes, req)) {
-      info("matches verify-email");
-      return route14(req, config);
-    }
-    warn(`No POST routes matched ${req.url}`);
-    return new Response(null, { status: 404 });
-  };
-}
-
-// src/api/routes/tenants/[tenantId]/users/[userId]/DELETE.ts
-async function DELETE3(config, init) {
-  const yurl = new URL(init.request.url);
-  const [, userId, , tenantId] = yurl.pathname.split("/").reverse();
-  config.tenantId = tenantId;
-  config.userId = userId;
-  init.method = "DELETE";
-  const url = `${apiRoutes(config).TENANT_USER}/link`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/users/[userId]/PUT.ts
-async function PUT4(config, init) {
-  const yurl = new URL(init.request.url);
-  const [, userId, , tenantId] = yurl.pathname.split("/").reverse();
-  config.tenantId = tenantId;
-  config.userId = userId;
-  init.method = "PUT";
-  const url = `${apiRoutes(config).TENANT_USER}/link`;
-  return await request(url, init, config);
-}
-
-// src/api/routes/tenants/[tenantId]/users/[userId]/index.ts
-var key13 = "TENANT_USER";
-async function route16(request2, config) {
-  const { info } = Logger(
-    { ...config, debug: config.debug },
-    `[ROUTES][${key13}]`
-  );
-  const session = await auth(request2, config);
-  if (!session) {
-    info("401");
-    return new Response(null, { status: 401 });
-  }
-  const yurl = new URL(request2.url);
-  const [, userId] = yurl.pathname.split("/").reverse();
-  if (!userId) {
-    info("No tenant id found in path");
-    return new Response(null, { status: 404 });
-  }
-  switch (request2.method) {
-    case "PUT":
-      return await PUT4(config, { request: request2 });
-    case "DELETE":
-      return await DELETE3(config, { request: request2 });
-    default:
-      return new Response("method not allowed", { status: 405 });
-  }
-}
-function matches16(configRoutes, request2) {
-  const url = new URL(request2.url);
-  const [, userId, possibleTenantId, tenantId] = url.pathname.split("/").reverse();
-  let route17 = configRoutes[key13].replace("{tenantId}", tenantId).replace("{userId}", userId);
-  if (userId === "users") {
-    route17 = configRoutes[key13].replace("{tenantId}", possibleTenantId);
-  }
-  return urlMatches(request2.url, route17);
-}
-
-// src/api/handlers/DELETE.ts
-function DELETER(configRoutes, config) {
-  const { info, warn } = Logger(config, "[DELETE MATCHER]");
-  return async function DELETE4(req) {
-    if (matches16(configRoutes, req)) {
-      info("matches tenant user");
-      return route16(req, config);
-    }
-    if (matches3(configRoutes, req)) {
-      info("matches tenant users");
-      return route3(req, config);
-    }
-    if (matches4(configRoutes, req)) {
-      info("matches tenants");
-      return route4(req, config);
-    }
-    if (matches(configRoutes, req)) {
-      info("matches me");
-      return route(req, config);
-    }
-    warn("No DELETE routes matched");
-    return new Response(null, { status: 404 });
-  };
-}
-
-// src/api/handlers/PUT.ts
-function PUTER(configRoutes, config) {
-  const { info, warn } = Logger(config, "[PUT MATCHER]");
-  return async function PUT5(req) {
-    if (matches16(configRoutes, req)) {
-      info("matches tenant user");
-      return route16(req, config);
-    }
-    if (matches3(configRoutes, req)) {
-      info("matches tenant users");
-      return route3(req, config);
-    }
-    if (matches2(configRoutes, req)) {
-      info("matches users");
-      return route2(req, config);
-    }
-    if (matches(configRoutes, req)) {
-      info("matches me");
-      return route(req, config);
-    }
-    if (matches4(configRoutes, req)) {
-      info("matches tenants");
-      return route4(req, config);
-    }
-    if (matches13(configRoutes, req)) {
-      info("matches reset password");
-      return route13(req, config);
-    }
-    warn("No PUT routes matched");
-    return new Response(null, { status: 404 });
-  };
-}
-
-// src/api/handlers/index.ts
-function Handlers(configRoutes, config) {
-  const GET6 = GETTER(configRoutes, config);
-  const POST5 = POSTER(configRoutes, config);
-  const DELETE4 = DELETER(configRoutes, config);
-  const PUT5 = PUTER(configRoutes, config);
-  return {
-    GET: GET6,
-    POST: POST5,
-    DELETE: DELETE4,
-    PUT: PUT5
-  };
-}
-var getApiUrl = (cfg) => {
-  const { config } = cfg;
-  if (config?.apiUrl != null) {
-    return config?.apiUrl;
-  }
-  if (stringCheck(process.env.NILEDB_API_URL)) {
-    return process.env.NILEDB_API_URL;
-  }
-  throw new Error(
-    "A connection to nile-auth is required. Set NILEDB_API_URL as an environment variable."
-  );
-};
-var getCallbackUrl = (cfg) => {
-  const { config } = cfg;
-  if (stringCheck(config?.callbackUrl)) {
-    return config?.callbackUrl;
-  }
-  return process.env.NILEDB_CALLBACK_URL;
-};
-var getSecureCookies = (cfg) => {
-  const { config } = cfg;
-  if (config?.secureCookies != null) {
-    return config?.secureCookies;
-  }
-  if (stringCheck(process.env.NILEDB_SECURECOOKIES)) {
-    return Boolean(process.env.NILEDB_SECURECOOKIES);
-  }
-  return void 0;
-};
-var getUsername = (cfg) => {
-  const { config, logger } = cfg;
-  const { info } = Logger(config, "[username]");
-  if (config?.user) {
-    logger && info(`${logger}[config] ${config.user}`);
-    return String(config?.user);
-  }
-  const user = stringCheck(process.env.NILEDB_USER);
-  if (user) {
-    logger && info(`${logger}[NILEDB_USER] ${user}`);
-    return user;
-  }
-  const pg = stringCheck(process.env.NILEDB_POSTGRES_URL);
-  if (pg) {
-    try {
-      const url = new URL(pg);
-      if (url.username) {
-        return url.username;
-      }
-    } catch (e) {
-    }
-  }
-  throw new Error(
-    "A database user is required. Set NILEDB_USER as an environment variable."
-  );
-};
-var getPassword = (cfg) => {
-  const { config, logger } = cfg;
-  const log = logProtector(logger);
-  const { info } = Logger(config, "[password]");
-  if (stringCheck(config?.password)) {
-    log && info(`${logger}[config] ***`);
-    return String(config?.password);
-  }
-  const pass = stringCheck(process.env.NILEDB_PASSWORD);
-  if (pass) {
-    logger && info(`${logger}[NILEDB_PASSWORD] ***`);
-    return pass;
-  }
-  const pg = stringCheck(process.env.NILEDB_POSTGRES_URL);
-  if (pg) {
-    try {
-      const url = new URL(pg);
-      if (url.password) {
-        return url.password;
-      }
-    } catch (e) {
-    }
-  }
-  throw new Error(
-    "A database password is required. Set NILEDB_PASSWORD as an environment variable."
-  );
-};
-var getDatabaseName = (cfg) => {
-  const { config, logger } = cfg;
-  const { info } = Logger(config, "[databaseName]");
-  if (stringCheck(config?.databaseName)) {
-    logger && info(`${logger}[config] ${config?.databaseName}`);
-    return String(config?.databaseName);
-  }
-  const name = stringCheck(process.env.NILEDB_NAME);
-  if (name) {
-    logger && info(`${logger}[NILEDB_NAME] ${name}`);
-    return name;
-  }
-  if (process.env.NILEDB_POSTGRES_URL) {
-    try {
-      const pgUrl = new URL(process.env.NILEDB_POSTGRES_URL);
-      return pgUrl.pathname.substring(1);
-    } catch (e) {
-    }
-  }
-  throw new Error(
-    "A database name is required. Set NILEDB_PASSWORD as an environment variable."
-  );
-};
-function getDbHost(cfg) {
-  const { config, logger } = cfg;
-  const { info } = Logger(config, "[db.host]");
-  if (stringCheck(config?.db && config.db.host)) {
-    logger && info(`${logger}[config] ${config?.db?.host}`);
-    return String(config?.db?.host);
-  }
-  if (stringCheck(process.env.NILEDB_HOST)) {
-    logger && info(`${logger}[NILEDB_HOST] ${process.env.NILEDB_HOST}`);
-    return process.env.NILEDB_HOST;
-  }
-  const pg = stringCheck(process.env.NILEDB_POSTGRES_URL);
-  if (pg) {
-    try {
-      const pgUrl = new URL(pg);
-      logger && info(`${logger}[NILEDB_POSTGRES_URL] ${pgUrl.hostname}`);
-      return pgUrl.hostname;
-    } catch (e) {
-    }
-  }
-  logger && info(`${logger}[default] db.thenile.dev`);
-  return "db.thenile.dev";
-}
-function getDbPort(cfg) {
-  const { config, logger } = cfg;
-  const { info } = Logger(config, "[db.port]");
-  if (config?.db?.port && config.db.port != null) {
-    logger && info(`${logger}[config] ${config?.db.port}`);
-    return Number(config.db?.port);
-  }
-  if (stringCheck(process.env.NILEDB_PORT)) {
-    logger && info(`${logger}[NILEDB_PORT] ${process.env.NILEDB_PORT}`);
-    return Number(process.env.NILEDB_PORT);
-  }
-  const pg = stringCheck(process.env.NILEDB_POSTGRES_URL);
-  if (pg) {
-    try {
-      const pgUrl = new URL(pg);
-      if (pgUrl.port) {
-        return Number(pgUrl.port);
-      }
-    } catch (e) {
-    }
-  }
-  logger && info(`${logger}[default] 5432`);
-  return 5432;
-}
-var logProtector = (logger) => {
-  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" ? logger : null;
-};
-var stringCheck = (str) => {
-  if (str && str !== "") {
-    return str;
-  }
-  return;
-};
-
-// src/utils/Config/index.ts
-var Config = class {
-  routes;
-  handlers;
-  paths;
-  logger;
-  /**
-   * Stores the set tenant id from Server for use in sub classes
-   */
-  tenantId;
-  /**
-   * Stores the set user id from Server for use in sub classes
-   */
-  userId;
-  /**
-   * Stores the headers to be used in `fetch` calls
-   */
-  headers;
-  /**
-   * The nile-auth url
-   */
-  apiUrl;
-  origin;
-  /**
-   * important for separating the `origin` config value from a default in order to make requests
-   */
-  serverOrigin;
-  debug;
-  /**
-   * To use secure cookies or not in the fetch
-   */
-  secureCookies;
-  callbackUrl;
-  /**
-   * change the starting route
-   */
-  routePrefix;
-  db;
-  // api: ApiConfig;
-  constructor(config, logger) {
-    const envVarConfig = { config, logger };
-    this.routePrefix = config?.routePrefix ?? "/api";
-    this.secureCookies = getSecureCookies(envVarConfig);
-    this.callbackUrl = getCallbackUrl(envVarConfig);
-    this.debug = config?.debug;
-    this.origin = config?.origin;
-    this.serverOrigin = config?.origin ?? "http://localhost:3000";
-    this.apiUrl = getApiUrl(envVarConfig);
-    const user = getUsername(envVarConfig);
-    const password = getPassword(envVarConfig);
-    const databaseName = getDatabaseName(envVarConfig);
-    const { host, port, ...dbConfig } = config?.db ?? {};
-    const configuredHost = host ?? getDbHost(envVarConfig);
-    const configuredPort = port ?? getDbPort(envVarConfig);
-    this.db = {
-      user,
-      password,
-      host: configuredHost,
-      port: configuredPort,
-      ...dbConfig
-    };
-    if (databaseName) {
-      this.db.database = databaseName;
-    }
-    if (config?.headers) {
-      this.headers = config?.headers;
-    } else {
-      this.headers = new Headers();
-    }
-    this.routes = {
-      ...appRoutes(config?.routePrefix),
-      ...config?.routes
-    };
-    this.handlers = Handlers(this.routes, this);
-    this.paths = {
-      get: [
-        this.routes.ME,
-        this.routes.TENANT_USERS,
-        this.routes.TENANTS,
-        this.routes.TENANT,
-        this.routes.SESSION,
-        this.routes.SIGNIN,
-        this.routes.PROVIDERS,
-        this.routes.CSRF,
-        this.routes.PASSWORD_RESET,
-        this.routes.CALLBACK,
-        this.routes.SIGNOUT,
-        this.routes.VERIFY_REQUEST,
-        this.routes.ERROR
-      ],
-      post: [
-        this.routes.TENANT_USERS,
-        this.routes.SIGNUP,
-        this.routes.USERS,
-        this.routes.TENANTS,
-        this.routes.SESSION,
-        `${this.routes.SIGNIN}/{provider}`,
-        this.routes.PASSWORD_RESET,
-        this.routes.PROVIDERS,
-        this.routes.CSRF,
-        `${this.routes.CALLBACK}/{provider}`,
-        this.routes.SIGNOUT
-      ],
-      put: [
-        this.routes.TENANT_USERS,
-        this.routes.USERS,
-        this.routes.TENANT,
-        this.routes.PASSWORD_RESET
-      ],
-      delete: [this.routes.TENANT_USER, this.routes.TENANT]
-    };
-    this.tenantId = config?.tenantId;
-    this.userId = config?.userId;
-    this.logger = config?.logger;
-  }
-};
-
-// src/lib/express.ts
-function cleaner(val) {
-  return val.replaceAll(/\{([^}]+)\}/g, ":$1");
-}
-function expressPaths(nile) {
-  const nilePaths = nile.getPaths();
-  const paths = {
-    get: nilePaths.get.map(cleaner),
-    post: nilePaths.post.map(cleaner),
-    put: nilePaths.put.map(cleaner),
-    delete: nilePaths.delete.map(cleaner)
-  };
-  return {
-    paths
-  };
-}
-async function NileExpressHandler(nile, config) {
-  const { error } = Logger(
-    config ? new Config(config) : void 0,
-    "nile-express"
-  );
-  async function handler(req, res) {
-    const headers = new Headers();
-    if (!req || typeof req !== "object") {
-      return null;
-    }
-    if (!("url" in req) || typeof req?.url !== "string") {
-      error("A url is necessary for the nile express handler");
-      return null;
-    }
-    const method = "method" in req && typeof req.method === "string" ? req.method : "GET";
-    if ("headers" in req && typeof req.headers === "object" && req.headers && "cookie" in req.headers && typeof req.headers.cookie === "string") {
-      headers.set("cookie", req.headers.cookie);
-    }
-    const _init = { method, ...config?.init };
-    if ("body" in req) {
-      if (method === "POST" || method === "PUT") {
-        headers.set("content-type", "application/json");
-        _init.body = JSON.stringify(req.body);
-      }
-    }
-    _init.headers = headers;
-    const reqUrl = req.protocol + "://" + req.get("host") + req.originalUrl;
-    try {
-      new URL(reqUrl);
-    } catch (e) {
-      error("Invalid URL", {
-        url: reqUrl,
-        error: e
-      });
-      return null;
-    }
-    const proxyRequest = new Request(reqUrl, _init);
-    let response;
-    try {
-      response = await nile.handlers[method](proxyRequest);
-    } catch (e) {
-      error(e);
-    }
-    let body;
-    if (response instanceof Response) {
-      try {
-        const tryJson = await response.clone();
-        body = await tryJson.json();
-      } catch (e) {
-        body = await response.text();
-      }
-      const newHeaders = {};
-      response.headers.forEach((value, key14) => {
-        if (!["content-length", "transfer-encoding"].includes(key14.toLowerCase())) {
-          if (newHeaders[key14]) {
-            const prev = newHeaders[key14];
-            if (Array.isArray(prev)) {
-              newHeaders[key14] = [...prev, value];
-            } else {
-              newHeaders[key14] = [prev, value];
-            }
-          } else {
-            newHeaders[key14] = value;
-          }
-        }
-      });
-      if (config?.muteResponse !== true) {
-        if (res) {
-          res.status(response.status).set(newHeaders);
-          if (typeof body === "string") {
-            res.send(body);
-          } else {
-            res.json(body ?? {});
-          }
-        }
-        return;
-      }
-      return {
-        body,
-        status: response.status,
-        headers: newHeaders,
-        response
-      };
-    } else {
-      error("Bad response", { response });
-      return;
-    }
-  }
-  const { paths } = expressPaths(nile);
-  return { handler, paths };
-}
-
-exports.NileExpressHandler = NileExpressHandler;
-exports.cleaner = cleaner;
-exports.expressPaths = expressPaths;
-//# sourceMappingURL=express.js.map
-//# sourceMappingURL=express.js.map