@graphoria/server 0.2.3 → 0.4.0

package/src/databases/high-level-operations.ts

@@ -28,6 +28,10 @@ export const getDatabasesStructure = async (
 ) => {
   const entities: TableResolver[] = [];
   const enhancedStoredProcedures: ProcedureResolver[] = [];
+  // Taken before the exclusion and auth-table filters below, because that is the
+  // only point where a name the config excludes is still visible. Resolving
+  // `schema.excludedTables` against `entities` could never succeed.
+  const tableNamesByDatabase: Record<string, string[]> = {};
 
   // The auth user table holds the password hash and must never be served via
   // the generated API. Its resolver key matches t.schemaName, which is always
@@ -39,10 +43,17 @@ export const getDatabasesStructure = async (
   for (const db of databases) {
     const { tables, storedProcedures } = await fetchStructure(db);
 
+    // Every other name comparison in this file folds case. This one used not to,
+    // and it is the one where a mismatch fails open: excludedTables is a
+    // do-not-serve list, so a name spelled in the wrong case served the table.
+    const excluded = new Set((db.schema?.excludedTables ?? []).map((name) => name.toLowerCase()));
+
+    tableNamesByDatabase[db.name] = tables.map((t) => t.schemaName);
+
     const tablesToAdd = tables
       .reduce<Tables>((acc, t) => {
         if (authUserKey && t.schemaName === authUserKey) return acc;
-        if (db.schema?.excludedTables.includes(t.schemaName)) return acc;
+        if (excluded.has(t.schemaName.toLowerCase())) return acc;
 
         const tableOverride = db.schema?.database[t.schemaName];
 
@@ -150,7 +161,7 @@ export const getDatabasesStructure = async (
     enhancedStoredProcedures.push(...storedProceduresToAdd);
   }
 
-  return { tables: entities, storedProcedures: enhancedStoredProcedures };
+  return { tables: entities, storedProcedures: enhancedStoredProcedures, tableNamesByDatabase };
 };
 
 export type EntitiesOfRole = {

package/src/index.ts

@@ -4,8 +4,10 @@ import { serve } from "bun";
 import { isString } from "es-toolkit";
 
 import type { BunRequest } from "bun";
+import type { Capability } from "./authentication/capabilities";
 import type { Configuration } from "./types/configuration";
 import type { Env } from "./types/env";
+import type { SessionContext } from "./utils/sessionVariables";
 
 import { createTokenService } from "./authentication";
 import { analyzeConfiguration, loadConfiguration } from "./configuration";
@@ -14,16 +16,26 @@ import { websocketHandlerFactory } from "./configuration/gql/handleGraphQLSubscr
 import { consoleRoutesFactory } from "./console/api";
 import { createAuthTables, verifyAuthTablesExist } from "./databases";
 import { createMCPRoutes } from "./ai";
+import { createCapabilityAuthorizer } from "./authentication/capabilities";
 import { getAgent, instantiateAI } from "./singletons/ai";
 import { getTokenService, setTokenService } from "./singletons/authentication";
 import { instantiateCronJobs } from "./singletons/cron";
 import { disconnectDatabases, instantiateDatabasesConnections } from "./singletons/databases";
+import { getCacheRedisClient } from "./singletons/cache/redisClient";
 import { env } from "./singletons/env";
+import { setQueryTimeoutMs } from "./singletons/queryTimeout";
 import { instantiateQueues } from "./singletons/queues";
 import { ConfigurationZod } from "./types/zod/configuration";
-import { S200, S400, S401, S404 } from "./utils/responses";
+import {
+  createMemoryRateLimitStore,
+  createRateLimiter,
+  createRedisRateLimitStore,
+  resolveClientAddress,
+} from "./utils/rateLimit";
+import { S200, S400, S401, S404, S429 } from "./utils/responses";
 import { writeSchema } from "./utils/writeSchema";
 import { logger, configureLogging } from "./logging";
+import { actorFromSession, audit } from "./logging/audit";
 
 // Re-export for consumers
 export { configureLogging };
@@ -73,6 +85,20 @@ const bootAnalyzedConfiguration = async (env: Env) => {
     configureLogging(env.logger);
   }
 
+  if (env.maxQueryDepth === 0) {
+    logger("graphoria").warn(
+      "MAX_QUERY_DEPTH=0 disables the query depth limit; one deeply nested query can exhaust the server",
+    );
+  }
+
+  setQueryTimeoutMs(env.queryTimeoutMs);
+
+  if (env.queryTimeoutMs === 0) {
+    logger("graphoria").warn(
+      "QUERY_TIMEOUT_MS=0 disables the statement timeout; one slow query can hold a connection and its locks indefinitely",
+    );
+  }
+
   if (!env.configuration) {
     throw new Error("Configuration is required to create the GraphQL server");
   }
@@ -212,19 +238,85 @@ const createGraphQLServer = async (env: Env) => {
 
   const consoleHtml = await renderPlayground("../playgrounds/console/index.html", {});
 
-  // Helper to get role-based handlers
-  const getRoleHandlers = async (req: Request) => {
-    const session = await getTokenService().verifyTokenAndGetSession(
-      req.headers.get(env.authorizationHeader),
-      req.headers.get(env.admin.header),
-    );
+  const rateLimiter = createRateLimiter({
+    settings: env.rateLimit,
+    anonymousRole: env.anonymousRole,
+    permissions: projectConfiguration.auth?.permissions,
+    store: () =>
+      env.cache.store === "redis"
+        ? createRedisRateLimitStore(getCacheRedisClient())
+        : createMemoryRateLimitStore(),
+  });
+
+  const authorizeCapability = createCapabilityAuthorizer(env);
+
+  // Helper to get role-based handlers. A route that names a capability also
+  // accepts that capability's scoped credential in the admin-secret header;
+  // it stands in for the superadmin role on that route and nowhere else.
+  const getRoleHandlers = async (
+    req: Request,
+    server?: Bun.Server<unknown>,
+    capability?: Capability,
+  ) => {
+    const adminSecretHeader = req.headers.get(env.admin.header);
+    const grant = capability ? authorizeCapability(adminSecretHeader, capability) : null;
+
+    const session: SessionContext =
+      grant && !grant.superset
+        ? { sub: capability, role: env.superadmin.role, authMethod: "admin_secret" }
+        : await getTokenService().verifyTokenAndGetSession(
+            req.headers.get(env.authorizationHeader),
+            adminSecretHeader,
+          );
+
+    const ip = resolveClientAddress(req, server, env.rateLimit.trustProxy);
+
+    // The limit needs the role, and the role costs a token verification plus a
+    // revocation lookup — so it is spent here, once, rather than again inside a
+    // wrapper.
+    const limit = await rateLimiter?.check(session, ip);
+
+    const scope: Capability | "all" | undefined = grant
+      ? grant.superset
+        ? "all"
+        : capability
+      : undefined;
+
+    if (session.authMethod === "admin_secret") {
+      audit().emit({
+        action: "admin_secret.used",
+        actor: { type: "admin_secret", ...(scope ? { scope } : {}), ip },
+        target: { kind: "endpoint", method: req.method, path: new URL(req.url).pathname },
+      });
+    }
+
     return {
       role: session.role!,
       session,
+      scope,
+      limit,
       ...analyzedConfiguration.roles[session.role!].handlers,
     };
   };
 
+  /**
+   * For the entry points that have no session to key on: the websocket upgrade
+   * (the token arrives in `connection_init`, after the upgrade) and MCP. They
+   * are keyed by address against the anonymous ceiling.
+   */
+  const withRateLimit =
+    <T>(handler: (req: BunRequest, server: Bun.Server<unknown>) => T | Promise<T>) =>
+    async (req: BunRequest, server: Bun.Server<unknown>) => {
+      const limit = await rateLimiter?.check(
+        null,
+        resolveClientAddress(req, server, env.rateLimit.trustProxy),
+      );
+
+      if (limit && !limit.allowed) return new S429(limit.retryAfterMs);
+
+      return handler(req, server);
+    };
+
   // Create routes map with all handlers
   const routes: RoutesMap = {};
 
@@ -251,7 +343,8 @@ const createGraphQLServer = async (env: Env) => {
         prefixes,
         projectConfiguration,
         analyzedConfiguration,
-        getRoleHandlers,
+        tokenService: getTokenService(),
+        rateLimiter,
       }),
     );
   }
@@ -259,7 +352,7 @@ const createGraphQLServer = async (env: Env) => {
   // GraphQL endpoint
   routes[prefixes.graphql] = {
     ...(env.enableCors ? { OPTIONS: () => new S200(null) } : {}),
-    GET: async (req: Request, server: Bun.Server<unknown>) => {
+    GET: withRateLimit(async (req: Request, server: Bun.Server<unknown>) => {
       try {
         if (req.headers.get("upgrade") === "websocket") {
           const success = server.upgrade(req, {
@@ -271,17 +364,19 @@ const createGraphQLServer = async (env: Env) => {
       } catch (error) {
         return new S400({ errors: [{ message: (error as Error)?.message }] });
       }
-    },
-    POST: async (req: BunRequest) => {
+    }),
+    POST: async (req: BunRequest, server: Bun.Server<unknown>) => {
       try {
-        const { gql, session } = await getRoleHandlers(req);
+        const { gql, session, limit } = await getRoleHandlers(req, server);
+        if (limit && !limit.allowed) return new S429(limit.retryAfterMs);
+
         const { query, variables } = await req.json();
 
         if (gql.isIntrospectionQuery(query)) return new S200(gql.introspectionResult);
 
         if (gql.isNoDataQuery(query)) return new S200(gql.noDataResult);
 
-        const { hasErrors, validationErrors } = gql.hasErrors(query);
+        const { hasErrors, validationErrors } = gql.hasErrors(query, { variables });
 
         if (hasErrors)
           return new S400({
@@ -312,23 +407,28 @@ const createGraphQLServer = async (env: Env) => {
 
     if (mcpEnabled) {
       const mcpPath = `${env.prefix}${env.ai?.mcp?.endpoint ?? projectConfiguration.ai?.endpoint ?? "/ai"}`;
-      routes[mcpPath] = createMCPRoutes(analyzedConfiguration, {
+      const mcpRoutes = createMCPRoutes(analyzedConfiguration, {
         ...(env.ai?.mcp ?? {}),
         name: projectConfiguration.name,
         version: projectConfiguration.version,
         maxQueryDepth: env.ai?.mcp?.maxQueryDepth ?? env.maxQueryDepth,
-        adminSecret: env.admin.secret,
+        authorize: authorizeCapability,
         adminSecretHeader: env.admin.header,
       });
+
+      routes[mcpPath] = Object.fromEntries(
+        Object.entries(mcpRoutes).map(([method, handler]) => [method, withRateLimit(handler)]),
+      );
     }
 
     if (env.ai?.restEnabled) {
       const aiPath = `${env.prefix}/rest${projectConfiguration.ai.endpoint ?? "/ai"}`;
       routes[aiPath] = {
         ...(env.enableCors ? { OPTIONS: () => new S200(null) } : {}),
-        POST: async (req: BunRequest) => {
+        POST: async (req: BunRequest, server: Bun.Server<unknown>) => {
           try {
-            const { role } = await getRoleHandlers(req);
+            const { role, session, scope, limit } = await getRoleHandlers(req, server, "ai");
+            if (limit && !limit.allowed) return new S429(limit.retryAfterMs);
             if (role !== env.superadmin.role) return new S404({ error: "Not Found" });
 
             const { prompt } = await req.json();
@@ -337,6 +437,13 @@ const createGraphQLServer = async (env: Env) => {
                 errors: [{ message: "`prompt` (string) is required" }],
               });
 
+            audit().emit({
+              action: "ai.ask",
+              actor: { ...actorFromSession(session), ...(scope ? { scope } : {}) },
+              target: { kind: "ai", via: "rest" },
+              prompt,
+            });
+
             return new S200({ answer: await getAgent()(prompt) });
           } catch (error) {
             return new S400({ errors: [{ message: (error as Error)?.message }] });
@@ -347,11 +454,12 @@ const createGraphQLServer = async (env: Env) => {
   }
 
   // REST API endpoint
-  routes[`${prefixes.rest}/*`] = async (req: BunRequest) => {
+  routes[`${prefixes.rest}/*`] = async (req: BunRequest, server: Bun.Server<unknown>) => {
     if (req.method === "OPTIONS" && env.enableCors) return new S200(null);
 
     try {
-      const { rest, session } = await getRoleHandlers(req);
+      const { rest, session, limit } = await getRoleHandlers(req, server);
+      if (limit && !limit.allowed) return new S429(limit.retryAfterMs);
 
       const urlParsed = new URL(req.url);
 

package/src/logging/audit.ts

@@ -0,0 +1,86 @@
+import type { Logger } from "pino";
+import type { Capability } from "../authentication/capabilities";
+import type { SessionContext } from "../utils/sessionVariables";
+
+import { logger } from "./index";
+
+export type AuditActor = {
+  type: "admin_secret" | "console" | "token" | "credentials" | "anonymous";
+  sub?: string;
+  role?: string;
+  /** Which credential was presented at a scoped surface: `all` is the admin secret. */
+  scope?: Capability | "all";
+  ip?: string | undefined;
+};
+
+export type AuditEvent = {
+  action: string;
+  actor: AuditActor;
+  target: Record<string, unknown>;
+  outcome?: "success" | "failure";
+  [key: string]: unknown;
+};
+
+export type AuditLog = {
+  emit(event: AuditEvent): void;
+};
+
+const REDACTED_KEYS = new Set([
+  "password",
+  "secret",
+  "secrets",
+  "token",
+  "access_token",
+  "refresh_token",
+  "authorization",
+  "cookie",
+]);
+
+const redact = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(redact);
+  if (typeof value !== "object" || value === null) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      REDACTED_KEYS.has(key) ? "[REDACTED]" : redact(entry),
+    ]),
+  );
+};
+
+export const actorFromSession = (session: SessionContext | undefined): AuditActor => {
+  if (!session) return { type: "anonymous" };
+  const type =
+    session.authMethod === "admin_secret" ? "admin_secret" : session.jti ? "token" : "anonymous";
+  return {
+    type,
+    ...(session.sub !== undefined ? { sub: session.sub } : {}),
+    ...(session.role !== undefined ? { role: session.role } : {}),
+  };
+};
+
+export const createAuditLog = (base: Logger): AuditLog => {
+  // An audit record has to survive LOG_LEVEL=warn: the level is pinned here,
+  // independent of whatever the root logger was configured with.
+  const log = base.child({});
+  log.level = "info";
+
+  return {
+    emit: (event) => {
+      log.info(redact(event) as object, event.action);
+    },
+  };
+};
+
+let override: AuditLog | null = null;
+let instance: AuditLog | null = null;
+
+/** Test seam: pass `null` to restore the default log. */
+export const setAuditLog = (log: AuditLog | null): void => {
+  override = log;
+};
+
+export const audit = (): AuditLog => {
+  if (override) return override;
+  if (!instance) instance = createAuditLog(logger("audit"));
+  return instance;
+};

package/src/singletons/queryTimeout.ts

@@ -0,0 +1,20 @@
+/**
+ * The process-wide statement timeout in milliseconds, resolved from
+ * `QUERY_TIMEOUT_MS` at boot.
+ *
+ * It lives here rather than being read from `singletons/env` because the engine
+ * connection modules need it, and that module parses `process.env` the moment it
+ * is imported — reaching it from an engine would make every unit test that
+ * transitively touches a query builder fail without `ADMIN_SECRET` set.
+ *
+ * `0` disables the bound. That is also the value before boot sets it, so an
+ * engine used outside a booted server behaves exactly as it did before timeouts
+ * existed.
+ */
+let queryTimeoutMs = 0;
+
+export const setQueryTimeoutMs = (ms: number) => {
+  queryTimeoutMs = ms;
+};
+
+export const getQueryTimeoutMs = () => queryTimeoutMs;

package/src/subscriptions/strategies/database.ts

@@ -15,10 +15,26 @@ export const createDatabaseSubscriptionStrategy = (): SubscriptionStrategy => ({
   source: EntitySource.TABLE,
 
   getSubscriptionKey(context) {
-    const { analysis } = context;
+    const { analysis, field, session, variables } = context;
     const operation = analysis.operations[0];
-    // Use operation name as the base key (existing behavior)
-    return operation.name ?? operation.fields[0]?.name ?? "unknown";
+    const base = operation.name ?? operation.fields[0]?.name ?? "unknown";
+
+    // Every part of this is load-bearing. A group shares one poller, and every
+    // client joined to it is served that poller's rows — so two callers may
+    // only share a key when the query they asked for is the same query,
+    // resolved against the same session. The role and the subject carry the row
+    // filter; the variables carry everything the caller chose; the selections
+    // carry the shape. Two keys that differ where they should not merely cost a
+    // second poller, but two that match where they should not is a cross-tenant
+    // read.
+    return [
+      base,
+      session.role ?? "",
+      session.sub ?? "",
+      field.alias ?? "",
+      JSON.stringify(field.selections),
+      JSON.stringify(variables),
+    ].join("\u0000");
   },
 
   async subscribe(context: SubscriptionContext): Promise<SubscriptionResult> {

package/src/subscriptions/types.ts

@@ -2,6 +2,7 @@ import type { ServerWebSocket } from "bun";
 import type { AnalysisResult, SelectionAnalysis, VariableDefinition } from "../analyzeQuery/types";
 import type { GetSchemaReturn } from "../configuration/getSchemas";
 import type { createQueryEventEmitter } from "../utils/event-emitter";
+import type { SessionContext } from "../utils/sessionVariables";
 
 /**
  * Type for the query event emitter instance
@@ -24,7 +25,7 @@ export interface SubscriptionContext {
   ws: ServerWebSocket<unknown>;
   /** Unique subscription ID from the client */
   subscriptionId: string;
-  /** Analyzed GraphQL query */
+  /** Analyzed GraphQL query, with variables and `$session.*` already resolved */
   analysis: AnalysisResult;
   /** The first field being subscribed to */
   field: SelectionAnalysis;
@@ -34,6 +35,8 @@ export interface SubscriptionContext {
   variables: Record<string, unknown>;
   /** Schema and entity information for the current role */
   schemaEntity: GetSchemaReturn;
+  /** The caller this subscription belongs to. Load-bearing: it keys the group. */
+  session: SessionContext;
   /** Shared event emitter for broadcasting updates */
   eventEmitter: QueryEventEmitter;
 }

package/src/subscriptions/utils/polling.ts

@@ -5,6 +5,7 @@ import type { DatabasePoller, QueryEventEmitter } from "../types";
 
 import { executeQuery, executeQueryJSON, generateSQL } from "../../databases";
 import { logger } from "../../logging";
+import { env } from "../../singletons/env";
 
 export interface DatabasePollerConfig {
   analysis: AnalysisResult;
@@ -60,9 +61,11 @@ export const createDatabasePoller = async (
   const firstFieldName = getFirstFieldName(analysis);
   const db = schemaEntity.queriesMap[firstFieldName!]!.db!;
 
-  // Generate SQL queries (data query and hash query)
-  const [[, queryData]] = generateSQL(schemaEntity, analysis, variables);
-  const [[, queryHash]] = generateSQL(schemaEntity, analysis, variables, true);
+  // Generate SQL queries (data query and hash query). A subscription query is
+  // caller-authored, so it carries the same page bounds an HTTP query does.
+  const pageLimits = { defaultPageSize: env.defaultPageSize, maxPageSize: env.maxPageSize };
+  const [[, queryData]] = generateSQL(schemaEntity, analysis, variables, false, pageLimits);
+  const [[, queryHash]] = generateSQL(schemaEntity, analysis, variables, true, pageLimits);
 
   // Get initial hash and send initial data
   let previousHash = await getResultHash(queryHash, db, variableDefinitions, variables);

package/src/types/env.ts

@@ -3,19 +3,29 @@ import { z } from "zod";
 import { version } from "../../package.json";
 import { ConfigurationZod } from "./zod/configuration";
 
+// A secret env var is a comma-separated list: the first entry is the one in
+// use, the rest are still accepted so a rotation can overlap instead of cutting
+// over. Blank entries are dropped, so an unset var is an empty list.
+const splitSecrets = (value: string) =>
+  value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+const secretList = z.string().default("").transform(splitSecrets);
+
 export const EnvZod = z
   .object({
     PORT: z.coerce.number().default(3000),
     NODE_ENV: z.string().default("DEVELOPMENT"),
-    ADMIN_SECRET: z.string(),
+    ADMIN_SECRET: z.string().transform(splitSecrets),
     CONFIGURATION: z.union([z.string(), ConfigurationZod]).optional(),
     ANONYMOUS_ROLE: z.string().default("anonymous"),
-    JWT_SECRET: z.string().optional().default(""),
+    JWT_SECRET: secretList,
     JWT_EXPIRES_IN: z.string().default("5m"),
     JWT_RT_EXPIRES_IN: z.string().default("7d"),
-    PASETO_LOCAL_KEY: z.string().optional().default(""),
+    PASETO_LOCAL_KEY: secretList,
     PASETO_SECRET_KEY: z.string().optional().default(""),
-    PASETO_PUBLIC_KEY: z.string().optional().default(""),
+    PASETO_PUBLIC_KEY: secretList,
     AUTH_STRATEGY: z.enum(["jwt", "paseto_local", "paseto_public"]).optional(),
     REDIS_URL: z.string().default("redis://localhost:6379"),
     CACHE_STORE: z.enum(["memory", "redis"]).default("memory"),
@@ -30,18 +40,31 @@ export const EnvZod = z
     // Boolean flags use stringbool, not coerce.boolean: Boolean("false") === true would flip them on
     CONSOLE_ENABLED: z.stringbool().default(false),
     CONSOLE_ENDPOINT: z.string().default("/_console"),
+    CONSOLE_SESSION_EXPIRES_IN: z.string().default("1h"),
+    CONSOLE_READ_SECRET: secretList,
+    CONSOLE_WRITE_SECRET: secretList,
     PREFIX: z.string().default(""),
     CORS_ENABLED: z.stringbool().default(true),
     PRINT_SCHEMAS: z.stringbool().default(false),
     SCHEMAS_OUTPUT_DIR: z.string().default("./.graphoria/schemas"),
     QUERY_ON_RESPONSE: z.stringbool().default(false),
-    MAX_QUERY_DEPTH: z.coerce.number().int().min(0).default(0),
+    MAX_QUERY_DEPTH: z.coerce.number().int().min(0).default(8),
+    DEFAULT_PAGE_SIZE: z.coerce.number().int().min(0).default(100),
+    MAX_PAGE_SIZE: z.coerce.number().int().min(0).default(1000),
+    QUERY_TIMEOUT_MS: z.coerce.number().int().min(0).default(10000),
+    MAX_QUERY_COST: z.coerce.number().int().min(0).default(0),
+    RATE_LIMIT_MAX: z.coerce.number().int().min(0).default(0),
+    RATE_LIMIT_ANONYMOUS_MAX: z.coerce.number().int().min(0).default(0),
+    RATE_LIMIT_WINDOW_MS: z.coerce.number().int().positive().default(60000),
+    RATE_LIMIT_TRUST_PROXY: z.stringbool().default(false),
     AI_ENABLED: z.stringbool().optional(),
     AI_GRAPHQL_ENABLED: z.stringbool().default(true),
     AI_REST_ENABLED: z.stringbool().default(true),
+    AI_SECRET: secretList,
     AI_MCP_ENABLED: z.stringbool().optional(),
     AI_MCP_ENDPOINT: z.string().default("/mcp"),
     AI_MCP_REQUIRE_ADMIN_SECRET: z.stringbool().default(false),
+    AI_MCP_SECRET: secretList,
     AI_MCP_MAX_QUERY_DEPTH: z.coerce.number().int().min(0).optional(),
     AI_MCP_DISABLED_TOOLS: z.string().default(""),
     AI_MCP_DISABLED_RESOURCES: z.string().default(""),
@@ -66,19 +89,29 @@ export const EnvZod = z
     authStrategy: env.AUTH_STRATEGY,
     queryOnResponse: env.QUERY_ON_RESPONSE,
     maxQueryDepth: env.MAX_QUERY_DEPTH,
+    defaultPageSize: env.DEFAULT_PAGE_SIZE,
+    maxPageSize: env.MAX_PAGE_SIZE,
+    queryTimeoutMs: env.QUERY_TIMEOUT_MS,
+    maxQueryCost: env.MAX_QUERY_COST,
     admin: {
-      secret: env.ADMIN_SECRET,
+      secrets: env.ADMIN_SECRET,
       header: env.ADMIN_SECRET_HEADER,
     },
     jwt: {
-      secret: env.JWT_SECRET,
+      secrets: env.JWT_SECRET,
       expiresIn: env.JWT_EXPIRES_IN,
       rtExpiresIn: env.JWT_RT_EXPIRES_IN,
     },
     paseto: {
-      localKey: env.PASETO_LOCAL_KEY,
+      localKeys: env.PASETO_LOCAL_KEY,
       secretKey: env.PASETO_SECRET_KEY,
-      publicKey: env.PASETO_PUBLIC_KEY,
+      publicKeys: env.PASETO_PUBLIC_KEY,
+    },
+    rateLimit: {
+      max: env.RATE_LIMIT_MAX,
+      anonymousMax: env.RATE_LIMIT_ANONYMOUS_MAX,
+      windowMs: env.RATE_LIMIT_WINDOW_MS,
+      trustProxy: env.RATE_LIMIT_TRUST_PROXY,
     },
     cache: {
       store: env.CACHE_STORE,
@@ -94,15 +127,20 @@ export const EnvZod = z
     console: {
       enabled: env.CONSOLE_ENABLED,
       endpoint: env.CONSOLE_ENDPOINT,
+      sessionExpiresIn: env.CONSOLE_SESSION_EXPIRES_IN,
+      readSecrets: env.CONSOLE_READ_SECRET,
+      writeSecrets: env.CONSOLE_WRITE_SECRET,
     },
     ai: {
       enabled: env.AI_ENABLED,
       graphqlEnabled: env.AI_GRAPHQL_ENABLED,
       restEnabled: env.AI_REST_ENABLED,
+      secrets: env.AI_SECRET,
       mcp: {
         enabled: env.AI_MCP_ENABLED,
         endpoint: env.AI_MCP_ENDPOINT,
         requireAdminSecret: env.AI_MCP_REQUIRE_ADMIN_SECRET,
+        secrets: env.AI_MCP_SECRET,
         maxQueryDepth: env.AI_MCP_MAX_QUERY_DEPTH,
         disabledTools: env.AI_MCP_DISABLED_TOOLS
           ? env.AI_MCP_DISABLED_TOOLS.split(",")