ont-run 0.0.4 → 0.0.5

package/dist/src/config/types.d.ts

@@ -32,10 +32,32 @@ export interface FieldOption {
     /** Human-readable label for display */
     label: string;
 }
+/**
+ * Context passed to resolvers
+ */
+export interface ResolverContext {
+    /** Current environment name */
+    env: string;
+    /** Environment configuration */
+    envConfig: EnvironmentConfig;
+    /** Logger instance */
+    logger: {
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+        debug: (message: string, ...args: unknown[]) => void;
+    };
+    /** Access groups for the current request */
+    accessGroups: string[];
+}
+/**
+ * Resolver function signature
+ */
+export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;
 /**
  * Definition of a function in the ontology
  */
-export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string> {
+export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string, TInputs extends z.ZodType = z.ZodType<unknown>, TOutputs extends z.ZodType = z.ZodType<unknown>> {
     /** Human-readable description of what this function does */
     description: string;
     /** Which access groups can call this function */
@@ -43,11 +65,11 @@ export interface FunctionDefinition<TGroups extends string = string, TEntities e
     /** Which entities this function relates to (use empty array [] if none) */
     entities: TEntities[];
     /** Zod schema for input validation */
-    inputs: z.ZodType<unknown>;
+    inputs: TInputs;
     /** Zod schema for output validation/documentation */
-    outputs?: z.ZodType<unknown>;
-    /** Path to the resolver file (relative to ontology.config.ts) */
-    resolver: string;
+    outputs?: TOutputs;
+    /** Resolver function that handles this function's logic */
+    resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
 }
 /**
  * Result returned by the auth function
@@ -82,25 +104,3 @@ export interface OntologyConfig<TGroups extends string = string, TEntities exten
     /** Function definitions */
     functions: TFunctions;
 }
-/**
- * Context passed to resolvers
- */
-export interface ResolverContext {
-    /** Current environment name */
-    env: string;
-    /** Environment configuration */
-    envConfig: EnvironmentConfig;
-    /** Logger instance */
-    logger: {
-        info: (message: string, ...args: unknown[]) => void;
-        warn: (message: string, ...args: unknown[]) => void;
-        error: (message: string, ...args: unknown[]) => void;
-        debug: (message: string, ...args: unknown[]) => void;
-    };
-    /** Access groups for the current request */
-    accessGroups: string[];
-}
-/**
- * Resolver function signature
- */
-export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;

package/dist/src/index.d.ts

@@ -5,6 +5,7 @@
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { hello } from './resolvers/hello.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -23,13 +24,13 @@
  *       access: ['public'],
  *       entities: [],
  *       inputs: z.object({ name: z.string() }),
- *       resolver: './resolvers/hello.ts',
+ *       resolver: hello,  // Direct function reference for type safety
  *     },
  *   },
  * });
  * ```
  */
-export { defineOntology } from "./config/define.js";
+export { defineOntology, defineFunction } from "./config/define.js";
 export { fieldFrom, userContext } from "./config/categorical.js";
 export { startOnt } from "./server/start.js";
 export type { StartOntOptions, StartOntResult } from "./server/start.js";

package/dist/src/server/api/index.d.ts

@@ -4,8 +4,6 @@ import { type OntologyVariables } from "./middleware.js";
 export interface ApiServerOptions {
     /** The ontology configuration */
     config: OntologyConfig;
-    /** Directory containing the ontology.config.ts (for resolving resolver paths) */
-    configDir: string;
     /** Environment to use (e.g., 'dev', 'prod') */
     env: string;
     /** Enable CORS (default: true) */

package/dist/src/server/api/router.d.ts

@@ -4,7 +4,7 @@ import { type OntologyVariables } from "./middleware.js";
 /**
  * Create API routes from function definitions
  */
-export declare function createApiRoutes(config: OntologyConfig, configDir: string): Hono<{
+export declare function createApiRoutes(config: OntologyConfig): Hono<{
     Variables: OntologyVariables;
 }>;
 /**

package/dist/src/server/mcp/index.d.ts

@@ -3,8 +3,6 @@ import type { OntologyConfig } from "../../config/types.js";
 export interface McpServerOptions {
     /** The ontology configuration */
     config: OntologyConfig;
-    /** Directory containing the ontology.config.ts */
-    configDir: string;
     /** Environment to use */
     env: string;
     /** Port for the MCP HTTP server */

package/dist/src/server/mcp/tools.d.ts

@@ -1,5 +1,5 @@
 import type { OntologyConfig, EnvironmentConfig, AuthResult } from "../../config/types.js";
-import { type Logger } from "../resolver.js";
+import type { Logger } from "../resolver.js";
 /**
  * Field reference info for MCP tools
  */
@@ -32,4 +32,4 @@ export declare function filterToolsByAccess(tools: McpTool[], accessGroups: stri
 /**
  * Create a tool executor function that accepts per-request auth result
  */
-export declare function createToolExecutor(config: OntologyConfig, configDir: string, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;
+export declare function createToolExecutor(config: OntologyConfig, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;

package/dist/src/server/resolver.d.ts

@@ -1,20 +1,9 @@
-import type { ResolverFunction, OntologyConfig } from "../config/types.js";
+import type { ResolverFunction } from "../config/types.js";
 /**
- * Load a resolver from a file path.
- * The path is relative to the config file location.
- *
- * @param resolverPath - Path to the resolver file (relative to configDir)
- * @param configDir - Directory containing the ontology.config.ts
+ * Get a resolver function. Since resolvers are now passed directly as functions,
+ * this is a simple passthrough that could be removed in the future.
  */
-export declare function loadResolver(resolverPath: string, configDir: string): Promise<ResolverFunction>;
-/**
- * Clear the resolver cache (useful for hot reloading)
- */
-export declare function clearResolverCache(): void;
-/**
- * Check which resolvers are missing and return their paths
- */
-export declare function findMissingResolvers(config: OntologyConfig, configDir: string): string[];
+export declare function loadResolver(resolver: ResolverFunction): ResolverFunction;
 /**
  * Logger type returned by createLogger
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Ontology-enforced API framework for AI coding agents",
   "type": "module",
   "bin": {

package/src/browser/server.ts

@@ -1,4 +1,6 @@
 import { Hono } from "hono";
+import { readFileSync } from "fs";
+import { basename } from "path";
 import open from "open";
 import type { OntologyConfig } from "../config/types.js";
 import type { OntologyDiff } from "../lockfile/types.js";
@@ -12,6 +14,8 @@ export interface BrowserServerOptions {
   diff?: OntologyDiff | null;
   /** Directory to write the lockfile to on approval */
   configDir?: string;
+  /** Path to the ontology.config.ts file */
+  configPath?: string;
   port?: number;
   openBrowser?: boolean;
 }
@@ -22,7 +26,7 @@ export interface BrowserServerResult {
 }
 
 export async function startBrowserServer(options: BrowserServerOptions): Promise<BrowserServerResult> {
-  const { config, diff = null, configDir, port: preferredPort, openBrowser = true } = options;
+  const { config, diff = null, configDir, configPath, port: preferredPort, openBrowser = true } = options;
 
   // Transform config to graph data and enhance with diff info
   const baseGraphData = transformToGraphData(config);
@@ -90,6 +94,26 @@ export async function startBrowserServer(options: BrowserServerOptions): Promise
       return c.json({ success: true });
     });
 
+    // API: Get raw TypeScript source
+    app.get("/api/source", (c) => {
+      if (!configPath) {
+        return c.json({ error: "Config path not available" }, 400);
+      }
+      try {
+        const source = readFileSync(configPath, "utf-8");
+        const filename = basename(configPath);
+        return c.json({ source, filename, path: configPath });
+      } catch (error) {
+        return c.json(
+          {
+            error: "Failed to read config file",
+            message: error instanceof Error ? error.message : "Unknown error",
+          },
+          500
+        );
+      }
+    });
+
     // Serve UI
     app.get("/", (c) => c.html(generateBrowserUI(graphData)));
 
@@ -705,6 +729,89 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       color: var(--change-added);
     }
 
+    /* Source View */
+    .source-view {
+      display: none;
+      grid-column: 2 / 4;
+      padding: 24px;
+      overflow-y: auto;
+      background: linear-gradient(to bottom, rgba(255, 255, 255, 0.5), rgba(231, 225, 207, 0.3));
+    }
+
+    .source-view.active {
+      display: flex;
+      flex-direction: column;
+    }
+
+    .source-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 20px;
+      background: rgba(2, 61, 96, 0.95);
+      border-radius: 12px 12px 0 0;
+      color: white;
+    }
+
+    .source-filename {
+      font-family: 'Space Mono', monospace;
+      font-size: 13px;
+      font-weight: 500;
+    }
+
+    .copy-btn {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 6px 12px;
+      background: rgba(255, 255, 255, 0.1);
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      border-radius: 6px;
+      color: white;
+      font-family: 'Space Grotesk', sans-serif;
+      font-size: 12px;
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+
+    .copy-btn:hover {
+      background: rgba(255, 255, 255, 0.2);
+    }
+
+    .copy-btn.copied {
+      background: rgba(21, 168, 168, 0.3);
+      border-color: var(--vanna-teal);
+    }
+
+    .source-code {
+      flex: 1;
+      margin: 0;
+      padding: 20px;
+      background: #1e1e1e;
+      border-radius: 0 0 12px 12px;
+      overflow: auto;
+      font-family: 'Space Mono', monospace;
+      font-size: 13px;
+      line-height: 1.6;
+      color: #d4d4d4;
+      tab-size: 2;
+    }
+
+    .source-code code {
+      display: block;
+      white-space: pre;
+    }
+
+    /* Syntax highlighting classes */
+    .source-code .keyword { color: #569cd6; }
+    .source-code .string { color: #ce9178; }
+    .source-code .number { color: #b5cea8; }
+    .source-code .comment { color: #6a9955; }
+    .source-code .function { color: #dcdcaa; }
+    .source-code .type { color: #4ec9b0; }
+    .source-code .property { color: #9cdcfe; }
+    .source-code .punctuation { color: #d4d4d4; }
+
     /* No Changes State */
     .no-changes {
       text-align: center;
@@ -1433,6 +1540,7 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       <div class="view-tabs">
         <button class="view-tab active" data-view="graph">Graph</button>
         <button class="view-tab" data-view="table">Table</button>
+        <button class="view-tab" data-view="source">Source</button>
       </div>
 
       <div class="filter-buttons" id="graphFilters">
@@ -1553,6 +1661,20 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
     <div class="table-view" id="tableView">
       <div id="tableContent"></div>
     </div>
+
+    <!-- Source View -->
+    <div class="source-view" id="sourceView">
+      <div class="source-header">
+        <span class="source-filename" id="sourceFilename">ontology.config.ts</span>
+        <button class="copy-btn" id="copySourceBtn" title="Copy to clipboard">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+          </svg>
+          Copy
+        </button>
+      </div>
+      <pre class="source-code" id="sourceCode"><code>Loading...</code></pre>
+    </div>
   </div>
 
   <!-- Review Footer -->
@@ -2429,6 +2551,7 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       const graphContainer = document.querySelector('.graph-container');
       const detailPanel = document.getElementById('detailPanel');
       const tableView = document.getElementById('tableView');
+      const sourceView = document.getElementById('sourceView');
       const graphFilters = document.getElementById('graphFilters');
       const layoutSelector = document.querySelector('.layout-selector');
 
@@ -2436,15 +2559,25 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
         graphContainer.style.display = 'block';
         detailPanel.style.display = 'block';
         tableView.classList.remove('active');
+        sourceView.classList.remove('active');
         if (graphFilters) graphFilters.style.display = 'flex';
         if (layoutSelector) layoutSelector.style.display = 'flex';
-      } else {
+      } else if (view === 'table') {
         graphContainer.style.display = 'none';
         detailPanel.style.display = 'none';
         tableView.classList.add('active');
+        sourceView.classList.remove('active');
         if (graphFilters) graphFilters.style.display = 'none';
         if (layoutSelector) layoutSelector.style.display = 'none';
         renderTableView();
+      } else if (view === 'source') {
+        graphContainer.style.display = 'none';
+        detailPanel.style.display = 'none';
+        tableView.classList.remove('active');
+        sourceView.classList.add('active');
+        if (graphFilters) graphFilters.style.display = 'none';
+        if (layoutSelector) layoutSelector.style.display = 'none';
+        loadSourceView();
       }
     }
 
@@ -2486,6 +2619,74 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       });
     }
 
+    // Source view
+    let sourceLoaded = false;
+    let sourceContent = '';
+
+    async function loadSourceView() {
+      if (sourceLoaded) return;
+
+      const codeEl = document.getElementById('sourceCode').querySelector('code');
+      const filenameEl = document.getElementById('sourceFilename');
+
+      try {
+        const res = await fetch('/api/source');
+        if (!res.ok) throw new Error('Failed to load source');
+        const data = await res.json();
+
+        sourceContent = data.source;
+        filenameEl.textContent = data.filename;
+        codeEl.innerHTML = highlightTypeScript(data.source);
+        sourceLoaded = true;
+      } catch (err) {
+        codeEl.textContent = 'Error loading source: ' + err.message;
+      }
+    }
+
+    function highlightTypeScript(code) {
+      // Escape HTML first
+      code = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+      // Comments (single and multi-line)
+      code = code.replace(/(\\/\\/.*$)/gm, '<span class="comment">$1</span>');
+      code = code.replace(/(\\/\\*[\\s\\S]*?\\*\\/)/g, '<span class="comment">$1</span>');
+
+      // Strings (double, single, and template)
+      code = code.replace(/("(?:[^"\\\\]|\\\\.)*")/g, '<span class="string">$1</span>');
+      code = code.replace(/('(?:[^'\\\\]|\\\\.)*')/g, '<span class="string">$1</span>');
+      code = code.replace(/(\`(?:[^\`\\\\]|\\\\.)*\`)/g, '<span class="string">$1</span>');
+
+      // Keywords
+      const keywords = ['import', 'export', 'from', 'const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'extends', 'new', 'this', 'true', 'false', 'null', 'undefined', 'typeof', 'instanceof', 'async', 'await', 'default', 'as', 'type', 'interface'];
+      keywords.forEach(kw => {
+        code = code.replace(new RegExp('\\\\b(' + kw + ')\\\\b', 'g'), '<span class="keyword">$1</span>');
+      });
+
+      // Numbers
+      code = code.replace(/\\b(\\d+\\.?\\d*)\\b/g, '<span class="number">$1</span>');
+
+      // Function calls
+      code = code.replace(/\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(/g, '<span class="function">$1</span>(');
+
+      return code;
+    }
+
+    // Copy source button
+    document.getElementById('copySourceBtn').addEventListener('click', async () => {
+      const btn = document.getElementById('copySourceBtn');
+      try {
+        await navigator.clipboard.writeText(sourceContent);
+        btn.classList.add('copied');
+        btn.innerHTML = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="20 6 9 17 4 12"/></svg> Copied!';
+        setTimeout(() => {
+          btn.classList.remove('copied');
+          btn.innerHTML = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg> Copy';
+        }, 2000);
+      } catch (err) {
+        console.error('Failed to copy:', err);
+      }
+    });
+
     function renderTableSection(title, items, type) {
       const changedCount = items.filter(n => n.changeStatus !== 'unchanged').length;
 

package/src/browser/transform.ts

@@ -16,7 +16,6 @@ export interface GraphNode {
   metadata: {
     inputs?: Record<string, unknown>;
     outputs?: Record<string, unknown>;
-    resolver?: string;
     functionCount?: number;
     usesUserContext?: boolean;
   };
@@ -173,7 +172,6 @@ export function transformToGraphData(config: OntologyConfig): GraphData {
       metadata: {
         inputs: safeZodToJsonSchema(fn.inputs),
         outputs: fn.outputs ? safeZodToJsonSchema(fn.outputs) : undefined,
-        resolver: fn.resolver,
         usesUserContext: usesUserContext || undefined,
       },
     });

package/src/cli/commands/review.ts

@@ -48,7 +48,7 @@ export const reviewCommand = defineCommand({
 
       // Load config
       consola.info("Loading ontology config...");
-      const { config, configDir } = await loadConfig();
+      const { config, configDir, configPath } = await loadConfig();
 
       // Compute current ontology snapshot
       const { ontology: newOntology, hash: newHash } = computeOntologyHash(config);
@@ -107,6 +107,7 @@ export const reviewCommand = defineCommand({
         config,
         diff: diff.hasChanges ? diff : null,
         configDir,
+        configPath,
       });
 
       if (diff.hasChanges) {

package/src/config/define.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import {
   OntologyConfigSchema,
   validateAccessGroups,
@@ -11,6 +12,7 @@ import type {
   EnvironmentConfig,
   EntityDefinition,
   AuthFunction,
+  ResolverFunction,
 } from "./types.js";
 
 /**
@@ -20,6 +22,7 @@ import type {
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { getUser } from './resolvers/getUser.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -44,7 +47,7 @@ import type {
  *       access: ['public', 'admin'],
  *       entities: ['User'],
  *       inputs: z.object({ id: z.string() }),
- *       resolver: './resolvers/getUser.ts',
+ *       resolver: getUser,  // Direct function reference for type safety
  *     },
  *   },
  * });
@@ -76,3 +79,48 @@ export function defineOntology<
 
   return config as OntologyConfig<TGroups, TEntities, TFunctions>;
 }
+
+/**
+ * Define a function with full type inference for resolver type safety.
+ *
+ * This helper ensures that the resolver function's return type matches
+ * the outputs Zod schema at compile time.
+ *
+ * @example
+ * ```ts
+ * import { defineFunction, z } from 'ont-run';
+ * import type { ResolverContext } from 'ont-run';
+ *
+ * const getUser = defineFunction({
+ *   description: 'Get a user by ID',
+ *   access: ['public', 'admin'] as const,
+ *   entities: ['User'] as const,
+ *   inputs: z.object({ id: z.string() }),
+ *   outputs: z.object({ id: z.string(), name: z.string() }),
+ *   resolver: async (ctx, args) => {
+ *     // TypeScript knows args is { id: string }
+ *     // TypeScript enforces return type is { id: string, name: string }
+ *     return { id: args.id, name: 'Example User' };
+ *   },
+ * });
+ * ```
+ */
+export function defineFunction<
+  TGroups extends string,
+  TEntities extends string,
+  TInputs extends z.ZodType,
+  TOutputs extends z.ZodType,
+>(config: {
+  description: string;
+  access: readonly TGroups[];
+  entities: readonly TEntities[];
+  inputs: TInputs;
+  outputs?: TOutputs;
+  resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
+}): FunctionDefinition<TGroups, TEntities, TInputs, TOutputs> {
+  return {
+    ...config,
+    access: [...config.access],
+    entities: [...config.entities],
+  };
+}

package/src/config/schema.ts

@@ -53,7 +53,7 @@ export const FunctionDefinitionSchema = z.object({
       message: "outputs must be a Zod schema",
     })
     .optional(),
-  resolver: z.string(),
+  resolver: z.function(),
 });
 
 /**

package/src/config/types.ts

@@ -37,12 +37,41 @@ export interface FieldOption {
   label: string;
 }
 
+/**
+ * Context passed to resolvers
+ */
+export interface ResolverContext {
+  /** Current environment name */
+  env: string;
+  /** Environment configuration */
+  envConfig: EnvironmentConfig;
+  /** Logger instance */
+  logger: {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+  };
+  /** Access groups for the current request */
+  accessGroups: string[];
+}
+
+/**
+ * Resolver function signature
+ */
+export type ResolverFunction<TArgs = unknown, TResult = unknown> = (
+  ctx: ResolverContext,
+  args: TArgs
+) => Promise<TResult> | TResult;
+
 /**
  * Definition of a function in the ontology
  */
 export interface FunctionDefinition<
   TGroups extends string = string,
   TEntities extends string = string,
+  TInputs extends z.ZodType = z.ZodType<unknown>,
+  TOutputs extends z.ZodType = z.ZodType<unknown>,
 > {
   /** Human-readable description of what this function does */
   description: string;
@@ -51,11 +80,11 @@ export interface FunctionDefinition<
   /** Which entities this function relates to (use empty array [] if none) */
   entities: TEntities[];
   /** Zod schema for input validation */
-  inputs: z.ZodType<unknown>;
+  inputs: TInputs;
   /** Zod schema for output validation/documentation */
-  outputs?: z.ZodType<unknown>;
-  /** Path to the resolver file (relative to ontology.config.ts) */
-  resolver: string;
+  outputs?: TOutputs;
+  /** Resolver function that handles this function's logic */
+  resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
 }
 
 /**
@@ -105,30 +134,3 @@ export interface OntologyConfig<
   /** Function definitions */
   functions: TFunctions;
 }
-
-/**
- * Context passed to resolvers
- */
-export interface ResolverContext {
-  /** Current environment name */
-  env: string;
-  /** Environment configuration */
-  envConfig: EnvironmentConfig;
-  /** Logger instance */
-  logger: {
-    info: (message: string, ...args: unknown[]) => void;
-    warn: (message: string, ...args: unknown[]) => void;
-    error: (message: string, ...args: unknown[]) => void;
-    debug: (message: string, ...args: unknown[]) => void;
-  };
-  /** Access groups for the current request */
-  accessGroups: string[];
-}
-
-/**
- * Resolver function signature
- */
-export type ResolverFunction<TArgs = unknown, TResult = unknown> = (
-  ctx: ResolverContext,
-  args: TArgs
-) => Promise<TResult> | TResult;