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

package/dist/src/cli.js

@@ -18,7 +18,610 @@ var GLOBAL_KEY = Symbol.for("@di-framework/http-registry");
 var registry = globalThis[GLOBAL_KEY] ?? (globalThis[GLOBAL_KEY] = new Registry);
 var registry_default = registry;
 
+// ../di-framework/dist/container.js
+var INJECT_METADATA_KEY = "di:inject";
+var DESIGN_PARAM_TYPES_KEY = "design:paramtypes";
+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)) {
+    metadataStore.set(target, new Map);
+  }
+  metadataStore.get(target).set(key, value);
+}
+function getMetadata(key, target) {
+  return metadataStore.get(target)?.get(key);
+}
+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, {
+      type: serviceClass,
+      singleton: options.singleton ?? true
+    });
+    this.services.set(serviceClass, {
+      type: serviceClass,
+      singleton: options.singleton ?? true
+    });
+    this.emit("registered", {
+      key: serviceClass,
+      singleton: options.singleton ?? true,
+      kind: "class"
+    });
+    return this;
+  }
+  registerFactory(name, factory, options = { singleton: true }) {
+    this.services.set(name, {
+      type: factory,
+      singleton: options.singleton ?? true
+    });
+    this.emit("registered", {
+      key: name,
+      singleton: options.singleton ?? true,
+      kind: "factory"
+    });
+    return this;
+  }
+  resolve(serviceClass) {
+    const key = typeof serviceClass === "string" ? serviceClass : serviceClass;
+    const keyStr = typeof serviceClass === "string" ? serviceClass : serviceClass.name;
+    if (this.resolutionStack.has(key)) {
+      throw new Error(`Circular dependency detected while resolving ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(" -> ")} -> ${keyStr}`);
+    }
+    const definition = this.services.get(key);
+    if (!definition) {
+      throw new Error(`Service '${keyStr}' is not registered in the DI container`);
+    }
+    const wasCached = definition.singleton && !!definition.instance;
+    if (definition.singleton && definition.instance) {
+      this.emit("resolved", {
+        key,
+        instance: definition.instance,
+        singleton: true,
+        fromCache: true
+      });
+      return definition.instance;
+    }
+    this.resolutionStack.add(key);
+    try {
+      const instance = this.instantiate(definition.type);
+      if (definition.singleton) {
+        definition.instance = instance;
+      }
+      this.emit("resolved", {
+        key,
+        instance,
+        singleton: definition.singleton,
+        fromCache: wasCached
+      });
+      return instance;
+    } finally {
+      this.resolutionStack.delete(key);
+    }
+  }
+  construct(serviceClass, overrides = {}) {
+    const keyStr = serviceClass.name;
+    if (this.resolutionStack.has(serviceClass)) {
+      throw new Error(`Circular dependency detected while constructing ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(" -> ")} -> ${keyStr}`);
+    }
+    this.resolutionStack.add(serviceClass);
+    try {
+      const instance = this.instantiate(serviceClass, overrides);
+      this.emit("constructed", { key: serviceClass, instance, overrides });
+      return instance;
+    } finally {
+      this.resolutionStack.delete(serviceClass);
+    }
+  }
+  has(serviceClass) {
+    return this.services.has(serviceClass);
+  }
+  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) => {
+      if (typeof key === "string") {
+        names.add(key);
+      }
+    });
+    return Array.from(names);
+  }
+  fork(options = {}) {
+    const clone = new Container;
+    this.services.forEach((def, key) => {
+      clone.services.set(key, {
+        ...def,
+        instance: options.carrySingletons ? def.instance : undefined
+      });
+    });
+    return clone;
+  }
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    const listeners = this.listeners.get(event);
+    if (!listeners || listeners.size === 0)
+      return;
+    listeners.forEach((listener) => {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.error(`[Container] listener for '${String(event)}' threw`, err);
+      }
+    });
+  }
+  applyEvents(instance, constructor) {
+    const className = constructor.name;
+    const subscriberMap = getMetadata(SUBSCRIBER_METADATA_KEY, constructor.prototype) || {};
+    Object.entries(subscriberMap).forEach(([event, methods]) => {
+      methods.forEach((methodName) => {
+        const method = instance[methodName];
+        if (typeof method === "function") {
+          this.on(event, (payload) => {
+            try {
+              method.call(instance, payload);
+            } catch (err) {
+              console.error(`[Container] Subscriber '${className}.${methodName}' for event '${event}' threw`, err);
+            }
+          });
+        }
+      });
+    });
+    const publisherMethods = getMetadata(PUBLISHER_METADATA_KEY, constructor.prototype) || {};
+    Object.entries(publisherMethods).forEach(([methodName, options]) => {
+      const originalMethod = instance[methodName];
+      if (typeof originalMethod === "function") {
+        const self = this;
+        const phase = options.phase ?? "after";
+        instance[methodName] = function(...args) {
+          const startTime = Date.now();
+          const emit = (result, error) => {
+            const payload = {
+              className,
+              methodName,
+              args,
+              startTime,
+              endTime: Date.now(),
+              result,
+              error
+            };
+            if (options.logging) {
+              const duration = payload.endTime - payload.startTime;
+              const status = error ? `ERROR: ${error && error.message ? error.message : String(error)}` : "SUCCESS";
+              console.log(`[Publisher] ${className}.${methodName} -> '${options.event}' - ${status} (${duration}ms)`);
+            }
+            self.emit(options.event, payload);
+          };
+          try {
+            if (phase === "before" || phase === "both") {
+              emit(undefined, undefined);
+            }
+            const result = originalMethod.apply(this, args);
+            if (result instanceof Promise) {
+              return result.then((val) => {
+                if (phase === "after" || phase === "both") {
+                  emit(val, undefined);
+                }
+                return val;
+              }).catch((err) => {
+                emit(undefined, err);
+                throw err;
+              });
+            }
+            if (phase === "after" || phase === "both") {
+              emit(result, undefined);
+            }
+            return result;
+          } catch (err) {
+            emit(undefined, err);
+            throw err;
+          }
+        };
+      }
+    });
+  }
+  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");
+    }
+    if (!this.isClass(type)) {
+      return type();
+    }
+    const paramTypes = getMetadata(DESIGN_PARAM_TYPES_KEY, type) || [];
+    const paramNames = this.getConstructorParamNames(type);
+    const dependencies = [];
+    const injectMetadata = getOwnMetadata(INJECT_METADATA_KEY, type) || {};
+    const paramCount = Math.max(paramTypes.length, paramNames.length);
+    for (let i = 0;i < paramCount; i++) {
+      if (Object.prototype.hasOwnProperty.call(overrides, i)) {
+        dependencies.push(overrides[i]);
+        continue;
+      }
+      const paramType = paramTypes[i];
+      const paramName = paramNames[i];
+      const paramInjectTarget = injectMetadata[`param_${i}`];
+      if (paramInjectTarget) {
+        dependencies.push(this.resolve(paramInjectTarget));
+      } else if (paramType && paramType !== Object) {
+        if (this.has(paramType)) {
+          dependencies.push(this.resolve(paramType));
+        } else if (this.has(paramType.name)) {
+          dependencies.push(this.resolve(paramType.name));
+        } else {
+          throw new Error(`Cannot resolve dependency of type ${paramType.name} for parameter '${paramName}' in ${type.name}`);
+        }
+      } else {}
+    }
+    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 = {
+      ...injectProperties,
+      ...protoInjectProperties
+    };
+    Object.entries(allInjectProperties).forEach(([propName, targetType]) => {
+      if (!propName.startsWith("param_") && targetType) {
+        try {
+          instance[propName] = this.resolve(targetType);
+        } catch (error) {
+          console.warn(`Failed to inject property '${propName}' on ${type.name}:`, error);
+        }
+      }
+    });
+    return instance;
+  }
+  applyTelemetry(instance, constructor) {
+    const className = constructor.name;
+    const listenerMethods = getMetadata(TELEMETRY_LISTENER_METADATA_KEY, constructor.prototype) || [];
+    listenerMethods.forEach((methodName) => {
+      const method = instance[methodName];
+      if (typeof method === "function") {
+        this.on("telemetry", (payload) => {
+          try {
+            method.call(instance, payload);
+          } catch (err) {
+            console.error(`[Container] TelemetryListener '${className}.${methodName}' threw`, err);
+          }
+        });
+      }
+    });
+    const telemetryMethods = getMetadata(TELEMETRY_METADATA_KEY, constructor.prototype) || {};
+    Object.entries(telemetryMethods).forEach(([methodName, options]) => {
+      const originalMethod = instance[methodName];
+      if (typeof originalMethod === "function") {
+        const self = this;
+        instance[methodName] = function(...args) {
+          const startTime = Date.now();
+          const emit = (result, error) => {
+            const payload = {
+              className,
+              methodName,
+              args,
+              startTime,
+              endTime: Date.now(),
+              result,
+              error
+            };
+            if (options.logging) {
+              const duration = payload.endTime - payload.startTime;
+              const status = error ? `ERROR: ${error.message || error}` : "SUCCESS";
+              console.log(`[Telemetry] ${className}.${methodName} - ${status} (${duration}ms)`);
+            }
+            self.emit("telemetry", payload);
+          };
+          try {
+            const result = originalMethod.apply(this, args);
+            if (result instanceof Promise) {
+              return result.then((val) => {
+                emit(val);
+                return val;
+              }).catch((err) => {
+                emit(undefined, err);
+                throw err;
+              });
+            }
+            emit(result);
+            return result;
+          } catch (err) {
+            emit(undefined, err);
+            throw err;
+          }
+        };
+      }
+    });
+  }
+  isClass(func) {
+    return typeof func === "function" && func.prototype && func.prototype.constructor === func;
+  }
+  getConstructorParamNames(target) {
+    const funcStr = target.toString();
+    const match = funcStr.match(/constructor\s*\(([^)]*)\)/);
+    if (!match || !match[1])
+      return [];
+    const paramsStr = match[1];
+    return paramsStr.split(",").map((param) => {
+      const trimmed = param.trim();
+      const withoutDefault = trimmed.split("=")[0] || "";
+      const withoutType = withoutDefault.split(":")[0] || "";
+      return withoutType.trim();
+    }).filter((param) => param);
+  }
+  extractParamTypesFromSource(target) {
+    const funcStr = target.toString();
+    const decoratorMatch = funcStr.match(/__decorate\(\[\s*(?:\w+\s*\([^)]*\),?\s*)*__param\((\d+),\s*(\w+)\([^)]*\)\)/g);
+    if (decoratorMatch) {
+      return [];
+    }
+    return [];
+  }
+}
+var container = new Container;
+function useContainer() {
+  return container;
+}
+
+// ../di-framework/dist/decorators.js
+var INJECTABLE_METADATA_KEY = "di:injectable";
+function Container2(options = {}) {
+  return function(constructor) {
+    const container2 = options.container ?? useContainer();
+    const singleton = options.singleton ?? true;
+    defineMetadata(INJECTABLE_METADATA_KEY, true, constructor);
+    container2.register(constructor, { singleton });
+    return constructor;
+  };
+}
+
+// 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 containerDecorator = Container2(options);
+  return function(target) {
+    target.isController = true;
+    registry_default.addTarget(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);
+      if (property) {
+        property.isEndpoint = true;
+        if (metadata) {
+          property.metadata = metadata;
+        }
+      }
+      if (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",
@@ -33,12 +636,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] = {};
         }
@@ -56,6 +663,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;
 }
 

package/dist/src/decorators.d.ts

@@ -1,3 +1,4 @@
+export declare const SCHEMAS: unique symbol;
 export declare function Controller(options?: {
     singleton?: boolean;
     container?: any;
@@ -5,6 +6,7 @@ export declare function Controller(options?: {
 export declare function Endpoint(metadata?: {
     summary?: string;
     description?: string;
+    parameters?: unknown[];
     requestBody?: any;
     responses?: Record<string, any>;
 }): (target: any, propertyKey?: string) => void;

package/dist/src/openapi.d.ts

@@ -3,5 +3,6 @@ export type OpenAPIOptions = {
     version?: string;
     description?: string;
     outputPath?: string;
+    schemas?: Record<string, unknown>;
 };
 export declare function generateOpenAPI(options?: OpenAPIOptions, registryToUse?: import("./registry.ts").Registry): any;

package/dist/src/typed-router.d.ts

@@ -1,11 +1,11 @@
-import { Router, type IRequest } from "itty-router";
+import { Router, type IRequest } from 'itty-router';
 /** Marker for body "shape + content-type" */
 export type Json<T> = {
-    readonly __kind: "json";
+    readonly __kind: 'json';
     readonly __type?: T;
 };
 export type Multipart<T> = {
-    readonly __kind: "multipart";
+    readonly __kind: 'multipart';
     readonly __type?: T;
 };
 export type PathParams<T> = {
@@ -26,7 +26,7 @@ type ContentOf<BodySpec> = BodySpec extends Json<infer T> ? T : BodySpec extends
 type PathParamsOf<BodySpec> = BodySpec extends PathParams<infer T> ? T : Record<string, string>;
 type QueryParamsOf<BodySpec> = BodySpec extends QueryParams<infer T> ? T : Record<string, string | string[] | undefined>;
 /** The actual request type your handlers receive */
-export type TypedRequest<ReqSpec> = Omit<IRequest, "params" | "query"> & {
+export type TypedRequest<ReqSpec> = Omit<IRequest, 'params' | 'query'> & {
     content: ContentOf<ReqSpec extends RequestSpec<infer B> ? B : never>;
     params: PathParamsOf<ReqSpec extends RequestSpec<infer B> ? B : never>;
     query: QueryParamsOf<ReqSpec extends RequestSpec<infer B> ? B : never>;