@niledatabase/server 5.0.0-alpha.1 → 5.0.0-alpha.2

package/dist/express.mjs

@@ -2,7 +2,8 @@ import 'dotenv/config';
 
 // src/api/utils/routes/index.ts
 var NILEDB_API_URL = process.env.NILEDB_API_URL;
-var appRoutes = (prefix = "/api") => ({
+var DEFAULT_PREFIX = "/api";
+var appRoutes = (prefix = DEFAULT_PREFIX) => ({
   SIGNIN: `${prefix}${"/auth/signin" /* SIGNIN */}`,
   PROVIDERS: `${prefix}${"/auth/providers" /* PROVIDERS */}`,
   SESSION: `${prefix}${"/auth/session" /* SESSION */}`,
@@ -11,7 +12,8 @@ var appRoutes = (prefix = "/api") => ({
   SIGNOUT: `${prefix}${"/auth/signout" /* SIGNOUT */}`,
   ERROR: `${prefix}/auth/error`,
   VERIFY_REQUEST: `${prefix}/auth/verify-request`,
-  PASSWORD_RESET: `${prefix}/auth/reset-password`,
+  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 */}`,
@@ -45,7 +47,8 @@ var proxyRoutes = (config) => ({
   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: makeRestUrl(config, "/auth/reset-password" /* PASSWORD_RESET */),
+  VERIFY_EMAIL: makeRestUrl(config, "/auth/verify-email" /* VERIFY_EMAIL */)
 });
 function filterNullUndefined(obj) {
   if (!obj) {
@@ -70,9 +73,9 @@ function makeRestUrl(config, path, qp) {
   const strParams = params.toString();
   return `${[url, path.substring(1, path.length)].join("/")}${strParams ? `?${strParams}` : ""}`;
 }
-function urlMatches(requestUrl, route16) {
+function urlMatches(requestUrl, route17) {
   const url = new URL(requestUrl);
-  return url.pathname.startsWith(route16);
+  return url.pathname.startsWith(route17);
 }
 function isUUID(value) {
   if (!value) {
@@ -142,9 +145,9 @@ function matchesLog(configRoutes, request2) {
 }
 
 // src/utils/constants.ts
-var X_NILE_TENANT = "nile.tenant_id";
-var X_NILE_ORIGIN = "nile.origin";
-var X_NILE_SECURECOOKIES = "nile.secure_cookies";
+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) {
@@ -163,15 +166,29 @@ async function request(url, _init, config) {
   }
   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 {
-    updatedHeaders.set(X_NILE_ORIGIN, requestUrl.origin);
-    debug(`Obtained origin from request ${requestUrl.origin}`);
+    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") {
@@ -425,11 +442,11 @@ async function route3(request2, config) {
 function matches3(configRoutes, request2) {
   const url = new URL(request2.url);
   const [userId, possibleTenantId, tenantId] = url.pathname.split("/").reverse();
-  let route16 = configRoutes[key3].replace("{tenantId}", tenantId).replace("{userId}", userId);
+  let route17 = configRoutes[key3].replace("{tenantId}", tenantId).replace("{userId}", userId);
   if (userId === "users") {
-    route16 = configRoutes[key3].replace("{tenantId}", possibleTenantId);
+    route17 = configRoutes[key3].replace("{tenantId}", possibleTenantId);
   }
-  return urlMatches(request2.url, route16);
+  return urlMatches(request2.url, route17);
 }
 
 // src/api/routes/tenants/GET.ts
@@ -709,6 +726,34 @@ 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]");
@@ -761,6 +806,10 @@ function GETTER(configRoutes, config) {
       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);
@@ -779,8 +828,8 @@ async function POST4(config, init) {
 }
 
 // src/api/routes/signup/index.tsx
-var key11 = "SIGNUP";
-async function route14(request2, config) {
+var key12 = "SIGNUP";
+async function route15(request2, config) {
   switch (request2.method) {
     case "POST":
       return await POST4(config, { request: request2 });
@@ -788,8 +837,8 @@ async function route14(request2, config) {
       return new Response("method not allowed", { status: 405 });
   }
 }
-function matches14(configRoutes, request2) {
-  return urlMatches(request2.url, configRoutes[key11]);
+function matches15(configRoutes, request2) {
+  return urlMatches(request2.url, configRoutes[key12]);
 }
 
 // src/api/handlers/POST.ts
@@ -797,24 +846,21 @@ function POSTER(configRoutes, config) {
   const { info, warn, error } = Logger(config, "[POST MATCHER]");
   return async function POST5(req) {
     if (matchesLog(configRoutes, req)) {
-      if (req.body) {
-        try {
-          const text = await req.text();
-          error(text);
-          return new Response(null, {
-            status: 200
-          });
-        } catch (e) {
-        }
+      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 (matches14(configRoutes, req)) {
+    if (matches15(configRoutes, req)) {
       info("matches signup");
-      return route14(req, config);
+      return route15(req, config);
     }
     if (matches2(configRoutes, req)) {
       info("matches users");
@@ -852,6 +898,10 @@ function POSTER(configRoutes, config) {
       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 });
   };
@@ -880,11 +930,11 @@ async function PUT4(config, init) {
 }
 
 // src/api/routes/tenants/[tenantId]/users/[userId]/index.ts
-var key12 = "TENANT_USER";
-async function route15(request2, config) {
+var key13 = "TENANT_USER";
+async function route16(request2, config) {
   const { info } = Logger(
     { ...config, debug: config.debug },
-    `[ROUTES][${key12}]`
+    `[ROUTES][${key13}]`
   );
   const session = await auth(request2, config);
   if (!session) {
@@ -906,23 +956,23 @@ async function route15(request2, config) {
       return new Response("method not allowed", { status: 405 });
   }
 }
-function matches15(configRoutes, request2) {
+function matches16(configRoutes, request2) {
   const url = new URL(request2.url);
   const [, userId, possibleTenantId, tenantId] = url.pathname.split("/").reverse();
-  let route16 = configRoutes[key12].replace("{tenantId}", tenantId).replace("{userId}", userId);
+  let route17 = configRoutes[key13].replace("{tenantId}", tenantId).replace("{userId}", userId);
   if (userId === "users") {
-    route16 = configRoutes[key12].replace("{tenantId}", possibleTenantId);
+    route17 = configRoutes[key13].replace("{tenantId}", possibleTenantId);
   }
-  return urlMatches(request2.url, route16);
+  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 (matches15(configRoutes, req)) {
+    if (matches16(configRoutes, req)) {
       info("matches tenant user");
-      return route15(req, config);
+      return route16(req, config);
     }
     if (matches3(configRoutes, req)) {
       info("matches tenant users");
@@ -945,9 +995,9 @@ function DELETER(configRoutes, config) {
 function PUTER(configRoutes, config) {
   const { info, warn } = Logger(config, "[PUT MATCHER]");
   return async function PUT5(req) {
-    if (matches15(configRoutes, req)) {
+    if (matches16(configRoutes, req)) {
       info("matches tenant user");
-      return route15(req, config);
+      return route16(req, config);
     }
     if (matches3(configRoutes, req)) {
       info("matches tenant users");
@@ -1152,7 +1202,6 @@ var stringCheck = (str) => {
 // src/utils/Config/index.ts
 var Config = class {
   routes;
-  // handlersWithContext;
   handlers;
   paths;
   logger;
@@ -1173,6 +1222,10 @@ var Config = class {
    */
   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
@@ -1191,7 +1244,8 @@ var Config = class {
     this.secureCookies = getSecureCookies(envVarConfig);
     this.callbackUrl = getCallbackUrl(envVarConfig);
     this.debug = config?.debug;
-    this.origin = config?.origin ?? "http://localhost:3000";
+    this.origin = config?.origin;
+    this.serverOrigin = config?.origin ?? "http://localhost:3000";
     this.apiUrl = getApiUrl(envVarConfig);
     const user = getUsername(envVarConfig);
     const password = getPassword(envVarConfig);
@@ -1330,17 +1384,17 @@ async function NileExpressHandler(nile, config) {
         body = await response.text();
       }
       const newHeaders = {};
-      response.headers.forEach((value, key13) => {
-        if (!["content-length", "transfer-encoding"].includes(key13.toLowerCase())) {
-          if (newHeaders[key13]) {
-            const prev = newHeaders[key13];
+      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[key13] = [...prev, value];
+              newHeaders[key14] = [...prev, value];
             } else {
-              newHeaders[key13] = [prev, value];
+              newHeaders[key14] = [prev, value];
             }
           } else {
-            newHeaders[key13] = value;
+            newHeaders[key14] = value;
           }
         }
       });