@classytic/arc 2.2.5 → 2.4.1

package/dist/presets-C9QXJV1u.mjs

@@ -0,0 +1,422 @@
+import { n as PUBLIC_SCOPE, u as isElevated } from "./types-C6TQjtdi.mjs";
+import multiTenantPreset from "./presets/multiTenant.mjs";
+import { d as requireRoles, n as allowPublic, s as requireAuth } from "./permissions-CA5zg0yK.mjs";
+//#region src/presets/ownedByUser.ts
+/**
+* Create ownership check middleware.
+* Elevated scope (platform admin) bypasses ownership checks.
+*/
+function createOwnershipCheck(ownerField) {
+	return async (request, _reply) => {
+		const user = request.user;
+		if (!user) return;
+		if (isElevated(request.scope ?? PUBLIC_SCOPE)) return;
+		const userWithId = user;
+		const userId = userWithId._id ?? userWithId.id;
+		if (userId) request._ownershipCheck = {
+			field: ownerField,
+			userId
+		};
+	};
+}
+function ownedByUserPreset(options = {}) {
+	const { ownerField = "userId" } = options;
+	const ownershipMiddleware = createOwnershipCheck(ownerField);
+	return {
+		name: "ownedByUser",
+		middlewares: {
+			update: [ownershipMiddleware],
+			delete: [ownershipMiddleware]
+		}
+	};
+}
+//#endregion
+//#region src/presets/slugLookup.ts
+/**
+* Slug Lookup Preset
+*
+* Adds a route to get resource by slug.
+*/
+function slugLookupPreset(options = {}) {
+	const { slugField = "slug" } = options;
+	return {
+		name: "slugLookup",
+		additionalRoutes: (permissions) => [{
+			method: "GET",
+			path: `/slug/:${slugField}`,
+			handler: "getBySlug",
+			summary: "Get by slug",
+			permissions: permissions.get ?? allowPublic(),
+			wrapHandler: true,
+			operation: "getBySlug"
+		}],
+		controllerOptions: { slugField }
+	};
+}
+//#endregion
+//#region src/presets/softDelete.ts
+/**
+* Soft Delete Preset
+*
+* Adds routes for listing deleted items and restoring them.
+* The actual soft-delete behavior (deletedAt field, query filtering)
+* is handled by the repository/adapter layer (e.g., MongoKit's softDelete plugin).
+*/
+function softDeletePreset() {
+	return {
+		name: "softDelete",
+		additionalRoutes: (permissions) => [{
+			method: "GET",
+			path: "/deleted",
+			handler: "getDeleted",
+			summary: "Get soft-deleted items",
+			permissions: permissions.list ?? requireRoles(["admin"]),
+			wrapHandler: true,
+			operation: "listDeleted"
+		}, {
+			method: "POST",
+			path: "/:id/restore",
+			handler: "restore",
+			summary: "Restore soft-deleted item",
+			permissions: permissions.update ?? requireRoles(["admin"]),
+			wrapHandler: true,
+			operation: "restore"
+		}]
+	};
+}
+//#endregion
+//#region src/presets/audited.ts
+/**
+* Audited preset - adds createdBy/updatedBy tracking
+*/
+function auditedPreset(options = {}) {
+	const { createdByField = "createdBy", updatedByField = "updatedBy" } = options;
+	const injectCreatedBy = async (request, _reply) => {
+		const userWithId = request.user;
+		if (userWithId?._id || userWithId?.id) {
+			const userId = userWithId._id ?? userWithId.id;
+			request.body[createdByField] = userId;
+			request.body[updatedByField] = userId;
+		}
+	};
+	const injectUpdatedBy = async (request, _reply) => {
+		const userWithId = request.user;
+		if (userWithId?._id || userWithId?.id) request.body[updatedByField] = userWithId._id ?? userWithId.id;
+	};
+	return {
+		name: "audited",
+		schemaOptions: { fieldRules: {
+			[createdByField]: { systemManaged: true },
+			[updatedByField]: { systemManaged: true },
+			createdAt: { systemManaged: true },
+			updatedAt: { systemManaged: true }
+		} },
+		middlewares: {
+			create: [injectCreatedBy],
+			update: [injectUpdatedBy]
+		}
+	};
+}
+//#endregion
+//#region src/presets/bulk.ts
+/**
+* Bulk Operations Preset
+*
+* Adds bulk CRUD routes to a resource:
+* - POST   /{resource}/bulk   → bulkCreate
+* - PATCH  /{resource}/bulk   → bulkUpdate
+* - DELETE /{resource}/bulk   → bulkDelete
+*
+* Permissions inherit from the resource's create/update/delete permissions.
+* Handlers delegate to BaseController.bulkCreate/bulkUpdate/bulkDelete,
+* which call the repository's createMany/updateMany/deleteMany.
+*
+* DB-agnostic — works with any repository that provides these methods.
+* MongoKit provides them via batchOperationsPlugin.
+*
+* @example
+* ```typescript
+* defineResource({
+*   name: 'product',
+*   adapter: createMongooseAdapter({ model, repository }),
+*   presets: ['bulk'],
+* });
+* // Adds: POST /products/bulk, PATCH /products/bulk, DELETE /products/bulk
+* ```
+*/
+function bulkPreset(opts) {
+	const operations = opts?.operations ?? [
+		"createMany",
+		"updateMany",
+		"deleteMany"
+	];
+	const maxCreateItems = opts?.maxCreateItems ?? 1e3;
+	return {
+		name: "bulk",
+		additionalRoutes: (permissions) => {
+			const routes = [];
+			if (operations.includes("createMany")) routes.push({
+				method: "POST",
+				path: "/bulk",
+				handler: "bulkCreate",
+				wrapHandler: true,
+				operation: "bulkCreate",
+				summary: "Create multiple items",
+				permissions: permissions.create ?? requireAuth(),
+				schema: {
+					body: {
+						type: "object",
+						properties: { items: {
+							type: "array",
+							maxItems: maxCreateItems,
+							minItems: 1
+						} },
+						required: ["items"]
+					},
+					response: { 201: {
+						type: "object",
+						properties: {
+							success: { type: "boolean" },
+							data: { type: "array" },
+							meta: {
+								type: "object",
+								properties: { count: { type: "number" } }
+							}
+						}
+					} }
+				}
+			});
+			if (operations.includes("updateMany")) routes.push({
+				method: "PATCH",
+				path: "/bulk",
+				handler: "bulkUpdate",
+				wrapHandler: true,
+				operation: "bulkUpdate",
+				summary: "Update multiple items matching filter",
+				permissions: permissions.update ?? requireAuth(),
+				schema: {
+					body: {
+						type: "object",
+						properties: {
+							filter: { type: "object" },
+							data: { type: "object" }
+						},
+						required: ["filter", "data"]
+					},
+					response: { 200: {
+						type: "object",
+						properties: {
+							success: { type: "boolean" },
+							data: {
+								type: "object",
+								properties: {
+									matchedCount: { type: "number" },
+									modifiedCount: { type: "number" }
+								}
+							}
+						}
+					} }
+				}
+			});
+			if (operations.includes("deleteMany")) routes.push({
+				method: "DELETE",
+				path: "/bulk",
+				handler: "bulkDelete",
+				wrapHandler: true,
+				operation: "bulkDelete",
+				summary: "Delete multiple items matching filter",
+				permissions: permissions.delete ?? requireAuth(),
+				schema: {
+					body: {
+						type: "object",
+						properties: { filter: { type: "object" } },
+						required: ["filter"]
+					},
+					response: { 200: {
+						type: "object",
+						properties: {
+							success: { type: "boolean" },
+							data: {
+								type: "object",
+								properties: { deletedCount: { type: "number" } }
+							}
+						}
+					} }
+				}
+			});
+			return routes;
+		}
+	};
+}
+//#endregion
+//#region src/presets/tree.ts
+/**
+* Tree Preset
+*
+* Adds routes for hierarchical tree structures.
+*/
+function treePreset(options = {}) {
+	const { parentField = "parent" } = options;
+	return {
+		name: "tree",
+		additionalRoutes: (permissions) => [{
+			method: "GET",
+			path: "/tree",
+			handler: "getTree",
+			summary: "Get hierarchical tree",
+			permissions: permissions.list ?? allowPublic(),
+			wrapHandler: true,
+			operation: "getTree"
+		}, {
+			method: "GET",
+			path: `/:${parentField}/children`,
+			handler: "getChildren",
+			summary: "Get children of parent",
+			permissions: permissions.list ?? allowPublic(),
+			wrapHandler: true,
+			operation: "getChildren"
+		}],
+		controllerOptions: { parentField }
+	};
+}
+//#endregion
+//#region src/presets/index.ts
+/**
+* Convenience alias for multiTenantPreset with public list/get routes
+* Equivalent to: multiTenantPreset({ allowPublic: ['list', 'get'] })
+*/
+const flexibleMultiTenantPreset = (options = {}) => multiTenantPreset({
+	...options,
+	allowPublic: ["list", "get"]
+});
+const presetRegistry = {
+	softDelete: softDeletePreset,
+	slugLookup: slugLookupPreset,
+	ownedByUser: ownedByUserPreset,
+	multiTenant: multiTenantPreset,
+	tree: treePreset,
+	audited: auditedPreset,
+	bulk: bulkPreset
+};
+/**
+* Get preset by name with options
+*/
+function getPreset(nameOrConfig) {
+	if (typeof nameOrConfig === "object" && nameOrConfig.name) {
+		const { name, ...options } = nameOrConfig;
+		return resolvePreset(name, options);
+	}
+	return resolvePreset(nameOrConfig);
+}
+/**
+* Resolve preset by name
+*/
+function resolvePreset(name, options = {}) {
+	const factory = presetRegistry[name];
+	if (!factory) {
+		const available = Object.keys(presetRegistry).join(", ");
+		throw new Error(`Unknown preset: '${name}'\nAvailable presets: ${available}\nDocs: https://github.com/classytic/arc#presets`);
+	}
+	return factory(options);
+}
+/**
+* Register a custom preset
+*/
+function registerPreset(name, factory, options) {
+	if (presetRegistry[name] && !options?.override) throw new Error(`Preset '${name}' already exists. Pass { override: true } to replace.`);
+	presetRegistry[name] = factory;
+}
+/**
+* Get all available preset names
+*/
+function getAvailablePresets() {
+	return Object.keys(presetRegistry);
+}
+/**
+* Validate that preset combinations don't conflict.
+* Detects route collisions (same method + path from different presets).
+*/
+function validatePresetCombination(presets) {
+	const conflicts = [];
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const preset of presets) {
+		const name = preset.name ?? "unknown";
+		const routes = typeof preset.additionalRoutes === "function" ? preset.additionalRoutes({}) : preset.additionalRoutes ?? [];
+		for (const route of routes) {
+			const key = `${route.method} ${route.path}`;
+			const existing = routeMap.get(key);
+			if (existing) conflicts.push({
+				presets: [existing, name],
+				message: `Both '${existing}' and '${name}' define route ${key}`,
+				severity: "error"
+			});
+			routeMap.set(key, name);
+		}
+	}
+	return conflicts;
+}
+/**
+* Apply presets to resource config.
+* Validates preset combinations for conflicts before merging.
+*/
+function applyPresets(config, presets = []) {
+	let result = { ...config };
+	const resolved = presets.map(resolvePresetInput);
+	const errors = validatePresetCombination(resolved).filter((c) => c.severity === "error");
+	if (errors.length > 0) throw new Error(`[Arc] Resource '${config.name}' preset conflicts:\n` + errors.map((c) => `  - ${c.message}`).join("\n"));
+	for (const preset of resolved) result = mergePreset(result, preset);
+	return result;
+}
+/**
+* Resolve preset input to PresetResult
+*/
+function resolvePresetInput(preset) {
+	if (typeof preset === "object" && ("middlewares" in preset || "additionalRoutes" in preset)) return preset;
+	if (typeof preset === "object" && "name" in preset) {
+		const { name, ...options } = preset;
+		return resolvePreset(name, options);
+	}
+	return resolvePreset(preset);
+}
+/**
+* Merge preset into config
+*/
+function mergePreset(config, preset) {
+	const result = { ...config };
+	if (preset.additionalRoutes) {
+		const routes = typeof preset.additionalRoutes === "function" ? preset.additionalRoutes(config.permissions ?? {}) : preset.additionalRoutes;
+		result.additionalRoutes = [...result.additionalRoutes ?? [], ...routes];
+	}
+	if (preset.middlewares) {
+		result.middlewares = result.middlewares ?? {};
+		for (const [op, mws] of Object.entries(preset.middlewares)) {
+			const key = op;
+			result.middlewares[key] = [...result.middlewares[key] ?? [], ...mws ?? []];
+		}
+	}
+	if (preset.schemaOptions) result.schemaOptions = {
+		...result.schemaOptions,
+		...preset.schemaOptions,
+		fieldRules: {
+			...result.schemaOptions?.fieldRules,
+			...preset.schemaOptions?.fieldRules
+		}
+	};
+	if (preset.controllerOptions) result._controllerOptions = {
+		...result._controllerOptions,
+		...preset.controllerOptions
+	};
+	if (preset.hooks && preset.hooks.length > 0) {
+		result._hooks = result._hooks ?? [];
+		for (const hook of preset.hooks) result._hooks.push({
+			presetName: preset.name,
+			operation: hook.operation,
+			phase: hook.phase,
+			handler: hook.handler,
+			priority: hook.priority
+		});
+	}
+	return result;
+}
+//#endregion
+export { registerPreset as a, auditedPreset as c, ownedByUserPreset as d, getPreset as i, softDeletePreset as l, flexibleMultiTenantPreset as n, treePreset as o, getAvailablePresets as r, bulkPreset as s, applyPresets as t, slugLookupPreset as u };

package/dist/{queryCachePlugin-B6R0d4av.mjs → queryCachePlugin-ClosZdNS.mjs}

@@ -1,9 +1,8 @@
-import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
-import { i as versionKey, r as tagVersionKey } from "./keys-DhqDRxv3.mjs";
-import { t as hasEvents } from "./typeGuards-DwxA1t_L.mjs";
-import { t as MemoryCacheStore } from "./memory-B2v7KrCB.mjs";
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
+import { i as versionKey, r as tagVersionKey } from "./keys-qcD-TVJl.mjs";
+import { t as hasEvents } from "./typeGuards-Cj5Rgvlg.mjs";
+import { t as MemoryCacheStore } from "./memory-Cb_7iy9e.mjs";
 import fp from "fastify-plugin";
-
 //#region src/cache/QueryCache.ts
 var QueryCache = class {
 	store;
@@ -12,7 +11,7 @@ var QueryCache = class {
 	}
 	async get(key) {
 		const envelope = await this.store.get(key);
-		if (!envelope || !envelope.createdAt) return {
+		if (!envelope?.createdAt) return {
 			data: void 0,
 			status: "miss"
 		};
@@ -70,27 +69,8 @@ var QueryCache = class {
 		await this.store.set(key, newVersion, { ttlMs: 1440 * 60 * 1e3 });
 	}
 };
-
 //#endregion
 //#region src/cache/queryCachePlugin.ts
-/**
-* QueryCache Fastify Plugin
-*
-* Registers QueryCache on `fastify.queryCache` and wires automatic
-* cache invalidation via CRUD events. Zero config for memory mode.
-*
-* @example
-* ```typescript
-* // Memory mode (default)
-* await fastify.register(queryCachePlugin);
-*
-* // With Redis store
-* await fastify.register(queryCachePlugin, {
-*   store: new RedisCacheStore({ client: redis, prefix: 'arc:qc:' }),
-*   defaults: { staleTime: 30, gcTime: 300 },
-* });
-* ```
-*/
 var queryCachePlugin_exports = /* @__PURE__ */ __exportAll({ queryCachePlugin: () => queryCachePlugin });
 const CRUD_SUFFIXES = new Set([
 	"created",
@@ -133,6 +113,5 @@ const queryCachePlugin = fp(queryCachePluginImpl, {
 	name: "arc-query-cache",
 	fastify: "5.x"
 });
-
 //#endregion
-export { queryCachePlugin_exports as n, QueryCache as r, queryCachePlugin as t };
+export { queryCachePlugin_exports as n, QueryCache as r, queryCachePlugin as t };

package/dist/{queryCachePlugin-Q6SYuHZ6.d.mts → queryCachePlugin-DcmETvcB.d.mts}

@@ -1,4 +1,4 @@
-import { i as CacheStore } from "./interface-DTbsvIWe.mjs";
+import { i as CacheStore } from "./interface-D_BWALyZ.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/cache/QueryCache.d.ts
@@ -18,7 +18,7 @@ interface QueryCacheConfig {
   /** Tags for group invalidation */
   tags?: string[];
 }
-type CacheStatus = 'fresh' | 'stale' | 'miss';
+type CacheStatus = "fresh" | "stale" | "miss";
 interface CacheResult<T> {
   data: T;
   status: CacheStatus;
@@ -58,7 +58,7 @@ interface CrossResourceRule {
   pattern: string;
   tags: string[];
 }
-declare module 'fastify' {
+declare module "fastify" {
   interface FastifyInstance {
     queryCache: QueryCache;
     queryCacheConfig: QueryCacheDefaults;