fragment-ts 1.0.0 → 1.0.1

package/src/core/container/di-container.ts

@@ -1,43 +1,100 @@
-
-import 'reflect-metadata';
-import { AUTOWIRE_METADATA } from '../decorators/autowire.decorator';
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { Scope } from '../decorators/injectable.decorator';
 
 export class DIContainer {
-  private static instances = new Map<any, any>();
-  private static classes = new Set<any>();
+  private static instance: DIContainer;
+  private singletons: Map<any, any> = new Map();
+  private transients: Map<any, any> = new Map();
+  private factories: Map<any, () => any> = new Map();
 
-  static register(target: any): void {
-    this.classes.add(target);
+  static getInstance(): DIContainer {
+    if (!DIContainer.instance) {
+      DIContainer.instance = new DIContainer();
+    }
+    return DIContainer.instance;
   }
 
-  static resolve<T>(target: any): T {
-    // Return existing singleton if available
-    if (this.instances.has(target)) {
-      return this.instances.get(target);
+  register(token: any, instance?: any, factory?: () => any): void {
+    if (instance) {
+      this.singletons.set(token, instance);
+    } else if (factory) {
+      this.factories.set(token, factory);
     }
+  }
 
-    // Get constructor parameter metadata
-    const params = Reflect.getOwnMetadata(AUTOWIRE_METADATA, target) || [];
-    const sortedParams = params.sort((a: any, b: any) => a.index - b.index);
+  resolve<T>(token: any): T {
+    if (this.singletons.has(token)) {
+      return this.singletons.get(token);
+    }
 
-    // Resolve dependencies recursively
-    const dependencies = sortedParams.map((param: any) => {
-      return this.resolve(param.type);
-    });
+    if (this.factories.has(token)) {
+      const factory = this.factories.get(token)!;
+      const instance = factory();
+      const scope = Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || 'singleton';
+      
+      if (scope === 'singleton') {
+        this.singletons.set(token, instance);
+      }
+      
+      return instance;
+    }
 
-    // Create instance
-    const instance = new target(...dependencies);
-    this.instances.set(target, instance);
+    if (typeof token === 'function') {
+      const instance = this.createInstance(token);
+      const scope = Reflect.getMetadata(METADATA_KEYS.SCOPE, token) || 'singleton';
+      
+      if (scope === 'singleton') {
+        this.singletons.set(token, instance);
+      }
+      
+      return instance;
+    }
 
+    throw new Error(`Cannot resolve dependency: ${token}`);
+  }
+
+  private createInstance(target: any): any {
+    const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
+    const params = paramTypes.map((type: any) => this.resolve(type));
+    const instance = new target(...params);
+    
+    this.injectProperties(instance);
+    
     return instance;
   }
 
-  static getRegisteredClasses(): any[] {
-    return Array.from(this.classes);
+  private injectProperties(instance: any): void {
+    const properties = Object.getOwnPropertyNames(instance.constructor.prototype);
+    
+    properties.forEach(prop => {
+      const autowired = Reflect.getMetadata(METADATA_KEYS.AUTOWIRED, instance, prop);
+      const inject = Reflect.getMetadata(METADATA_KEYS.INJECT, instance, prop);
+      const value = Reflect.getMetadata(METADATA_KEYS.VALUE, instance, prop);
+      
+      if (autowired) {
+        instance[prop] = this.resolve(autowired);
+      } else if (inject) {
+        instance[prop] = this.resolve(inject);
+      } else if (value) {
+        instance[prop] = this.resolveValue(value);
+      }
+    });
+  }
+
+  private resolveValue(expression: string): any {
+    const match = expression.match(/\$\{(.+?)\}/);
+    if (match) {
+      const key = match[1];
+      return process.env[key] || '';
+    }
+    return expression;
+  }
+
+  has(token: any): boolean {
+    return this.singletons.has(token) || this.factories.has(token);
   }
 
-  static clear(): void {
-    this.instances.clear();
-    this.classes.clear();
+  getAllInstances(): any[] {
+    return Array.from(this.singletons.values());
   }
 }

package/src/core/decorators/application.decorator.ts

@@ -0,0 +1,26 @@
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+
+export interface ApplicationOptions {
+  port?: number;
+  host?: string;
+  configPath?: string;
+  autoScan?: boolean;
+}
+
+export function FragmentApplication(
+  options: ApplicationOptions = {},
+): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(
+      METADATA_KEYS.APPLICATION,
+      {
+        ...options,
+        port: options.port || 3000,
+        host: options.host || "0.0.0.0",
+        configPath: options.configPath || "fragment.json",
+        autoScan: options.autoScan || true,
+      },
+      target,
+    );
+  };
+}

package/src/core/decorators/auto-configuration.decorator.ts

@@ -0,0 +1,17 @@
+import { Injectable } from './injectable.decorator';
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { MetadataStorage } from '../metadata/metadata-storage';
+
+export function AutoConfiguration(): ClassDecorator {
+  return (target: any) => {
+    Injectable('singleton')(target);
+    Reflect.defineMetadata(METADATA_KEYS.AUTO_CONFIGURATION, true, target);
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
+      target,
+      type: 'auto-configuration',
+      scope: 'singleton'
+    });
+  };
+}

package/src/core/decorators/conditional.decorators.ts

@@ -0,0 +1,19 @@
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+
+export function ConditionalOnClass(classRef: any): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_CLASS, classRef, target);
+  };
+}
+
+export function ConditionalOnMissingBean(token: any): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_MISSING_BEAN, token, target);
+  };
+}
+
+export function ConditionalOnProperty(key: string, expectedValue?: any): ClassDecorator {
+  return (target: any) => {
+    Reflect.defineMetadata(METADATA_KEYS.CONDITIONAL_ON_PROPERTY, { key, expectedValue }, target);
+  };
+}

package/src/core/decorators/controller.decorator.ts

@@ -1,15 +1,18 @@
-
-import 'reflect-metadata';
-import { DIContainer } from '../container/di-container';
-
-export const CONTROLLER_METADATA = 'controller:metadata';
-export const CONTROLLER_PATH = 'controller:path';
+import { Injectable } from './injectable.decorator';
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { MetadataStorage } from '../metadata/metadata-storage';
 
 export function Controller(path: string = ''): ClassDecorator {
   return (target: any) => {
-    Reflect.defineMetadata(CONTROLLER_METADATA, true, target);
-    Reflect.defineMetadata(CONTROLLER_PATH, path, target);
-    DIContainer.register(target);
-    return target;
+    Injectable('singleton')(target);
+    Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, path, target);
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
+      target,
+      type: 'controller',
+      scope: 'singleton',
+      path
+    });
   };
-}
+}

package/src/core/decorators/http.decorators.ts

@@ -0,0 +1,71 @@
+import { METADATA_KEYS } from "../metadata/metadata-keys";
+import { MetadataStorage } from "../metadata/metadata-storage";
+
+function createHttpMethodDecorator(method: string) {
+  return (path: string = ""): MethodDecorator => {
+    return (
+      target: any,
+      propertyKey: string | symbol,
+      descriptor: PropertyDescriptor,
+    ) => {
+      Reflect.defineMetadata(
+        METADATA_KEYS.HTTP_METHOD,
+        method,
+        target,
+        propertyKey,
+      );
+      Reflect.defineMetadata(
+        METADATA_KEYS.ROUTE_PATH,
+        path,
+        target,
+        propertyKey,
+      );
+
+      const storage = MetadataStorage.getInstance();
+      storage.addMethod({
+        target: target.constructor,
+        propertyKey: propertyKey as string,
+        method,
+        path,
+        paramMetadata: storage.getParams(target, propertyKey as string),
+      });
+    };
+  };
+}
+
+export const Get = createHttpMethodDecorator("GET");
+export const Post = createHttpMethodDecorator("POST");
+export const Put = createHttpMethodDecorator("PUT");
+export const Delete = createHttpMethodDecorator("DELETE");
+export const Patch = createHttpMethodDecorator("PATCH");
+
+function createParamDecorator(type: string) {
+  return (paramName?: string): ParameterDecorator => {
+    return (
+      target: Object,
+      propertyKey: string | symbol | undefined,
+      parameterIndex: number,
+    ): void => {
+      if (!propertyKey) {
+        throw new Error(`@${type}() cannot be used on constructor parameters`);
+      }
+
+      const storage = MetadataStorage.getInstance();
+
+      storage.addParam({
+        target,
+        propertyKey: propertyKey.toString(),
+        index: parameterIndex,
+        type: type as any,
+        paramName,
+      });
+    };
+  };
+}
+
+export const Body = createParamDecorator("body");
+export const Param = createParamDecorator("param");
+export const Query = createParamDecorator("query");
+export const Header = createParamDecorator("header");
+export const Req = (): ParameterDecorator => createParamDecorator("req")();
+export const Res = (): ParameterDecorator => createParamDecorator("res")();

package/src/core/decorators/injectable.decorator.ts

@@ -1,13 +1,18 @@
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { MetadataStorage } from '../metadata/metadata-storage';
 
-import 'reflect-metadata';
-import { DIContainer } from '../container/di-container';
+export type Scope = 'singleton' | 'request' | 'transient';
 
-export const INJECTABLE_METADATA = 'injectable:metadata';
-
-export function Injectable(): ClassDecorator {
+export function Injectable(scope: Scope = 'singleton'): ClassDecorator {
   return (target: any) => {
-    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
-    DIContainer.register(target);
-    return target;
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, scope, target);
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
+      target,
+      type: 'injectable',
+      scope
+    });
   };
-}
+}

package/src/core/decorators/injection.decorators.ts

@@ -0,0 +1,26 @@
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+
+export function Autowired(): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    const type = Reflect.getMetadata('design:type', target, propertyKey);
+    Reflect.defineMetadata(METADATA_KEYS.AUTOWIRED, type, target, propertyKey);
+  };
+}
+
+export function Inject(token: string): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    Reflect.defineMetadata(METADATA_KEYS.INJECT, token, target, propertyKey);
+  };
+}
+
+export function Qualifier(name: string): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    Reflect.defineMetadata(METADATA_KEYS.QUALIFIER, name, target, propertyKey);
+  };
+}
+
+export function Value(expression: string): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    Reflect.defineMetadata(METADATA_KEYS.VALUE, expression, target, propertyKey);
+  };
+}

package/src/core/decorators/repository.decorator.ts

@@ -1,6 +1,17 @@
-
 import { Injectable } from './injectable.decorator';
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { MetadataStorage } from '../metadata/metadata-storage';
 
 export function Repository(): ClassDecorator {
-  return Injectable();
+  return (target: any) => {
+    Injectable('singleton')(target);
+    Reflect.defineMetadata(METADATA_KEYS.REPOSITORY, true, target);
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
+      target,
+      type: 'repository',
+      scope: 'singleton'
+    });
+  };
 }

package/src/core/decorators/service.decorator.ts

@@ -1,6 +1,17 @@
-
 import { Injectable } from './injectable.decorator';
+import { METADATA_KEYS } from '../metadata/metadata-keys';
+import { MetadataStorage } from '../metadata/metadata-storage';
 
 export function Service(): ClassDecorator {
-  return Injectable();
+  return (target: any) => {
+    Injectable('singleton')(target);
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE, true, target);
+    
+    const storage = MetadataStorage.getInstance();
+    storage.addClass({
+      target,
+      type: 'service',
+      scope: 'singleton'
+    });
+  };
 }

package/src/core/index.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+
+export * from './decorators/application.decorator';
+export * from './decorators/injectable.decorator';
+export * from './decorators/service.decorator';
+export * from './decorators/controller.decorator';
+export * from './decorators/repository.decorator';
+export * from './decorators/auto-configuration.decorator';
+export * from './decorators/conditional.decorators';
+export * from './decorators/injection.decorators';
+export * from './decorators/http.decorators';
+export * from './container/di-container';
+export * from './metadata/metadata-storage';

package/src/core/loader/file-loader.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+
+export class FileLoader {
+  static async loadFiles(
+    pattern: string,
+    cwd: string = process.cwd(),
+  ): Promise<void> {
+    try {
+      const files = await glob(pattern, {
+        cwd,
+        ignore: [
+          "**/*.spec.ts",
+          "**/*.test.ts",
+          "**/*.d.ts",
+          "**/node_modules/**",
+        ],
+      });
+
+      for (const file of files) {
+        const absolutePath = path.join(cwd, file);
+
+        // Check if it's a TypeScript file
+        if (file.endsWith(".ts")) {
+          try {
+            // Use require to execute the file (decorators run on import)
+            delete require.cache[absolutePath];
+            require(absolutePath);
+          } catch (error) {
+            console.warn(`Failed to load ${file}:`, (error as any)?.message);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error loading files:", error);
+    }
+  }
+
+  static async loadProjectFiles(): Promise<void> {
+    const isProduction = process.env.NODE_ENV === "production";
+    const srcDir = isProduction ? "dist" : "src";
+    const pattern = isProduction ? "**/*.js" : "**/*.ts";
+
+    const projectRoot = process.cwd();
+    const sourceDir = path.join(projectRoot, srcDir);
+
+    if (!fs.existsSync(sourceDir)) {
+      console.warn(`Source directory not found: ${sourceDir}`);
+      return;
+    }
+
+    await this.loadFiles(pattern, sourceDir);
+  }
+}

package/src/core/metadata/metadata-keys.ts

@@ -0,0 +1,19 @@
+export const METADATA_KEYS = {
+  INJECTABLE: 'fragment:injectable',
+  SCOPE: 'fragment:scope',
+  SERVICE: 'fragment:service',
+  CONTROLLER: 'fragment:controller',
+  REPOSITORY: 'fragment:repository',
+  AUTO_CONFIGURATION: 'fragment:auto-configuration',
+  CONDITIONAL_ON_CLASS: 'fragment:conditional-class',
+  CONDITIONAL_ON_MISSING_BEAN: 'fragment:conditional-missing-bean',
+  CONDITIONAL_ON_PROPERTY: 'fragment:conditional-property',
+  AUTOWIRED: 'fragment:autowired',
+  INJECT: 'fragment:inject',
+  QUALIFIER: 'fragment:qualifier',
+  VALUE: 'fragment:value',
+  HTTP_METHOD: 'fragment:http-method',
+  ROUTE_PATH: 'fragment:route-path',
+  PARAM_METADATA: 'fragment:param-metadata',
+  APPLICATION: 'fragment:application'
+};

package/src/core/metadata/metadata-storage.ts

@@ -0,0 +1,91 @@
+import { METADATA_KEYS } from "./metadata-keys";
+
+export interface ClassMetadata {
+  target: any;
+  type:
+    | "injectable"
+    | "service"
+    | "controller"
+    | "repository"
+    | "auto-configuration";
+  scope?: "singleton" | "request" | "transient";
+  path?: string;
+}
+
+export interface MethodMetadata {
+  target: any;
+  propertyKey: string;
+  method: string;
+  path: string;
+  paramMetadata: ParamMetadata[];
+}
+
+export interface ParamMetadata {
+  target: any;
+  propertyKey: string;
+  index: number;
+  type: "body" | "param" | "query" | "header" | "req" | "res";
+  paramName?: string;
+}
+
+export class MetadataStorage {
+  private static instance: MetadataStorage;
+  private classes: Map<any, ClassMetadata> = new Map();
+  private methods: Map<string, MethodMetadata> = new Map();
+  private params: Map<string, ParamMetadata[]> = new Map();
+
+  static getInstance(): MetadataStorage {
+    if (!MetadataStorage.instance) {
+      MetadataStorage.instance = new MetadataStorage();
+    }
+    return MetadataStorage.instance;
+  }
+
+  addClass(metadata: ClassMetadata): void {
+    this.classes.set(metadata.target, metadata);
+  }
+
+  getClass(target: any): ClassMetadata | undefined {
+    return this.classes.get(target);
+  }
+
+  getAllClasses(): ClassMetadata[] {
+    return Array.from(this.classes.values());
+  }
+
+  addMethod(metadata: MethodMetadata): void {
+    const key = `${metadata.target.name}.${metadata.propertyKey}`;
+
+    const existingParams = this.getParams(
+      metadata.target,
+      metadata.propertyKey,
+    );
+    metadata.paramMetadata = existingParams.sort((a, b) => a.index - b.index);
+
+    this.methods.set(key, metadata);
+  }
+
+  getMethod(target: any, propertyKey: string): MethodMetadata | undefined {
+    const key = `${target.name}.${propertyKey}`;
+    return this.methods.get(key);
+  }
+
+  getAllMethods(): MethodMetadata[] {
+    return Array.from(this.methods.values());
+  }
+
+  addParam(metadata: ParamMetadata): void {
+    const key = `${metadata.target.constructor.name}.${metadata.propertyKey}`;
+    const existing = this.params.get(key) || [];
+    existing.push(metadata);
+    this.params.set(key, existing);
+  }
+
+  getParams(target: any, propertyKey: string): ParamMetadata[] {
+    const targetName = target.name || target.constructor?.name;
+    if (!targetName) return [];
+
+    const key = `${targetName}.${propertyKey}`;
+    return this.params.get(key) || [];
+  }
+}