@arcteninc/core 0.0.32 → 0.0.33

package/package.json

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

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

@@ -14,7 +14,8 @@ interface JsonSchemaProperty {
   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
@@ -428,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' } };
   }
@@ -448,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' } };
   }
@@ -514,6 +535,18 @@ function serializeType(
         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;
@@ -645,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' }
   };
 }