From 69aaff96e733e7d1722ce8f3a2d2bd99b23c23bc Mon Sep 17 00:00:00 2001
From: 7000pctAUTO <lukems3823@gmail.com>
Date: Sat, 31 Jan 2026 12:25:58 +0000
Subject: [PATCH] Initial upload with CI/CD workflow

---
 tests/type-inference.test.ts | 138 +++++++++++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 tests/type-inference.test.ts

diff --git a/tests/type-inference.test.ts b/tests/type-inference.test.ts
new file mode 100644
index 0000000..acffbaa
--- /dev/null
+++ b/tests/type-inference.test.ts
@@ -0,0 +1,138 @@
+import { TypeInferrer } from '../src/type-inferrer.js';
+
+describe('TypeInferrer', () => {
+  describe('infer', () => {
+    it('should infer string type', () => {
+      const inferrer = new TypeInferrer({ rootName: 'StringType' });
+      const result = inferrer.infer('hello');
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer number type', () => {
+      const inferrer = new TypeInferrer({ rootName: 'NumberType' });
+      const result = inferrer.infer(42);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer boolean type', () => {
+      const inferrer = new TypeInferrer({ rootName: 'BooleanType' });
+      const result = inferrer.infer(true);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer null type', () => {
+      const inferrer = new TypeInferrer({ rootName: 'NullType' });
+      const result = inferrer.infer(null);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer array of primitives', () => {
+      const inferrer = new TypeInferrer();
+      const result = inferrer.infer([1, 2, 3]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer array of strings', () => {
+      const inferrer = new TypeInferrer();
+      const result = inferrer.infer(['a', 'b', 'c']);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer empty array', () => {
+      const inferrer = new TypeInferrer();
+      const result = inferrer.infer([]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should infer simple object', () => {
+      const inferrer = new TypeInferrer({ rootName: 'User' });
+      const result = inferrer.infer({
+        name: 'John',
+        age: 30,
+        active: true,
+      });
+      expect(result.types.length).toBeGreaterThan(0);
+      expect(result.types[0].name).toBe('User');
+    });
+
+    it('should infer nested objects', () => {
+      const inferrer = new TypeInferrer({ rootName: 'Company' });
+      const result = inferrer.infer({
+        name: 'Acme',
+        address: {
+          street: '123 Main St',
+          city: 'Boston',
+        },
+      });
+      expect(result.types.length).toBeGreaterThanOrEqual(1);
+      expect(result.types.find(t => t.name === 'Company')).toBeDefined();
+    });
+
+    it('should infer array of objects', () => {
+      const inferrer = new TypeInferrer({ rootName: 'UserList' });
+      const result = inferrer.infer([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+      ]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should handle mixed type arrays', () => {
+      const inferrer = new TypeInferrer();
+      const result = inferrer.infer([1, 'two', true]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('inferFromMultiple', () => {
+    it('should merge compatible objects', () => {
+      const inferrer = new TypeInferrer({ rootName: 'User' });
+      const result = inferrer.inferFromMultiple([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+      ]);
+      expect(result.types.length).toBeGreaterThan(0);
+      expect(result.types[0].name).toBe('User');
+    });
+
+    it('should detect optional fields', () => {
+      const inferrer = new TypeInferrer({ rootName: 'User' });
+      const result = inferrer.inferFromMultiple([
+        { id: 1, name: 'Alice', email: 'alice@example.com' },
+        { id: 2, name: 'Bob' },
+      ]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should create union types for field variations', () => {
+      const inferrer = new TypeInferrer({ rootName: 'Response' });
+      const result = inferrer.inferFromMultiple([
+        { id: 1 },
+        { id: 'two' },
+      ]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty result for empty samples', () => {
+      const inferrer = new TypeInferrer();
+      const result = inferrer.inferFromMultiple([]);
+      expect(result.types.length).toBe(0);
+      expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    it('should handle single sample', () => {
+      const inferrer = new TypeInferrer({ rootName: 'Single' });
+      const result = inferrer.inferFromMultiple([{ key: 'value' }]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+
+    it('should create literal types for enum-like values', () => {
+      const inferrer = new TypeInferrer({ rootName: 'Status' });
+      const result = inferrer.inferFromMultiple([
+        { status: 'active' },
+        { status: 'inactive' },
+      ]);
+      expect(result.types.length).toBeGreaterThan(0);
+    });
+  });
+});