@arcteninc/core 0.0.51 → 0.0.53

package/package.json

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

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

@@ -692,6 +692,117 @@ function serializeTypeCustom(
   }
 
   const typeId = (type as any).id;
+  
+  // Check for interfaces/type aliases FIRST (before general visited check)
+  // This allows us to handle recursive types properly with $defs
+  const symbol = type.getSymbol();
+  if (symbol) {
+    const declarations = symbol.getDeclarations();
+    if (declarations && declarations.length > 0) {
+      const firstDecl = declarations[0];
+      
+      // 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 already defined (from a previous call)
+          if (defs[defsKey]) {
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Check if we've visited this type before (circular/recursive reference)
+          // This happens when we encounter the same type while building its properties
+          if (typeId !== undefined && visited.has(typeId)) {
+            // Create a placeholder that will be filled in by the original call
+            if (!defs[defsKey]) {
+              defs[defsKey] = { type: 'object', properties: {} };
+            }
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Create placeholder first to handle recursion
+          defs[defsKey] = { type: 'object', properties: {} };
+          
+          // Mark as visited BEFORE building properties (so recursion is detected)
+          if (typeId !== undefined) {
+            visited.add(typeId);
+          }
+          
+          // Build the schema for this type
+          // For interfaces, get properties from both the type and the declaration
+          const props = checker.getPropertiesOfType(type);
+          const properties: Record<string, JsonSchemaProperty> = {};
+          const required: string[] = [];
+          
+          // Extract properties from the interface/type alias declaration
+          if (ts.isInterfaceDeclaration(firstDecl)) {
+            for (const member of firstDecl.members) {
+              if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                const propName = member.name.text;
+                const isOptional = member.questionToken !== undefined;
+                
+                if (member.type) {
+                  const propType = checker.getTypeFromTypeNode(member.type);
+                  const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
+                  properties[propName] = propResult.schema;
+                  
+                  if (!isOptional && !propResult.isOptional) {
+                    required.push(propName);
+                  }
+                }
+              }
+            }
+          } else if (ts.isTypeAliasDeclaration(firstDecl) && firstDecl.type) {
+            // For type aliases, resolve the underlying type
+            const underlyingType = checker.getTypeFromTypeNode(firstDecl.type);
+            if (underlyingType.flags & ts.TypeFlags.Object) {
+              const aliasProps = checker.getPropertiesOfType(underlyingType);
+              for (const prop of aliasProps) {
+                const propName = prop.getName();
+                const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || null as any);
+                const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+                
+                const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
+                properties[propName] = propResult.schema;
+                
+                if (!isOptional && !propResult.isOptional) {
+                  required.push(propName);
+                }
+              }
+            }
+          } else if (props.length > 0) {
+            // Fallback: use getPropertiesOfType if declaration parsing didn't work
+            for (const prop of props) {
+              const propName = prop.getName();
+              const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || null as any);
+              const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+              
+              const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
+              properties[propName] = propResult.schema;
+              
+              if (!isOptional && !propResult.isOptional) {
+                required.push(propName);
+              }
+            }
+          }
+          
+          // Update the placeholder with the actual schema (even if empty, to avoid infinite loops)
+          defs[defsKey] = {
+            type: 'object',
+            properties,
+            ...(required.length > 0 && { required })
+          };
+          
+          // Return reference
+          return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+        }
+      }
+    }
+  }
+  
+  // General recursion check for non-interface types
   if (typeId !== undefined && visited.has(typeId)) {
     return { isOptional: false, schema: {} };
   }
@@ -725,7 +836,6 @@ function serializeTypeCustom(
   }
 
   // Handle enums (TypeScript enum types)
-  const symbol = type.getSymbol();
   if (symbol) {
     const declarations = symbol.getDeclarations();
     if (declarations && declarations.length > 0) {
@@ -747,66 +857,6 @@ 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}` } };
-          }
-        }
-      }
     }
   }