refactor and reorganize

.gitignore

@@ -27,4 +27,5 @@ package-lock.json
 tsconfig.tsbuildinfo
 config/
 dist
-.dist
+.dist
+installer

drizzle.config.ts

@@ -1,4 +1,4 @@
-import { APP_PATH } from "@server/consts";
+import { APP_PATH } from "@server/lib/consts";
 import { defineConfig } from "drizzle-kit";
 import path from "path";
 

install/.gitignore

@@ -1 +0,0 @@
-installer

server/apiServer.ts

@@ -1,7 +1,7 @@
 import express from "express";
 import cors from "cors";
 import cookieParser from "cookie-parser";
-import config from "@server/config";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import {
     errorHandlerMiddleware,

server/auth/index.ts

@@ -1,6 +1,3 @@
-export * from "./verifySession";
-export * from "./unauthorizedResponse";
-
 import {
     encodeBase32LowerCaseNoPadding,
     encodeHexLowerCase,
@@ -9,7 +6,7 @@ import { sha256 } from "@oslojs/crypto/sha2";
 import { Session, sessions, User, users } from "@server/db/schema";
 import db from "@server/db";
 import { eq } from "drizzle-orm";
-import config from "@server/config";
+import config from "@server/lib/config";
 import type { RandomReader } from "@oslojs/crypto/random";
 import { generateRandomString } from "@oslojs/crypto/random";
 

server/auth/resourceOtp.ts

@@ -5,7 +5,7 @@ import { createDate, isWithinExpirationDate, TimeSpan } from "oslo";
 import { alphabet, generateRandomString, sha256 } from "oslo/crypto";
 import { sendEmail } from "@server/emails";
 import ResourceOTPCode from "@server/emails/templates/ResourceOTPCode";
-import config from "@server/config";
+import config from "@server/lib/config";
 import { verifyPassword } from "./password";
 import { hashPassword } from "./password";
 

server/auth/sendEmailVerificationCode.ts

@@ -4,7 +4,7 @@ import db from "@server/db";
 import { users, emailVerificationCodes } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import { sendEmail } from "@server/emails";
-import config from "@server/config";
+import config from "@server/lib/config";
 import { VerifyEmail } from "@server/emails/templates/VerifyEmailCode";
 
 export async function sendEmailVerificationCode(

server/auth/sessions/app.ts

@@ -0,0 +1,118 @@
+import {
+    encodeBase32LowerCaseNoPadding,
+    encodeHexLowerCase,
+} from "@oslojs/encoding";
+import { sha256 } from "@oslojs/crypto/sha2";
+import { Session, sessions, User, users } from "@server/db/schema";
+import db from "@server/db";
+import { eq } from "drizzle-orm";
+import config from "@server/lib/config";
+import type { RandomReader } from "@oslojs/crypto/random";
+import { generateRandomString } from "@oslojs/crypto/random";
+
+export const SESSION_COOKIE_NAME = config.getRawConfig().server.session_cookie_name;
+export const SESSION_COOKIE_EXPIRES = 1000 * 60 * 60 * 24 * 30;
+export const SECURE_COOKIES = config.getRawConfig().server.secure_cookies;
+export const COOKIE_DOMAIN = "." + config.getBaseDomain();
+
+export function generateSessionToken(): string {
+    const bytes = new Uint8Array(20);
+    crypto.getRandomValues(bytes);
+    const token = encodeBase32LowerCaseNoPadding(bytes);
+    return token;
+}
+
+export async function createSession(
+    token: string,
+    userId: string,
+): Promise<Session> {
+    const sessionId = encodeHexLowerCase(
+        sha256(new TextEncoder().encode(token)),
+    );
+    const session: Session = {
+        sessionId: sessionId,
+        userId,
+        expiresAt: new Date(Date.now() + SESSION_COOKIE_EXPIRES).getTime(),
+    };
+    await db.insert(sessions).values(session);
+    return session;
+}
+
+export async function validateSessionToken(
+    token: string,
+): Promise<SessionValidationResult> {
+    const sessionId = encodeHexLowerCase(
+        sha256(new TextEncoder().encode(token)),
+    );
+    const result = await db
+        .select({ user: users, session: sessions })
+        .from(sessions)
+        .innerJoin(users, eq(sessions.userId, users.userId))
+        .where(eq(sessions.sessionId, sessionId));
+    if (result.length < 1) {
+        return { session: null, user: null };
+    }
+    const { user, session } = result[0];
+    if (Date.now() >= session.expiresAt) {
+        await db
+            .delete(sessions)
+            .where(eq(sessions.sessionId, session.sessionId));
+        return { session: null, user: null };
+    }
+    if (Date.now() >= session.expiresAt - SESSION_COOKIE_EXPIRES / 2) {
+        session.expiresAt = new Date(
+            Date.now() + SESSION_COOKIE_EXPIRES,
+        ).getTime();
+        await db
+            .update(sessions)
+            .set({
+                expiresAt: session.expiresAt,
+            })
+            .where(eq(sessions.sessionId, session.sessionId));
+    }
+    return { session, user };
+}
+
+export async function invalidateSession(sessionId: string): Promise<void> {
+    await db.delete(sessions).where(eq(sessions.sessionId, sessionId));
+}
+
+export async function invalidateAllSessions(userId: string): Promise<void> {
+    await db.delete(sessions).where(eq(sessions.userId, userId));
+}
+
+export function serializeSessionCookie(token: string): string {
+    if (SECURE_COOKIES) {
+        return `${SESSION_COOKIE_NAME}=${token}; HttpOnly; SameSite=Strict; Max-Age=${SESSION_COOKIE_EXPIRES}; Path=/; Secure; Domain=${COOKIE_DOMAIN}`;
+    } else {
+        return `${SESSION_COOKIE_NAME}=${token}; HttpOnly; SameSite=Strict; Max-Age=${SESSION_COOKIE_EXPIRES}; Path=/; Domain=${COOKIE_DOMAIN}`;
+    }
+}
+
+export function createBlankSessionTokenCookie(): string {
+    if (SECURE_COOKIES) {
+        return `${SESSION_COOKIE_NAME}=; HttpOnly; SameSite=Strict; Max-Age=0; Path=/; Secure; Domain=${COOKIE_DOMAIN}`;
+    } else {
+        return `${SESSION_COOKIE_NAME}=; HttpOnly; SameSite=Strict; Max-Age=0; Path=/; Domain=${COOKIE_DOMAIN}`;
+    }
+}
+
+const random: RandomReader = {
+    read(bytes: Uint8Array): void {
+        crypto.getRandomValues(bytes);
+    },
+};
+
+export function generateId(length: number): string {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+    return generateRandomString(random, alphabet, length);
+}
+
+export function generateIdFromEntropySize(size: number): string {
+    const buffer = crypto.getRandomValues(new Uint8Array(size));
+    return encodeBase32LowerCaseNoPadding(buffer);
+}
+
+export type SessionValidationResult =
+    | { session: Session; user: User }
+    | { session: null; user: null };

server/auth/newt.ts → server/auth/sessions/newt.ts

@@ -1,6 +1,3 @@
-export * from "./verifySession";
-export * from "./unauthorizedResponse";
-
 import {
     encodeHexLowerCase,
 } from "@oslojs/encoding";
@@ -8,12 +5,8 @@ import { sha256 } from "@oslojs/crypto/sha2";
 import { Newt, newts, newtSessions, NewtSession } from "@server/db/schema";
 import db from "@server/db";
 import { eq } from "drizzle-orm";
-import config from "@server/config";
 
-export const SESSION_COOKIE_NAME = "session";
-export const SESSION_COOKIE_EXPIRES = 1000 * 60 * 60 * 24 * 30;
-export const SECURE_COOKIES = config.getRawConfig().server.secure_cookies;
-export const COOKIE_DOMAIN = "." + config.getBaseDomain();
+export const EXPIRES = 1000 * 60 * 60 * 24 * 30;
 
 export async function createNewtSession(
     token: string,
@@ -25,7 +18,7 @@ export async function createNewtSession(
     const session: NewtSession = {
         sessionId: sessionId,
         newtId,
-        expiresAt: new Date(Date.now() + SESSION_COOKIE_EXPIRES).getTime(),
+        expiresAt: new Date(Date.now() + EXPIRES).getTime(),
     };
     await db.insert(newtSessions).values(session);
     return session;
@@ -52,9 +45,9 @@ export async function validateNewtSessionToken(
             .where(eq(newtSessions.sessionId, session.sessionId));
         return { session: null, newt: null };
     }
-    if (Date.now() >= session.expiresAt - (SESSION_COOKIE_EXPIRES / 2)) {
+    if (Date.now() >= session.expiresAt - (EXPIRES / 2)) {
         session.expiresAt = new Date(
-            Date.now() + SESSION_COOKIE_EXPIRES,
+            Date.now() + EXPIRES,
         ).getTime();
         await db
             .update(newtSessions)

server/auth/resource.ts → server/auth/sessions/resource.ts

@@ -1,15 +1,12 @@
 import { encodeHexLowerCase } from "@oslojs/encoding";
 import { sha256 } from "@oslojs/crypto/sha2";
-import {
-    resourceSessions,
-    ResourceSession,
-    resources
-} from "@server/db/schema";
+import { resourceSessions, ResourceSession } from "@server/db/schema";
 import db from "@server/db";
 import { eq, and } from "drizzle-orm";
-import config from "@server/config";
+import config from "@server/lib/config";
 
-export const SESSION_COOKIE_NAME = "resource_session";
+export const SESSION_COOKIE_NAME =
+    config.getRawConfig().server.resource_session_cookie_name;
 export const SESSION_COOKIE_EXPIRES = 1000 * 60 * 60 * 24 * 30;
 export const SECURE_COOKIES = config.getRawConfig().server.secure_cookies;
 export const COOKIE_DOMAIN = "." + config.getBaseDomain();
@@ -88,18 +85,20 @@ export async function validateResourceSessionToken(
         return { resourceSession: null };
     } else if (
         Date.now() >=
-            resourceSession.expiresAt - resourceSession.sessionLength / 2
+        resourceSession.expiresAt - resourceSession.sessionLength / 2
     ) {
         if (!resourceSession.doNotExtend) {
             resourceSession.expiresAt = new Date(
                 Date.now() + resourceSession.sessionLength
             ).getTime();
             await db
-            .update(resourceSessions)
-            .set({
-                expiresAt: resourceSession.expiresAt
-            })
-            .where(eq(resourceSessions.sessionId, resourceSession.sessionId));
+                .update(resourceSessions)
+                .set({
+                    expiresAt: resourceSession.expiresAt
+                })
+                .where(
+                    eq(resourceSessions.sessionId, resourceSession.sessionId)
+                );
         }
     }
 

server/auth/verifySession.ts → server/auth/sessions/verifySession.ts

@@ -1,5 +1,5 @@
 import { Request } from "express";
-import { validateSessionToken, SESSION_COOKIE_NAME } from "@server/auth";
+import { validateSessionToken, SESSION_COOKIE_NAME } from "@server/auth/sessions/app";
 
 export async function verifySession(req: Request) {
     const res = await validateSessionToken(

server/db/index.ts

@@ -3,7 +3,7 @@ import Database from "better-sqlite3";
 import * as schema from "@server/db/schema";
 import path from "path";
 import fs from "fs/promises";
-import { APP_PATH } from "@server/consts";
+import { APP_PATH } from "@server/lib/consts";
 
 export const location = path.join(APP_PATH, "db", "db.sqlite");
 export const exists = await checkFileExists(location);

server/db/names.ts

@@ -3,15 +3,15 @@ import { readFileSync } from "fs";
 import { db } from "@server/db";
 import { exitNodes, sites } from "./schema";
 import { eq, and } from "drizzle-orm";
-import { __DIRNAME } from "@server/consts";
+import { __DIRNAME } from "@server/lib/consts";
 
 // Load the names from the names.json file
 const dev = process.env.ENVIRONMENT !== "prod";
 let file;
 if (!dev) {
-    file = join(__DIRNAME, "names.json");
+    file = join("names.json");
 } else {
-    file = join(__DIRNAME, "/db/names.json");
+    file = join("server/db/names.json");
 }
 export const names = JSON.parse(readFileSync(file, "utf-8"));
 

server/emails/index.ts

@@ -1,7 +1,7 @@
 export * from "@server/emails/sendEmail";
 
 import nodemailer from "nodemailer";
-import config from "@server/config";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 
 function createEmailClient() {

server/internalServer.ts

@@ -2,7 +2,7 @@ import express from "express";
 import helmet from "helmet";
 import cors from "cors";
 import cookieParser from "cookie-parser";
-import config from "@server/config";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import {
     errorHandlerMiddleware,

server/config.ts → server/lib/config.ts

@@ -3,8 +3,8 @@ import yaml from "js-yaml";
 import path from "path";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
-import { __DIRNAME, APP_PATH } from "@server/consts";
-import { loadAppVersion } from "@server/utils/loadAppVersion";
+import { __DIRNAME, APP_PATH } from "@server/lib/consts";
+import { loadAppVersion } from "@server/lib/loadAppVersion";
 
 const portSchema = z.number().positive().gt(0).lte(65535);
 

server/utils/loadAppVersion.ts → server/lib/loadAppVersion.ts

@@ -1,9 +1,9 @@
 import path from "path";
-import { __DIRNAME } from "@server/consts";
+import { __DIRNAME } from "@server/lib/consts";
 import fs from "fs";
 
 export function loadAppVersion() {
-    const packageJsonPath = path.join(__DIRNAME, "..", "package.json");
+    const packageJsonPath = path.join("package.json");
     let packageJson: any;
     if (fs.existsSync && fs.existsSync(packageJsonPath)) {
         const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");

server/logger.ts

@@ -1,8 +1,8 @@
 import "winston-daily-rotate-file";
-import config from "@server/config";
+import config from "@server/lib/config";
 import * as winston from "winston";
 import path from "path";
-import { APP_PATH } from "./consts";
+import { APP_PATH } from "./lib/consts";
 
 const hformat = winston.format.printf(
     ({ level, label, message, timestamp, stack, ...metadata }) => {

server/middlewares/formatError.ts

@@ -2,7 +2,7 @@ import { ErrorRequestHandler, NextFunction, Response } from "express";
 import ErrorResponse from "@server/types/ErrorResponse";
 import HttpCode from "@server/types/HttpCode";
 import logger from "@server/logger";
-import config from "@server/config";
+import config from "@server/lib/config";
 
 export const errorHandlerMiddleware: ErrorRequestHandler = (
     error,

server/middlewares/verifyAccessTokenAccess.ts

@@ -4,7 +4,7 @@ import { resourceAccessToken, resources, userOrgs } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import { canUserAccessResource } from "./helpers/canUserAccessResource";
+import { canUserAccessResource } from "@server/lib/canUserAccessResource";
 
 export async function verifyAccessTokenAccess(
     req: Request,

server/middlewares/verifySession.ts

@@ -1,16 +1,17 @@
 import { NextFunction, Response } from "express";
 import ErrorResponse from "@server/types/ErrorResponse";
-import { unauthorized, verifySession } from "@server/auth";
 import { db } from "@server/db";
 import { users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
+import { verifySession } from "@server/auth/sessions/verifySession";
+import { unauthorized } from "@server/auth/unauthorizedResponse";
 
 export const verifySessionMiddleware = async (
     req: any,
     res: Response<ErrorResponse>,
-    next: NextFunction,
+    next: NextFunction
 ) => {
     const { session, user } = await verifySession(req);
     if (!session || !user) {
@@ -24,7 +25,7 @@ export const verifySessionMiddleware = async (
 
     if (!existingUser || !existingUser[0]) {
         return next(
-            createHttpError(HttpCode.BAD_REQUEST, "User does not exist"),
+            createHttpError(HttpCode.BAD_REQUEST, "User does not exist")
         );
     }
 

server/middlewares/verifyTargetAccess.ts

@@ -4,7 +4,7 @@ import { resources, targets, userOrgs } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import { canUserAccessResource } from "./helpers/canUserAccessResource";
+import { canUserAccessResource } from "../lib/canUserAccessResource";
 
 export async function verifyTargetAccess(
     req: Request,

server/middlewares/verifyUser.ts

@@ -1,12 +1,13 @@
 import { NextFunction, Response } from "express";
 import ErrorResponse from "@server/types/ErrorResponse";
-import { unauthorized, verifySession } from "@server/auth";
 import { db } from "@server/db";
 import { users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import config from "@server/config";
+import config from "@server/lib/config";
+import { verifySession } from "@server/auth/sessions/verifySession";
+import { unauthorized } from "@server/auth/unauthorizedResponse";
 
 export const verifySessionUserMiddleware = async (
     req: any,

server/names.json

@@ -1,1711 +0,0 @@
-{
-    "descriptors": [
-        "abandoned",
-        "able",
-        "absolute",
-        "adorable",
-        "adventurous",
-        "academic",
-        "acceptable",
-        "acclaimed",
-        "accomplished",
-        "accurate",
-        "aching",
-        "acidic",
-        "acrobatic",
-        "active",
-        "actual",
-        "adept",
-        "admirable",
-        "admired",
-        "adolescent",
-        "adorable",
-        "adored",
-        "advanced",
-        "afraid",
-        "affectionate",
-        "aged",
-        "aggravating",
-        "aggressive",
-        "agile",
-        "agitated",
-        "agonizing",
-        "agreeable",
-        "ajar",
-        "alarmed",
-        "alarming",
-        "alert",
-        "alienated",
-        "alive",
-        "all",
-        "altruistic",
-        "amazing",
-        "ambitious",
-        "ample",
-        "amused",
-        "amusing",
-        "anchored",
-        "ancient",
-        "angelic",
-        "angry",
-        "anguished",
-        "animated",
-        "annual",
-        "another",
-        "antique",
-        "anxious",
-        "any",
-        "apprehensive",
-        "appropriate",
-        "apt",
-        "arctic",
-        "arid",
-        "aromatic",
-        "artistic",
-        "ashamed",
-        "assured",
-        "astonishing",
-        "athletic",
-        "attached",
-        "attentive",
-        "attractive",
-        "austere",
-        "authentic",
-        "authorized",
-        "automatic",
-        "avaricious",
-        "average",
-        "aware",
-        "awesome",
-        "awful",
-        "awkward",
-        "babyish",
-        "bad",
-        "back",
-        "baggy",
-        "bare",
-        "barren",
-        "basic",
-        "beautiful",
-        "belated",
-        "beloved",
-        "beneficial",
-        "better",
-        "best",
-        "bewitched",
-        "big",
-        "big-hearted",
-        "biodegradable",
-        "bite-sized",
-        "bitter",
-        "black",
-        "black-and-white",
-        "bland",
-        "blank",
-        "blaring",
-        "bleak",
-        "blind",
-        "blissful",
-        "blond",
-        "blue",
-        "blushing",
-        "bogus",
-        "boiling",
-        "bold",
-        "bony",
-        "boring",
-        "bossy",
-        "both",
-        "bouncy",
-        "bountiful",
-        "bowed",
-        "brave",
-        "breakable",
-        "brief",
-        "bright",
-        "brilliant",
-        "brisk",
-        "broken",
-        "bronze",
-        "brown",
-        "bruised",
-        "bubbly",
-        "bulky",
-        "bumpy",
-        "buoyant",
-        "burdensome",
-        "burly",
-        "bustling",
-        "busy",
-        "buttery",
-        "buzzing",
-        "calculating",
-        "calm",
-        "candid",
-        "canine",
-        "capital",
-        "carefree",
-        "careful",
-        "careless",
-        "caring",
-        "cautious",
-        "cavernous",
-        "celebrated",
-        "charming",
-        "cheap",
-        "cheerful",
-        "cheery",
-        "chief",
-        "chilly",
-        "chubby",
-        "circular",
-        "classic",
-        "clean",
-        "clear",
-        "clear-cut",
-        "clever",
-        "close",
-        "closed",
-        "cloudy",
-        "clueless",
-        "clumsy",
-        "cluttered",
-        "coarse",
-        "cold",
-        "colorful",
-        "colorless",
-        "colossal",
-        "comfortable",
-        "common",
-        "compassionate",
-        "competent",
-        "complete",
-        "complex",
-        "complicated",
-        "composed",
-        "concerned",
-        "concrete",
-        "confused",
-        "conscious",
-        "considerate",
-        "constant",
-        "content",
-        "conventional",
-        "cooked",
-        "cool",
-        "cooperative",
-        "coordinated",
-        "corny",
-        "corrupt",
-        "costly",
-        "courageous",
-        "courteous",
-        "crafty",
-        "crazy",
-        "creamy",
-        "creative",
-        "creepy",
-        "criminal",
-        "crisp",
-        "critical",
-        "crooked",
-        "crowded",
-        "cruel",
-        "crushing",
-        "cuddly",
-        "cultivated",
-        "cultured",
-        "cumbersome",
-        "curly",
-        "curvy",
-        "cute",
-        "cylindrical",
-        "damaged",
-        "damp",
-        "dangerous",
-        "dapper",
-        "daring",
-        "darling",
-        "dark",
-        "dazzling",
-        "dead",
-        "deadly",
-        "deafening",
-        "dear",
-        "dearest",
-        "decent",
-        "decimal",
-        "decisive",
-        "deep",
-        "defenseless",
-        "defensive",
-        "defiant",
-        "deficient",
-        "definite",
-        "definitive",
-        "delayed",
-        "delectable",
-        "delicious",
-        "delightful",
-        "delirious",
-        "demanding",
-        "dense",
-        "dental",
-        "dependable",
-        "dependent",
-        "descriptive",
-        "deserted",
-        "detailed",
-        "determined",
-        "devoted",
-        "different",
-        "difficult",
-        "digital",
-        "diligent",
-        "dim",
-        "dimpled",
-        "dimwitted",
-        "direct",
-        "disastrous",
-        "discrete",
-        "disfigured",
-        "disgusting",
-        "disloyal",
-        "dismal",
-        "distant",
-        "downright",
-        "dreary",
-        "dirty",
-        "disguised",
-        "dishonest",
-        "dismal",
-        "distant",
-        "distinct",
-        "distorted",
-        "dizzy",
-        "dopey",
-        "doting",
-        "double",
-        "downright",
-        "drab",
-        "drafty",
-        "dramatic",
-        "dreary",
-        "droopy",
-        "dry",
-        "dual",
-        "dull",
-        "dutiful",
-        "each",
-        "eager",
-        "earnest",
-        "early",
-        "easy",
-        "easy-going",
-        "ecstatic",
-        "edible",
-        "educated",
-        "elaborate",
-        "elastic",
-        "elated",
-        "elderly",
-        "electric",
-        "elegant",
-        "elementary",
-        "elliptical",
-        "embarrassed",
-        "embellished",
-        "eminent",
-        "emotional",
-        "empty",
-        "enchanted",
-        "enchanting",
-        "energetic",
-        "enlightened",
-        "enormous",
-        "enraged",
-        "entire",
-        "envious",
-        "equal",
-        "equatorial",
-        "essential",
-        "esteemed",
-        "ethical",
-        "euphoric",
-        "even",
-        "evergreen",
-        "everlasting",
-        "every",
-        "evil",
-        "exalted",
-        "excellent",
-        "exemplary",
-        "exhausted",
-        "excitable",
-        "excited",
-        "exciting",
-        "exotic",
-        "expensive",
-        "experienced",
-        "expert",
-        "extraneous",
-        "extroverted",
-        "extra-large",
-        "extra-small",
-        "fabulous",
-        "failing",
-        "faint",
-        "fair",
-        "faithful",
-        "fake",
-        "false",
-        "familiar",
-        "famous",
-        "fancy",
-        "fantastic",
-        "far",
-        "faraway",
-        "far-flung",
-        "far-off",
-        "fast",
-        "fat",
-        "fatal",
-        "fatherly",
-        "favorable",
-        "favorite",
-        "fearful",
-        "fearless",
-        "feisty",
-        "feline",
-        "female",
-        "feminine",
-        "few",
-        "fickle",
-        "filthy",
-        "fine",
-        "finished",
-        "firm",
-        "first",
-        "firsthand",
-        "fitting",
-        "fixed",
-        "flaky",
-        "flamboyant",
-        "flashy",
-        "flat",
-        "flawed",
-        "flawless",
-        "flickering",
-        "flimsy",
-        "flippant",
-        "flowery",
-        "fluffy",
-        "fluid",
-        "flustered",
-        "focused",
-        "fond",
-        "foolhardy",
-        "foolish",
-        "forceful",
-        "forked",
-        "formal",
-        "forsaken",
-        "forthright",
-        "fortunate",
-        "fragrant",
-        "frail",
-        "frank",
-        "frayed",
-        "free",
-        "French",
-        "fresh",
-        "frequent",
-        "friendly",
-        "frightened",
-        "frightening",
-        "frigid",
-        "frilly",
-        "frizzy",
-        "frivolous",
-        "front",
-        "frosty",
-        "frozen",
-        "frugal",
-        "fruitful",
-        "full",
-        "fumbling",
-        "functional",
-        "funny",
-        "fussy",
-        "fuzzy",
-        "gargantuan",
-        "gaseous",
-        "general",
-        "generous",
-        "gentle",
-        "genuine",
-        "giant",
-        "giddy",
-        "gigantic",
-        "gifted",
-        "giving",
-        "glamorous",
-        "glaring",
-        "glass",
-        "gleaming",
-        "gleeful",
-        "glistening",
-        "glittering",
-        "gloomy",
-        "glorious",
-        "glossy",
-        "glum",
-        "golden",
-        "good",
-        "good-natured",
-        "gorgeous",
-        "graceful",
-        "gracious",
-        "grand",
-        "grandiose",
-        "granular",
-        "grateful",
-        "grave",
-        "gray",
-        "great",
-        "greedy",
-        "green",
-        "gregarious",
-        "grim",
-        "grimy",
-        "gripping",
-        "grizzled",
-        "gross",
-        "grotesque",
-        "grouchy",
-        "grounded",
-        "growing",
-        "growling",
-        "grown",
-        "grubby",
-        "gruesome",
-        "grumpy",
-        "guilty",
-        "gullible",
-        "gummy",
-        "hairy",
-        "half",
-        "handmade",
-        "handsome",
-        "handy",
-        "happy",
-        "happy-go-lucky",
-        "hard",
-        "hard-to-find",
-        "harmful",
-        "harmless",
-        "harmonious",
-        "harsh",
-        "hasty",
-        "hateful",
-        "haunting",
-        "healthy",
-        "heartfelt",
-        "hearty",
-        "heavenly",
-        "heavy",
-        "hefty",
-        "helpful",
-        "helpless",
-        "hidden",
-        "hideous",
-        "high",
-        "high-level",
-        "hilarious",
-        "hoarse",
-        "hollow",
-        "homely",
-        "honest",
-        "honorable",
-        "honored",
-        "hopeful",
-        "horrible",
-        "hospitable",
-        "hot",
-        "huge",
-        "humble",
-        "humiliating",
-        "humming",
-        "humongous",
-        "hungry",
-        "hurtful",
-        "husky",
-        "icky",
-        "icy",
-        "ideal",
-        "idealistic",
-        "identical",
-        "idle",
-        "idiotic",
-        "idolized",
-        "ignorant",
-        "ill",
-        "illegal",
-        "ill-fated",
-        "ill-informed",
-        "illiterate",
-        "illustrious",
-        "imaginary",
-        "imaginative",
-        "immaculate",
-        "immaterial",
-        "immediate",
-        "immense",
-        "impassioned",
-        "impeccable",
-        "impartial",
-        "imperfect",
-        "imperturbable",
-        "impish",
-        "impolite",
-        "important",
-        "impossible",
-        "impractical",
-        "impressionable",
-        "impressive",
-        "improbable",
-        "impure",
-        "inborn",
-        "incomparable",
-        "incompatible",
-        "incomplete",
-        "inconsequential",
-        "incredible",
-        "indelible",
-        "inexperienced",
-        "indolent",
-        "infamous",
-        "infantile",
-        "infatuated",
-        "inferior",
-        "infinite",
-        "informal",
-        "innocent",
-        "insecure",
-        "insidious",
-        "insignificant",
-        "insistent",
-        "instructive",
-        "insubstantial",
-        "intelligent",
-        "intent",
-        "intentional",
-        "interesting",
-        "internal",
-        "international",
-        "intrepid",
-        "ironclad",
-        "irresponsible",
-        "irritating",
-        "itchy",
-        "jaded",
-        "jagged",
-        "jam-packed",
-        "jaunty",
-        "jealous",
-        "jittery",
-        "joint",
-        "jolly",
-        "jovial",
-        "joyful",
-        "joyous",
-        "jubilant",
-        "judicious",
-        "juicy",
-        "jumbo",
-        "junior",
-        "jumpy",
-        "juvenile",
-        "kaleidoscopic",
-        "keen",
-        "key",
-        "kind",
-        "kindhearted",
-        "kindly",
-        "klutzy",
-        "knobby",
-        "knotty",
-        "knowledgeable",
-        "knowing",
-        "known",
-        "kooky",
-        "kosher",
-        "lame",
-        "lanky",
-        "large",
-        "last",
-        "lasting",
-        "late",
-        "lavish",
-        "lawful",
-        "lazy",
-        "leading",
-        "lean",
-        "leafy",
-        "left",
-        "legal",
-        "legitimate",
-        "light",
-        "lighthearted",
-        "likable",
-        "likely",
-        "limited",
-        "limp",
-        "limping",
-        "linear",
-        "lined",
-        "liquid",
-        "little",
-        "live",
-        "lively",
-        "livid",
-        "loathsome",
-        "lone",
-        "lonely",
-        "long",
-        "long-term",
-        "loose",
-        "lopsided",
-        "lost",
-        "loud",
-        "lovable",
-        "lovely",
-        "loving",
-        "low",
-        "loyal",
-        "lucky",
-        "lumbering",
-        "luminous",
-        "lumpy",
-        "lustrous",
-        "luxurious",
-        "mad",
-        "made-up",
-        "magnificent",
-        "majestic",
-        "major",
-        "male",
-        "mammoth",
-        "married",
-        "marvelous",
-        "masculine",
-        "massive",
-        "mature",
-        "meager",
-        "mealy",
-        "mean",
-        "measly",
-        "meaty",
-        "medical",
-        "mediocre",
-        "medium",
-        "meek",
-        "mellow",
-        "melodic",
-        "memorable",
-        "menacing",
-        "merry",
-        "messy",
-        "metallic",
-        "mild",
-        "milky",
-        "mindless",
-        "miniature",
-        "minor",
-        "minty",
-        "miserable",
-        "miserly",
-        "misguided",
-        "misty",
-        "mixed",
-        "modern",
-        "modest",
-        "moist",
-        "monstrous",
-        "monthly",
-        "monumental",
-        "moral",
-        "mortified",
-        "motherly",
-        "motionless",
-        "mountainous",
-        "muddy",
-        "muffled",
-        "multicolored",
-        "mundane",
-        "murky",
-        "mushy",
-        "musty",
-        "muted",
-        "mysterious",
-        "naive",
-        "narrow",
-        "nasty",
-        "natural",
-        "naughty",
-        "nautical",
-        "near",
-        "neat",
-        "necessary",
-        "needy",
-        "negative",
-        "neglected",
-        "negligible",
-        "neighboring",
-        "nervous",
-        "new",
-        "next",
-        "nice",
-        "nifty",
-        "nimble",
-        "nippy",
-        "nocturnal",
-        "noisy",
-        "nonstop",
-        "normal",
-        "notable",
-        "noted",
-        "noteworthy",
-        "novel",
-        "noxious",
-        "numb",
-        "nutritious",
-        "nutty",
-        "obedient",
-        "obese",
-        "oblong",
-        "oily",
-        "oblong",
-        "obvious",
-        "occasional",
-        "odd",
-        "oddball",
-        "offbeat",
-        "offensive",
-        "official",
-        "old",
-        "old-fashioned",
-        "only",
-        "open",
-        "optimal",
-        "optimistic",
-        "opulent",
-        "orange",
-        "orderly",
-        "organic",
-        "ornate",
-        "ornery",
-        "ordinary",
-        "original",
-        "other",
-        "our",
-        "outlying",
-        "outgoing",
-        "outlandish",
-        "outrageous",
-        "outstanding",
-        "oval",
-        "overcooked",
-        "overdue",
-        "overjoyed",
-        "overlooked",
-        "palatable",
-        "pale",
-        "paltry",
-        "parallel",
-        "parched",
-        "partial",
-        "passionate",
-        "past",
-        "pastel",
-        "peaceful",
-        "peppery",
-        "perfect",
-        "perfumed",
-        "periodic",
-        "perky",
-        "personal",
-        "pertinent",
-        "pesky",
-        "pessimistic",
-        "petty",
-        "phony",
-        "physical",
-        "piercing",
-        "pink",
-        "pitiful",
-        "plain",
-        "plaintive",
-        "plastic",
-        "playful",
-        "pleasant",
-        "pleased",
-        "pleasing",
-        "plump",
-        "plush",
-        "polished",
-        "polite",
-        "political",
-        "pointed",
-        "pointless",
-        "poised",
-        "poor",
-        "popular",
-        "portly",
-        "posh",
-        "positive",
-        "possible",
-        "potable",
-        "powerful",
-        "powerless",
-        "practical",
-        "precious",
-        "present",
-        "prestigious",
-        "pretty",
-        "precious",
-        "previous",
-        "pricey",
-        "prickly",
-        "primary",
-        "prime",
-        "pristine",
-        "private",
-        "prize",
-        "probable",
-        "productive",
-        "profitable",
-        "profuse",
-        "proper",
-        "proud",
-        "prudent",
-        "punctual",
-        "pungent",
-        "puny",
-        "pure",
-        "purple",
-        "pushy",
-        "putrid",
-        "puzzled",
-        "puzzling",
-        "quaint",
-        "qualified",
-        "quarrelsome",
-        "quarterly",
-        "queasy",
-        "querulous",
-        "questionable",
-        "quick",
-        "quick-witted",
-        "quiet",
-        "quintessential",
-        "quirky",
-        "quixotic",
-        "quizzical",
-        "radiant",
-        "ragged",
-        "rapid",
-        "rare",
-        "rash",
-        "raw",
-        "recent",
-        "reckless",
-        "rectangular",
-        "ready",
-        "real",
-        "realistic",
-        "reasonable",
-        "red",
-        "reflecting",
-        "regal",
-        "regular",
-        "reliable",
-        "relieved",
-        "remarkable",
-        "remorseful",
-        "remote",
-        "repentant",
-        "required",
-        "respectful",
-        "responsible",
-        "repulsive",
-        "revolving",
-        "rewarding",
-        "rich",
-        "rigid",
-        "right",
-        "ringed",
-        "ripe",
-        "roasted",
-        "robust",
-        "rosy",
-        "rotating",
-        "rotten",
-        "rough",
-        "round",
-        "rowdy",
-        "royal",
-        "rubbery",
-        "rundown",
-        "ruddy",
-        "rude",
-        "runny",
-        "rural",
-        "rusty",
-        "sad",
-        "safe",
-        "salty",
-        "same",
-        "sandy",
-        "sane",
-        "sarcastic",
-        "sardonic",
-        "satisfied",
-        "scaly",
-        "scarce",
-        "scared",
-        "scary",
-        "scented",
-        "scholarly",
-        "scientific",
-        "scornful",
-        "scratchy",
-        "scrawny",
-        "second",
-        "secondary",
-        "second-hand",
-        "secret",
-        "self-assured",
-        "self-reliant",
-        "selfish",
-        "sentimental",
-        "separate",
-        "serene",
-        "serious",
-        "serpentine",
-        "several",
-        "severe",
-        "shabby",
-        "shadowy",
-        "shady",
-        "shallow",
-        "shameful",
-        "shameless",
-        "sharp",
-        "shimmering",
-        "shiny",
-        "shocked",
-        "shocking",
-        "shoddy",
-        "short",
-        "short-term",
-        "showy",
-        "shrill",
-        "shy",
-        "sick",
-        "silent",
-        "silky",
-        "silly",
-        "silver",
-        "similar",
-        "simple",
-        "simplistic",
-        "sinful",
-        "single",
-        "sizzling",
-        "skeletal",
-        "skinny",
-        "sleepy",
-        "slight",
-        "slim",
-        "slimy",
-        "slippery",
-        "slow",
-        "slushy",
-        "small",
-        "smart",
-        "smoggy",
-        "smooth",
-        "smug",
-        "snappy",
-        "snarling",
-        "sneaky",
-        "sniveling",
-        "snoopy",
-        "sociable",
-        "soft",
-        "soggy",
-        "solid",
-        "somber",
-        "some",
-        "spherical",
-        "sophisticated",
-        "sore",
-        "sorrowful",
-        "soulful",
-        "soupy",
-        "sour",
-        "Spanish",
-        "sparkling",
-        "sparse",
-        "specific",
-        "spectacular",
-        "speedy",
-        "spicy",
-        "spiffy",
-        "spirited",
-        "spiteful",
-        "splendid",
-        "spotless",
-        "spotted",
-        "spry",
-        "square",
-        "squeaky",
-        "squiggly",
-        "stable",
-        "staid",
-        "stained",
-        "stale",
-        "standard",
-        "starchy",
-        "stark",
-        "starry",
-        "steep",
-        "sticky",
-        "stiff",
-        "stimulating",
-        "stingy",
-        "stormy",
-        "straight",
-        "strange",
-        "steel",
-        "strict",
-        "strident",
-        "striking",
-        "striped",
-        "strong",
-        "studious",
-        "stunning",
-        "stupendous",
-        "stupid",
-        "sturdy",
-        "stylish",
-        "subdued",
-        "submissive",
-        "substantial",
-        "subtle",
-        "suburban",
-        "sudden",
-        "sugary",
-        "sunny",
-        "super",
-        "superb",
-        "superficial",
-        "superior",
-        "supportive",
-        "sure-footed",
-        "surprised",
-        "suspicious",
-        "svelte",
-        "sweaty",
-        "sweet",
-        "sweltering",
-        "swift",
-        "sympathetic",
-        "tall",
-        "talkative",
-        "tame",
-        "tan",
-        "tangible",
-        "tart",
-        "tasty",
-        "tattered",
-        "taut",
-        "tedious",
-        "teeming",
-        "tempting",
-        "tender",
-        "tense",
-        "tepid",
-        "terrible",
-        "terrific",
-        "testy",
-        "thankful",
-        "that",
-        "these",
-        "thick",
-        "thin",
-        "third",
-        "thirsty",
-        "this",
-        "thorough",
-        "thorny",
-        "those",
-        "thoughtful",
-        "threadbare",
-        "thrifty",
-        "thunderous",
-        "tidy",
-        "tight",
-        "timely",
-        "tinted",
-        "tiny",
-        "tired",
-        "torn",
-        "total",
-        "tough",
-        "traumatic",
-        "treasured",
-        "tremendous",
-        "tragic",
-        "trained",
-        "tremendous",
-        "triangular",
-        "tricky",
-        "trifling",
-        "trim",
-        "trivial",
-        "troubled",
-        "true",
-        "trusting",
-        "trustworthy",
-        "trusty",
-        "truthful",
-        "tubby",
-        "turbulent",
-        "twin",
-        "ugly",
-        "ultimate",
-        "unacceptable",
-        "unaware",
-        "uncomfortable",
-        "uncommon",
-        "unconscious",
-        "understated",
-        "unequaled",
-        "uneven",
-        "unfinished",
-        "unfit",
-        "unfolded",
-        "unfortunate",
-        "unhappy",
-        "unhealthy",
-        "uniform",
-        "unimportant",
-        "unique",
-        "united",
-        "unkempt",
-        "unknown",
-        "unlawful",
-        "unlined",
-        "unlucky",
-        "unnatural",
-        "unpleasant",
-        "unrealistic",
-        "unripe",
-        "unruly",
-        "unselfish",
-        "unsightly",
-        "unsteady",
-        "unsung",
-        "untidy",
-        "untimely",
-        "untried",
-        "untrue",
-        "unused",
-        "unusual",
-        "unwelcome",
-        "unwieldy",
-        "unwilling",
-        "unwitting",
-        "unwritten",
-        "upbeat",
-        "upright",
-        "upset",
-        "urban",
-        "usable",
-        "used",
-        "useful",
-        "useless",
-        "utilized",
-        "utter",
-        "vacant",
-        "vague",
-        "vain",
-        "valid",
-        "valuable",
-        "vapid",
-        "variable",
-        "vast",
-        "velvety",
-        "venerated",
-        "vengeful",
-        "verifiable",
-        "vibrant",
-        "vicious",
-        "victorious",
-        "vigilant",
-        "vigorous",
-        "villainous",
-        "violet",
-        "violent",
-        "virtual",
-        "virtuous",
-        "visible",
-        "vital",
-        "vivacious",
-        "vivid",
-        "voluminous",
-        "wan",
-        "warlike",
-        "warm",
-        "warmhearted",
-        "warped",
-        "wary",
-        "wasteful",
-        "watchful",
-        "waterlogged",
-        "watery",
-        "wavy",
-        "wealthy",
-        "weak",
-        "weary",
-        "webbed",
-        "wee",
-        "weekly",
-        "weepy",
-        "weighty",
-        "weird",
-        "welcome",
-        "well-documented",
-        "well-groomed",
-        "well-informed",
-        "well-lit",
-        "well-made",
-        "well-off",
-        "well-to-do",
-        "well-worn",
-        "wet",
-        "which",
-        "whimsical",
-        "whirlwind",
-        "whispered",
-        "white",
-        "whole",
-        "whopping",
-        "wicked",
-        "wide",
-        "wide-eyed",
-        "wiggly",
-        "wild",
-        "willing",
-        "wilted",
-        "winding",
-        "windy",
-        "winged",
-        "wiry",
-        "wise",
-        "witty",
-        "wobbly",
-        "woeful",
-        "wonderful",
-        "wooden",
-        "woozy",
-        "wordy",
-        "worldly",
-        "worn",
-        "worried",
-        "worrisome",
-        "worse",
-        "worst",
-        "worthless",
-        "worthwhile",
-        "worthy",
-        "wrathful",
-        "wretched",
-        "writhing",
-        "wrong",
-        "wry",
-        "yawning",
-        "yearly",
-        "yellow",
-        "yellowish",
-        "young",
-        "youthful",
-        "yummy",
-        "zany",
-        "zealous",
-        "zesty",
-        "zigzag"
-    ],
-    "animals": [
-        "Cape Fox",
-        "Short-Beaked Echidna",
-        "Platypus",
-        "Arctic Ground Squirrel",
-        "Black-Tailed Prairie Dog",
-        "Franklin's Ground Squirrel",
-        "Golden-Mantled Ground Squirrel",
-        "Groundhog",
-        "Yellow-Bellied Marmot",
-        "Eastern Mole",
-        "Pink Fairy Armadillo",
-        "Star-Nosed Mole",
-        "Smooth-Coated Otter",
-        "Degu",
-        "Meadow Vole",
-        "Campbell's Dwarf Hamster",
-        "Fat Sand Rat",
-        "Striped Ground Squirrel",
-        "Syrian Hamster",
-        "Common Wombat",
-        "Greater Bilby",
-        "Marsupial Mole",
-        "Numbat",
-        "Southern Hairy-Nosed Wombat",
-        "American Badger",
-        "Little Blue Penguin",
-        "Giant Armadillo",
-        "Eastern Long-Beaked Echidna",
-        "Screaming Hairy Armadillo",
-        "Chinese Hamster",
-        "Roborovski Hamster",
-        "Djungarian Hamster",
-        "Indian Desert Jird",
-        "Great Gerbil",
-        "Plains Rat",
-        "Big-Headed Mole-Rat",
-        "Cape Ground Squirrel",
-        "Colorado Chipmunk",
-        "Alpine Chipmunk",
-        "Cliff Chipmunk",
-        "Hoary Marmot",
-        "Himalayan Marmot",
-        "Olympic Marmot",
-        "San Joaquin Antelope Squirrel",
-        "Gunnison's Prairie Dog",
-        "California Ground Squirrel",
-        "White-Tailed Prairie Dog",
-        "Spotted Ground Squirrel",
-        "Uinta Ground Squirrel",
-        "Columbian Ground Squirrel",
-        "Richardson's Ground Squirrel",
-        "European Ground Squirrel",
-        "Speckled Ground Squirrel",
-        "Broad-Footed Mole",
-        "European Mole",
-        "Sunda Pangolin",
-        "Desert Rosy Boa",
-        "Desert Tortoise",
-        "Brahminy Blind Snake",
-        "Eastern Hognose Snake",
-        "Saharan Horned Viper",
-        "Gopher Snake",
-        "Scarlet Kingsnake",
-        "Eastern Pine Snake",
-        "Eastern Coral Snake",
-        "Naked Mole-Rat",
-        "Mud Snake",
-        "Barbados Threadsnake",
-        "Arabian Sand Boa",
-        "Japanese Badger",
-        "Rainbow Snake",
-        "Red-Eyed Crocodile Skink",
-        "Texas Coral Snake",
-        "Glossy Snake",
-        "Oriental Wolf Snake",
-        "Hog Badger",
-        "Mongolian Gerbil",
-        "Damaraland Mole-Rat",
-        "Steppe Polecat",
-        "Woma Python",
-        "Southern Hognose Snake",
-        "Asian Badger",
-        "Giant Girdled Lizard",
-        "Common Vole",
-        "Bank Vole",
-        "Chinese Ferret-Badger",
-        "Desert Grassland Whiptail Lizard",
-        "Rough Earth Snake",
-        "Thirteen-Lined Ground Squirrel",
-        "Southern Three-Banded Armadillo",
-        "Slowworm",
-        "Siberian Chipmunk",
-        "Round-Tailed Ground Squirrel",
-        "Pygmy Rabbit",
-        "Pied Kingfisher",
-        "Northern Short-Tailed Shrew ",
-        "Northern Pika",
-        "Nine-Banded Armadillo",
-        "Nile Monitor",
-        "Lowland Streaked Tenrec",
-        "Lowland Paca",
-        "Long-Nosed Bandicoot",
-        "Long-Eared Jerboa",
-        "Idaho Ground Squirrel",
-        "Ground Pangolin",
-        "Great Plains Rat Snake",
-        "Gopher Tortoise",
-        "Giant Pangolin",
-        "European Hedgehog",
-        "European Hamster",
-        "Common Box Turtle",
-        "Brown Rat",
-        "Bog Turtle",
-        "Bengal Fox",
-        "American Alligator",
-        "Aardvark",
-        "Olm",
-        "Tiger salamander",
-        "Chinese giant salamander",
-        "Spotted salamander",
-        "Blue-spotted salamander",
-        "Eastern worm snake",
-        "Deinagkistrodon",
-        "Northern crested newt",
-        "Barred tiger salamander",
-        "Rainbow bee-eater",
-        "Sunbeam Snake",
-        "Sandfish Skink",
-        "Mexican Mole Lizard",
-        "Tarbagan marmot",
-        "Black-Headed Python",
-        "Vancouver Island Marmot",
-        "Bothrochilus",
-        "Western Box Turtle",
-        "Long-toed salamander",
-        "Fat-Tailed Gerbil",
-        "Mexican Prairie Dog",
-        "Marbled salamander",
-        "Bandy-Bandy",
-        "Smooth Earth Snake",
-        "Boodie",
-        "Zebra-Tailed Lizard",
-        "White-headed langur",
-        "Javan Ferret-Badger",
-        "Southwestern Blackhead Snake",
-        "Malagasy Giant Rat",
-        "Big Hairy Armadillo",
-        "Camas pocket gopher",
-        "Woodland vole",
-        "Lesser Egyptian jerboa",
-        "Little Brown Skink",
-        "Plains pocket gopher",
-        "Alaska marmot",
-        "Gray marmot",
-        "Louisiana waterthrush",
-        "Ord's kangaroo rat",
-        "North American least shrew",
-        "Western rosella",
-        "Northwestern salamander",
-        "Acrochordus granulatus",
-        "Kowari",
-        "Anilius",
-        "Gastrophryne carolinensis",
-        "Yellow mud turtle",
-        "Plateau pika",
-        "Steppe lemming",
-        "American shrew mole",
-        "Calabar python",
-        "Dermophis mexicanus",
-        "Rufous rat-kangaroo",
-        "Hairy-tailed mole",
-        "Mexican burrowing toad",
-        "Seven-banded armadillo",
-        "Scaphiopus holbrookii",
-        "Asiatic brush-tailed porcupine",
-        "Bolson tortoise",
-        "Common midwife toad",
-        "Ambystoma talpoideum",
-        "Crucifix toad",
-        "Red Hills salamander",
-        "Uperodon taprobanicus",
-        "Plains spadefoot toad",
-        "Spea hammondii",
-        "Puerto Rican crested toad",
-        "Physalaemus nattereri",
-        "Yosemite toad",
-        "Frosted flatwoods salamander",
-        "Striped newt",
-        "Streamside salamander",
-        "Southern red-backed salamander",
-        "Spencer's burrowing frog",
-        "Ringed salamander",
-        "Kaloula baleata",
-        "Uperodon systoma",
-        "Ichthyophis beddomei",
-        "Uperodon globulosus",
-        "Herpele squalostoma",
-        "Ichthyophis mindanaoensis",
-        "Sandhill frog",
-        "Strecker's chorus frog",
-        "Uraeotyphlus oxyurus",
-        "Caecilia nigricans",
-        "Uraeotyphlus menoni",
-        "Savannah forest tree frog",
-        "Uraeotyphlus interruptus",
-        "Rose's rain frog",
-        "Dermophis parviceps",
-        "Leptopelis gramineus",
-        "Rhombophryne coudreaui",
-        "Elachistocleis pearsei",
-        "Hylodes heyeri",
-        "Carphophis vermis",
-        "Anniella pulchra",
-        "Lampropeltis calligaster rhombomaculata",
-        "Xerotyphlops vermicularis",
-        "Iberian worm lizard",
-        "Lytorhynchus diadema",
-        "Micrurus frontalis",
-        "Euprepiophis conspicillata",
-        "Amphisbaena fuliginosa",
-        "Greater earless lizard",
-        "Afrotyphlops schlegelii",
-        "Texas lined snake",
-        "Atractaspis branchi",
-        "Calamaria gervaisii",
-        "Brachyurophis fasciolatus",
-        "Brongersma's worm snake",
-        "Letheobia simonii",
-        "Grypotyphlops acutus",
-        "Acontias breviceps",
-        "Reticulate worm snake",
-        "Trinidad worm snake",
-        "Amphisbaena microcephala",
-        "Lerista labialis",
-        "Flathead worm snake",
-        "Mertens's worm lizard",
-        "Elegant worm snake",
-        "Iranian worm snake",
-        "Pernambuco worm snake",
-        "Crest-tailed mulgara",
-        "Southern long-nosed armadillo",
-        "Greater fairy armadillo",
-        "Steppe pika",
-        "Black-capped marmot",
-        "Armored rat",
-        "Giant mole-rat",
-        "Montane vole",
-        "Oldfield mouse",
-        "Southeastern pocket gopher",
-        "Long-tailed vole",
-        "Greater naked-tailed armadillo",
-        "Common mole-rat",
-        "Philippine porcupine",
-        "Milne-Edwards's sifaka",
-        "Townsend's mole",
-        "Giant golden mole",
-        "Daurian pika",
-        "Cape golden mole",
-        "Yellow-faced pocket gopher",
-        "Indian gerbil",
-        "Plains viscacha rat",
-        "Red tree vole",
-        "Middle East blind mole-rat",
-        "Mountain paca",
-        "Pallas's pika",
-        "Bicolored shrew",
-        "Cape mole-rat",
-        "Cascade golden-mantled ground squirrel",
-        "Unstriped ground squirrel",
-        "Townsend's vole",
-        "Yellow ground squirrel",
-        "Desert pocket gopher",
-        "Bunny rat",
-        "Washington ground squirrel",
-        "Mole-like rice tenrec",
-        "Greater mole-rat",
-        "Hottentot golden mole",
-        "Plains pocket mouse",
-        "Cheesman's gerbil",
-        "Judean Mountains blind mole-rat",
-        "Chisel-toothed kangaroo rat",
-        "Rough-haired golden mole",
-        "Southeastern shrew",
-        "California pocket mouse",
-        "Coruro",
-        "Merriam's shrew",
-        "Long-tailed mole",
-        "Orange leaf-nosed bat",
-        "South African pouched mouse",
-        "Selous's mongoose",
-        "Ash-grey mouse",
-        "Russet ground squirrel",
-        "Gulf Coast kangaroo rat",
-        "Olive-backed pocket mouse",
-        "Northeast African mole-rat",
-        "San Diego pocket mouse",
-        "Nelson's pocket mouse",
-        "Geoffroy's horseshoe bat",
-        "Narrow-faced kangaroo rat",
-        "Chilean rock rat",
-        "R\u00fcppell's horseshoe bat",
-        "Long-tailed pocket mouse",
-        "Aztec mouse",
-        "Western mouse",
-        "Felten's myotis",
-        "Akodon azarae",
-        "Talas tuco-tuco",
-        "Upper Galilee Mountains blind mole-rat",
-        "Pearson's tuco-tuco",
-        "Mount Carmel blind mole-rat",
-        "Plethobasus cyphyus",
-        "Long-Nosed Snake",
-        "Russian Desman",
-        "Texas Blind Snake",
-        "Florida Box Turtle",
-        "Lesser Bandicoot Rat",
-        "Bush Rat",
-        "Six-Lined Racerunner",
-        "Eastern Bearded Dragon",
-        "Lesser Antillean Iguana",
-        "Eastern Mud Turtle",
-        "Slender Glass Lizard",
-        "Scarlet Snake",
-        "Natal Multimammate Mouse",
-        "Mountain Beaver",
-        "Bobak Marmot",
-        "Kirtland's Snake",
-        "Pine Woods Snake",
-        "Western Whiptail",
-        "Boxelder bug",
-        "Porcellio scaber",
-        "German cockroach",
-        "Forficula auricularia",
-        "Anisolabis maritima",
-        "Trigoniulus corallinus",
-        "Sinea diadema",
-        "Black imported fire ant",
-        "Scutigera coleoptrata",
-        "Mastigoproctus giganteus",
-        "Dermacentor andersoni",
-        "Deathstalker",
-        "Larinioides cornutus",
-        "Cheiracanthium inclusum",
-        "Latrodectus hesperus",
-        "Scytodes thoracica",
-        "Atypus affinis",
-        "Illacme plenipes",
-        "Ommatoiulus moreleti",
-        "Narceus americanus",
-        "Madagascar hissing cockroach",
-        "Labidura riparia",
-        "Forficula smyrnensis",
-        "Argentine ant",
-        "Texas leafcutter ant",
-        "Brachypelma klaasi",
-        "Western Blind Snake",
-        "Desert Box Turtle",
-        "African Striped Weasel"
-    ]
-}

server/nextServer.ts

@@ -2,7 +2,7 @@ import next from "next";
 import express from "express";
 import { parse } from "url";
 import logger from "@server/logger";
-import config from "@server/config";
+import config from "@server/lib/config";
 
 const nextPort = config.getRawConfig().server.next_port;
 

server/routers/accessToken/deleteAccessToken.ts

@@ -1,6 +1,6 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/accessToken/generateAccessToken.ts

@@ -3,7 +3,7 @@ import {
     generateId,
     generateIdFromEntropySize,
     SESSION_COOKIE_EXPIRES
-} from "@server/auth";
+} from "@server/auth/sessions/app";
 import db from "@server/db";
 import {
     ResourceAccessToken,
@@ -11,7 +11,7 @@ import {
     resources
 } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";

server/routers/accessToken/listAccessTokens.ts

@@ -7,12 +7,12 @@ import {
     roleResources,
     resourceAccessToken
 } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { sql, eq, or, inArray, and, count, isNull, lt, gt } from "drizzle-orm";
 import logger from "@server/logger";
-import stoi from "@server/utils/stoi";
+import stoi from "@server/lib/stoi";
 
 const listAccessTokensParamsSchema = z
     .object({

server/routers/auth/changePassword.ts

@@ -2,22 +2,28 @@ import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { unauthorized, invalidateAllSessions } from "@server/auth";
 import { z } from "zod";
 import { db } from "@server/db";
 import { User, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import { response } from "@server/utils";
-import { hashPassword, verifyPassword } from "@server/auth/password";
-import { verifyTotpCode } from "@server/auth/2fa";
-import { passwordSchema } from "@server/auth/passwordSchema";
+import { response } from "@server/lib";
+import {
+    hashPassword,
+    verifyPassword
+} from "@server/auth/password";
+import { verifyTotpCode } from "@server/auth/totp";
 import logger from "@server/logger";
+import { unauthorized } from "@server/auth/unauthorizedResponse";
+import { invalidateAllSessions } from "@server/auth/sessions/app";
+import { passwordSchema } from "@server/auth/passwordSchema";
 
-export const changePasswordBody = z.object({
-    oldPassword: z.string(),
-    newPassword: passwordSchema,
-    code: z.string().optional(),
-}).strict();
+export const changePasswordBody = z
+    .object({
+        oldPassword: z.string(),
+        newPassword: passwordSchema,
+        code: z.string().optional()
+    })
+    .strict();
 
 export type ChangePasswordBody = z.infer<typeof changePasswordBody>;
 
@@ -28,7 +34,7 @@ export type ChangePasswordResponse = {
 export async function changePassword(
     req: Request,
     res: Response,
-    next: NextFunction,
+    next: NextFunction
 ): Promise<any> {
     const parsedBody = changePasswordBody.safeParse(req.body);
 
@@ -36,8 +42,8 @@ export async function changePassword(
         return next(
             createHttpError(
                 HttpCode.BAD_REQUEST,
-                fromError(parsedBody.error).toString(),
-            ),
+                fromError(parsedBody.error).toString()
+            )
         );
     }
 
@@ -49,14 +55,14 @@ export async function changePassword(
             return next(
                 createHttpError(
                     HttpCode.BAD_REQUEST,
-                    "New password cannot be the same as the old password",
-                ),
+                    "New password cannot be the same as the old password"
+                )
             );
         }
 
         const validPassword = await verifyPassword(
             oldPassword,
-            user.passwordHash,
+            user.passwordHash
         );
         if (!validPassword) {
             return next(unauthorized());
@@ -69,21 +75,21 @@ export async function changePassword(
                     success: true,
                     error: false,
                     message: "Two-factor authentication required",
-                    status: HttpCode.ACCEPTED,
+                    status: HttpCode.ACCEPTED
                 });
             }
             const validOTP = await verifyTotpCode(
                 code!,
                 user.twoFactorSecret!,
-                user.userId,
+                user.userId
             );
 
             if (!validOTP) {
                 return next(
                     createHttpError(
                         HttpCode.BAD_REQUEST,
-                        "The two-factor code you entered is incorrect",
-                    ),
+                        "The two-factor code you entered is incorrect"
+                    )
                 );
             }
         }
@@ -93,7 +99,7 @@ export async function changePassword(
         await db
             .update(users)
             .set({
-                passwordHash: hash,
+                passwordHash: hash
             })
             .where(eq(users.userId, user.userId));
 
@@ -106,15 +112,15 @@ export async function changePassword(
             success: true,
             error: false,
             message: "Password changed successfully",
-            status: HttpCode.OK,
+            status: HttpCode.OK
         });
     } catch (error) {
         logger.error(error);
         return next(
             createHttpError(
                 HttpCode.INTERNAL_SERVER_ERROR,
-                "Failed to authenticate user",
-            ),
+                "Failed to authenticate user"
+            )
         );
     }
 }

server/routers/auth/checkResourceSession.ts

@@ -3,8 +3,8 @@ import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
-import { validateResourceSessionToken } from "@server/auth/resource";
+import { response } from "@server/lib";
+import { validateResourceSessionToken } from "@server/auth/sessions/resource";
 import logger from "@server/logger";
 
 export const params = z.object({

server/routers/auth/disable2fa.ts

@@ -2,18 +2,18 @@ import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { unauthorized } from "@server/auth";
 import { z } from "zod";
 import { db } from "@server/db";
-import { twoFactorBackupCodes, User, users } from "@server/db/schema";
+import { User, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { verifyPassword } from "@server/auth/password";
-import { verifyTotpCode } from "@server/auth/2fa";
+import { verifyTotpCode } from "@server/auth/totp";
 import logger from "@server/logger";
 import { sendEmail } from "@server/emails";
 import TwoFactorAuthNotification from "@server/emails/templates/TwoFactorAuthNotification";
-import config from "@server/config";
+import config from "@server/lib/config";
+import { unauthorized } from "@server/auth/unauthorizedResponse";
 
 export const disable2faBody = z
     .object({

server/routers/auth/login.ts

@@ -1,23 +1,22 @@
-import { verify } from "@node-rs/argon2";
 import {
     createSession,
     generateSessionToken,
-    serializeSessionCookie,
-    verifySession
-} from "@server/auth";
+    serializeSessionCookie
+} from "@server/auth/sessions/app";
 import db from "@server/db";
 import { users } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
-import { verifyTotpCode } from "@server/auth/2fa";
-import config from "@server/config";
+import { verifyTotpCode } from "@server/auth/totp";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import { verifyPassword } from "@server/auth/password";
+import { verifySession } from "@server/auth/sessions/verifySession";
 
 export const loginBodySchema = z
     .object({

server/routers/auth/logout.ts

@@ -1,13 +1,13 @@
 import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import logger from "@server/logger";
 import {
     createBlankSessionTokenCookie,
     invalidateSession,
     SESSION_COOKIE_NAME
-} from "@server/auth";
+} from "@server/auth/sessions/app";
 
 export async function logout(
     req: Request,

server/routers/auth/requestEmailVerificationCode.ts

@@ -1,10 +1,10 @@
 import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { User } from "@server/db/schema";
 import { sendEmailVerificationCode } from "../../auth/sendEmailVerificationCode";
-import config from "@server/config";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 
 export type RequestEmailVerificationCodeResponse = {

server/routers/auth/requestPasswordReset.ts

@@ -3,7 +3,7 @@ import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { db } from "@server/db";
 import { passwordResetTokens, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
@@ -11,9 +11,9 @@ import { alphabet, generateRandomString, sha256 } from "oslo/crypto";
 import { encodeHex } from "oslo/encoding";
 import { createDate } from "oslo";
 import logger from "@server/logger";
-import { generateIdFromEntropySize } from "@server/auth";
+import { generateIdFromEntropySize } from "@server/auth/sessions/app";
 import { TimeSpan } from "oslo";
-import config from "@server/config";
+import config from "@server/lib/config";
 import { sendEmail } from "@server/emails";
 import ResetPasswordCode from "@server/emails/templates/ResetPasswordCode";
 import { hashPassword } from "@server/auth/password";

server/routers/auth/requestTotpSecret.ts

@@ -4,16 +4,14 @@ import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import { encodeHex } from "oslo/encoding";
 import HttpCode from "@server/types/HttpCode";
-import { unauthorized } from "@server/auth";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { db } from "@server/db";
 import { User, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import { verify } from "@node-rs/argon2";
 import { createTOTPKeyURI } from "oslo/otp";
-import config from "@server/config";
 import logger from "@server/logger";
 import { verifyPassword } from "@server/auth/password";
+import { unauthorized } from "@server/auth/unauthorizedResponse";
 
 export const requestTotpSecretBody = z
     .object({

server/routers/auth/resetPassword.ts

@@ -1,23 +1,21 @@
-import config from "@server/config";
+import config from "@server/lib/config";
 import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { db } from "@server/db";
 import { passwordResetTokens, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import { sha256 } from "oslo/crypto";
 import { hashPassword, verifyPassword } from "@server/auth/password";
-import { verifyTotpCode } from "@server/auth/2fa";
-import { passwordSchema } from "@server/auth/passwordSchema";
-import { encodeHex } from "oslo/encoding";
+import { verifyTotpCode } from "@server/auth/totp";
 import { isWithinExpirationDate } from "oslo";
-import { invalidateAllSessions } from "@server/auth";
+import { invalidateAllSessions } from "@server/auth/sessions/app";
 import logger from "@server/logger";
 import ConfirmPasswordReset from "@server/emails/templates/NotifyResetPassword";
 import { sendEmail } from "@server/emails";
+import { passwordSchema } from "@server/auth/passwordSchema";
 
 export const resetPasswordBody = z
     .object({

server/routers/auth/signup.ts

@@ -1,15 +1,13 @@
 import { NextFunction, Request, Response } from "express";
 import db from "@server/db";
-import { hash } from "@node-rs/argon2";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { userActions, users } from "@server/db/schema";
+import { users } from "@server/db/schema";
 import { fromError } from "zod-validation-error";
 import createHttpError from "http-errors";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { SqliteError } from "better-sqlite3";
 import { sendEmailVerificationCode } from "../../auth/sendEmailVerificationCode";
-import { passwordSchema } from "@server/auth/passwordSchema";
 import { eq } from "drizzle-orm";
 import moment from "moment";
 import {
@@ -17,12 +15,12 @@ import {
     generateId,
     generateSessionToken,
     serializeSessionCookie
-} from "@server/auth";
-import { ActionsEnum } from "@server/auth/actions";
-import config from "@server/config";
+} from "@server/auth/sessions/app";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import { hashPassword } from "@server/auth/password";
 import { checkValidInvite } from "@server/auth/checkValidInvite";
+import { passwordSchema } from "@server/auth/passwordSchema";
 
 export const signupBodySchema = z.object({
     email: z.string().email(),

server/routers/auth/verifyEmail.ts

@@ -3,12 +3,12 @@ import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { db } from "@server/db";
 import { User, emailVerificationCodes, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import { isWithinExpirationDate } from "oslo";
-import config from "@server/config";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 
 export const verifyEmailBody = z

server/routers/auth/verifyTotp.ts

@@ -3,17 +3,17 @@ import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import { db } from "@server/db";
 import { twoFactorBackupCodes, User, users } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import { alphabet, generateRandomString } from "oslo/crypto";
 import { hashPassword } from "@server/auth/password";
-import { verifyTotpCode } from "@server/auth/2fa";
+import { verifyTotpCode } from "@server/auth/totp";
 import logger from "@server/logger";
 import { sendEmail } from "@server/emails";
 import TwoFactorAuthNotification from "@server/emails/templates/TwoFactorAuthNotification";
-import config from "@server/config";
+import config from "@server/lib/config";
 
 export const verifyTotpBody = z
     .object({

server/routers/badger/verifySession.ts

@@ -3,8 +3,8 @@ import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
-import { response } from "@server/utils/response";
-import { validateSessionToken } from "@server/auth";
+import { response } from "@server/lib/response";
+import { validateSessionToken } from "@server/auth/sessions/app";
 import db from "@server/db";
 import {
     resourceAccessToken,
@@ -16,8 +16,8 @@ import {
     userOrgs
 } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
-import config from "@server/config";
-import { validateResourceSessionToken } from "@server/auth/resource";
+import config from "@server/lib/config";
+import { validateResourceSessionToken } from "@server/auth/sessions/resource";
 import { Resource, roleResources, userResources } from "@server/db/schema";
 import logger from "@server/logger";
 

server/routers/external.ts

@@ -1,5 +1,5 @@
 import { Router } from "express";
-import config from "@server/config";
+import config from "@server/lib/config";
 import * as site from "./site";
 import * as org from "./org";
 import * as resource from "./resource";

server/routers/gerbil/getConfig.ts

@@ -3,13 +3,13 @@ import { z } from 'zod';
 import { sites, resources, targets, exitNodes } from '@server/db/schema';
 import { db } from '@server/db';
 import { eq } from 'drizzle-orm';
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import logger from '@server/logger';
-import config from "@server/config";
+import config from "@server/lib/config";
 import { getUniqueExitNodeEndpointName } from '@server/db/names';
-import { findNextAvailableCidr } from "@server/utils/ip";
+import { findNextAvailableCidr } from "@server/lib/ip";
 import { fromError } from 'zod-validation-error';
 // Define Zod schema for request validation
 const getConfigSchema = z.object({
@@ -34,7 +34,7 @@ export async function getConfig(req: Request, res: Response, next: NextFunction)
             return next(
                 createHttpError(
                     HttpCode.BAD_REQUEST,
-                    fromError(parsedParams.error).toString() 
+                    fromError(parsedParams.error).toString()
                 )
             );
         }
@@ -151,4 +151,4 @@ async function getNextAvailablePort(): Promise<number> {
     }
 
     return nextPort;
-}
+}

server/routers/gerbil/receiveBandwidth.ts

@@ -5,7 +5,7 @@ import db from "@server/db";
 import logger from "@server/logger";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 
 interface PeerBandwidth {
     publicKey: string;

server/routers/newt/createNewt.ts

@@ -5,11 +5,11 @@ import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
 import { newts } from "@server/db/schema";
 import createHttpError from "http-errors";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { SqliteError } from "better-sqlite3";
 import moment from "moment";
-import { generateSessionToken } from "@server/auth";
-import { createNewtSession } from "@server/auth/newt";
+import { generateSessionToken } from "@server/auth/sessions/app";
+import { createNewtSession } from "@server/auth/sessions/newt";
 import { fromError } from "zod-validation-error";
 import { hashPassword } from "@server/auth/password";
 

server/routers/newt/getToken.ts

@@ -1,19 +1,16 @@
-import { verify } from "@node-rs/argon2";
 import {
-    createSession,
     generateSessionToken,
-    verifySession
-} from "@server/auth";
+} from "@server/auth/sessions/app";
 import db from "@server/db";
 import { newts } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
-import { createNewtSession, validateNewtSessionToken } from "@server/auth/newt";
+import { createNewtSession, validateNewtSessionToken } from "@server/auth/sessions/newt";
 import { verifyPassword } from "@server/auth/password";
 
 export const newtGetTokenBodySchema = z.object({

server/routers/org/checkId.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { orgs } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/org/createOrg.ts

@@ -3,12 +3,12 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { eq } from "drizzle-orm";
 import { Org, orgs, roleActions, roles, userOrgs } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { createAdminRole } from "@server/setup/ensureActions";
-import config from "@server/config";
+import config from "@server/lib/config";
 import { fromError } from "zod-validation-error";
 import { defaultRoleAllowedActions } from "../role";
 

server/routers/org/deleteOrg.ts

@@ -9,7 +9,7 @@ import {
     userActions
 } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { ActionsEnum, checkUserActionPermission } from "@server/auth/actions";

server/routers/org/getOrg.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { Org, orgs } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/org/getOrgOverview.ts

@@ -12,7 +12,7 @@ import {
     userSites
 } from "@server/db/schema";
 import { and, count, eq, inArray } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/org/listOrgs.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { Org, orgs } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { sql, inArray } from "drizzle-orm";

server/routers/org/updateOrg.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { orgs } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/authWithAccessToken.ts

@@ -1,8 +1,8 @@
-import { generateSessionToken } from "@server/auth";
+import { generateSessionToken } from "@server/auth/sessions/app";
 import db from "@server/db";
 import { resourceAccessToken, resources } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq, and } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
@@ -11,8 +11,8 @@ import { fromError } from "zod-validation-error";
 import {
     createResourceSession,
     serializeResourceSessionCookie
-} from "@server/auth/resource";
-import config from "@server/config";
+} from "@server/auth/sessions/resource";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import { verify } from "@node-rs/argon2";
 import { isWithinExpirationDate } from "oslo";

server/routers/resource/authWithPassword.ts

@@ -1,9 +1,9 @@
 import { verify } from "@node-rs/argon2";
-import { generateSessionToken } from "@server/auth";
+import { generateSessionToken } from "@server/auth/sessions/app";
 import db from "@server/db";
 import { orgs, resourcePassword, resources } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
@@ -12,8 +12,8 @@ import { fromError } from "zod-validation-error";
 import {
     createResourceSession,
     serializeResourceSessionCookie
-} from "@server/auth/resource";
-import config from "@server/config";
+} from "@server/auth/sessions/resource";
+import config from "@server/lib/config";
 import logger from "@server/logger";
 import { verifyPassword } from "@server/auth/password";
 

server/routers/resource/authWithPincode.ts

@@ -1,5 +1,5 @@
 import { verify } from "@node-rs/argon2";
-import { generateSessionToken } from "@server/auth";
+import { generateSessionToken } from "@server/auth/sessions/app";
 import db from "@server/db";
 import {
     orgs,
@@ -9,7 +9,7 @@ import {
     resourceWhitelist
 } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { and, eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
@@ -18,9 +18,9 @@ import { fromError } from "zod-validation-error";
 import {
     createResourceSession,
     serializeResourceSessionCookie
-} from "@server/auth/resource";
+} from "@server/auth/sessions/resource";
 import logger from "@server/logger";
-import config from "@server/config";
+import config from "@server/lib/config";
 import { AuthWithPasswordResponse } from "./authWithPassword";
 import { isValidOtp, sendResourceOtpEmail } from "@server/auth/resourceOtp";
 import { verifyPassword } from "@server/auth/password";

server/routers/resource/authWithWhitelist.ts

@@ -1,4 +1,4 @@
-import { generateSessionToken } from "@server/auth";
+import { generateSessionToken } from "@server/auth/sessions/app";
 import db from "@server/db";
 import {
     orgs,
@@ -8,7 +8,7 @@ import {
     resourceWhitelist
 } from "@server/db/schema";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { eq, and } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
@@ -17,8 +17,8 @@ import { fromError } from "zod-validation-error";
 import {
     createResourceSession,
     serializeResourceSessionCookie
-} from "@server/auth/resource";
-import config from "@server/config";
+} from "@server/auth/sessions/resource";
+import config from "@server/lib/config";
 import { isValidOtp, sendResourceOtpEmail } from "@server/auth/resourceOtp";
 import logger from "@server/logger";
 

server/routers/resource/createResource.ts

@@ -10,11 +10,11 @@ import {
     roles,
     userResources
 } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { eq, and } from "drizzle-orm";
-import stoi from "@server/utils/stoi";
+import stoi from "@server/lib/stoi";
 import { fromError } from "zod-validation-error";
 import { subdomainSchema } from "@server/schemas/subdomainSchema";
 import logger from "@server/logger";

server/routers/resource/deleteResource.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { newts, resources, sites, targets } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/getResource.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { Resource, resources } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { fromError } from "zod-validation-error";

server/routers/resource/getResourceAuthInfo.ts

@@ -7,7 +7,7 @@ import {
     resources
 } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { fromError } from "zod-validation-error";

server/routers/resource/getResourceWhitelist.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { resourceWhitelist, users } from "@server/db/schema"; // Assuming these are the correct tables
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/listResourceRoles.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleResources, roles } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/listResourceUsers.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { userResources, users } from "@server/db/schema"; // Assuming these are the correct tables
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/listResources.ts

@@ -9,12 +9,12 @@ import {
     resourcePassword,
     resourcePincode
 } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { sql, eq, or, inArray, and, count } from "drizzle-orm";
 import logger from "@server/logger";
-import stoi from "@server/utils/stoi";
+import stoi from "@server/lib/stoi";
 
 const listResourcesParamsSchema = z
     .object({

server/routers/resource/setResourcePassword.ts

@@ -7,7 +7,7 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { fromError } from "zod-validation-error";
 import { hash } from "@node-rs/argon2";
-import { response } from "@server/utils";
+import { response } from "@server/lib";
 import logger from "@server/logger";
 import { hashPassword } from "@server/auth/password";
 

server/routers/resource/setResourcePincode.ts

@@ -7,8 +7,8 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { fromError } from "zod-validation-error";
 import { hash } from "@node-rs/argon2";
-import { response } from "@server/utils";
-import stoi from "@server/utils/stoi";
+import { response } from "@server/lib";
+import stoi from "@server/lib/stoi";
 import logger from "@server/logger";
 import { hashPassword } from "@server/auth/password";
 

server/routers/resource/setResourceRoles.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { roleResources, roles } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/setResourceUsers.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { userResources } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/setResourceWhitelist.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { resources, resourceWhitelist } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/resource/updateResource.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { orgs, resources, sites } from "@server/db/schema";
 import { eq, or } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/addRoleAction.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { roleActions, roles } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/addRoleSite.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { resources, roleResources, roleSites } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/createRole.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { orgs, Role, roleActions, roles } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/deleteRole.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roles, userOrgs } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
@@ -108,7 +108,7 @@ export async function deleteRole(
             // delete the old role
             await trx.delete(roles).where(eq(roles.roleId, roleId));
         });
-        
+
         return response(res, {
             data: null,
             success: true,

server/routers/role/getRole.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roles } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/listRoleActions.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleActions, actions } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/listRoleResources.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleResources, resources } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/listRoleSites.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleSites, sites } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/listRoles.ts

@@ -2,13 +2,13 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { roles, orgs } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import { sql, eq } from "drizzle-orm";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
-import stoi from "@server/utils/stoi";
+import stoi from "@server/lib/stoi";
 
 const listRolesParamsSchema = z
     .object({

server/routers/role/removeRoleAction.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleActions } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/removeRoleResource.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleResources } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/removeRoleSite.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { resources, roleResources, roleSites } from "@server/db/schema";
 import { and, eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/role/updateRole.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roles } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/site/createSite.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { roles, userSites, sites, roleSites, Site } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/site/deleteSite.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { newts, newtSessions, sites } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
@@ -77,7 +77,7 @@ export async function deleteSite(
 
             await trx.delete(sites).where(eq(sites.siteId, siteId));
         });
-        
+
         return response(res, {
             data: null,
             success: true,

server/routers/site/getSite.ts

@@ -3,11 +3,11 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { sites } from "@server/db/schema";
 import { eq, and } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
-import stoi from "@server/utils/stoi";
+import stoi from "@server/lib/stoi";
 import { fromError } from "zod-validation-error";
 
 const getSiteSchema = z

server/routers/site/listSiteRoles.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { roleSites, roles } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/site/listSites.ts

@@ -2,7 +2,7 @@ import { db } from "@server/db";
 import { orgs, roleSites, sites, userSites } from "@server/db/schema";
 import logger from "@server/logger";
 import HttpCode from "@server/types/HttpCode";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import { and, count, eq, inArray, or, sql } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";

server/routers/site/pickSiteDefaults.ts

@@ -2,12 +2,12 @@ import { Request, Response, NextFunction } from "express";
 import { db } from "@server/db";
 import { exitNodes, sites } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
-import { findNextAvailableCidr } from "@server/utils/ip";
-import { generateId } from "@server/auth";
+import { findNextAvailableCidr } from "@server/lib/ip";
+import { generateId } from "@server/auth/sessions/app";
 
 export type PickSiteDefaultsResponse = {
     exitNodeId: number;

server/routers/site/updateSite.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { sites } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";

server/routers/target/createTarget.ts

@@ -2,13 +2,13 @@ import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
 import { newts, resources, sites, Target, targets } from "@server/db/schema";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { addPeer } from "../gerbil/peers";
 import { eq, and } from "drizzle-orm";
-import { isIpInCidr } from "@server/utils/ip";
+import { isIpInCidr } from "@server/lib/ip";
 import { fromError } from "zod-validation-error";
 import { addTargets } from "../newt/targets";
 

server/routers/target/deleteTarget.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { db } from "@server/db";
 import { newts, resources, sites, targets } from "@server/db/schema";
 import { eq } from "drizzle-orm";
-import response from "@server/utils/response";
+import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";