ts-forge 2.0.0 → 2.1.0-beta.0

package/dist/decorators/resolver.d.ts

@@ -1,20 +1,4 @@
 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/resolverFn.d.ts

@@ -1,9 +1,2 @@
 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/index.min.js

@@ -0,0 +1 @@
+import r from"../constants";export function Resolver(e={middlewares:[],errorHandler:void 0}){return function(o){o.prototype[r.RESOLVER_CONFIG]={middlewares:Array.from(e.middlewares||[]),errorHandler:e.errorHandler}}}var e=this&&this.__awaiter||function(r,e,o,n){return new(o||(o=Promise))(function(t,i){function a(r){try{s(n.next(r))}catch(r){i(r)}}function l(r){try{s(n.throw(r))}catch(r){i(r)}}function s(r){var e;r.done?t(r.value):(e=r.value,e instanceof o?e:new o(function(r){r(e)})).then(a,l)}s((n=n.apply(r,e||[])).next())})};import o from"../utils/isResolverFnConfig";import r from"../constants";export function ResolverFn(n){return function(t,i,a){const l=o(n)?n:{key:n,middlewares:[],errorHandler:void 0};Array.isArray(l.middlewares)||(l.middlewares=[]),t[r.RESOLVER_FUNCTIONS]||(t[r.RESOLVER_FUNCTIONS]=[]),t[r.RESOLVER_FUNCTIONS].push({config:l,methodName:i});const s=a.value;a.value=function(o){return e(this,void 0,void 0,function*(){const e=this[r.RESOLVER_CONFIG]||{};try{const r=Array.from((null==l?void 0:l.middlewares)||[]);Array.isArray(e.middlewares)&&r.push(...e.middlewares),Array.isArray(e.globalMiddlewares)&&r.push(...e.globalMiddlewares);for(const e of r){const r=yield e(o);if(r)return r}return yield s.call(this,o)}catch(r){const n=l.errorHandler||(null==e?void 0:e.errorHandler)||(null==e?void 0:e.globalErrorHandler);if(n)try{return o.context.resolver={key:l.key,className:t.constructor.name,methodName:i},yield n(r,o)}catch(e){return console.error(e),r}return console.error(r),r}})}}}export{};export*from"./forge";export*from"./resolver";export*from"./utils";export{};export{};import n from"@forge/resolver";import r from"../constants";export function getDefinitionsForClass({resolvers:e,middlewares:o=[],errorHandler:t}){const i=new n;if(!Array.isArray(o))throw new Error("Middlewares must be an array");if(o.length>0&&!o.every(r=>"function"==typeof r))throw new Error("All middlewares must be functions");if(t&&"function"!=typeof t)throw new Error("Error handler must be a function");for(const n of e){if(n[r.RESOLVER_CONFIG]){const e={middlewares:Array.from(n[r.RESOLVER_CONFIG].middlewares||[]),errorHandler:n[r.RESOLVER_CONFIG].errorHandler};e.globalMiddlewares=Array.from(o),e.globalErrorHandler=t,n[r.RESOLVER_CONFIG]=e}for(const e of n[r.RESOLVER_FUNCTIONS])i.define(e.config.key,n[e.methodName].bind(n))}return i.getDefinitions()}export default function o(r){return"object"==typeof r&&"string"==typeof(null==r?void 0:r.key)&&(void 0===r.middlewares||Array.isArray(r.middlewares))&&(void 0===r.errorHandler||"function"==typeof r.errorHandler)}

package/dist/utils/getDefinitionsForClass.d.ts

@@ -1,10 +1,2 @@
 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/package.json

@@ -1,12 +1,17 @@
 {
   "name": "ts-forge",
-  "version": "2.0.0",
-  "main": "dist/index.js",
+  "version": "2.1.0-beta.0",
+  "main": "dist/index.min.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.d.ts",
+    "dist/index.min.js"
+  ],
   "scripts": {
     "test": "vitest --run --coverage",
     "test:ui": "vitest --ui --coverage",
     "dev": "tsc -p ./tsconfig.json --watch",
-    "build": "eval $(rm -r dist) && tsc -p ./tsconfig.json",
+    "build": "./scripts/build.sh",
     "prepublish": "npm run build"
   },
   "repository": {
@@ -31,7 +36,8 @@
     "@vitest/coverage-v8": "4.1.2",
     "@vitest/ui": "4.1.2",
     "jsdom": "^29.0.1",
+    "terser": "^5.46.1",
     "typescript": "6.0.2",
     "vitest": "^4.1.2"
   }
-}
+}

package/CHANGELOG.md

@@ -1,39 +0,0 @@
-## 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
-
-## v1.0.1
-
-- This version contains changes from the following beta versions:
-  - `v1.0.1-beta.0`
-  - `v1.0.1-beta.1`
-- Github actions:
-  - workflow to publish stable and beta versions were created
-  - Added a workflow to run tests on development branch
-
-## v1.0.1-beta.1
-
-- Improved type definitions for getDefinitionsForClass function
-
-## v1.0.1-beta.0
-
-- README.md: documentation finished
-- Updated dev dependencies
-- coverage folder was added to .npmignore
-- Improved type definitions for getDefinitionsForClass function
-
-## v1.0.0
-
-- `@Resolver()` and `@ResolverFn()` decorators were created
-- Created `getDefinitionsForClass()` function which handles resolver functions definition
-- Unit testing for decorators and utils

package/dist/constants.js

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

package/dist/decorators/resolver.js

@@ -1,25 +0,0 @@
-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 = { middlewares: [], errorHandler: undefined }) {
-    return function (constructor) {
-        constructor.prototype[_.RESOLVER_CONFIG] = {
-            middlewares: Array.from(config.middlewares || []),
-            errorHandler: config.errorHandler
-        };
-    };
-}

package/dist/decorators/resolverFn.js

@@ -1,93 +0,0 @@
-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());
-    });
-};
-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
-        const 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,
-            methodName: propertyKey
-        });
-        const method = descriptor.value;
-        descriptor.value = function (req) {
-            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 yield errorHandlerFn(error, req);
-                        }
-                        catch (err) {
-                            // If the error handler throws an error, log it and return the original error
-                            console.error(err);
-                            return error;
-                        }
-                    }
-                    // If no error handler is provided, log the error, then return it
-                    console.error(error);
-                    return error;
-                }
-            });
-        };
-    };
-}

package/dist/index.js

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

package/dist/types/forge.js

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

package/dist/types/index.js

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

package/dist/types/resolver.js

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

package/dist/types/utils.js

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

package/dist/utils/getDefinitionsForClass.js

@@ -1,40 +0,0 @@
-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({ 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((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 (const instance of resolvers) {
-        if (instance[_.RESOLVER_CONFIG]) {
-            // Set global middlewares and error handler for the resolver class
-            const 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 (const resolver of instance[_.RESOLVER_FUNCTIONS]) {
-            forgeResolver.define(resolver.config.key, instance[resolver.methodName].bind(instance));
-        }
-    }
-    return forgeResolver.getDefinitions();
-}

package/dist/utils/isResolverFnConfig.js

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