@objectstack/core 1.0.2 → 1.0.5

package/dist/plugin-loader.test.js

@@ -1,348 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { PluginLoader, ServiceLifecycle } from './plugin-loader';
-import { createLogger } from './logger';
-describe('PluginLoader', () => {
-    let loader;
-    beforeEach(() => {
-        const logger = createLogger({ level: 'error' }); // Suppress logs in tests
-        loader = new PluginLoader(logger);
-        loader.setContext({
-            registerService: () => { },
-            getService: () => { throw new Error('Mock service not found'); },
-            hook: () => { },
-            trigger: async () => { },
-            getServices: () => new Map(),
-            logger: logger,
-            getKernel: () => ({})
-        });
-    });
-    describe('Plugin Loading', () => {
-        it('should load a valid plugin', async () => {
-            const plugin = {
-                name: 'test-plugin',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(true);
-            expect(result.plugin?.name).toBe('test-plugin');
-            expect(result.plugin?.version).toBe('1.0.0');
-            expect(result.loadTime).toBeGreaterThanOrEqual(0);
-        });
-        it('should reject plugin with invalid name', async () => {
-            const plugin = {
-                name: '',
-                init: async () => { },
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(false);
-            expect(result.error?.message).toContain('name is required');
-        });
-        it('should reject plugin without init function', async () => {
-            const plugin = {
-                name: 'invalid-plugin',
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(false);
-            expect(result.error?.message).toContain('init function is required');
-        });
-        it('should use default version 0.0.0 if not provided', async () => {
-            const plugin = {
-                name: 'no-version',
-                init: async () => { },
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(true);
-            expect(result.plugin?.version).toBe('0.0.0');
-        });
-    });
-    describe('Version Compatibility', () => {
-        it('should accept valid semantic versions', async () => {
-            const validVersions = ['1.0.0', '2.3.4', '0.0.1', '10.20.30'];
-            for (const version of validVersions) {
-                const plugin = {
-                    name: `plugin-${version}`,
-                    version,
-                    init: async () => { },
-                };
-                const result = await loader.loadPlugin(plugin);
-                expect(result.success).toBe(true);
-            }
-        });
-        it('should accept versions with pre-release tags', async () => {
-            const plugin = {
-                name: 'prerelease',
-                version: '1.0.0-alpha.1',
-                init: async () => { },
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(true);
-        });
-        it('should accept versions with build metadata', async () => {
-            const plugin = {
-                name: 'build-meta',
-                version: '1.0.0+20230101',
-                init: async () => { },
-            };
-            const result = await loader.loadPlugin(plugin);
-            expect(result.success).toBe(true);
-        });
-        it('should reject invalid semantic versions', async () => {
-            const invalidVersions = ['1.0', 'v1.0.0', '1', 'invalid'];
-            for (const version of invalidVersions) {
-                const plugin = {
-                    name: `invalid-${version}`,
-                    version,
-                    init: async () => { },
-                };
-                const result = await loader.loadPlugin(plugin);
-                expect(result.success).toBe(false);
-            }
-        });
-    });
-    describe('Service Factory Registration', () => {
-        it('should register a singleton service factory', () => {
-            let callCount = 0;
-            const factory = () => {
-                callCount++;
-                return { value: callCount };
-            };
-            loader.registerServiceFactory({
-                name: 'singleton-service',
-                factory,
-                lifecycle: ServiceLifecycle.SINGLETON,
-            });
-            expect(() => {
-                loader.registerServiceFactory({
-                    name: 'singleton-service',
-                    factory,
-                    lifecycle: ServiceLifecycle.SINGLETON,
-                });
-            }).toThrow('already registered');
-        });
-        it('should register multiple service factories with different names', () => {
-            loader.registerServiceFactory({
-                name: 'service-1',
-                factory: () => ({ id: 1 }),
-                lifecycle: ServiceLifecycle.SINGLETON,
-            });
-            loader.registerServiceFactory({
-                name: 'service-2',
-                factory: () => ({ id: 2 }),
-                lifecycle: ServiceLifecycle.TRANSIENT,
-            });
-            // Should not throw
-            expect(true).toBe(true);
-        });
-    });
-    describe('Service Retrieval with Lifecycle', () => {
-        it('should create singleton service only once', async () => {
-            let callCount = 0;
-            loader.registerServiceFactory({
-                name: 'counter',
-                factory: () => {
-                    callCount++;
-                    return { count: callCount };
-                },
-                lifecycle: ServiceLifecycle.SINGLETON,
-            });
-            const service1 = await loader.getService('counter');
-            const service2 = await loader.getService('counter');
-            expect(callCount).toBe(1);
-            expect(service1).toBe(service2);
-        });
-        it('should create new transient service on each request', async () => {
-            let callCount = 0;
-            loader.registerServiceFactory({
-                name: 'transient',
-                factory: () => {
-                    callCount++;
-                    return { count: callCount };
-                },
-                lifecycle: ServiceLifecycle.TRANSIENT,
-            });
-            const service1 = await loader.getService('transient');
-            const service2 = await loader.getService('transient');
-            expect(callCount).toBe(2);
-            expect(service1).not.toBe(service2);
-            expect(service1.count).toBe(1);
-            expect(service2.count).toBe(2);
-        });
-        it('should create scoped service once per scope', async () => {
-            let callCount = 0;
-            loader.registerServiceFactory({
-                name: 'scoped',
-                factory: () => {
-                    callCount++;
-                    return { count: callCount };
-                },
-                lifecycle: ServiceLifecycle.SCOPED,
-            });
-            const scope1Service1 = await loader.getService('scoped', 'scope-1');
-            const scope1Service2 = await loader.getService('scoped', 'scope-1');
-            const scope2Service1 = await loader.getService('scoped', 'scope-2');
-            expect(callCount).toBe(2); // Once per scope
-            expect(scope1Service1).toBe(scope1Service2); // Same within scope
-            expect(scope1Service1).not.toBe(scope2Service1); // Different across scopes
-        });
-        it('should throw error for scoped service without scope ID', async () => {
-            loader.registerServiceFactory({
-                name: 'scoped-no-id',
-                factory: () => ({ value: 'test' }),
-                lifecycle: ServiceLifecycle.SCOPED,
-            });
-            await expect(async () => {
-                await loader.getService('scoped-no-id');
-            }).rejects.toThrow('Scope ID required');
-        });
-        it('should throw error for non-existent service', async () => {
-            await expect(async () => {
-                await loader.getService('non-existent');
-            }).rejects.toThrow('not found');
-        });
-    });
-    describe('Circular Dependency Detection', () => {
-        it('should detect simple circular dependency', () => {
-            loader.registerServiceFactory({
-                name: 'service-a',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-b'],
-            });
-            loader.registerServiceFactory({
-                name: 'service-b',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-a'],
-            });
-            const cycles = loader.detectCircularDependencies();
-            expect(cycles.length).toBeGreaterThan(0);
-            expect(cycles[0]).toContain('service-a');
-            expect(cycles[0]).toContain('service-b');
-        });
-        it('should detect complex circular dependency', () => {
-            loader.registerServiceFactory({
-                name: 'service-a',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-b'],
-            });
-            loader.registerServiceFactory({
-                name: 'service-b',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-c'],
-            });
-            loader.registerServiceFactory({
-                name: 'service-c',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-a'],
-            });
-            const cycles = loader.detectCircularDependencies();
-            expect(cycles.length).toBeGreaterThan(0);
-        });
-        it('should not report false positives for valid dependency chains', () => {
-            loader.registerServiceFactory({
-                name: 'service-a',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-b'],
-            });
-            loader.registerServiceFactory({
-                name: 'service-b',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-                dependencies: ['service-c'],
-            });
-            loader.registerServiceFactory({
-                name: 'service-c',
-                factory: () => ({}),
-                lifecycle: ServiceLifecycle.SINGLETON,
-            });
-            const cycles = loader.detectCircularDependencies();
-            expect(cycles.length).toBe(0);
-        });
-    });
-    describe('Plugin Health Checks', () => {
-        it('should return healthy for plugin without health check', async () => {
-            const plugin = {
-                name: 'no-health-check',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            await loader.loadPlugin(plugin);
-            const health = await loader.checkPluginHealth('no-health-check');
-            expect(health.healthy).toBe(true);
-            expect(health.message).toContain('No health check');
-        });
-        it('should execute plugin health check', async () => {
-            const plugin = {
-                name: 'with-health-check',
-                version: '1.0.0',
-                init: async () => { },
-                healthCheck: async () => ({
-                    healthy: true,
-                    message: 'All systems operational',
-                }),
-            };
-            await loader.loadPlugin(plugin);
-            const health = await loader.checkPluginHealth('with-health-check');
-            expect(health.healthy).toBe(true);
-            expect(health.message).toBe('All systems operational');
-            expect(health.lastCheck).toBeInstanceOf(Date);
-        });
-        it('should handle failing health check', async () => {
-            const plugin = {
-                name: 'failing-health',
-                version: '1.0.0',
-                init: async () => { },
-                healthCheck: async () => {
-                    throw new Error('Service unavailable');
-                },
-            };
-            await loader.loadPlugin(plugin);
-            const health = await loader.checkPluginHealth('failing-health');
-            expect(health.healthy).toBe(false);
-            expect(health.message).toContain('Health check failed');
-        });
-        it('should return not found for unknown plugin', async () => {
-            const health = await loader.checkPluginHealth('unknown-plugin');
-            expect(health.healthy).toBe(false);
-            expect(health.message).toContain('not found');
-        });
-    });
-    describe('Scope Management', () => {
-        it('should clear scoped services', async () => {
-            let callCount = 0;
-            loader.registerServiceFactory({
-                name: 'scoped-clear',
-                factory: () => {
-                    callCount++;
-                    return { count: callCount };
-                },
-                lifecycle: ServiceLifecycle.SCOPED,
-            });
-            const service1 = await loader.getService('scoped-clear', 'scope-1');
-            expect(service1.count).toBe(1);
-            loader.clearScope('scope-1');
-            const service2 = await loader.getService('scoped-clear', 'scope-1');
-            expect(service2.count).toBe(2); // New instance created
-        });
-    });
-    describe('Static Service Registration', () => {
-        it('should register static service instance', () => {
-            const service = { value: 'test' };
-            loader.registerService('static-service', service);
-            expect(() => {
-                loader.registerService('static-service', service);
-            }).toThrow('already registered');
-        });
-        it('should retrieve static service', async () => {
-            const service = { value: 'static' };
-            loader.registerService('static', service);
-            const retrieved = await loader.getService('static');
-            expect(retrieved).toBe(service);
-        });
-    });
-});

package/dist/qa/adapter.d.ts

@@ -1,14 +0,0 @@
-import { QA } from '@objectstack/spec';
-/**
- * Interface for executing test actions against a target system.
- * The target could be a local Kernel instance or a remote API.
- */
-export interface TestExecutionAdapter {
-    /**
-     * Execute a single test action.
-     * @param action The action to perform (create_record, api_call, etc.)
-     * @returns The result of the action (e.g. created record, API response)
-     */
-    execute(action: QA.TestAction, context: Record<string, unknown>): Promise<unknown>;
-}
-//# sourceMappingURL=adapter.d.ts.map

package/dist/qa/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/qa/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAEvC;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF"}

package/dist/qa/adapter.js

@@ -1 +0,0 @@
-export {};

package/dist/qa/http-adapter.d.ts

@@ -1,16 +0,0 @@
-import { QA } from '@objectstack/spec';
-import { TestExecutionAdapter } from './adapter.js';
-export declare class HttpTestAdapter implements TestExecutionAdapter {
-    private baseUrl;
-    private authToken?;
-    constructor(baseUrl: string, authToken?: string | undefined);
-    execute(action: QA.TestAction, _context: Record<string, unknown>): Promise<unknown>;
-    private createRecord;
-    private updateRecord;
-    private deleteRecord;
-    private readRecord;
-    private queryRecords;
-    private rawApiCall;
-    private handleResponse;
-}
-//# sourceMappingURL=http-adapter.d.ts.map

package/dist/qa/http-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-adapter.d.ts","sourceRoot":"","sources":["../../src/qa/http-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,qBAAa,eAAgB,YAAW,oBAAoB;IAC9C,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,SAAS,CAAC;gBAAnC,OAAO,EAAE,MAAM,EAAU,SAAS,CAAC,EAAE,MAAM,YAAA;IAEzD,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;YAiC3E,YAAY;YASZ,YAAY;YAWZ,YAAY;YAUZ,UAAU;YAUV,YAAY;YAUZ,UAAU;YAaV,cAAc;CAW7B"}

package/dist/qa/http-adapter.js

@@ -1,107 +0,0 @@
-export class HttpTestAdapter {
-    constructor(baseUrl, authToken) {
-        this.baseUrl = baseUrl;
-        this.authToken = authToken;
-    }
-    async execute(action, _context) {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (this.authToken) {
-            headers['Authorization'] = `Bearer ${this.authToken}`;
-        }
-        // If action.user is specified, maybe add a specific header for impersonation if supported?
-        if (action.user) {
-            headers['X-Run-As'] = action.user;
-        }
-        switch (action.type) {
-            case 'create_record':
-                return this.createRecord(action.target, action.payload || {}, headers);
-            case 'update_record':
-                return this.updateRecord(action.target, action.payload || {}, headers);
-            case 'delete_record':
-                return this.deleteRecord(action.target, action.payload || {}, headers);
-            case 'read_record':
-                return this.readRecord(action.target, action.payload || {}, headers);
-            case 'query_records':
-                return this.queryRecords(action.target, action.payload || {}, headers);
-            case 'api_call':
-                return this.rawApiCall(action.target, action.payload || {}, headers);
-            case 'wait':
-                const ms = Number(action.payload?.duration || 1000);
-                return new Promise(resolve => setTimeout(() => resolve({ waited: ms }), ms));
-            default:
-                throw new Error(`Unsupported action type in HttpAdapter: ${action.type}`);
-        }
-    }
-    async createRecord(objectName, data, headers) {
-        const response = await fetch(`${this.baseUrl}/api/data/${objectName}`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(data)
-        });
-        return this.handleResponse(response);
-    }
-    async updateRecord(objectName, data, headers) {
-        const id = data._id || data.id;
-        if (!id)
-            throw new Error('Update record requires _id or id in payload');
-        const response = await fetch(`${this.baseUrl}/api/data/${objectName}/${id}`, {
-            method: 'PUT',
-            headers,
-            body: JSON.stringify(data)
-        });
-        return this.handleResponse(response);
-    }
-    async deleteRecord(objectName, data, headers) {
-        const id = data._id || data.id;
-        if (!id)
-            throw new Error('Delete record requires _id or id in payload');
-        const response = await fetch(`${this.baseUrl}/api/data/${objectName}/${id}`, {
-            method: 'DELETE',
-            headers
-        });
-        return this.handleResponse(response);
-    }
-    async readRecord(objectName, data, headers) {
-        const id = data._id || data.id;
-        if (!id)
-            throw new Error('Read record requires _id or id in payload');
-        const response = await fetch(`${this.baseUrl}/api/data/${objectName}/${id}`, {
-            method: 'GET',
-            headers
-        });
-        return this.handleResponse(response);
-    }
-    async queryRecords(objectName, data, headers) {
-        // Assuming query via POST or GraphQL-like endpoint
-        const response = await fetch(`${this.baseUrl}/api/data/${objectName}/query`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(data)
-        });
-        return this.handleResponse(response);
-    }
-    async rawApiCall(endpoint, data, headers) {
-        const method = data.method || 'GET';
-        const body = data.body ? JSON.stringify(data.body) : undefined;
-        const url = endpoint.startsWith('http') ? endpoint : `${this.baseUrl}${endpoint}`;
-        const response = await fetch(url, {
-            method,
-            headers,
-            body
-        });
-        return this.handleResponse(response);
-    }
-    async handleResponse(response) {
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`HTTP Error ${response.status}: ${text}`);
-        }
-        const contentType = response.headers.get('content-type');
-        if (contentType && contentType.includes('application/json')) {
-            return response.json();
-        }
-        return response.text();
-    }
-}

package/dist/qa/index.d.ts

@@ -1,4 +0,0 @@
-export * from './adapter.js';
-export * from './runner.js';
-export * from './http-adapter.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/qa/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/qa/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

package/dist/qa/index.js

@@ -1,3 +0,0 @@
-export * from './adapter.js';
-export * from './runner.js';
-export * from './http-adapter.js';

package/dist/qa/runner.d.ts

@@ -1,27 +0,0 @@
-import { QA } from '@objectstack/spec';
-import { TestExecutionAdapter } from './adapter.js';
-export interface TestResult {
-    scenarioId: string;
-    passed: boolean;
-    steps: StepResult[];
-    error?: unknown;
-    duration: number;
-}
-export interface StepResult {
-    stepName: string;
-    passed: boolean;
-    error?: unknown;
-    output?: unknown;
-    duration: number;
-}
-export declare class TestRunner {
-    private adapter;
-    constructor(adapter: TestExecutionAdapter);
-    runSuite(suite: QA.TestSuite): Promise<TestResult[]>;
-    runScenario(scenario: QA.TestScenario): Promise<TestResult>;
-    private runStep;
-    private resolveVariables;
-    private getValueByPath;
-    private assert;
-}
-//# sourceMappingURL=runner.d.ts.map

package/dist/qa/runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/qa/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,UAAU;IACT,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,oBAAoB;IAE3C,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAQpD,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;YA4EnD,OAAO;IAyBrB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,MAAM;CA8Bf"}