@pulzar/core
Version:
Next-generation Node.js framework for ultra-fast web applications with zero-reflection DI, GraphQL, WebSockets, events, and edge runtime support
193 lines • 7.81 kB
JavaScript
/**
* Example usage of the DependencyScanner
* This file demonstrates how to use the scanner to analyze TypeScript files for DI metadata
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { createDependencyScanner } from "./scanner";
import { Injectable, Inject } from "./decorators";
import { DI_TOKENS } from "./tokens";
// Example service classes that the scanner can detect
let DatabaseService = class DatabaseService {
constructor() {
console.log("DatabaseService created");
}
query(sql) {
return { result: "mock data" };
}
};
DatabaseService = __decorate([
Injectable({ scope: "singleton" }),
__metadata("design:paramtypes", [])
], DatabaseService);
export { DatabaseService };
let UserService = class UserService {
db;
logger;
constructor(db, logger) {
this.db = db;
this.logger = logger;
}
async getUser(id) {
this.logger.info(`Getting user ${id}`);
return this.db.query(`SELECT * FROM users WHERE id = ${id}`);
}
};
UserService = __decorate([
Injectable({ scope: "request" }),
__param(0, Inject("DatabaseService")),
__param(1, Inject(DI_TOKENS.APP_LOGGER)),
__metadata("design:paramtypes", [DatabaseService, Object])
], UserService);
export { UserService };
let EmailService = class EmailService {
userService;
constructor(userService) {
this.userService = userService;
}
async sendEmail(userId, message) {
const user = await this.userService.getUser(userId);
console.log(`Sending email to user:`, user);
// Mock email sending
return { sent: true, messageId: "msg_123" };
}
};
EmailService = __decorate([
Injectable({ scope: "transient" }),
__metadata("design:paramtypes", [UserService])
], EmailService);
export { EmailService };
// Example usage of the scanner
export async function demonstrateScanner() {
console.log("🔍 Demonstrating Dependency Scanner\n");
// Create scanner instance
const scanner = createDependencyScanner();
try {
// Scan this current file
console.log("📄 Scanning current file...");
const providers = scanner.scanFile(__filename);
console.log(`Found ${providers.length} providers:`);
providers.forEach((provider) => {
console.log(` • ${String(provider.token)} (${provider.scope || "singleton"})`);
if (provider.dependencies.length > 0) {
console.log(` Dependencies: ${provider.dependencies.map((d) => String(d)).join(", ")}`);
}
});
// Scan entire src directory (example)
console.log("\n📁 Scanning src directory...");
try {
const allProviders = scanner.scanDirectory("./src");
console.log(`Found ${allProviders.length} total providers in src directory`);
// Show statistics
const stats = scanner.getStats();
console.log("\n📊 Scanner Statistics:");
console.log(` Total Providers: ${stats.totalProviders}`);
console.log(` Total Modules: ${stats.totalModules}`);
console.log(` Scanned Files: ${stats.scannedFiles}`);
console.log(` By Scope:`, stats.providersByScope);
}
catch (error) {
console.log("Note: src directory scan failed (expected in test environment)");
}
// Validate dependencies
console.log("\n✅ Validating dependencies...");
const validation = scanner.validate();
if (validation.valid) {
console.log("All dependencies are valid!");
}
else {
console.log("Validation errors:");
validation.errors.forEach((error) => console.log(` ❌ ${error}`));
}
// Generate dependency graph
console.log("\n🕸️ Dependency Graph:");
const graph = scanner.generateGraph();
console.log(`Providers: ${graph.providers.length}`);
console.log(`Modules: ${graph.modules.length}`);
// Show dependency map
if (graph.dependencies.size > 0) {
console.log("Dependencies:");
for (const [token, deps] of graph.dependencies.entries()) {
if (deps.length > 0) {
console.log(` ${String(token)} → [${deps.map((d) => String(d)).join(", ")}]`);
}
}
}
}
catch (error) {
console.error("Scanner demonstration failed:", error);
}
}
// Example of advanced scanner usage
export class ScannerUsageExample {
/**
* Scan and analyze a specific project structure
*/
static async analyzeProject(projectPath) {
const scanner = createDependencyScanner(`${projectPath}/tsconfig.json`);
// Scan different directories
const srcProviders = scanner.scanDirectory(`${projectPath}/src`);
const libProviders = scanner.scanDirectory(`${projectPath}/lib`);
console.log("Project Analysis:");
console.log(`Source providers: ${srcProviders.length}`);
console.log(`Library providers: ${libProviders.length}`);
// Check for circular dependencies
const validation = scanner.validate();
if (!validation.valid) {
console.error("Circular dependencies detected:");
validation.errors.forEach((error) => console.error(` ${error}`));
}
return {
providers: scanner.getProviders(),
modules: scanner.getModules(),
stats: scanner.getStats(),
validation,
};
}
/**
* Incremental scanning (useful for watch mode)
*/
static async incrementalScan(scanner, changedFiles) {
console.log(`Incrementally scanning ${changedFiles.length} changed files...`);
const newProviders = [];
for (const filePath of changedFiles) {
const providers = scanner.scanFile(filePath);
newProviders.push(...providers);
}
// Re-validate after changes
const validation = scanner.validate();
return {
newProviders,
validation,
stats: scanner.getStats(),
};
}
/**
* Filter providers by criteria
*/
static filterProviders(scanner) {
const allProviders = scanner.getProviders();
return {
singletons: allProviders.filter((p) => p.scope === "singleton"),
requestScoped: allProviders.filter((p) => p.scope === "request"),
transients: allProviders.filter((p) => p.scope === "transient"),
withDependencies: allProviders.filter((p) => p.dependencies.length > 0),
isolated: allProviders.filter((p) => p.dependencies.length === 0),
};
}
}
// Run demonstration if this file is executed directly
if (require.main === module) {
demonstrateScanner().catch(console.error);
}
//# sourceMappingURL=scanner.example.js.map