@di-framework/di-framework-http 0.0.0-prerelease.308 → 0.0.0-prerelease.310

package/index.ts

@@ -1,5 +1,5 @@
-export * from "./src/typed-router.ts";
-export * from "./src/decorators.ts";
-export * from "./src/openapi.ts";
-export * from "./src/registry.ts";
-export { default as registry } from "./src/registry.ts";
+export * from './src/typed-router.ts';
+export * from './src/decorators.ts';
+export * from './src/openapi.ts';
+export * from './src/registry.ts';
+export { default as registry } from './src/registry.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@di-framework/di-framework-http",
-  "version": "0.0.0-prerelease.308",
+  "version": "0.0.0-prerelease.310",
   "description": "Extends di-framework with HTTP features",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -40,7 +40,7 @@
     "typescript": "^5"
   },
   "peerDependencies": {
-    "@di-framework/di-framework": "^0.0.0-prerelease.308",
+    "@di-framework/di-framework": "^0.0.0-prerelease.310",
     "typescript": "^5"
   }
 }

package/src/cli.test.ts

@@ -1,85 +1,76 @@
-import { describe, it, expect, afterEach } from "bun:test";
-import { spawnSync } from "child_process";
-import fs from "fs";
-import path from "path";
+import { describe, it, expect, afterEach } from 'bun:test';
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
 
-const CLI_PATH = path.resolve(import.meta.dir, "cli.ts");
-const TEST_OUTPUT = "test.openapi.json";
+const CLI_PATH = path.resolve(import.meta.dir, 'cli.ts');
+const TEST_OUTPUT = 'test.openapi.json';
 
-describe("CLI", () => {
+describe('CLI', () => {
   afterEach(() => {
     if (fs.existsSync(TEST_OUTPUT)) {
       fs.unlinkSync(TEST_OUTPUT);
     }
   });
 
-  it("should show help when no command is provided", () => {
-    const { stdout } = spawnSync("bun", [CLI_PATH]);
-    expect(stdout.toString()).toContain("Usage: di-framework-http generate");
+  it('should show help when no command is provided', () => {
+    const { stdout } = spawnSync('bun', [CLI_PATH]);
+    expect(stdout.toString()).toContain('Usage: di-framework-http generate');
   });
 
-  it("should error when --controllers is missing", () => {
-    const { stderr, status } = spawnSync("bun", [CLI_PATH, "generate"]);
+  it('should error when --controllers is missing', () => {
+    const { stderr, status } = spawnSync('bun', [CLI_PATH, 'generate']);
     expect(status).toBe(1);
-    expect(stderr.toString()).toContain(
-      "Error: --controllers path is required",
-    );
+    expect(stderr.toString()).toContain('Error: --controllers path is required');
   });
 
-  it("should generate OpenAPI spec with --controllers and --output", () => {
+  it('should generate OpenAPI spec with --controllers and --output', () => {
     const controllersPath = path.resolve(
       import.meta.dir,
-      "../../examples/packages/http-router/index.ts",
+      '../../examples/packages/http-router/index.ts',
     );
-    const { stdout, status } = spawnSync("bun", [
+    const { stdout, status } = spawnSync('bun', [
       CLI_PATH,
-      "generate",
-      "--controllers",
+      'generate',
+      '--controllers',
       controllersPath,
-      "--output",
+      '--output',
       TEST_OUTPUT,
     ]);
 
     expect(status).toBe(0);
-    expect(stdout.toString()).toContain(
-      "Successfully generated OpenAPI spec at test.openapi.json",
-    );
+    expect(stdout.toString()).toContain('Successfully generated OpenAPI spec at test.openapi.json');
     expect(fs.existsSync(TEST_OUTPUT)).toBe(true);
 
-    const spec = JSON.parse(fs.readFileSync(TEST_OUTPUT, "utf8"));
-    expect(spec.openapi).toBe("3.1.0");
-    expect(spec.paths["/echo"]).toBeDefined();
-    expect(spec.paths["/echo"].post).toBeDefined();
+    const spec = JSON.parse(fs.readFileSync(TEST_OUTPUT, 'utf8'));
+    expect(spec.openapi).toBe('3.1.0');
+    expect(spec.paths['/echo']).toBeDefined();
+    expect(spec.paths['/echo'].post).toBeDefined();
   });
 
-  it("should use default output path (openapi.json) if --output is missing", () => {
-    const DEFAULT_OUTPUT = "openapi.json";
+  it('should use default output path (openapi.json) if --output is missing', () => {
+    const DEFAULT_OUTPUT = 'openapi.json';
     if (fs.existsSync(DEFAULT_OUTPUT)) fs.unlinkSync(DEFAULT_OUTPUT);
 
     const controllersPath = path.resolve(
       import.meta.dir,
-      "../../examples/packages/http-router/index.ts",
+      '../../examples/packages/http-router/index.ts',
     );
-    const { status } = spawnSync("bun", [
-      CLI_PATH,
-      "generate",
-      "--controllers",
-      controllersPath,
-    ]);
+    const { status } = spawnSync('bun', [CLI_PATH, 'generate', '--controllers', controllersPath]);
 
     expect(status).toBe(0);
     expect(fs.existsSync(DEFAULT_OUTPUT)).toBe(true);
     fs.unlinkSync(DEFAULT_OUTPUT);
   });
 
-  it("should error with invalid controllers path", () => {
-    const { stderr, status } = spawnSync("bun", [
+  it('should error with invalid controllers path', () => {
+    const { stderr, status } = spawnSync('bun', [
       CLI_PATH,
-      "generate",
-      "--controllers",
-      "./non-existent-file.ts",
+      'generate',
+      '--controllers',
+      './non-existent-file.ts',
     ]);
     expect(status).toBe(1);
-    expect(stderr.toString()).toContain("Error generating OpenAPI spec");
+    expect(stderr.toString()).toContain('Error generating OpenAPI spec');
   });
 });

package/src/cli.ts

@@ -1,34 +1,31 @@
 #!/usr/bin/env bun
-import fs from "fs";
-import path from "path";
-import { generateOpenAPI } from "./openapi.ts";
-import registry from "./registry.ts";
+import fs from 'fs';
+import path from 'path';
+import { generateOpenAPI } from './openapi.ts';
+import registry from './registry.ts';
 
 const args = process.argv.slice(2);
 const command = args[0];
 
-if (command === "generate") {
-  const outputArg = args.indexOf("--output");
-  const outputPath = outputArg !== -1 ? args[outputArg + 1] : "openapi.json";
+if (command === 'generate') {
+  const outputArg = args.indexOf('--output');
+  const outputPath = outputArg !== -1 ? args[outputArg + 1] : 'openapi.json';
 
-  const controllersArg = args.indexOf("--controllers");
+  const controllersArg = args.indexOf('--controllers');
   if (controllersArg === -1) {
-    console.error("Error: --controllers path is required");
+    console.error('Error: --controllers path is required');
     process.exit(1);
   }
 
   async function run() {
     try {
       // Import the user's controllers to trigger decorator registration
-      const controllersPathResolved = path.resolve(
-        process.cwd(),
-        args[controllersArg + 1]!,
-      );
+      const controllersPathResolved = path.resolve(process.cwd(), args[controllersArg + 1]!);
       await import(controllersPathResolved);
 
       const spec = generateOpenAPI(
         {
-          title: "API Documentation",
+          title: 'API Documentation',
         },
         registry,
       );

package/src/decorators.test.ts

@@ -1,15 +1,17 @@
-import { describe, it, expect } from "bun:test";
-import { Controller, Endpoint } from "./decorators.ts";
-import registry from "./registry.ts";
+import { describe, it, expect } from 'bun:test';
+import { Controller, Endpoint, SCHEMAS } from './decorators.ts';
+import registry from './registry.ts';
+import { useContainer } from '@di-framework/di-framework/container';
+import { Component } from '@di-framework/di-framework/decorators';
 
-describe("Decorators", () => {
-  it("should register a controller and its endpoints", () => {
+describe('Decorators', () => {
+  it('should register a controller and its endpoints', () => {
     const initialSize = registry.getTargets().size;
 
     @Controller()
     class TestController {
-      @Endpoint({ summary: "Test endpoint" })
-      static test = { isEndpoint: true, path: "/test", method: "get" };
+      @Endpoint({ summary: 'Test endpoint' })
+      static test = { isEndpoint: true, path: '/test', method: 'get' };
     }
 
     expect(registry.getTargets().has(TestController)).toBe(true);
@@ -18,25 +20,25 @@ describe("Decorators", () => {
     // @ts-ignore
     expect(TestController.test.isEndpoint).toBe(true);
     // @ts-ignore
-    expect(TestController.test.metadata.summary).toBe("Test endpoint");
+    expect(TestController.test.metadata.summary).toBe('Test endpoint');
 
     expect(registry.getTargets().size).toBeGreaterThan(initialSize);
   });
 
-  it("should work as a class decorator for Endpoint", () => {
-    @Endpoint({ summary: "Class level" })
+  it('should work as a class decorator for Endpoint', () => {
+    @Endpoint({ summary: 'Class level' })
     class ClassEndpoint {}
 
     expect(registry.getTargets().has(ClassEndpoint)).toBe(true);
     // @ts-ignore
     expect(ClassEndpoint.isEndpoint).toBe(true);
     // @ts-ignore
-    expect(ClassEndpoint.metadata.summary).toBe("Class level");
+    expect(ClassEndpoint.metadata.summary).toBe('Class level');
   });
 
-  it("should work on instance methods (via prototype)", () => {
+  it('should work on instance methods (via prototype)', () => {
     class InstanceController {
-      @Endpoint({ summary: "Instance method" })
+      @Endpoint({ summary: 'Instance method' })
       method() {}
     }
 
@@ -44,4 +46,51 @@ describe("Decorators", () => {
     // @ts-ignore
     expect(InstanceController.prototype.method.isEndpoint).toBe(true);
   });
+
+  it('should inject static properties on Controller classes', () => {
+    class InjectedService {
+      value = 42;
+    }
+    useContainer().register(InjectedService);
+
+    @Controller()
+    class InjectedController {
+      @Component(InjectedService)
+      static service: InjectedService;
+    }
+
+    expect(InjectedController.service).toBeDefined();
+    expect(InjectedController.service.value).toBe(42);
+  });
+
+  it('should extract schemas from Endpoint metadata and store them via SCHEMAS symbol', () => {
+    class SchemaEndpoint {
+      @Endpoint({
+        responses: {
+          '200': {
+            description: 'A successful response',
+            content: {
+              'application/json': {
+                schema: { $ref: '#/components/schemas/MyModel' },
+              },
+            },
+          },
+        },
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/MyRequest' },
+            },
+          },
+        },
+      })
+      static myEndpoint() {}
+    }
+
+    const schemas = (SchemaEndpoint as any)[SCHEMAS];
+    expect(schemas).toBeDefined();
+    expect(schemas.has('MyModel')).toBe(true);
+    expect(schemas.has('MyRequest')).toBe(true);
+    expect(schemas.size).toBe(2);
+  });
 });

package/src/decorators.ts

@@ -1,24 +1,67 @@
-import registry from "./registry.ts";
-import { Container as ContainerDecorator } from "@di-framework/di-framework/decorators";
+import registry from './registry.ts';
+import { Container as ContainerDecorator } from '@di-framework/di-framework/decorators';
+import { getOwnMetadata, useContainer } from '@di-framework/di-framework/container';
 
-export function Controller(
-  options: { singleton?: boolean; container?: any } = {},
-) {
+const INJECT_METADATA_KEY = 'di:inject';
+export const SCHEMAS = Symbol.for('proseva:component-schemas');
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+interface ContainerLike {
+  resolve(token: unknown): unknown;
+}
+
+export function Controller(options: { singleton?: boolean; container?: any } = {}) {
   // Compose DI registration with OpenAPI registry marking
-  const container = ContainerDecorator(options);
+  const containerDecorator = ContainerDecorator(options);
   return function (target: any) {
     // Mark for HTTP/OpenAPI purposes
     target.isController = true;
     registry.addTarget(target);
 
     // Also register with the DI container (same instance as core framework)
-    container(target);
+    containerDecorator(target);
+
+    const container: ContainerLike = (options.container ?? useContainer()) as ContainerLike;
+
+    const rawMetadata: unknown = getOwnMetadata(INJECT_METADATA_KEY, target) as unknown;
+    const injectMetadata: UnknownRecord = isRecord(rawMetadata) ? rawMetadata : {};
+
+    for (const [propName, targetType] of Object.entries(injectMetadata)) {
+      if (!propName.startsWith('param_') && targetType) {
+        (target as UnknownRecord)[propName] = container.resolve(targetType);
+      }
+    }
   };
 }
 
+/** Extract all `#/components/schemas/<Name>` references from a metadata tree. */
+function extractSchemaRefs(obj: unknown, out: Set<string>): void {
+  if (typeof obj !== 'object' || obj === null) return;
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) extractSchemaRefs(item, out);
+    return;
+  }
+
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (key === '$ref' && typeof value === 'string') {
+      const match = /^#\/components\/schemas\/(.+)$/.exec(value);
+      if (match?.[1]) out.add(match[1]);
+    } else {
+      extractSchemaRefs(value, out);
+    }
+  }
+}
+
 export function Endpoint(metadata?: {
   summary?: string;
   description?: string;
+  parameters?: unknown[];
   requestBody?: any;
   responses?: Record<string, any>;
 }) {
@@ -28,22 +71,35 @@ export function Endpoint(metadata?: {
 
       // For static methods on a class, target is the constructor.
       // If it's a static method, target itself is the constructor.
-      const constructor =
-        typeof target === "function" ? target : target.constructor;
+      const constructor = typeof target === 'function' ? target : target.constructor;
       registry.addTarget(constructor);
 
       // We'll let the generator discover the details from the property for now,
       // or we could register it explicitly here if we had path/method info.
       // Since TypedRouter adds path/method to the handler, we keep it as is
       // but we can ensure the metadata is attached.
-      property.isEndpoint = true;
+      if (property) {
+        property.isEndpoint = true;
+        if (metadata) {
+          property.metadata = metadata;
+        }
+      }
+
+      // Also attach schemas if metadata is provided
       if (metadata) {
-        property.metadata = metadata;
+        const existing: Set<string> =
+          (constructor as Record<symbol, Set<string>>)[SCHEMAS] ?? new Set<string>();
+        extractSchemaRefs(metadata, existing);
+        (constructor as Record<symbol, Set<string>>)[SCHEMAS] = existing;
       }
     } else {
       target.isEndpoint = true;
       if (metadata) {
         target.metadata = metadata;
+        const existing: Set<string> =
+          (target as Record<symbol, Set<string>>)[SCHEMAS] ?? new Set<string>();
+        extractSchemaRefs(metadata, existing);
+        (target as Record<symbol, Set<string>>)[SCHEMAS] = existing;
       }
       registry.addTarget(target);
     }