ts-forge 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+## v1.0.0
+
+- `@Resolver()` and `@ResolverFn()` decorators were created
+- Created `getDefinitionsForClass()` function which handles resolver functions definition

package/README.md

@@ -0,0 +1,228 @@
+**Warning:** The first version of this library is ready, however documentation is still in progress
+
+## @Resolver
+
+```ts
+import { Resolver, ResolverFn } from "ts-forge";
+
+@Resolver({
+  middlewares: [authMiddleware, adminMiddleware],
+  errorHandler: myErrorHandler
+})
+class HelloWorldResolver {}
+```
+
+#### Parameters
+
+Parameter 1 (Resolver config) - Optional
+
+- `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
+- `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
+
+## @ResolverFn
+
+```ts
+import { Request } from "@forge/resolver";
+import { Resolver, ResolverFn } from "ts-forge";
+
+@Resolver()
+class HelloWorldResolver {
+  @ResolverFn("my-resolver")
+  public async hello(req: Request) {
+    return { message: "Hello world!" };
+  }
+}
+```
+
+#### Parameters
+
+**Parameter 1 (Resolver key or resolver function config) - Required**
+
+You could use either, a string or an object
+
+**Resolver key**
+
+- `string`
+  - Required
+  - This is the resolver key that you will use when you call `invoke()` method in your addon's UI
+
+**Resolver function config**
+
+- `{ key: string, middlewares?: MiddlewareFn[], errorHandler?: ErrorHandlerFn }`
+  - `key: string`
+    - Required
+    - This is the resolver key that you will use when you call `invoke()` method in your addon's UI
+  - `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
+  - `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
+
+```ts
+@Resolver()
+class HelloWorldResolver {
+  @ResolverFn("my-resolver")
+  async hello(req: Request) {}
+}
+```
+
+or, if you need to define middlewares or an error handler for that resolver function, you could pass a config object like this:
+
+```ts
+@Resolver()
+class HelloWorldResolver {
+  @ResolverFn({
+    key: "my-resolver",
+    middlewares: [authMiddleware, adminMiddleware],
+    errorHandler: myErrorHandler
+  })
+  async hello(req: Request) {}
+}
+```
+
+## 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
+
+```ts
+import { getDefinitionsForClass } from "ts-forge";
+
+getDefinitionsForClass({
+  resolvers: [HelloWorldResolver, GetJiraProjectResolver],
+  errorHandler: ErrorHandlerFn,
+  middlewares: MiddlewareFn[]
+});
+```
+
+#### Parameters
+
+**Parameter 1 (Config) - Required**
+
+- `{ resolvers: [], middlewares: MiddlewareFn[], errorHandler: ErrorHandlerFn }`
+  - `resolvers`
+    - Required
+    - This is an array of class instances in which you used the `@Resolver()` decorator
+    - 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`
+    - **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
+    - 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
+    - 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()`
+
+## 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
+
+Middleware functions have priority depending 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()`
+
+#### Usage
+
+This is an example of a middleware function
+
+```ts
+import { Request } from "@forge/resolver";
+
+// Request is the same object you have access to in your resolver functions
+function verifyUserIsJiraAdmin(request: Request): any | Promise<any> {
+  // Verify that the current user is a jira admin ...
+}
+```
+
+Then you can use this middleware 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 some resolver functions
+
+```ts
+@Resolver()
+class HelloWorldResolver {
+  @ResolverFn({
+    key: "hello-world",
+    middlewares: [verifyUserIsJiraAdmin]
+  })
+  async helloWorld() {
+    // Do whatever this resolver should do
+  }
+
+  // verifyUserIsJiraAdmin won't be called when this resolver function is invoked
+  @ResolverFn({
+    key: "get-current-user",
+    middlewares: []
+  })
+  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.
+
+```ts
+@Resolver({
+  // Middlewares defined in this array will be called in each resolver function defined in this class
+  middlewares: [verifyUserIsJiraAdmin]
+})
+class HelloWorldResolver {
+  // There's no need to add the same middleware in @ResolverFn()
+  @ResolverFn("hello-world")
+  async helloWorld() {
+    // Do whatever this resolver should do
+  }
+
+  // verifyUserIsJiraAdmin will also be called before this resolver function
+  @ResolverFn("get-current-user")
+  async getCurrentUser() {
+    // Return current user
+  }
+}
+```
+
+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
+
+```ts
+@Resolver()
+class HelloWorldResolver {
+  @ResolverFn("hello-world")
+  helloWorld(request: Request) {
+    return { message: "Hello world!" };
+  }
+}
+
+@Resolver()
+class UserResolver {
+  @ResolverFn("get-user")
+  getUser(request: Request) {
+    return {...};
+  }
+}
+
+const definitions = 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
+
+An error handler is a function that is called when an error is thrown in a resolver function

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    RESOLVER_FUNCTIONS: symbol;
+    RESOLVER_CONFIG: symbol;
+};
+export default _default;

package/dist/constants.js

@@ -0,0 +1,4 @@
+export default {
+    RESOLVER_FUNCTIONS: Symbol.for("@@resolver__functions@@"),
+    RESOLVER_CONFIG: Symbol.for("@@resolver__config@@")
+};

package/dist/decorators/resolver.d.ts

@@ -0,0 +1,20 @@
+import { ResolverConfig } from "../types";
+/**
+ * Decorator for defining forge resolvers.
+ * @param ResolverConfig - Configuration object for the resolver.
+ * @param ResolverConfig.middlewares - Array of middleware functions to be applied to the resolver functions.
+ * @param ResolverConfig.errorHandler - Custom error handler function for the resolver functions.
+ * @returns A modified class with resolver configuration.
+ *
+ * @example
+ * ```ts
+ * \@Resolver({
+ *   middlewares: [myMiddleware],
+ *   errorHandler: myErrorHandler,
+ * })
+ * class MyResolver{}
+ * ```
+ */
+export declare function Resolver(config?: ResolverConfig): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => void;

package/dist/decorators/resolver.js

@@ -0,0 +1,26 @@
+import _ from "../constants";
+/**
+ * Decorator for defining forge resolvers.
+ * @param ResolverConfig - Configuration object for the resolver.
+ * @param ResolverConfig.middlewares - Array of middleware functions to be applied to the resolver functions.
+ * @param ResolverConfig.errorHandler - Custom error handler function for the resolver functions.
+ * @returns A modified class with resolver configuration.
+ *
+ * @example
+ * ```ts
+ * \@Resolver({
+ *   middlewares: [myMiddleware],
+ *   errorHandler: myErrorHandler,
+ * })
+ * class MyResolver{}
+ * ```
+ */
+export function Resolver(config) {
+    if (config === void 0) { config = { middlewares: [], errorHandler: undefined }; }
+    return function (constructor) {
+        constructor.prototype[_.RESOLVER_CONFIG] = {
+            middlewares: Array.from(config.middlewares || []),
+            errorHandler: config.errorHandler
+        };
+    };
+}

package/dist/decorators/resolverFn.d.ts

@@ -0,0 +1,9 @@
+import { ResolverFnConfig } from "../types";
+/**
+ * Define a resolver function
+ * @param resolverFnConfig - Resolver function config
+ * @param resolverFnConfig.middlewares - Array of middleware functions to be applied to this resolver function
+ * @param resolverFnConfig.errorHandler - Custom error handler function for this resolver function
+ * @returns - Response
+ */
+export declare function ResolverFn(resolverFnConfig: ResolverFnConfig | string): (target: any, propertyKey: string, descriptor: any) => void;

package/dist/decorators/resolverFn.js

@@ -0,0 +1,135 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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";
+/**
+ * Define a resolver function
+ * @param resolverFnConfig - Resolver function config
+ * @param resolverFnConfig.middlewares - Array of middleware functions to be applied to this resolver function
+ * @param resolverFnConfig.errorHandler - Custom error handler function for this resolver function
+ * @returns - Response
+ */
+export function ResolverFn(resolverFnConfig) {
+    return function (target, propertyKey, descriptor) {
+        // Handle the case where resolverFnConfig is a string
+        var config = isResolverFnConfig(resolverFnConfig)
+            ? resolverFnConfig
+            : { key: resolverFnConfig, middlewares: [], errorHandler: undefined };
+        // If the middlewares property is not an array, initialize it as an empty array
+        if (!Array.isArray(config.middlewares)) {
+            config.middlewares = [];
+        }
+        // Check if the target has the resolverNames property
+        if (!target[_.RESOLVER_FUNCTIONS]) {
+            target[_.RESOLVER_FUNCTIONS] = [];
+        }
+        // Add the resolver's data to the target
+        target[_.RESOLVER_FUNCTIONS].push({
+            config: config,
+            methodName: propertyKey
+        });
+        var 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.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]);
+                            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();
+                            // 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*/];
+                    }
+                });
+            });
+        };
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Resolver } from "./decorators/resolver";
+export { ResolverFn } from "./decorators/resolverFn";
+export { getDefinitionsForClass } from "./utils/getDefinitionsForClass";
+export { RequestError, ErrorHandlerFn, MiddlewareFn } from "./types";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Resolver } from "./decorators/resolver";
+export { ResolverFn } from "./decorators/resolverFn";
+export { getDefinitionsForClass } from "./utils/getDefinitionsForClass";

package/dist/types/forge.d.ts

@@ -0,0 +1,15 @@
+import { ResolverFunction, Request } from "@forge/resolver";
+interface InvokePayload {
+    call: {
+        functionKey: string;
+        payload?: {
+            [key in number | string]: any;
+        };
+        jobId?: string;
+    };
+    context: {
+        [key: string]: any;
+    };
+}
+export type DefinitionsHandler = (payload: InvokePayload, backendRuntimePayload?: Request["payload"]) => Promise<ReturnType<ResolverFunction>>;
+export {};

package/dist/types/forge.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./forge";
+export * from "./resolver";
+export * from "./utils";

package/dist/types/index.js

@@ -0,0 +1,3 @@
+export * from "./forge";
+export * from "./resolver";
+export * from "./utils";

package/dist/types/resolver.d.ts

@@ -0,0 +1,29 @@
+import { Request } from "@forge/resolver";
+export interface ResolverConfig {
+    middlewares?: MiddlewareFn[];
+    errorHandler?: ErrorHandlerFn;
+}
+export interface ResolverClassConfig extends ResolverConfig {
+    globalMiddlewares?: MiddlewareFn[];
+    globalErrorHandler?: ErrorHandlerFn;
+}
+export type MiddlewareFn = (req: Request) => Promise<any> | any;
+export type ErrorHandlerFn = (error: any, req: RequestError) => any;
+export type RequestError = Request & {
+    context: Request["context"] & {
+        resolver: {
+            key: string;
+            className: string;
+            methodName: string;
+        };
+    };
+};
+export interface ResolverFnConfig {
+    key: string;
+    middlewares?: MiddlewareFn[];
+    errorHandler?: ErrorHandlerFn;
+}
+export interface TargetResolverFnConfig {
+    config: ResolverFnConfig;
+    methodName: string;
+}

package/dist/types/resolver.js

@@ -0,0 +1 @@
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,6 @@
+import { MiddlewareFn, ErrorHandlerFn } from "./resolver";
+export interface GetDefinitionsForClassParams {
+    resolvers: any[];
+    middlewares?: MiddlewareFn[];
+    errorHandler?: ErrorHandlerFn;
+}

package/dist/types/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/getDefinitionsForClass.d.ts

@@ -0,0 +1,10 @@
+import { DefinitionsHandler, GetDefinitionsForClassParams } from "@/types";
+/**
+ * Get definitions for the provided resolvers
+ * @param config - Config
+ * @param config.resolvers - Array of resolvers
+ * @param config.middlewares - Array of middlewares to be applied to the provided resolvers
+ * @param config.errorHandler - Custom error handler to be applied to the provided resolvers
+ * @returns - Resolver definitions
+ */
+export declare function getDefinitionsForClass({ resolvers, middlewares, errorHandler }: GetDefinitionsForClassParams): DefinitionsHandler;

package/dist/utils/getDefinitionsForClass.js

@@ -0,0 +1,43 @@
+import ForgeResolver from "@forge/resolver";
+import _ from "../constants";
+/**
+ * Get definitions for the provided resolvers
+ * @param config - Config
+ * @param config.resolvers - Array of resolvers
+ * @param config.middlewares - Array of middlewares to be applied to the provided resolvers
+ * @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();
+    if (!Array.isArray(middlewares)) {
+        throw new Error("Middlewares must be an array");
+    }
+    if (middlewares.length > 0 && !middlewares.every(function (m) { return 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];
+        if (instance[_.RESOLVER_CONFIG]) {
+            // Set global middlewares and error handler for the resolver class
+            var instanceConfig = {
+                middlewares: Array.from(instance[_.RESOLVER_CONFIG].middlewares || []),
+                errorHandler: instance[_.RESOLVER_CONFIG].errorHandler
+            };
+            instanceConfig.globalMiddlewares = Array.from(middlewares);
+            // Set the global error handler
+            instanceConfig.globalErrorHandler = errorHandler;
+            // 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];
+            forgeResolver.define(resolver.config.key, instance[resolver.methodName].bind(instance));
+        }
+    }
+    return forgeResolver.getDefinitions();
+}

package/dist/utils/isResolverFnConfig.d.ts

@@ -0,0 +1,2 @@
+import { ResolverFnConfig } from "../types";
+export default function isResolverFnConfig(config: ResolverFnConfig | string): config is ResolverFnConfig;

package/dist/utils/isResolverFnConfig.js

@@ -0,0 +1,6 @@
+export default function isResolverFnConfig(config) {
+    return (typeof config === "object" &&
+        typeof config.key === "string" &&
+        (typeof config.middlewares === "undefined" || Array.isArray(config.middlewares)) &&
+        (typeof config.errorHandler === "undefined" || typeof config.errorHandler === "function"));
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "ts-forge",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "vitest --run",
+    "test:ui": "vitest --ui",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --run --coverage",
+    "dev": "tsc -p ./tsconfig.json --watch",
+    "build": "eval $(rm -r dist) && tsc -p ./tsconfig.json",
+    "prepublish": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://www.github.com/gustavo0197/ts-forge"
+  },
+  "keywords": [
+    "forge",
+    "atlassian",
+    "addon"
+  ],
+  "author": "Gustavo Velazquez",
+  "license": "ISC",
+  "description": "Decorators for creating resolvers in Atlassian's Forge addons",
+  "peerDependencies": {
+    "@forge/resolver": ">=1.6.0 <2.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "3.1.4",
+    "jsdom": "^26.1.0",
+    "typescript": "5.8.3",
+    "vitest": "^3.1.4"
+  }
+}