ts-forge 1.0.3 → 2.0.0-beta.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## v2.0.0-beta.0
+
+- Resolved warnings from TypeScript 6.0
+
 ## v1.0.3
 
 - README.md: updated documentation

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,25 @@
+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.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,93 @@
+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.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,40 @@
+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.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 === 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"));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-forge",
-  "version": "1.0.3",
+  "version": "2.0.0-beta.0",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest --run --coverage",