@onebun/core 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",

package/src/application/application.test.ts

@@ -432,6 +432,236 @@ describe('OneBunApplication', () => {
       expect(prodApp).toBeInstanceOf(OneBunApplication);
     });
 
+    test('should use PORT env variable when port is not explicitly provided', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '4567';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:4567');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should use HOST env variable when host is not explicitly provided', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '192.168.1.100';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://192.168.1.100:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
+    test('should use both PORT and HOST env variables when not explicitly provided', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '8888';
+        process.env.HOST = '10.0.0.1';
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://10.0.0.1:8888');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should prefer explicit port over PORT env variable', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '9999';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule, { port: 5555 });
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:5555');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should prefer explicit host over HOST env variable', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '192.168.1.100';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule, { host: 'localhost' });
+        expect(app.getHttpUrl()).toBe('http://localhost:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
+    test('should use defaults when env variables are not set', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        delete process.env.PORT;
+        delete process.env.HOST;
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort !== undefined) {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost !== undefined) {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore invalid PORT env variable and use default', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = 'invalid';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore empty PORT env variable and use default', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore empty HOST env variable and use default', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
     test('should handle complex envSchema configuration', () => {
       @Module({})
       class TestModule {}

package/src/application/application.ts

@@ -112,17 +112,48 @@ function normalizePath(path: string): string {
   return path.endsWith('/') ? path.slice(0, -1) : path;
 }
 
+/**
+ * Resolve port from options, environment variable, or default.
+ * Priority: explicit option > PORT env > default (3000)
+ */
+function resolvePort(explicitPort: number | undefined): number {
+  if (explicitPort !== undefined) {
+    return explicitPort;
+  }
+  const envPort = process.env.PORT;
+  if (envPort !== undefined && envPort !== '') {
+    const parsed = parseInt(envPort, 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+
+  return 3000;
+}
+
+/**
+ * Resolve host from options, environment variable, or default.
+ * Priority: explicit option > HOST env > default ('0.0.0.0')
+ */
+function resolveHost(explicitHost: string | undefined): string {
+  if (explicitHost !== undefined) {
+    return explicitHost;
+  }
+  const envHost = process.env.HOST;
+  if (envHost !== undefined && envHost !== '') {
+    return envHost;
+  }
+
+  return '0.0.0.0';
+}
+
 /**
  * OneBun Application
  */
 export class OneBunApplication {
   private rootModule: ModuleInstance;
   private server: ReturnType<typeof Bun.serve> | null = null;
-  private options: ApplicationOptions = {
-    port: 3000,
-    host: '0.0.0.0',
-    development: process.env.NODE_ENV !== 'production',
-  };
+  private options: ApplicationOptions;
   private logger: SyncLogger;
   private config: IConfig<OneBunAppConfig>;
   private configService: ConfigServiceImpl | null = null;
@@ -144,9 +175,13 @@ export class OneBunApplication {
     moduleClass: new (...args: unknown[]) => object,
     options?: Partial<ApplicationOptions>,
   ) {
-    if (options) {
-      this.options = { ...this.options, ...options };
-    }
+    // Resolve port and host with priority: explicit > env > default
+    this.options = {
+      port: resolvePort(options?.port),
+      host: resolveHost(options?.host),
+      development: options?.development ?? process.env.NODE_ENV !== 'production',
+      ...options,
+    };
 
     // Initialize configuration - TypedEnv if schema provided, otherwise NotInitializedConfig
     if (this.options.envSchema) {

package/src/module/module.ts

@@ -326,11 +326,12 @@ export class OneBunModule implements ModuleInstance {
       }
     }
 
-    if (iterations >= maxIterations) {
-      const unresolvedServices = pendingProviders
-        .filter((p) => typeof p === 'function')
-        .map((p) => p.name);
+    // Only report circular dependency if there are still unresolved services
+    const unresolvedServices = pendingProviders
+      .filter((p) => typeof p === 'function')
+      .map((p) => p.name);
 
+    if (iterations >= maxIterations && unresolvedServices.length > 0) {
       const details = unresolvedServices
         .map((serviceName) => {
           const deps = unresolvedDeps.get(serviceName) || [];