don't include callables/function-like things in json schemas

Author: mathpirate

packages/js-runtime/test/fixtures/handler-schema/date-and-map-types.expected.ts

@@ -25,47 +25,11 @@ const timedHandler = handler({
         Map: {
             type: "object",
             properties: {
-                clear: {
-                    type: "object",
-                    properties: {}
-                },
-                delete: {
-                    type: "object",
-                    properties: {}
-                },
-                forEach: {
-                    type: "object",
-                    properties: {}
-                },
-                get: {
-                    type: "object",
-                    properties: {}
-                },
-                has: {
-                    type: "object",
-                    properties: {}
-                },
-                set: {
-                    type: "object",
-                    properties: {}
-                },
                 size: {
                     type: "number"
-                },
-                entries: {
-                    type: "object",
-                    properties: {}
-                },
-                keys: {
-                    type: "object",
-                    properties: {}
-                },
-                values: {
-                    type: "object",
-                    properties: {}
                 }
             },
-            required: ["clear", "delete", "forEach", "get", "has", "set", "size", "entries", "keys", "values"]
+            required: ["size"]
         }
     }
 } as const satisfies JSONSchema, {
@@ -85,47 +49,11 @@ const timedHandler = handler({
         Map: {
             type: "object",
             properties: {
-                clear: {
-                    type: "object",
-                    properties: {}
-                },
-                delete: {
-                    type: "object",
-                    properties: {}
-                },
-                forEach: {
-                    type: "object",
-                    properties: {}
-                },
-                get: {
-                    type: "object",
-                    properties: {}
-                },
-                has: {
-                    type: "object",
-                    properties: {}
-                },
-                set: {
-                    type: "object",
-                    properties: {}
-                },
                 size: {
                     type: "number"
-                },
-                entries: {
-                    type: "object",
-                    properties: {}
-                },
-                keys: {
-                    type: "object",
-                    properties: {}
-                },
-                values: {
-                    type: "object",
-                    properties: {}
                 }
             },
-            required: ["clear", "delete", "forEach", "get", "has", "set", "size", "entries", "keys", "values"]
+            required: ["size"]
         }
     }
 } as const satisfies JSONSchema, (event, state) => {

packages/schema-generator/src/formatters/object-formatter.ts

@@ -4,7 +4,7 @@ import type {
   SchemaDefinition,
   TypeFormatter,
 } from "../interface.ts";
-import { safeGetPropertyType } from "../type-utils.ts";
+import { isFunctionLike, safeGetPropertyType } from "../type-utils.ts";
 import type { SchemaGenerator } from "../schema-generator.ts";
 import { extractDocFromSymbolAndDecls, getDeclDocs } from "../doc-utils.ts";
 import { getLogger } from "@commontools/utils/logger";
@@ -66,20 +66,25 @@ export class ObjectFormatter implements TypeFormatter {
       const propName = prop.getName();
       if (propName.startsWith("__")) continue; // Skip internal properties
 
-      const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
-      if (!isOptional) required.push(propName);
-
       let propTypeNode: ts.TypeNode | undefined;
       const propDecl = prop.valueDeclaration ??
-        (prop.declarations?.[0] as ts.Declaration);
+        (prop.declarations?.[0] as ts.Declaration | undefined);
+
       if (propDecl) {
+        if (
+          ts.isMethodSignature(propDecl) || ts.isMethodDeclaration(propDecl)
+        ) {
+          continue;
+        }
         if (
           ts.isPropertySignature(propDecl) || ts.isPropertyDeclaration(propDecl)
         ) {
           if (propDecl.type) propTypeNode = propDecl.type as ts.TypeNode;
         }
       }
 
+      if ((prop.flags & ts.SymbolFlags.Method) !== 0) continue;
+
       // Get the actual property type and recursively delegate to the main schema generator
       const resolvedPropType = safeGetPropertyType(
         prop,
@@ -88,6 +93,13 @@ export class ObjectFormatter implements TypeFormatter {
         propTypeNode,
       );
 
+      if (isFunctionLike(resolvedPropType)) {
+        continue;
+      }
+
+      const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+      if (!isOptional) required.push(propName);
+
       // Delegate to the main generator (specific formatters handle wrappers/defaults)
       const generated: SchemaDefinition = this.schemaGenerator.formatChildType(
         resolvedPropType,

packages/schema-generator/src/type-utils.ts

@@ -165,6 +165,28 @@ export function getNamedTypeKey(
   return name;
 }
 
+/**
+ * Determine if a type represents a callable/constructable function value.
+ */
+export function isFunctionLike(type: ts.Type): boolean {
+  if (type.getCallSignatures().length > 0) return true;
+  if (type.getConstructSignatures().length > 0) return true;
+
+  const symbol = type.symbol;
+  if (!symbol) return false;
+
+  const flags = symbol.flags;
+  if (
+    (flags & ts.SymbolFlags.Function) !== 0 ||
+    (flags & ts.SymbolFlags.Method) !== 0 ||
+    (flags & ts.SymbolFlags.Signature) !== 0
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Helper to extract array element type using multiple detection methods
  */