@nestia/e2e 10.0.1 → 11.0.0-dev.20260305

package/lib/ArrayUtil.js

@@ -1,410 +0,0 @@
-"use strict";
-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 };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayUtil = void 0;
-/**
- * A namespace providing utility functions for array manipulation.
- *
- * This namespace contains utility functions for array operations including
- * asynchronous processing, filtering, mapping, and repetition tasks implemented
- * in functional programming style. Functions use direct parameter passing for
- * simplicity while maintaining functional programming principles.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   ```typescript
- *   // Asynchronous filtering example
- *   const numbers = [1, 2, 3, 4, 5];
- *   const evenNumbers = await ArrayUtil.asyncFilter(numbers,
- *     async (num) => num % 2 === 0
- *   );
- *   console.log(evenNumbers); // [2, 4]
- *   ```;
- */
-var ArrayUtil;
-(function (ArrayUtil) {
-    var _this = this;
-    /**
-     * Filters an array by applying an asynchronous predicate function to each
-     * element.
-     *
-     * Elements are processed sequentially, ensuring order is maintained. The
-     * predicate function receives the element, index, and the full array as
-     * parameters.
-     *
-     * @example
-     *   ```typescript
-     *   const users = [
-     *     { id: 1, name: 'Alice', active: true },
-     *     { id: 2, name: 'Bob', active: false },
-     *     { id: 3, name: 'Charlie', active: true }
-     *   ];
-     *
-     *   const activeUsers = await ArrayUtil.asyncFilter(users,
-     *     async (user) => {
-     *       // Async validation logic (e.g., API call)
-     *       await new Promise(resolve => setTimeout(resolve, 100));
-     *       return user.active;
-     *     }
-     *   );
-     *   console.log(activeUsers); // [{ id: 1, name: 'Alice', active: true }, { id: 3, name: 'Charlie', active: true }]
-     *   ```;
-     *
-     * @template Input - The type of elements in the input array
-     * @param elements - The readonly array to filter
-     * @param pred - The asynchronous predicate function to test each element
-     * @returns A Promise resolving to the filtered array
-     */
-    ArrayUtil.asyncFilter = function (elements, pred) { return __awaiter(_this, void 0, void 0, function () {
-        var ret;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ret = [];
-                    return [4 /*yield*/, ArrayUtil.asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
-                            var flag;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, pred(elem, index, array)];
-                                    case 1:
-                                        flag = _a.sent();
-                                        if (flag === true)
-                                            ret.push(elem);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, ret];
-            }
-        });
-    }); };
-    /**
-     * Executes an asynchronous function for each element in an array
-     * sequentially.
-     *
-     * Unlike JavaScript's native forEach, this function processes asynchronous
-     * functions sequentially and waits for all operations to complete. It
-     * performs sequential processing rather than parallel processing, making it
-     * suitable for operations where order matters.
-     *
-     * @example
-     *   ```typescript
-     *   const urls = ['url1', 'url2', 'url3'];
-     *
-     *   await ArrayUtil.asyncForEach(urls, async (url, index) => {
-     *   console.log(`Processing ${index}: ${url}`);
-     *   const data = await fetch(url);
-     *   await processData(data);
-     *   console.log(`Completed ${index}: ${url}`);
-     *   });
-     *   console.log('All URLs processed sequentially');
-     *   ```
-     *
-     * @template Input - The type of elements in the input array
-     * @param elements - The readonly array to process
-     * @param closure - The asynchronous function to execute for each element
-     * @returns A Promise<void> that resolves when all operations complete
-     */
-    ArrayUtil.asyncForEach = function (elements, closure) { return __awaiter(_this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, ArrayUtil.asyncRepeat(elements.length, function (index) {
-                        return closure(elements[index], index, elements);
-                    })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    /**
-     * Transforms each element of an array using an asynchronous function to
-     * create a new array.
-     *
-     * Similar to JavaScript's native map but processes asynchronous functions
-     * sequentially. Each element's transformation is completed before proceeding
-     * to the next element, ensuring order is maintained. This function still
-     * maintains the currying pattern for composition.
-     *
-     * @example
-     *   ```typescript
-     *   const userIds = [1, 2, 3, 4, 5];
-     *
-     *   const userDetails = await ArrayUtil.asyncMap(userIds)(
-     *   async (id, index) => {
-     *   console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
-     *   const response = await fetch(`/api/users/${id}`);
-     *   return await response.json();
-     *   }
-     *   );
-     *   console.log('All users fetched:', userDetails);
-     *   ```
-     *
-     * @template Input - The type of elements in the input array
-     * @param elements - The readonly array to transform
-     * @returns A function that takes a transformation function and returns a
-     *   Promise resolving to the transformed array
-     */
-    ArrayUtil.asyncMap = function (elements, closure) { return __awaiter(_this, void 0, void 0, function () {
-        var ret;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ret = [];
-                    return [4 /*yield*/, ArrayUtil.asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
-                            var output;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, closure(elem, index, array)];
-                                    case 1:
-                                        output = _a.sent();
-                                        ret.push(output);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, ret];
-            }
-        });
-    }); };
-    /**
-     * Executes an asynchronous function a specified number of times sequentially.
-     *
-     * Executes the function with indices from 0 to count-1 incrementally. Each
-     * execution is performed sequentially, and all results are collected into an
-     * array.
-     *
-     * @example
-     *   ```typescript
-     *   // Generate random data 5 times
-     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
-     *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
-     *     return {
-     *       id: index,
-     *       value: Math.random(),
-     *       timestamp: new Date().toISOString()
-     *     };
-     *   });
-     *   console.log('Generated data:', randomData);
-     *   ```;
-     *
-     * @template T - The type of the result from each execution
-     * @param count - The number of times to repeat (non-negative integer)
-     * @param closure - The asynchronous function to execute repeatedly
-     * @returns A Promise resolving to an array of results
-     */
-    ArrayUtil.asyncRepeat = function (count, closure) { return __awaiter(_this, void 0, void 0, function () {
-        var indexes, output, indexes_1, indexes_1_1, index, _a, _b, e_1_1;
-        var e_1, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    indexes = new Array(count).fill(1).map(function (_, index) { return index; });
-                    output = [];
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 6, 7, 8]);
-                    indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next();
-                    _d.label = 2;
-                case 2:
-                    if (!!indexes_1_1.done) return [3 /*break*/, 5];
-                    index = indexes_1_1.value;
-                    _b = (_a = output).push;
-                    return [4 /*yield*/, closure(index)];
-                case 3:
-                    _b.apply(_a, [_d.sent()]);
-                    _d.label = 4;
-                case 4:
-                    indexes_1_1 = indexes_1.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_1_1 = _d.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (indexes_1_1 && !indexes_1_1.done && (_c = indexes_1.return)) _c.call(indexes_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/, output];
-            }
-        });
-    }); };
-    /**
-     * Checks if at least one element in the array satisfies the given condition.
-     *
-     * Similar to JavaScript's native some() method. Returns true immediately when
-     * the first element satisfying the condition is found.
-     *
-     * @example
-     *   ```typescript
-     *   const numbers = [1, 3, 5, 7, 8, 9];
-     *   const products = [
-     *     { name: 'Apple', price: 100, inStock: true },
-     *     { name: 'Banana', price: 50, inStock: false },
-     *     { name: 'Orange', price: 80, inStock: true }
-     *   ];
-     *
-     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
-     *   console.log(hasEvenNumber); // true (8 exists)
-     *
-     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
-     *   console.log(hasExpensiveItem); // true (Apple costs 100)
-     *
-     *   const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);
-     *   console.log(hasOutOfStock); // true (Banana is out of stock)
-     *   ```;
-     *
-     * @template T - The type of elements in the array
-     * @param elements - The readonly array to check
-     * @param pred - The predicate function to test elements
-     * @returns Boolean indicating if any element satisfies the condition
-     */
-    ArrayUtil.has = function (elements, pred) { return elements.find(pred) !== undefined; };
-    /**
-     * Executes a function a specified number of times and collects the results
-     * into an array.
-     *
-     * A synchronous repetition function that executes the given function for each
-     * index (from 0 to count-1) and collects the results into an array.
-     *
-     * @example
-     *   ```typescript
-     *   // Generate an array of squares from 1 to 5
-     *   const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);
-     *   console.log(squares); // [1, 4, 9, 16, 25]
-     *
-     *   // Generate an array of default user objects
-     *   const users = ArrayUtil.repeat(3, index => ({
-     *   id: index + 1,
-     *   name: `User${index + 1}`,
-     *   email: `user${index + 1}@example.com`
-     *   }));
-     *   console.log(users);
-     *   // [
-     *   //   { id: 1, name: 'User1', email: 'user1@example.com' },
-     *   //   { id: 2, name: 'User2', email: 'user2@example.com' },
-     *   //   { id: 3, name: 'User3', email: 'user3@example.com' }
-     *   // ]
-     *   ```
-     *
-     * @template T - The type of the result from each execution
-     * @param count - The number of times to repeat (non-negative integer)
-     * @param closure - The function to execute repeatedly
-     * @returns An array of results
-     */
-    ArrayUtil.repeat = function (count, closure) { return new Array(count).fill("").map(function (_, index) { return closure(index); }); };
-    /**
-     * Generates all possible subsets of a given array.
-     *
-     * Implements the mathematical concept of power set, generating 2^n subsets
-     * from an array of n elements. Uses depth-first search (DFS) algorithm to
-     * calculate all possible combinations of including or excluding each
-     * element.
-     *
-     * @example
-     *   ```typescript
-     *   const numbers = [1, 2, 3];
-     *   const allSubsets = ArrayUtil.subsets(numbers);
-     *   console.log(allSubsets);
-     *   // [
-     *   //   [],           // empty set
-     *   //   [3],          // {3}
-     *   //   [2],          // {2}
-     *   //   [2, 3],       // {2, 3}
-     *   //   [1],          // {1}
-     *   //   [1, 3],       // {1, 3}
-     *   //   [1, 2],       // {1, 2}
-     *   //   [1, 2, 3]     // {1, 2, 3}
-     *   // ]
-     *
-     *   const colors = ['red', 'blue'];
-     *   const colorSubsets = ArrayUtil.subsets(colors);
-     *   console.log(colorSubsets);
-     *   // [
-     *   //   [],
-     *   //   ['blue'],
-     *   //   ['red'],
-     *   //   ['red', 'blue']
-     *   // ]
-     *
-     *   // Warning: Result size grows exponentially with array size
-     *   // Example: 10 elements → 1,024 subsets, 20 elements → 1,048,576 subsets
-     *   ```;
-     *
-     * @template T - The type of elements in the array
-     * @param array - The array to generate subsets from
-     * @returns An array containing all possible subsets
-     */
-    ArrayUtil.subsets = function (array) {
-        var check = new Array(array.length).fill(false);
-        var output = [];
-        var dfs = function (depth) {
-            if (depth === check.length)
-                output.push(array.filter(function (_v, idx) { return check[idx]; }));
-            else {
-                check[depth] = true;
-                dfs(depth + 1);
-                check[depth] = false;
-                dfs(depth + 1);
-            }
-        };
-        dfs(0);
-        return output;
-    };
-})(ArrayUtil || (exports.ArrayUtil = ArrayUtil = {}));
-//# sourceMappingURL=ArrayUtil.js.map

package/lib/ArrayUtil.js.map

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

package/lib/DynamicExecutor.d.ts

@@ -1,144 +0,0 @@
-/**
- * Dynamic Executor running prefixed functions.
- *
- * `DynamicExecutor` runs every (or some filtered) prefixed functions in a
- * specific directory.
- *
- * For reference, it's useful for test program development of a backend server.
- * Just write test functions under a directory, and just specify it.
- * Furthermore, if you compose e2e test programs to utilize the `@nestia/sdk`
- * generated API functions, you can take advantage of {@link DynamicBenchmarker}
- * at the same time.
- *
- * When you want to see some utilization cases, see the below example links.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   https://github.com/samchon/nestia-start/blob/master/test/index.ts
- *
- * @example
- *   https://github.com/samchon/backend/blob/master/test/index.ts
- */
-export declare namespace DynamicExecutor {
-    /**
-     * Function type of a prefixed.
-     *
-     * @template Arguments Type of parameters
-     * @template Ret Type of return value
-     */
-    interface Closure<Arguments extends any[], Ret = any> {
-        (...args: Arguments): Promise<Ret>;
-    }
-    /** Options for dynamic executor. */
-    interface IProps<Parameters extends any[], Ret = any> {
-        /**
-         * Prefix of function name.
-         *
-         * Every prefixed function will be executed.
-         *
-         * In other words, if a function name doesn't start with the prefix, then it
-         * would never be executed.
-         */
-        prefix: string;
-        /** Location of the test functions. */
-        location: string;
-        /**
-         * Get parameters of a function.
-         *
-         * @param name Function name
-         * @returns Parameters
-         */
-        parameters: (name: string) => Parameters;
-        /**
-         * On complete function.
-         *
-         * Listener of completion of a test function.
-         *
-         * @param exec Execution result of a test function
-         */
-        onComplete?: (exec: IExecution) => void;
-        /**
-         * Filter function whether to run or not.
-         *
-         * @param name Function name
-         * @returns Whether to run or not
-         */
-        filter?: (name: string) => boolean;
-        /**
-         * Wrapper of test function.
-         *
-         * If you specify this `wrapper` property, every dynamic functions loaded
-         * and called by this `DynamicExecutor` would be wrapped by the `wrapper`
-         * function.
-         *
-         * @param name Function name
-         * @param closure Function to be executed
-         * @param parameters Parameters, result of options.parameters function.
-         * @returns Wrapper function
-         */
-        wrapper?: (name: string, closure: Closure<Parameters, Ret>, parameters: Parameters) => Promise<any>;
-        /**
-         * Number of simultaneous requests.
-         *
-         * The number of requests to be executed simultaneously.
-         *
-         * If you configure a value greater than one, the dynamic executor will
-         * process the functions concurrently with the given capacity value.
-         *
-         * @default 1
-         */
-        simultaneous?: number;
-        /**
-         * Extension of dynamic functions.
-         *
-         * @default js
-         */
-        extension?: string;
-    }
-    /** Report, result of dynamic execution. */
-    interface IReport {
-        /** Location path of dynamic functions. */
-        location: string;
-        /** Execution results of dynamic functions. */
-        executions: IExecution[];
-        /** Total elapsed time. */
-        time: number;
-    }
-    /** Execution of a test function. */
-    interface IExecution {
-        /** Name of function. */
-        name: string;
-        /** Location path of the function. */
-        location: string;
-        /** Returned value from the function. */
-        value: unknown;
-        /** Error when occurred. */
-        error: Error | null;
-        /** Elapsed time. */
-        started_at: string;
-        /** Completion time. */
-        completed_at: string;
-    }
-    /**
-     * Prepare dynamic executor in strict mode.
-     *
-     * In strict mode, if any error occurs, the program will be terminated
-     * directly. Otherwise, {@link validate} mode does not terminate when error
-     * occurs, but just archive the error log.
-     *
-     * @param props Properties of dynamic execution
-     * @returns Report of dynamic test functions execution
-     */
-    const assert: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;
-    /**
-     * Prepare dynamic executor in loose mode.
-     *
-     * In loose mode, the program would not be terminated even when error occurs.
-     * Instead, the error would be archived and returns as a list. Otherwise,
-     * {@link assert} mode terminates the program directly when error occurs.
-     *
-     * @param props Properties of dynamic executor
-     * @returns Report of dynamic test functions execution
-     */
-    const validate: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;
-}