@capixjs/core 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Capix Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,329 @@
+# capix
+
+Core primitives for the Capix framework. Defines capabilities, context, guards, errors, enhancers, plugins, and the server.
+
+## Install
+
+```bash
+npm install @capixjs/core zod
+```
+
+## Quick example
+
+```ts
+import { z } from 'zod';
+import { capability, defineContext, defineGuard, defineError, createServer } from '@capixjs/core';
+import { restTransport } from '@capixjs/transport-rest';
+
+// 1. Define what your server knows about each request
+const buildContext = defineContext(async (req) => ({
+  requestId: crypto.randomUUID(),
+  user: req.headers.authorization === 'Bearer admin'
+    ? { id: '1', role: 'admin' as const }
+    : null,
+}));
+
+// 2. Define guards — preconditions that run before a capability
+const Errors = { Unauthorized: defineError(401, 'Unauthorized') };
+const mustBeUser = defineGuard((ctx) => {
+  if (!ctx.user) throw Errors.Unauthorized();
+});
+
+// 3. Define capabilities — typed pure functions
+const cap     = capability.withContext<Awaited<ReturnType<typeof buildContext>>>();
+const getUser = cap(
+  z.object({ id: z.string() }),
+  async ({ id }) => ({ id, name: 'Alice' }),
+  'query',
+).guard(mustBeUser);
+
+// 4. Create the server
+createServer({
+  context:      buildContext,
+  capabilities: { users: { getUser } },
+  transports:   [restTransport({ port: 3000 })],
+}).start();
+// → GET /users/:id
+```
+
+## Capability
+
+A capability wraps a resolver function with optional input/output schemas:
+
+```ts
+// No schema — no input validation
+const ping = capability(() => 'pong');
+
+// With input schema — validates and infers types
+const greet = capability(
+  z.object({ name: z.string() }),
+  ({ name }) => `Hello, ${name}`,
+);
+
+// With output schema — validates resolver return value in development
+const getMetrics = capability(
+  z.object({ window: z.enum(['1h', '24h']) }),
+  fetchMetrics,
+).output(MetricsSchema);
+
+// With explicit intent (overrides name-based inference)
+const searchUsers = capability(
+  z.object({ q: z.string() }),
+  ({ q }) => db.users.search(q),
+  'query',
+);
+```
+
+Capabilities are **immutable**. `.guard()`, `.enhance()`, and `.output()` each return a new instance:
+
+```ts
+const adminOnly = greet.guard(mustBeAdmin);
+const cached    = getMetrics.enhance(withCache(60));
+```
+
+### Context-typed factory
+
+Use `capability.withContext<TContext>()` to bind the factory to your application context type. Define it once, import everywhere:
+
+```ts
+// src/capabilities.ts
+import { capability } from '@capixjs/core';
+import type { AppContext } from './context.js';
+
+export const cap = capability.withContext<AppContext>();
+```
+
+For capabilities that require a logged-in user, define a second factory with a narrowed context:
+
+```ts
+type AuthContext = AppContext & { user: NonNullable<AppContext['user']> };
+
+export const cap     = capability.withContext<AppContext>();   // public endpoints
+export const authCap = capability.withContext<AuthContext>();  // authenticated endpoints
+```
+
+Without `withContext`, `ctx` is typed as `BaseContext` (only `requestId`).
+
+### Internal composition with `.resolve()`
+
+Call one capability from inside another. Guards re-run — this is intentional and safe:
+
+```ts
+export const getPost = cap(z.object({ id: z.string() }), async ({ id }) => {
+  const post = await db.posts.find(id);
+  if (!post) throw Errors.NotFound();
+  return post;
+}, 'query').guard(mustBeUser);
+
+export const updatePost = cap(z.object({ id: z.string(), title: z.string() }), async ({ id, title }, ctx) => {
+  const post = await getPost.resolve({ id }, ctx); // guards re-run
+  return db.posts.update(id, { title });
+}, 'update').guard(mustBeUser);
+```
+
+## Guards
+
+Guards run before the resolver and throw to reject the request:
+
+```ts
+import { defineGuard, defineError } from '@capixjs/core';
+
+const Errors = { Forbidden: defineError(403, 'Forbidden') };
+
+const mustBeAdmin = defineGuard((ctx) => {
+  if (ctx.user?.role !== 'admin') throw Errors.Forbidden();
+});
+
+// Multiple guards run in order; first failure stops execution
+const adminCap = capability(schema, handler)
+  .guard(mustBeLoggedIn)
+  .guard(mustBeAdmin);
+```
+
+**Input guards** run after input validation and receive both `(input, ctx)`:
+
+```ts
+import { defineInputGuard } from '@capixjs/core';
+
+const mustOwnResource = defineInputGuard((input: { id: string }, ctx) => {
+  if (input.id !== ctx.user?.id) throw Errors.Forbidden();
+});
+```
+
+## Errors
+
+```ts
+import { defineError, defaultErrors } from '@capixjs/core';
+
+// Define application-specific errors
+const Errors = {
+  NotFound:     defineError(404, 'Not found'),
+  OutOfStock:   defineError(409, 'Out of stock'),
+  // Explicit code — predictable, easy to test:
+  NotPurchased: defineError(403, 'You can only review products you have purchased', 'NotPurchased'),
+};
+
+// Use built-in errors
+throw defaultErrors.Unauthorized();
+throw defaultErrors.NotFound({ detail: 'User not found' });
+
+// Use custom errors
+throw Errors.OutOfStock({ productId: '123' });
+```
+
+The error code in responses is derived from the message (`'Not found'` → `'NotFound'`) unless you pass a third argument. Errors are serialized as:
+
+```json
+{ "error": "NotFound", "message": "Not found" }
+```
+
+with the given HTTP status code.
+
+## Enhancers
+
+Enhancers wrap the resolver for cross-cutting concerns:
+
+```ts
+import { withCache, withRateLimit, withCircuitBreaker, withTimeout, withRetry, withMetrics } from '@capixjs/core';
+
+const robustCap = capability(schema, handler)
+  .enhance(withCache(30))
+  .enhance(withRateLimit({ max: 100, windowMs: 60_000 }))
+  .enhance(withCircuitBreaker({ failureThreshold: 5, successThreshold: 2, timeoutMs: 30_000 }))
+  .enhance(withTimeout(5000))
+  .enhance(withRetry(3, 200));
+```
+
+| Enhancer | Options | Description |
+|---|---|---|
+| `withCache(ttlSeconds)` | `number` | In-memory cache keyed by capability name + serialized input |
+| `withRateLimit(opts)` | `{ max, windowMs }` | Sliding window rate limiter |
+| `withCircuitBreaker(opts)` | `{ failureThreshold, successThreshold, timeoutMs }` | Opens after N failures; resets after timeout |
+| `withTimeout(ms)` | `number` | Rejects after N milliseconds with `504 Timeout` |
+| `withRetry(n, delayMs?)` | `number, number` | Retries on non-FrameworkError failures with backoff |
+| `withRollback` | — | Enables `ctx.onRollback(fn)` for compensating failed multi-step mutations |
+| `withMetrics(collector)` | `MetricsCollector` | Emits duration and success/error metrics |
+| `withLogging` | — | Logs capability name, duration, and outcome |
+
+## Context
+
+Context is built once per request and passed to every guard and resolver:
+
+```ts
+import { defineContext } from '@capixjs/core';
+
+const buildContext = defineContext(async (req) => ({
+  requestId: crypto.randomUUID(),
+  user:      await verifyToken(req.headers.authorization),
+  db,
+}));
+```
+
+The `req` argument is `{ headers: Record<string, string | string[] | undefined> }`. Use `getHeader(req, 'authorization')` for safe string access.
+
+## Plugins
+
+Plugins encapsulate capabilities and context extensions:
+
+```ts
+import { definePlugin } from '@capixjs/core';
+
+const tenantPlugin = definePlugin({
+  capabilities: { users: { getUser, createUser } },
+  context: (base) => ({ ...base, tenantId: 'default' }),
+});
+
+createServer({
+  plugins:    [tenantPlugin, loggingPlugin],
+  transports: [restTransport({ port: 3000 })],
+}).start();
+```
+
+## Event bus
+
+Typed pub/sub for broadcasting events from REST capabilities to WebSocket clients:
+
+```ts
+import { createEventBus } from '@capixjs/core';
+
+type AppEvents = {
+  'order:paid':   { orderId: string; amount: number };
+  'task:updated': { id: string; status: string };
+};
+
+export const eventBus = createEventBus<AppEvents>();
+
+// Publish from any capability or anywhere in your app
+eventBus.publish('order:paid', { orderId: '123', amount: 99 });
+
+// Subscribe server-side
+const unsub = eventBus.subscribe('order:paid', (data) => {
+  console.log('Order paid:', data.orderId);
+});
+unsub(); // unsubscribe
+```
+
+Pass `eventBus` to `wsTransport({ eventBus })` to forward published events to subscribed WS clients.
+
+## Exports
+
+### Factories
+
+| Export | Description |
+|---|---|
+| `capability()` | Create a capability |
+| `capability.withContext<T>()` | Create a scoped factory with a pre-bound context type |
+| `defineContext(fn)` | Define a context builder |
+| `defineGuard(fn)` | Define a guard |
+| `defineGuardFor<T>()` | Define a narrowing guard (asserts ctx is T) |
+| `defineInputGuard(fn)` | Define an input guard (runs after validation, receives input + ctx) |
+| `defineError(status, message, code?)` | Define a typed error factory |
+| `defineEnhancer(fn)` | Define a capability enhancer |
+| `definePlugin(plugin)` | Define a plugin |
+| `defineConfig(config)` | Define server config with type inference |
+| `createServer(config)` | Create a server |
+| `createEventBus<TEvents>()` | Create a typed event bus |
+
+### Built-in enhancers
+
+| Export | Description |
+|---|---|
+| `withCache(ttlSeconds)` | In-memory output cache |
+| `withRateLimit(options)` | Sliding window rate limiter |
+| `withCircuitBreaker(options)` | Circuit breaker (closed / open / half-open) |
+| `withTimeout(ms)` | Cancel after N milliseconds |
+| `withRetry(maxAttempts, delayMs?)` | Retry on non-framework failures with backoff |
+| `withRollback` | Compensation registry for multi-step mutations |
+| `withMetrics(collector)` | Record timing and outcome metrics |
+| `withLogging` | Log capability name, duration, and outcome |
+| `consoleMetricsCollector` | Default `MetricsCollector` that logs to console |
+
+### Utilities
+
+| Export | Description |
+|---|---|
+| `isCapability(v)` | Type guard for capabilities |
+| `isFrameworkError(v)` | Type guard for FrameworkErrors |
+| `inferIntent(key)` | Infer capability intent from a key name |
+| `compileRegistry(capabilities)` | Compile a group tree into a flat registry |
+| `getHeader(req, name)` | Safe header access from `RawRequest` |
+| `defaultErrors` | Built-in error factories: `BadRequest`, `Unauthorized`, `Forbidden`, `NotFound`, `Conflict`, `TooManyRequests`, `Internal`, `Timeout` |
+| `runGuards` / `runInputGuards` | Run guard arrays (used by custom transports) |
+| `createExecutionEngine(options)` | Create a capability execution engine |
+| `mergePlugins(plugins)` | Merge a plugin array into a single plugin |
+
+### Types
+
+`Capability<TInput, TOutput, TContext>`, `AnyCapability`, `BaseContext`, `ContextBuilder`,
+`RawRequest`, `Guard`, `NarrowingGuard`, `InputGuard`, `AnyGuard`, `NarrowContext`,
+`Enhancer`, `Resolver`, `Plugin`, `MergedPlugins`, `Intent`, `InferInput<Cap>`,
+`InferOutput<Cap>`, `InferContext<Cap>`, `GroupTree`, `CapabilityRegistry`,
+`ScopedCapabilityFactory`, `FrameworkError`, `ErrorFactory`, `WithRollback<T>`,
+`MetricsCollector`, `CircuitBreakerOptions`, `RateLimitOptions`, `Transport`,
+`TransportWithCapabilities`, `MountOptions`, `ServerConfig`, `Server`,
+`EventBus<TEvents>`, `EventMap`, `SubscribeOptions`, `InvokeFn`, `CapabilityRequest`,
+`CapabilityResponse`
+
+## License
+
+MIT

package/dist/capability.d.ts

@@ -0,0 +1,165 @@
+/**
+ * capability.ts — the core capability primitive
+ * Depends on: errors.ts, context.ts, guards.ts, zod
+ */
+import type { ZodSchema, ZodTypeAny } from 'zod';
+import type { BaseContext } from './context.js';
+import type { AnyGuard, AnyInputGuard, InputGuard, NarrowContext } from './guards.js';
+declare const CAPABILITY_BRAND: unique symbol;
+export type Intent = 'query' | 'mutation' | 'update' | 'replace' | 'delete';
+/** Infers capability intent from its key name in the parent group. */
+export declare function inferIntent(key: string): Intent;
+export type Enhancer = <TInput, TOutput, TContext extends BaseContext>(cap: Capability<TInput, TOutput, TContext>) => Capability<TInput, TOutput, TContext>;
+export type Resolver<TInput, TOutput, TContext extends BaseContext> = (input: TInput, ctx: TContext) => TOutput | Promise<TOutput>;
+export type Capability<TInput, TOutput, TContext extends BaseContext> = {
+    readonly _capix: true;
+    readonly [CAPABILITY_BRAND]: true;
+    readonly name: string;
+    readonly _input: TInput;
+    readonly _output: TOutput;
+    readonly _context: TContext;
+    readonly inputSchema: ZodTypeAny | null;
+    readonly outputSchema: ZodTypeAny | null;
+    readonly guards: ReadonlyArray<AnyGuard>;
+    readonly inputGuards: ReadonlyArray<AnyInputGuard>;
+    readonly intent: Intent;
+    /** True when intent was explicitly passed to capability(); false when defaulted. */
+    readonly _intentExplicit: boolean;
+    /**
+     * Set by compileRegistry when inputSchema is a z.object({}) with no keys.
+     * The execution engine skips input validation entirely — there is nothing to validate.
+     */
+    readonly _skipValidation: boolean;
+    /**
+     * Invoke this capability's guards and resolver directly.
+     *
+     * Guards always re-run — this is safe to call from any context.
+     * If the context does not satisfy the guards, they throw as normal.
+     *
+     * TypeScript does not verify at the call site that the provided context
+     * satisfies this capability's guard requirements — guards enforce this
+     * at runtime. This enables capability composition without escape hatches:
+     *
+     * ```ts
+     * const getDashboard = cap(z.object({}), async (_, ctx) => {
+     *   const [log, projects] = await Promise.all([
+     *     listAuditLog.resolve({ limit: 10 }, ctx),  // mustBeAdmin runs — throws if not admin
+     *     listProjects.resolve({ limit: 5 },  ctx),  // mustBeAuthenticated runs
+     *   ]);
+     *   return { log, projects };
+     * }, 'query').guard(mustBeAuthenticated);
+     * ```
+     *
+     * For HTTP/GraphQL/queue invocation, the execution engine uses _resolverOnly
+     * after running guards itself — guards run exactly once per external request.
+     */
+    resolve: (input: TInput, ctx: BaseContext) => Promise<TOutput>;
+    /**
+     * Raw resolver — no guards. Used by the execution engine after it has
+     * already run guards. Also used internally by enhancers wrapping the resolver.
+     * Do not call this from application code — use resolve() instead.
+     */
+    _resolverOnly: (input: TInput, ctx: TContext) => Promise<TOutput>;
+    /**
+     * Adds a guard to this capability.
+     *
+     * The guard must accept the capability's current TContext (or a supertype of it).
+     * Function-parameter contravariance means a guard typed for a broader context
+     * (e.g. BaseContext) is always assignable, while a guard typed for a more specific
+     * context (e.g. AppContext) requires TContext to already be at least that specific.
+     * Use `capability.withContext<AppContext>()` to start with TContext = AppContext so
+     * all AppContext guards are accepted without explicit resolver annotation.
+     */
+    guard<G extends (ctx: TContext) => any>(g: G): Capability<TInput, TOutput, NarrowContext<TContext, G>>;
+    /**
+     * Adds an input guard that receives both validated input and context.
+     * Runs after input validation, before the resolver.
+     * Use for resource ownership checks and other input-dependent access control.
+     */
+    inputGuard(g: InputGuard<TInput, TContext>): Capability<TInput, TOutput, TContext>;
+    enhance(e: Enhancer): Capability<TInput, TOutput, TContext>;
+    output<O>(schema: ZodSchema<O>): Capability<TInput, O, TContext>;
+};
+export type AnyCapability = Capability<any, any, any>;
+/**
+ * Defines a capability — the unit of server-side logic in Capix.
+ *
+ * Wraps a resolver function with optional input validation (Zod schema), guards,
+ * and enhancers. Capabilities are the building blocks registered in createServer().
+ *
+ * @example No-input capability
+ * const ping = capability(() => ({ pong: true }));
+ *
+ * @example With Zod input schema
+ * const getUser = capability(
+ *   z.object({ id: z.string() }),
+ *   async (input, ctx) => db.users.find(input.id),
+ * );
+ *
+ * @example With explicit intent (overrides key-based inference in inferRoutes)
+ * const deletePost = capability(
+ *   z.object({ id: z.string() }),
+ *   async (input, ctx) => db.posts.delete(input.id),
+ *   'delete',
+ * );
+ *
+ * @example Adding guards and enhancers
+ * const createPost = capability(schema, resolver)
+ *   .guard(mustBeAuthenticated)
+ *   .enhance(withTimeout(5000));
+ *
+ * Use {@link capability.withContext} to pre-bind the context type when all
+ * capabilities in a module share the same application context.
+ */
+/** No-input capability. */
+export declare function capability<TOutput, TContext extends BaseContext = BaseContext>(resolver: (input: undefined, ctx: TContext) => TOutput | Promise<TOutput>): Capability<undefined, TOutput, TContext>;
+/** No-input capability with explicit intent. */
+export declare function capability<TOutput, TContext extends BaseContext = BaseContext>(resolver: (input: undefined, ctx: TContext) => TOutput | Promise<TOutput>, intent: Intent): Capability<undefined, TOutput, TContext>;
+/** With typed input schema. */
+export declare function capability<TSchema extends ZodTypeAny, TOutput, TContext extends BaseContext = BaseContext>(schema: TSchema, resolver: Resolver<TSchema['_output'], TOutput, TContext>): Capability<TSchema['_output'], TOutput, TContext>;
+/** With typed input schema and explicit intent. */
+export declare function capability<TSchema extends ZodTypeAny, TOutput, TContext extends BaseContext = BaseContext>(schema: TSchema, resolver: Resolver<TSchema['_output'], TOutput, TContext>, intent: Intent): Capability<TSchema['_output'], TOutput, TContext>;
+/** Extract the validated input type from a Capability. */
+export type InferInput<TCap extends AnyCapability> = TCap['_input'];
+/** Extract the resolved output type from a Capability. */
+export type InferOutput<TCap extends AnyCapability> = TCap['_output'];
+/** Extract the required context type from a Capability (reflects guard narrowing). */
+export type InferContext<TCap extends AnyCapability> = TCap['_context'];
+/** Returns true for values created by capability(). Plain objects with _capix: true return false. */
+export declare function isCapability(value: unknown): value is AnyCapability;
+export type CapabilityRegistry = ReadonlyMap<string, AnyCapability>;
+/** Interface to allow recursive references (type aliases can't be circular). */
+export interface GroupTree {
+    [key: string]: AnyCapability | GroupTree;
+}
+export declare function compileRegistry(tree: GroupTree, prefix?: string): CapabilityRegistry;
+/**
+ * The type returned by `capability.withContext<TContext>()`.
+ * Identical to the `capability()` overloads but with TContext fixed.
+ */
+export type ScopedCapabilityFactory<TContext extends BaseContext> = {
+    <TOutput>(resolver: (input: undefined, ctx: TContext) => TOutput | Promise<TOutput>): Capability<undefined, TOutput, TContext>;
+    <TOutput>(resolver: (input: undefined, ctx: TContext) => TOutput | Promise<TOutput>, intent: Intent): Capability<undefined, TOutput, TContext>;
+    <TSchema extends ZodTypeAny, TOutput>(schema: TSchema, resolver: Resolver<TSchema['_output'], TOutput, TContext>): Capability<TSchema['_output'], TOutput, TContext>;
+    <TSchema extends ZodTypeAny, TOutput>(schema: TSchema, resolver: Resolver<TSchema['_output'], TOutput, TContext>, intent: Intent): Capability<TSchema['_output'], TOutput, TContext>;
+};
+export declare namespace capability {
+    /**
+     * Returns a `capability()` factory with TContext pre-bound.
+     * The resolver's `ctx` parameter is inferred as TContext without annotation,
+     * and guards typed for TContext are accepted without the `any` escape hatch.
+     *
+     * @example
+     * const appCap = capability.withContext<AppContext>();
+     * const getUser = appCap(
+     *   z.object({ id: z.string() }),
+     *   async (input, ctx) => {  // ctx: AppContext — no annotation needed
+     *     if (!ctx.user) throw Errors.Unauthorized();
+     *     return db.users.find(input.id);
+     *   },
+     * ).guard(mustBeAuthenticated);
+     */
+    function withContext<TContext extends BaseContext>(): ScopedCapabilityFactory<TContext>;
+}
+export {};
+//# sourceMappingURL=capability.d.ts.map

package/dist/capability.d.ts.map

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