@fastact/core 0.1.0-dev

package/dist/application-factory.d.ts

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

package/dist/application-factory.js

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,42 @@
+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'));
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_SERVER_HOST = "localhost";
+export declare const DEFAULT_SERVER_PORT = 3000;
+export declare const LOG_PREFIX: {
+    readonly INFO: string;
+    readonly WARN: string;
+    readonly ERROR: string;
+};

package/dist/constants.js

@@ -0,0 +1,8 @@
+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]'),
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ioc';
+export * from './types';
+export { createApp } from './application-factory';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './ioc';
+export * from './types';
+export { createApp } from './application-factory';

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

@@ -0,0 +1,18 @@
+import type { IContainerBuilder, ContainerInstance, InjectionToken, RegistrationTarget } from './types';
+/**
+ * Dependency container builder with a fluent registration API.
+ *
+ * Example: `builder.add(DI.UserService).asClass(createUserService).withDeps(DI.Database).scoped()`.
+ */
+export declare class ContainerBuilder implements IContainerBuilder {
+    private container;
+    private register;
+    /**
+     * Starts dependency registration using its unique token.
+     *
+     * Specify a class with `asClass()`, a factory with `asFactory()`, or a ready
+     * value with `asValue()`.
+     */
+    add<T>(token: InjectionToken<T>): RegistrationTarget<T>;
+    build(): Promise<ContainerInstance>;
+}

package/dist/ioc/container-builder.js

@@ -0,0 +1,97 @@
+import path from 'node:path';
+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()`.
+ */
+export class ContainerBuilder {
+    container = new Container();
+    register(token, factory, deps, lifecycle) {
+        this.container.register(token, factory, deps, lifecycle);
+        return this;
+    }
+    /**
+     * Starts dependency registration using its unique token.
+     *
+     * Specify a class with `asClass()`, a factory with `asFactory()`, or a ready
+     * value with `asValue()`.
+     */
+    add(token) {
+        const withFactory = (factory) => {
+            // 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. */
+                singleton: () => this.register(token, factory, deps, 'singleton'),
+                /** A new instance each time the dependency is resolved. */
+                transient: () => this.register(token, factory, deps, 'transient'),
+            });
+            return {
+                ...withLifecycle(),
+                /**
+                 * Passes factory dependency tokens in the order of its arguments.
+                 * Accepts individual tokens or a single array of tokens.
+                 */
+                withDeps: (...deps) => withLifecycle(deps.flat()),
+            };
+        };
+        return {
+            /** Specifies a class that the container instantiates with `new`. */
+            asClass: (Class) => withFactory((...deps) => new Class(...deps)),
+            /** Specifies a factory that creates the dependency instance. */
+            asFactory: (factory) => withFactory(factory),
+            /** Registers a ready value as a singleton dependency. */
+            asValue: (value) => {
+                this.container.registerValue(token, value);
+                return this;
+            },
+        };
+    }
+    async build() {
+        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) { ... }"`);
+                }
+            }
+        }
+        catch (err) {
+            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;
+    }
+}

package/dist/ioc/container.d.ts

@@ -0,0 +1,29 @@
+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;
+    /** 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.
+     */
+    get<T>(token: InjectionToken<T>, scopeId?: string, resolvesSingleton?: boolean, resolutionPath?: InjectionToken<any>[]): T;
+    private build;
+    /** Creates an isolated scope for scoped dependencies. */
+    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. */
+export declare class ScopedContainer {
+    private parent;
+    scopeId: string;
+    constructor(parent: Container, scopeId: string);
+    get<T>(token: InjectionToken<T>): T;
+    /** Clears the dependency cache for the current scope. */
+    clear(): void;
+}

package/dist/ioc/container.js

@@ -0,0 +1,97 @@
+export class Container {
+    registry = new Map();
+    scoped = new Map();
+    /** Registers a dependency factory and its dependency list. */
+    register(token, factory, deps, lifecycle = 'scoped') {
+        this.registry.set(token, {
+            factory,
+            deps,
+            lifecycle,
+            isInitialized: false,
+        });
+        this.clearTokenFromScopes(token);
+        return this;
+    }
+    /** Registers a ready value as a singleton dependency. */
+    registerValue(token, value) {
+        this.registry.set(token, {
+            factory: () => value,
+            deps: [],
+            lifecycle: 'singleton',
+            instance: value,
+            isInitialized: true,
+        });
+        this.clearTokenFromScopes(token);
+        return this;
+    }
+    /**
+    * Resolves a dependency. Scoped dependencies require a scope identifier,
+    * such as an HTTP request identifier.
+     */
+    get(token, scopeId, resolvesSingleton = false, resolutionPath = []) {
+        const entry = this.registry.get(token);
+        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);
+        }
+        return this.build(token, entry, scopeId, resolvesSingleton, resolutionPath);
+    }
+    build(token, entry, scopeId, resolvesSingleton, resolutionPath) {
+        if (resolutionPath.includes(token)) {
+            const chain = [...resolutionPath, token].map(String).join(' -> ');
+            throw new Error(`Circular dependency detected: ${chain}`);
+        }
+        const nextPath = [...resolutionPath, token];
+        const args = entry.deps.map((dep) => this.get(dep, scopeId, resolvesSingleton, nextPath));
+        return entry.factory(...args);
+    }
+    /** Creates an isolated scope for scoped dependencies. */
+    createScope(id) {
+        return new ScopedContainer(this, id);
+    }
+    /** Removes all cached scoped dependencies for the specified scope. */
+    clearScope(id) {
+        this.scoped.delete(id);
+    }
+    clearTokenFromScopes(token) {
+        for (const scopeCache of this.scoped.values()) {
+            scopeCache.delete(token);
+        }
+    }
+}
+/** A container with a predefined scope identifier. */
+export class ScopedContainer {
+    parent;
+    scopeId;
+    constructor(parent, scopeId) {
+        this.parent = parent;
+        this.scopeId = scopeId;
+    }
+    get(token) {
+        return this.parent.get(token, this.scopeId);
+    }
+    /** Clears the dependency cache for the current scope. */
+    clear() {
+        this.parent.clearScope(this.scopeId);
+    }
+}

package/dist/ioc/index.d.ts

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

package/dist/ioc/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+//export interface InjectionToken<T> extends Symbol {
+//  __type?: T;
+//}
+export * from './container-builder';

package/dist/ioc/types.d.ts

@@ -0,0 +1,35 @@
+/** 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 SymbolToken<T> extends Symbol {
+    readonly __type?: T;
+}
+export type InjectionToken<T> = string | SymbolToken<T>;
+/** The lifetime of a registered dependency. */
+export type Lifecycle = 'singleton' | 'scoped' | 'transient';
+export type Factory<T, Deps extends any[] = any[]> = (...deps: Deps) => T;
+export interface DepEntry<T> {
+    factory: Factory<T>;
+    deps: InjectionToken<any>[];
+    lifecycle: Lifecycle;
+    instance?: T;
+    isInitialized: boolean;
+}
+export interface RegistrationLifecycle {
+    scoped(): IContainerBuilder;
+    singleton(): IContainerBuilder;
+    transient(): IContainerBuilder;
+}
+export interface RegistrationWithDependencies extends RegistrationLifecycle {
+    withDeps(...deps: Array<InjectionToken<any> | InjectionToken<any>[]>): RegistrationLifecycle;
+}
+export interface RegistrationTarget<T> {
+    asClass(Class: new (...deps: any[]) => T): RegistrationWithDependencies;
+    asFactory(factory: Factory<T>): RegistrationWithDependencies;
+    asValue(value: T): IContainerBuilder;
+}

package/dist/ioc/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+import type { FastifyInstance, FastifyBaseLogger, FastifyServerOptions, RawServerBase, RawServerDefault } from 'fastify';
+import { ContainerInstance } from './ioc';
+export interface Application {
+    getContainer(): ContainerInstance;
+    getServer(): FastifyInstance;
+    /** Starts the application. */
+    start(): Promise<void>;
+    /** Stops the application. */
+    stop(): Promise<void>;
+}
+export interface ApplicationOptions<RawServer extends RawServerBase = RawServerDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> {
+    host?: string;
+    port?: number;
+    runServer?: boolean;
+    server?: FastifyServerOptions<RawServer, Logger>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@fastact/core",
+  "version": "0.1.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"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "fastact",
+    "fastify",
+    "web",
+    "app",
+    "http",
+    "application",
+    "framework",
+    "router",
+    "nodejs",
+    "deno",
+    "bun"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "chalk": "^6.0.0",
+    "fastify": "^5.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  },
+  "files": [
+    "dist"
+  ]
+}