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

package/README.md

@@ -36,9 +36,9 @@ import {
   type Json,
   Controller,
   Endpoint,
-} from "@di-framework/di-framework-http";
-import { Component, Container } from "@di-framework/di-framework/decorators";
-import { useContainer } from "@di-framework/di-framework/container";
+} from '@di-framework/di-framework-http';
+import { Component, Container } from '@di-framework/di-framework/decorators';
+import { useContainer } from '@di-framework/di-framework/container';
 
 const router = TypedRouter();
 
@@ -66,29 +66,28 @@ export class EchoController {
   }
 
   @Endpoint({
-    summary: "Echo a message",
-    description: "Returns the provided message with a server timestamp.",
+    summary: 'Echo a message',
+    description: 'Returns the provided message with a server timestamp.',
     responses: {
-      "200": { description: "Successful echo" },
+      '200': { description: 'Successful echo' },
     },
   })
-  static post = router.post<
-    RequestSpec<Json<EchoPayload>>,
-    ResponseSpec<EchoResponse>
-  >("/echo", (req) => {
-    // Demonstrate auto DI registration: resolve the controller instance from
-    // the global container without any manual registration.
-    const controller = useContainer().resolve(EchoController);
-    return json(controller.echoMessage(req.content.message));
-  });
+  static post = router.post<RequestSpec<Json<EchoPayload>>, ResponseSpec<EchoResponse>>(
+    '/echo',
+    (req) => {
+      // Demonstrate auto DI registration: resolve the controller instance from
+      // the global container without any manual registration.
+      const controller = useContainer().resolve(EchoController);
+      return json(controller.echoMessage(req.content.message));
+    },
+  );
 }
 
 // Add a simple GET route
-router.get("/", () => json({ message: "API is healthy" }));
+router.get('/', () => json({ message: 'API is healthy' }));
 
 export default {
-  fetch: (request: Request, env: any, ctx: any) =>
-    router.fetch(request, env, ctx),
+  fetch: (request: Request, env: any, ctx: any) => router.fetch(request, env, ctx),
 };
 ```
 
@@ -103,7 +102,7 @@ import {
   type RequestSpec,
   type ResponseSpec,
   type Multipart,
-} from "@di-framework/di-framework-http";
+} from '@di-framework/di-framework-http';
 
 const router = TypedRouter();
 
@@ -111,10 +110,10 @@ type UploadPayload = { files: File[] };
 type UploadResult = { filenames: string[] };
 
 router.post<RequestSpec<Multipart<UploadPayload>>, ResponseSpec<UploadResult>>(
-  "/upload",
+  '/upload',
   (req) => {
     // req.content is typed as FormData
-    const files = req.content.getAll("files") as File[];
+    const files = req.content.getAll('files') as File[];
     return json({ filenames: files.map((f) => f.name) });
   },
   { multipart: true },
@@ -144,13 +143,13 @@ bun x di-framework-http generate --controllers ./src/index.ts
 You can also generate the spec programmatically using the `generateOpenAPI` function and the default `registry`:
 
 ```typescript
-import registry, { generateOpenAPI } from "@di-framework/di-framework-http";
-import "./controllers/MyController"; // Import to trigger registration
+import registry, { generateOpenAPI } from '@di-framework/di-framework-http';
+import './controllers/MyController'; // Import to trigger registration
 
 const spec = generateOpenAPI(
   {
-    title: "My API",
-    version: "1.0.0",
+    title: 'My API',
+    version: '1.0.0',
   },
   registry,
 );
@@ -161,7 +160,7 @@ console.log(JSON.stringify(spec, null, 2));
 If you need full control, you can iterate the `registry` manually:
 
 ```typescript
-import registry from "@di-framework/di-framework-http";
+import registry from '@di-framework/di-framework-http';
 
 for (const target of registry.getTargets()) {
   // target is the decorated class

package/dist/index.d.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/dist/index.js

@@ -1,9 +1,5 @@
 // src/typed-router.ts
-import {
-  Router,
-  withContent,
-  json as ittyJson
-} from "itty-router";
+import { Router, withContent, json as ittyJson } from "itty-router";
 function json(data, init) {
   return ittyJson(data, init);
 }
@@ -21,15 +17,7 @@ function TypedRouter(opts) {
       req.content = await req.formData();
     } catch {}
   }
-  const methodsToProxy = [
-    "get",
-    "post",
-    "put",
-    "delete",
-    "patch",
-    "head",
-    "options"
-  ];
+  const methodsToProxy = ["get", "post", "put", "delete", "patch", "head", "options"];
   const wrapper = new Proxy(r, {
     get(target, prop, receiver) {
       if (typeof prop === "string" && methodsToProxy.includes(prop)) {
@@ -90,6 +78,7 @@ var TELEMETRY_METADATA_KEY = "di:telemetry";
 var TELEMETRY_LISTENER_METADATA_KEY = "di:telemetry-listener";
 var PUBLISHER_METADATA_KEY = "di:publisher";
 var SUBSCRIBER_METADATA_KEY = "di:subscriber";
+var CRON_METADATA_KEY = "di:cron";
 var metadataStore = new Map;
 function defineMetadata(key, value, target) {
   if (!metadataStore.has(target)) {
@@ -103,11 +92,64 @@ function getMetadata(key, target) {
 function getOwnMetadata(key, target) {
   return getMetadata(key, target);
 }
+function parseCronField(field, min, max) {
+  if (field === "*") {
+    const out = [];
+    for (let i = min;i <= max; i++)
+      out.push(i);
+    return out;
+  }
+  if (field.startsWith("*/")) {
+    const step = parseInt(field.slice(2), 10);
+    const out = [];
+    for (let i = min;i <= max; i++) {
+      if (i % step === 0)
+        out.push(i);
+    }
+    return out;
+  }
+  if (field.includes(",")) {
+    return field.split(",").map((s) => parseInt(s.trim(), 10));
+  }
+  if (field.includes("-")) {
+    const [lo = 0, hi = 0] = field.split("-").map((s) => parseInt(s.trim(), 10));
+    const out = [];
+    for (let i = lo;i <= hi; i++)
+      out.push(i);
+    return out;
+  }
+  return [parseInt(field, 10)];
+}
+function parseCronExpression(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5)
+    throw new Error(`Invalid cron expression "${expr}": expected 5 fields (minute hour dayOfMonth month dayOfWeek)`);
+  return {
+    minute: parseCronField(parts[0], 0, 59),
+    hour: parseCronField(parts[1], 0, 23),
+    dayOfMonth: parseCronField(parts[2], 1, 31),
+    month: parseCronField(parts[3], 1, 12),
+    dayOfWeek: parseCronField(parts[4], 0, 6)
+  };
+}
+function getNextCronTime(fields, from) {
+  const next = new Date(from);
+  next.setSeconds(0, 0);
+  next.setMinutes(next.getMinutes() + 1);
+  for (let i = 0;i < 1051920; i++) {
+    if (fields.minute.includes(next.getMinutes()) && fields.hour.includes(next.getHours()) && fields.dayOfMonth.includes(next.getDate()) && fields.month.includes(next.getMonth() + 1) && fields.dayOfWeek.includes(next.getDay())) {
+      return next;
+    }
+    next.setMinutes(next.getMinutes() + 1);
+  }
+  throw new Error(`No matching cron time found for expression within 2 years`);
+}
 
 class Container {
   services = new Map;
   resolutionStack = new Set;
   listeners = new Map;
+  cronJobs = [];
   register(serviceClass, options = { singleton: true }) {
     const name = serviceClass.name;
     this.services.set(name, {
@@ -193,9 +235,16 @@ class Container {
   }
   clear() {
     const count = this.services.size;
+    this.stopCronJobs();
     this.services.clear();
     this.emit("cleared", { count });
   }
+  stopCronJobs() {
+    for (const job of this.cronJobs) {
+      job.stop();
+    }
+    this.cronJobs = [];
+  }
   getServiceNames() {
     const names = new Set;
     this.services.forEach((_, key) => {
@@ -307,6 +356,55 @@ class Container {
       }
     });
   }
+  applyCron(instance, constructor) {
+    const cronMethods = getMetadata(CRON_METADATA_KEY, constructor.prototype) || {};
+    Object.entries(cronMethods).forEach(([methodName, schedule]) => {
+      const method = instance[methodName];
+      if (typeof method !== "function")
+        return;
+      if (typeof schedule === "number") {
+        const timer = setInterval(() => {
+          try {
+            method.call(instance);
+          } catch (err) {
+            console.error(`[Cron] ${constructor.name}.${methodName} threw`, err);
+          }
+        }, schedule);
+        this.cronJobs.push({ stop: () => clearInterval(timer) });
+      } else {
+        const fields = parseCronExpression(schedule);
+        let stopped = false;
+        const scheduleNext = () => {
+          if (stopped)
+            return;
+          const now = new Date;
+          const next = getNextCronTime(fields, now);
+          const delay = next.getTime() - now.getTime();
+          const timer = setTimeout(() => {
+            if (stopped)
+              return;
+            try {
+              method.call(instance);
+            } catch (err) {
+              console.error(`[Cron] ${constructor.name}.${methodName} threw`, err);
+            }
+            scheduleNext();
+          }, delay);
+          job.stop = () => {
+            stopped = true;
+            clearTimeout(timer);
+          };
+        };
+        const job = {
+          stop: () => {
+            stopped = true;
+          }
+        };
+        this.cronJobs.push(job);
+        scheduleNext();
+      }
+    });
+  }
   instantiate(type, overrides = {}) {
     if (typeof type !== "function") {
       throw new Error("Service type must be a constructor or factory function");
@@ -342,6 +440,7 @@ class Container {
     const instance = new type(...dependencies);
     this.applyTelemetry(instance, type);
     this.applyEvents(instance, type);
+    this.applyCron(instance, type);
     const injectProperties = getMetadata(INJECT_METADATA_KEY, type) || {};
     const protoInjectProperties = getMetadata(INJECT_METADATA_KEY, type.prototype) || {};
     const allInjectProperties = {
@@ -462,34 +561,119 @@ function Container2(options = {}) {
 }
 
 // src/decorators.ts
+var INJECT_METADATA_KEY2 = "di:inject";
+var SCHEMAS = Symbol.for("proseva:component-schemas");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function Controller(options = {}) {
-  const container2 = Container2(options);
+  const containerDecorator = Container2(options);
   return function(target) {
     target.isController = true;
     registry_default.addTarget(target);
-    container2(target);
+    containerDecorator(target);
+    const container2 = options.container ?? useContainer();
+    const rawMetadata = getOwnMetadata(INJECT_METADATA_KEY2, target);
+    const injectMetadata = isRecord(rawMetadata) ? rawMetadata : {};
+    for (const [propName, targetType] of Object.entries(injectMetadata)) {
+      if (!propName.startsWith("param_") && targetType) {
+        target[propName] = container2.resolve(targetType);
+      }
+    }
   };
 }
+function extractSchemaRefs(obj, out) {
+  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)) {
+    if (key === "$ref" && typeof value === "string") {
+      const match = /^#\/components\/schemas\/(.+)$/.exec(value);
+      if (match?.[1])
+        out.add(match[1]);
+    } else {
+      extractSchemaRefs(value, out);
+    }
+  }
+}
 function Endpoint(metadata) {
   return function(target, propertyKey) {
     if (propertyKey) {
       const property = target[propertyKey];
       const constructor = typeof target === "function" ? target : target.constructor;
       registry_default.addTarget(constructor);
-      property.isEndpoint = true;
+      if (property) {
+        property.isEndpoint = true;
+        if (metadata) {
+          property.metadata = metadata;
+        }
+      }
       if (metadata) {
-        property.metadata = metadata;
+        const existing = constructor[SCHEMAS] ?? new Set;
+        extractSchemaRefs(metadata, existing);
+        constructor[SCHEMAS] = existing;
       }
     } else {
       target.isEndpoint = true;
       if (metadata) {
         target.metadata = metadata;
+        const existing = target[SCHEMAS] ?? new Set;
+        extractSchemaRefs(metadata, existing);
+        target[SCHEMAS] = existing;
       }
       registry_default.addTarget(target);
     }
   };
 }
 // src/openapi.ts
+function collectRefs(obj, out) {
+  if (typeof obj !== "object" || obj === null)
+    return;
+  if (Array.isArray(obj)) {
+    for (const item of obj)
+      collectRefs(item, out);
+    return;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "$ref" && typeof value === "string") {
+      const match = /^#\/components\/schemas\/(.+)$/.exec(value);
+      if (match?.[1])
+        out.add(match[1]);
+    } else {
+      collectRefs(value, out);
+    }
+  }
+}
+function resolveSchema(name, resolved, schemas) {
+  if (name in resolved)
+    return;
+  const schema = schemas[name];
+  if (!schema)
+    return;
+  resolved[name] = schema;
+  const transitive = new Set;
+  collectRefs(schema, transitive);
+  for (const dep of transitive) {
+    resolveSchema(dep, resolved, schemas);
+  }
+}
+function toOpenAPIPath(path) {
+  return path.replace(/:([a-zA-Z_]\w*)/g, "{$1}");
+}
+function extractPathParams(path) {
+  const names = [];
+  const re = /:([a-zA-Z_]\w*)/g;
+  let m;
+  while ((m = re.exec(path)) !== null) {
+    if (m[1])
+      names.push(m[1]);
+  }
+  return names;
+}
 function generateOpenAPI(options = {}, registryToUse = registry_default) {
   const spec = {
     openapi: "3.1.0",
@@ -504,12 +688,16 @@ function generateOpenAPI(options = {}, registryToUse = registry_default) {
     }
   };
   const targets = registryToUse.getTargets();
+  const metaParamsMap = new Map;
   for (const target of targets) {
     for (const key of Object.getOwnPropertyNames(target)) {
       const property = target[key];
       if (property && property.isEndpoint) {
         const path = property.path || "/unknown";
-        const method = property.method || "get";
+        const method = (property.method || "get").toLowerCase();
+        if (property.metadata?.parameters) {
+          metaParamsMap.set(`${path}|${method}`, property.metadata.parameters);
+        }
         if (!spec.paths[path]) {
           spec.paths[path] = {};
         }
@@ -527,6 +715,36 @@ function generateOpenAPI(options = {}, registryToUse = registry_default) {
       }
     }
   }
+  const rewrittenPaths = {};
+  for (const [rawPath, methods] of Object.entries(spec.paths)) {
+    const openApiPath = toOpenAPIPath(rawPath);
+    const pathParamNames = extractPathParams(rawPath);
+    const autoParams = pathParamNames.map((name) => ({
+      name,
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    }));
+    rewrittenPaths[openApiPath] ??= {};
+    for (const [method, operation] of Object.entries(methods)) {
+      const decoratorParams = metaParamsMap.get(`${rawPath}|${method}`) ?? [];
+      if (autoParams.length > 0 || decoratorParams.length > 0) {
+        operation.parameters = [...autoParams, ...decoratorParams];
+      }
+      rewrittenPaths[openApiPath][method] = operation;
+    }
+  }
+  spec.paths = rewrittenPaths;
+  const resolved = {};
+  for (const target of targets) {
+    const refs = target[SCHEMAS];
+    if (!refs)
+      continue;
+    for (const name of refs) {
+      resolveSchema(name, resolved, options.schemas || {});
+    }
+  }
+  spec.components.schemas = resolved;
   return spec;
 }
 export {
@@ -534,6 +752,7 @@ export {
   json,
   generateOpenAPI,
   TypedRouter,
+  SCHEMAS,
   Registry,
   Endpoint,
   Controller