@nejs/basic-extensions 2.6.0 → 2.8.0

package/dist/mjs/classes/param.parser.d.ts

@@ -0,0 +1,227 @@
+export class ParamParser {
+    /**
+     * Attempts to parse the given parameters using the provided parsers, throwing an
+     * error if no valid parser is found. This method serves as a convenience wrapper
+     * around `safeTryParsers`, enforcing strict parsing by automatically enabling
+     * error throwing on failure.
+     *
+     * @param {any[]} parameters - The parameters to be parsed.
+     * @param {Function[]} parsers - An array of `ParamParser` subclasses to attempt
+     * parsing with.
+     * @returns {Object} An object containing the parsing result, with a `success`
+     * property indicating if parsing was successful, and a `data` property containing
+     * the parsed data if successful.
+     * @example
+     * const parameters = ['param1', 'param2'];
+     * const parsers = [Parser1, Parser2];
+     * const result = ParamParser.tryParsers(parameters, parsers);
+     * if (result.success) {
+     *   console.log('Parsing successful:', result.data);
+     * } else {
+     *   console.error('Parsing failed.');
+     * }
+     */
+    static tryParsers(parameters: any[], parsers: Function[]): Object;
+    /**
+     * Tries parsing `parameters` with each parser in `parsers`. If
+     * `throwOnFail` is true, throws an error when validation fails or
+     * no valid parser is found.
+     *
+     * This method attempts to parse the given parameters using the
+     * provided list of parsers. It validates the input to ensure both
+     * `parameters` and `parsers` are arrays and that `parsers`
+     * contains at least one valid `ParamParser` subclass. If
+     * `throwOnFail` is set to true, it will throw specific errors for
+     * invalid inputs or when no parser succeeds. Otherwise, it returns
+     * an object indicating the success status and the result of
+     * parsing, if successful.
+     *
+     * @param {any[]} parameters - The parameters to be parsed.
+     * @param {Function[]} parsers - An array of `ParamParser`
+     * subclasses to attempt parsing with.
+     * @param {boolean} [throwOnFail=false] - Whether to throw an
+     * error on failure.
+     * @returns {{success: boolean, data: any}} An object with a
+     * `success` flag and `data` containing the parsing result, if
+     * successful.
+     * @throws {ParametersMustBeArrayError} If `parameters` or
+     * `parsers` are not arrays when `throwOnFail` is true.
+     * @throws {ParsersArrayMustContainParsersError} If `parsers`
+     * does not contain at least one valid `ParamParser` subclass
+     * when `throwOnFail` is true.
+     * @throws {NoValidParsersFound} If no valid parser is found
+     * and `throwOnFail` is true.
+     * @example
+     * const parameters = ['param1', 'param2'];
+     * const parsers = [Parser1, Parser2];
+     * const result = ParamParser.safeTryParsers(
+     *   parameters, parsers, true
+     * );
+     *
+     * if (result.success) {
+     *   console.log('Parsing successful:', result.data);
+     * } else {
+     *   console.error('Parsing failed.');
+     * }
+     */
+    static safeTryParsers(parameters: any[], parsers: Function[], throwOnFail?: boolean | undefined): {
+        success: boolean;
+        data: any;
+    };
+    /**
+     * A custom error class that signifies no valid parsers were found
+     * during the parsing process. This error is thrown when all
+     * parsers fail to parse the given parameters and the `throwOnFail`
+     * flag is set to true in the `safeTryParsers` method.
+     *
+     * @returns {Function} A class extending Error, representing a
+     * specific error when no valid parsers are found.ound.
+     *
+     * @example
+     * try {
+     *   const result = ParamParser.safeTryParsers(
+     *     parameters, parsers, true
+     *   );
+     * } catch (error) {
+     *   if (error instanceof ParamParser.NoValidParsersFound) {
+     *     console.error(
+     *       'No valid parsers could process the parameters.'
+     *     );
+     *   }
+     * }
+     */
+    static get NoValidParsersFound(): Function;
+    /**
+     * Represents an error thrown when the parameters provided to a method
+     * are not in an array format as expected. This class extends the
+     * native JavaScript `Error` class, allowing for instances of this
+     * error to be thrown and caught using standard error handling
+     * mechanisms in JavaScript.
+     *
+     * This error is specifically used in scenarios where a method
+     * expects its arguments to be provided as an array, and the
+     * validation of those arguments fails because they were not
+     * provided in an array format. It serves as a clear indicator
+     * of the nature of the error to developers, enabling them to
+     * quickly identify and rectify the issue in their code.
+     *
+     * @example
+     * try {
+     *   ParamParser.safeTryParsers(nonArrayParameters, parsers, true);
+     * } catch (error) {
+     *   if (error instanceof ParamParser.ParametersMustBeArrayError) {
+     *     console.error('Parameters must be provided as an array.');
+     *   }
+     * }
+     */
+    static get ParametersMustBeArrayError(): {
+        new (message?: string | undefined): {
+            name: string;
+            message: string;
+            stack?: string | undefined;
+            cause?: unknown;
+        };
+        new (message?: string | undefined, options?: ErrorOptions | undefined): {
+            name: string;
+            message: string;
+            stack?: string | undefined;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    /**
+     * A custom error class indicating that the parsers array does not
+     * contain valid parser functions. This error is thrown when the
+     * validation of parsers within `ParamParser.safeTryParsers` fails
+     * to find any instance that is a subclass of `ParamParser`. It
+     * extends the native JavaScript `Error` class, allowing it to be
+     * thrown and caught using standard error handling mechanisms.
+     *
+     * This error serves as a clear indicator to developers that the
+     * provided array of parsers does not meet the expected criteria,
+     * specifically that it must contain at least one valid parser
+     * that extends `ParamParser`. This ensures that the parsing
+     * process can be executed with at least one valid parser function.
+     *
+     * @example
+     * try {
+     *   ParamParser.safeTryParsers(parameters, [], true);
+     * } catch (error) {
+     *   const { ParsersArrayMustContainParsersError } = ParamParser
+     *   if (error instanceof ParsersArrayMustContainParsersError) {
+     *     console.error(
+     *       'The parsers array must contain at least one valid parser.'
+     *     );
+     *   }
+     * }
+     */
+    static get ParsersArrayMustContainParsersError(): {
+        new (message?: string | undefined): {
+            name: string;
+            message: string;
+            stack?: string | undefined;
+            cause?: unknown;
+        };
+        new (message?: string | undefined, options?: ErrorOptions | undefined): {
+            name: string;
+            message: string;
+            stack?: string | undefined;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    /**
+     * Constructs an instance of ParamParser. It takes in parameters, an optional
+     * validator function, and an optional parser function. The parameters are
+     * validated and if successful, parsed.
+     *
+     * @param {any[]} parameters - Arguments passed in by the process.
+     * @param {((any[]) => boolean)?} [validator=() => {}] - An optional function
+     * to specify a validator without subclassing ParamParser. It should return
+     * a boolean indicating the validity of the parameters.
+     * @param {((any[]) => object)?} [parser=() => {}] - An optional function to
+     * specify a parser without subclassing ParamParser. It should return an
+     * object after parsing the input parameters.
+     *
+     * @example
+     * const parameters = ['param1', 'param2']
+     * const validator = params => params.every(param => typeof param === 'string')
+     * const parser = params => ({ params })
+     * const paramParser = new ParamParser(parameters, validator, parser)
+     * if (paramParser.success) {
+     *   console.log('Parsing successful:', paramParser.results)
+     * } else {
+     *   console.error('Parsing failed.')
+     * }
+     */
+    constructor(parameters: any[], validator?: () => void, parser?: () => void);
+    args: any[];
+    parser: () => void;
+    validator: () => void;
+    result: any;
+    success: boolean;
+    results: object | undefined;
+    /**
+     * @param {object} args arguments that were previously validated
+     * by either the overloaded validate() method or the supplied
+     * validator closure.
+     * @returns {object} returns the output object, or an empty
+     * object, after parsing the input arguments or parameters.
+     */
+    parse(args: object): object;
+    /**
+     * Walk the arguments and determine if the supplied input is
+     * a valid parsing.
+     *
+     * @param {any[]} args arguments supplied by the process.
+     * @returns {boolean} `true` if the validation is successful,
+     * `false` otherwise.
+     */
+    validate(args: any[]): boolean;
+}
+export const ParamParserExtensions: Extension;
+import { Extension } from '@nejs/extension';

package/dist/mjs/classes/param.parser.js

@@ -0,0 +1,238 @@
+import { Extension } from '@nejs/extension';
+export class ParamParser {
+    /**
+     * Constructs an instance of ParamParser. It takes in parameters, an optional
+     * validator function, and an optional parser function. The parameters are
+     * validated and if successful, parsed.
+     *
+     * @param {any[]} parameters - Arguments passed in by the process.
+     * @param {((any[]) => boolean)?} [validator=() => {}] - An optional function
+     * to specify a validator without subclassing ParamParser. It should return
+     * a boolean indicating the validity of the parameters.
+     * @param {((any[]) => object)?} [parser=() => {}] - An optional function to
+     * specify a parser without subclassing ParamParser. It should return an
+     * object after parsing the input parameters.
+     *
+     * @example
+     * const parameters = ['param1', 'param2']
+     * const validator = params => params.every(param => typeof param === 'string')
+     * const parser = params => ({ params })
+     * const paramParser = new ParamParser(parameters, validator, parser)
+     * if (paramParser.success) {
+     *   console.log('Parsing successful:', paramParser.results)
+     * } else {
+     *   console.error('Parsing failed.')
+     * }
+     */
+    constructor(parameters, validator = () => { }, parser = () => { }) {
+        this.args = parameters;
+        this.parser = parser;
+        this.validator = validator;
+        this.result = undefined;
+        this.success = this.validate(this.args);
+        if (this.success) {
+            this.results = this.parse(this.args);
+        }
+    }
+    /**
+     * @param {object} args arguments that were previously validated
+     * by either the overloaded validate() method or the supplied
+     * validator closure.
+     * @returns {object} returns the output object, or an empty
+     * object, after parsing the input arguments or parameters.
+     */
+    parse(args) {
+        return this.parser?.(args);
+    }
+    /**
+     * Walk the arguments and determine if the supplied input is
+     * a valid parsing.
+     *
+     * @param {any[]} args arguments supplied by the process.
+     * @returns {boolean} `true` if the validation is successful,
+     * `false` otherwise.
+     */
+    validate(args) {
+        return this.validator?.(args);
+    }
+    /**
+     * Attempts to parse the given parameters using the provided parsers, throwing an
+     * error if no valid parser is found. This method serves as a convenience wrapper
+     * around `safeTryParsers`, enforcing strict parsing by automatically enabling
+     * error throwing on failure.
+     *
+     * @param {any[]} parameters - The parameters to be parsed.
+     * @param {Function[]} parsers - An array of `ParamParser` subclasses to attempt
+     * parsing with.
+     * @returns {Object} An object containing the parsing result, with a `success`
+     * property indicating if parsing was successful, and a `data` property containing
+     * the parsed data if successful.
+     * @example
+     * const parameters = ['param1', 'param2'];
+     * const parsers = [Parser1, Parser2];
+     * const result = ParamParser.tryParsers(parameters, parsers);
+     * if (result.success) {
+     *   console.log('Parsing successful:', result.data);
+     * } else {
+     *   console.error('Parsing failed.');
+     * }
+     */
+    static tryParsers(parameters, parsers) {
+        return this.safeTryParsers(parameters, parsers, true);
+    }
+    /**
+     * Tries parsing `parameters` with each parser in `parsers`. If
+     * `throwOnFail` is true, throws an error when validation fails or
+     * no valid parser is found.
+     *
+     * This method attempts to parse the given parameters using the
+     * provided list of parsers. It validates the input to ensure both
+     * `parameters` and `parsers` are arrays and that `parsers`
+     * contains at least one valid `ParamParser` subclass. If
+     * `throwOnFail` is set to true, it will throw specific errors for
+     * invalid inputs or when no parser succeeds. Otherwise, it returns
+     * an object indicating the success status and the result of
+     * parsing, if successful.
+     *
+     * @param {any[]} parameters - The parameters to be parsed.
+     * @param {Function[]} parsers - An array of `ParamParser`
+     * subclasses to attempt parsing with.
+     * @param {boolean} [throwOnFail=false] - Whether to throw an
+     * error on failure.
+     * @returns {{success: boolean, data: any}} An object with a
+     * `success` flag and `data` containing the parsing result, if
+     * successful.
+     * @throws {ParametersMustBeArrayError} If `parameters` or
+     * `parsers` are not arrays when `throwOnFail` is true.
+     * @throws {ParsersArrayMustContainParsersError} If `parsers`
+     * does not contain at least one valid `ParamParser` subclass
+     * when `throwOnFail` is true.
+     * @throws {NoValidParsersFound} If no valid parser is found
+     * and `throwOnFail` is true.
+     * @example
+     * const parameters = ['param1', 'param2'];
+     * const parsers = [Parser1, Parser2];
+     * const result = ParamParser.safeTryParsers(
+     *   parameters, parsers, true
+     * );
+     *
+     * if (result.success) {
+     *   console.log('Parsing successful:', result.data);
+     * } else {
+     *   console.error('Parsing failed.');
+     * }
+     */
+    static safeTryParsers(parameters, parsers, throwOnFail = false) {
+        if (!Array.isArray(parameters) || !Array.isArray(parsers)) {
+            if (throwOnFail) {
+                throw new this.ParametersMustBeArrayError(`${this.name}.tryParsers must receive two arrays as args`);
+            }
+        }
+        if (!parsers.some(parser => parser?.prototype instanceof ParamParser &&
+            typeof parser === 'function')) {
+            if (throwOnFail) {
+                throw new this.ParsersArrayMustContainParsersError(`${this.name}.tryParsers parsers argument must contain at least one ` +
+                    `ParamParser derived class`);
+            }
+        }
+        let success = false;
+        let result = undefined;
+        for (let Parser of parsers) {
+            const parser = new Parser(parameters);
+            if (parser.success) {
+                success = true;
+                result = parser.result;
+                break;
+            }
+        }
+        if (!success && throwOnFail) {
+            throw new this.NoValidParsersFound('No valid parsers found');
+        }
+        return { success, data: result };
+    }
+    /**
+     * A custom error class that signifies no valid parsers were found
+     * during the parsing process. This error is thrown when all
+     * parsers fail to parse the given parameters and the `throwOnFail`
+     * flag is set to true in the `safeTryParsers` method.
+     *
+     * @returns {Function} A class extending Error, representing a
+     * specific error when no valid parsers are found.ound.
+     *
+     * @example
+     * try {
+     *   const result = ParamParser.safeTryParsers(
+     *     parameters, parsers, true
+     *   );
+     * } catch (error) {
+     *   if (error instanceof ParamParser.NoValidParsersFound) {
+     *     console.error(
+     *       'No valid parsers could process the parameters.'
+     *     );
+     *   }
+     * }
+     */
+    static get NoValidParsersFound() {
+        return class NoValidParsersFound extends Error {
+        };
+    }
+    /**
+     * Represents an error thrown when the parameters provided to a method
+     * are not in an array format as expected. This class extends the
+     * native JavaScript `Error` class, allowing for instances of this
+     * error to be thrown and caught using standard error handling
+     * mechanisms in JavaScript.
+     *
+     * This error is specifically used in scenarios where a method
+     * expects its arguments to be provided as an array, and the
+     * validation of those arguments fails because they were not
+     * provided in an array format. It serves as a clear indicator
+     * of the nature of the error to developers, enabling them to
+     * quickly identify and rectify the issue in their code.
+     *
+     * @example
+     * try {
+     *   ParamParser.safeTryParsers(nonArrayParameters, parsers, true);
+     * } catch (error) {
+     *   if (error instanceof ParamParser.ParametersMustBeArrayError) {
+     *     console.error('Parameters must be provided as an array.');
+     *   }
+     * }
+     */
+    static get ParametersMustBeArrayError() {
+        return class ParametersMustBeArrayError extends Error {
+        };
+    }
+    /**
+     * A custom error class indicating that the parsers array does not
+     * contain valid parser functions. This error is thrown when the
+     * validation of parsers within `ParamParser.safeTryParsers` fails
+     * to find any instance that is a subclass of `ParamParser`. It
+     * extends the native JavaScript `Error` class, allowing it to be
+     * thrown and caught using standard error handling mechanisms.
+     *
+     * This error serves as a clear indicator to developers that the
+     * provided array of parsers does not meet the expected criteria,
+     * specifically that it must contain at least one valid parser
+     * that extends `ParamParser`. This ensures that the parsing
+     * process can be executed with at least one valid parser function.
+     *
+     * @example
+     * try {
+     *   ParamParser.safeTryParsers(parameters, [], true);
+     * } catch (error) {
+     *   const { ParsersArrayMustContainParsersError } = ParamParser
+     *   if (error instanceof ParsersArrayMustContainParsersError) {
+     *     console.error(
+     *       'The parsers array must contain at least one valid parser.'
+     *     );
+     *   }
+     * }
+     */
+    static get ParsersArrayMustContainParsersError() {
+        return class ParsersArrayMustContainParsersError extends Error {
+        };
+    }
+}
+export const ParamParserExtensions = new Extension(ParamParser);
+//# sourceMappingURL=param.parser.js.map

package/dist/mjs/classes/param.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"param.parser.js","sourceRoot":"","sources":["../../../src/classes/param.parser.js"],"names":[],"mappings":"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"}

package/dist/mjs/classes/pluggable.proxy.d.ts

@@ -0,0 +1,152 @@
+export class ProxyHandlerResponse {
+    constructor(success?: boolean, value?: undefined, context?: undefined);
+}
+export class ProxyHandler {
+    /**
+     * This static method is used to create a response object. The response
+     * object contains the success status, the value, and the context of the
+     * response. It also includes a getter for the Symbol.toStringTag property
+     * that returns the ResponseType of the ProxyHandler.
+     *
+     * @param {boolean} success - The success status of the response.
+     * @param {*} value - The value of the response.
+     * @param {Object} context - The context of the response.
+     * @returns {Object} The response object.
+     *
+     * @example
+     * // Create a response object
+     * const response = ProxyHandler.response(
+     *   true, 'value', { key: 'context' }
+     * );
+     *
+     * // Output: { success: true, value: 'value', context: { key: 'context' },
+     * //           [Symbol.toStringTag]: 'ProxyHandlerResponse' }
+     * console.log(response);
+     */
+    static response(success: boolean, value: any, context: Object): Object;
+    /**
+     * This static getter method is used to retrieve the response type
+     * of the ProxyHandler. It returns a string that represents the
+     * response type of the ProxyHandler.
+     *
+     * @property {function} ResponseType - A static getter method that
+     * returns the response type of the ProxyHandler.
+     * @returns {string} A string representing the response type of the
+     * ProxyHandler.
+     *
+     * @example
+     * // Get the response type of the ProxyHandler
+     * const responseType = ProxyHandler.ResponseType;
+     *
+     * // Output: 'ProxyHandlerResponse'
+     * console.log(responseType);
+     */
+    static get ResponseType(): string;
+    /**
+     * This static method is used to retrieve the name of a ProxyHandler type
+     * from a given array of arguments. If the array of arguments matches any
+     * of the ProxyHandler types, the name of that type is returned. If no
+     * match is found, or if the input is not an array, 'custom' is returned.
+     *
+     * @param {Array.<*>} proxyHandlerType - An array of arguments to match
+     * against the ProxyHandler types.
+     * @returns {string} The name of the matching ProxyHandler type, or 'custom'
+     * if no match is found.
+     *
+     * @example
+     * // Get the name of a type from its arguments
+     * const typeName = ProxyHandler.nameFromType(
+     *   ['target', 'thisArg', 'argumentsList']
+     * );
+     *
+     * // Output: 'apply'
+     * console.log(typeName);
+     *
+     * @throws {TypeError} If ProxyHandler.type is undefined.
+     */
+    static nameFromType(proxyHandlerType: Array<any>): string;
+    /**
+     * This method is used to retrieve all the types of ProxyHandler available
+     * in the ProxyHandler.type object. It is useful when you need to iterate
+     * over all the types or when you need to check if a certain type exists.
+     *
+     * @property {function} typeNames - A static getter method that returns an
+     * array of keys from the ProxyHandler.type object.
+     * @returns {Array.<string>} An array of strings representing the keys of
+     * the ProxyHandler.type object.
+     *
+     * @example
+     * // Get all type names
+     * const types = ProxyHandler.typeNames;
+     *
+     * // Output: ['apply', 'construct', 'defineProperty', ...]
+     * console.log(types);
+     *
+     * @throws {TypeError} If ProxyHandler.type is undefined.
+     */
+    static get typeNames(): string[];
+    /**
+     * A static getter method that returns an object containing keyed proxy
+     * trap types and their associated expected arguments list by name. A
+     * docstring description complete with url shortening links for each entry
+     * are provided (links go to the MDN documentation)
+     *
+     * @property {function} type - A static getter method that returns an object
+     * of ProxyHandler types.
+     * @returns {Object.<string, function>} An object where each key is a type
+     * name and each value is a function that returns an array of strings
+     * representing the arguments for that type.
+     *
+     * @example
+     * // Get the 'apply' type
+     * const applyType = ProxyHandler.type.apply;
+     *
+     * // Output: ['target', 'thisArg', 'argumentsList']
+     * console.log(applyType());
+     *
+     * @throws {TypeError} If ProxyHandler.type is undefined.
+     */
+    static get type(): {
+        [x: string]: Function;
+    };
+    constructor(handler: any, type?: Function);
+    handler: any;
+    typeName: string;
+    type: any;
+    invoke(...args: any[]): any;
+}
+export class PluggableProxy {
+    static get kCreated(): symbol;
+    static get kOriginal(): symbol;
+    static get kProxy(): symbol;
+    constructor(Class: any, handlers: any, options?: {
+        prototype: undefined;
+        apply: boolean;
+    });
+    handlers: Map<any, any>;
+    handlersOfType(typeName: any): any;
+    tryEachOfType(type: any, ...args: any[]): any[];
+    apply(target: any, thisArg: any, argumentsList: any): any;
+    construct(target: any, args: any): any;
+    defineProperty(target: any, key: any, descriptor: any): any;
+    deleteProperty(target: any, property: any): any;
+    get(target: any, property: any, receiver: any): any;
+    getOwnPropertyDescriptor(target: any, property: any): any;
+    getPrototypeOf(target: any): any;
+    has(target: any, property: any): any;
+    isExtensible(target: any): any;
+    ownKeys(target: any): any;
+    preventExtensions(target: any): any;
+    set(target: any, property: any, value: any, receiver: any): any;
+    setPrototypeOf(target: any, prototype: any): any;
+}
+export const ProxyHandlerExtensions: Extension;
+export const PluggableProxyExtensions: Extension;
+export const PluggableProxyExtensionSet: {
+    name: string;
+    extensionObjects: Set<any>;
+    extensions: Set<any>;
+    apply(): void;
+    revert(): void;
+};
+import { Extension } from '@nejs/extension';