@classytic/arc 2.9.1 → 2.10.8

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 };

package/dist/dynamic/index.mjs

@@ -1,122 +0,0 @@
-import { t as ArcQueryParser } from "../queryParser-Cs-6SHQK.mjs";
-import { n as defineResource } from "../defineResource-C__jkwvs.mjs";
-import { C as publicRead, T as readOnly, b as fullPublic, v as adminOnly, w as publicReadAdminWrite, x as ownerWithAdminBypass, y as authenticated } from "../permissions-oNZawnkR.mjs";
-//#region src/dynamic/ArcDynamicLoader.ts
-const VALID_FIELD_TYPES = new Set([
-	"string",
-	"number",
-	"boolean",
-	"date",
-	"object",
-	"array"
-]);
-function validateSchema(schema) {
-	if (!schema.app || typeof schema.app !== "string") throw new Error("AAS: 'app' name is required");
-	if (!Array.isArray(schema.resources) || schema.resources.length === 0) throw new Error("AAS: 'resources' must be a non-empty array");
-	for (const r of schema.resources) {
-		if (!r.name || typeof r.name !== "string") throw new Error("AAS: each resource must have a 'name' string");
-		if (!r.permissions) throw new Error(`AAS: resource "${r.name}" must have 'permissions'`);
-		if (r.fields) for (const [fieldName, fieldDef] of Object.entries(r.fields)) {
-			const type = typeof fieldDef === "string" ? fieldDef : fieldDef.type;
-			if (!VALID_FIELD_TYPES.has(type)) throw new Error(`AAS: resource "${r.name}" field "${fieldName}" has invalid type "${type}". Valid types: ${[...VALID_FIELD_TYPES].join(", ")}`);
-		}
-	}
-}
-/**
-* 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
-*/
-var ArcDynamicLoader = class {
-	context;
-	constructor(context) {
-		this.context = context;
-	}
-	/**
-	* Load an AAS definition and return fully constructed ResourceDefinitions.
-	* Validates the schema before processing — throws on malformed input.
-	*/
-	load(schema) {
-		validateSchema(schema);
-		return schema.resources.map((r) => {
-			const adapter = this.context.adapterResolver(r.name, r.adapterPattern);
-			const fieldRules = this.buildFieldRules(r.fields);
-			const queryParser = this.buildQueryParser(r);
-			return defineResource({
-				name: r.name,
-				displayName: r.displayName,
-				prefix: r.prefix,
-				adapter,
-				queryParser,
-				presets: r.presets,
-				permissions: this.resolvePermissions(r.permissions),
-				disabledRoutes: r.disabledRoutes,
-				tenantField: r.tenantField,
-				schemaOptions: fieldRules ? {
-					fieldRules,
-					filterableFields: r.filterable
-				} : void 0
-			});
-		});
-	}
-	buildFieldRules(fields) {
-		if (!fields) return void 0;
-		const rules = {};
-		for (const [name, def] of Object.entries(fields)) rules[name] = typeof def === "string" ? { type: def } : def;
-		return rules;
-	}
-	buildQueryParser(r) {
-		if (!r.filterable && !r.sortable) return void 0;
-		return new ArcQueryParser({
-			allowedFilterFields: r.filterable,
-			allowedSortFields: r.sortable
-		});
-	}
-	resolvePermissions(policy) {
-		if (typeof policy === "string") return this.resolvePreset(policy);
-		return this.resolveFinGrained(policy);
-	}
-	resolvePreset(preset) {
-		switch (preset) {
-			case "publicRead": return publicRead();
-			case "publicReadAdminWrite": return publicReadAdminWrite();
-			case "authenticated": return authenticated();
-			case "adminOnly": return adminOnly();
-			case "ownerWithAdminBypass": return ownerWithAdminBypass();
-			case "fullPublic": return fullPublic();
-			case "readOnly": return readOnly();
-			default:
-				if (this.context.permissionResolver) {
-					const resolved = this.context.permissionResolver(preset);
-					if (resolved) return resolved;
-				}
-				throw new Error(`Unknown permission preset: "${preset}"`);
-		}
-	}
-	resolveFinGrained(policy) {
-		const pick = (preset, op) => preset[op] ?? authenticated()[op];
-		const map = {
-			public: (op) => pick(publicRead(), op),
-			auth: (op) => pick(authenticated(), op),
-			admin: (op) => pick(adminOnly(), op),
-			owner: (op) => pick(ownerWithAdminBypass(), op)
-		};
-		const permissions = {};
-		const ops = {
-			list: policy.list,
-			get: policy.get,
-			create: policy.create,
-			update: policy.update,
-			delete: policy.delete
-		};
-		for (const [op, level] of Object.entries(ops)) if (level && map[level]) permissions[op] = map[level](op);
-		return permissions;
-	}
-};
-//#endregion
-export { ArcDynamicLoader };