feat: reduce any types in core (99→28), add test suites for SDK/CLI/Create/VSCode

- Add KernelBridge interface to replace `as any` casts in app.ts
- Type repository.ts CRUD methods with proper Record<string, unknown> types
- Add 65-test SDK test suite (RemoteDriver, DataApiClient, MetadataApiClient)
- Add 37-test CLI test suite (command registration, options, utilities)
- Add 32-test Create tool test suite (templates, scaffolding)
- Add 20-test VSCode extension test suite (manifest, commands, providers)
- Exclude test files from build tsconfigs
- Fix repository.test.ts to match null return (IObjectRepository contract)

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/drivers/sdk/tsconfig.json

@@ -5,5 +5,6 @@
         "rootDir": "./src"
     },
     "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist", "src/**/*.test.ts"],
     "references": [{ "path": "../../foundation/types" }]
 }

packages/foundation/core/src/app.ts

@@ -71,7 +71,7 @@ export class ObjectRepository {
     }
 
 
-    async find(query: UnifiedQuery = {}): Promise<any[]> {
+    async find(query: UnifiedQuery = {}): Promise<Record<string, unknown>[]> {
         const hookCtx: RetrievalHookContext = {
             ...this.context,
             objectName: this.objectName,
@@ -84,17 +84,18 @@ export class ObjectRepository {
         await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
 
         // Execute via kernel (delegates to QueryService)
-        const kernelResult = await (this.getKernel() as any).find(this.objectName, hookCtx.query || {});
+        const kernel = this.getKernel() as unknown as { find(objectName: string, query: Record<string, unknown>): Promise<{ value: Record<string, unknown>[] }> };
+        const kernelResult = await kernel.find(this.objectName, (hookCtx.query || {}) as Record<string, unknown>);
         const results = kernelResult.value;
 
         // Formula evaluation moved to FormulaPlugin hook
         hookCtx.result = results;
         await this.app.triggerHook('afterFind', this.objectName, hookCtx);
 
-        return hookCtx.result as any[];
+        return hookCtx.result as Record<string, unknown>[];
     }
 
-    async findOne(idOrQuery: string | number | UnifiedQuery): Promise<any> {
+    async findOne(idOrQuery: string | number | UnifiedQuery): Promise<Record<string, unknown> | null> {
         if (typeof idOrQuery === 'string' || typeof idOrQuery === 'number') {
             const hookCtx: RetrievalHookContext = {
                 ...this.context,
@@ -108,30 +109,30 @@ export class ObjectRepository {
             await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
 
             // Use kernel.get() for direct ID lookup
-            const result = await (this.getKernel() as any).get(this.objectName, String(idOrQuery));
+            const kernel = this.getKernel() as unknown as { get(objectName: string, id: string): Promise<Record<string, unknown> | null> };
+            const result = await kernel.get(this.objectName, String(idOrQuery));
 
             // Formula evaluation moved to FormulaPlugin hook
-            hookCtx.result = result;
+            hookCtx.result = result ? [result] : [];
             await this.app.triggerHook('afterFind', this.objectName, hookCtx);
-            return hookCtx.result;
+            const resultArray = hookCtx.result as Record<string, unknown>[];
+            return resultArray[0] || null;
         } else {
             const results = await this.find(idOrQuery);
             return results[0] || null;
         }
     }
 
-    async count(filters: any): Promise<number> {
+    async count(filters: Record<string, unknown> | unknown[] | undefined): Promise<number> {
         // Normalize filters to UnifiedQuery format
         // If filters is an array, wrap it in a query object
         // If filters is already a UnifiedQuery (has UnifiedQuery-specific properties), use it as-is
         let query: UnifiedQuery;
         if (Array.isArray(filters)) {
             query = { where: filters };
-        } else if (filters && typeof filters === 'object' && (filters.fields || filters.orderBy || filters.limit !== undefined || filters.offset !== undefined)) {
-            // It's already a UnifiedQuery object
-            query = filters;
+        } else if (filters && typeof filters === 'object' && ((filters as Record<string, unknown>).fields || (filters as Record<string, unknown>).orderBy || (filters as Record<string, unknown>).limit !== undefined || (filters as Record<string, unknown>).offset !== undefined)) {
+            query = filters as UnifiedQuery;
         } else if (filters) {
-            // It's a raw filter object, wrap it
             query = { where: filters };
         } else {
             query = {};
@@ -150,11 +151,10 @@ export class ObjectRepository {
 
         // Execute via kernel (delegates to QueryService)
         let result: number;
-        const kernel = this.getKernel() as any;
+        const kernel = this.getKernel() as unknown as { count?(objectName: string, query: Record<string, unknown>): Promise<number> };
         if (typeof kernel.count === 'function') {
-            result = await kernel.count(this.objectName, hookCtx.query || {});
+            result = await kernel.count(this.objectName, (hookCtx.query || {}) as Record<string, unknown>);
         } else {
-            // Fallback to driver if kernel doesn't support count
             result = await this.getDriver().count(this.objectName, hookCtx.query || {});
         }
 
@@ -163,7 +163,7 @@ export class ObjectRepository {
         return hookCtx.result as number;
     }
 
-    async create(doc: any): Promise<any> {
+    async create(doc: Record<string, unknown>): Promise<Record<string, unknown>> {
         const hookCtx: MutationHookContext = {
             ...this.context,
             objectName: this.objectName,
@@ -176,20 +176,19 @@ export class ObjectRepository {
         await this.app.triggerHook('beforeCreate', this.objectName, hookCtx);
         const finalDoc = hookCtx.data || doc;
 
-        if (this.context.userId) finalDoc.created_by = this.context.userId;
-        if (this.context.spaceId) finalDoc.space_id = this.context.spaceId;
-        
-        // Validation moved to ValidatorPlugin hook
+        if (this.context.userId) (finalDoc as Record<string, unknown>).created_by = this.context.userId;
+        if (this.context.spaceId) (finalDoc as Record<string, unknown>).space_id = this.context.spaceId;
 
         // Execute via kernel
-        const result = await (this.getKernel() as any).create(this.objectName, finalDoc, this.getOptions());
+        const kernel = this.getKernel() as unknown as { create(objectName: string, doc: Record<string, unknown>, options: Record<string, unknown>): Promise<Record<string, unknown>> };
+        const result = await kernel.create(this.objectName, finalDoc as Record<string, unknown>, this.getOptions());
 
         hookCtx.result = result;
         await this.app.triggerHook('afterCreate', this.objectName, hookCtx);
-        return hookCtx.result;
+        return hookCtx.result as Record<string, unknown>;
     }
 
-    async update(id: string | number, doc: any, _options?: any): Promise<any> {
+    async update(id: string | number, doc: Record<string, unknown>, _options?: Record<string, unknown>): Promise<Record<string, unknown>> {
         const previousData = await this.findOne(id);
         const hookCtx: UpdateHookContext = {
             ...this.context,
@@ -200,22 +199,21 @@ export class ObjectRepository {
             user: this.getUserFromContext(),
             id,
             data: doc,
-            previousData,
+            previousData: previousData as Record<string, unknown> | undefined,
             isModified: (field) => hookCtx.data ? Object.prototype.hasOwnProperty.call(hookCtx.data, field) : false
         };
         await this.app.triggerHook('beforeUpdate', this.objectName, hookCtx);
 
-        // Validation moved to ValidatorPlugin hook
-
         // Execute via kernel
-        const result = await (this.getKernel() as any).update(this.objectName, String(id), hookCtx.data, this.getOptions());
+        const kernel = this.getKernel() as unknown as { update(objectName: string, id: string, data: unknown, options: Record<string, unknown>): Promise<Record<string, unknown>> };
+        const result = await kernel.update(this.objectName, String(id), hookCtx.data, this.getOptions());
 
         hookCtx.result = result;
         await this.app.triggerHook('afterUpdate', this.objectName, hookCtx);
-        return hookCtx.result;
+        return hookCtx.result as Record<string, unknown>;
     }
 
-    async delete(id: string | number): Promise<any> {
+    async delete(id: string | number): Promise<Record<string, unknown>> {
         const previousData = await this.findOne(id);
         const hookCtx: MutationHookContext = {
             ...this.context,
@@ -225,80 +223,74 @@ export class ObjectRepository {
             api: this.getHookAPI(),
             user: this.getUserFromContext(),
             id,
-            previousData
+            previousData: previousData as Record<string, unknown> | undefined
         };
         await this.app.triggerHook('beforeDelete', this.objectName, hookCtx);
 
         // Execute via kernel
-        const result = await (this.getKernel() as any).delete(this.objectName, String(id), this.getOptions());
+        const kernel = this.getKernel() as unknown as { delete(objectName: string, id: string, options: Record<string, unknown>): Promise<Record<string, unknown>> };
+        const result = await kernel.delete(this.objectName, String(id), this.getOptions());
 
         hookCtx.result = result;
         await this.app.triggerHook('afterDelete', this.objectName, hookCtx);
-        return hookCtx.result;
+        return hookCtx.result as Record<string, unknown>;
     }
 
-    async aggregate(query: any): Promise<any> {
+    async aggregate(query: Record<string, unknown>): Promise<unknown[]> {
         const driver = this.getDriver();
         if (!driver.aggregate) throw new ObjectQLError({ code: 'DRIVER_UNSUPPORTED_OPERATION', message: "Driver does not support aggregate" });
 
         return driver.aggregate(this.objectName, query, this.getOptions());
     }
 
-    async distinct(field: string, filters?: any): Promise<any[]> {
+    async distinct(field: string, filters?: Record<string, unknown>): Promise<unknown[]> {
         const driver = this.getDriver();
         if (!driver.distinct) throw new ObjectQLError({ code: 'DRIVER_UNSUPPORTED_OPERATION', message: "Driver does not support distinct" });
 
         return driver.distinct(this.objectName, field, filters, this.getOptions());
     }
 
-    async findOneAndUpdate(filters: any, update: any, options?: any): Promise<any> {
+    async findOneAndUpdate(filters: Record<string, unknown>, update: Record<string, unknown>, options?: Record<string, unknown>): Promise<Record<string, unknown> | null> {
         const driver = this.getDriver();
         if (!driver.findOneAndUpdate) throw new ObjectQLError({ code: 'DRIVER_UNSUPPORTED_OPERATION', message: "Driver does not support findOneAndUpdate" });
         return driver.findOneAndUpdate(this.objectName, filters, update, this.getOptions(options));
     }
 
-    async createMany(data: any[]): Promise<any> {
+    async createMany(data: Record<string, unknown>[]): Promise<Record<string, unknown>[]> {
         const _driver = this.getDriver();
 
-        // Always use fallback to ensure validation and hooks are executed
-        // This maintains ObjectQL's metadata-driven architecture where
-        // validation rules, hooks, and permissions are enforced consistently
-        const results = [];
+        const results: Record<string, unknown>[] = [];
         for (const item of data) {
             results.push(await this.create(item));
         }
         return results;
     }
 
-    async updateMany(filters: any, data: any): Promise<any> {
-        // Find all matching records and update them individually
-        // to ensure validation and hooks are executed
+    async updateMany(filters: Record<string, unknown>, data: Record<string, unknown>): Promise<number> {
         const records = await this.find({ where: filters });
         let count = 0;
         for (const record of records) {
             if (record && record._id) {
-                await this.update(record._id, data);
+                await this.update(record._id as string | number, data);
                 count++;
             }
         }
         return count;
     }
 
-    async deleteMany(filters: any): Promise<any> {
-        // Find all matching records and delete them individually
-        // to ensure hooks are executed
+    async deleteMany(filters: Record<string, unknown>): Promise<number> {
         const records = await this.find({ where: filters });
         let count = 0;
         for (const record of records) {
             if (record && record._id) {
-                await this.delete(record._id);
+                await this.delete(record._id as string | number);
                 count++;
             }
         }
         return count;
     }
 
-    async execute(actionName: string, id: string | number | undefined, params: any): Promise<any> {
+    async execute(actionName: string, id: string | number | undefined, params: Record<string, unknown>): Promise<unknown> {
         const api: HookAPI = {
             find: (obj, q) => this.context.object(obj).find(q),
             findOne: (obj, id) => this.context.object(obj).findOne(id),

packages/foundation/core/src/repository.ts

@@ -68,7 +68,7 @@ describe('ObjectQL Repository', () => {
 
         await repo.delete(created._id);
         const found = await repo.findOne(created._id);
-        expect(found).toBeUndefined();
+        expect(found).toBeNull();
     });
 
     it('should support listeners (triggers)', async () => {

packages/foundation/core/test/repository.test.ts

@@ -5,6 +5,7 @@
     "rootDir": "src"
   },
   "include": ["src"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"],
   "references": [
     { "path": "../../foundation/types" },
     { "path": "../../foundation/plugin-validator" },

packages/tools/cli/tsconfig.json

@@ -8,5 +8,6 @@
     "esModuleInterop": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
 }

packages/tools/create/tsconfig.json

@@ -17,5 +17,5 @@
     "declarationMap": true
   },
   "include": ["src"],
-  "exclude": ["node_modules", ".vscode-test"]
+  "exclude": ["node_modules", ".vscode-test", "src/**/*.test.ts"]
 }