ont-run 0.0.4 → 0.0.5

package/src/index.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,7 +24,7 @@
  *       access: ['public'],
  *       entities: [],
  *       inputs: z.object({ name: z.string() }),
- *       resolver: './resolvers/hello.ts',
+ *       resolver: hello,  // Direct function reference for type safety
  *     },
  *   },
  * });
@@ -31,7 +32,7 @@
  */
 
 // Main API
-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/src/server/api/index.ts

@@ -1,6 +1,5 @@
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import consola from "consola";
 import type { OntologyConfig } from "../../config/types.js";
 import {
   createAuthMiddleware,
@@ -9,13 +8,10 @@ import {
   type OntologyVariables,
 } from "./middleware.js";
 import { createApiRoutes, getFunctionsInfo } from "./router.js";
-import { findMissingResolvers } from "../resolver.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) */
@@ -26,7 +22,7 @@ export interface ApiServerOptions {
  * Create the Hono API app from an OntologyConfig
  */
 export function createApiApp(options: ApiServerOptions): Hono<{ Variables: OntologyVariables }> {
-  const { config, configDir, env, cors: enableCors = true } = options;
+  const { config, env, cors: enableCors = true } = options;
 
   // Get environment config
   const envConfig = config.environments[env];
@@ -36,15 +32,6 @@ export function createApiApp(options: ApiServerOptions): Hono<{ Variables: Ontol
     );
   }
 
-  // Check for missing resolvers
-  const missingResolvers = findMissingResolvers(config, configDir);
-  if (missingResolvers.length > 0) {
-    consola.warn(`Missing resolvers (${missingResolvers.length}):`);
-    for (const resolver of missingResolvers) {
-      consola.warn(`  - ${resolver}`);
-    }
-  }
-
   const app = new Hono<{ Variables: OntologyVariables }>();
 
   // Global middleware
@@ -83,7 +70,7 @@ export function createApiApp(options: ApiServerOptions): Hono<{ Variables: Ontol
   });
 
   // Mount function routes under /api
-  const apiRoutes = createApiRoutes(config, configDir);
+  const apiRoutes = createApiRoutes(config);
   app.route("/api", apiRoutes);
 
   return app;

package/src/server/api/router.ts

@@ -1,6 +1,5 @@
 import { Hono } from "hono";
 import type { OntologyConfig, FunctionDefinition } from "../../config/types.js";
-import { loadResolver } from "../resolver.js";
 import { getUserContextFields } from "../../config/categorical.js";
 import {
   createAccessControlMiddleware,
@@ -11,8 +10,7 @@ import {
  * Create API routes from function definitions
  */
 export function createApiRoutes(
-  config: OntologyConfig,
-  configDir: string
+  config: OntologyConfig
 ): Hono<{ Variables: OntologyVariables }> {
   const router = new Hono<{ Variables: OntologyVariables }>();
 
@@ -83,10 +81,9 @@ export function createApiRoutes(
           args = parsed.data;
         }
 
-        // Load and execute resolver
+        // Execute resolver
         try {
-          const resolver = await loadResolver(fn.resolver, configDir);
-          const result = await resolver(resolverContext, args);
+          const result = await fn.resolver(resolverContext, args);
           return c.json(result);
         } catch (error) {
           console.error(`Error in resolver ${name}:`, error);

package/src/server/mcp/index.ts

@@ -39,8 +39,6 @@ function getAuthResult(authInfo?: AuthInfo): AuthResult {
 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 */
@@ -51,7 +49,7 @@ export interface McpServerOptions {
  * Create the MCP server instance with per-request authentication
  */
 export function createMcpServer(options: McpServerOptions): Server {
-  const { config, configDir, env } = options;
+  const { config, env } = options;
 
   // Get environment config
   const envConfig = config.environments[env];
@@ -67,7 +65,7 @@ export function createMcpServer(options: McpServerOptions): Server {
   const allTools = generateMcpTools(config);
 
   // Create tool executor factory that accepts per-request access groups
-  const executeToolWithAccess = createToolExecutor(config, configDir, env, envConfig, logger);
+  const executeToolWithAccess = createToolExecutor(config, env, envConfig, logger);
 
   // Create MCP server
   const server = new Server(

package/src/server/mcp/tools.ts

@@ -8,7 +8,7 @@ import type {
   AuthResult,
 } from "../../config/types.js";
 import { getFieldFromMetadata, getUserContextFields, hasUserContextMetadata } from "../../config/categorical.js";
-import { loadResolver, type Logger } from "../resolver.js";
+import type { Logger } from "../resolver.js";
 
 /**
  * Field reference info for MCP tools
@@ -198,7 +198,6 @@ export function filterToolsByAccess(
  */
 export function createToolExecutor(
   config: OntologyConfig,
-  configDir: string,
   env: string,
   envConfig: EnvironmentConfig,
   logger: Logger
@@ -253,8 +252,7 @@ export function createToolExecutor(
       accessGroups: authResult.groups,
     };
 
-    // Load and execute resolver
-    const resolver = await loadResolver(fn.resolver, configDir);
-    return resolver(resolverContext, parsed.data);
+    // Execute resolver
+    return fn.resolver(resolverContext, parsed.data);
   };
 }

package/src/server/resolver.ts

@@ -1,84 +1,11 @@
-import { join, dirname, isAbsolute } from "path";
-import { existsSync } from "fs";
-import type { ResolverFunction, ResolverContext, OntologyConfig } from "../config/types.js";
+import type { ResolverFunction } from "../config/types.js";
 
 /**
- * Cache of loaded resolvers to avoid re-importing
+ * Get a resolver function. Since resolvers are now passed directly as functions,
+ * this is a simple passthrough that could be removed in the future.
  */
-const resolverCache = new Map<string, ResolverFunction>();
-
-/**
- * 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
- */
-export async function loadResolver(
-  resolverPath: string,
-  configDir: string
-): Promise<ResolverFunction> {
-  // Resolve the full path
-  const fullPath = isAbsolute(resolverPath)
-    ? resolverPath
-    : join(configDir, resolverPath);
-
-  // Check cache
-  if (resolverCache.has(fullPath)) {
-    return resolverCache.get(fullPath)!;
-  }
-
-  try {
-    // Dynamic import the resolver
-    const module = await import(fullPath);
-
-    // Expect default export to be the resolver function
-    const resolver = module.default;
-
-    if (typeof resolver !== "function") {
-      throw new Error(
-        `Resolver at ${resolverPath} must export a default function`
-      );
-    }
-
-    // Cache and return
-    resolverCache.set(fullPath, resolver);
-    return resolver;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(`Resolver not found: ${resolverPath}`);
-    }
-    throw error;
-  }
-}
-
-/**
- * Clear the resolver cache (useful for hot reloading)
- */
-export function clearResolverCache(): void {
-  resolverCache.clear();
-}
-
-/**
- * Check which resolvers are missing and return their paths
- */
-export function findMissingResolvers(
-  config: OntologyConfig,
-  configDir: string
-): string[] {
-  const missing: string[] = [];
-
-  for (const [name, fn] of Object.entries(config.functions)) {
-    const fullPath = isAbsolute(fn.resolver)
-      ? fn.resolver
-      : join(configDir, fn.resolver);
-
-    if (!existsSync(fullPath)) {
-      missing.push(fn.resolver);
-    }
-  }
-
-  return missing;
+export function loadResolver(resolver: ResolverFunction): ResolverFunction {
+  return resolver;
 }
 
 /**

package/src/server/start.ts

@@ -121,7 +121,6 @@ export async function startOnt(options: StartOntOptions = {}): Promise<StartOntR
   if (!mcpOnly) {
     const api = createApiApp({
       config,
-      configDir,
       env,
     });
 
@@ -144,7 +143,6 @@ export async function startOnt(options: StartOntOptions = {}): Promise<StartOntR
   if (!apiOnly) {
     const mcpServer = await startMcpServer({
       config,
-      configDir,
       env,
       port: mcpPort,
     });