@objectstack/core 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/core",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "Apache-2.0",
   "description": "Microkernel Core for ObjectStack",
   "type": "module",
@@ -12,10 +12,10 @@
     "@types/node": "^25.1.0"
   },
   "dependencies": {
-    "pino": "^8.17.0",
-    "pino-pretty": "^10.3.0",
+    "pino": "^10.3.0",
+    "pino-pretty": "^13.1.3",
     "zod": "^4.3.6",
-    "@objectstack/spec": "1.0.4"
+    "@objectstack/spec": "1.0.6"
   },
   "peerDependencies": {
     "pino": "^8.0.0"
@@ -26,7 +26,7 @@
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup --config ../../tsup.config.ts",
     "test": "vitest run",
     "test:watch": "vitest"
   }

package/src/logger.ts

@@ -51,13 +51,13 @@ export class ObjectLogger implements Logger {
     /**
      * Initialize Pino logger for Node.js
      */
-    private initPinoLogger() {
+    private async initPinoLogger() {
         if (!this.isNode) return;
 
         try {
             // Create require function dynamically for Node.js (avoids bundling issues in browser)
             // @ts-ignore - dynamic import of Node.js module
-            const { createRequire } = eval('require("module")');
+            const { createRequire } = await import('module');
             this.require = createRequire(import.meta.url);
             
             // Synchronous import for Pino using createRequire (works in ESM)

package/src/security/plugin-signature-verifier.ts

@@ -3,15 +3,7 @@ import type { PluginMetadata } from '../plugin-loader.js';
 
 // Conditionally import crypto for Node.js environments
 let cryptoModule: typeof import('crypto') | null = null;
-if (typeof (globalThis as any).window === 'undefined') {
-  try {
-    // Dynamic import for Node.js crypto module (using eval to avoid bundling issues)
-    // @ts-ignore - dynamic require for Node.js
-    cryptoModule = eval('require("crypto")');
-  } catch {
-    // Crypto module not available (e.g., browser environment)
-  }
-}
+
 
 /**
  * Plugin Signature Configuration
@@ -295,11 +287,20 @@ export class PluginSignatureVerifier {
     return this.verifyCryptoSignatureNode(data, signature, publicKey);
   }
   
-  private verifyCryptoSignatureNode(
+  private async verifyCryptoSignatureNode(
     data: string,
     signature: string,
     publicKey: string
-  ): boolean {
+  ): Promise<boolean> {
+    if (!cryptoModule) {
+      try {
+        // @ts-ignore
+        cryptoModule = await import('crypto');
+      } catch (e) {
+        // ignore
+      }
+    }
+
     if (!cryptoModule) {
       this.logger.error('Crypto module not available for signature verification');
       return false;

package/tsconfig.json

@@ -2,9 +2,7 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src",
-    "moduleResolution": "bundler",
-    "module": "esnext"
+    "rootDir": "./src"
   },
   "include": ["src/**/*"],
   "exclude": [] 

package/dist/api-registry-plugin.d.ts

@@ -1,54 +0,0 @@
-import type { Plugin } from './types.js';
-import type { ConflictResolutionStrategy } from '@objectstack/spec/api';
-/**
- * API Registry Plugin Configuration
- */
-export interface ApiRegistryPluginConfig {
-    /**
-     * Conflict resolution strategy for route conflicts
-     * @default 'error'
-     */
-    conflictResolution?: ConflictResolutionStrategy;
-    /**
-     * Registry version
-     * @default '1.0.0'
-     */
-    version?: string;
-}
-/**
- * API Registry Plugin
- *
- * Registers the API Registry service in the kernel, making it available
- * to all plugins for endpoint registration and discovery.
- *
- * **Usage:**
- * ```typescript
- * const kernel = new ObjectKernel();
- *
- * // Register API Registry Plugin
- * kernel.use(createApiRegistryPlugin({ conflictResolution: 'priority' }));
- *
- * // In other plugins, access the API Registry
- * const plugin: Plugin = {
- *   name: 'my-plugin',
- *   init: async (ctx) => {
- *     const registry = ctx.getService<ApiRegistry>('api-registry');
- *
- *     // Register plugin APIs
- *     registry.registerApi({
- *       id: 'my_plugin_api',
- *       name: 'My Plugin API',
- *       type: 'rest',
- *       version: 'v1',
- *       basePath: '/api/v1/my-plugin',
- *       endpoints: [...]
- *     });
- *   }
- * };
- * ```
- *
- * @param config - Plugin configuration
- * @returns Plugin instance
- */
-export declare function createApiRegistryPlugin(config?: ApiRegistryPluginConfig): Plugin;
-//# sourceMappingURL=api-registry-plugin.d.ts.map

package/dist/api-registry-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-registry-plugin.d.ts","sourceRoot":"","sources":["../src/api-registry-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;AAExD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,0BAA0B,CAAC;IAEhD;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,GAAE,uBAA4B,GACnC,MAAM,CA2BR"}

package/dist/api-registry-plugin.js

@@ -1,53 +0,0 @@
-import { ApiRegistry } from './api-registry.js';
-/**
- * API Registry Plugin
- *
- * Registers the API Registry service in the kernel, making it available
- * to all plugins for endpoint registration and discovery.
- *
- * **Usage:**
- * ```typescript
- * const kernel = new ObjectKernel();
- *
- * // Register API Registry Plugin
- * kernel.use(createApiRegistryPlugin({ conflictResolution: 'priority' }));
- *
- * // In other plugins, access the API Registry
- * const plugin: Plugin = {
- *   name: 'my-plugin',
- *   init: async (ctx) => {
- *     const registry = ctx.getService<ApiRegistry>('api-registry');
- *
- *     // Register plugin APIs
- *     registry.registerApi({
- *       id: 'my_plugin_api',
- *       name: 'My Plugin API',
- *       type: 'rest',
- *       version: 'v1',
- *       basePath: '/api/v1/my-plugin',
- *       endpoints: [...]
- *     });
- *   }
- * };
- * ```
- *
- * @param config - Plugin configuration
- * @returns Plugin instance
- */
-export function createApiRegistryPlugin(config = {}) {
-    const { conflictResolution = 'error', version = '1.0.0', } = config;
-    return {
-        name: 'com.objectstack.core.api-registry',
-        version: '1.0.0',
-        init: async (ctx) => {
-            // Create API Registry instance
-            const registry = new ApiRegistry(ctx.logger, conflictResolution, version);
-            // Register as a service
-            ctx.registerService('api-registry', registry);
-            ctx.logger.info('API Registry plugin initialized', {
-                conflictResolution,
-                version,
-            });
-        },
-    };
-}

package/dist/api-registry-plugin.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=api-registry-plugin.test.d.ts.map

package/dist/api-registry-plugin.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-registry-plugin.test.d.ts","sourceRoot":"","sources":["../src/api-registry-plugin.test.ts"],"names":[],"mappings":""}

package/dist/api-registry-plugin.test.js

@@ -1,334 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ObjectKernel } from './kernel';
-import { createApiRegistryPlugin } from './api-registry-plugin';
-import { ApiRegistry } from './api-registry';
-describe('API Registry Plugin', () => {
-    let kernel;
-    beforeEach(() => {
-        kernel = new ObjectKernel({
-            skipSystemValidation: true
-        });
-    });
-    describe('Plugin Registration', () => {
-        it('should register API Registry as a service', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            expect(registry).toBeDefined();
-            expect(registry).toBeInstanceOf(ApiRegistry);
-            await kernel.shutdown();
-        });
-        it('should register with custom conflict resolution', async () => {
-            await kernel.use(createApiRegistryPlugin({
-                conflictResolution: 'priority',
-                version: '2.0.0',
-            }));
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            const snapshot = registry.getRegistry();
-            expect(snapshot.conflictResolution).toBe('priority');
-            expect(snapshot.version).toBe('2.0.0');
-            await kernel.shutdown();
-        });
-    });
-    describe('Integration with Plugins', () => {
-        it('should allow plugins to register APIs', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            const testPlugin = {
-                name: 'test-plugin',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    const api = {
-                        id: 'test_api',
-                        name: 'Test API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/test',
-                        endpoints: [
-                            {
-                                id: 'get_test',
-                                method: 'GET',
-                                path: '/api/test/hello',
-                                summary: 'Test endpoint',
-                                responses: [
-                                    {
-                                        statusCode: 200,
-                                        description: 'Success',
-                                    },
-                                ],
-                            },
-                        ],
-                    };
-                    registry.registerApi(api);
-                },
-            };
-            await kernel.use(testPlugin);
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            const api = registry.getApi('test_api');
-            expect(api).toBeDefined();
-            expect(api?.name).toBe('Test API');
-            expect(api?.endpoints.length).toBe(1);
-            await kernel.shutdown();
-        });
-        it('should allow multiple plugins to register APIs', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            const plugin1 = {
-                name: 'plugin-1',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'api1',
-                        name: 'API 1',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/plugin1',
-                        endpoints: [
-                            {
-                                id: 'endpoint1',
-                                method: 'GET',
-                                path: '/api/plugin1/data',
-                                responses: [],
-                            },
-                        ],
-                    });
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'api2',
-                        name: 'API 2',
-                        type: 'graphql',
-                        version: 'v1',
-                        basePath: '/graphql',
-                        endpoints: [
-                            {
-                                id: 'query',
-                                path: '/graphql',
-                                responses: [],
-                            },
-                        ],
-                    });
-                },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            const stats = registry.getStats();
-            expect(stats.totalApis).toBe(2);
-            expect(stats.apisByType.rest).toBe(1);
-            expect(stats.apisByType.graphql).toBe(1);
-            await kernel.shutdown();
-        });
-        it('should support API discovery across plugins', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            const dataPlugin = {
-                name: 'data-plugin',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'customer_api',
-                        name: 'Customer API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/v1/customers',
-                        endpoints: [],
-                        metadata: {
-                            status: 'active',
-                            tags: ['crm', 'data'],
-                        },
-                    });
-                    registry.registerApi({
-                        id: 'product_api',
-                        name: 'Product API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/v1/products',
-                        endpoints: [],
-                        metadata: {
-                            status: 'active',
-                            tags: ['inventory', 'data'],
-                        },
-                    });
-                },
-            };
-            const analyticsPlugin = {
-                name: 'analytics-plugin',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'analytics_api',
-                        name: 'Analytics API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/v1/analytics',
-                        endpoints: [],
-                        metadata: {
-                            status: 'beta',
-                            tags: ['analytics', 'reporting'],
-                        },
-                    });
-                },
-            };
-            await kernel.use(dataPlugin);
-            await kernel.use(analyticsPlugin);
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            // Find all data APIs
-            const dataApis = registry.findApis({ tags: ['data'] });
-            expect(dataApis.total).toBe(2);
-            // Find active APIs
-            const activeApis = registry.findApis({ status: 'active' });
-            expect(activeApis.total).toBe(2);
-            // Find CRM APIs
-            const crmApis = registry.findApis({ tags: ['crm'] });
-            expect(crmApis.total).toBe(1);
-            expect(crmApis.apis[0].id).toBe('customer_api');
-            await kernel.shutdown();
-        });
-        it('should handle route conflicts based on strategy', async () => {
-            await kernel.use(createApiRegistryPlugin({
-                conflictResolution: 'priority',
-            }));
-            const corePlugin = {
-                name: 'core-plugin',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'core_api',
-                        name: 'Core API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api',
-                        endpoints: [
-                            {
-                                id: 'core_endpoint',
-                                method: 'GET',
-                                path: '/api/data/:object',
-                                priority: 900, // High priority
-                                summary: 'Core data endpoint',
-                                responses: [],
-                            },
-                        ],
-                    });
-                },
-            };
-            const pluginOverride = {
-                name: 'plugin-override',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'plugin_api',
-                        name: 'Plugin API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api',
-                        endpoints: [
-                            {
-                                id: 'plugin_endpoint',
-                                method: 'GET',
-                                path: '/api/data/:object',
-                                priority: 300, // Lower priority
-                                summary: 'Plugin data endpoint',
-                                responses: [],
-                            },
-                        ],
-                    });
-                },
-            };
-            await kernel.use(corePlugin);
-            await kernel.use(pluginOverride);
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            const result = registry.findEndpointByRoute('GET', '/api/data/:object');
-            // Core API should win due to higher priority
-            expect(result?.api.id).toBe('core_api');
-            expect(result?.endpoint.id).toBe('core_endpoint');
-            await kernel.shutdown();
-        });
-        it('should support cleanup on plugin unload', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            const dynamicPlugin = {
-                name: 'dynamic-plugin',
-                init: async (ctx) => {
-                    const registry = ctx.getService('api-registry');
-                    registry.registerApi({
-                        id: 'dynamic_api',
-                        name: 'Dynamic API',
-                        type: 'rest',
-                        version: 'v1',
-                        basePath: '/api/dynamic',
-                        endpoints: [
-                            {
-                                id: 'test',
-                                method: 'GET',
-                                path: '/api/dynamic/test',
-                                responses: [],
-                            },
-                        ],
-                    });
-                },
-                destroy: async () => {
-                    // In a real scenario, this would use ctx to access registry
-                    // For now, we'll test the registry's unregister capability
-                },
-            };
-            await kernel.use(dynamicPlugin);
-            await kernel.bootstrap();
-            const registry = kernel.getService('api-registry');
-            expect(registry.getApi('dynamic_api')).toBeDefined();
-            // Unregister the API
-            registry.unregisterApi('dynamic_api');
-            expect(registry.getApi('dynamic_api')).toBeUndefined();
-            await kernel.shutdown();
-        });
-    });
-    describe('API Registry Lifecycle', () => {
-        it('should be available during plugin start phase', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            let registryAvailable = false;
-            const testPlugin = {
-                name: 'test-plugin',
-                init: async () => {
-                    // Init phase
-                },
-                start: async (ctx) => {
-                    // Start phase - registry should be available
-                    const registry = ctx.getService('api-registry');
-                    registryAvailable = registry !== undefined;
-                },
-            };
-            await kernel.use(testPlugin);
-            await kernel.bootstrap();
-            expect(registryAvailable).toBe(true);
-            await kernel.shutdown();
-        });
-        it('should provide consistent registry across all plugins', async () => {
-            await kernel.use(createApiRegistryPlugin());
-            let registry1;
-            let registry2;
-            const plugin1 = {
-                name: 'plugin-1',
-                init: async (ctx) => {
-                    registry1 = ctx.getService('api-registry');
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                init: async (ctx) => {
-                    registry2 = ctx.getService('api-registry');
-                },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            // Same registry instance should be shared
-            expect(registry1).toBe(registry2);
-            await kernel.shutdown();
-        });
-    });
-});