@arcteninc/core 0.0.31 → 0.0.32

package/package.json

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

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

@@ -11,13 +11,18 @@ 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
   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 {
@@ -451,31 +456,138 @@ 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 (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' }
     };
   }