@arcteninc/core 0.0.31 → 0.0.33

package/package.json

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

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

@@ -11,13 +11,19 @@ import { glob } from 'glob';
 
 // JSON Schema compatible format
 interface JsonSchemaProperty {
-  type: string;
+  type?: string | string[]; // Can be string, array of strings, or omitted for anyOf/oneOf/$ref
   description?: string;
   default?: string;
-  enum?: string[]; // For enum types
+  enum?: (string | number)[]; // For enum types (can be string or number enums)
+  const?: string | number | boolean; // For literal values
   items?: JsonSchemaProperty; // For array types
   properties?: Record<string, JsonSchemaProperty>; // For object types
   required?: string[]; // For nested objects
+  anyOf?: JsonSchemaProperty[]; // For union types
+  oneOf?: JsonSchemaProperty[]; // For discriminated unions
+  $ref?: string; // For type references
+  // Allow any additional properties for complex schemas
+  [key: string]: any;
 }
 
 interface FunctionMetadata {
@@ -423,7 +429,7 @@ function serializeType(
   depth = 0
 ): { isOptional: boolean; schema: JsonSchemaProperty } {
   const typeString = checker.typeToString(type);
-
+  
   if (depth > 10) {
     return { isOptional: false, schema: { type: 'any' } };
   }
@@ -443,6 +449,26 @@ function serializeType(
   if (type.flags & ts.TypeFlags.Boolean) {
     return { isOptional: false, schema: { type: 'boolean' } };
   }
+  
+  // Handle boolean literals (true/false)
+  if (type.flags & ts.TypeFlags.BooleanLiteral) {
+    // Access the value through the intrinsicName property
+    const value = (type as any).intrinsicName === 'true';
+    return { isOptional: false, schema: { type: 'boolean', const: value } };
+  }
+  
+  // Handle number literals
+  if (type.flags & ts.TypeFlags.NumberLiteral) {
+    const value = (type as any).value;
+    return { isOptional: false, schema: { type: 'number', const: value } };
+  }
+  
+  // Handle string literals (enum members)
+  if (type.flags & ts.TypeFlags.StringLiteral) {
+    const value = (type as any).value;
+    return { isOptional: false, schema: { type: 'string', const: value } };
+  }
+  
   if (type.flags & ts.TypeFlags.Undefined || type.flags & ts.TypeFlags.Void) {
     return { isOptional: true, schema: { type: 'null' } };
   }
@@ -451,31 +477,150 @@ function serializeType(
   if (type.isUnion()) {
     const types = type.types;
 
-    // Check if it's a string literal union (enum)
-    const stringLiterals = types
+    // Separate null, undefined, and other types
+    const hasNull = types.some(t => t.flags & ts.TypeFlags.Null);
+    const hasUndefined = types.some(t => t.flags & ts.TypeFlags.Undefined);
+    const nonNullUndefinedTypes = types.filter(
+      t => !(t.flags & ts.TypeFlags.Null) && !(t.flags & ts.TypeFlags.Undefined)
+    );
+
+    // Check if it's a string literal union (enum) - possibly with null/undefined
+    const stringLiterals = nonNullUndefinedTypes
       .filter(t => t.flags & ts.TypeFlags.StringLiteral)
       .map(t => (t as ts.StringLiteralType).value);
 
-    if (stringLiterals.length === types.length) {
+    // If all non-null/undefined types are string literals, use enum
+    if (stringLiterals.length > 0 && stringLiterals.length === nonNullUndefinedTypes.length) {
+      const enumSchema: JsonSchemaProperty = { type: 'string', enum: stringLiterals };
+      
+      // If null or undefined is also present, wrap in anyOf
+      if (hasNull || hasUndefined) {
+        return {
+          isOptional: false,
+          schema: { anyOf: [enumSchema, { type: 'null' }] }
+        };
+      }
+      
       return {
         isOptional: false,
-        schema: { type: 'string', enum: stringLiterals }
+        schema: enumSchema
       };
     }
 
-    // Check for optional (T | undefined)
-    const hasUndefined = types.some(t => t.flags & ts.TypeFlags.Undefined);
-    const nonUndefinedTypes = types.filter(t => !(t.flags & ts.TypeFlags.Undefined));
-
-    if (hasUndefined && nonUndefinedTypes.length === 1) {
-      const result = serializeType(nonUndefinedTypes[0], checker, visited, depth + 1);
+    // Handle optional (T | undefined) - make it optional instead of union
+    if (hasUndefined && nonNullUndefinedTypes.length === 1 && !hasNull) {
+      const result = serializeType(nonNullUndefinedTypes[0], checker, visited, depth + 1);
       return { isOptional: true, schema: result.schema };
     }
 
-    // Generic union - just use string representation
+    // Build anyOf array for proper JSON Schema union
+    const anyOf: JsonSchemaProperty[] = [];
+
+    // Add null if present
+    if (hasNull) {
+      anyOf.push({ type: 'null' });
+    }
+
+    // Add undefined as null (JSON doesn't have undefined)
+    if (hasUndefined) {
+      anyOf.push({ type: 'null' });
+    }
+
+    // Process non-null/undefined types
+    for (const unionType of nonNullUndefinedTypes) {
+      // Check if it's a primitive type
+      if (unionType.flags & ts.TypeFlags.String) {
+        anyOf.push({ type: 'string' });
+      } else if (unionType.flags & ts.TypeFlags.Number) {
+        anyOf.push({ type: 'number' });
+      } else if (unionType.flags & ts.TypeFlags.Boolean) {
+        anyOf.push({ type: 'boolean' });
+      } else if (unionType.flags & ts.TypeFlags.BooleanLiteral) {
+        // Boolean literal (true/false)
+        const value = (unionType as any).intrinsicName === 'true';
+        anyOf.push({ type: 'boolean', const: value });
+      } else if (unionType.flags & ts.TypeFlags.NumberLiteral) {
+        // Number literal
+        const value = (unionType as any).value;
+        anyOf.push({ type: 'number', const: value });
+      } else if (unionType.flags & ts.TypeFlags.StringLiteral) {
+        // String literal (enum member)
+        const value = (unionType as any).value;
+        anyOf.push({ type: 'string', const: value });
+      } else if (checker.isArrayType(unionType)) {
+        // Handle array types
+        const typeArgs = (unionType as ts.TypeReference).typeArguments;
+        if (typeArgs && typeArgs.length > 0) {
+          const itemResult = serializeType(typeArgs[0], checker, visited, depth + 1);
+          anyOf.push({ type: 'array', items: itemResult.schema });
+        } else {
+          anyOf.push({ type: 'array' });
+        }
+      } else {
+        // Try to serialize the type (handles objects, type references, etc.)
+        // This will recursively resolve type aliases and interfaces
+        try {
+          const refResult = serializeType(unionType, checker, visited, depth + 1);
+          
+          // Check if we got a valid schema (not just 'any' fallback)
+          const typeString = checker.typeToString(unionType);
+          const isFallbackAny = refResult.schema.type === 'any' && 
+                                 !refResult.schema.properties && 
+                                 !refResult.schema.anyOf &&
+                                 !refResult.schema.items &&
+                                 typeString.length < 100; // If type string is short, it's probably a simple reference
+          
+          if (!isFallbackAny) {
+            anyOf.push(refResult.schema);
+          } else {
+            // For type references we can't fully resolve (like FilterTreeNode),
+            // check if it's a named type that might be defined elsewhere
+            // For now, we'll use 'any' but in a more advanced version,
+            // we'd track these and generate $defs or inline them
+            // Check if it looks like a type reference (starts with capital, no special chars)
+            if (/^[A-Z][a-zA-Z0-9]*$/.test(typeString)) {
+              // It's a type reference - use any for now
+              // TODO: Resolve and inline type definitions or use $ref with $defs
+              anyOf.push({ type: 'any' });
+            } else {
+              // It's something else - try to use the serialized result anyway
+              anyOf.push(refResult.schema);
+            }
+          }
+        } catch (e) {
+          // Fallback for unresolvable types
+          const typeString = checker.typeToString(unionType);
+          console.warn(`Warning: Could not serialize union type: ${typeString}`, e);
+          anyOf.push({ type: 'any' });
+        }
+      }
+    }
+
+    // If we only have one type (plus null/undefined), simplify
+    if (anyOf.length === 1) {
+      return { isOptional: hasNull || hasUndefined, schema: anyOf[0] };
+    }
+
+    // If we have multiple types, use anyOf
+    if (anyOf.length > 1) {
+      // Remove duplicate null entries
+      const uniqueAnyOf = anyOf.filter((schema, index, self) => {
+        if (schema.type === 'null') {
+          return index === self.findIndex(s => s.type === 'null');
+        }
+        return true;
+      });
+
+      return {
+        isOptional: false,
+        schema: { anyOf: uniqueAnyOf }
+      };
+    }
+
+    // Fallback
     return {
       isOptional: false,
-      schema: { type: types.map(t => checker.typeToString(t)).join(' | ') }
+      schema: { type: 'any' }
     };
   }
 
@@ -533,10 +678,74 @@ function serializeType(
     }
   }
 
-  // Fallback
+  // Fallback - check type flags to determine if it's a valid JSON Schema type
+  // Valid JSON Schema types: string, number, integer, boolean, object, array, null
+  
+  // Check if it's an enum type (TypeScript enum)
+  if (type.flags & ts.TypeFlags.Enum) {
+    // Try to get enum members
+    const symbol = type.symbol || (type as any).symbol;
+    if (symbol) {
+      const enumMembers = checker.getPropertiesOfType(type);
+      if (enumMembers.length > 0) {
+        // Extract enum values - enum members are typically string or number literals
+        const values: (string | number)[] = [];
+        for (const member of enumMembers) {
+          const memberType = checker.getTypeOfSymbolAtLocation(member, member.valueDeclaration || member.declarations?.[0] || type as any);
+          if (memberType.flags & ts.TypeFlags.StringLiteral) {
+            values.push((memberType as any).value);
+          } else if (memberType.flags & ts.TypeFlags.NumberLiteral) {
+            values.push((memberType as any).value);
+          }
+        }
+        if (values.length > 0) {
+          // Check if all values are strings or all are numbers
+          const allStrings = values.every(v => typeof v === 'string');
+          const allNumbers = values.every(v => typeof v === 'number');
+          if (allStrings) {
+            return { isOptional: false, schema: { type: 'string', enum: values.filter((v): v is string => typeof v === 'string') } };
+          } else if (allNumbers) {
+            const numberValues = values.filter((v): v is number => typeof v === 'number');
+            return { isOptional: false, schema: { type: 'number', enum: numberValues } };
+          }
+        }
+      }
+    }
+    // If we can't extract enum values, use 'any'
+    return { isOptional: false, schema: { type: 'any' } };
+  }
+  
+  // Check if it's a type reference (like InternalFilterType.StringFilter)
+  // Type references that aren't objects/arrays/primitives should use 'any'
+  if (type.flags & ts.TypeFlags.Object) {
+    // Already handled above, but check if it's an empty object type
+    const props = checker.getPropertiesOfType(type);
+    if (props.length === 0) {
+      // Empty object or type reference we can't resolve
+      // Check if typeString suggests it's a named type reference
+      if (typeString && typeString.includes('.')) {
+        return { isOptional: false, schema: { type: 'any' } };
+      }
+    }
+  }
+  
+  // Check if typeString is a valid JSON Schema primitive type
+  const validJsonSchemaTypes = new Set(['string', 'number', 'integer', 'boolean', 'object', 'array', 'null']);
+  const lowerTypeString = typeString?.toLowerCase();
+  
+  // If it's a valid JSON Schema type, use it (shouldn't happen here, but safety check)
+  if (lowerTypeString && validJsonSchemaTypes.has(lowerTypeString)) {
+    return {
+      isOptional: false,
+      schema: { type: lowerTypeString as any }
+    };
+  }
+  
+  // For any other unrecognized type, use 'any' instead of invalid type strings
+  // This prevents errors like "type": "InternalFilterType.StringFilter"
   return {
     isOptional: false,
-    schema: { type: typeString.length < 100 ? typeString : 'any' }
+    schema: { type: 'any' }
   };
 }