@graphoria/server 0.1.0

package/src/utils/event-emitter.ts

@@ -0,0 +1,217 @@
+import type { ServerWebSocket } from "bun";
+import type { GraphQLError } from "graphql";
+import type { DatabasePoller } from "../subscriptions/types";
+
+type EventEmitterData = {
+  data: object | null;
+  poll?: DatabasePoller;
+  responseKey?: string;
+  dataTransform?: (data: unknown) => unknown;
+  clients: Map<ServerWebSocket<unknown>, string>;
+};
+
+export const createQueryEventEmitter = () => {
+  const connections: Map<string, EventEmitterData> = new Map();
+  // Maps a field key (e.g. "conn_queueName") to all composite subscription keys
+  // that are registered under it. Used for queue fan-out.
+  const fieldIndex: Map<string, Set<string>> = new Map();
+
+  const addConnection = (
+    queryName: string,
+    id: string,
+    ws: ServerWebSocket<unknown>,
+    poll?: DatabasePoller,
+  ) => {
+    if (!connections.has(queryName)) {
+      const clientsMap = new Map<ServerWebSocket<unknown>, string>();
+
+      clientsMap.set(ws, id);
+
+      connections.set(queryName, {
+        poll,
+        data: null,
+        clients: clientsMap,
+      });
+
+      return;
+    }
+
+    if (poll) connections.get(queryName)!.poll = poll;
+
+    connections.get(queryName)!.clients.set(ws, id);
+  };
+
+  const removeConnection = (ws: ServerWebSocket<unknown>) => {
+    connections.entries().forEach(([queryName, con]) => {
+      if (con.clients.has(ws)) {
+        con.clients.delete(ws);
+
+        if (con.clients.size === 0) {
+          con.poll?.stop();
+          connections.delete(queryName);
+          // Clean up fieldIndex entries pointing to this subscriptionKey
+          for (const [fieldKey, keys] of fieldIndex.entries()) {
+            keys.delete(queryName);
+            if (keys.size === 0) fieldIndex.delete(fieldKey);
+          }
+        }
+      }
+    });
+  };
+
+  const sendDataToWS = (data: object, ws: ServerWebSocket<unknown>) => {
+    ws.send(JSON.stringify(data));
+  };
+
+  const sendDataByQueryNameToSingleClient = (
+    queryName: string,
+    ws: ServerWebSocket<unknown>,
+    id: string,
+  ) => {
+    if (connections.has(queryName)) {
+      const data = connections.get(queryName)!.data;
+
+      if (data) sendDataToWS({ id, type: "next", payload: data }, ws);
+    }
+  };
+
+  const sendDataUpdate = (queryName: string, data: object) => {
+    // Fan-out path: if queryName is a field key registered in the index,
+    // broadcast to each composite subscription key with its own transform.
+    if (fieldIndex.has(queryName)) {
+      for (const subscriptionKey of fieldIndex.get(queryName)!) {
+        const conn = connections.get(subscriptionKey);
+        if (!conn) continue;
+
+        const rawData = (data as Record<string, unknown>).data;
+        const transformed = conn.dataTransform ? conn.dataTransform(rawData) : rawData;
+        const responseKey = conn.responseKey;
+
+        conn.data = responseKey ? { data: { [responseKey]: transformed } } : { data: transformed };
+
+        for (const [ws, id] of conn.clients) {
+          sendDataByQueryNameToSingleClient(subscriptionKey, ws, id);
+        }
+      }
+      return;
+    }
+
+    // Direct path: database strategy and other non-queue sources
+    if (connections.has(queryName)) {
+      const conn = connections.get(queryName)!;
+      const responseKey = conn.responseKey;
+
+      conn.data = responseKey
+        ? { data: { [responseKey]: (data as Record<string, unknown>).data } }
+        : data;
+
+      if (conn.clients.size) {
+        for (const [ws, id] of conn.clients) {
+          sendDataByQueryNameToSingleClient(queryName, ws, id);
+        }
+      }
+    }
+  };
+
+  const hasConnection = (queryName: string): boolean => {
+    return connections.has(queryName) && connections.get(queryName)!.clients.size > 0;
+  };
+
+  const getConnectionCount = (queryName: string): number => {
+    return connections.has(queryName) ? connections.get(queryName)!.clients.size : 0;
+  };
+
+  const setData = (queryName: string, data: object) => {
+    if (connections.has(queryName)) {
+      connections.get(queryName)!.data = data;
+    }
+  };
+
+  const setPoll = (queryName: string, poll: DatabasePoller) => {
+    if (connections.has(queryName)) {
+      connections.get(queryName)!.poll = poll;
+    }
+  };
+
+  const setResponseKey = (queryName: string, key: string) => {
+    if (connections.has(queryName)) {
+      connections.get(queryName)!.responseKey = key;
+    }
+  };
+
+  const setDataTransform = (queryName: string, transform: (data: unknown) => unknown) => {
+    if (connections.has(queryName)) {
+      connections.get(queryName)!.dataTransform = transform;
+    }
+  };
+
+  const registerFieldMapping = (fieldKey: string, subscriptionKey: string) => {
+    if (!fieldIndex.has(fieldKey)) {
+      fieldIndex.set(fieldKey, new Set());
+    }
+    fieldIndex.get(fieldKey)!.add(subscriptionKey);
+  };
+
+  const sendErrorToSingleClient = (
+    ws: ServerWebSocket<unknown>,
+    id: string,
+    errors: readonly GraphQLError[],
+  ) => {
+    sendDataToWS(
+      {
+        id,
+        type: "error",
+        payload: errors.map((error) => ({
+          message: error.message,
+          locations: error.locations,
+          path: error.path,
+        })),
+      },
+      ws,
+    );
+  };
+
+  const removeSubscription = (ws: ServerWebSocket<unknown>, subscriptionId: string) => {
+    for (const [queryName, con] of connections.entries()) {
+      if (con.clients.has(ws) && con.clients.get(ws) === subscriptionId) {
+        con.clients.delete(ws);
+
+        // Send complete message to client
+        sendDataToWS(
+          {
+            id: subscriptionId,
+            type: "complete",
+          },
+          ws,
+        );
+
+        if (con.clients.size === 0) {
+          con.poll?.stop();
+          connections.delete(queryName);
+          // Clean up fieldIndex entries pointing to this subscriptionKey
+          for (const [fieldKey, keys] of fieldIndex.entries()) {
+            keys.delete(queryName);
+            if (keys.size === 0) fieldIndex.delete(fieldKey);
+          }
+        }
+        break;
+      }
+    }
+  };
+
+  return {
+    addConnection,
+    removeConnection,
+    sendDataByQueryNameToSingleClient,
+    sendDataUpdate,
+    hasConnection,
+    getConnectionCount,
+    setData,
+    setPoll,
+    setResponseKey,
+    setDataTransform,
+    registerFieldMapping,
+    sendErrorToSingleClient,
+    removeSubscription,
+  };
+};

package/src/utils/responses.ts

@@ -0,0 +1,42 @@
+export class ClientResponse extends Response {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body ? JSON.stringify(body) : null, init);
+
+    this.headers.set("Access-Control-Allow-Origin", "*");
+    this.headers.set("Access-Control-Allow-Credentials", "true");
+    this.headers.set("Access-Control-Allow-Methods", "*");
+    this.headers.set("Access-Control-Allow-Headers", "*");
+
+    this.headers.set("Content-Type", "application/json");
+  }
+}
+
+export class S200 extends ClientResponse {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body, { ...init, status: 200 });
+  }
+}
+
+export class S400 extends ClientResponse {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body, { ...init, status: 400 });
+  }
+}
+
+export class S401 extends ClientResponse {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body, { ...init, status: 401 });
+  }
+}
+
+export class S404 extends ClientResponse {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body, { ...init, status: 404 });
+  }
+}
+
+export class S500 extends ClientResponse {
+  constructor(body?: object | null, init?: ResponseInit) {
+    super(body, { ...init, status: 500 });
+  }
+}

package/src/utils/safeJSONParse.ts

@@ -0,0 +1,10 @@
+import { logger } from "../logging";
+
+export const safeJSONParse = <T = Record<string, unknown>>(jsonString: string): T => {
+  try {
+    return JSON.parse(jsonString) as T;
+  } catch (error) {
+    logger("utils").warn({ err: error }, "failed to parse JSON");
+    return {} as T;
+  }
+};

package/src/utils/selection.ts

@@ -0,0 +1,35 @@
+import type { SelectionAnalysis } from "../analyzeQuery/types";
+
+export const filterResultBySelection = (
+  data: unknown,
+  fields: SelectionAnalysis[] | undefined,
+): unknown => {
+  if (!fields || fields.length === 0) return data;
+
+  if (Array.isArray(data)) {
+    return data.map((item) => filterResultBySelection(item, fields));
+  }
+
+  if (data && typeof data === "object") {
+    const result: Record<string, unknown> = {};
+
+    for (const field of fields) {
+      const key = field.name;
+      const alias = field.alias || key;
+
+      if (key in (data as Record<string, unknown>)) {
+        const value = (data as Record<string, unknown>)[key];
+
+        if (field.selections && field.selections.length > 0) {
+          result[alias] = filterResultBySelection(value, field.selections);
+        } else {
+          result[alias] = value;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  return data;
+};

package/src/utils/sessionVariables.ts

@@ -0,0 +1,131 @@
+/**
+ * Session variable replacement utility
+ * Replaces $session.* placeholders with actual values from token claims
+ */
+
+export type SessionContext = {
+  role?: string;
+  sub?: string;
+  claims?: Record<string, unknown>;
+  jti?: string;
+  iss?: string;
+  aud?: string | string[];
+  iat?: number;
+  exp?: number;
+  nbf?: number;
+  [key: string]: unknown;
+};
+
+const resolveDotPath = (obj: Record<string, unknown>, path: string): unknown => {
+  const parts = path.split(".");
+  let current: unknown = obj;
+
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+};
+
+/**
+ * Replace session variables in a filter object
+ * Converts values like "$session.userId" to actual claim values
+ * Supports operator-based structure matching GraphQL where arguments
+ *
+ * @param filter - Filter object with potential session variables
+ * @param session - JWT payload containing user session data
+ * @returns Filter object with session variables replaced
+ *
+ * @example
+ * ```typescript
+ * const filter = {
+ *   userId: { eq: "$session.sub" },
+ *   age: { gte: 18, lt: 65 },
+ *   organizationId: { eq: "$session.organizationId" }
+ * };
+ * const session = { sub: "123", organizationId: "org-456" };
+ * const result = replaceSessionVariables(filter, session);
+ * // result: { userId: { eq: "123" }, age: { gte: 18, lt: 65 }, organizationId: { eq: "org-456" } }
+ * ```
+ */
+export const replaceSessionVariables = (
+  filter: Record<string, unknown>,
+  session: SessionContext | null,
+): Record<string, unknown> => {
+  if (!filter || !session) {
+    return filter;
+  }
+
+  const result: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(filter)) {
+    // Handle operator-based structure (e.g., { eq: "$session.sub", gt: 10 })
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const operatorObj = value as Record<string, unknown>;
+      const processedOperators: Record<string, unknown> = {};
+
+      for (const [operator, operatorValue] of Object.entries(operatorObj)) {
+        // Replace session variables in operator values
+        if (typeof operatorValue === "string" && operatorValue.startsWith("$session.")) {
+          const claimPath = operatorValue.substring(9);
+          const sessionValue = resolveDotPath(session, claimPath);
+
+          if (sessionValue === undefined) {
+            throw new Error(
+              `Session variable ${operatorValue} not found in JWT claims. Available claims: ${Object.keys(session).join(", ")}`,
+            );
+          }
+
+          processedOperators[operator] = sessionValue;
+        }
+        // Recursively handle nested objects
+        else if (
+          typeof operatorValue === "object" &&
+          operatorValue !== null &&
+          !Array.isArray(operatorValue)
+        ) {
+          processedOperators[operator] = replaceSessionVariables(
+            operatorValue as Record<string, unknown>,
+            session,
+          );
+        }
+        // Keep other values as-is
+        else {
+          processedOperators[operator] = operatorValue;
+        }
+      }
+
+      result[key] = processedOperators;
+    }
+    // Keep other values as-is
+    else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Check if a filter contains session variables
+ * Supports both simple values and operator-based structure
+ *
+ * @param filter - Filter object to check
+ * @returns true if filter contains $session.* variables
+ */
+export const hasSessionVariables = (filter: Record<string, unknown>): boolean => {
+  for (const value of Object.values(filter)) {
+    if (typeof value === "string" && value.startsWith("$session.")) {
+      return true;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      if (hasSessionVariables(value as Record<string, unknown>)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};

package/src/utils/writeSchema.ts

@@ -0,0 +1,13 @@
+import { format } from "oxfmt";
+
+import type { AnalyzedConfiguration } from "../configuration/index.ts";
+
+export const writeSchema = async (
+  roles: AnalyzedConfiguration["roles"],
+  outputDir: string,
+): Promise<void> => {
+  Object.entries(roles).forEach(async ([role, schema]) => {
+    const { code } = await format("schema.graphql", schema.typeDefs);
+    await Bun.write(`${outputDir}/schema_${role}.graphql`, code);
+  });
+};

package/standalone.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+import { parseArgs } from "node:util";
+
+// Minimal arg parsing so standalone.ts works both as a cluster worker
+// (args forwarded by cli.ts) and as a direct invocation.
+const { values } = parseArgs({
+  args: Bun.argv.slice(2),
+  options: {
+    config: { type: "string", short: "c" },
+    port: { type: "string", short: "p" },
+    "reuse-port": { type: "boolean" },
+  },
+  strict: true,
+  allowPositionals: true,
+});
+
+// Set CLI overrides on process.env BEFORE importing server code,
+// so EnvZod.parse(process.env) picks them up through the existing Zod pipeline.
+if (values.config) process.env.CONFIGURATION = values.config;
+if (values.port) process.env.PORT = values.port;
+
+const { createHandlers } = await import("./src/index.ts");
+
+const { serverHandlers } = await createHandlers();
+
+const server = Bun.serve({
+  ...serverHandlers,
+  reusePort: values["reuse-port"] ?? false,
+});
+
+const { logger } = await import("./src/logging/index.ts");
+logger("graphoria").info({ port: server.port }, "server ready");