@arcteninc/core 0.0.49 → 0.0.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.49",
+  "version": "0.0.51",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/scripts/cli-extract-types-auto.ts

@@ -747,10 +747,70 @@ function serializeTypeCustom(
           return { isOptional: false, schema: { enum: enumMembers } };
         }
       }
+      
+      // Handle interfaces and type aliases (for recursive types)
+      if (ts.isInterfaceDeclaration(firstDecl) || ts.isTypeAliasDeclaration(firstDecl)) {
+        const typeName = symbol.getName();
+        if (typeName && defs) {
+          const defsKey = typeName; // Use the type name as key
+          
+          // Check if we've visited this type before (circular/recursive reference)
+          if (visited.has(typeId)) {
+            // Create a reference to avoid infinite recursion
+            if (!defs[defsKey]) {
+              // Create placeholder - will be filled in below
+              defs[defsKey] = { type: 'object', properties: {} };
+            }
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Check if already defined (from a previous call)
+          if (defs[defsKey]) {
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Mark as visited and build the definition
+          visited.add(typeId);
+          
+          // Build the schema for this type
+          const props = checker.getPropertiesOfType(type);
+          if (props.length > 0) {
+            const properties: Record<string, JsonSchemaProperty> = {};
+            const required: string[] = [];
+            
+            // Use the same visited set for properties to detect recursion
+            for (const prop of props) {
+              const propName = prop.getName();
+              const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || checker.getDeclaredTypeOfSymbol(prop).symbol?.valueDeclaration || null as any);
+              const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+              
+              // Recursively serialize the property type (will detect recursion via visited set)
+              const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
+              properties[propName] = propResult.schema;
+              
+              if (!isOptional && !propResult.isOptional) {
+                required.push(propName);
+              }
+            }
+            
+            const schema: JsonSchemaProperty = {
+              type: 'object',
+              properties,
+              ...(required.length > 0 && { required })
+            };
+            
+            // Store in defs
+            defs[defsKey] = schema;
+            
+            // Return reference
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+        }
+      }
     }
   }
 
-  // Handle object types with properties
+  // Handle object types with properties (anonymous types)
   if (type.flags & ts.TypeFlags.Object) {
     const props = checker.getPropertiesOfType(type);
     if (props.length > 0) {
@@ -930,9 +990,9 @@ async function serializeType(
     return result;
   }
 
-  // Generator failed - log and return empty schema
-  console.warn(`⚠️  Failed to generate schema for type "${typeInfo.typeName}" from ${typeInfo.sourceFile}. Using empty schema.`);
-  return { isOptional: false, schema: {} }; // Empty schema = any value
+  // Generator failed - fall back to custom serializer
+  console.warn(`⚠️  Failed to generate schema for type "${typeInfo.typeName}" from ${typeInfo.sourceFile}. Falling back to custom serializer.`);
+  return serializeTypeCustom(type, checker, defs);
 }
 
 /**