ts-forge 1.0.2 → 2.0.0-beta.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## v2.0.0-beta.0
+
+- Resolved warnings from TypeScript 6.0
+
+## v1.0.3
+
+- README.md: updated documentation
+- Keywords were added to package.json
+- Fixed vulnerabilities in package.json
+
 ## v1.0.2
 
 - Files in the .github and scripts folders were added to .npmignore to avoid publishing them to npm registry

package/README.md

@@ -1,20 +1,24 @@
-**Warning:** The first version of this library is ready, however documentation is still in progress
+# ts-forge
+
+[npm version](https://badge.fury.io/js/ts-forge)
+[npm downloads](https://www.npmjs.com/package/ts-forge)
 
 This library allows you to define resolvers for your Atlassian Forge addon using decorators. It uses the `@forge/resolver` library under the hood to define resolvers, but it provides a more convenient way to define them using decorators.
 
 ## Table of contents
 
 - [Introduction](#introduction)
-- [Table of Contents](#table-of-contents)
+- [Quick Start](#quick-start)
 - [Installation](#installation)
+- [TypeScript Configuration](#typescript-configuration)
 - [@Resolver](#resolver)
 - [@ResolverFn](#resolverfn)
 - [getDefinitionsForClass](#getdefinitionsforclass)
 - [Middlewares](#middlewares)
 - [Error handler](#error-handler)
-
-[![npm version](https://badge.fury.io/js/ts-forge.svg)](https://badge.fury.io/js/ts-forge)
-[![npm downloads](https://img.shields.io/npm/dm/ts-forge.svg)](https://www.npmjs.com/package/ts-forge)
+- [Frontend Usage](#frontend-usage)
+- [Complete Example](#complete-example)
+- [License](#license)
 
 ## Introduction
 
@@ -25,14 +29,14 @@ It provides two main decorators: `@Resolver` and `@ResolverFn`, which can be use
 When you create a resolver, you typically would do something like this:
 
 ```ts
-import Resolver "@forge/resolver";
+import Resolver from "@forge/resolver";
 
 const resolver = new Resolver();
 
 resolver.define("hello", async (req) => {
   try {
     return { message: "Hello world!" };
-  } catch(error)  {
+  } catch (error) {
     console.error("An error occurred:", error);
 
     return { status: "error", message: "An error occurred" };
@@ -44,7 +48,7 @@ resolver.define("update-user", async (req) => {
     // Update user logic...
 
     return { status: "success", message: "User updated successfully" };
-  } catch(error) {
+  } catch (error) {
     console.error("An error occurred:", error);
 
     return { status: "error", message: "An error occurred" };
@@ -69,7 +73,6 @@ class UserResolver {
   @ResolverFn("update-user")
   async updateUser(req) {
     // Update user logic...
-  }
     return { status: "success", message: "User updated successfully" };
   }
 }
@@ -82,16 +85,101 @@ export const definitions = getDefinitionsForClass({
 });
 ```
 
+## Quick Start
+
+1. Install the library and its peer dependency:
+
+```bash
+npm install ts-forge @forge/resolver
+```
+
+1. Configure TypeScript (see [TypeScript Configuration](#typescript-configuration))
+2. Create a resolver class:
+
+```ts
+import { Resolver, ResolverFn } from "ts-forge";
+import { Request } from "@forge/resolver";
+
+@Resolver()
+class MyResolver {
+  @ResolverFn("say-hello")
+  async sayHello(req: Request) {
+    return { message: "Hello from ts-forge!" };
+  }
+}
+```
+
+1. Export definitions in any file you want, for example `src/resolvers/index.ts`:
+
+```ts
+import { getDefinitionsForClass } from "ts-forge";
+import MyResolver from "./MyResolver";
+
+export const handler = getDefinitionsForClass({
+  resolvers: [MyResolver]
+});
+```
+
+1. Define your Forge function in your manifest.yml:
+
+```yml
+modules:
+  function:
+    - key: resolver-function
+      handler: resolvers/index.handler
+```
+
+1. Use in your Forge app's UI by invoking the resolver function:
+
+```ts
+import { invoke } from "@forge/bridge";
+
+async function callHelloResolver() {
+  const response = await invoke("resolver-function", {
+    key: "say-hello"
+  });
+
+  console.log(response.message); // "Hello from ts-forge!"
+}
+```
+
 ## Installation
 
 This is a Node.js module available on npm. Make sure you have `@forge/resolver` installed as well, since this library uses it under the hood. The minimum version of `@forge/resolver` required is `^1.6.0`.
 
 ```bash
-npm install ts-forge
+npm install ts-forge @forge/resolver
+```
+
+Or if you're using yarn:
+
+```bash
+yarn add ts-forge @forge/resolver
+```
+
+Or if you're using pnpm:
+
+```bash
+pnpm add ts-forge @forge/resolver
+```
+
+## TypeScript Configuration
+
+To use decorators in TypeScript, you need to enable experimental decorators in your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
 ```
 
 ## @Resolver
 
+The `@Resolver` decorator is used to mark a class as a resolver. You can optionally provide configuration for middlewares and error handlers that will apply to all resolver functions in the class.
+
 ```ts
 import { Resolver, ResolverFn } from "ts-forge";
 
@@ -112,10 +200,12 @@ Parameter 1 (Resolver config) - Optional
 - `middlewares: ((request: Request) => any | Promise<any>)[]`
   - Optional
   - This is an array of middleware functions, each function will be called before the resolver function
-  - If you return a value it will be sent to the frontend, pending middlewares and resolver function won't be called
+  - If a middleware returns a value, it will be sent to the frontend and pending middlewares and the resolver function won't be called
 
 ## @ResolverFn
 
+The `@ResolverFn` decorator is used to mark a method as a resolver function. Each decorated method will be registered as a resolver that can be invoked from your Forge app's frontend.
+
 ```ts
 import { Request } from "@forge/resolver";
 import { Resolver, ResolverFn } from "ts-forge";
@@ -133,7 +223,7 @@ class HelloWorldResolver {
 
 **Parameter 1 (Resolver key or resolver function config) - Required**
 
-You could use either, a string or an object
+You can use either a string or an object.
 
 **Resolver key**
 
@@ -150,23 +240,25 @@ You could use either, a string or an object
   - `middlewares: ((request: Request) => any | Promise<any>)[]`
     - Optional
     - This is an array of middleware functions, each function will be called before the resolver function
-    - If you return a value it will be sent to the frontend, pending middlewares and resolver function won't be called
+    - If a middleware returns a value, it will be sent to the frontend and pending middlewares and the resolver function won't be called
   - `errorHandler: (error: any, request: Request) => any | Promise<any>`
     - Optional
     - If an error is thrown in your resolver function or middlewares, this function will be called so that you can handle the error and return a response
 
-The `@ResolverFn()` decorator takes only one argument, which can be either a string or an object
-If you don't need to define middlewares or an error handler, you could just pass the resolver key
+The `@ResolverFn()` decorator takes only one argument, which can be either a string or an object.
+If you don't need to define middlewares or an error handler, you can just pass the resolver key:
 
 ```ts
 @Resolver()
 class HelloWorldResolver {
   @ResolverFn("my-resolver")
-  async hello(req: Request) {}
+  async hello(req: Request) {
+    return { message: "Hello!" };
+  }
 }
 ```
 
-or, if you need to define middlewares or an error handler for that resolver function, you could pass a config object like this:
+Or, if you need to define middlewares or an error handler for that resolver function, you can pass a config object like this:
 
 ```ts
 @Resolver()
@@ -176,38 +268,42 @@ class HelloWorldResolver {
     middlewares: [authMiddleware, adminMiddleware],
     errorHandler: myErrorHandler
   })
-  async hello(req: Request) {}
+  async hello(req: Request) {
+    return { message: "Hello!" };
+  }
 }
 ```
 
 ## getDefinitionsForClass
 
-This function is used to get definitions of the resolvers that you created, it uses `@forge/resolver` under the hood to define resolvers then calls `getDefinitions()` method and returns its result
+This function is used to get definitions of the resolvers that you created. It uses `@forge/resolver` under the hood to define resolvers, then calls `getDefinitions()` method and returns its result. The returned value should be exported as the `handler` for your Forge function.
 
 ```ts
 import { getDefinitionsForClass } from "ts-forge";
 
-getDefinitionsForClass({
+const handler = getDefinitionsForClass({
   resolvers: [HelloWorldResolver, GetJiraProjectResolver],
-  errorHandler: ErrorHandlerFn,
-  middlewares: MiddlewareFn[]
+  errorHandler: myErrorHandler,
+  middlewares: [authMiddleware]
 });
+
+export { handler };
 ```
 
 #### Parameters
 
 **Parameter 1 (Config) - Required**
 
-- `{ resolvers: [], middlewares: MiddlewareFn[], errorHandler: ErrorHandlerFn }`
+- `{ resolvers: [], middlewares?: MiddlewareFn[], errorHandler?: ErrorHandlerFn }`
   - `resolvers`
     - Required
-    - This is an array of class instances in which you used the `@Resolver()` decorator
+    - This is an array of classes (not instances) that have been decorated with `@Resolver()`
     - Must have at least one element
   - `middlewares: ((request: Request) => any | Promise<any>)[]`
     - Optional
     - This is an array of middleware functions, each function will be called before the resolver function
-    - If you return a value it will be sent to the frontend, pending middlewares and resolver function won't be called
-    - Those middlewares will be called before each resolver function defined in `resolvers`
+    - If a middleware returns a value, it will be sent to the frontend and pending middlewares and the resolver function won't be called
+    - These middlewares will be called before each resolver function defined in `resolvers`
     - **Note:** Middlewares defined here will be the last to be called, in case you have defined middlewares in `@Resolver()` or `@ResolverFn()`
   - `errorHandler: (error: any, request: Request) => any | Promise<any>`
     - Optional
@@ -215,32 +311,57 @@ getDefinitionsForClass({
     - This function will handle errors for all the resolver functions defined in `resolvers`
     - **Note:** This function will be called only when an error handler was not defined in `@Resolver()` and `@ResolverFn()`
 
+#### Return Value
+
+Returns the definitions object that should be exported for use in your Forge manifest. This object contains all the resolver function definitions that can be invoked from your Forge app's frontend.
+
 ## Middlewares
 
-You can define middlewares in `@ResolverFn()`, `@Resolver()` and `getDefinitionsForClass()`. It only takes one parameter which is the same request object you have access to in resolver functions
+You can define middlewares in `@ResolverFn()`, `@Resolver()` and `getDefinitionsForClass()`. Each middleware takes one parameter which is the same request object you have access to in resolver functions.
 
-Middleware functions have priority depending where they were defined. When a resolver function is invoked, the middlewares will be called in the following order:
+Middleware functions have priority depending on where they were defined. When a resolver function is invoked, the middlewares will be called in the following order:
 
 1. `@ResolverFn()`: Middlewares defined in this decorator's config will be the first to be called
 2. `@Resolver()`: Middlewares defined in this decorator's config will run after `@ResolverFn()`'s middlewares are called. If no middlewares were defined in `@ResolverFn()`, middlewares defined in `@Resolver()` would be the first to be called
-3. `getDefinitionsForClass()`: Middlewares defined in this function will be the last to be called. If no middlewares were defined in `@ResolverFn()` and `@Resolver()`, middlewares defined in `getDefinitionsForClass()` would be the first to be called, this is useful when you want the same middlewares to be called for all of your resolver functions, so that you don't have to define the same middlewares in each `@ResolverFn()` or `@Resolver()`
+3. `getDefinitionsForClass()`: Middlewares defined in this function will be the last to be called. If no middlewares were defined in `@ResolverFn()` and `@Resolver()`, middlewares defined in `getDefinitionsForClass()` would be the first to be called. This is useful when you want the same middlewares to be called for all of your resolver functions, so that you don't have to define the same middlewares in each `@ResolverFn()` or `@Resolver()`
+
+**Important**: If a middleware returns a value, that value will be sent to the frontend immediately and any pending middlewares and the resolver function will not be executed. If a middleware should just perform checks or logging without stopping execution, it should not return anything.
 
 #### Usage
 
-This is an example of a middleware function
+This is an example of a middleware function that returns early (blocking execution):
 
 ```ts
 import { Request } from "@forge/resolver";
 
-// Request is the same object you have access to in your resolver functions
+// This middleware returns a value, stopping execution if user is not admin
 function verifyUserIsJiraAdmin(request: Request): any | Promise<any> {
-  // Verify that the current user is a jira admin ...
+  const isAdmin = checkIfUserIsAdmin(request.context.accountId);
+
+  if (!isAdmin) {
+    // Returning a value stops execution
+    return { error: "Unauthorized", message: "Admin access required" };
+  }
+
+  // Not returning anything allows execution to continue
 }
 ```
 
-Then you can use this middleware in `@ResolverFn()`, `@Resolver()` or `getDefinitionsForClass()`
+Example of a middleware that doesn't return (passes through):
 
-In the following example the `verifyUserIsJiraAdmin` middleware is used in `@ResolverFn()`. This is useful when you want certain middleware to be called for some resolver functions
+```ts
+import { Request } from "@forge/resolver";
+
+// This middleware logs but doesn't return, so execution continues
+function loggingMiddleware(request: Request): void {
+  console.log(`Resolver called: ${request.payload?.action}`);
+  // No return statement - execution continues to next middleware/resolver
+}
+```
+
+Then you can use these middlewares in `@ResolverFn()`, `@Resolver()` or `getDefinitionsForClass()`.
+
+In the following example the `verifyUserIsJiraAdmin` middleware is used in `@ResolverFn()`. This is useful when you want certain middleware to be called for specific resolver functions:
 
 ```ts
 @Resolver()
@@ -254,21 +375,18 @@ class HelloWorldResolver {
   }
 
   // verifyUserIsJiraAdmin won't be called when this resolver function is invoked
-  @ResolverFn({
-    key: "get-current-user",
-    middlewares: []
-  })
+  @ResolverFn("get-current-user")
   async getCurrentUser() {
     // Return current user
   }
 }
 ```
 
-In this example the `verifyUserIsJiraAdmin` middleware is used in `@Resolver()`. Middlewares defined in this decorator will be called for all resolver functions defined in the class.
+In this example the `verifyUserIsJiraAdmin` middleware is used in `@Resolver()`. Middlewares defined in this decorator will be called for all resolver functions defined in the class:
 
 ```ts
 @Resolver({
-  // Middlewares defined in this array will be called in each resolver function defined in this class
+  // Middlewares defined in this array will be called for each resolver function defined in this class
   middlewares: [verifyUserIsJiraAdmin]
 })
 class HelloWorldResolver {
@@ -286,7 +404,7 @@ class HelloWorldResolver {
 }
 ```
 
-Last but not least, you can define middlewares in the `getDefinitionsForClass` function. Middlewares defined here will be called in all resolvers that you pass to the `resolvers` array
+Last but not least, you can define middlewares in the `getDefinitionsForClass` function. Middlewares defined here will be called for all resolvers that you pass to the `resolvers` array:
 
 ```ts
 @Resolver()
@@ -305,12 +423,12 @@ class UserResolver {
   }
 }
 
-const definitions = getDefinitionsForClass({
+const handler = getDefinitionsForClass({
   middlewares: [verifyUserIsJiraAdmin],
   // Middlewares will be called before each resolver function, you don't need to add the verifyUserIsJiraAdmin middleware
   // in @Resolver or @ResolverFn decorators
   resolvers: [HelloWorldResolver, UserResolver]
-})
+});
 ```
 
 ## Error handler
@@ -322,13 +440,13 @@ When an error is thrown, the error handler will be called with the error and the
 When an error is thrown, the error handler will be called in the following order:
 
 1. If an error handler is defined in the `@ResolverFn()` decorator, it will be called
-2. Error handler defined in `@Resolver()`, will be called when an error handler was not defined in `@ResolverFn()`
+2. Error handler defined in `@Resolver()` will be called when an error handler was not defined in `@ResolverFn()`
 3. If no error handler was defined in `@ResolverFn()` and `@Resolver()`, the error handler defined in `getDefinitionsForClass()` will be called
 4. If no error handler was defined in any of the above, the error will be logged to the console and will be returned to the frontend
 
 #### Usage
 
-This is an example of an error handler function
+This is an example of an error handler function:
 
 ```ts
 import { Request } from "@forge/resolver";
@@ -341,8 +459,9 @@ function myErrorHandler(error: any, request: Request): any | Promise<any> {
 }
 ```
 
-Then you can use this error handler in `@ResolverFn()`, `@Resolver()` or `getDefinitionsForClass()`
-In the following example the `myErrorHandler` error handler is used in `@ResolverFn()`. This is useful when you want certain error handler to be called for some resolver functions
+Then you can use this error handler in `@ResolverFn()`, `@Resolver()` or `getDefinitionsForClass()`.
+
+In the following example the `myErrorHandler` error handler is used in `@ResolverFn()`. This is useful when you want a specific error handler to be called for some resolver functions:
 
 ```ts
 @Resolver()
@@ -363,11 +482,11 @@ class HelloWorldResolver {
 }
 ```
 
-In this example the `myErrorHandler` error handler is used in `@Resolver()`. Error handlers defined in this decorator will be called for all resolver functions defined in the class.
+In this example the `myErrorHandler` error handler is used in `@Resolver()`. Error handlers defined in this decorator will be called for all resolver functions defined in the class:
 
 ```ts
 @Resolver({
-  // Error handler defined in this function will be called if an error is thrown in any of the resolver functions defined in this class
+  // Error handler defined in this decorator will be called if an error is thrown in any of the resolver functions defined in this class
   errorHandler: myErrorHandler
 })
 class HelloWorldResolver {
@@ -385,7 +504,7 @@ class HelloWorldResolver {
 }
 ```
 
-Last but not least, you can define an error handler in the `getDefinitionsForClass` function. Error handlers defined here will be called if an error is thrown in any of the resolvers that you pass to the `resolvers` array.
+Last but not least, you can define an error handler in the `getDefinitionsForClass` function. Error handlers defined here will be called if an error is thrown in any of the resolvers that you pass to the `resolvers` array:
 
 ```ts
 @Resolver()
@@ -404,10 +523,219 @@ class UserResolver {
   }
 }
 
-const definitions = getDefinitionsForClass({
+const handler = getDefinitionsForClass({
   errorHandler: myErrorHandler,
   // Error handler will be called if an error is thrown in any of the resolver functions
   // You don't need to add the myErrorHandler error handler in @Resolver or @ResolverFn decorators
   resolvers: [HelloWorldResolver, UserResolver]
 });
 ```
+
+## Frontend Usage
+
+After defining your resolvers and exporting the handler, you can invoke them from your Forge app's frontend using the `invoke()` method from `@forge/bridge`.
+
+**Backend (src/resolvers/index.ts):**
+
+```ts
+import { getDefinitionsForClass, Resolver, ResolverFn } from "ts-forge";
+import { Request } from "@forge/resolver";
+
+@Resolver()
+class UserResolver {
+  @ResolverFn("get-user")
+  async getUser(req: Request) {
+    const userId = req.payload.userId;
+    // Fetch user logic...
+    return { id: userId, name: "John Doe" };
+  }
+
+  @ResolverFn("update-user")
+  async updateUser(req: Request) {
+    const { userId, name } = req.payload;
+    // Update user logic...
+    return { success: true, message: "User updated" };
+  }
+}
+
+export const handler = getDefinitionsForClass({
+  resolvers: [UserResolver]
+});
+```
+
+**Frontend (src/index.tsx or src/index.jsx):**
+
+```tsx
+import React, { useState, useEffect } from "react";
+import { invoke } from "@forge/bridge";
+
+function App() {
+  const [user, setUser] = useState(null);
+
+  useEffect(() => {
+    // Invoke the "get-user" resolver
+    invoke("get-user", { userId: "123" })
+      .then((response) => {
+        setUser(response);
+      })
+      .catch((error) => {
+        console.error("Error fetching user:", error);
+      });
+  }, []);
+
+  const handleUpdateUser = async () => {
+    try {
+      // Invoke the "update-user" resolver
+      const response = await invoke("update-user", {
+        userId: "123",
+        name: "Jane Doe"
+      });
+      console.log(response.message);
+    } catch (error) {
+      console.error("Error updating user:", error);
+    }
+  };
+
+  return (
+    <div>
+      {user && (
+        <>
+          <h1>{user.name}</h1>
+          <button onClick={handleUpdateUser}>Update User</button>
+        </>
+      )}
+    </div>
+  );
+}
+
+export default App;
+```
+
+## Complete Example
+
+Here's a complete example showing all features together:
+
+**src/middlewares/auth.ts:**
+
+```ts
+import { Request } from "@forge/resolver";
+
+export function authMiddleware(request: Request) {
+  const accountId = request.context.accountId;
+
+  if (!accountId) {
+    return { error: "Unauthorized", message: "User not authenticated" };
+  }
+  // Don't return anything to continue execution
+}
+
+export function adminMiddleware(request: Request) {
+  // Check if user is admin
+  const isAdmin = checkIfUserIsAdmin(request.context.accountId);
+
+  if (!isAdmin) {
+    return { error: "Forbidden", message: "Admin access required" };
+  }
+}
+```
+
+**src/handlers/errorHandler.ts:**
+
+```ts
+import { Request } from "@forge/resolver";
+
+export function globalErrorHandler(error: any, request: Request) {
+  console.error("Error in resolver:", error);
+
+  // Log to external service
+  logErrorToService(error, request.context);
+
+  return {
+    success: false,
+    error: "An unexpected error occurred",
+    message: error.message
+  };
+}
+```
+
+**src/resolvers/UserResolver.ts:**
+
+```ts
+import { Resolver, ResolverFn } from "ts-forge";
+import { Request } from "@forge/resolver";
+import { authMiddleware, adminMiddleware } from "../middlewares/auth";
+
+@Resolver({
+  middlewares: [authMiddleware]
+})
+class UserResolver {
+  @ResolverFn("get-current-user")
+  async getCurrentUser(req: Request) {
+    const accountId = req.context.accountId;
+    // Fetch user from API
+    return { id: accountId, name: "John Doe" };
+  }
+
+  @ResolverFn({
+    key: "delete-user",
+    middlewares: [adminMiddleware] // Additional middleware for this resolver
+  })
+  async deleteUser(req: Request) {
+    const userId = req.payload.userId;
+    // Delete user logic
+    return { success: true, message: `User ${userId} deleted` };
+  }
+}
+
+export default UserResolver;
+```
+
+**src/resolvers/ProjectResolver.ts:**
+
+```ts
+import { Resolver, ResolverFn } from "ts-forge";
+import { Request } from "@forge/resolver";
+
+@Resolver()
+class ProjectResolver {
+  @ResolverFn("get-projects")
+  async getProjects(req: Request) {
+    // Fetch projects
+    return { projects: [] };
+  }
+}
+
+export default ProjectResolver;
+```
+
+**src/resolvers/index.ts:**
+
+```ts
+import { getDefinitionsForClass } from "ts-forge";
+import UserResolver from "./UserResolver";
+import ProjectResolver from "./ProjectResolver";
+import { globalErrorHandler } from "../handlers/errorHandler";
+
+export const handler = getDefinitionsForClass({
+  resolvers: [UserResolver, ProjectResolver],
+  errorHandler: globalErrorHandler
+});
+```
+
+**manifest.yml:**
+
+```yml
+modules:
+  function:
+    - key: resolver-function
+      handler: resolvers/index.handler
+  jira:issuePanel:
+    - key: my-issue-panel
+      function: resolver-function
+      title: My Issue Panel
+      icon: https://example.com/icon.png
+```
+
+## License
+
+MIT

package/dist/decorators/resolver.js

@@ -15,8 +15,7 @@ import _ from "../constants";
  * class MyResolver{}
  * ```
  */
-export function Resolver(config) {
-    if (config === void 0) { config = { middlewares: [], errorHandler: undefined }; }
+export function Resolver(config = { middlewares: [], errorHandler: undefined }) {
     return function (constructor) {
         constructor.prototype[_.RESOLVER_CONFIG] = {
             middlewares: Array.from(config.middlewares || []),

package/dist/decorators/resolverFn.js

@@ -7,33 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import isResolverFnConfig from "../utils/isResolverFnConfig";
 import _ from "../constants";
 /**
@@ -46,7 +19,7 @@ import _ from "../constants";
 export function ResolverFn(resolverFnConfig) {
     return function (target, propertyKey, descriptor) {
         // Handle the case where resolverFnConfig is a string
-        var config = isResolverFnConfig(resolverFnConfig)
+        const config = isResolverFnConfig(resolverFnConfig)
             ? resolverFnConfig
             : { key: resolverFnConfig, middlewares: [], errorHandler: undefined };
         // If the middlewares property is not an array, initialize it as an empty array
@@ -59,76 +32,61 @@ export function ResolverFn(resolverFnConfig) {
         }
         // Add the resolver's data to the target
         target[_.RESOLVER_FUNCTIONS].push({
-            config: config,
+            config,
             methodName: propertyKey
         });
-        var method = descriptor.value;
+        const method = descriptor.value;
         descriptor.value = function (req) {
-            return __awaiter(this, void 0, void 0, function () {
-                var targetConfig, middlewares, _i, middlewares_1, middleware, response, error_1, errorHandlerFn, err_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            targetConfig = this[_.RESOLVER_CONFIG] || {};
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 7, , 12]);
-                            middlewares = Array.from((config === null || config === void 0 ? void 0 : config.middlewares) || []);
-                            // If there are middlewares defined in the resolver class, add them to the middlewares array
-                            if (Array.isArray(targetConfig.middlewares)) {
-                                middlewares.push.apply(middlewares, targetConfig.middlewares);
-                            }
-                            // If there are middlewares defined in the getDefinitionsForClass config, add them to the middlewares array
-                            if (Array.isArray(targetConfig.globalMiddlewares)) {
-                                middlewares.push.apply(middlewares, targetConfig.globalMiddlewares);
-                            }
-                            _i = 0, middlewares_1 = middlewares;
-                            _a.label = 2;
-                        case 2:
-                            if (!(_i < middlewares_1.length)) return [3 /*break*/, 5];
-                            middleware = middlewares_1[_i];
-                            return [4 /*yield*/, middleware(req)];
-                        case 3:
-                            response = _a.sent();
-                            // If response is provided, send it to the frontend
-                            // This means that the resolver or next middleware will not be called
-                            if (response) {
-                                return [2 /*return*/, response];
-                            }
-                            _a.label = 4;
-                        case 4:
-                            _i++;
-                            return [3 /*break*/, 2];
-                        case 5: return [4 /*yield*/, method.call(this, req)];
-                        case 6: 
-                        // Call the original method
-                        return [2 /*return*/, _a.sent()];
-                        case 7:
-                            error_1 = _a.sent();
-                            errorHandlerFn = config.errorHandler || (targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.errorHandler) || (targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.globalErrorHandler);
-                            if (!errorHandlerFn) return [3 /*break*/, 11];
-                            _a.label = 8;
-                        case 8:
-                            _a.trys.push([8, 10, , 11]);
+            return __awaiter(this, void 0, void 0, function* () {
+                const targetConfig = this[_.RESOLVER_CONFIG] || {};
+                try {
+                    // Merge middlewares from the resolver function and the resolver class
+                    // Method middlewares are always executed first
+                    const middlewares = Array.from((config === null || config === void 0 ? void 0 : config.middlewares) || []);
+                    // If there are middlewares defined in the resolver class, add them to the middlewares array
+                    if (Array.isArray(targetConfig.middlewares)) {
+                        middlewares.push(...targetConfig.middlewares);
+                    }
+                    // If there are middlewares defined in the getDefinitionsForClass config, add them to the middlewares array
+                    if (Array.isArray(targetConfig.globalMiddlewares)) {
+                        middlewares.push(...targetConfig.globalMiddlewares);
+                    }
+                    // Run provided middlewares
+                    for (const middleware of middlewares) {
+                        const response = yield middleware(req);
+                        // If response is provided, send it to the frontend
+                        // This means that the resolver or next middleware will not be called
+                        if (response) {
+                            return response;
+                        }
+                    }
+                    // Call the original method
+                    return yield method.call(this, req);
+                }
+                catch (error) {
+                    // Resolver function error handler has priority over the resolver error handler
+                    const errorHandlerFn = config.errorHandler || (targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.errorHandler) || (targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.globalErrorHandler);
+                    // If an error handler is provided, call it with the request data and error object
+                    // This allows the error handler to handle the error and return a response
+                    if (errorHandlerFn) {
+                        try {
                             req.context.resolver = {
                                 key: config.key,
                                 className: target.constructor.name,
                                 methodName: propertyKey
                             };
-                            return [4 /*yield*/, errorHandlerFn(error_1, req)];
-                        case 9: return [2 /*return*/, _a.sent()];
-                        case 10:
-                            err_1 = _a.sent();
+                            return yield errorHandlerFn(error, req);
+                        }
+                        catch (err) {
                             // If the error handler throws an error, log it and return the original error
-                            console.error(err_1);
-                            return [2 /*return*/, error_1];
-                        case 11:
-                            // If no error handler is provided, log the error, then return it
-                            console.error(error_1);
-                            return [2 /*return*/, error_1];
-                        case 12: return [2 /*return*/];
+                            console.error(err);
+                            return error;
+                        }
                     }
-                });
+                    // If no error handler is provided, log the error, then return it
+                    console.error(error);
+                    return error;
+                }
             });
         };
     };

package/dist/utils/getDefinitionsForClass.js

@@ -8,23 +8,21 @@ import _ from "../constants";
  * @param config.errorHandler - Custom error handler to be applied to the provided resolvers
  * @returns - Resolver definitions
  */
-export function getDefinitionsForClass(_a) {
-    var resolvers = _a.resolvers, _b = _a.middlewares, middlewares = _b === void 0 ? [] : _b, errorHandler = _a.errorHandler;
-    var forgeResolver = new ForgeResolver();
+export function getDefinitionsForClass({ resolvers, middlewares = [], errorHandler }) {
+    const forgeResolver = new ForgeResolver();
     if (!Array.isArray(middlewares)) {
         throw new Error("Middlewares must be an array");
     }
-    if (middlewares.length > 0 && !middlewares.every(function (m) { return typeof m === "function"; })) {
+    if (middlewares.length > 0 && !middlewares.every((m) => typeof m === "function")) {
         throw new Error("All middlewares must be functions");
     }
     if (errorHandler && typeof errorHandler !== "function") {
         throw new Error("Error handler must be a function");
     }
-    for (var _i = 0, resolvers_1 = resolvers; _i < resolvers_1.length; _i++) {
-        var instance = resolvers_1[_i];
+    for (const instance of resolvers) {
         if (instance[_.RESOLVER_CONFIG]) {
             // Set global middlewares and error handler for the resolver class
-            var instanceConfig = {
+            const instanceConfig = {
                 middlewares: Array.from(instance[_.RESOLVER_CONFIG].middlewares || []),
                 errorHandler: instance[_.RESOLVER_CONFIG].errorHandler
             };
@@ -34,8 +32,7 @@ export function getDefinitionsForClass(_a) {
             // Set the updated config on the instance
             instance[_.RESOLVER_CONFIG] = instanceConfig;
         }
-        for (var _c = 0, _d = instance[_.RESOLVER_FUNCTIONS]; _c < _d.length; _c++) {
-            var resolver = _d[_c];
+        for (const resolver of instance[_.RESOLVER_FUNCTIONS]) {
             forgeResolver.define(resolver.config.key, instance[resolver.methodName].bind(instance));
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-forge",
-  "version": "1.0.2",
+  "version": "2.0.0-beta.0",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest --run --coverage",
@@ -16,7 +16,9 @@
   "keywords": [
     "forge",
     "atlassian",
-    "addon"
+    "addon",
+    "ts-forge",
+    "resolvers"
   ],
   "author": "Gustavo Velazquez",
   "license": "ISC",
@@ -26,10 +28,10 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.0",
-    "@vitest/coverage-v8": "4.0.8",
-    "@vitest/ui": "4.0.8",
-    "jsdom": "^27.1.0",
-    "typescript": "5.9.3",
-    "vitest": "^4.0.8"
+    "@vitest/coverage-v8": "4.1.2",
+    "@vitest/ui": "4.1.2",
+    "jsdom": "^29.0.1",
+    "typescript": "6.0.2",
+    "vitest": "^4.1.2"
   }
-}
+}