@bluelibs/runner 3.2.0 → 3.3.0

package/README.md

@@ -999,40 +999,418 @@ await paymentLogger.info("Processing payment", { data: paymentData });
 await authLogger.warn("Failed login attempt", { data: { email, ip } });
 ```
 
-## Meta: Tagging Your Components
+## Meta: Documenting and Organizing Your Components
 
-Sometimes you want to attach metadata to your tasks and resources for documentation, filtering, or middleware logic:
+_The structured way to describe what your components do and control their behavior_
+
+Metadata in BlueLibs Runner provides a systematic way to document, categorize, and control the behavior of your tasks, resources, events, and middleware. Think of it as your component's passport - it tells you and your tools everything they need to know about what this component does and how it should be treated.
+
+### Basic Metadata Properties
+
+Every component can have these basic metadata properties:
+
+```typescript
+interface IMeta {
+  title?: string; // Human-readable name
+  description?: string; // What this component does
+  tags?: TagType[]; // Categories and behavioral flags
+}
+```
+
+### Simple Documentation Example
 
 ```typescript
-const apiTask = task({
-  id: "app.tasks.api.createUser",
+const userService = resource({
+  id: "app.services.user",
   meta: {
-    title: "Create User API",
-    description: "Creates a new user account",
-    tags: ["api", "user", "public"],
+    title: "User Management Service",
+    description:
+      "Handles user creation, authentication, and profile management",
+    tags: ["service", "user", "core"],
   },
-  run: async (userData) => {
-    // Business logic
+  dependencies: { database },
+  init: async (_, { database }) => ({
+    createUser: async (userData) => {
+      /* ... */
+    },
+    authenticateUser: async (credentials) => {
+      /* ... */
+    },
+  }),
+});
+
+const sendWelcomeEmail = task({
+  id: "app.tasks.sendWelcomeEmail",
+  meta: {
+    title: "Send Welcome Email",
+    description: "Sends a welcome email to newly registered users",
+    tags: ["email", "automation", "user-onboarding"],
+  },
+  dependencies: { emailService },
+  run: async (userData, { emailService }) => {
+    // Email sending logic
   },
 });
+```
+
+### Tags: The Powerful Classification System
+
+Tags are the most powerful part of the metadata system. They can be simple strings or sophisticated configuration objects that control component behavior.
 
-// Middleware that only applies to API tasks
-const apiMiddleware = middleware({
-  id: "app.middleware.api",
+#### String Tags for Simple Classification
+
+```typescript
+const adminTask = task({
+  id: "app.tasks.admin.deleteUser",
+  meta: {
+    title: "Delete User Account",
+    description: "Permanently removes a user account and all associated data",
+    tags: [
+      "admin", // Access level
+      "destructive", // Behavioral flag
+      "user", // Domain
+      "gdpr-compliant", // Compliance flag
+    ],
+  },
+  run: async (userId) => {
+    // Deletion logic
+  },
+});
+
+// Middleware that adds extra logging for destructive operations
+const auditMiddleware = middleware({
+  id: "app.middleware.audit",
   run: async ({ task, next }) => {
-    if (task.meta?.tags?.includes("api")) {
-      // Apply API-specific logic
+    const isDestructive = task.definition.meta?.tags?.includes("destructive");
+
+    if (isDestructive) {
+      console.log(`🔥 DESTRUCTIVE OPERATION: ${task.definition.id}`);
+      await auditLogger.log({
+        operation: task.definition.id,
+        user: getCurrentUser(),
+        timestamp: new Date(),
+      });
     }
+
     return next(task.input);
   },
 });
 ```
 
+#### Advanced Tags with Configuration
+
+For more sophisticated control, you can create structured tags that carry configuration:
+
+```typescript
+import { tag } from "@bluelibs/runner";
+
+// Define a reusable tag with configuration
+const performanceTag = tag<{ alertAboveMs: number; criticalAboveMs: number }>({
+  id: "performance.monitoring",
+});
+
+const rateLimitTag = tag<{ maxRequestsPerMinute: number; burstLimit?: number }>(
+  {
+    id: "rate.limit",
+  }
+);
+
+const cacheTag = tag<{ ttl: number; keyPattern?: string }>({
+  id: "cache.strategy",
+});
+
+// Use structured tags in your components
+const expensiveTask = task({
+  id: "app.tasks.expensiveCalculation",
+  meta: {
+    title: "Complex Data Processing",
+    description: "Performs heavy computational analysis on large datasets",
+    tags: [
+      "computation",
+      "background",
+      performanceTag.with({
+        alertAboveMs: 5000,
+        criticalAboveMs: 15000,
+      }),
+      cacheTag.with({
+        ttl: 300000, // 5 minutes
+        keyPattern: "calc-{userId}-{datasetId}",
+      }),
+    ],
+  },
+  run: async (input) => {
+    // Heavy computation here
+  },
+});
+
+const apiEndpoint = task({
+  id: "app.tasks.api.getUserProfile",
+  meta: {
+    title: "Get User Profile",
+    description: "Returns user profile information with privacy filtering",
+    tags: [
+      "api",
+      "public",
+      rateLimitTag.with({
+        maxRequestsPerMinute: 100,
+        burstLimit: 20,
+      }),
+      cacheTag.with({ ttl: 60000 }), // 1 minute cache
+    ],
+  },
+  run: async (userId) => {
+    // API logic
+  },
+});
+```
+
+#### Smart Middleware Using Structured Tags
+
+```typescript
+const performanceMiddleware = middleware({
+  id: "app.middleware.performance",
+  run: async ({ task, next }) => {
+    const tags = task.definition.meta?.tags || [];
+    const perfConfig = performanceTag.extract(tags);
+
+    if (perfConfig) {
+      const startTime = Date.now();
+
+      try {
+        const result = await next(task.input);
+        const duration = Date.now() - startTime;
+
+        if (duration > perfConfig.config.criticalAboveMs) {
+          await alerting.critical(
+            `Task ${task.definition.id} took ${duration}ms`
+          );
+        } else if (duration > perfConfig.config.alertAboveMs) {
+          await alerting.warn(`Task ${task.definition.id} took ${duration}ms`);
+        }
+
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        await alerting.error(
+          `Task ${task.definition.id} failed after ${duration}ms`,
+          error
+        );
+        throw error;
+      }
+    }
+
+    return next(task.input);
+  },
+});
+
+const rateLimitMiddleware = middleware({
+  id: "app.middleware.rateLimit",
+  dependencies: { redis },
+  run: async ({ task, next }, { redis }) => {
+    // Extraction can be done at task.definition level or at task.definition.meta.tags
+    const rateLimitCurrentTag = rateLimitTag.extract(task.definition);
+
+    // Alternative way
+    const tags = task.definition.meta?.tags;
+    const rateLimitCurrentTag = rateLimitTag.extract(tags);
+
+    if (rateLimitCurrentTag) {
+      const key = `rateLimit:${task.definition.id}`;
+      const current = await redis.incr(key);
+
+      if (current === 1) {
+        await redis.expire(key, 60); // 1 minute window
+      }
+
+      if (current > rateLimitCurrentTag.config.maxRequestsPerMinute) {
+        throw new Error("Rate limit exceeded");
+      }
+    }
+
+    return next(task.input);
+  },
+});
+```
+
+### When to Use Metadata
+
+#### ✅ Great Use Cases
+
+**Documentation & Discovery**
+
+```typescript
+const paymentProcessor = resource({
+  meta: {
+    title: "Payment Processing Service",
+    description:
+      "Handles credit card payments via Stripe API with fraud detection",
+    tags: ["payment", "stripe", "pci-compliant", "critical"],
+  },
+  // ... implementation
+});
+```
+
+**Conditional Behavior**
+
+```typescript
+const backgroundTask = task({
+  meta: {
+    tags: ["background", "low-priority", retryTag.with({ maxAttempts: 5 })],
+  },
+  // ... implementation
+});
+```
+
+**Cross-Cutting Concerns**
+
+```typescript
+// All tasks tagged with "audit" get automatic logging
+const sensitiveOperation = task({
+  meta: {
+    tags: ["audit", "sensitive", "admin-only"],
+  },
+  // ... implementation
+});
+```
+
+**Environment-Specific Behavior**
+
+```typescript
+const developmentTask = task({
+  meta: {
+    tags: ["development-only", debugTag.with({ verbose: true })],
+  },
+  // ... implementation
+});
+```
+
+#### ❌ When NOT to Use Metadata
+
+**Simple Internal Logic** - Don't overcomplicate straightforward code:
+
+```typescript
+// ❌ Overkill
+const simple = task({
+  meta: { tags: ["internal", "utility"] },
+  run: () => Math.random(),
+});
+
+// ✅ Better
+const generateId = () => Math.random().toString(36);
+```
+
+**One-Off Tasks** - If it's used once, metadata won't help:
+
+```typescript
+// ❌ Unnecessary
+const oneTimeScript = task({
+  meta: { title: "Migration Script", tags: ["migration"] },
+  run: () => {
+    /* run once and forget */
+  },
+});
+```
+
+### Extending Metadata: Custom Properties
+
+For advanced use cases, you can extend the metadata interfaces to add your own properties:
+
+```typescript
+// In your types file
+declare module "@bluelibs/runner" {
+  interface ITaskMeta {
+    author?: string;
+    version?: string;
+    deprecated?: boolean;
+    apiVersion?: "v1" | "v2" | "v3";
+    costLevel?: "low" | "medium" | "high";
+  }
+
+  interface IResourceMeta {
+    healthCheck?: string; // URL for health checking
+    dependencies?: string[]; // External service dependencies
+    scalingPolicy?: "auto" | "manual";
+  }
+}
+
+// Now use your custom properties
+const expensiveApiTask = task({
+  id: "app.tasks.ai.generateImage",
+  meta: {
+    title: "AI Image Generation",
+    description: "Uses OpenAI DALL-E to generate images from text prompts",
+    tags: ["ai", "expensive", "external-api"],
+    author: "AI Team",
+    version: "2.1.0",
+    apiVersion: "v2",
+    costLevel: "high", // Custom property!
+  },
+  run: async (prompt) => {
+    // AI generation logic
+  },
+});
+
+const database = resource({
+  id: "app.database.primary",
+  meta: {
+    title: "Primary PostgreSQL Database",
+    tags: ["database", "critical", "persistent"],
+    healthCheck: "/health/db", // Custom property!
+    dependencies: ["postgresql", "connection-pool"],
+    scalingPolicy: "auto",
+  },
+  // ... implementation
+});
+```
+
+### Advanced Patterns
+
+#### Tag-Based Component Selection
+
+```typescript
+// Find all API endpoints
+function getApiTasks(store: Store) {
+  return store.getAllTasks().filter((task) => task.meta?.tags?.includes("api"));
+}
+
+// Find all tasks with specific performance requirements
+function getPerformanceCriticalTasks(store: Store) {
+  return store.getAllTasks().filter((task) => {
+    const tags = task.meta?.tags || [];
+    return performanceTag.extract(tags) !== null;
+  });
+}
+```
+
+#### Dynamic Middleware Application
+
+```typescript
+const app = resource({
+  id: "app",
+  register: [
+    // Apply performance middleware globally but only to tagged tasks
+    performanceMiddleware.everywhere({
+      tasks: true,
+      resources: false,
+    }),
+    // Apply rate limiting only to API tasks
+    rateLimitMiddleware.everywhere({
+      tasks: true,
+      resources: false,
+    }),
+  ],
+});
+```
+
+Metadata transforms your components from anonymous functions into self-documenting, discoverable, and controllable building blocks. Use it wisely, and your future self (and your team) will thank you.
+
 ## Advanced Usage: When You Need More Power
 
 ### Overrides: Swapping Components at Runtime
 
-Sometimes you need to replace a component entirely. Maybe you're testing, maybe you're A/B testing, maybe you just changed your mind:
+Sometimes you need to replace a component entirely. Maybe you're doing integration testing or you want to override a library from an external package.
+
+You can now use a dedicated helper `override()` to safely override any property on tasks, resources, or middleware — except `id`. This ensures the identity is preserved, while allowing behavior changes.
 
 ```typescript
 const productionEmailer = resource({
@@ -1040,9 +1418,15 @@ const productionEmailer = resource({
   init: async () => new SMTPEmailer(),
 });
 
+// Option 1: Using override() to change behavior while preserving id (Recommended)
+const testEmailer = override(productionEmailer, {
+  init: async () => new MockEmailer(),
+});
+
+// Option 2: Using spread operator, does not provide type-safety
 const testEmailer = resource({
-  ...productionEmailer, // Copy everything else
-  init: async () => new MockEmailer(), // But use a different implementation
+  ...productionEmailer,
+  init: async () => {},
 });
 
 const app = resource({
@@ -1050,8 +1434,36 @@ const app = resource({
   register: [productionEmailer],
   overrides: [testEmailer], // This replaces the production version
 });
+
+import { override } from "@bluelibs/runner";
+
+// Tasks
+const originalTask = task({ id: "app.tasks.compute", run: async () => 1 });
+const overriddenTask = override(originalTask, {
+  run: async () => 2,
+});
+
+// Resources
+const originalResource = resource({ id: "app.db", init: async () => "conn" });
+const overriddenResource = override(originalResource, {
+  init: async () => "mock-conn",
+});
+
+// Middleware
+const originalMiddleware = middleware({
+  id: "app.middleware.log",
+  run: async ({ next }) => next(),
+});
+const overriddenMiddleware = override(originalMiddleware, {
+  run: async ({ task, next }) => {
+    const result = await next(task?.input as any);
+    return { wrapped: result } as any;
+  },
+});
 ```
 
+Overrides are applied after everything is registered. If multiple overrides target the same id, the one defined higher in the resource tree (closer to the root) wins, because it’s applied last. Conflicting overrides are allowed; overriding something that wasn’t registered throws. Use override() to change behavior safely while preserving the original id.
+
 ### Namespacing: Keeping Things Organized
 
 As your app grows, you'll want consistent naming. Here's the convention that won't drive you crazy:
@@ -1444,34 +1856,70 @@ describe("registerUser task", () => {
 });
 ```
 
-### Integration Testing: The Real Deal
+### Integration Testing: The Real Deal (But Actually Fun)
 
-Integration testing with overrides lets you test the whole system with controlled components:
+Spin up your whole app, keep all the middleware/events, and still test like a human. The trick: a tiny test harness.
 
 ```typescript
-const testDatabase = resource({
-  id: "app.database",
-  init: async () => new MemoryDatabase(), // In-memory test database
+import {
+  run,
+  createTestResource,
+  resource,
+  task,
+  override,
+} from "@bluelibs/runner";
+
+// Your real app
+const app = resource({
+  id: "app",
+  register: [
+    /* tasks, resources, middleware */
+  ],
 });
 
-// Just like a shaworma wrap!
-const testApp = resource({
-  id: "test.app",
-  register: [productionApp],
-  overrides: [testDatabase], // Replace real database with test one
+// Optional: overrides for infra (hello, fast tests!)
+const testDb = resource({
+  id: "app.database",
+  init: async () => new InMemoryDb(),
 });
+const mockMailer = override(realMailer, { init: async () => fakeMailer });
 
-describe("Full application", () => {
-  it("should handle user registration flow", async () => {
-    const { dispose } = await run(testApp);
+// Create the test harness
+const harness = createTestResource(app, { overrides: [testDb, mockMailer] });
 
-    // Test your application end-to-end
+// A task you want to drive in your tests
+const registerUser = task({ id: "app.tasks.registerUser" /* ... */ });
 
-    await dispose(); // Clean up
-  });
-});
+// Boom: full ecosystem run (middleware, events, overrides) with a tiny driver
+const { value: t, dispose } = await run(harness);
+const result = await t.runTask(registerUser, { email: "x@y.z" });
+expect(result).toMatchObject({ success: true });
+await dispose();
 ```
 
+Prefer scenario tests? Return whatever you want from the harness and assert outside:
+
+```typescript
+const flowHarness = createTestResource(
+  resource({
+    id: "app",
+    register: [db, createUser, issueToken],
+  })
+);
+
+const { value: t, dispose } = await run(flowHarness);
+const user = await t.runTask(createUser, { email: "a@b.c" });
+const token = await t.runTask(issueToken, { userId: user.id });
+expect(token).toBeTruthy();
+await dispose();
+```
+
+Why this rocks:
+
+- Minimal ceremony, no API pollution
+- Real wiring (middleware/events/overrides) – what runs in prod runs in tests
+- You choose: drive tasks directly or build domain-y flows
+
 ## Semaphore
 
 Ever had too many database connections competing for resources? Your connection pool under pressure? The `Semaphore` is here to manage concurrent operations like a professional traffic controller.

package/dist/cli/extract-docs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/extract-docs.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+// Note: avoid file URLs to keep CommonJS require working well
+const introspect_1 = require("../docs/introspect");
+function parseArgs(argv) {
+    const args = { entry: "", outDir: "./documentation" };
+    const offset = argv[2] === "extract-docs" ? 3 : 2;
+    const rest = argv.slice(offset);
+    if (!rest[0]) {
+        console.error("Usage: runner extract-docs <entry> [--export <name>] [--out-dir <dir>] [--include-globals] [--config <path>] [--format json|md|all]");
+        process.exit(1);
+    }
+    args.entry = rest[0];
+    for (let i = 1; i < rest.length; i++) {
+        const flag = rest[i];
+        if (flag === "--export") {
+            args.exportName = rest[++i];
+        }
+        else if (flag === "--out-dir") {
+            args.outDir = rest[++i];
+        }
+        else if (flag === "--include-globals") {
+            args.includeGlobals = true;
+        }
+        else if (flag === "--config") {
+            args.configPath = rest[++i];
+        }
+        else if (flag === "--format") {
+            const val = rest[++i];
+            if (val === "json" || val === "md" || val === "all") {
+                args.format = val;
+            }
+        }
+    }
+    return args;
+}
+async function loadModule(entryPath) {
+    const resolved = path.isAbsolute(entryPath)
+        ? entryPath
+        : path.resolve(process.cwd(), entryPath);
+    // Prefer dynamic import; in CommonJS this becomes require(resolved)
+    return await Promise.resolve(`${resolved}`).then(s => require(s));
+}
+async function main() {
+    const args = parseArgs(process.argv);
+    const mod = await loadModule(args.entry);
+    const exportName = args.exportName || "default";
+    let resource;
+    if (exportName === "default") {
+        resource = (mod && mod.default) || mod;
+    }
+    else {
+        resource = mod[exportName];
+    }
+    if (!resource || typeof resource !== "object") {
+        console.error(`Could not find exported resource '${exportName}' from ${args.entry}`);
+        process.exit(2);
+    }
+    const config = args.configPath
+        ? JSON.parse(fs.readFileSync(args.configPath, "utf-8"))
+        : {};
+    const graph = await (0, introspect_1.introspectResource)(resource, config, {
+        includeGlobals: args.includeGlobals,
+    });
+    const outDir = path.isAbsolute(args.outDir)
+        ? args.outDir
+        : path.resolve(process.cwd(), args.outDir);
+    fs.mkdirSync(outDir, { recursive: true });
+    const format = args.format || "json";
+    if (format === "json" || format === "all") {
+        const outFile = path.join(outDir, "graph.json");
+        fs.writeFileSync(outFile, JSON.stringify(graph, null, 2), "utf-8");
+        console.log(`Docs graph written to ${outFile}`);
+    }
+    if (format === "md" || format === "all") {
+        const { renderMarkdown } = await Promise.resolve().then(() => require("../docs/markdown"));
+        renderMarkdown(graph, outDir);
+        console.log(`Markdown docs written under ${outDir}`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(99);
+});
+//# sourceMappingURL=extract-docs.js.map

package/dist/cli/extract-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-docs.js","sourceRoot":"","sources":["../../src/cli/extract-docs.ts"],"names":[],"mappings":"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"}