Merge branch 'dev' into redis

server/routers/accessToken/deleteAccessToken.ts

@@ -5,9 +5,9 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
-import { resourceAccessToken } from "@server/db/schemas";
+import { resourceAccessToken } from "@server/db";
 import { and, eq } from "drizzle-orm";
-import db from "@server/db";
+import { db } from "@server/db";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const deleteAccessTokenParamsSchema = z

server/routers/accessToken/generateAccessToken.ts

@@ -4,12 +4,12 @@ import {
     generateIdFromEntropySize,
     SESSION_COOKIE_EXPIRES
 } from "@server/auth/sessions/app";
-import db from "@server/db";
+import { db } from "@server/db";
 import {
     ResourceAccessToken,
     resourceAccessToken,
     resources
-} from "@server/db/schemas";
+} from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq } from "drizzle-orm";

server/routers/accessToken/listAccessTokens.ts

@@ -7,7 +7,7 @@ import {
     roleResources,
     resourceAccessToken,
     sites
-} from "@server/db/schemas";
+} from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/apiKeys/createOrgApiKey.ts

@@ -1,8 +1,8 @@
 import { NextFunction, Request, Response } from "express";
-import db from "@server/db";
+import { db } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { apiKeyOrg, apiKeys } from "@server/db/schemas";
+import { apiKeyOrg, apiKeys } from "@server/db";
 import { fromError } from "zod-validation-error";
 import createHttpError from "http-errors";
 import response from "@server/lib/response";

server/routers/apiKeys/createRootApiKey.ts

@@ -1,8 +1,8 @@
 import { NextFunction, Request, Response } from "express";
-import db from "@server/db";
+import { db } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { apiKeyOrg, apiKeys, orgs } from "@server/db/schemas";
+import { apiKeyOrg, apiKeys, orgs } from "@server/db";
 import { fromError } from "zod-validation-error";
 import createHttpError from "http-errors";
 import response from "@server/lib/response";

server/routers/apiKeys/deleteApiKey.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { apiKeys } from "@server/db/schemas";
+import { apiKeys } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/apiKeys/deleteOrgApiKey.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { apiKeyOrg, apiKeys } from "@server/db/schemas";
+import { apiKeyOrg, apiKeys } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/apiKeys/getApiKey.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { apiKeys } from "@server/db/schemas";
+import { apiKeys } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/apiKeys/listApiKeyActions.ts

@@ -1,5 +1,5 @@
 import { db } from "@server/db";
-import { actions, apiKeyActions, apiKeyOrg, apiKeys } from "@server/db/schemas";
+import { actions, apiKeyActions, apiKeyOrg, apiKeys } from "@server/db";
 import logger from "@server/logger";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";

server/routers/apiKeys/listOrgApiKeys.ts

@@ -1,5 +1,5 @@
 import { db } from "@server/db";
-import { apiKeyOrg, apiKeys } from "@server/db/schemas";
+import { apiKeyOrg, apiKeys } from "@server/db";
 import logger from "@server/logger";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";

server/routers/apiKeys/listRootApiKeys.ts

@@ -1,5 +1,5 @@
 import { db } from "@server/db";
-import { apiKeys } from "@server/db/schemas";
+import { apiKeys } from "@server/db";
 import logger from "@server/logger";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";

server/routers/apiKeys/setApiKeyActions.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { actions, apiKeyActions } from "@server/db/schemas";
+import { actions, apiKeyActions } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/apiKeys/setApiKeyOrgs.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { apiKeyOrg, orgs } from "@server/db/schemas";
+import { apiKeyOrg, orgs } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/auth/changePassword.ts

@@ -4,7 +4,7 @@ import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
 import { z } from "zod";
 import { db } from "@server/db";
-import { User, users } from "@server/db/schemas";
+import { User, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { response } from "@server/lib";
 import {

server/routers/auth/disable2fa.ts

@@ -4,7 +4,7 @@ import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
 import { z } from "zod";
 import { db } from "@server/db";
-import { User, users } from "@server/db/schemas";
+import { User, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { response } from "@server/lib";
 import { verifyPassword } from "@server/auth/password";

server/routers/auth/login.ts

@@ -3,8 +3,8 @@ import {
     generateSessionToken,
     serializeSessionCookie
 } from "@server/auth/sessions/app";
-import db from "@server/db";
-import { users } from "@server/db/schemas";
+import { db } from "@server/db";
+import { users } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq, and } from "drizzle-orm";
@@ -37,6 +37,8 @@ export type LoginResponse = {
     emailVerificationRequired?: boolean;
 };
 
+export const dynamic = "force-dynamic";
+
 export async function login(
     req: Request,
     res: Response,

server/routers/auth/logout.ts

@@ -34,7 +34,7 @@ export async function logout(
         try {
             await invalidateSession(session.sessionId);
         } catch (error) {
-            logger.error("Failed to invalidate session", error)
+            logger.error("Failed to invalidate session", error);
         }
 
         const isSecure = req.protocol === "https";

server/routers/auth/requestEmailVerificationCode.ts

@@ -2,7 +2,7 @@ import { Request, Response, NextFunction } from "express";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
-import { User } from "@server/db/schemas";
+import { User } from "@server/db";
 import { sendEmailVerificationCode } from "../../auth/sendEmailVerificationCode";
 import config from "@server/lib/config";
 import logger from "@server/logger";

server/routers/auth/requestPasswordReset.ts

@@ -5,7 +5,7 @@ import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
 import { db } from "@server/db";
-import { passwordResetTokens, users } from "@server/db/schemas";
+import { passwordResetTokens, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { alphabet, generateRandomString, sha256 } from "oslo/crypto";
 import { createDate } from "oslo";

server/routers/auth/requestTotpSecret.ts

@@ -6,7 +6,7 @@ import { encodeHex } from "oslo/encoding";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
 import { db } from "@server/db";
-import { User, users } from "@server/db/schemas";
+import { User, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { createTOTPKeyURI } from "oslo/otp";
 import logger from "@server/logger";

server/routers/auth/resetPassword.ts

@@ -6,7 +6,7 @@ import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
 import { db } from "@server/db";
-import { passwordResetTokens, users } from "@server/db/schemas";
+import { passwordResetTokens, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { hashPassword, verifyPassword } from "@server/auth/password";
 import { verifyTotpCode } from "@server/auth/totp";

server/routers/auth/signup.ts

@@ -1,8 +1,8 @@
 import { NextFunction, Request, Response } from "express";
-import db from "@server/db";
+import { db } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { users } from "@server/db/schemas";
+import { users } from "@server/db";
 import { fromError } from "zod-validation-error";
 import createHttpError from "http-errors";
 import response from "@server/lib/response";

server/routers/auth/verifyEmail.ts

@@ -5,7 +5,7 @@ import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
 import { db } from "@server/db";
-import { User, emailVerificationCodes, users } from "@server/db/schemas";
+import { User, emailVerificationCodes, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { isWithinExpirationDate } from "oslo";
 import config from "@server/lib/config";

server/routers/auth/verifyTotp.ts

@@ -5,7 +5,7 @@ import { fromError } from "zod-validation-error";
 import HttpCode from "@server/types/HttpCode";
 import { response } from "@server/lib";
 import { db } from "@server/db";
-import { twoFactorBackupCodes, User, users } from "@server/db/schemas";
+import { twoFactorBackupCodes, User, users } from "@server/db";
 import { eq } from "drizzle-orm";
 import { alphabet, generateRandomString } from "oslo/crypto";
 import { hashPassword } from "@server/auth/password";

server/routers/badger/exchangeSession.ts

@@ -4,8 +4,8 @@ import createHttpError from "http-errors";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import logger from "@server/logger";
-import { resourceAccessToken, resources, sessions } from "@server/db/schemas";
-import db from "@server/db";
+import { resourceAccessToken, resources, sessions } from "@server/db";
+import { db } from "@server/db";
 import { eq } from "drizzle-orm";
 import {
     createResourceSession,

server/routers/badger/verifySession.ts

@@ -5,7 +5,7 @@ import {
     validateResourceSessionToken
 } from "@server/auth/sessions/resource";
 import { verifyResourceAccessToken } from "@server/auth/verifyResourceAccessToken";
-import db from "@server/db";
+import { db } from "@server/db";
 import {
     Resource,
     ResourceAccessToken,
@@ -21,7 +21,7 @@ import {
     userOrgs,
     userResources,
     users
-} from "@server/db/schemas";
+} from "@server/db";
 import config from "@server/lib/config";
 import { isIpInCidr } from "@server/lib/ip";
 import { response } from "@server/lib/response";
@@ -56,9 +56,16 @@ export type VerifyResourceSessionSchema = z.infer<
     typeof verifyResourceSessionSchema
 >;
 
+type BasicUserData = {
+    username: string;
+    email: string | null;
+    name: string | null;
+};
+
 export type VerifyUserResponse = {
     valid: boolean;
     redirectUrl?: string;
+    userData?: BasicUserData;
 };
 
 export async function verifyResourceSession(
@@ -90,7 +97,28 @@ export async function verifyResourceSession(
             query
         } = parsedBody.data;
 
-        const clientIp = requestIp?.split(":")[0];
+        const clientIp = requestIp
+            ? (() => {
+                  logger.debug("Request IP:", { requestIp });
+                  if (requestIp.startsWith("[") && requestIp.includes("]")) {
+                      // if brackets are found, extract the IPv6 address from between the brackets
+                      const ipv6Match = requestIp.match(/\[(.*?)\]/);
+                      if (ipv6Match) {
+                          return ipv6Match[1];
+                      }
+                  }
+
+                  // ivp4
+                  // split at last colon
+                  const lastColonIndex = requestIp.lastIndexOf(":");
+                  if (lastColonIndex !== -1) {
+                      return requestIp.substring(0, lastColonIndex);
+                  }
+                  return requestIp;
+              })()
+            : undefined;
+
+        logger.debug("Client IP:", { clientIp });
 
         let cleanHost = host;
         // if the host ends with :443 or :80 remove it
@@ -350,23 +378,26 @@ export async function verifyResourceSession(
                         resourceSession.userSessionId
                     }:${resource.resourceId}`;
 
-                    let isAllowed: boolean | undefined =
+                    let allowedUserData: BasicUserData | null | undefined =
                         cache.get(userAccessCacheKey);
 
-                    if (isAllowed === undefined) {
-                        isAllowed = await isUserAllowedToAccessResource(
+                    if (allowedUserData === undefined) {
+                        allowedUserData = await isUserAllowedToAccessResource(
                             resourceSession.userSessionId,
                             resource
                         );
 
-                        cache.set(userAccessCacheKey, isAllowed);
+                        cache.set(userAccessCacheKey, allowedUserData);
                     }
 
-                    if (isAllowed) {
+                    if (
+                        allowedUserData !== null &&
+                        allowedUserData !== undefined
+                    ) {
                         logger.debug(
                             "Resource allowed because user session is valid"
                         );
-                        return allowed(res);
+                        return allowed(res, allowedUserData);
                     }
                 }
             }
@@ -448,15 +479,17 @@ function notAllowed(res: Response, redirectUrl?: string) {
     return response<VerifyUserResponse>(res, data);
 }
 
-function allowed(res: Response) {
+function allowed(res: Response, userData?: BasicUserData) {
     const data = {
-        data: { valid: true },
+        data:
+            userData !== undefined && userData !== null
+                ? { valid: true, ...userData }
+                : { valid: true },
         success: true,
         error: false,
         message: "Access allowed",
         status: HttpCode.OK
     };
-    logger.debug(JSON.stringify(data));
     return response<VerifyUserResponse>(res, data);
 }
 
@@ -496,7 +529,7 @@ async function createAccessTokenSession(
 async function isUserAllowedToAccessResource(
     userSessionId: string,
     resource: Resource
-): Promise<boolean> {
+): Promise<BasicUserData | null> {
     const [res] = await db
         .select()
         .from(sessions)
@@ -507,14 +540,14 @@ async function isUserAllowedToAccessResource(
     const session = res.session;
 
     if (!user || !session) {
-        return false;
+        return null;
     }
 
     if (
         config.getRawConfig().flags?.require_email_verification &&
         !user.emailVerified
     ) {
-        return false;
+        return null;
     }
 
     const userOrgRole = await db
@@ -529,7 +562,7 @@ async function isUserAllowedToAccessResource(
         .limit(1);
 
     if (userOrgRole.length === 0) {
-        return false;
+        return null;
     }
 
     const roleResourceAccess = await db
@@ -544,7 +577,11 @@ async function isUserAllowedToAccessResource(
         .limit(1);
 
     if (roleResourceAccess.length > 0) {
-        return true;
+        return {
+            username: user.username,
+            email: user.email,
+            name: user.name
+        };
     }
 
     const userResourceAccess = await db
@@ -559,10 +596,14 @@ async function isUserAllowedToAccessResource(
         .limit(1);
 
     if (userResourceAccess.length > 0) {
-        return true;
+        return {
+            username: user.username,
+            email: user.email,
+            name: user.name
+        };
     }
 
-    return false;
+    return null;
 }
 
 async function checkRules(

server/routers/domain/listDomains.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { domains, orgDomains, users } from "@server/db/schemas";
+import { domains, orgDomains, users } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/external.ts

@@ -29,7 +29,7 @@ import {
     getUserOrgs,
     verifyUserIsServerAdmin,
     verifyIsLoggedInUser,
-    verifyApiKeyAccess,
+    verifyApiKeyAccess
 } from "@server/middlewares";
 import { verifyUserHasAction } from "../middlewares/verifyUserHasAction";
 import { ActionsEnum } from "@server/auth/actions";
@@ -124,6 +124,37 @@ authenticated.delete(
     site.deleteSite
 );
 
+authenticated.get(
+    "/site/:siteId/docker/status",
+    verifySiteAccess,
+    verifyUserHasAction(ActionsEnum.getSite),
+    site.dockerStatus
+);
+authenticated.get(
+    "/site/:siteId/docker/online",
+    verifySiteAccess,
+    verifyUserHasAction(ActionsEnum.getSite),
+    site.dockerOnline
+);
+authenticated.post(
+    "/site/:siteId/docker/check",
+    verifySiteAccess,
+    verifyUserHasAction(ActionsEnum.getSite),
+    site.checkDockerSocket
+);
+authenticated.post(
+    "/site/:siteId/docker/trigger",
+    verifySiteAccess,
+    verifyUserHasAction(ActionsEnum.getSite),
+    site.triggerFetchContainers
+);
+authenticated.get(
+    "/site/:siteId/docker/containers",
+    verifySiteAccess,
+    verifyUserHasAction(ActionsEnum.getSite),
+    site.listContainers
+);
+
 authenticated.put(
     "/org/:orgId/site/:siteId/resource",
     verifyOrgAccess,

server/routers/gerbil/getConfig.ts

@@ -1,21 +1,21 @@
-import { Request, Response, NextFunction } from 'express';
-import { z } from 'zod';
-import { sites, resources, targets, exitNodes } from '@server/db/schemas';
-import { db } from '@server/db';
-import { eq } from 'drizzle-orm';
+import { Request, Response, NextFunction } from "express";
+import { z } from "zod";
+import { sites, resources, targets, exitNodes } from "@server/db";
+import { db } from "@server/db";
+import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
-import HttpCode from '@server/types/HttpCode';
-import createHttpError from 'http-errors';
-import logger from '@server/logger';
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+import logger from "@server/logger";
 import config from "@server/lib/config";
-import { getUniqueExitNodeEndpointName } from '@server/db/names';
+import { getUniqueExitNodeEndpointName } from "../../db/names";
 import { findNextAvailableCidr } from "@server/lib/ip";
-import { fromError } from 'zod-validation-error';
-import { getAllowedIps } from '../target/helpers';
+import { fromError } from "zod-validation-error";
+import { getAllowedIps } from "../target/helpers";
 // Define Zod schema for request validation
 const getConfigSchema = z.object({
     publicKey: z.string(),
-    reachableAt: z.string().optional(),
+    reachableAt: z.string().optional()
 });
 
 export type GetConfigResponse = {
@@ -25,9 +25,13 @@ export type GetConfigResponse = {
         publicKey: string | null;
         allowedIps: string[];
     }[];
-}
+};
 
-export async function getConfig(req: Request, res: Response, next: NextFunction): Promise<any> {
+export async function getConfig(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): Promise<any> {
     try {
         // Validate request parameters
         const parsedParams = getConfigSchema.safeParse(req.body);
@@ -43,11 +47,16 @@ export async function getConfig(req: Request, res: Response, next: NextFunction)
         const { publicKey, reachableAt } = parsedParams.data;
 
         if (!publicKey) {
-            return next(createHttpError(HttpCode.BAD_REQUEST, 'publicKey is required'));
+            return next(
+                createHttpError(HttpCode.BAD_REQUEST, "publicKey is required")
+            );
         }
 
         // Fetch exit node
-        let exitNodeQuery = await db.select().from(exitNodes).where(eq(exitNodes.publicKey, publicKey));
+        let exitNodeQuery = await db
+            .select()
+            .from(exitNodes)
+            .where(eq(exitNodes.publicKey, publicKey));
         let exitNode;
         if (exitNodeQuery.length === 0) {
             const address = await getNextAvailableSubnet();
@@ -60,40 +69,53 @@ export async function getConfig(req: Request, res: Response, next: NextFunction)
             }
 
             // create a new exit node
-            exitNode = await db.insert(exitNodes).values({
-                publicKey,
-                endpoint: `${subEndpoint}${subEndpoint != "" ? "." : ""}${config.getRawConfig().gerbil.base_endpoint}`,
-                address,
-                listenPort,
-                reachableAt,
-                name: `Exit Node ${publicKey.slice(0, 8)}`,
-            }).returning().execute();
+            exitNode = await db
+                .insert(exitNodes)
+                .values({
+                    publicKey,
+                    endpoint: `${subEndpoint}${subEndpoint != "" ? "." : ""}${config.getRawConfig().gerbil.base_endpoint}`,
+                    address,
+                    listenPort,
+                    reachableAt,
+                    name: `Exit Node ${publicKey.slice(0, 8)}`
+                })
+                .returning()
+                .execute();
 
-            logger.info(`Created new exit node ${exitNode[0].name} with address ${exitNode[0].address} and port ${exitNode[0].listenPort}`);
+            logger.info(
+                `Created new exit node ${exitNode[0].name} with address ${exitNode[0].address} and port ${exitNode[0].listenPort}`
+            );
         } else {
             exitNode = exitNodeQuery;
         }
 
         if (!exitNode) {
-            return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "Failed to create exit node"));
+            return next(
+                createHttpError(
+                    HttpCode.INTERNAL_SERVER_ERROR,
+                    "Failed to create exit node"
+                )
+            );
         }
 
-        // Fetch sites for this exit node
-        const sitesRes = await db.query.sites.findMany({
-            where: eq(sites.exitNodeId, exitNode[0].exitNodeId),
-        });
+        const sitesRes = await db
+            .select()
+            .from(sites)
+            .where(eq(sites.exitNodeId, exitNode[0].exitNodeId));
 
-        const peers = await Promise.all(sitesRes.map(async (site) => {
-            return {
-                publicKey: site.pubKey,
-                allowedIps: await getAllowedIps(site.siteId)
-            };
-        }));
+        const peers = await Promise.all(
+            sitesRes.map(async (site) => {
+                return {
+                    publicKey: site.pubKey,
+                    allowedIps: await getAllowedIps(site.siteId)
+                };
+            })
+        );
 
         const configResponse: GetConfigResponse = {
             listenPort: exitNode[0].listenPort || 51820,
             ipAddress: exitNode[0].address,
-            peers,
+            peers
         };
 
         logger.debug("Sending config: ", configResponse);
@@ -101,32 +123,49 @@ export async function getConfig(req: Request, res: Response, next: NextFunction)
         return res.status(HttpCode.OK).send(configResponse);
     } catch (error) {
         logger.error(error);
-        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                "An error occurred..."
+            )
+        );
     }
 }
 
 async function getNextAvailableSubnet(): Promise<string> {
     // Get all existing subnets from routes table
-    const existingAddresses = await db.select({
-        address: exitNodes.address,
-    }).from(exitNodes);
+    const existingAddresses = await db
+        .select({
+            address: exitNodes.address
+        })
+        .from(exitNodes);
 
-    const addresses = existingAddresses.map(a => a.address);
-    let subnet = findNextAvailableCidr(addresses, config.getRawConfig().gerbil.block_size, config.getRawConfig().gerbil.subnet_group);
+    const addresses = existingAddresses.map((a) => a.address);
+    let subnet = findNextAvailableCidr(
+        addresses,
+        config.getRawConfig().gerbil.block_size,
+        config.getRawConfig().gerbil.subnet_group
+    );
     if (!subnet) {
-        throw new Error('No available subnets remaining in space');
+        throw new Error("No available subnets remaining in space");
     }
 
     // replace the last octet with 1
-    subnet = subnet.split('.').slice(0, 3).join('.') + '.1' + '/' + subnet.split('/')[1];
+    subnet =
+        subnet.split(".").slice(0, 3).join(".") +
+        ".1" +
+        "/" +
+        subnet.split("/")[1];
     return subnet;
 }
 
 async function getNextAvailablePort(): Promise<number> {
     // Get all existing ports from exitNodes table
-    const existingPorts = await db.select({
-        listenPort: exitNodes.listenPort,
-    }).from(exitNodes);
+    const existingPorts = await db
+        .select({
+            listenPort: exitNodes.listenPort
+        })
+        .from(exitNodes);
 
     // Find the first available port between 1024 and 65535
     let nextPort = config.getRawConfig().gerbil.start_port;
@@ -136,7 +175,7 @@ async function getNextAvailablePort(): Promise<number> {
         }
         nextPort++;
         if (nextPort > 65535) {
-            throw new Error('No available ports remaining in space');
+            throw new Error("No available ports remaining in space");
         }
     }
 

server/routers/gerbil/peers.ts

@@ -1,7 +1,7 @@
 import axios from 'axios';
 import logger from '@server/logger';
-import db from '@server/db';
-import { exitNodes } from '@server/db/schemas';
+import { db } from "@server/db";
+import { exitNodes } from '@server/db';
 import { eq } from 'drizzle-orm';
 
 export async function addPeer(exitNodeId: number, peer: {
@@ -24,7 +24,7 @@ export async function addPeer(exitNodeId: number, peer: {
             }
         });
 
-        logger.info('Peer added successfully:', response.data.status);
+        logger.info('Peer added successfully:', { peer: response.data.status });
         return response.data;
     } catch (error) {
         if (axios.isAxiosError(error)) {

server/routers/gerbil/receiveBandwidth.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
-import { DrizzleError, eq } from "drizzle-orm";
-import { sites, resources, targets, exitNodes } from "@server/db/schemas";
-import db from "@server/db";
+import { eq } from "drizzle-orm";
+import { sites, } from "@server/db";
+import { db } from "@server/db";
 import logger from "@server/logger";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
@@ -29,10 +29,11 @@ export const receiveBandwidth = async (
             for (const peer of bandwidthData) {
                 const { publicKey, bytesIn, bytesOut } = peer;
 
-                // Find the site by public key
-                const site = await trx.query.sites.findFirst({
-                    where: eq(sites.pubKey, publicKey)
-                });
+                const [site] = await trx
+                    .select()
+                    .from(sites)
+                    .where(eq(sites.pubKey, publicKey))
+                    .limit(1);
 
                 if (!site) {
                     logger.warn(`Site not found for public key: ${publicKey}`);
@@ -84,10 +85,4 @@ export const receiveBandwidth = async (
             )
         );
     }
-};
-
-function calculateSubnet(index: number): string {
-    const baseIp = 10 << 24;
-    const subnetSize = 16;
-    return `${(baseIp | (index * subnetSize)).toString()}/28`;
-}
+};

server/routers/idp/createIdpOrgPolicy.ts

@@ -9,7 +9,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import config from "@server/lib/config";
 import { eq, and } from "drizzle-orm";
-import { idp, idpOrg } from "@server/db/schemas";
+import { idp, idpOrg } from "@server/db";
 
 const paramsSchema = z
     .object({

server/routers/idp/createOidcIdp.ts

@@ -7,7 +7,7 @@ import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { idp, idpOidcConfig, idpOrg, orgs } from "@server/db/schemas";
+import { idp, idpOidcConfig, idpOrg, orgs } from "@server/db";
 import { generateOidcRedirectUrl } from "@server/lib/idp/generateRedirectUrl";
 import { encrypt } from "@server/lib/crypto";
 import config from "@server/lib/config";

server/routers/idp/deleteIdp.ts

@@ -6,7 +6,7 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
-import { idp, idpOidcConfig, idpOrg } from "@server/db/schemas";
+import { idp, idpOidcConfig, idpOrg } from "@server/db";
 import { eq } from "drizzle-orm";
 import { OpenAPITags, registry } from "@server/openApi";
 

server/routers/idp/deleteIdpOrgPolicy.ts

@@ -6,7 +6,7 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
-import { idp, idpOrg } from "@server/db/schemas";
+import { idp, idpOrg } from "@server/db";
 import { eq, and } from "drizzle-orm";
 import { OpenAPITags, registry } from "@server/openApi";
 

server/routers/idp/generateOidcUrl.ts

@@ -6,7 +6,7 @@ import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
-import { idp, idpOidcConfig, idpOrg } from "@server/db/schemas";
+import { idp, idpOidcConfig, idpOrg } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import * as arctic from "arctic";
 import { generateOidcRedirectUrl } from "@server/lib/idp/generateRedirectUrl";

server/routers/idp/getIdp.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { idp, idpOidcConfig } from "@server/db/schemas";
+import { idp, idpOidcConfig } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/idp/listIdpOrgPolicies.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { idpOrg } from "@server/db/schemas";
+import { idpOrg } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/idp/listIdps.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { domains, idp, orgDomains, users, idpOrg } from "@server/db/schemas";
+import { domains, idp, orgDomains, users, idpOrg } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/idp/updateIdpOrgPolicy.ts

@@ -8,7 +8,7 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { eq, and } from "drizzle-orm";
-import { idp, idpOrg } from "@server/db/schemas";
+import { idp, idpOrg } from "@server/db";
 
 const paramsSchema = z
     .object({

server/routers/idp/updateOidcIdp.ts

@@ -7,7 +7,7 @@ import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { idp, idpOidcConfig } from "@server/db/schemas";
+import { idp, idpOidcConfig } from "@server/db";
 import { eq } from "drizzle-orm";
 import { encrypt } from "@server/lib/crypto";
 import config from "@server/lib/config";

server/routers/idp/validateOidcCallback.ts

@@ -14,7 +14,7 @@ import {
     roles,
     userOrgs,
     users
-} from "@server/db/schemas";
+} from "@server/db";
 import { and, eq, inArray } from "drizzle-orm";
 import * as arctic from "arctic";
 import { generateOidcRedirectUrl } from "@server/lib/idp/generateRedirectUrl";

server/routers/integration.ts

@@ -280,6 +280,13 @@ authenticated.delete(
     role.deleteRole
 );
 
+authenticated.get(
+    "/role/:roleId",
+    verifyApiKeyRoleAccess,
+    verifyApiKeyHasAction(ActionsEnum.getRole),
+    role.getRole
+);
+
 authenticated.post(
     "/role/:roleId/add/:userId",
     verifyApiKeyRoleAccess,

server/routers/internal.ts

@@ -6,6 +6,7 @@ import * as badger from "./badger";
 import * as auth from "@server/routers/auth";
 import * as supporterKey from "@server/routers/supporterKey";
 import * as license from "@server/routers/license";
+import * as idp from "@server/routers/idp";
 import HttpCode from "@server/types/HttpCode";
 import {
     verifyResourceAccess,
@@ -38,10 +39,11 @@ internalRouter.get(
     supporterKey.isSupporterKeyVisible
 );
 
-internalRouter.get(
-    `/license/status`,
-    license.getLicenseStatus
-);
+internalRouter.get(`/license/status`, license.getLicenseStatus);
+
+internalRouter.get("/idp", idp.listIdps);
+
+internalRouter.get("/idp/:idpId", idp.getIdp);
 
 // Gerbil routes
 const gerbilRouter = Router();

server/routers/license/deleteLicenseKey.ts

@@ -5,9 +5,9 @@ import logger from "@server/logger";
 import { response as sendResponse } from "@server/lib";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
-import db from "@server/db";
+import { db } from "@server/db";
 import { eq } from "drizzle-orm";
-import { licenseKey } from "@server/db/schemas";
+import { licenseKey } from "@server/db";
 import license, { LicenseStatus } from "@server/license/license";
 import { encrypt } from "@server/lib/crypto";
 import config from "@server/lib/config";

server/routers/messageHandlers.ts

@@ -1,6 +1,12 @@
-import { handleRegisterMessage } from "./newt";
+import {
+    handleRegisterMessage,
+    handleDockerStatusMessage,
+    handleDockerContainersMessage
+} from "./newt";
 import { MessageHandler } from "./ws";
 
 export const messageHandlers: Record<string, MessageHandler> = {
     "newt/wg/register": handleRegisterMessage,
-};
+    "newt/socket/status": handleDockerStatusMessage,
+    "newt/socket/containers": handleDockerContainersMessage
+};

server/routers/newt/createNewt.ts

@@ -1,9 +1,9 @@
 import { NextFunction, Request, Response } from "express";
-import db from "@server/db";
+import { db } from "@server/db";
 import { hash } from "@node-rs/argon2";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { newts } from "@server/db/schemas";
+import { newts } from "@server/db";
 import createHttpError from "http-errors";
 import response from "@server/lib/response";
 import { SqliteError } from "better-sqlite3";

server/routers/newt/dockerSocket.ts

@@ -0,0 +1,22 @@
+import NodeCache from "node-cache";
+import { sendToClient } from "../ws";
+
+export const dockerSocketCache = new NodeCache({
+    stdTTL: 3600 // seconds
+});
+
+export function fetchContainers(newtId: string) {
+    const payload = {
+        type: `newt/socket/fetch`,
+        data: {}
+    };
+    sendToClient(newtId, payload);
+}
+
+export function dockerSocket(newtId: string) {
+    const payload = {
+        type: `newt/socket/check`,
+        data: {}
+    };
+    sendToClient(newtId, payload);
+}

server/routers/newt/getToken.ts

@@ -1,6 +1,6 @@
 import { generateSessionToken } from "@server/auth/sessions/app";
-import db from "@server/db";
-import { newts } from "@server/db/schemas";
+import { db } from "@server/db";
+import { newts } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq } from "drizzle-orm";

server/routers/newt/handleRegisterMessage.ts

@@ -1,4 +1,4 @@
-import db from "@server/db";
+import { db } from "@server/db";
 import { MessageHandler } from "../ws";
 import {
     exitNodes,
@@ -6,7 +6,7 @@ import {
     sites,
     Target,
     targets
-} from "@server/db/schemas";
+} from "@server/db";
 import { eq, and, sql, inArray } from "drizzle-orm";
 import { addPeer, deletePeer } from "../gerbil/peers";
 import logger from "@server/logger";

server/routers/newt/handleSocketMessages.ts

@@ -0,0 +1,57 @@
+import { MessageHandler } from "../ws";
+import logger from "@server/logger";
+import { dockerSocketCache } from "./dockerSocket";
+
+export const handleDockerStatusMessage: MessageHandler = async (context) => {
+    const { message, newt } = context;
+
+    logger.info("Handling Docker socket check response");
+
+    if (!newt) {
+        logger.warn("Newt not found");
+        return;
+    }
+
+    logger.info(`Newt ID: ${newt.newtId}, Site ID: ${newt.siteId}`);
+    const { available, socketPath } = message.data;
+
+    logger.info(
+        `Docker socket availability for Newt ${newt.newtId}: available=${available}, socketPath=${socketPath}`
+    );
+
+    if (available) {
+        logger.info(`Newt ${newt.newtId} has Docker socket access`);
+        dockerSocketCache.set(`${newt.newtId}:socketPath`, socketPath, 0);
+        dockerSocketCache.set(`${newt.newtId}:isAvailable`, available, 0);
+    } else {
+        logger.warn(`Newt ${newt.newtId} does not have Docker socket access`);
+    }
+
+    return;
+};
+
+export const handleDockerContainersMessage: MessageHandler = async (
+    context
+) => {
+    const { message, newt } = context;
+
+    logger.info("Handling Docker containers response");
+
+    if (!newt) {
+        logger.warn("Newt not found");
+        return;
+    }
+
+    logger.info(`Newt ID: ${newt.newtId}, Site ID: ${newt.siteId}`);
+    const { containers } = message.data;
+
+    logger.info(
+        `Docker containers for Newt ${newt.newtId}: ${containers ? containers.length : 0}`
+    );
+
+    if (containers && containers.length > 0) {
+        dockerSocketCache.set(`${newt.newtId}:dockerContainers`, containers, 0);
+    } else {
+        logger.warn(`Newt ${newt.newtId} does not have Docker containers`);
+    }
+};

server/routers/newt/index.ts

@@ -1,3 +1,4 @@
 export * from "./createNewt";
 export * from "./getToken";
-export * from "./handleRegisterMessage";
+export * from "./handleRegisterMessage";
+export * from "./handleSocketMessages";

server/routers/newt/targets.ts

@@ -1,4 +1,4 @@
-import { Target } from "@server/db/schemas";
+import { Target } from "@server/db";
 import { sendToClient } from "../ws";
 
 export function addTargets(

server/routers/org/checkId.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { orgs } from "@server/db/schemas";
+import { orgs } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/org/createOrg.ts

@@ -12,13 +12,13 @@ import {
     roleActions,
     roles,
     userOrgs,
-    users
-} from "@server/db/schemas";
+    users,
+    actions
+} from "@server/db";
 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/lib/config";
 import { fromError } from "zod-validation-error";
 import { defaultRoleAllowedActions } from "../role";
@@ -78,16 +78,6 @@ export async function createOrg(
             );
         }
 
-        // const userOrgIds = req.userOrgIds;
-        // if (userOrgIds && userOrgIds.length > MAX_ORGS) {
-        //     return next(
-        //         createHttpError(
-        //             HttpCode.FORBIDDEN,
-        //             `Maximum number of organizations reached.`
-        //         )
-        //     );
-        // }
-
         const { orgId, name } = parsedBody.data;
 
         // make sure the orgId is unique
@@ -131,14 +121,40 @@ export async function createOrg(
 
             org = newOrg[0];
 
-            const roleId = await createAdminRole(newOrg[0].orgId);
+            // Create admin role within the same transaction
+            const [insertedRole] = await trx
+                .insert(roles)
+                .values({
+                    orgId: newOrg[0].orgId,
+                    isAdmin: true,
+                    name: "Admin",
+                    description: "Admin role with the most permissions"
+                })
+                .returning({ roleId: roles.roleId });
 
-            if (!roleId) {
+            if (!insertedRole || !insertedRole.roleId) {
                 error = "Failed to create Admin role";
                 trx.rollback();
                 return;
             }
 
+            const roleId = insertedRole.roleId;
+
+            // Get all actions and create role actions
+            const actionIds = await trx.select().from(actions).execute();
+            
+            if (actionIds.length > 0) {
+                await trx
+                    .insert(roleActions)
+                    .values(
+                        actionIds.map((action) => ({
+                            roleId,
+                            actionId: action.actionId,
+                            orgId: newOrg[0].orgId
+                        }))
+                    );
+            }
+
             await trx.insert(orgDomains).values(
                 allDomains.map((domain) => ({
                     orgId: newOrg[0].orgId,
@@ -208,7 +224,7 @@ export async function createOrg(
             return next(
                 createHttpError(
                     HttpCode.INTERNAL_SERVER_ERROR,
-                    "Failed to createo org"
+                    "Failed to create org"
                 )
             );
         }

server/routers/org/deleteOrg.ts

@@ -7,7 +7,7 @@ import {
     orgs,
     sites,
     userActions
-} from "@server/db/schemas";
+} from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/org/getOrg.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { Org, orgs } from "@server/db/schemas";
+import { Org, orgs } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/org/getOrgOverview.ts

@@ -10,7 +10,7 @@ import {
     userResources,
     users,
     userSites
-} from "@server/db/schemas";
+} from "@server/db";
 import { and, count, eq, inArray } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/org/listOrgs.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { Org, orgs, userOrgs } from "@server/db/schemas";
+import { Org, orgs, userOrgs } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/org/listUserOrgs.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { Org, orgs, userOrgs } from "@server/db/schemas";
+import { Org, orgs, userOrgs } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/org/updateOrg.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { orgs } from "@server/db/schemas";
+import { orgs } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/authWithAccessToken.ts

@@ -1,6 +1,6 @@
 import { generateSessionToken } from "@server/auth/sessions/app";
-import db from "@server/db";
-import { Resource, resources } from "@server/db/schemas";
+import { db } from "@server/db";
+import { Resource, resources } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq } from "drizzle-orm";

server/routers/resource/authWithPassword.ts

@@ -1,7 +1,7 @@
 import { verify } from "@node-rs/argon2";
 import { generateSessionToken } from "@server/auth/sessions/app";
-import db from "@server/db";
-import { orgs, resourcePassword, resources } from "@server/db/schemas";
+import { db } from "@server/db";
+import { orgs, resourcePassword, resources } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq } from "drizzle-orm";

server/routers/resource/authWithPincode.ts

@@ -1,6 +1,6 @@
 import { generateSessionToken } from "@server/auth/sessions/app";
-import db from "@server/db";
-import { orgs, resourcePincode, resources } from "@server/db/schemas";
+import { db } from "@server/db";
+import { orgs, resourcePincode, resources } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq } from "drizzle-orm";

server/routers/resource/authWithWhitelist.ts

@@ -1,11 +1,11 @@
 import { generateSessionToken } from "@server/auth/sessions/app";
-import db from "@server/db";
+import { db } from "@server/db";
 import {
     orgs,
     resourceOtp,
     resources,
     resourceWhitelist
-} from "@server/db/schemas";
+} from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq, and } from "drizzle-orm";

server/routers/resource/createResource.ts

@@ -10,7 +10,7 @@ import {
     roleResources,
     roles,
     userResources
-} from "@server/db/schemas";
+} from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/resource/createResourceRule.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourceRules, resources } from "@server/db/schemas";
+import { resourceRules, resources } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/deleteResource.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { newts, resources, sites, targets } from "@server/db/schemas";
+import { newts, resources, sites, targets } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/deleteResourceRule.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourceRules, resources } from "@server/db/schemas";
+import { resourceRules, resources } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/getExchangeToken.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resources } from "@server/db/schemas";
+import { resources } from "@server/db";
 import { eq } from "drizzle-orm";
 import { createResourceSession } from "@server/auth/sessions/resource";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/getResource.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { Resource, resources, sites } from "@server/db/schemas";
+import { Resource, resources, sites } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/getResourceAuthInfo.ts

@@ -5,7 +5,7 @@ import {
     resourcePassword,
     resourcePincode,
     resources
-} from "@server/db/schemas";
+} from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/getResourceWhitelist.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourceWhitelist, users } from "@server/db/schemas"; // Assuming these are the correct tables
+import { resourceWhitelist, users } from "@server/db"; // Assuming these are the correct tables
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/listResourceRoles.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleResources, roles } from "@server/db/schemas";
+import { roleResources, roles } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/listResourceRules.ts

@@ -1,5 +1,5 @@
 import { db } from "@server/db";
-import { resourceRules, resources } from "@server/db/schemas";
+import { resourceRules, resources } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import response from "@server/lib/response";
 import { eq, sql } from "drizzle-orm";

server/routers/resource/listResourceUsers.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { idp, userResources, users } from "@server/db/schemas"; // Assuming these are the correct tables
+import { idp, userResources, users } from "@server/db"; // Assuming these are the correct tables
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/listResources.ts

@@ -8,7 +8,7 @@ import {
     roleResources,
     resourcePassword,
     resourcePincode
-} from "@server/db/schemas";
+} from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/resource/setResourcePassword.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourcePassword } from "@server/db/schemas";
+import { resourcePassword } from "@server/db";
 import { eq } from "drizzle-orm";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/resource/setResourcePincode.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourcePincode } from "@server/db/schemas";
+import { resourcePincode } from "@server/db";
 import { eq } from "drizzle-orm";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/resource/setResourceRoles.ts

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

server/routers/resource/setResourceUsers.ts

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

server/routers/resource/setResourceWhitelist.ts

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

server/routers/resource/transferResource.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { newts, resources, sites, targets } from "@server/db/schemas";
+import { newts, resources, sites, targets } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/updateResource.ts

@@ -8,7 +8,7 @@ import {
     orgs,
     Resource,
     resources
-} from "@server/db/schemas";
+} from "@server/db";
 import { eq, and } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/resource/updateResourceRule.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resourceRules, resources } from "@server/db/schemas";
+import { resourceRules, resources } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/addRoleAction.ts

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

server/routers/role/addRoleSite.ts

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

server/routers/role/createRole.ts

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

server/routers/role/deleteRole.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roles, userOrgs } from "@server/db/schemas";
+import { roles, userOrgs } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/getRole.ts

@@ -1,13 +1,14 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roles } from "@server/db/schemas";
+import { roles } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
+import { OpenAPITags, registry } from "@server/openApi";
 
 const getRoleSchema = z
     .object({
@@ -15,6 +16,17 @@ const getRoleSchema = z
     })
     .strict();
 
+registry.registerPath({
+    method: "get",
+    path: "/role/{roleId}",
+    description: "Get a role.",
+    tags: [OpenAPITags.Role],
+    request: {
+        params: getRoleSchema
+    },
+    responses: {}
+});
+
 export async function getRole(
     req: Request,
     res: Response,

server/routers/role/listRoleActions.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleActions, actions } from "@server/db/schemas";
+import { roleActions, actions } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/listRoleResources.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleResources, resources } from "@server/db/schemas";
+import { roleResources, resources } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/listRoleSites.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleSites, sites } from "@server/db/schemas";
+import { roleSites, sites } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/listRoles.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roles, orgs } from "@server/db/schemas";
+import { roles, orgs } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";

server/routers/role/removeRoleAction.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleActions } from "@server/db/schemas";
+import { roleActions } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/removeRoleResource.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roleResources } from "@server/db/schemas";
+import { roleResources } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/removeRoleSite.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resources, roleResources, roleSites } from "@server/db/schemas";
+import { resources, roleResources, roleSites } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/role/updateRole.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roles } from "@server/db/schemas";
+import { roles } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";

server/routers/site/createSite.ts

@@ -1,16 +1,16 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { roles, userSites, sites, roleSites, Site, orgs } from "@server/db/schemas";
+import { roles, userSites, sites, roleSites, Site, orgs } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { eq, and } from "drizzle-orm";
-import { getUniqueSiteName } from "@server/db/names";
+import { getUniqueSiteName } from "../../db/names";
 import { addPeer } from "../gerbil/peers";
 import { fromError } from "zod-validation-error";
-import { newts } from "@server/db/schemas";
+import { newts } from "@server/db";
 import moment from "moment";
 import { OpenAPITags, registry } from "@server/openApi";
 import { hashPassword } from "@server/auth/password";
@@ -141,6 +141,7 @@ export async function createSite(
                         niceId,
                         subnet,
                         type,
+                        dockerSocketEnabled: type == "newt",
                         ...(pubKey && type == "wireguard" && { pubKey })
                     })
                     .returning();
@@ -154,6 +155,7 @@ export async function createSite(
                         name,
                         niceId,
                         type,
+                        dockerSocketEnabled: type == "newt",
                         subnet: "0.0.0.0/0"
                     })
                     .returning();

server/routers/site/deleteSite.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { newts, newtSessions, sites } from "@server/db/schemas";
+import { newts, newtSessions, sites } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";