@graphoria/server 0.1.0

package/src/types/zod/auth.ts

@@ -0,0 +1,96 @@
+import { isString } from "es-toolkit";
+
+import { AuthConfigZod } from "../../config";
+import type { TableFilter } from "../configuration";
+
+// Re-export base types and schemas from the config module
+export type {
+  DirectionUnion,
+  OrderByClause,
+  FilterCondition,
+  TablePermission,
+  RolePermission,
+  AuthConfig,
+} from "../../config";
+
+export {
+  DirectionUnionZod,
+  OrderByClauseZod,
+  FilterConditionZod,
+  TablePermissionZod,
+  RolePermissionZod,
+  AuthConfigZod,
+} from "../../config";
+
+// ============================================================================
+// Permissions Normalization Transform
+// ============================================================================
+
+type TablePermissionsDictionary = Record<
+  string,
+  {
+    columns: "ALL" | string[];
+  } & TableFilter
+>;
+
+/**
+ * Auth schema with permissions-dictionary normalization.
+ * The transform normalizes tables from the three accepted input forms
+ * (string[], "ALL", Record<string, "ALL" | TablePermission>) into a single
+ * consistent runtime shape: either "ALL" or Record<string, { columns, ... }>.
+ */
+export const AuthZod = AuthConfigZod.transform((val) => {
+  if (!val) return undefined;
+
+  return {
+    ...val,
+    permissions: Object.fromEntries(
+      Object.entries(val.permissions).map(([role, perms]) => {
+        let tablesComputed: "ALL" | TablePermissionsDictionary = {};
+
+        if (isString(perms.tables) && perms.tables === "ALL") {
+          tablesComputed = "ALL";
+        } else if (Array.isArray(perms.tables)) {
+          tablesComputed = perms.tables.reduce<TablePermissionsDictionary>(
+            (acc, table) => ({
+              ...acc,
+              [table.toLowerCase()]: { columns: "ALL" },
+            }),
+            {},
+          );
+        } else if (typeof perms.tables === "object" && perms.tables !== null) {
+          tablesComputed = Object.fromEntries(
+            Object.entries(perms.tables).map(([table, tablePerms]) => {
+              if (isString(tablePerms) && tablePerms === "ALL") {
+                return [table.toLowerCase(), { columns: "ALL" }];
+              } else if (
+                typeof tablePerms === "object" &&
+                tablePerms !== null &&
+                "columns" in tablePerms
+              ) {
+                return [
+                  table.toLowerCase(),
+                  {
+                    columns: tablePerms.columns,
+                    filter: tablePerms.filter,
+                    orderBy: tablePerms.orderBy,
+                  },
+                ];
+              } else {
+                return [table.toLowerCase(), { columns: "ALL" }];
+              }
+            }),
+          );
+        }
+
+        return [
+          role,
+          {
+            ...perms,
+            tables: tablesComputed,
+          },
+        ];
+      }),
+    ),
+  };
+});

package/src/types/zod/configuration.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+import { TokenStrategyZod } from "../../config";
+import { AIZod } from "./ai";
+import { AuthZod } from "./auth";
+import { TypedCronJobZod } from "./cron";
+import { DatabaseConnectionZod } from "./db";
+import { OperationsZod } from "./operation";
+import { QueueConfigZod } from "./queue";
+import { RemoteRESTConfigZod } from "./remoteREST";
+import { RemoteSchemaConfigZod } from "./remoteSchema";
+
+export const ConfigurationZod = z
+  .object({
+    name: z.string(),
+    version: z.string(),
+    tokenStrategy: TokenStrategyZod.optional().default("jwt"),
+    databases: z.array(DatabaseConnectionZod).default([]),
+    queues: z.array(QueueConfigZod).optional().default([]),
+    cron: z.array(TypedCronJobZod).optional().default([]),
+    operations: OperationsZod.optional().default({}),
+    auth: AuthZod,
+    remoteSchemas: z.array(RemoteSchemaConfigZod).optional().default([]),
+    remoteREST: z.array(RemoteRESTConfigZod).optional().default([]),
+    ai: AIZod.optional().default({ enabled: false, endpoint: "/ai", mcp: { enabled: false } }),
+  })
+  .refine(
+    (data) => {
+      if (!data.auth?.enabled) return true;
+
+      return data.auth?.enabled && data.databases.find((db) => db.name === data.auth?.database);
+    },
+    {
+      message: "Database to store auth information is not found",
+      path: ["auth", "database"],
+    },
+  )
+  .transform((data) => ({
+    ...data,
+    // Pre-calculate enabled databases during parsing
+    enabledDatabases: data.databases.filter((d) => d.enabled),
+    auth: {
+      ...data.auth!,
+      databaseEntity: data.databases.find((db) => db.name === data.auth!.database)!,
+    },
+  }));

package/src/types/zod/cron.ts

@@ -0,0 +1,35 @@
+import { TypedCronJobZod as BaseTypedCronJobZod } from "../../config";
+import { z } from "zod";
+
+import type { DefaultVariables, TickContext } from "../../config";
+import type { BackgroundCallbackOptions } from "../common";
+
+// Re-export definition types from config package
+export {
+  DefaultVariablesSchema,
+  createTypedCronJobZod,
+  type DefaultVariables,
+  type TickContext,
+  type TypedCronJob,
+  type CronJobType,
+} from "../../config";
+
+/**
+ * Tick callback function type - receives options object with gqlQuery and databases
+ * This is server-specific because it references runtime types (BackgroundCallbackOptions)
+ */
+export type TickCallback<TVariables = DefaultVariables> = (
+  options: BackgroundCallbackOptions,
+  context: TickContext<TVariables>,
+  response?: { data: unknown; errors?: unknown[] },
+) => Promise<void> | void;
+
+/**
+ * Server-specific Zod schema that extends the config schema with onTick callback
+ */
+export const TypedCronJobZod = BaseTypedCronJobZod.extend({
+  /**
+   * Optional callback function executed on each tick
+   */
+  onTick: z.custom<TickCallback>().optional(),
+});

package/src/types/zod/db.ts

@@ -0,0 +1,146 @@
+import { z } from "zod";
+
+import {
+  BunSQLConnectionOptionsZod,
+  DatabaseConnectionZod,
+  DatabaseSchemaConfigZod,
+  MSSQLConnectionOptionsZod,
+  TableRelationshipZod as TableRelationshipBaseZod,
+} from "../../config";
+import { genResolverName } from "../../databases/transformers/genResolverName";
+
+// Re-export base types and schemas from the config module
+export type {
+  BunSQLConnectionOptions,
+  DatabaseConfig,
+  DatabaseConnection,
+  DatabaseSchemaConfig,
+  DatabaseType,
+  MSSQLConnectionOptions,
+  TableRelationship,
+  TableSchemaConfig,
+} from "../../config";
+
+export {
+  BunSQLConnectionOptionsZod,
+  DatabaseConnectionZod,
+  DatabaseSchemaConfigZod,
+  MSSQLConnectionOptionsZod,
+  VirtualColumnZod,
+} from "../../config";
+
+/**
+ * Base column schema from database queries.
+ * Handles the isNullable type conversion (number to boolean) that different databases return.
+ */
+export const TableColumnZod = z
+  .object({
+    name: z.string(),
+    dataType: z.string(),
+    isNullable: z.union([z.boolean(), z.number()]),
+    description: z.string().nullable().optional(),
+  })
+  .transform((val) => ({
+    name: val.name,
+    dataType: val.dataType,
+    isNullable: typeof val.isNullable === "boolean" ? val.isNullable : val.isNullable === 1,
+    description: val.description ?? null,
+  }));
+
+/**
+ * Table relationship schema with computed dashedName property.
+ * Extends the base config schema with a dashedName transform for introspection use.
+ */
+export const TableRelationshipEnhancedZod = TableRelationshipBaseZod.transform((rel) => ({
+  ...rel,
+  dashedName: `${rel.schema}_${rel.name}`,
+}));
+
+/**
+ * Base table schema from database queries (before enhancement).
+ * Contains raw database structure.
+ */
+export const TableBaseZod = z.object({
+  schema: z.string(),
+  name: z.string(),
+  entityType: z.union([z.literal("table"), z.literal("view")]),
+  tableDescription: z.string().nullable().optional(),
+  columns: z.array(TableColumnZod),
+  foreignKeys: z.array(TableRelationshipEnhancedZod),
+});
+
+/**
+ * Enrichment function that adds computed properties to tables.
+ * Called during Zod transformation.
+ */
+export const enrichTable = (table: z.output<typeof TableBaseZod>) => ({
+  ...table,
+  dashedName: `${table.schema}_${table.name}`,
+  dashedNameLS: `${table.schema}_${table.name}`.toLowerCase(),
+  dottedName: `${table.schema}.${table.name}`,
+  dottedQuotedName: `"${table.schema}"."${table.name}"`,
+  schemaName: genResolverName(table.schema, table.name, table.entityType),
+});
+
+/**
+ * Table schema with enriched properties (dashedName, dottedName, etc.).
+ * This is the primary table type used throughout the application.
+ */
+export const TableZod = TableBaseZod.transform(enrichTable);
+
+/**
+ * Stored procedure parameter schema.
+ */
+export const StoredProcedureParameterZod = z.object({
+  name: z.string(),
+  dataType: z.string().nullable(),
+  maxLength: z.number(),
+  precision: z.number(),
+  scale: z.number(),
+});
+
+/**
+ * Base stored procedure schema from database queries (before enhancement).
+ * Contains raw database structure.
+ */
+export const StoredProcedureBaseZod = z.object({
+  schema: z.string(),
+  name: z.string(),
+  signature: z.string().optional(),
+  type: z.string().optional(),
+  parameters: z.array(StoredProcedureParameterZod),
+});
+
+/**
+ * Stored procedure schema with enriched naming properties.
+ * Adds dashedName, dottedName, and other computed fields for consistent naming across the app.
+ * Uses signature for unique identification when function overloading exists.
+ */
+export const StoredProcedureZod = StoredProcedureBaseZod.transform((sp) => {
+  const signatureSuffix = sp.signature ? `_${sp.signature.replace(/[^a-zA-Z0-9]/g, "_")}` : "";
+  const signatureSuffixClean = signatureSuffix.replace(/_+/g, "_").replace(/_$/, "");
+  return {
+    ...sp,
+    dashedName: `${sp.schema}_${sp.name}${signatureSuffixClean}`,
+    dashedNameLS: `${sp.schema}_${sp.name}${signatureSuffixClean}`.toLowerCase(),
+    dottedName: `${sp.schema}.${sp.name}`,
+    dottedQuotedName: `"${sp.schema}"."${sp.name}"`,
+    schemaName: genResolverName(sp.schema, sp.name + signatureSuffixClean, "sp"),
+  };
+});
+
+/**
+ * Database structure schema returned from database queries.
+ * Contains both tables and stored procedures with their enriched properties.
+ */
+export const DatabaseStructureZod = z.object({
+  tables: z.array(TableZod).default([]),
+  storedProcedures: z.array(StoredProcedureZod).default([]),
+});
+
+// View schema
+export const ViewZod = z.object({
+  schema: z.string(),
+  name: z.string(),
+  definition: z.string(),
+});

package/src/types/zod/mcp.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+import { MCPZod } from "../../config/types/ai";
+
+export { MCPZod };
+
+/** Runtime (z.output) type for MCP configuration */
+export type MCPConfig = z.output<typeof MCPZod>;

package/src/types/zod/operation.ts

@@ -0,0 +1,37 @@
+import type { BackgroundCallbackOptions } from "../common";
+
+// Re-export base types from the config module
+export type {
+  DefaultInput,
+  BeforeRequestContext,
+  AfterRequestContext,
+  OperationRestConfig,
+  OperationGraphQLConfig,
+  OperationCacheConfig,
+  OperationInitHook,
+  OperationBeforeRequestHook,
+  OperationAfterRequestHook,
+  OperationHandler,
+  BaseOperation,
+  QueryOperation,
+  HandlerOperation,
+  TypedOperation,
+  GqlQueryResult,
+  Operation,
+  Operations,
+} from "../../config";
+
+// Re-export Zod schemas from config
+export {
+  OperationRestConfigZod,
+  OperationGraphQLConfigZod,
+  OperationCacheConfigZod,
+  OperationZod,
+  OperationsZod,
+} from "../../config";
+
+/**
+ * Options passed to operation handlers and hooks
+ * This is the runtime version with fully typed Bun-specific options
+ */
+export type OperationOptions<TRepository = unknown> = BackgroundCallbackOptions<TRepository>;

package/src/types/zod/queue.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+
+import {
+  BaseQueueConfigZod,
+  KafkaConnectionZod,
+  PublisherConfigZod,
+  RabbitMQConnectionZod,
+  ReconnectConfigZod,
+  SubscriberConfigZod,
+  TopicConfigZod,
+} from "../../config";
+import type { CacheContext, SubscriberHandler } from "../../config";
+
+// Re-export base types and schemas from the config module
+export type {
+  ReconnectConfig,
+  PublisherConfig,
+  SubscriberConfig,
+  TopicConfig,
+  CacheContext,
+  SubscriberHandler,
+  RabbitMQConnection,
+  KafkaConnection,
+} from "../../config";
+
+export {
+  ReconnectConfigZod,
+  PublisherConfigZod,
+  SubscriberConfigZod,
+  TopicConfigZod,
+  BaseQueueConfigZod,
+  RabbitMQConnectionZod,
+  KafkaConnectionZod,
+} from "../../config";
+
+// ============================================================================
+// RabbitMQ Configuration (extends base)
+// ============================================================================
+
+const RabbitMQConfigZod = BaseQueueConfigZod.extend({
+  type: z.literal("rabbitmq"),
+  /** Connection config or AMQP URL string */
+  connection: z.union([z.url(), RabbitMQConnectionZod]),
+});
+
+// ============================================================================
+// Kafka Configuration (extends base)
+// ============================================================================
+
+const KafkaConfigZod = BaseQueueConfigZod.extend({
+  type: z.literal("kafka"),
+  /** Connection config or broker string "host:port" */
+  connection: z.union([z.string(), KafkaConnectionZod]),
+});
+
+// ============================================================================
+// Union Type with Transform for Backward Compatibility
+// ============================================================================
+
+/**
+ * Transforms user-facing flat config (publishers/subscribers/topics) into
+ * the internal runtime shape with derived exchanges[] and queues[] arrays.
+ */
+const transformQueueConfig = <T extends z.infer<typeof BaseQueueConfigZod>>(
+  config: T,
+): T & {
+  exchanges: Array<{
+    name: string;
+    type: "topic" | "direct" | "fanout" | "headers";
+    options?: { durable?: boolean; autoDelete?: boolean };
+    publishers: Array<{
+      name: string;
+      resolverName: string;
+      routingKey: string;
+      options?: { persistent?: boolean; headers?: Record<string, string> };
+    }>;
+  }>;
+  queues: Array<{
+    name: string;
+    queue?: string;
+    groupId?: string;
+    bindings: Array<{ exchange: string; pattern: string }>;
+    queueOptions?: { durable?: boolean; autoDelete?: boolean };
+    handler?: SubscriberHandler;
+  }>;
+} => {
+  // Group publishers by topic to create exchanges
+  const topicPublishers = new Map<
+    string,
+    Array<{ key: string; config: (typeof config.publishers)[string] }>
+  >();
+
+  Object.entries(config.publishers).forEach(([key, pub]) => {
+    const existing = topicPublishers.get(pub.topic) || [];
+    existing.push({ key, config: pub });
+    topicPublishers.set(pub.topic, existing);
+  });
+
+  // Create exchanges from topics
+  const exchanges = Array.from(topicPublishers.entries()).map(([topic, pubs]) => {
+    const topicConfig = config.topics[topic];
+    return {
+      name: topic,
+      type: topicConfig?.type || ("topic" as const),
+      options: topicConfig
+        ? { durable: topicConfig.durable, autoDelete: topicConfig.autoDelete }
+        : undefined,
+      publishers: pubs.map((p) => ({
+        name: p.key,
+        resolverName: `${config.name}_${p.key}`,
+        routingKey: p.config.routingKey || "",
+        options: {
+          persistent: p.config.persistent,
+          headers: p.config.headers,
+        },
+      })),
+    };
+  });
+
+  // Create queues from subscribers
+  const queues = Object.entries(config.subscribers).map(([key, sub]) => ({
+    name: key,
+    queue: sub.queue,
+    groupId: sub.group,
+    bindings: [{ exchange: sub.topic, pattern: sub.pattern }],
+    queueOptions: {
+      durable: sub.durable,
+      autoDelete: sub.autoDelete,
+    },
+    handler: sub.handler,
+  }));
+
+  return {
+    ...config,
+    exchanges,
+    queues,
+  };
+};
+
+const RabbitMQConfigTransformed = RabbitMQConfigZod.transform(transformQueueConfig);
+const KafkaConfigTransformed = KafkaConfigZod.transform(transformQueueConfig);
+
+export const QueueConfigZod = z.discriminatedUnion("type", [
+  RabbitMQConfigTransformed,
+  KafkaConfigTransformed,
+]);
+
+export type QueueConfig = z.infer<typeof QueueConfigZod>;
+export type RabbitMQConfig = z.infer<typeof RabbitMQConfigTransformed>;
+export type KafkaConfig = z.infer<typeof KafkaConfigTransformed>;
+
+/** Pre-transform input types — the shape users write in graphoria.ts */
+export type RabbitMQConfigInput = z.input<typeof RabbitMQConfigTransformed>;
+export type KafkaConfigInput = z.input<typeof KafkaConfigTransformed>;
+
+// ============================================================================
+// Transform helpers — Convert simplified config to internal format
+// ============================================================================
+
+/**
+ * Derives unique topics from publishers and subscribers
+ */
+export const deriveTopics = (config: QueueConfig): string[] => {
+  const topics = new Set<string>();
+
+  Object.values(config.publishers).forEach((pub) => topics.add(pub.topic));
+  Object.values(config.subscribers).forEach((sub) => topics.add(sub.topic));
+
+  return Array.from(topics);
+};
+
+/**
+ * Get publisher resolver name
+ */
+export const getPublisherResolverName = (queueName: string, publisherKey: string): string =>
+  `${queueName}_${publisherKey}`;
+
+/**
+ * Get subscriber resolver name
+ */
+export const getSubscriberResolverName = (queueName: string, subscriberKey: string): string =>
+  `${queueName}_${subscriberKey}`;

package/src/types/zod/remoteREST.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+import { RemoteRESTConfigZod } from "../../config/types/remote-rest";
+
+export { RemoteRESTConfigZod };
+
+/** Runtime (z.output) type for remote REST config */
+export type RemoteRESTConfig = z.output<typeof RemoteRESTConfigZod>;

package/src/types/zod/remoteSchema.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+import {
+  RemoteSchemaConfigZod,
+  RemoteSchemaIntrospectionConfigZod,
+} from "../../config/types/remote-schema";
+
+export { RemoteSchemaConfigZod, RemoteSchemaIntrospectionConfigZod };
+
+/** Runtime (z.output) type for remote schema config */
+export type RemoteSchemaConfig = z.output<typeof RemoteSchemaConfigZod>;

package/src/utils/benchmark.ts

@@ -0,0 +1,13 @@
+import { logger } from "../logging";
+
+export const benchmark = async <T>(fn: () => Promise<T>): Promise<T> => {
+  const start = Bun.nanoseconds();
+
+  const result = await fn();
+
+  const finish = Bun.nanoseconds();
+
+  logger("benchmark").debug({ durationMs: (finish - start) / 1e6 }, "execution time");
+
+  return result;
+};