@fastact/core 0.1.0-dev → 0.2.0-dev

package/README.md

@@ -0,0 +1,99 @@
+# ⚡ FastAct — Backend Without the Bullsh\*t.
+
+**FastAct** is a lightweight, ultra-fast backend framework for Node.js built with **TypeScript** and **Fastify**.
+
+It is designed for engineers who are tired of bloated enterprise monsters, endless decorators, heavy reflection magic, and overwhelming boilerplate. **FastAct** brings back the joy of writing clean, predictable, and rock-solid server-side code.
+
+[Documentation (Coming Soon)] • [CLI Utility: fac] • [Community]
+
+---
+
+## 🔥 Key Features & Philosophy
+
+### 🚫 No Decorator Pollution
+
+Forget about `@Injectable()`, `@Inject()`, or `@Module()`. Your code should be pure TypeScript. FastAct uses an explicit, declarative, and fluent API for building dependencies, which plays perfectly with native tools and unit tests.
+
+### 🛡 Symbol-Driven IoC Container
+
+Our custom built-in Dependency Injection (DI) container operates entirely on unique `Symbol` tokens. No string name collisions, no accidental service overwrites. You get 100% type safety and perfect IDE autocomplete out of the box.
+
+### 🧬 Advanced Lifecycles (Singleton & Scoped)
+
+FastAct natively supports both lazy `Singleton` instances and fully isolated `Scoped` contexts for every single HTTP request or CLI command. This makes it an ideal fit for managing MikroORM's `EntityManager` and isolating database transactions safely.
+
+### 🔀 Unified Web & CLI Architecture (Standalone Mode)
+
+Initialize your entire application with a single `createApp()` function. Need a web server? Pass `runServer: true`. Need a lightweight cron job, queue worker, or a CLI command via our `fac` utility? Turn off the server, and the IoC container will assemble only the required services without opening ports or wasting memory.
+
+---
+
+## 🎹 Code Showcase
+
+### 1. Define Unique Tokens
+
+```typescript
+// src/modules/auth/auth.tokens.ts
+import type { InjectionToken } from '@fastactjs/core';
+import type { AuthService } from './auth.service';
+
+export const AUTH_DI = {
+  AuthService: Symbol('AuthService') as InjectionToken<AuthService>,
+};
+```
+
+### 2. Register Dependencies Cleanly (Fluent API)
+
+```typescript
+// src/modules/auth/auth.module.ts
+import { AUTH_DI } from './auth.tokens';
+import { AuthService } from './auth.service';
+import type { ContainerBuilder } from '@fastactjs/core';
+
+export async function createContainerModule(builder: ContainerBuilder) {
+  // Simple, elegant, and instantly readable for developers worldwide
+  builder.add(AUTH_DI.AuthService).asClass(AuthService).singleton();
+}
+```
+
+### 3. Ignite the Engine
+
+```typescript
+// src/main.ts
+import { createApp } from '@fastactjs/core';
+import path from 'node:path';
+
+async function bootstrap() {
+  const app = await createApp({
+    modulesDir: path.join(__dirname, 'modules'),
+    runServer: true,
+    port: 3000,
+  });
+
+  await app.start();
+}
+bootstrap();
+```
+
+---
+
+## 🛠 Our Powerful CLI: `fac`
+
+Manage your FastAct applications with our sharp and blunt console utility — `fac`. Fast, efficient, straight to the point.
+
+```bash
+# Generate a new module structure automatically (Zero Boilerplate)
+\$ fac add module user
+
+# Run the project in development mode with hot-reload
+\$ fac start --dev
+
+# Execute a standalone CLI command / cron script
+\$ fac run cron:sync-users
+```
+
+---
+
+## 🌏 Join the Movement
+
+We are building a backend framework that speaks the same language of simplicity to engineers in Moscow, Seoul, Tokyo, and San Francisco. If you share our passion for clean JavaScript/TypeScript without "magic" crutches — drop a star ⭐️ and let's reshape backend development together.

package/dist/app-factory.d.ts

@@ -0,0 +1,8 @@
+import { App } from './app';
+import type { NormalAppOptions, StandaloneAppOptions } from './types';
+export declare class AppFactory {
+    static create(options?: NormalAppOptions): Promise<App>;
+    static createStandalone(options?: StandaloneAppOptions): Promise<App>;
+}
+export declare function createApp(options?: NormalAppOptions): Promise<App>;
+export declare function createStandaloneApp(options?: StandaloneAppOptions): Promise<App>;

package/dist/app-factory.js

@@ -0,0 +1,24 @@
+import { App } from './app';
+import { ContainerBuilder } from './ioc';
+export class AppFactory {
+    // prettier-ignore
+    static async create(options) {
+        const container = await new ContainerBuilder().build();
+        return new App(container, { runServer: true, ...options });
+    }
+    // prettier-ignore
+    static async createStandalone(options) {
+        const container = await new ContainerBuilder().build();
+        return new App(container, { runServer: false, ...options });
+    }
+}
+// prettier-ignore
+export async function createApp(options) {
+    const container = await new ContainerBuilder().build();
+    return new App(container, { runServer: true, ...options });
+}
+// prettier-ignore
+export async function createStandaloneApp(options) {
+    const container = await new ContainerBuilder().build();
+    return new App(container, { runServer: false, ...options });
+}

package/dist/app.d.ts

@@ -0,0 +1,17 @@
+import { FastifyInstance } from 'fastify';
+import { type ContainerInstance } from './ioc';
+import type { NormalAppOptions, StandaloneAppOptions } from './types';
+export type AppOptions = NormalAppOptions & StandaloneAppOptions & {
+    runServer?: boolean;
+};
+export declare class App {
+    private readonly container;
+    private readonly server;
+    private readonly options;
+    constructor(container: ContainerInstance, options?: AppOptions);
+    getContainer(): ContainerInstance;
+    getServer(): FastifyInstance;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private stopServer;
+}

package/dist/app.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import fastify from 'fastify';
+import { fastactIocPlugin } from './ioc';
+import { DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT, LOG_PREFIX, } from './constants';
+export class App {
+    container;
+    server;
+    options;
+    constructor(container, options = {}) {
+        this.options = options;
+        this.container = container;
+        if (this.options.runServer !== false) {
+            this.server = fastify(this.options.server);
+            this.server.register(fastactIocPlugin, {
+                container: this.container,
+            });
+        }
+    }
+    getContainer() {
+        return this.container;
+    }
+    getServer() {
+        if (!this.server) {
+            throw new Error('Fastify server is not initialized in standalone mode');
+        }
+        return this.server;
+    }
+    async start() {
+        if (this.options.runServer === false) {
+            // prettier-ignore
+            console.log(`${LOG_PREFIX.WARN} Standalone context initialized (CLI mode)`);
+            return;
+        }
+        // Защита для TypeScript (хотя при runServer !== false сервер точно есть)
+        if (!this.server)
+            return;
+        const host = this.options.host ?? DEFAULT_SERVER_HOST;
+        const port = this.options.port ?? DEFAULT_SERVER_PORT;
+        try {
+            await this.server.listen({ port, host });
+            console.log(`${chalk.green.bold('[FastAct]')} Server is now listening on ${host}:${port}`);
+        }
+        catch (err) {
+            // console.log(`${LOG_PREFIX.ERROR} ${err}`);
+            throw err;
+        }
+    }
+    async close() {
+        //if (this.container?.dispose) await this.container.dispose();
+        await this.stopServer();
+        if (this.options.runServer !== false)
+            return;
+        console.log(`${LOG_PREFIX.INFO} Standalone application stopped`);
+        process.exit(0);
+    }
+    async stopServer() {
+        if (!this.server)
+            return;
+        console.log(`${LOG_PREFIX.WARN} Shutting down the server...`);
+        await this.server.close();
+        console.log(`${LOG_PREFIX.INFO} Server gracefully stopped`);
+    }
+}

package/dist/constants.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 export const DEFAULT_SERVER_HOST = 'localhost';
 export const DEFAULT_SERVER_PORT = 3000;
 export const LOG_PREFIX = {
-    INFO: chalk.green.bold('[fastact]'),
-    WARN: chalk.yellow.bold('[fastact]'),
-    ERROR: chalk.red.bold('[fastact]'),
+    INFO: chalk.green.bold('[FastAct]'),
+    WARN: chalk.yellow.bold('[FastAct]'),
+    ERROR: chalk.red.bold('[FastAct]'),
 };

package/dist/define-config.d.ts

@@ -0,0 +1,16 @@
+import type { AppConfig } from './types';
+/**
+ * Helper function to define FastAct configuration with TypeScript inference
+ *
+ * @example
+ * ```ts
+ * // fastact.config.ts
+ * import { defineConfig } from '@fastact/core'
+ *
+ * export default defineConfig({
+ *   modules: ['./dist/**\/*.module.js'],
+ *   modulesTs: ['./src/**\/*.module.ts'],
+ * })
+ * ```
+ */
+export declare function defineConfig<T extends AppConfig = AppConfig>(config: T): T;

package/dist/define-config.js

@@ -0,0 +1,17 @@
+/**
+ * Helper function to define FastAct configuration with TypeScript inference
+ *
+ * @example
+ * ```ts
+ * // fastact.config.ts
+ * import { defineConfig } from '@fastact/core'
+ *
+ * export default defineConfig({
+ *   modules: ['./dist/**\/*.module.js'],
+ *   modulesTs: ['./src/**\/*.module.ts'],
+ * })
+ * ```
+ */
+export function defineConfig(config) {
+    return config;
+}

package/dist/errors/base.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class FastactError extends Error {
+    abstract readonly code: string;
+    abstract readonly statusCode: number;
+    constructor(message: string);
+    get fullCode(): string;
+}

package/dist/errors/base.js

@@ -0,0 +1,10 @@
+export class FastactError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    get fullCode() {
+        return `FA_${this.code.toUpperCase()}`;
+    }
+}

package/dist/errors/domain.error.d.ts

@@ -0,0 +1,3 @@
+export declare class DomainError extends Error {
+    constructor(message: string);
+}

package/dist/errors/domain.error.js

@@ -0,0 +1,6 @@
+export class DomainError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './domain.error';

package/dist/errors/index.js

@@ -0,0 +1 @@
+export * from './domain.error';

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-export * from './ioc';
+export * from './errors';
 export * from './types';
-export { createApp } from './application-factory';
+export * from './ioc';
+export { defineConfig } from './define-config';
+export { createApp, createStandaloneApp, AppFactory as FastAct } from './app-factory';

package/dist/index.js

@@ -1,3 +1,6 @@
-export * from './ioc';
+export * from './errors';
 export * from './types';
-export { createApp } from './application-factory';
+export * from './ioc';
+export { defineConfig } from './define-config';
+// prettier-ignore
+export { createApp, createStandaloneApp, AppFactory as FastAct } from './app-factory';

package/dist/ioc/container-builder.d.ts

@@ -1,18 +1,23 @@
-import type { IContainerBuilder, ContainerInstance, InjectionToken, RegistrationTarget } from './types';
+import type { ContainerInstance, InjectionToken, RegistrationTarget } from './types';
+/** Represents a module that can be loaded into the container builder. */
+export type ContainerModule = (builder: ContainerBuilder) => Promise<void>;
 /**
  * Dependency container builder with a fluent registration API.
  *
- * Example: `builder.add(DI.UserService).asClass(createUserService).withDeps(DI.Database).scoped()`.
+ * Example: `builder.add(DI.UserService).asClass(UserService).withDeps(DI.Database).scoped()`.
  */
-export declare class ContainerBuilder implements IContainerBuilder {
+export declare class ContainerBuilder {
     private container;
     private register;
     /**
-     * Starts dependency registration using its unique token.
+     * Starts dependency registration using its token.
      *
      * Specify a class with `asClass()`, a factory with `asFactory()`, or a ready
      * value with `asValue()`.
      */
-    add<T>(token: InjectionToken<T>): RegistrationTarget<T>;
+    add<T>(token: InjectionToken<T>): RegistrationTarget<T, this>;
     build(): Promise<ContainerInstance>;
+    private findProjectRoot;
+    /** Helper method for loading the config with TS/JS support. */
+    private loadConfig;
 }

package/dist/ioc/container-builder.js

@@ -1,11 +1,13 @@
 import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
 import { glob } from 'node:fs/promises';
 import chalk from 'chalk';
 import { Container } from './container';
 /**
  * Dependency container builder with a fluent registration API.
  *
- * Example: `builder.add(DI.UserService).asClass(createUserService).withDeps(DI.Database).scoped()`.
+ * Example: `builder.add(DI.UserService).asClass(UserService).withDeps(DI.Database).scoped()`.
  */
 export class ContainerBuilder {
     container = new Container();
@@ -14,20 +16,20 @@ export class ContainerBuilder {
         return this;
     }
     /**
-     * Starts dependency registration using its unique token.
+     * Starts dependency registration using its token.
      *
      * Specify a class with `asClass()`, a factory with `asFactory()`, or a ready
      * value with `asValue()`.
      */
     add(token) {
         const withFactory = (factory) => {
+            // prettier-ignore
             // prettier-ignore
             const withLifecycle = (deps = []) => ({
-                /** One instance per scope, such as an HTTP request. */
                 scoped: () => this.register(token, factory, deps, 'scoped'),
-                /** One instance for the container's entire lifetime. */
+                /** Registers one instance for the container's entire lifetime. */
                 singleton: () => this.register(token, factory, deps, 'singleton'),
-                /** A new instance each time the dependency is resolved. */
+                /** Registers a new instance for each resolution. */
                 transient: () => this.register(token, factory, deps, 'transient'),
             });
             return {
@@ -42,6 +44,25 @@ export class ContainerBuilder {
         return {
             /** Specifies a class that the container instantiates with `new`. */
             asClass: (Class) => withFactory((...deps) => new Class(...deps)),
+            /*
+            withFactory((...deps) => {
+            const instance = new Class(...deps);
+            const allProps = new Set([
+              ...Object.getOwnPropertyNames(instance),
+              ...Object.getOwnPropertyNames(Object.getPrototypeOf(instance))
+            ]);
+      
+            allProps.forEach((name) => {
+              if (name === 'constructor') return;
+              const value = (instance as any)[name];
+              if (typeof value === 'function' && value.prototype !== undefined) {
+                (instance as any)[name] = value.bind(instance);
+              }
+            });
+      
+            return instance;
+          }),
+            */
             /** Specifies a factory that creates the dependency instance. */
             asFactory: (factory) => withFactory(factory),
             /** Registers a ready value as a singleton dependency. */
@@ -55,43 +76,85 @@ export class ContainerBuilder {
         let moduleErrorName;
         try {
             const runDir = path.dirname(process.argv[1]);
-            const modulesGlob = glob('**/*.module.{ts,js}', {
-                cwd: runDir,
-                exclude: (p) => p.includes('node_modules'),
-            });
-            for await (const relativePath of modulesGlob) {
-                const fullPath = path.resolve(runDir, relativePath);
-                //console.log(
-                //  `${chalk.green.bold('[fastact]')} Found module file: ${relativePath}`
-                //);
-                const moduleExport = require(fullPath);
-                moduleErrorName = fullPath;
-                const initModule = moduleExport.createContainerModule;
-                if (typeof initModule === 'function') {
-                    await initModule(this);
-                }
-                else {
-                    console.warn(`${chalk.yellow.bold('[fastact]')} File ${relativePath} skipped: missing "export function createContainerModule(builder) { ... }"`);
+            const root = this.findProjectRoot(runDir);
+            const config = await this.loadConfig(root);
+            const isTypeScriptRuntime = process.argv[1]?.endsWith('.ts') ||
+                typeof globalThis.Bun !==
+                    'undefined';
+            let masks;
+            if (isTypeScriptRuntime) {
+                masks =
+                    config.modulesTs && config.modulesTs.length > 0
+                        ? config.modulesTs
+                        : ['src/**/*.module.ts'];
+            }
+            else {
+                masks =
+                    config.modules && config.modules.length > 0
+                        ? config.modules
+                        : ['dist/**/*.module.js'];
+            }
+            for (const mask of masks) {
+                const cleanPathMask = mask.startsWith('./') ? mask.slice(2) : mask;
+                const modulesGlob = glob(cleanPathMask, {
+                    cwd: root,
+                    exclude: (p) => p.includes('node_modules') ||
+                        p.includes('.git') ||
+                        (isTypeScriptRuntime ? p.endsWith('.js') : p.endsWith('.ts')), // Smart exclusion: ignore dist in TS runtime, ignore src in JS runtime
+                });
+                for await (const relativePath of modulesGlob) {
+                    const fullPath = path.resolve(root, relativePath);
+                    moduleErrorName = fullPath;
+                    // In production this will be a native, fast import() of a plain JS file
+                    const fileUrl = pathToFileURL(fullPath).href;
+                    const moduleExport = await import(fileUrl);
+                    const initModule = moduleExport.createContainerModule;
+                    if (typeof initModule === 'function') {
+                        await initModule(this);
+                    }
+                    else {
+                        throw new Error(`Missing required "export function createContainerModule(builder) { ... }"`);
+                    }
                 }
             }
         }
         catch (err) {
-            console.log(`${chalk.red.bold('[fastact]')} IoC auto-load failed: ${err instanceof Error ? err.message : err} in the module: ${moduleErrorName}`);
+            console.log(`${chalk.red.bold('[FastAct]')} IoC auto-load failed: ${err instanceof Error ? err.message : err} in the module: ${moduleErrorName}`);
         }
-        const container = this.container;
-        /*     container.get = <T>(token: InjectionToken<T>): T => {
-          const key = token.description;
-          if (!key) {
-            throw new Error('Symbol token must have a description to be resolved!');
-          }
-    
-          const dependency = container[key];
-          if (!dependency) {
-            throw new Error(`IoC dependency for Symbol(${key}) not found`);
-          }
-    
-          return dependency;
-        }; */
         return this.container;
     }
+    findProjectRoot(startDir) {
+        let currentDir = startDir;
+        while (currentDir !== path.parse(currentDir).root) {
+            if (existsSync(path.join(currentDir, 'package.json'))) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return startDir;
+    }
+    /** Helper method for loading the config with TS/JS support. */
+    async loadConfig(projectRootDir) {
+        const extensions = ['.ts', '.js', '.mts', '.mjs', '.cts', '.cjs'];
+        let configPath = '';
+        for (const ext of extensions) {
+            const file = path.join(projectRootDir, `fastact.config${ext}`);
+            if (existsSync(file)) {
+                configPath = file;
+                break;
+            }
+        }
+        if (!configPath)
+            return {};
+        try {
+            // Convert the absolute path to a file:// URL (required for ESM import)
+            const fileUrl = pathToFileURL(configPath).href;
+            const configModule = await import(fileUrl);
+            return configModule.default || configModule;
+        }
+        catch (err) {
+            console.log(`${chalk.yellow.bold('[FastAct]')} Failed to load config file: ${err instanceof Error ? err.message : err}`);
+            return {};
+        }
+    }
 }

package/dist/ioc/container.d.ts

@@ -1,24 +1,24 @@
 import type { Lifecycle, Factory, InjectionToken } from './types';
 export declare class Container {
     private registry;
-    private scoped;
-    /** Registers a dependency factory and its dependency list. */
-    register<T, D extends any[]>(token: InjectionToken<T>, factory: Factory<T, D>, deps: InjectionToken<D[number]>[], lifecycle?: Lifecycle): this;
+    private scopeCaches;
+    /** Registers a dependency factory, its dependencies, and its lifecycle. */
+    register<T, D extends any[]>(token: InjectionToken<T>, factory: Factory<T, D>, deps?: InjectionToken<D[number]>[], lifecycle?: Lifecycle): this;
     /** Registers a ready value as a singleton dependency. */
     registerValue<T>(token: InjectionToken<T>, value: T): this;
-    /**
-    * Resolves a dependency. Scoped dependencies require a scope identifier,
-    * such as an HTTP request identifier.
-     */
+    /** Resolves a dependency according to its lifecycle. */
     get<T>(token: InjectionToken<T>, scopeId?: string, resolvesSingleton?: boolean, resolutionPath?: InjectionToken<any>[]): T;
+    private resolveSingleton;
+    private resolveScoped;
+    private getScopeCache;
     private build;
-    /** Creates an isolated scope for scoped dependencies. */
+    /** Creates a scoped resolver that reuses instances for the given scope ID. */
     createScope(id: string): ScopedContainer;
     /** Removes all cached scoped dependencies for the specified scope. */
     clearScope(id: string): void;
     private clearTokenFromScopes;
 }
-/** A container with a predefined scope identifier. */
+/** Resolves dependencies within a predefined scope. */
 export declare class ScopedContainer {
     private parent;
     scopeId: string;

package/dist/ioc/container.js

@@ -1,8 +1,8 @@
 export class Container {
     registry = new Map();
-    scoped = new Map();
-    /** Registers a dependency factory and its dependency list. */
-    register(token, factory, deps, lifecycle = 'scoped') {
+    scopeCaches = new Map();
+    /** Registers a dependency factory, its dependencies, and its lifecycle. */
+    register(token, factory, deps = [], lifecycle = 'singleton') {
         this.registry.set(token, {
             factory,
             deps,
@@ -24,37 +24,47 @@ export class Container {
         this.clearTokenFromScopes(token);
         return this;
     }
-    /**
-    * Resolves a dependency. Scoped dependencies require a scope identifier,
-    * such as an HTTP request identifier.
-     */
+    /** Resolves a dependency according to its lifecycle. */
     get(token, scopeId, resolvesSingleton = false, resolutionPath = []) {
         const entry = this.registry.get(token);
-        if (!entry)
+        if (!entry) {
             throw new Error(`Dependency ${String(token)} not found`);
-        if (entry.lifecycle === 'singleton') {
-            if (!entry.isInitialized) {
-                entry.instance = this.build(token, entry, scopeId, true, resolutionPath);
-                entry.isInitialized = true;
-            }
-            return entry.instance;
         }
-        if (entry.lifecycle === 'scoped') {
-            if (resolvesSingleton) {
-                throw new Error(`Singleton dependency chain cannot include scoped dependency ${String(token)}`);
-            }
-            if (!scopeId)
-                throw new Error(`Scope ID required for ${String(token)}`);
-            if (!this.scoped.has(scopeId)) {
-                this.scoped.set(scopeId, new Map());
-            }
-            const scopeCache = this.scoped.get(scopeId);
-            if (!scopeCache.has(token)) {
-                scopeCache.set(token, this.build(token, entry, scopeId, false, resolutionPath));
-            }
-            return scopeCache.get(token);
+        const resolvers = {
+            singleton: () => this.resolveSingleton(token, entry, scopeId, resolutionPath),
+            scoped: () => 
+            // prettier-ignore
+            this.resolveScoped(token, entry, scopeId, resolvesSingleton, resolutionPath),
+            transient: () => this.build(token, entry, scopeId, resolvesSingleton, resolutionPath),
+        };
+        return resolvers[entry.lifecycle]?.();
+    }
+    resolveSingleton(token, entry, scopeId, resolutionPath) {
+        if (!entry.isInitialized) {
+            entry.instance = this.build(token, entry, scopeId, true, resolutionPath);
+            entry.isInitialized = true;
+        }
+        return entry.instance;
+    }
+    resolveScoped(token, entry, scopeId, resolvesSingleton, resolutionPath) {
+        if (resolvesSingleton) {
+            throw new Error(`Singleton dependency chain cannot include scoped dependency ${String(token)}`);
+        }
+        if (!scopeId)
+            throw new Error(`Scope ID required for ${String(token)}`);
+        const scopeCache = this.getScopeCache(scopeId);
+        if (!scopeCache.has(token)) {
+            scopeCache.set(token, this.build(token, entry, scopeId, false, resolutionPath));
+        }
+        return scopeCache.get(token);
+    }
+    getScopeCache(scopeId) {
+        let scopeCache = this.scopeCaches.get(scopeId);
+        if (!scopeCache) {
+            scopeCache = new Map();
+            this.scopeCaches.set(scopeId, scopeCache);
         }
-        return this.build(token, entry, scopeId, resolvesSingleton, resolutionPath);
+        return scopeCache;
     }
     build(token, entry, scopeId, resolvesSingleton, resolutionPath) {
         if (resolutionPath.includes(token)) {
@@ -65,21 +75,21 @@ export class Container {
         const args = entry.deps.map((dep) => this.get(dep, scopeId, resolvesSingleton, nextPath));
         return entry.factory(...args);
     }
-    /** Creates an isolated scope for scoped dependencies. */
+    /** Creates a scoped resolver that reuses instances for the given scope ID. */
     createScope(id) {
         return new ScopedContainer(this, id);
     }
     /** Removes all cached scoped dependencies for the specified scope. */
     clearScope(id) {
-        this.scoped.delete(id);
+        this.scopeCaches.delete(id);
     }
     clearTokenFromScopes(token) {
-        for (const scopeCache of this.scoped.values()) {
+        for (const scopeCache of this.scopeCaches.values()) {
             scopeCache.delete(token);
         }
     }
 }
-/** A container with a predefined scope identifier. */
+/** Resolves dependencies within a predefined scope. */
 export class ScopedContainer {
     parent;
     scopeId;

package/dist/ioc/fastify-plugin.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { ContainerInstance, ScopedContainerInstance } from './types';
+interface InternalRootContainer extends ContainerInstance {
+    createScope(id: string): InternalScopedContainer;
+}
+interface InternalScopedContainer extends ScopedContainerInstance {
+    dispose(): void | Promise<void>;
+}
+declare module 'fastify' {
+    interface FastifyRequest {
+        container: ContainerInstance;
+        scopedContainer: ScopedContainerInstance;
+    }
+}
+export declare const fastactIocPlugin: FastifyPluginAsync<{
+    container: InternalRootContainer;
+}>;
+export {};

package/dist/ioc/fastify-plugin.js

@@ -0,0 +1,21 @@
+import fp from 'fastify-plugin';
+// prettier-ignore
+const plugin = async (fastify, options) => {
+    fastify.decorateRequest('container', null);
+    fastify.decorateRequest('scopedContainer', null);
+    fastify.addHook('onRequest', async (req) => {
+        const r = req;
+        r.container = options.container;
+        r.scopedContainer = options.container.createScope(req.id);
+    });
+    fastify.addHook('onResponse', async (req) => {
+        const r = req;
+        if (r.scopedContainer && typeof r.scopedContainer.dispose === 'function') {
+            await r.scopedContainer.dispose();
+        }
+        // Зануляем ссылки, очищая память для Garbage Collector
+        r.container = null;
+        r.scopedContainer = null;
+    });
+};
+export const fastactIocPlugin = fp(plugin, { name: '@fastact/ioc-plugin' });

package/dist/ioc/index.d.ts

@@ -1,2 +1,4 @@
 export * from './types';
 export * from './container-builder';
+export * from './container';
+export * from './fastify-plugin';

package/dist/ioc/index.js

@@ -3,3 +3,5 @@ export * from './types';
 //  __type?: T;
 //}
 export * from './container-builder';
+export * from './container';
+export * from './fastify-plugin';

package/dist/ioc/types.d.ts

@@ -1,14 +1,14 @@
-/** Public contract for configuring and building a dependency container. */
-export interface IContainerBuilder {
-    add<T>(token: InjectionToken<T>): RegistrationTarget<T>;
-    build(): Promise<ContainerInstance>;
-}
 export interface ContainerInstance {
     get<T>(token: InjectionToken<T>): T;
 }
+export interface ScopedContainerInstance {
+    get<T>(token: InjectionToken<T>): T;
+}
+/** A symbol token carrying the type of the dependency it identifies. */
 export interface SymbolToken<T> extends Symbol {
     readonly __type?: T;
 }
+/** A string or typed symbol used to identify a dependency. */
 export type InjectionToken<T> = string | SymbolToken<T>;
 /** The lifetime of a registered dependency. */
 export type Lifecycle = 'singleton' | 'scoped' | 'transient';
@@ -20,16 +20,16 @@ export interface DepEntry<T> {
     instance?: T;
     isInitialized: boolean;
 }
-export interface RegistrationLifecycle {
-    scoped(): IContainerBuilder;
-    singleton(): IContainerBuilder;
-    transient(): IContainerBuilder;
+export interface RegistrationLifecycle<B = any> {
+    scoped(): B;
+    singleton(): B;
+    transient(): B;
 }
-export interface RegistrationWithDependencies extends RegistrationLifecycle {
-    withDeps(...deps: Array<InjectionToken<any> | InjectionToken<any>[]>): RegistrationLifecycle;
+export interface RegistrationWithDependencies<B> extends RegistrationLifecycle<B> {
+    withDeps(...deps: Array<InjectionToken<any> | InjectionToken<any>[]>): RegistrationLifecycle<B>;
 }
-export interface RegistrationTarget<T> {
-    asClass(Class: new (...deps: any[]) => T): RegistrationWithDependencies;
-    asFactory(factory: Factory<T>): RegistrationWithDependencies;
-    asValue(value: T): IContainerBuilder;
+export interface RegistrationTarget<V, B> {
+    asClass(Class: new (...args: any[]) => V): RegistrationWithDependencies<B>;
+    asFactory(factory: (...args: any[]) => V): RegistrationWithDependencies<B>;
+    asValue(value: V): B;
 }

package/dist/types.d.ts

@@ -1,16 +1,46 @@
-import type { FastifyInstance, FastifyBaseLogger, FastifyServerOptions, RawServerBase, RawServerDefault } from 'fastify';
-import { ContainerInstance } from './ioc';
+import type { FastifyInstance, FastifyHttpOptions } from 'fastify';
+import type { ContainerInstance } from './ioc';
 export interface Application {
     getContainer(): ContainerInstance;
     getServer(): FastifyInstance;
-    /** Starts the application. */
-    start(): Promise<void>;
-    /** Stops the application. */
-    stop(): Promise<void>;
+    /** Close the application. */
+    close(): Promise<void>;
 }
-export interface ApplicationOptions<RawServer extends RawServerBase = RawServerDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> {
+/**
+export interface ApplicationOptions<
+  RawServer extends RawServerBase = RawServerDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+> {
+  host?: string;
+  port?: number;
+  // runServer?: boolean;
+  server?: FastifyServerOptions<RawServer, Logger>;
+}
+**/
+export interface NormalAppOptions {
     host?: string;
     port?: number;
-    runServer?: boolean;
-    server?: FastifyServerOptions<RawServer, Logger>;
+    server?: FastifyHttpOptions<any>;
+}
+export interface StandaloneAppOptions {
+}
+export interface AppConfig {
+    /**
+     * Glob patterns for compiled JS module files to auto-load.
+     *
+     * @example
+     * ```js
+     *   modules: ['./dist/**\/*.module.js'],
+     * ```
+     */
+    modules?: string[];
+    /**
+     * Glob patterns for TypeScript module files to auto-load.
+     *
+     * @example
+     * ```ts
+     * modulesTs: ['./src/**\/*.module.ts'],
+     * ```
+     */
+    modulesTs?: string[];
 }

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './logger';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './logger';

package/dist/utils/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    warn(message: string): void;
+    error(message: string, error?: any): void;
+    info(message: string): void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,17 @@
+const RESET = '\x1b[0m';
+const BOLD_YELLOW = '\x1b[1;33m';
+const BOLD_RED = '\x1b[1;31m';
+const BOLD_GREEN = '\x1b[1;32m';
+export const logger = {
+    warn(message) {
+        console.warn(`${BOLD_YELLOW}[FastAct]${RESET} ${message}`);
+    },
+    error(message, error) {
+        const errMessage = error instanceof Error ? error.message : String(error || '');
+        const suffix = errMessage ? `: ${errMessage}` : '';
+        console.error(`${BOLD_RED}[FastAct]${RESET} ${message}${suffix}`);
+    },
+    info(message) {
+        console.log(`${BOLD_GREEN}[FastAct]${RESET} ${message}`);
+    },
+};

package/dist/validation/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class ValidationError extends Error {
+    readonly code = "E_VALIDATION_ERROR";
+    readonly statusCode = 422;
+    readonly errors: any[];
+    constructor(rawErrors: any[]);
+}

package/dist/validation/errors.js

@@ -0,0 +1,11 @@
+export class ValidationError extends Error {
+    code = 'E_VALIDATION_ERROR';
+    statusCode = 422;
+    errors;
+    constructor(rawErrors) {
+        super('Validation failed');
+        this.name = 'ValidationError';
+        this.errors = rawErrors;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}

package/dist/validation/plugin.d.ts

@@ -0,0 +1 @@
+export declare const fastactValidationPlugin: (fastify: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>) => Promise<void>;

package/dist/validation/plugin.js

@@ -0,0 +1,23 @@
+import fp from 'fastify-plugin';
+import Ajv from 'ajv';
+import { ValidationError } from './errors';
+const ajv = new Ajv({ coerceTypes: true, useDefaults: true, removeAdditional: true });
+const compilersCache = new Map();
+export const fastactValidationPlugin = fp(async (fastify) => {
+    // Регистрируем метод в прототип запроса Fastify
+    fastify.decorateRequest('validateWith', async function (schema) {
+        const request = this;
+        let validateFn = compilersCache.get(schema);
+        if (!validateFn) {
+            validateFn = ajv.compile(schema);
+            compilersCache.set(schema, validateFn);
+        }
+        // Валидируем body (или можно расширить до query/params)
+        const isValid = validateFn(request.body);
+        if (!isValid) {
+            // Выкидываем кастомную ошибку пакета validation
+            throw new ValidationError(validateFn.errors);
+        }
+        return request.body;
+    });
+});

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@fastact/core",
-  "version": "0.1.0-dev",
+  "version": "0.2.0-dev",
   "description": "A fantastic, vanilla-flavored web framework core powered by Fastify. Built for JS purists: strictly 0 decorators, 0 reflect-metadata magic, and 100% predictable asynchronous flow.",
   "license": "MIT",
   "author": "Igor Bezlepkin",
   "repository": {
     "type": "git",
-    "url": "github:fastactjs/core"
+    "url": "git+https://github.com/fastactjs/core.git"
   },
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui"
   },
   "keywords": [
     "fastact",
@@ -31,14 +34,19 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "chalk": "^6.0.0",
-    "fastify": "^5.12.1"
+    "chalk": "^6.0.0"
+  },
+  "peerDependencies": {
+    "fastify": "^5.12.1",
+    "fastify-plugin": "^6.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.5.0"
+    "fastify": "^5.12.1",
+    "typescript": "^5.5.0",
+    "vitest": "^5.0.0"
   },
   "files": [
     "dist"
   ]
-}
+}

package/dist/application-factory.d.ts

@@ -1,2 +0,0 @@
-import type { Application, ApplicationOptions } from './types';
-export declare function createApp(options?: ApplicationOptions): Promise<Application>;

package/dist/application-factory.js

@@ -1,7 +0,0 @@
-import { App } from './application';
-import { ContainerBuilder } from './ioc';
-// prettier-ignore
-export async function createApp(options) {
-    const container = await new ContainerBuilder().build();
-    return new App(container, options);
-}

package/dist/application.d.ts

@@ -1,13 +0,0 @@
-import { FastifyInstance } from 'fastify';
-import type { ContainerInstance } from './ioc';
-import type { ApplicationOptions, Application } from './types';
-export declare class App implements Application {
-    private readonly container;
-    private readonly server;
-    private readonly options;
-    constructor(container: ContainerInstance, options?: ApplicationOptions);
-    getContainer(): ContainerInstance;
-    getServer(): FastifyInstance;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}

package/dist/application.js

@@ -1,42 +0,0 @@
-import chalk from 'chalk';
-import fastify from 'fastify';
-import { DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT } from './constants';
-export class App {
-    container;
-    server;
-    options;
-    constructor(container, options = {}) {
-        this.options = options;
-        this.container = container;
-        this.server = fastify(this.options.server);
-    }
-    getContainer() {
-        return this.container;
-    }
-    getServer() {
-        return this.server;
-    }
-    async start() {
-        /** Exit immediately when running as a CLI command or worker without a server. */
-        if (this.options.runServer === false) {
-            console.log(chalk.yellow('FastAct initialized in standalone (CLI) mode'));
-            return;
-        }
-        const host = this.options.host ?? DEFAULT_SERVER_HOST;
-        const port = this.options.port ?? DEFAULT_SERVER_PORT;
-        try {
-            await this.server.ready();
-            await this.server.listen({ port, host });
-            console.log(`${chalk.green.bold('[fastact]')} Server is now listening on ${host}:${port}`);
-        }
-        catch (err) {
-            console.log(`${chalk.red.bold('[fastact]')} ${err}`);
-            throw err;
-        }
-    }
-    async stop() {
-        console.log(`${chalk.yellow.bold('[fastact] Shutting down the server...')}`);
-        await this.server.close();
-        console.log(chalk.bgGreenBright.bold('[fastact] Server gracefully stopped'));
-    }
-}