@aigne/afs 1.11.0-beta → 1.11.0-beta.10

package/dist/provider/decorators.d.mts

@@ -0,0 +1,244 @@
+import { ListDecoratorOptions, RouteMetadata } from "./types.mjs";
+
+//#region src/provider/decorators.d.ts
+type Constructor = Function;
+/**
+ * Get all registered routes for a class (including inherited routes)
+ */
+declare function getRoutes(ctor: Constructor): RouteMetadata[];
+/**
+ * Clear routes for a class (mainly for testing)
+ */
+declare function clearRoutes(ctor: Constructor): void;
+/**
+ * @List decorator - handles list operations
+ * Handler should return: { data: AFSEntry[], total?: number }
+ *
+ * @param pattern - Route pattern to match
+ * @param optionsOrDescription - Either a description string or ListDecoratorOptions
+ *
+ * @example
+ * ```typescript
+ * // Simple usage
+ * @List("/:table")
+ * async listRows(ctx: RouteContext<{ table: string }>) {
+ *   return { data: rows, total: 100 };
+ * }
+ *
+ * // Default behavior - base provider handles depth via BFS
+ * @List("/**")
+ * async listDir(ctx: RouteContext) {
+ *   // Only need to return single-level results
+ *   return { data: entries };
+ * }
+ *
+ * // Handler manages depth itself (opt-in for special cases like S3)
+ * @List("/**", { handleDepth: true })
+ * async listDirWithDepth(ctx: RouteContext) {
+ *   // Handler implements maxDepth logic
+ *   return { data: entries };
+ * }
+ * ```
+ */
+declare function List(pattern: string, optionsOrDescription?: string | ListDecoratorOptions): MethodDecorator;
+/**
+ * @Read decorator - handles read operations
+ * Handler should return: AFSEntry
+ *
+ * @example
+ * ```typescript
+ * @Read("/:table/:pk")
+ * async getRow(ctx: RouteContext<{ table: string; pk: string }>) {
+ *   return { id: pk, path: ctx.path, content: row };
+ * }
+ * ```
+ */
+declare const Read: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Write decorator - handles write operations
+ * Handler should return: AFSWriteResult
+ *
+ * @example
+ * ```typescript
+ * @Write("/:table/:pk")
+ * async updateRow(ctx: RouteContext, content: AFSWriteEntryPayload) {
+ *   return { data: updatedEntry };
+ * }
+ * ```
+ */
+declare const Write: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Delete decorator - handles delete operations
+ * Handler should return: AFSDeleteResult
+ *
+ * @example
+ * ```typescript
+ * @Delete("/:table/:pk")
+ * async deleteRow(ctx: RouteContext<{ table: string; pk: string }>) {
+ *   return { message: "Deleted" };
+ * }
+ * ```
+ */
+declare const Delete: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Exec decorator - handles exec operations
+ * Handler should return: AFSExecResult
+ *
+ * @example
+ * ```typescript
+ * @Exec("/:table/:pk/.actions/:action")
+ * async executeAction(ctx: RouteContext, args: Record<string, unknown>) {
+ *   return { data: { success: true } };
+ * }
+ * ```
+ */
+declare const Exec: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Search decorator - handles search operations
+ * Handler should return: AFSSearchResult
+ *
+ * @example
+ * ```typescript
+ * @Search("/:table")
+ * async searchTable(ctx: RouteContext, query: string, options?: AFSSearchOptions) {
+ *   return { data: matchingEntries };
+ * }
+ * ```
+ */
+declare const Search: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Meta decorator - handles .meta path reads (introspection only, read-only)
+ * Automatically appends /.meta to the pattern
+ * Handler should return: AFSEntry
+ *
+ * Note: Meta is read-only. To write metadata, use @Write handler with payload.meta.
+ *
+ * @example
+ * ```typescript
+ * @Meta("/:table/:pk")  // Registers as /:table/:pk/.meta
+ * async getRowMeta(ctx: RouteContext<{ table: string; pk: string }>) {
+ *   return { id: "meta", path: `${ctx.path}/.meta`, content: schema };
+ * }
+ *
+ * @Meta("/")  // Registers as /.meta (root metadata)
+ * async getRootMeta(ctx: RouteContext) {
+ *   return { id: "meta", path: "/.meta", content: rootSchema };
+ * }
+ * ```
+ */
+declare function Meta(pattern: string, description?: string): MethodDecorator;
+/**
+ * Actions decorator interface - callable function with Execute method
+ */
+interface ActionsDecorator {
+  /**
+   * @Actions decorator - handles .actions path listing
+   * Automatically appends /.actions to the pattern
+   * Handler should return: { data: AFSEntry[] }
+   *
+   * @param pattern - Base path pattern for the node
+   * @param description - Optional description for the route
+   *
+   * @example
+   * ```typescript
+   * @Actions("/:table/:pk")  // Registers as /:table/:pk/.actions
+   * async listRowActions(ctx: RouteContext<{ table: string; pk: string }>) {
+   *   return { data: availableActions };
+   * }
+   * ```
+   */
+  (pattern: string, description?: string): MethodDecorator;
+  /**
+   * @Actions.Exec decorator - handles action execution on nodes
+   * Automatically constructs the full .actions path for action execution.
+   * Handler should return: AFSExecResult
+   *
+   * @param pattern - Base path pattern for the node (e.g., "/issues/:number")
+   * @param actionName - Optional specific action name. If omitted, registers catch-all pattern.
+   * @param description - Optional description for the route
+   *
+   * @example
+   * ```typescript
+   * // Specific action - registers as /issues/:number/.actions/close
+   * @Actions.Exec("/issues/:number", "close")
+   * async closeIssue(ctx: RouteContext<{ number: string }>, args: Record<string, unknown>) {
+   *   return { data: { success: true } };
+   * }
+   *
+   * // Catch-all action - registers as /issues/:number/.actions/:action
+   * @Actions.Exec("/issues/:number")
+   * async handleIssueAction(ctx: RouteContext<{ number: string; action: string }>, args: Record<string, unknown>) {
+   *   return { data: { action: ctx.params.action } };
+   * }
+   *
+   * // Root-level action - registers as /.actions/refresh
+   * @Actions.Exec("/", "refresh")
+   * async refreshAll(ctx: RouteContext, args: Record<string, unknown>) {
+   *   return { data: { refreshed: true } };
+   * }
+   * ```
+   */
+  Exec: (pattern: string, actionName?: string, description?: string) => MethodDecorator;
+}
+/**
+ * @Actions decorator - handles action-related routes
+ *
+ * Use directly for listing actions:
+ * @example
+ * ```typescript
+ * @Actions("/:table/:pk")  // Registers as /:table/:pk/.actions
+ * async listRowActions(ctx: RouteContext<{ table: string; pk: string }>) {
+ *   return { data: availableActions };
+ * }
+ * ```
+ *
+ * Use Actions.Exec for action execution:
+ * @example
+ * ```typescript
+ * @Actions.Exec("/:table/:pk", "close")
+ * async closeAction(ctx: RouteContext, args: Record<string, unknown>) { ... }
+ * ```
+ */
+declare const Actions: ActionsDecorator;
+/**
+ * @Stat decorator - handles stat operations
+ * Handler should return: AFSStatResult
+ *
+ * @example
+ * ```typescript
+ * @Stat("/:path*")
+ * async statPath(ctx: RouteContext<{ path?: string }>) {
+ *   return { data: { path: ctx.path, size: 100, modified: new Date() } };
+ * }
+ * ```
+ */
+declare const Stat: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Explain decorator - handles explain operations
+ * Handler should return: AFSExplainResult
+ *
+ * @example
+ * ```typescript
+ * @Explain("/:path*")
+ * async explainPath(ctx: RouteContext<{ path?: string }>) {
+ *   return { data: { content: "...", format: "markdown" } };
+ * }
+ * ```
+ */
+declare const Explain: (pattern: string, description?: string) => MethodDecorator;
+/**
+ * @Rename decorator - handles rename operations
+ * Handler should return: AFSRenameResult
+ *
+ * @example
+ * ```typescript
+ * @Rename("/:path*")
+ * async renamePath(ctx: RouteContext<{ path?: string }>, newPath: string) {
+ *   return { message: "Renamed successfully" };
+ * }
+ * ```
+ */
+declare const Rename: (pattern: string, description?: string) => MethodDecorator;
+//#endregion
+export { Actions, Delete, Exec, Explain, List, Meta, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes };
+//# sourceMappingURL=decorators.d.mts.map

package/dist/provider/decorators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.mts","names":[],"sources":["../../src/provider/decorators.ts"],"mappings":";;;KAGK,WAAA,GAAc,QAAA;;AAHmE;;iBAetE,SAAA,CAAU,IAAA,EAAM,WAAA,GAAc,aAAA;;;AAA9C;iBAoBgB,WAAA,CAAY,IAAA,EAAM,WAAA;;;;;;;;AAAlC;;;;;AA6DA;;;;;;;;;;AAwBA;;;;;;;;iBAxBgB,IAAA,CACd,OAAA,UACA,oBAAA,YAAgC,oBAAA,GAC/B,eAAA;AAmCH;;;;;;;;;AAcA;;;AAdA,cAda,IAAA,GAAI,OAAA,UA7DQ,WAAA,cAAyB,eAAA;;;;;;AAuGlD;;;;;;;cA5Ba,KAAA,GAAK,OAAA,UA3EO,WAAA,cAAyB,eAAA;;AAqHlD;;;;;;;;;AAsBA;;cAlDa,MAAA,GAAM,OAAA,UAzFM,WAAA,cAAyB,eAAA;;;;;;;AA+IjD;;;;;;cAxCY,IAAA,GAAI,OAAA,UAvGQ,WAAA,cAAyB,eAAA;;;;;;;;AAkPlD;;;;;cA7Ha,MAAA,GAAM,OAAA,UArHM,WAAA,cAAyB,eAAA;;;;;;;;;AAuRlD;;;;;;;;;AAcA;;;iBA1JgB,IAAA,CAAK,OAAA,UAAiB,WAAA,YAAuB,eAAA;;;;UAgCnD,gBAAA;EA0H0C;;;;;;;;;;;;;;;;EAAA,CAzGjD,OAAA,UAAiB,WAAA,YAAuB,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCzC,IAAA,GAAO,OAAA,UAAiB,UAAA,WAAqB,WAAA,cAAyB,eAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAsB3D,OAAA,EAAS,gBAAA;;;;;;;;;;;;;cAuBT,IAAA,GAAI,OAAA,UAzQQ,WAAA,cAAyB,eAAA;;;;;;;;;;;;;cAuRrC,OAAA,GAAO,OAAA,UAvRK,WAAA,cAAyB,eAAA;;;;;;;;;;;;;cAqSrC,MAAA,GAAM,OAAA,UArSM,WAAA,cAAyB,eAAA"}

package/dist/provider/decorators.mjs

@@ -0,0 +1,256 @@
+//#region src/provider/decorators.ts
+/**
+* WeakMap-based route registry
+* Using WeakMap to avoid memory leaks - when class is garbage collected,
+* its routes are automatically cleaned up
+*/
+const routeRegistry = /* @__PURE__ */ new WeakMap();
+/**
+* Get all registered routes for a class (including inherited routes)
+*/
+function getRoutes(ctor) {
+	const routes = [];
+	let current = ctor;
+	while (current && current !== Function.prototype && current !== Object) {
+		const classRoutes = routeRegistry.get(current);
+		if (classRoutes) routes.unshift(...classRoutes);
+		current = Object.getPrototypeOf(current);
+	}
+	return routes;
+}
+/**
+* Clear routes for a class (mainly for testing)
+*/
+function clearRoutes(ctor) {
+	routeRegistry.delete(ctor);
+}
+/**
+* Register a route on a class
+*/
+function registerRoute(ctor, pattern, operation, methodName, description, listOptions) {
+	const routes = routeRegistry.get(ctor) || [];
+	routes.push({
+		pattern,
+		operation,
+		methodName,
+		description,
+		listOptions
+	});
+	routeRegistry.set(ctor, routes);
+}
+/**
+* Create a route decorator for a specific operation
+*/
+function createRouteDecorator(operation) {
+	return (pattern, description) => (target, propertyKey) => {
+		const ctor = target.constructor;
+		registerRoute(ctor, pattern, operation, String(propertyKey), description);
+	};
+}
+/**
+* @List decorator - handles list operations
+* Handler should return: { data: AFSEntry[], total?: number }
+*
+* @param pattern - Route pattern to match
+* @param optionsOrDescription - Either a description string or ListDecoratorOptions
+*
+* @example
+* ```typescript
+* // Simple usage
+* @List("/:table")
+* async listRows(ctx: RouteContext<{ table: string }>) {
+*   return { data: rows, total: 100 };
+* }
+*
+* // Default behavior - base provider handles depth via BFS
+* @List("/**")
+* async listDir(ctx: RouteContext) {
+*   // Only need to return single-level results
+*   return { data: entries };
+* }
+*
+* // Handler manages depth itself (opt-in for special cases like S3)
+* @List("/**", { handleDepth: true })
+* async listDirWithDepth(ctx: RouteContext) {
+*   // Handler implements maxDepth logic
+*   return { data: entries };
+* }
+* ```
+*/
+function List(pattern, optionsOrDescription) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const description = typeof optionsOrDescription === "string" ? optionsOrDescription : void 0;
+		const listOptions = typeof optionsOrDescription === "object" ? optionsOrDescription : void 0;
+		registerRoute(ctor, pattern, "list", String(propertyKey), description, listOptions);
+	};
+}
+/**
+* @Read decorator - handles read operations
+* Handler should return: AFSEntry
+*
+* @example
+* ```typescript
+* @Read("/:table/:pk")
+* async getRow(ctx: RouteContext<{ table: string; pk: string }>) {
+*   return { id: pk, path: ctx.path, content: row };
+* }
+* ```
+*/
+const Read = createRouteDecorator("read");
+/**
+* @Write decorator - handles write operations
+* Handler should return: AFSWriteResult
+*
+* @example
+* ```typescript
+* @Write("/:table/:pk")
+* async updateRow(ctx: RouteContext, content: AFSWriteEntryPayload) {
+*   return { data: updatedEntry };
+* }
+* ```
+*/
+const Write = createRouteDecorator("write");
+/**
+* @Delete decorator - handles delete operations
+* Handler should return: AFSDeleteResult
+*
+* @example
+* ```typescript
+* @Delete("/:table/:pk")
+* async deleteRow(ctx: RouteContext<{ table: string; pk: string }>) {
+*   return { message: "Deleted" };
+* }
+* ```
+*/
+const Delete = createRouteDecorator("delete");
+/**
+* @Exec decorator - handles exec operations
+* Handler should return: AFSExecResult
+*
+* @example
+* ```typescript
+* @Exec("/:table/:pk/.actions/:action")
+* async executeAction(ctx: RouteContext, args: Record<string, unknown>) {
+*   return { data: { success: true } };
+* }
+* ```
+*/
+const Exec = createRouteDecorator("exec");
+/**
+* @Search decorator - handles search operations
+* Handler should return: AFSSearchResult
+*
+* @example
+* ```typescript
+* @Search("/:table")
+* async searchTable(ctx: RouteContext, query: string, options?: AFSSearchOptions) {
+*   return { data: matchingEntries };
+* }
+* ```
+*/
+const Search = createRouteDecorator("search");
+/**
+* @Meta decorator - handles .meta path reads (introspection only, read-only)
+* Automatically appends /.meta to the pattern
+* Handler should return: AFSEntry
+*
+* Note: Meta is read-only. To write metadata, use @Write handler with payload.meta.
+*
+* @example
+* ```typescript
+* @Meta("/:table/:pk")  // Registers as /:table/:pk/.meta
+* async getRowMeta(ctx: RouteContext<{ table: string; pk: string }>) {
+*   return { id: "meta", path: `${ctx.path}/.meta`, content: schema };
+* }
+*
+* @Meta("/")  // Registers as /.meta (root metadata)
+* async getRootMeta(ctx: RouteContext) {
+*   return { id: "meta", path: "/.meta", content: rootSchema };
+* }
+* ```
+*/
+function Meta(pattern, description) {
+	const metaPattern = pattern === "/" ? "/.meta" : `${pattern}/.meta`;
+	return createRouteDecorator("read")(metaPattern, description);
+}
+/**
+* Creates a list decorator for .actions path
+*/
+function createActionsListDecorator(pattern, description) {
+	const actionsPattern = pattern === "/" ? "/.actions" : `${pattern}/.actions`;
+	return createRouteDecorator("list")(actionsPattern, description);
+}
+/**
+* Creates an exec decorator for action execution
+*/
+function createActionsExecuteDecorator(pattern, actionName, description) {
+	const basePath = pattern === "/" ? "" : pattern;
+	const fullPattern = actionName ? `${basePath}/.actions/${actionName}` : `${basePath}/.actions/:action`;
+	return createRouteDecorator("exec")(fullPattern, description);
+}
+/**
+* @Actions decorator - handles action-related routes
+*
+* Use directly for listing actions:
+* @example
+* ```typescript
+* @Actions("/:table/:pk")  // Registers as /:table/:pk/.actions
+* async listRowActions(ctx: RouteContext<{ table: string; pk: string }>) {
+*   return { data: availableActions };
+* }
+* ```
+*
+* Use Actions.Exec for action execution:
+* @example
+* ```typescript
+* @Actions.Exec("/:table/:pk", "close")
+* async closeAction(ctx: RouteContext, args: Record<string, unknown>) { ... }
+* ```
+*/
+const Actions = Object.assign((pattern, description) => {
+	return createActionsListDecorator(pattern, description);
+}, { Exec: createActionsExecuteDecorator });
+/**
+* @Stat decorator - handles stat operations
+* Handler should return: AFSStatResult
+*
+* @example
+* ```typescript
+* @Stat("/:path*")
+* async statPath(ctx: RouteContext<{ path?: string }>) {
+*   return { data: { path: ctx.path, size: 100, modified: new Date() } };
+* }
+* ```
+*/
+const Stat = createRouteDecorator("stat");
+/**
+* @Explain decorator - handles explain operations
+* Handler should return: AFSExplainResult
+*
+* @example
+* ```typescript
+* @Explain("/:path*")
+* async explainPath(ctx: RouteContext<{ path?: string }>) {
+*   return { data: { content: "...", format: "markdown" } };
+* }
+* ```
+*/
+const Explain = createRouteDecorator("explain");
+/**
+* @Rename decorator - handles rename operations
+* Handler should return: AFSRenameResult
+*
+* @example
+* ```typescript
+* @Rename("/:path*")
+* async renamePath(ctx: RouteContext<{ path?: string }>, newPath: string) {
+*   return { message: "Renamed successfully" };
+* }
+* ```
+*/
+const Rename = createRouteDecorator("rename");
+
+//#endregion
+export { Actions, Delete, Exec, Explain, List, Meta, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes };
+//# sourceMappingURL=decorators.mjs.map

package/dist/provider/decorators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.mjs","names":[],"sources":["../../src/provider/decorators.ts"],"sourcesContent":["import type { ListDecoratorOptions, RouteMetadata, RouteOperation } from \"./types.js\";\n\n// biome-ignore lint/complexity/noBannedTypes: WeakMap requires object key type, Function is appropriate for class constructors\ntype Constructor = Function;\n\n/**\n * WeakMap-based route registry\n * Using WeakMap to avoid memory leaks - when class is garbage collected,\n * its routes are automatically cleaned up\n */\nconst routeRegistry = new WeakMap<Constructor, RouteMetadata[]>();\n\n/**\n * Get all registered routes for a class (including inherited routes)\n */\nexport function getRoutes(ctor: Constructor): RouteMetadata[] {\n  const routes: RouteMetadata[] = [];\n\n  // Walk up the prototype chain to collect routes from parent classes\n  let current: Constructor | null = ctor;\n  while (current && current !== Function.prototype && current !== Object) {\n    const classRoutes = routeRegistry.get(current);\n    if (classRoutes) {\n      // Prepend parent routes so child routes can override\n      routes.unshift(...classRoutes);\n    }\n    current = Object.getPrototypeOf(current);\n  }\n\n  return routes;\n}\n\n/**\n * Clear routes for a class (mainly for testing)\n */\nexport function clearRoutes(ctor: Constructor): void {\n  routeRegistry.delete(ctor);\n}\n\n/**\n * Register a route on a class\n */\nfunction registerRoute(\n  ctor: Constructor,\n  pattern: string,\n  operation: RouteOperation,\n  methodName: string,\n  description?: string,\n  listOptions?: ListDecoratorOptions,\n): void {\n  const routes = routeRegistry.get(ctor) || [];\n  routes.push({ pattern, operation, methodName, description, listOptions });\n  routeRegistry.set(ctor, routes);\n}\n\n/**\n * Create a route decorator for a specific operation\n */\nfunction createRouteDecorator(operation: RouteOperation) {\n  return (pattern: string, description?: string): MethodDecorator =>\n    (target: object, propertyKey: string | symbol): void => {\n      const ctor = target.constructor;\n      registerRoute(ctor, pattern, operation, String(propertyKey), description);\n    };\n}\n\n/**\n * @List decorator - handles list operations\n * Handler should return: { data: AFSEntry[], total?: number }\n *\n * @param pattern - Route pattern to match\n * @param optionsOrDescription - Either a description string or ListDecoratorOptions\n *\n * @example\n * ```typescript\n * // Simple usage\n * @List(\"/:table\")\n * async listRows(ctx: RouteContext<{ table: string }>) {\n *   return { data: rows, total: 100 };\n * }\n *\n * // Default behavior - base provider handles depth via BFS\n * @List(\"/**\")\n * async listDir(ctx: RouteContext) {\n *   // Only need to return single-level results\n *   return { data: entries };\n * }\n *\n * // Handler manages depth itself (opt-in for special cases like S3)\n * @List(\"/**\", { handleDepth: true })\n * async listDirWithDepth(ctx: RouteContext) {\n *   // Handler implements maxDepth logic\n *   return { data: entries };\n * }\n * ```\n */\nexport function List(\n  pattern: string,\n  optionsOrDescription?: string | ListDecoratorOptions,\n): MethodDecorator {\n  return (target: object, propertyKey: string | symbol): void => {\n    const ctor = target.constructor;\n    const description = typeof optionsOrDescription === \"string\" ? optionsOrDescription : undefined;\n    const listOptions = typeof optionsOrDescription === \"object\" ? optionsOrDescription : undefined;\n    registerRoute(ctor, pattern, \"list\", String(propertyKey), description, listOptions);\n  };\n}\n\n/**\n * @Read decorator - handles read operations\n * Handler should return: AFSEntry\n *\n * @example\n * ```typescript\n * @Read(\"/:table/:pk\")\n * async getRow(ctx: RouteContext<{ table: string; pk: string }>) {\n *   return { id: pk, path: ctx.path, content: row };\n * }\n * ```\n */\nexport const Read = createRouteDecorator(\"read\");\n\n/**\n * @Write decorator - handles write operations\n * Handler should return: AFSWriteResult\n *\n * @example\n * ```typescript\n * @Write(\"/:table/:pk\")\n * async updateRow(ctx: RouteContext, content: AFSWriteEntryPayload) {\n *   return { data: updatedEntry };\n * }\n * ```\n */\nexport const Write = createRouteDecorator(\"write\");\n\n/**\n * @Delete decorator - handles delete operations\n * Handler should return: AFSDeleteResult\n *\n * @example\n * ```typescript\n * @Delete(\"/:table/:pk\")\n * async deleteRow(ctx: RouteContext<{ table: string; pk: string }>) {\n *   return { message: \"Deleted\" };\n * }\n * ```\n */\nexport const Delete = createRouteDecorator(\"delete\");\n\n/**\n * @Exec decorator - handles exec operations\n * Handler should return: AFSExecResult\n *\n * @example\n * ```typescript\n * @Exec(\"/:table/:pk/.actions/:action\")\n * async executeAction(ctx: RouteContext, args: Record<string, unknown>) {\n *   return { data: { success: true } };\n * }\n * ```\n */\nexport const Exec = createRouteDecorator(\"exec\");\n\n/**\n * @Search decorator - handles search operations\n * Handler should return: AFSSearchResult\n *\n * @example\n * ```typescript\n * @Search(\"/:table\")\n * async searchTable(ctx: RouteContext, query: string, options?: AFSSearchOptions) {\n *   return { data: matchingEntries };\n * }\n * ```\n */\nexport const Search = createRouteDecorator(\"search\");\n\n/**\n * @Meta decorator - handles .meta path reads (introspection only, read-only)\n * Automatically appends /.meta to the pattern\n * Handler should return: AFSEntry\n *\n * Note: Meta is read-only. To write metadata, use @Write handler with payload.meta.\n *\n * @example\n * ```typescript\n * @Meta(\"/:table/:pk\")  // Registers as /:table/:pk/.meta\n * async getRowMeta(ctx: RouteContext<{ table: string; pk: string }>) {\n *   return { id: \"meta\", path: `${ctx.path}/.meta`, content: schema };\n * }\n *\n * @Meta(\"/\")  // Registers as /.meta (root metadata)\n * async getRootMeta(ctx: RouteContext) {\n *   return { id: \"meta\", path: \"/.meta\", content: rootSchema };\n * }\n * ```\n */\nexport function Meta(pattern: string, description?: string): MethodDecorator {\n  // Handle root pattern specially to avoid double slash\n  const metaPattern = pattern === \"/\" ? \"/.meta\" : `${pattern}/.meta`;\n  return createRouteDecorator(\"read\")(metaPattern, description);\n}\n\n/**\n * Creates a list decorator for .actions path\n */\nfunction createActionsListDecorator(pattern: string, description?: string): MethodDecorator {\n  const actionsPattern = pattern === \"/\" ? \"/.actions\" : `${pattern}/.actions`;\n  return createRouteDecorator(\"list\")(actionsPattern, description);\n}\n\n/**\n * Creates an exec decorator for action execution\n */\nfunction createActionsExecuteDecorator(\n  pattern: string,\n  actionName?: string,\n  description?: string,\n): MethodDecorator {\n  const basePath = pattern === \"/\" ? \"\" : pattern;\n  const fullPattern = actionName\n    ? `${basePath}/.actions/${actionName}`\n    : `${basePath}/.actions/:action`;\n  return createRouteDecorator(\"exec\")(fullPattern, description);\n}\n\n/**\n * Actions decorator interface - callable function with Execute method\n */\ninterface ActionsDecorator {\n  /**\n   * @Actions decorator - handles .actions path listing\n   * Automatically appends /.actions to the pattern\n   * Handler should return: { data: AFSEntry[] }\n   *\n   * @param pattern - Base path pattern for the node\n   * @param description - Optional description for the route\n   *\n   * @example\n   * ```typescript\n   * @Actions(\"/:table/:pk\")  // Registers as /:table/:pk/.actions\n   * async listRowActions(ctx: RouteContext<{ table: string; pk: string }>) {\n   *   return { data: availableActions };\n   * }\n   * ```\n   */\n  (pattern: string, description?: string): MethodDecorator;\n\n  /**\n   * @Actions.Exec decorator - handles action execution on nodes\n   * Automatically constructs the full .actions path for action execution.\n   * Handler should return: AFSExecResult\n   *\n   * @param pattern - Base path pattern for the node (e.g., \"/issues/:number\")\n   * @param actionName - Optional specific action name. If omitted, registers catch-all pattern.\n   * @param description - Optional description for the route\n   *\n   * @example\n   * ```typescript\n   * // Specific action - registers as /issues/:number/.actions/close\n   * @Actions.Exec(\"/issues/:number\", \"close\")\n   * async closeIssue(ctx: RouteContext<{ number: string }>, args: Record<string, unknown>) {\n   *   return { data: { success: true } };\n   * }\n   *\n   * // Catch-all action - registers as /issues/:number/.actions/:action\n   * @Actions.Exec(\"/issues/:number\")\n   * async handleIssueAction(ctx: RouteContext<{ number: string; action: string }>, args: Record<string, unknown>) {\n   *   return { data: { action: ctx.params.action } };\n   * }\n   *\n   * // Root-level action - registers as /.actions/refresh\n   * @Actions.Exec(\"/\", \"refresh\")\n   * async refreshAll(ctx: RouteContext, args: Record<string, unknown>) {\n   *   return { data: { refreshed: true } };\n   * }\n   * ```\n   */\n  Exec: (pattern: string, actionName?: string, description?: string) => MethodDecorator;\n}\n\n/**\n * @Actions decorator - handles action-related routes\n *\n * Use directly for listing actions:\n * @example\n * ```typescript\n * @Actions(\"/:table/:pk\")  // Registers as /:table/:pk/.actions\n * async listRowActions(ctx: RouteContext<{ table: string; pk: string }>) {\n *   return { data: availableActions };\n * }\n * ```\n *\n * Use Actions.Exec for action execution:\n * @example\n * ```typescript\n * @Actions.Exec(\"/:table/:pk\", \"close\")\n * async closeAction(ctx: RouteContext, args: Record<string, unknown>) { ... }\n * ```\n */\nexport const Actions: ActionsDecorator = Object.assign(\n  // Main function - for listing actions\n  (pattern: string, description?: string): MethodDecorator => {\n    return createActionsListDecorator(pattern, description);\n  },\n  // Additional methods\n  {\n    Exec: createActionsExecuteDecorator,\n  },\n);\n\n/**\n * @Stat decorator - handles stat operations\n * Handler should return: AFSStatResult\n *\n * @example\n * ```typescript\n * @Stat(\"/:path*\")\n * async statPath(ctx: RouteContext<{ path?: string }>) {\n *   return { data: { path: ctx.path, size: 100, modified: new Date() } };\n * }\n * ```\n */\nexport const Stat = createRouteDecorator(\"stat\");\n\n/**\n * @Explain decorator - handles explain operations\n * Handler should return: AFSExplainResult\n *\n * @example\n * ```typescript\n * @Explain(\"/:path*\")\n * async explainPath(ctx: RouteContext<{ path?: string }>) {\n *   return { data: { content: \"...\", format: \"markdown\" } };\n * }\n * ```\n */\nexport const Explain = createRouteDecorator(\"explain\");\n\n/**\n * @Rename decorator - handles rename operations\n * Handler should return: AFSRenameResult\n *\n * @example\n * ```typescript\n * @Rename(\"/:path*\")\n * async renamePath(ctx: RouteContext<{ path?: string }>, newPath: string) {\n *   return { message: \"Renamed successfully\" };\n * }\n * ```\n */\nexport const Rename = createRouteDecorator(\"rename\");\n"],"mappings":";;;;;;AAUA,MAAM,gCAAgB,IAAI,SAAuC;;;;AAKjE,SAAgB,UAAU,MAAoC;CAC5D,MAAM,SAA0B,EAAE;CAGlC,IAAI,UAA8B;AAClC,QAAO,WAAW,YAAY,SAAS,aAAa,YAAY,QAAQ;EACtE,MAAM,cAAc,cAAc,IAAI,QAAQ;AAC9C,MAAI,YAEF,QAAO,QAAQ,GAAG,YAAY;AAEhC,YAAU,OAAO,eAAe,QAAQ;;AAG1C,QAAO;;;;;AAMT,SAAgB,YAAY,MAAyB;AACnD,eAAc,OAAO,KAAK;;;;;AAM5B,SAAS,cACP,MACA,SACA,WACA,YACA,aACA,aACM;CACN,MAAM,SAAS,cAAc,IAAI,KAAK,IAAI,EAAE;AAC5C,QAAO,KAAK;EAAE;EAAS;EAAW;EAAY;EAAa;EAAa,CAAC;AACzE,eAAc,IAAI,MAAM,OAAO;;;;;AAMjC,SAAS,qBAAqB,WAA2B;AACvD,SAAQ,SAAiB,iBACtB,QAAgB,gBAAuC;EACtD,MAAM,OAAO,OAAO;AACpB,gBAAc,MAAM,SAAS,WAAW,OAAO,YAAY,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC/E,SAAgB,KACd,SACA,sBACiB;AACjB,SAAQ,QAAgB,gBAAuC;EAC7D,MAAM,OAAO,OAAO;EACpB,MAAM,cAAc,OAAO,yBAAyB,WAAW,uBAAuB;EACtF,MAAM,cAAc,OAAO,yBAAyB,WAAW,uBAAuB;AACtF,gBAAc,MAAM,SAAS,QAAQ,OAAO,YAAY,EAAE,aAAa,YAAY;;;;;;;;;;;;;;;AAgBvF,MAAa,OAAO,qBAAqB,OAAO;;;;;;;;;;;;;AAchD,MAAa,QAAQ,qBAAqB,QAAQ;;;;;;;;;;;;;AAclD,MAAa,SAAS,qBAAqB,SAAS;;;;;;;;;;;;;AAcpD,MAAa,OAAO,qBAAqB,OAAO;;;;;;;;;;;;;AAchD,MAAa,SAAS,qBAAqB,SAAS;;;;;;;;;;;;;;;;;;;;;AAsBpD,SAAgB,KAAK,SAAiB,aAAuC;CAE3E,MAAM,cAAc,YAAY,MAAM,WAAW,GAAG,QAAQ;AAC5D,QAAO,qBAAqB,OAAO,CAAC,aAAa,YAAY;;;;;AAM/D,SAAS,2BAA2B,SAAiB,aAAuC;CAC1F,MAAM,iBAAiB,YAAY,MAAM,cAAc,GAAG,QAAQ;AAClE,QAAO,qBAAqB,OAAO,CAAC,gBAAgB,YAAY;;;;;AAMlE,SAAS,8BACP,SACA,YACA,aACiB;CACjB,MAAM,WAAW,YAAY,MAAM,KAAK;CACxC,MAAM,cAAc,aAChB,GAAG,SAAS,YAAY,eACxB,GAAG,SAAS;AAChB,QAAO,qBAAqB,OAAO,CAAC,aAAa,YAAY;;;;;;;;;;;;;;;;;;;;;AA6E/D,MAAa,UAA4B,OAAO,QAE7C,SAAiB,gBAA0C;AAC1D,QAAO,2BAA2B,SAAS,YAAY;GAGzD,EACE,MAAM,+BACP,CACF;;;;;;;;;;;;;AAcD,MAAa,OAAO,qBAAqB,OAAO;;;;;;;;;;;;;AAchD,MAAa,UAAU,qBAAqB,UAAU;;;;;;;;;;;;;AActD,MAAa,SAAS,qBAAqB,SAAS"}

package/dist/provider/index.cjs

@@ -0,0 +1,19 @@
+const require_decorators = require('./decorators.cjs');
+const require_router = require('./router.cjs');
+const require_base = require('./base.cjs');
+
+exports.AFSBaseProvider = require_base.AFSBaseProvider;
+exports.Actions = require_decorators.Actions;
+exports.Delete = require_decorators.Delete;
+exports.Exec = require_decorators.Exec;
+exports.Explain = require_decorators.Explain;
+exports.List = require_decorators.List;
+exports.Meta = require_decorators.Meta;
+exports.ProviderRouter = require_router.ProviderRouter;
+exports.Read = require_decorators.Read;
+exports.Rename = require_decorators.Rename;
+exports.Search = require_decorators.Search;
+exports.Stat = require_decorators.Stat;
+exports.Write = require_decorators.Write;
+exports.clearRoutes = require_decorators.clearRoutes;
+exports.getRoutes = require_decorators.getRoutes;

package/dist/provider/index.d.cts

@@ -0,0 +1,5 @@
+import { DeleteRouteHandler, ExecRouteHandler, ExplainRouteHandler, ListDecoratorOptions, ListHandlerResult, ListRouteHandler, ReadRouteHandler, RenameRouteHandler, RouteContext, RouteDefinition, RouteHandler, RouteMatch, RouteMetadata, RouteOperation, SearchRouteHandler, StatRouteHandler, WriteRouteHandler } from "./types.cjs";
+import { ProviderRouter } from "./router.cjs";
+import { AFSBaseProvider } from "./base.cjs";
+import { Actions, Delete, Exec, Explain, List, Meta, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes } from "./decorators.cjs";
+export { AFSBaseProvider, Actions, Delete, type DeleteRouteHandler, Exec, type ExecRouteHandler, Explain, type ExplainRouteHandler, List, type ListDecoratorOptions, type ListHandlerResult, type ListRouteHandler, Meta, ProviderRouter, Read, type ReadRouteHandler, Rename, type RenameRouteHandler, type RouteContext, type RouteDefinition, type RouteHandler, type RouteMatch, type RouteMetadata, type RouteOperation, Search, type SearchRouteHandler, Stat, type StatRouteHandler, Write, type WriteRouteHandler, clearRoutes, getRoutes };

package/dist/provider/index.d.mts

@@ -0,0 +1,5 @@
+import { DeleteRouteHandler, ExecRouteHandler, ExplainRouteHandler, ListDecoratorOptions, ListHandlerResult, ListRouteHandler, ReadRouteHandler, RenameRouteHandler, RouteContext, RouteDefinition, RouteHandler, RouteMatch, RouteMetadata, RouteOperation, SearchRouteHandler, StatRouteHandler, WriteRouteHandler } from "./types.mjs";
+import { ProviderRouter } from "./router.mjs";
+import { AFSBaseProvider } from "./base.mjs";
+import { Actions, Delete, Exec, Explain, List, Meta, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes } from "./decorators.mjs";
+export { AFSBaseProvider, Actions, Delete, type DeleteRouteHandler, Exec, type ExecRouteHandler, Explain, type ExplainRouteHandler, List, type ListDecoratorOptions, type ListHandlerResult, type ListRouteHandler, Meta, ProviderRouter, Read, type ReadRouteHandler, Rename, type RenameRouteHandler, type RouteContext, type RouteDefinition, type RouteHandler, type RouteMatch, type RouteMetadata, type RouteOperation, Search, type SearchRouteHandler, Stat, type StatRouteHandler, Write, type WriteRouteHandler, clearRoutes, getRoutes };

package/dist/provider/index.mjs

@@ -0,0 +1,5 @@
+import { Actions, Delete, Exec, Explain, List, Meta, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes } from "./decorators.mjs";
+import { ProviderRouter } from "./router.mjs";
+import { AFSBaseProvider } from "./base.mjs";
+
+export { AFSBaseProvider, Actions, Delete, Exec, Explain, List, Meta, ProviderRouter, Read, Rename, Search, Stat, Write, clearRoutes, getRoutes };