@graphoria/server 0.1.0

package/src/console/api.ts

@@ -0,0 +1,270 @@
+import type { AnalyzedConfiguration } from "../configuration";
+import type { Configuration } from "../types/configuration";
+import type { Env } from "../types/env";
+import type { SQL } from "bun";
+import type { ConnectionPool } from "mssql";
+
+import { getTags } from "../configuration/rest/generateOpenAPI";
+import { getCronJobs } from "../singletons/cron";
+import { databasesConnections } from "../singletons/databases";
+import { queueManager } from "../singletons/queues";
+import { S200, S400, S404 } from "../utils/responses";
+
+type ConsoleRoutesFactoryOptions = {
+  env: Env;
+  consolePath: string;
+  prefixes: Record<string, string>;
+  projectConfiguration: Configuration;
+  analyzedConfiguration: AnalyzedConfiguration;
+  getRoleHandlers: (req: Request) => Promise<{ role: string }>;
+};
+
+type ConsoleRouteHandler = (req: Request) => Response | Promise<Response>;
+
+const PING_TIMEOUT_MS = 2000;
+
+const pingConnection = (connection: SQL | ConnectionPool, type: string) =>
+  type === "mssql"
+    ? (connection as ConnectionPool).query("SELECT 1")
+    : (connection as SQL).unsafe("SELECT 1");
+
+const measureLatency = async (connection: SQL | ConnectionPool, type: string) => {
+  const start = performance.now();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      pingConnection(connection, type),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), PING_TIMEOUT_MS);
+      }),
+    ]);
+    return Math.round(performance.now() - start);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+export const consoleRoutesFactory = ({
+  env,
+  consolePath,
+  prefixes,
+  projectConfiguration,
+  analyzedConfiguration,
+  getRoleHandlers,
+}: ConsoleRoutesFactoryOptions): Record<string, Record<string, ConsoleRouteHandler>> => {
+  const guarded =
+    (handler: (req: Request) => object | Promise<object>): ConsoleRouteHandler =>
+    async (req: Request) => {
+      try {
+        const { role } = await getRoleHandlers(req);
+        if (role !== env.superadmin.role) return new S404({ error: "Not Found" });
+        return new S200(await handler(req));
+      } catch (error) {
+        return new S400({ errors: [{ message: (error as Error)?.message }] });
+      }
+    };
+
+  const cors: Record<string, ConsoleRouteHandler> = env.enableCors
+    ? { OPTIONS: () => new S200(null) }
+    : {};
+  const base = `${consolePath}/api`;
+
+  return {
+    [`${base}/meta`]: {
+      ...cors,
+      GET: () =>
+        new S200({
+          name: projectConfiguration.name,
+          version: projectConfiguration.version,
+          adminSecretHeader: env.admin.header,
+        }),
+    },
+
+    [`${base}/tables`]: {
+      ...cors,
+      GET: guarded(() => ({
+        tables: analyzedConfiguration.roles[env.superadmin.role].tables.map((table) => ({
+          schema: table.schema,
+          name: table.name,
+          entityType: table.entityType,
+          resolverName: table.resolverName,
+          description: table.tableDescription,
+          columns: table.columns.map((column) => ({
+            name: column.name,
+            dataType: column.dataType,
+            isNullable: column.isNullable,
+            description: column.description,
+          })),
+          relationships: table.relationships.map((relationship) => ({
+            schema: relationship.schema,
+            name: relationship.name,
+            columns: relationship.columns.map((column: { source: string; target: string }) => ({
+              source: column.source,
+              target: column.target,
+            })),
+          })),
+        })),
+      })),
+    },
+
+    [`${base}/roles`]: {
+      ...cors,
+      GET: guarded(() => ({
+        roles: Object.keys(analyzedConfiguration.roles),
+        permissions: analyzedConfiguration.auth?.permissions ?? {},
+      })),
+    },
+
+    [`${base}/roles/entities`]: {
+      ...cors,
+      GET: guarded((req) => {
+        const role = new URL(req.url).searchParams.get("role") ?? "";
+        const roleEntities = analyzedConfiguration.roles[role];
+        if (!roleEntities) throw new Error(`Unknown role "${role}"`);
+        return {
+          role,
+          tables: roleEntities.tables.map((table) => ({
+            schema: table.schema,
+            name: table.name,
+            columns: table.columns.map((column) => column.name),
+          })),
+          operations: Object.entries(roleEntities.operations ?? {}).map(([name, operation]) => ({
+            name,
+            method: operation.rest?.method ?? null,
+            path: operation.rest?.path ?? null,
+          })),
+          remoteSchemas: (roleEntities.remoteSchemas ?? []).map((schema) => ({
+            name: schema.config.name,
+            prefix: schema.prefix,
+            queryFields: schema.queryFields.length,
+            mutationFields: schema.mutationFields.length,
+          })),
+          remoteREST: (roleEntities.remoteRESTApis ?? []).map((api) => ({
+            name: api.config.name,
+            prefix: api.prefix,
+            routes: api.routes.length,
+          })),
+        };
+      }),
+    },
+
+    [`${base}/status`]: {
+      ...cors,
+      GET: guarded(async () => ({
+        uptimeSeconds: process.uptime(),
+        tokenStrategy: env.authStrategy ?? projectConfiguration.tokenStrategy,
+        memoryRssBytes: process.memoryUsage().rss,
+        bunVersion: Bun.version,
+        pid: process.pid,
+        databases: await Promise.all(
+          analyzedConfiguration.databases.map(async (database) => {
+            const connection = databasesConnections[database.name];
+            return {
+              name: database.name,
+              type: database.type,
+              connected: connection !== undefined,
+              latencyMs: connection ? await measureLatency(connection, database.type) : null,
+            };
+          }),
+        ),
+        publishers: Object.keys(queueManager?.publisherMap() ?? {}),
+        subscribers: (analyzedConfiguration.queues ?? []).flatMap((queue) =>
+          queue.queues.map((subscriber) => ({
+            name: subscriber.name,
+            topic: subscriber.bindings[0]?.exchange ?? "",
+          })),
+        ),
+        queueConnections: queueManager?.connections() ?? [],
+        cron: getCronJobs()?.getSummary() ?? [],
+      })),
+    },
+
+    [`${base}/apis`]: {
+      ...cors,
+      GET: guarded(() => {
+        const superadmin = analyzedConfiguration.roles[env.superadmin.role];
+        return {
+          operations: Object.entries(superadmin.operations ?? {})
+            .filter(([, operation]) => operation.rest)
+            .map(([name, operation]) => ({
+              name,
+              method: operation.rest!.method,
+              path: operation.rest!.path,
+              tag: getTags(operation.rest!.path)[0],
+            })),
+          remoteREST: (superadmin.remoteRESTApis ?? []).map((api) => ({
+            name: api.config.name,
+            prefix: api.prefix,
+            baseUrl: api.baseUrl,
+            routes: api.routes.length,
+          })),
+          remoteSchemas: (superadmin.remoteSchemas ?? []).map((schema) => ({
+            name: schema.config.name,
+            prefix: schema.prefix,
+            url: schema.config.url,
+            queryFields: schema.queryFields.length,
+            mutationFields: schema.mutationFields.length,
+          })),
+        };
+      }),
+    },
+
+    [`${base}/schema`]: {
+      ...cors,
+      GET: guarded((req) => {
+        const role = new URL(req.url).searchParams.get("role") ?? "";
+        const roleSchema = analyzedConfiguration.roles[role];
+        if (!roleSchema) throw new Error(`Unknown role "${role}"`);
+        return { role, sdl: roleSchema.typeDefs };
+      }),
+    },
+
+    [`${base}/config`]: {
+      ...cors,
+      GET: guarded(() => ({
+        name: projectConfiguration.name,
+        version: projectConfiguration.version,
+        prefixes,
+        features: {
+          auth: projectConfiguration.auth?.enabled ?? false,
+          ai: projectConfiguration.ai?.enabled ?? false,
+          mcp: projectConfiguration.ai?.mcp?.enabled ?? false,
+          cors: env.enableCors,
+        },
+      })),
+    },
+
+    [`${base}/queues/publish`]: {
+      ...cors,
+      POST: guarded(async (req) => {
+        const { publisher, message, key } = (await req.json()) as {
+          publisher?: string;
+          message?: string | object;
+          key?: string;
+        };
+        if (!publisher || message == null) throw new Error("publisher and message are required");
+        if (!Object.hasOwn(queueManager?.publisherMap() ?? {}, publisher))
+          throw new Error(`Unknown publisher "${publisher}"`);
+        return { ok: await queueManager!.sendMessage(publisher, message, key) };
+      }),
+    },
+
+    [`${base}/cron`]: {
+      ...cors,
+      POST: guarded(async (req) => {
+        const { name, action } = (await req.json()) as { name?: string; action?: string };
+        const cron = getCronJobs();
+        if (!cron) throw new Error("Cron is not enabled");
+        if (!name) throw new Error("name is required");
+        if (action !== "trigger" && action !== "pause" && action !== "resume")
+          throw new Error(`Unknown action "${action}"`);
+        if (!cron.getJob(name)) throw new Error(`Unknown job "${name}"`);
+        if (action === "trigger") await cron.trigger(name);
+        else cron[action](name);
+        return { ok: true };
+      }),
+    },
+  };
+};

package/src/cron/index.ts

@@ -0,0 +1,251 @@
+import { Cron } from "croner";
+
+import type { GqlQueryFn } from "../types/common";
+import type { CronJob } from "../types/configuration";
+import type { TickContext } from "../types/zod/cron";
+
+import { databasesConnections, repositoryMap } from "../singletons/databases";
+import { queueManager } from "../singletons/queues";
+import { logger } from "../logging";
+
+/**
+ * Interface for a scheduled cron job instance
+ */
+export interface ScheduledCronJob {
+  name: string;
+  job: Cron;
+  config: CronJob;
+  executionCount: number;
+  pause: () => boolean;
+  resume: () => boolean;
+  trigger: () => boolean;
+  stop: () => boolean;
+  getNextRun: () => Date | null;
+  getNextRuns: (count: number) => Date[];
+  getStatus: () => {
+    isRunning: boolean;
+    isStopped: boolean;
+    isBusy: boolean;
+    nextRun: Date | null;
+    previousRun: Date | null;
+    currentRun: Date | null;
+  };
+}
+
+/**
+ * Create a scheduled cron job
+ */
+const createScheduledJob = (config: CronJob, gqlQuery: GqlQueryFn<true>): ScheduledCronJob => {
+  const log = logger("cron").child({ job: config.name });
+  let executionCount = 0;
+
+  const job = new Cron(
+    config.pattern,
+    {
+      name: config.name,
+      timezone: config.timezone,
+      paused: config.paused,
+      maxRuns: config.maxRuns,
+      interval: config.interval,
+      startAt: config.startAt,
+      stopAt: config.stopAt,
+      protect: config.protect,
+      catch: config.catchErrors
+        ? (error) => {
+            log.error({ err: error }, "cron job caught error");
+          }
+        : false,
+      context: config.context,
+    },
+    async (self) => {
+      try {
+        log.info("executing");
+
+        executionCount++;
+
+        // Execute query if provided
+        const response = config.query
+          ? await gqlQuery(config.query, config.variables ?? {})
+          : undefined;
+
+        const tickContext: TickContext = {
+          name: config.name,
+          pattern: config.pattern,
+          variables: config.variables || {},
+          executionCount,
+          nextRun: self.nextRun(),
+          previousRun: self.previousRun(),
+        };
+
+        // Call the onTick callback if provided, passing options object
+        await config.onTick?.(
+          {
+            gqlQuery,
+            databases: databasesConnections,
+            queues: queueManager,
+            repository: repositoryMap,
+          },
+          tickContext,
+          response,
+        );
+
+        log.info({ executionCount, nextRun: self.nextRun() }, "completed");
+      } catch (error) {
+        log.error({ err: error }, "failed");
+        throw error;
+      }
+    },
+  );
+
+  log.info(
+    { pattern: config.pattern, nextRun: job.nextRun(), timezone: config.timezone },
+    "scheduled",
+  );
+
+  return {
+    name: config.name,
+    job,
+    config,
+    executionCount,
+    pause: () => {
+      job.pause();
+      log.info("paused");
+      return true;
+    },
+    resume: () => {
+      job.resume();
+      log.info({ nextRun: job.nextRun() }, "resumed");
+      return true;
+    },
+    trigger: () => {
+      job.trigger();
+      log.info("triggered manually");
+      return true;
+    },
+    stop: () => {
+      job.stop();
+      log.info("stopped");
+      return true;
+    },
+    getNextRun: () => job.nextRun(),
+    getNextRuns: (count: number) => job.nextRuns(count),
+    getStatus: () => ({
+      isRunning: job.isRunning(),
+      isStopped: job.isStopped(),
+      isBusy: job.isBusy(),
+      nextRun: job.nextRun(),
+      previousRun: job.previousRun(),
+      currentRun: job.currentRun(),
+    }),
+  };
+};
+
+/**
+ * Start cron connections and return management functions
+ */
+export const startCronJobs = async (jobs: CronJob[], gqlQuery: GqlQueryFn<true>) => {
+  const log = logger("cron");
+  const scheduledJobs = new Map<string, ScheduledCronJob>();
+
+  // Schedule all jobs
+  for (const jobConfig of jobs) {
+    try {
+      if (scheduledJobs.has(jobConfig.name)) {
+        log.error({ job: jobConfig.name }, "job name already exists, skipping");
+        continue;
+      }
+
+      const scheduled = createScheduledJob(jobConfig, gqlQuery);
+
+      scheduledJobs.set(jobConfig.name, scheduled);
+    } catch (error) {
+      log.error({ err: error, job: jobConfig.name }, "failed to schedule job");
+    }
+  }
+
+  return {
+    jobs: scheduledJobs,
+
+    getJob: (name: string) => scheduledJobs.get(name),
+
+    getAllJobs: () => Array.from(scheduledJobs.values()),
+
+    pause: (name: string) => {
+      const job = scheduledJobs.get(name);
+      if (!job) return false;
+      return job.pause();
+    },
+
+    resume: (name: string) => {
+      const job = scheduledJobs.get(name);
+      if (!job) return false;
+      return job.resume();
+    },
+
+    trigger: (name: string) => {
+      const job = scheduledJobs.get(name);
+      if (!job) return false;
+      return job.trigger();
+    },
+
+    stop: (name: string) => {
+      const job = scheduledJobs.get(name);
+      if (!job) return false;
+      const result = job.stop();
+      scheduledJobs.delete(name);
+      log.info({ job: name }, "removed");
+      return result;
+    },
+
+    stopAll: () => {
+      for (const [name, job] of scheduledJobs) {
+        job.stop();
+        log.info({ job: name }, "stopped");
+      }
+      scheduledJobs.clear();
+      log.info("all jobs stopped");
+    },
+
+    getNextRun: (name: string) => {
+      const job = scheduledJobs.get(name);
+      return job ? job.getNextRun() : null;
+    },
+
+    getNextRuns: (name: string, count: number) => {
+      const job = scheduledJobs.get(name);
+      return job ? job.getNextRuns(count) : [];
+    },
+
+    getStatus: (name: string) => {
+      const job = scheduledJobs.get(name);
+      if (!job) {
+        return { exists: false };
+      }
+      return {
+        exists: true,
+        ...job.getStatus(),
+      };
+    },
+
+    getSummary: () =>
+      Array.from(scheduledJobs.values()).map((job) => ({
+        name: job.name,
+        pattern: job.config.pattern,
+        executionCount: job.executionCount,
+        isRunning: job.job.isRunning(),
+        isBusy: job.job.isBusy(),
+        nextRun: job.job.nextRun(),
+      })),
+
+    schedule: (config: CronJob) => {
+      if (scheduledJobs.has(config.name)) {
+        throw new Error(`Cron job with name "${config.name}" already exists`);
+      }
+      const scheduled = createScheduledJob(config, gqlQuery);
+      scheduledJobs.set(config.name, scheduled);
+      return scheduled;
+    },
+  };
+};
+
+export type StartCronJobsReturn = Awaited<ReturnType<typeof startCronJobs>>;

package/src/databases/auth/auth-operations.ts

@@ -0,0 +1,36 @@
+import type { Auth } from "../../types/configuration";
+import type { InsertAuthUserInput } from "../core/function-mapping";
+
+import { databaseAdapters } from "../core/function-mapping";
+
+/**
+ * Authentication and authorization operations
+ */
+
+export const createAuthTables = async (auth: Auth) =>
+  databaseAdapters[auth.databaseEntity.type].createAuthTables(auth);
+
+export const getLoginFn = async (auth: Auth) =>
+  databaseAdapters[auth.databaseEntity.type].createAuthTables(auth);
+
+export const checkUserCredentials = async (auth: Auth, username: string, password: string) =>
+  databaseAdapters[auth.databaseEntity.type].checkUserCredentials(
+    auth.databaseEntity,
+    auth,
+    username,
+    password,
+  );
+
+export const insertAuthUser = async (auth: Auth, input: InsertAuthUserInput) =>
+  databaseAdapters[auth.databaseEntity.type].insertAuthUser(auth, input);
+
+export const verifyAuthTablesExist = async (auth: Auth) => {
+  try {
+    await databaseAdapters[auth.databaseEntity.type].verifyAuthTablesExist(auth);
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Auth user table not found at ${auth.schema}.user — set auth.autoCreateTables: true to provision it on boot, or run "graphoria seed-auth" after applying the schema manually. (driver: ${cause})`,
+    );
+  }
+};

package/src/databases/auth/password.ts

@@ -0,0 +1,4 @@
+export const hashPassword = (password: string) => Bun.password.hash(password);
+
+export const verifyPassword = async (plain: string, hashed: string) =>
+  Bun.password.verify(plain, hashed);