ont-run 0.0.4 → 0.0.6

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;

package/src/config/zod-utils.ts

@@ -0,0 +1,144 @@
+/**
+ * Utility functions for inspecting Zod schemas.
+ * These use duck typing to work across Zod 3 and Zod 4.
+ */
+
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries and Zod versions)
+ */
+export function isZodSchema(val: unknown): boolean {
+  if (val === null || typeof val !== "object") return false;
+  // Zod 4 uses _zod property
+  if ("_zod" in val && "safeParse" in val) return true;
+  // Zod 3 uses _def property
+  if ("_def" in val && "safeParse" in val) return true;
+  return false;
+}
+
+/**
+ * Get the Zod type name from a schema (works with both Zod 3 and 4)
+ */
+export function getZodTypeName(schema: unknown): string | undefined {
+  if (!isZodSchema(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: check _zod.def.typeName
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (typeof def.typeName === "string") return def.typeName;
+    }
+  }
+  // Zod 3: check _def.typeName
+  if (s._def && typeof s._def === "object") {
+    const def = s._def as Record<string, unknown>;
+    if (typeof def.typeName === "string") return def.typeName;
+  }
+  return undefined;
+}
+
+/**
+ * Check if schema is a ZodObject (works with both Zod 3 and 4)
+ */
+export function isZodObject(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodObject" || typeName === "object";
+}
+
+/**
+ * Check if schema is a ZodOptional (works with both Zod 3 and 4)
+ */
+export function isZodOptional(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodOptional" || typeName === "optional";
+}
+
+/**
+ * Check if schema is a ZodNullable (works with both Zod 3 and 4)
+ */
+export function isZodNullable(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodNullable" || typeName === "nullable";
+}
+
+/**
+ * Check if schema is a ZodArray (works with both Zod 3 and 4)
+ */
+export function isZodArray(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodArray" || typeName === "array";
+}
+
+/**
+ * Check if schema is a ZodDefault (works with both Zod 3 and 4)
+ */
+export function isZodDefault(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodDefault" || typeName === "default";
+}
+
+/**
+ * Get the shape of a ZodObject schema (works with both Zod 3 and 4)
+ */
+export function getObjectShape(schema: unknown): Record<string, unknown> | undefined {
+  if (!isZodObject(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: shape is in _zod.def.shape
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.shape && typeof def.shape === "object") {
+        return def.shape as Record<string, unknown>;
+      }
+    }
+  }
+  // Zod 3: shape property directly on schema
+  if (typeof s.shape === "object" && s.shape !== null) {
+    return s.shape as Record<string, unknown>;
+  }
+  return undefined;
+}
+
+/**
+ * Get the inner schema from Optional/Nullable/Default (works with both Zod 3 and 4)
+ */
+export function getInnerSchema(schema: unknown): unknown {
+  const s = schema as Record<string, unknown>;
+  // Zod 4: innerType is in _zod.def.innerType
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.innerType) return def.innerType;
+    }
+  }
+  // Zod 3: unwrap method or _def.innerType
+  if (typeof s.unwrap === "function") {
+    return (s.unwrap as () => unknown)();
+  }
+  if (s._def && typeof s._def === "object") {
+    const def = s._def as Record<string, unknown>;
+    if (def.innerType) return def.innerType;
+  }
+  return undefined;
+}
+
+/**
+ * Get the element schema from a ZodArray (works with both Zod 3 and 4)
+ */
+export function getArrayElement(schema: unknown): unknown {
+  if (!isZodArray(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: element is in _zod.def.element
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.element) return def.element;
+    }
+  }
+  // Zod 3: element property directly on schema
+  if (s.element) return s.element;
+  return undefined;
+}

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/lockfile/hasher.ts

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import type { OntologyConfig } from "../config/types.js";
 import { getFieldFromMetadata, getUserContextFields } from "../config/categorical.js";
+import {
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "../config/zod-utils.js";
 import type {
   OntologySnapshot,
   FunctionShape,
@@ -28,34 +37,48 @@ function extractFieldReferences(
   }
 
   // Handle ZodObject - recurse into properties
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
   // Handle ZodOptional - unwrap
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodNullable - unwrap
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodArray - recurse into element
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldReferences(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldReferences(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
   // Handle ZodDefault - unwrap
-  if (schema instanceof z.ZodDefault) {
-    results.push(...extractFieldReferences(schema._def.innerType, path));
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;
@@ -85,14 +108,14 @@ export function extractOntology(config: OntologyConfig): OntologySnapshot {
     // This ensures we're comparing the shape, not the Zod instance
     let inputsSchema: Record<string, unknown>;
     try {
-      inputsSchema = zodToJsonSchema(fn.inputs, {
-        // Remove $schema to make hashing more stable
-        $refStrategy: "none",
+      inputsSchema = z.toJSONSchema(fn.inputs, {
+        reused: "inline",
+        unrepresentable: "any",
       }) as Record<string, unknown>;
       // Remove $schema key if present
       delete inputsSchema.$schema;
     } catch {
-      // If zodToJsonSchema fails, use a placeholder
+      // If z.toJSONSchema fails, use a placeholder
       inputsSchema = { type: "unknown" };
     }
 
@@ -100,8 +123,9 @@ export function extractOntology(config: OntologyConfig): OntologySnapshot {
     let outputsSchema: Record<string, unknown> | undefined;
     if (fn.outputs) {
       try {
-        outputsSchema = zodToJsonSchema(fn.outputs, {
-          $refStrategy: "none",
+        outputsSchema = z.toJSONSchema(fn.outputs, {
+          reused: "inline",
+          unrepresentable: "any",
         }) as Record<string, unknown>;
         delete outputsSchema.$schema;
       } catch {

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

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import type {
   OntologyConfig,
   FunctionDefinition,
@@ -8,7 +7,17 @@ import type {
   AuthResult,
 } from "../../config/types.js";
 import { getFieldFromMetadata, getUserContextFields, hasUserContextMetadata } from "../../config/categorical.js";
-import { loadResolver, type Logger } from "../resolver.js";
+import {
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "../../config/zod-utils.js";
+import type { Logger } from "../resolver.js";
 
 /**
  * Field reference info for MCP tools
@@ -94,36 +103,48 @@ function extractFieldReferencesForMcp(
   }
 
   // Handle ZodObject - recurse into properties
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldReferencesForMcp(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldReferencesForMcp(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
   // Handle ZodOptional - unwrap
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldReferencesForMcp(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodNullable - unwrap
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldReferencesForMcp(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodArray - recurse into element
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldReferencesForMcp(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldReferencesForMcp(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
   // Handle ZodDefault - unwrap
-  if (schema instanceof z.ZodDefault) {
-    results.push(
-      ...extractFieldReferencesForMcp(schema._def.innerType, path)
-    );
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;
@@ -139,8 +160,9 @@ export function generateMcpTools(config: OntologyConfig): McpTool[] {
     // Convert Zod schema to JSON Schema for MCP
     let inputSchema: Record<string, unknown>;
     try {
-      inputSchema = zodToJsonSchema(fn.inputs, {
-        $refStrategy: "none",
+      inputSchema = z.toJSONSchema(fn.inputs, {
+        reused: "inline",
+        unrepresentable: "any",
       }) as Record<string, unknown>;
       // Remove $schema key if present
       delete inputSchema.$schema;
@@ -154,8 +176,9 @@ export function generateMcpTools(config: OntologyConfig): McpTool[] {
     let outputSchema: Record<string, unknown> | undefined;
     if (fn.outputs) {
       try {
-        outputSchema = zodToJsonSchema(fn.outputs, {
-          $refStrategy: "none",
+        outputSchema = z.toJSONSchema(fn.outputs, {
+          reused: "inline",
+          unrepresentable: "any",
         }) as Record<string, unknown>;
         delete outputSchema.$schema;
       } catch {
@@ -198,7 +221,6 @@ export function filterToolsByAccess(
  */
 export function createToolExecutor(
   config: OntologyConfig,
-  configDir: string,
   env: string,
   envConfig: EnvironmentConfig,
   logger: Logger
@@ -253,8 +275,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);
   };
 }