@classytic/arc 2.9.1 → 2.10.3

package/skills/arc/references/production.md

@@ -366,28 +366,6 @@ const runner = new MigrationRunner(mongoose.connection.db);
 await runner.up([v2]);
 ```
 
-## Policies
-
-Query-level authorization — modify queries based on user:
-
-```typescript
-import { createAccessControlPolicy } from '@classytic/arc/policies';
-
-const editorPolicy = createAccessControlPolicy({
-  statements: [
-    { resource: 'product', action: ['create', 'update'] },
-    { resource: 'order', action: ['read'] },
-  ],
-});
-
-defineResource({
-  permissions: {
-    create: editorPolicy,
-    update: editorPolicy,
-  },
-});
-```
-
 ## OpenAPI & External Paths
 
 Arc auto-generates OpenAPI 3.0 specs from resource definitions. External integrations (auth adapters, custom routes) inject their paths via `ExternalOpenApiPaths`.
@@ -562,25 +540,6 @@ const relayed = await outbox.relay();  // publishes pending → transport
 
 **OutboxStore interface**: `save(event)`, `getPending(limit)`, `acknowledge(eventId)` (+ optional `claimPending`, `fail`, `getDeadLettered`, `purge`). When you pass `repository`, arc adapts it internally.
 
-## RPC Service Client — Schema Versioning
-
-The service client supports a `schemaVersion` option for contract compatibility between services:
-
-```typescript
-import { createServiceClient } from '@classytic/arc/rpc';
-
-const catalog = createServiceClient({
-  baseUrl: 'http://catalog:3000',
-  schemaVersion: '1.2.0',  // sent as x-arc-schema-version header
-  correlationId: () => request.id,
-  retry: { maxRetries: 2 },
-});
-
-const products = await catalog.resource('product').list();
-```
-
-Receiving services can check `request.headers['x-arc-schema-version']` to detect version mismatches.
-
 ## Bulk Operations Preset
 
 Adds bulk CRUD routes — repository must provide `createMany`, `updateMany`, `deleteMany`:

package/dist/circuitBreaker-CvXkjfrW.d.mts

@@ -1,206 +0,0 @@
-//#region src/utils/circuitBreaker.d.ts
-/**
- * Circuit Breaker Pattern
- *
- * Wraps external service calls with failure protection.
- * Prevents cascading failures by "opening" the circuit when
- * a service is failing, allowing it time to recover.
- *
- * States:
- * - CLOSED: Normal operation, requests pass through
- * - OPEN: Too many failures, all requests fail fast
- * - HALF_OPEN: Testing if service recovered, limited requests
- *
- * @example
- * import { CircuitBreaker } from '@classytic/arc/utils';
- *
- * const paymentBreaker = new CircuitBreaker(async (amount) => {
- *   return await stripe.charges.create({ amount });
- * }, {
- *   failureThreshold: 5,
- *   resetTimeout: 30000,
- *   timeout: 5000,
- * });
- *
- * try {
- *   const result = await paymentBreaker.call(100);
- * } catch (error) {
- *   // Handle failure or circuit open
- * }
- */
-declare const CircuitState: {
-  readonly CLOSED: "CLOSED";
-  readonly OPEN: "OPEN";
-  readonly HALF_OPEN: "HALF_OPEN";
-};
-type CircuitState = (typeof CircuitState)[keyof typeof CircuitState];
-interface CircuitBreakerOptions {
-  /**
-   * Number of failures before opening circuit
-   * @default 5
-   */
-  failureThreshold?: number;
-  /**
-   * Time in ms before attempting to close circuit
-   * @default 60000 (60 seconds)
-   */
-  resetTimeout?: number;
-  /**
-   * Request timeout in ms
-   * @default 10000 (10 seconds)
-   */
-  timeout?: number;
-  /**
-   * Number of successful requests in HALF_OPEN before closing
-   * @default 1
-   */
-  successThreshold?: number;
-  /**
-   * Fallback function when circuit is open.
-   * Receives the same arguments as the wrapped function.
-   */
-  fallback?: (...args: unknown[]) => Promise<unknown>;
-  /**
-   * Callback when state changes
-   */
-  onStateChange?: (from: CircuitState, to: CircuitState) => void;
-  /**
-   * Callback on error
-   */
-  onError?: (error: Error) => void;
-  /**
-   * Name for logging/monitoring
-   */
-  name?: string;
-}
-interface CircuitBreakerStats {
-  name?: string;
-  state: CircuitState;
-  failures: number;
-  successes: number;
-  totalCalls: number;
-  openedAt: number | null;
-  lastCallAt: number | null;
-}
-declare class CircuitBreakerError extends Error {
-  state: CircuitState;
-  constructor(message: string, state: CircuitState);
-}
-declare class CircuitBreaker<T extends (...args: any[]) => Promise<any>> {
-  private state;
-  private failures;
-  private successes;
-  private totalCalls;
-  private nextAttempt;
-  private lastCallAt;
-  private openedAt;
-  private readonly failureThreshold;
-  private readonly resetTimeout;
-  private readonly timeout;
-  private readonly successThreshold;
-  private readonly fallback?;
-  private readonly onStateChange?;
-  private readonly onError?;
-  private readonly name;
-  private readonly fn;
-  constructor(fn: T, options?: CircuitBreakerOptions);
-  /**
-   * Call the wrapped function with circuit breaker protection
-   */
-  call(...args: Parameters<T>): Promise<ReturnType<T>>;
-  /**
-   * Execute function with timeout
-   */
-  private executeWithTimeout;
-  /**
-   * Handle successful call
-   */
-  private onSuccess;
-  /**
-   * Handle failed call
-   */
-  private onFailure;
-  /**
-   * Change circuit state
-   */
-  private setState;
-  /**
-   * Manually open the circuit
-   */
-  open(): void;
-  /**
-   * Manually close the circuit
-   */
-  close(): void;
-  /**
-   * Get current statistics
-   */
-  getStats(): CircuitBreakerStats;
-  /**
-   * Get current state
-   */
-  getState(): CircuitState;
-  /**
-   * Check if circuit is open
-   */
-  isOpen(): boolean;
-  /**
-   * Check if circuit is closed
-   */
-  isClosed(): boolean;
-  /**
-   * Reset statistics
-   */
-  reset(): void;
-}
-/**
- * Create a circuit breaker with sensible defaults
- *
- * @example
- * const emailBreaker = createCircuitBreaker(
- *   async (to, subject, body) => sendEmail(to, subject, body),
- *   { name: 'email-service' }
- * );
- */
-declare function createCircuitBreaker<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CircuitBreakerOptions): CircuitBreaker<T>;
-/**
- * Circuit breaker registry for managing multiple breakers
- */
-declare class CircuitBreakerRegistry {
-  private breakers;
-  /**
-   * Register a circuit breaker
-   */
-  register<T extends (...args: any[]) => Promise<any>>(name: string, fn: T, options?: Omit<CircuitBreakerOptions, "name">): CircuitBreaker<T>;
-  /**
-   * Get a circuit breaker by name
-   */
-  get(name: string): CircuitBreaker<any> | undefined;
-  /**
-   * Get all breakers
-   */
-  getAll(): Map<string, CircuitBreaker<any>>;
-  /**
-   * Get statistics for all breakers
-   */
-  getAllStats(): Record<string, CircuitBreakerStats>;
-  /**
-   * Reset all breakers
-   */
-  resetAll(): void;
-  /**
-   * Open all breakers
-   */
-  openAll(): void;
-  /**
-   * Close all breakers
-   */
-  closeAll(): void;
-}
-/**
- * Create a new CircuitBreakerRegistry instance.
- * Use this instead of a global singleton — attach to fastify.arc or pass explicitly.
- */
-declare function createCircuitBreakerRegistry(): CircuitBreakerRegistry;
-//#endregion
-export { CircuitBreakerStats as a, createCircuitBreakerRegistry as c, CircuitBreakerRegistry as i, CircuitBreakerError as n, CircuitState as o, CircuitBreakerOptions as r, createCircuitBreaker as s, CircuitBreaker as t };

package/dist/circuitBreaker-l18oRgL5.mjs

@@ -1,284 +0,0 @@
-//#region src/utils/circuitBreaker.ts
-/**
-* Circuit Breaker Pattern
-*
-* Wraps external service calls with failure protection.
-* Prevents cascading failures by "opening" the circuit when
-* a service is failing, allowing it time to recover.
-*
-* States:
-* - CLOSED: Normal operation, requests pass through
-* - OPEN: Too many failures, all requests fail fast
-* - HALF_OPEN: Testing if service recovered, limited requests
-*
-* @example
-* import { CircuitBreaker } from '@classytic/arc/utils';
-*
-* const paymentBreaker = new CircuitBreaker(async (amount) => {
-*   return await stripe.charges.create({ amount });
-* }, {
-*   failureThreshold: 5,
-*   resetTimeout: 30000,
-*   timeout: 5000,
-* });
-*
-* try {
-*   const result = await paymentBreaker.call(100);
-* } catch (error) {
-*   // Handle failure or circuit open
-* }
-*/
-const CircuitState = {
-	CLOSED: "CLOSED",
-	OPEN: "OPEN",
-	HALF_OPEN: "HALF_OPEN"
-};
-var CircuitBreakerError = class extends Error {
-	state;
-	constructor(message, state) {
-		super(message);
-		this.name = "CircuitBreakerError";
-		this.state = state;
-	}
-};
-var CircuitBreaker = class {
-	state = CircuitState.CLOSED;
-	failures = 0;
-	successes = 0;
-	totalCalls = 0;
-	nextAttempt = 0;
-	lastCallAt = null;
-	openedAt = null;
-	failureThreshold;
-	resetTimeout;
-	timeout;
-	successThreshold;
-	fallback;
-	onStateChange;
-	onError;
-	name;
-	fn;
-	constructor(fn, options = {}) {
-		this.fn = fn;
-		this.failureThreshold = options.failureThreshold ?? 5;
-		this.resetTimeout = options.resetTimeout ?? 6e4;
-		this.timeout = options.timeout ?? 1e4;
-		this.successThreshold = options.successThreshold ?? 1;
-		this.fallback = options.fallback;
-		this.onStateChange = options.onStateChange;
-		this.onError = options.onError;
-		this.name = options.name ?? "CircuitBreaker";
-	}
-	/**
-	* Call the wrapped function with circuit breaker protection
-	*/
-	async call(...args) {
-		this.totalCalls++;
-		this.lastCallAt = Date.now();
-		if (this.state === CircuitState.OPEN) {
-			if (Date.now() < this.nextAttempt) {
-				const error = new CircuitBreakerError(`Circuit breaker is OPEN for ${this.name}`, CircuitState.OPEN);
-				if (this.fallback) return this.fallback(...args);
-				throw error;
-			}
-			this.setState(CircuitState.HALF_OPEN);
-		}
-		try {
-			const result = await this.executeWithTimeout(args);
-			this.onSuccess();
-			return result;
-		} catch (err) {
-			this.onFailure(err instanceof Error ? err : new Error(String(err)));
-			throw err;
-		}
-	}
-	/**
-	* Execute function with timeout
-	*/
-	async executeWithTimeout(args) {
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				reject(/* @__PURE__ */ new Error(`Request timeout after ${this.timeout}ms`));
-			}, this.timeout);
-			this.fn(...args).then((result) => {
-				clearTimeout(timeoutId);
-				resolve(result);
-			}).catch((error) => {
-				clearTimeout(timeoutId);
-				reject(error);
-			});
-		});
-	}
-	/**
-	* Handle successful call
-	*/
-	onSuccess() {
-		this.failures = 0;
-		this.successes++;
-		if (this.state === CircuitState.HALF_OPEN) {
-			if (this.successes >= this.successThreshold) {
-				this.setState(CircuitState.CLOSED);
-				this.successes = 0;
-			}
-		}
-	}
-	/**
-	* Handle failed call
-	*/
-	onFailure(error) {
-		this.failures++;
-		this.successes = 0;
-		if (this.onError) this.onError(error);
-		if (this.state === CircuitState.HALF_OPEN || this.failures >= this.failureThreshold) {
-			this.setState(CircuitState.OPEN);
-			this.nextAttempt = Date.now() + this.resetTimeout;
-			this.openedAt = Date.now();
-		}
-	}
-	/**
-	* Change circuit state
-	*/
-	setState(newState) {
-		const oldState = this.state;
-		if (oldState !== newState) {
-			this.state = newState;
-			if (this.onStateChange) this.onStateChange(oldState, newState);
-		}
-	}
-	/**
-	* Manually open the circuit
-	*/
-	open() {
-		this.setState(CircuitState.OPEN);
-		this.nextAttempt = Date.now() + this.resetTimeout;
-		this.openedAt = Date.now();
-	}
-	/**
-	* Manually close the circuit
-	*/
-	close() {
-		this.failures = 0;
-		this.successes = 0;
-		this.setState(CircuitState.CLOSED);
-		this.openedAt = null;
-	}
-	/**
-	* Get current statistics
-	*/
-	getStats() {
-		return {
-			name: this.name,
-			state: this.state,
-			failures: this.failures,
-			successes: this.successes,
-			totalCalls: this.totalCalls,
-			openedAt: this.openedAt,
-			lastCallAt: this.lastCallAt
-		};
-	}
-	/**
-	* Get current state
-	*/
-	getState() {
-		return this.state;
-	}
-	/**
-	* Check if circuit is open
-	*/
-	isOpen() {
-		return this.state === CircuitState.OPEN;
-	}
-	/**
-	* Check if circuit is closed
-	*/
-	isClosed() {
-		return this.state === CircuitState.CLOSED;
-	}
-	/**
-	* Reset statistics
-	*/
-	reset() {
-		this.failures = 0;
-		this.successes = 0;
-		this.totalCalls = 0;
-		this.lastCallAt = null;
-		this.openedAt = null;
-		this.setState(CircuitState.CLOSED);
-	}
-};
-/**
-* Create a circuit breaker with sensible defaults
-*
-* @example
-* const emailBreaker = createCircuitBreaker(
-*   async (to, subject, body) => sendEmail(to, subject, body),
-*   { name: 'email-service' }
-* );
-*/
-function createCircuitBreaker(fn, options) {
-	return new CircuitBreaker(fn, options);
-}
-/**
-* Circuit breaker registry for managing multiple breakers
-*/
-var CircuitBreakerRegistry = class {
-	breakers = /* @__PURE__ */ new Map();
-	/**
-	* Register a circuit breaker
-	*/
-	register(name, fn, options) {
-		const breaker = new CircuitBreaker(fn, {
-			...options,
-			name
-		});
-		this.breakers.set(name, breaker);
-		return breaker;
-	}
-	/**
-	* Get a circuit breaker by name
-	*/
-	get(name) {
-		return this.breakers.get(name);
-	}
-	/**
-	* Get all breakers
-	*/
-	getAll() {
-		return this.breakers;
-	}
-	/**
-	* Get statistics for all breakers
-	*/
-	getAllStats() {
-		const stats = {};
-		for (const [name, breaker] of this.breakers.entries()) stats[name] = breaker.getStats();
-		return stats;
-	}
-	/**
-	* Reset all breakers
-	*/
-	resetAll() {
-		for (const breaker of this.breakers.values()) breaker.reset();
-	}
-	/**
-	* Open all breakers
-	*/
-	openAll() {
-		for (const breaker of this.breakers.values()) breaker.open();
-	}
-	/**
-	* Close all breakers
-	*/
-	closeAll() {
-		for (const breaker of this.breakers.values()) breaker.close();
-	}
-};
-/**
-* Create a new CircuitBreakerRegistry instance.
-* Use this instead of a global singleton — attach to fastify.arc or pass explicitly.
-*/
-function createCircuitBreakerRegistry() {
-	return new CircuitBreakerRegistry();
-}
-//#endregion
-export { createCircuitBreaker as a, CircuitState as i, CircuitBreakerError as n, createCircuitBreakerRegistry as o, CircuitBreakerRegistry as r, CircuitBreaker as t };

package/dist/core-DNncu0xF.mjs

@@ -1,34 +0,0 @@
-import { n as defineResource } from "./defineResource-C__jkwvs.mjs";
-//#region src/core/defineResourceVariants.ts
-/**
-* Define multiple resources from a shared base config and per-variant overrides.
-*
-* Each variant is independently passed through `defineResource()` — the
-* returned `ResourceDefinition`s are real, fully-registered resources.
-* Register each one's plugin in your app:
-*
-* ```typescript
-* await app.register(articlePublic.toPlugin());
-* await app.register(articleAdmin.toPlugin());
-* ```
-*
-* @param base    Shared config — adapter, queryParser, schemaOptions, hooks, etc.
-*                Must NOT include `name` or `prefix` (those are per-variant).
-* @param variants  Map of variant key → override. Each variant must declare
-*                  its own `name` and `prefix`. Other fields override the base.
-* @returns A record where each key from `variants` maps to a real
-*          `ResourceDefinition` ready for `.toPlugin()` registration.
-*/
-function defineResourceVariants(base, variants) {
-	const out = {};
-	for (const key of Object.keys(variants)) {
-		const override = variants[key];
-		out[key] = defineResource({
-			...base,
-			...override
-		});
-	}
-	return out;
-}
-//#endregion
-export { defineResourceVariants as t };

package/dist/dynamic/index.d.mts

@@ -1,93 +0,0 @@
-import { Kt as ResourceDefinition, r as DataAdapter } from "../interface-YrWsmKqE.mjs";
-import { t as PermissionCheck } from "../types-DZi1aYhm.mjs";
-
-//#region src/dynamic/ArcDynamicLoader.d.ts
-interface ArcArchitectureSchema {
-  /** Application name */
-  app: string;
-  /** Resources to provision */
-  resources: ArcResourceSchema[];
-}
-/** Field type — maps to JSON Schema / Zod types */
-type ArcFieldType = "string" | "number" | "boolean" | "date" | "object" | "array";
-/** Per-field definition — matches Arc's FieldRuleEntry for MCP compatibility */
-interface ArcFieldSchema {
-  type: ArcFieldType;
-  required?: boolean;
-  description?: string;
-  enum?: string[];
-  min?: number;
-  max?: number;
-  minLength?: number;
-  maxLength?: number;
-  /** System-managed fields (createdAt, updatedAt) — excluded from create/update schemas */
-  systemManaged?: boolean;
-  /** Immutable after creation (e.g. slug, organizationId) */
-  immutable?: boolean;
-}
-/** Permission preset name — matches Arc's built-in presets */
-type ArcPermissionPreset = "publicRead" | "publicReadAdminWrite" | "authenticated" | "adminOnly" | "ownerWithAdminBypass" | "fullPublic" | "readOnly";
-/** Fine-grained per-operation permission */
-interface ArcPermissionMap {
-  list?: "public" | "auth" | "admin";
-  get?: "public" | "auth" | "admin";
-  create?: "auth" | "admin";
-  update?: "auth" | "admin" | "owner";
-  delete?: "auth" | "admin" | "owner";
-}
-interface ArcResourceSchema {
-  /** Resource name (e.g., 'product', 'user') — used for URL prefix and tool names */
-  name: string;
-  /** Display name for docs and MCP descriptions (defaults to capitalized name) */
-  displayName?: string;
-  /** Custom URL prefix (defaults to `/${name}s`) */
-  prefix?: string;
-  /** Adapter resolution key — passed to adapterResolver */
-  adapterPattern?: string;
-  /** Permission preset name or fine-grained per-operation map */
-  permissions: ArcPermissionPreset | ArcPermissionMap;
-  /** Presets to apply (e.g., 'softDelete', 'slugLookup', 'bulk') */
-  presets?: string[];
-  /** Field definitions — drives schemaOptions.fieldRules for validation and MCP tool schemas */
-  fields?: Record<string, ArcFieldSchema | ArcFieldType>;
-  /** Fields allowed for filtering in list operations (drives queryParser + MCP) */
-  filterable?: string[];
-  /** Fields allowed for sorting (drives queryParser + MCP) */
-  sortable?: string[];
-  /** CRUD operations to disable (e.g., ['delete'] for append-only resources) */
-  disabledRoutes?: string[];
-  /** Tenant field name for multi-tenant resources */
-  tenantField?: string;
-}
-interface DynamicLoaderContext {
-  /** Resolve a data adapter for a resource — receives name and optional pattern key */
-  adapterResolver: (resourceName: string, pattern?: string) => DataAdapter;
-  /** Resolve custom permission checks beyond built-in presets */
-  permissionResolver?: (policy: string) => PermissionCheck;
-}
-/**
- * Load an Arc Architecture Schema (JSON) and produce fully configured ResourceDefinitions.
- *
- * Each resource gets:
- * - Adapter from the resolver
- * - Permissions from presets or fine-grained map
- * - schemaOptions.fieldRules for validation and MCP tool schemas
- * - ArcQueryParser with allowedFilterFields/allowedSortFields for MCP auto-derive
- * - Presets applied
- */
-declare class ArcDynamicLoader {
-  private context;
-  constructor(context: DynamicLoaderContext);
-  /**
-   * Load an AAS definition and return fully constructed ResourceDefinitions.
-   * Validates the schema before processing — throws on malformed input.
-   */
-  load(schema: ArcArchitectureSchema): ResourceDefinition<unknown>[];
-  private buildFieldRules;
-  private buildQueryParser;
-  private resolvePermissions;
-  private resolvePreset;
-  private resolveFinGrained;
-}
-//#endregion
-export { ArcArchitectureSchema, ArcDynamicLoader, ArcFieldSchema, ArcFieldType, ArcPermissionMap, ArcPermissionPreset, ArcResourceSchema, DynamicLoaderContext };