@classytic/arc 1.1.0 → 2.1.3

package/dist/HookSystem-BsGV-j2l.mjs

@@ -0,0 +1,404 @@
+//#region src/hooks/HookSystem.ts
+var HookSystem = class {
+	hooks;
+	logger;
+	warn;
+	constructor(options) {
+		this.hooks = /* @__PURE__ */ new Map();
+		this.logger = options?.logger ?? { error: (...args) => console.error(...args) };
+		this.warn = options?.logger?.warn ?? ((...args) => console.warn(...args));
+	}
+	/**
+	* Generate hook key
+	*/
+	getKey(resource, operation, phase) {
+		return `${resource}:${operation}:${phase}`;
+	}
+	/**
+	* Register a hook
+	* Supports both object parameter and positional arguments
+	*/
+	register(resourceOrOptions, operation, phase, handler, priority = 10) {
+		let hookName;
+		let resource;
+		let finalOperation;
+		let finalPhase;
+		let finalHandler;
+		let finalPriority;
+		let dependsOn;
+		if (typeof resourceOrOptions === "object") {
+			hookName = resourceOrOptions.name;
+			resource = resourceOrOptions.resource;
+			finalOperation = resourceOrOptions.operation;
+			finalPhase = resourceOrOptions.phase;
+			finalHandler = resourceOrOptions.handler;
+			finalPriority = resourceOrOptions.priority ?? 10;
+			dependsOn = resourceOrOptions.dependsOn;
+		} else {
+			resource = resourceOrOptions;
+			finalOperation = operation;
+			finalPhase = phase;
+			finalHandler = handler;
+			finalPriority = priority;
+		}
+		const key = this.getKey(resource, finalOperation, finalPhase);
+		if (!this.hooks.has(key)) this.hooks.set(key, []);
+		const registration = {
+			name: hookName,
+			resource,
+			operation: finalOperation,
+			phase: finalPhase,
+			handler: finalHandler,
+			priority: finalPriority,
+			dependsOn
+		};
+		const hooks = this.hooks.get(key);
+		hooks.push(registration);
+		hooks.sort((a, b) => a.priority - b.priority);
+		return () => {
+			const idx = hooks.indexOf(registration);
+			if (idx !== -1) hooks.splice(idx, 1);
+		};
+	}
+	/**
+	* Register before hook
+	*/
+	before(resource, operation, handler, priority = 10) {
+		return this.register(resource, operation, "before", handler, priority);
+	}
+	/**
+	* Register after hook
+	*/
+	after(resource, operation, handler, priority = 10) {
+		return this.register(resource, operation, "after", handler, priority);
+	}
+	/**
+	* Register around hook — wraps the core operation.
+	* Call `next()` inside the handler to proceed.
+	*/
+	around(resource, operation, handler, priority = 10) {
+		return this.register(resource, operation, "around", handler, priority);
+	}
+	/**
+	* Execute around hooks as a nested middleware chain.
+	* Each around hook receives `next()` to call the next hook or the core operation.
+	*/
+	async executeAround(resource, operation, data, execute, options) {
+		const key = this.getKey(resource, operation, "around");
+		const hooks = [...this.hooks.get(key) ?? []];
+		const wildcardKey = this.getKey("*", operation, "around");
+		const allHooks = [...this.hooks.get(wildcardKey) ?? [], ...hooks];
+		allHooks.sort((a, b) => a.priority - b.priority);
+		if (allHooks.length === 0) return execute();
+		let index = 0;
+		const next = async () => {
+			if (index < allHooks.length) {
+				const hook = allHooks[index++];
+				const ctx = {
+					resource,
+					operation,
+					phase: "around",
+					data,
+					user: options?.user,
+					context: options?.context,
+					meta: options?.meta
+				};
+				return hook.handler(ctx, next);
+			}
+			return execute();
+		};
+		return next();
+	}
+	/**
+	* Execute hooks for a given context
+	*/
+	async execute(ctx) {
+		const key = this.getKey(ctx.resource, ctx.operation, ctx.phase);
+		const hooks = this.hooks.get(key) ?? [];
+		const wildcardKey = this.getKey("*", ctx.operation, ctx.phase);
+		let allHooks = [...this.hooks.get(wildcardKey) ?? [], ...hooks];
+		allHooks.sort((a, b) => a.priority - b.priority);
+		if (allHooks.some((h) => h.dependsOn?.length)) allHooks = this.topologicalSort(allHooks);
+		let result = ctx.data;
+		for (const hook of allHooks) {
+			const handlerContext = {
+				resource: ctx.resource,
+				operation: ctx.operation,
+				phase: ctx.phase,
+				data: result,
+				result: ctx.result,
+				user: ctx.user,
+				context: ctx.context,
+				meta: ctx.meta
+			};
+			const hookResult = await hook.handler(handlerContext);
+			if (hookResult !== void 0 && hookResult !== null) result = hookResult;
+		}
+		return result;
+	}
+	/**
+	* Execute before hooks
+	*/
+	async executeBefore(resource, operation, data, options) {
+		return await this.execute({
+			resource,
+			operation,
+			phase: "before",
+			data,
+			user: options?.user,
+			context: options?.context,
+			meta: options?.meta
+		}) ?? data;
+	}
+	/**
+	* Execute after hooks
+	* Errors in after hooks are logged but don't fail the request
+	*/
+	async executeAfter(resource, operation, result, options) {
+		try {
+			await this.execute({
+				resource,
+				operation,
+				phase: "after",
+				result,
+				user: options?.user,
+				context: options?.context,
+				meta: options?.meta
+			});
+		} catch (error) {
+			this.logger.error(`[HookSystem] Error in after hook for ${resource}:${operation}:`, error);
+		}
+	}
+	/**
+	* Topological sort with Kahn's algorithm.
+	* Hooks with `dependsOn` are ordered after their dependencies.
+	* Within the same dependency level, priority ordering is preserved.
+	* Hooks without names or dependencies pass through in their original order.
+	*/
+	topologicalSort(hooks) {
+		const byName = /* @__PURE__ */ new Map();
+		const inDegree = /* @__PURE__ */ new Map();
+		const dependents = /* @__PURE__ */ new Map();
+		for (const hook of hooks) {
+			inDegree.set(hook, 0);
+			if (hook.name) byName.set(hook.name, hook);
+		}
+		for (const hook of hooks) if (hook.dependsOn) {
+			let resolvedDeps = 0;
+			for (const dep of hook.dependsOn) if (byName.has(dep)) {
+				resolvedDeps++;
+				if (!dependents.has(dep)) dependents.set(dep, []);
+				dependents.get(dep).push(hook);
+			} else this.warn(`[HookSystem] Hook '${hook.name ?? "<unnamed>"}' depends on '${dep}' which is not registered in the same phase/resource. Dependency will be ignored.`);
+			inDegree.set(hook, resolvedDeps);
+		}
+		const queue = [];
+		const result = [];
+		for (const hook of hooks) if (inDegree.get(hook) === 0) queue.push(hook);
+		queue.sort((a, b) => a.priority - b.priority);
+		while (queue.length > 0) {
+			const current = queue.shift();
+			result.push(current);
+			if (current.name && dependents.has(current.name)) {
+				const deps = dependents.get(current.name);
+				for (const dep of deps) {
+					const newDegree = inDegree.get(dep) - 1;
+					inDegree.set(dep, newDegree);
+					if (newDegree === 0) {
+						const insertIdx = queue.findIndex((q) => q.priority > dep.priority);
+						if (insertIdx === -1) queue.push(dep);
+						else queue.splice(insertIdx, 0, dep);
+					}
+				}
+			}
+		}
+		if (result.length < hooks.length) {
+			const missing = hooks.filter((h) => !result.includes(h));
+			const names = missing.map((h) => h.name ?? "<unnamed>").join(", ");
+			this.logger.error(`[HookSystem] Circular dependency detected in hooks: ${names}. These hooks will be appended in priority order.`);
+			missing.sort((a, b) => a.priority - b.priority);
+			result.push(...missing);
+		}
+		return result;
+	}
+	/**
+	* Get all registered hooks
+	*/
+	getAll() {
+		const all = [];
+		for (const hooks of this.hooks.values()) all.push(...hooks);
+		return all;
+	}
+	/**
+	* Get hooks for a specific resource
+	*/
+	getForResource(resource) {
+		const all = [];
+		for (const [key, hooks] of this.hooks.entries()) if (key.startsWith(`${resource}:`)) all.push(...hooks);
+		return all;
+	}
+	/**
+	* Get hooks matching filter criteria.
+	* Useful for debugging and testing specific hook combinations.
+	*
+	* @example
+	* ```typescript
+	* // Find all before-create hooks for products (including wildcards)
+	* const hooks = hookSystem.getRegistered({
+	*   resource: 'product',
+	*   operation: 'create',
+	*   phase: 'before',
+	* });
+	* ```
+	*/
+	getRegistered(filter) {
+		let results = this.getAll();
+		if (filter?.resource) results = results.filter((h) => h.resource === filter.resource || h.resource === "*");
+		if (filter?.operation) results = results.filter((h) => h.operation === filter.operation);
+		if (filter?.phase) results = results.filter((h) => h.phase === filter.phase);
+		return results;
+	}
+	/**
+	* Get a structured summary of all registered hooks for debugging.
+	*
+	* @example
+	* ```typescript
+	* const info = hookSystem.inspect();
+	* // { total: 12, resources: { product: [...], '*': [...] }, summary: [...] }
+	* ```
+	*/
+	inspect() {
+		const all = this.getAll();
+		const byResource = /* @__PURE__ */ new Map();
+		for (const hook of all) {
+			const arr = byResource.get(hook.resource) ?? [];
+			arr.push(hook);
+			byResource.set(hook.resource, arr);
+		}
+		return {
+			total: all.length,
+			resources: Object.fromEntries(byResource),
+			summary: all.map((h) => ({
+				name: h.name,
+				key: `${h.resource}:${h.operation}:${h.phase}`,
+				priority: h.priority,
+				...h.dependsOn?.length ? { dependsOn: h.dependsOn } : {}
+			}))
+		};
+	}
+	/**
+	* Check if any hooks exist for a specific resource/operation/phase combination.
+	*/
+	has(resource, operation, phase) {
+		const key = this.getKey(resource, operation, phase);
+		return (this.hooks.get(key)?.length ?? 0) > 0;
+	}
+	/**
+	* Clear all hooks
+	*/
+	clear() {
+		this.hooks.clear();
+	}
+	/**
+	* Clear hooks for a specific resource
+	*/
+	clearResource(resource) {
+		for (const key of this.hooks.keys()) if (key.startsWith(`${resource}:`)) this.hooks.delete(key);
+	}
+};
+/**
+* Create a new isolated HookSystem instance
+*
+* Use this for:
+* - Test isolation (parallel test suites)
+* - Multiple app instances with independent hooks
+*
+* @example
+* const hooks = createHookSystem();
+* await app.register(arcCorePlugin, { hookSystem: hooks });
+*
+* @example With custom logger
+* const hooks = createHookSystem({ logger: fastify.log });
+*/
+function createHookSystem(options) {
+	return new HookSystem(options);
+}
+/**
+* Define a named hook with optional dependencies.
+* Returns a registration object — call `register(hookSystem)` to activate.
+*
+* @example
+* ```typescript
+* const generateSlug = defineHook({
+*   name: 'generateSlug',
+*   resource: 'product', operation: 'create', phase: 'before',
+*   handler: (ctx) => ({ ...ctx.data, slug: slugify(ctx.data.name) }),
+* });
+*
+* const validateUniqueSlug = defineHook({
+*   name: 'validateUniqueSlug',
+*   resource: 'product', operation: 'create', phase: 'before',
+*   dependsOn: ['generateSlug'],
+*   handler: async (ctx) => { // check uniqueness },
+* });
+*
+* // Register on a hook system
+* generateSlug.register(hooks);
+* validateUniqueSlug.register(hooks);
+* ```
+*/
+function defineHook(options) {
+	return {
+		...options,
+		register(hooks) {
+			return hooks.register({
+				name: options.name,
+				resource: options.resource,
+				operation: options.operation,
+				phase: options.phase,
+				handler: options.handler,
+				priority: options.priority,
+				dependsOn: options.dependsOn
+			});
+		}
+	};
+}
+/**
+* Create a before-create hook registration for a given hook system
+*/
+function beforeCreate(hooks, resource, handler, priority = 10) {
+	return hooks.before(resource, "create", handler, priority);
+}
+/**
+* Create an after-create hook registration for a given hook system
+*/
+function afterCreate(hooks, resource, handler, priority = 10) {
+	return hooks.after(resource, "create", handler, priority);
+}
+/**
+* Create a before-update hook registration for a given hook system
+*/
+function beforeUpdate(hooks, resource, handler, priority = 10) {
+	return hooks.before(resource, "update", handler, priority);
+}
+/**
+* Create an after-update hook registration for a given hook system
+*/
+function afterUpdate(hooks, resource, handler, priority = 10) {
+	return hooks.after(resource, "update", handler, priority);
+}
+/**
+* Create a before-delete hook registration for a given hook system
+*/
+function beforeDelete(hooks, resource, handler, priority = 10) {
+	return hooks.before(resource, "delete", handler, priority);
+}
+/**
+* Create an after-delete hook registration for a given hook system
+*/
+function afterDelete(hooks, resource, handler, priority = 10) {
+	return hooks.after(resource, "delete", handler, priority);
+}
+
+//#endregion
+export { beforeCreate as a, createHookSystem as c, afterUpdate as i, defineHook as l, afterCreate as n, beforeDelete as o, afterDelete as r, beforeUpdate as s, HookSystem as t };

package/dist/ResourceRegistry-7Ic20ZMw.mjs

@@ -0,0 +1,249 @@
+import { s as DEFAULT_UPDATE_METHOD, t as CRUD_OPERATIONS } from "./constants-DdXFXQtN.mjs";
+
+//#region src/registry/ResourceRegistry.ts
+var ResourceRegistry = class {
+	_resources;
+	_frozen;
+	constructor() {
+		this._resources = /* @__PURE__ */ new Map();
+		this._frozen = false;
+	}
+	/**
+	* Register a resource
+	*/
+	register(resource, options = {}) {
+		if (this._frozen) throw new Error(`Registry frozen. Cannot register '${resource.name}' after startup.`);
+		if (this._resources.has(resource.name)) throw new Error(`Resource '${resource.name}' already registered.`);
+		const entry = {
+			name: resource.name,
+			displayName: resource.displayName,
+			tag: resource.tag,
+			prefix: resource.prefix,
+			module: options.module ?? void 0,
+			adapter: resource.adapter ? {
+				type: resource.adapter.type,
+				name: resource.adapter.name
+			} : null,
+			permissions: resource.permissions,
+			presets: resource._appliedPresets ?? [],
+			routes: [],
+			additionalRoutes: resource.additionalRoutes.map((r) => ({
+				method: r.method,
+				path: r.path,
+				handler: typeof r.handler === "string" ? r.handler : r.handler.name || "anonymous",
+				operation: r.operation,
+				summary: r.summary,
+				description: r.description,
+				permissions: r.permissions,
+				wrapHandler: r.wrapHandler,
+				schema: r.schema
+			})),
+			events: Object.keys(resource.events ?? {}),
+			registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+			disableDefaultRoutes: resource.disableDefaultRoutes,
+			updateMethod: resource.updateMethod,
+			disabledRoutes: resource.disabledRoutes,
+			openApiSchemas: options.openApiSchemas,
+			fieldPermissions: extractFieldPermissions(resource.fields),
+			pipelineSteps: extractPipelineSteps(resource.pipe),
+			rateLimit: resource.rateLimit,
+			plugin: resource.toPlugin()
+		};
+		this._resources.set(resource.name, entry);
+		return this;
+	}
+	/**
+	* Get resource by name
+	*/
+	get(name) {
+		return this._resources.get(name);
+	}
+	/**
+	* Get all resources
+	*/
+	getAll() {
+		return Array.from(this._resources.values());
+	}
+	/**
+	* Get resources by module
+	*/
+	getByModule(moduleName) {
+		return this.getAll().filter((r) => r.module === moduleName);
+	}
+	/**
+	* Get resources by preset
+	*/
+	getByPreset(presetName) {
+		return this.getAll().filter((r) => r.presets.includes(presetName));
+	}
+	/**
+	* Check if resource exists
+	*/
+	has(name) {
+		return this._resources.has(name);
+	}
+	/**
+	* Get registry statistics
+	*/
+	getStats() {
+		const resources = this.getAll();
+		const presetCounts = {};
+		for (const r of resources) for (const preset of r.presets) presetCounts[preset] = (presetCounts[preset] ?? 0) + 1;
+		return {
+			totalResources: resources.length,
+			byModule: this._groupBy(resources, "module"),
+			presetUsage: presetCounts,
+			totalRoutes: resources.reduce((sum, r) => {
+				if (r.disableDefaultRoutes) return sum + (r.additionalRoutes?.length ?? 0);
+				const disabledSet = new Set(r.disabledRoutes ?? []);
+				let defaultCount = CRUD_OPERATIONS.filter((route) => !disabledSet.has(route)).length;
+				if (!disabledSet.has("update") && r.updateMethod === "both") defaultCount += 1;
+				return sum + defaultCount + (r.additionalRoutes?.length ?? 0);
+			}, 0),
+			totalEvents: resources.reduce((sum, r) => sum + (r.events?.length ?? 0), 0)
+		};
+	}
+	/**
+	* Get full introspection data
+	*/
+	getIntrospection() {
+		return {
+			resources: this.getAll().map((r) => {
+				const disabledSet = new Set(r.disabledRoutes ?? []);
+				const updateMethod = r.updateMethod ?? DEFAULT_UPDATE_METHOD;
+				const defaultRoutes = r.disableDefaultRoutes ? [] : [
+					...!disabledSet.has("list") ? [{
+						method: "GET",
+						path: r.prefix,
+						operation: "list"
+					}] : [],
+					...!disabledSet.has("get") ? [{
+						method: "GET",
+						path: `${r.prefix}/:id`,
+						operation: "get"
+					}] : [],
+					...!disabledSet.has("create") ? [{
+						method: "POST",
+						path: r.prefix,
+						operation: "create"
+					}] : [],
+					...!disabledSet.has("update") ? updateMethod === "both" ? [{
+						method: "PUT",
+						path: `${r.prefix}/:id`,
+						operation: "update"
+					}, {
+						method: "PATCH",
+						path: `${r.prefix}/:id`,
+						operation: "update"
+					}] : [{
+						method: updateMethod,
+						path: `${r.prefix}/:id`,
+						operation: "update"
+					}] : [],
+					...!disabledSet.has("delete") ? [{
+						method: "DELETE",
+						path: `${r.prefix}/:id`,
+						operation: "delete"
+					}] : []
+				];
+				return {
+					name: r.name,
+					displayName: r.displayName,
+					prefix: r.prefix,
+					module: r.module,
+					presets: r.presets,
+					permissions: r.permissions,
+					routes: [...defaultRoutes, ...r.additionalRoutes?.map((ar) => ({
+						method: ar.method,
+						path: `${r.prefix}${ar.path}`,
+						operation: ar.operation ?? (typeof ar.handler === "string" ? ar.handler : "custom"),
+						handler: typeof ar.handler === "string" ? ar.handler : void 0,
+						summary: ar.summary
+					})) ?? []],
+					events: r.events
+				};
+			}),
+			stats: this.getStats(),
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	/**
+	* Freeze registry (prevent further registrations)
+	*/
+	freeze() {
+		this._frozen = true;
+	}
+	/**
+	* Check if frozen
+	*/
+	isFrozen() {
+		return this._frozen;
+	}
+	/**
+	* Unfreeze registry (allow new registrations)
+	*/
+	unfreeze() {
+		this._frozen = false;
+	}
+	/**
+	* Reset registry — clear all resources and unfreeze
+	*/
+	reset() {
+		this._resources.clear();
+		this._frozen = false;
+	}
+	/** @internal Alias for unfreeze() */
+	_unfreeze() {
+		this.unfreeze();
+	}
+	/** @internal Alias for reset() */
+	_clear() {
+		this.reset();
+	}
+	/**
+	* Group by key
+	*/
+	_groupBy(arr, key) {
+		const result = {};
+		for (const item of arr) {
+			const k = String(item[key] ?? "uncategorized");
+			result[k] = (result[k] ?? 0) + 1;
+		}
+		return result;
+	}
+};
+function extractFieldPermissions(fields) {
+	if (!fields || Object.keys(fields).length === 0) return void 0;
+	const result = {};
+	for (const [field, perm] of Object.entries(fields)) {
+		const entry = { type: perm._type };
+		if (perm.roles?.length) entry.roles = perm.roles;
+		if (perm.redactValue !== void 0) entry.redactValue = perm.redactValue;
+		result[field] = entry;
+	}
+	return result;
+}
+function extractPipelineSteps(pipe) {
+	if (!pipe) return void 0;
+	const steps = [];
+	if (Array.isArray(pipe)) steps.push(...pipe);
+	else {
+		const seen = /* @__PURE__ */ new Set();
+		for (const opSteps of Object.values(pipe)) if (Array.isArray(opSteps)) for (const step of opSteps) {
+			const key = `${step._type}:${step.name}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				steps.push(step);
+			}
+		}
+	}
+	if (steps.length === 0) return void 0;
+	return steps.map((s) => ({
+		type: s._type,
+		name: s.name,
+		operations: s.operations ? [...s.operations] : void 0
+	}));
+}
+
+//#endregion
+export { ResourceRegistry as t };

package/dist/adapters/index.d.mts

@@ -0,0 +1,5 @@
+import "../elevation-DGo5shaX.mjs";
+import { a as RepositoryLike, i as RelationMetadata, n as DataAdapter, o as SchemaMetadata, r as FieldMetadata, s as ValidationResult, t as AdapterFactory } from "../interface-e9XfSsUV.mjs";
+import "../types-RLkFVgaw.mjs";
+import { a as PrismaQueryParserOptions, c as MongooseAdapterOptions, i as PrismaQueryParser, l as createMongooseAdapter, n as PrismaAdapterOptions, o as createPrismaAdapter, r as PrismaQueryOptions, s as MongooseAdapter, t as PrismaAdapter } from "../prisma-C3iornoK.mjs";
+export { type AdapterFactory, type DataAdapter, type FieldMetadata, MongooseAdapter, type MongooseAdapterOptions, PrismaAdapter, type PrismaAdapterOptions, type PrismaQueryOptions, PrismaQueryParser, type PrismaQueryParserOptions, type RelationMetadata, type RepositoryLike, type SchemaMetadata, type ValidationResult, createMongooseAdapter, createPrismaAdapter };

package/dist/adapters/index.mjs

@@ -0,0 +1,3 @@
+import { a as createMongooseAdapter, i as MongooseAdapter, n as PrismaQueryParser, r as createPrismaAdapter, t as PrismaAdapter } from "../prisma-DJbMt3yf.mjs";
+
+export { MongooseAdapter, PrismaAdapter, PrismaQueryParser, createMongooseAdapter, createPrismaAdapter };