@datatruck/cli 0.0.1

package/lib/util/datatruck/config-util.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.findRepositoryOrFail = void 0;
+const AppError_1 = require("../../Error/AppError");
+const fs_util_1 = require("../fs-util");
+const string_util_1 = require("../string-util");
+const micromatch_1 = require("micromatch");
+function findRepositoryOrFail(config, repositoryName) {
+    const repo = config.repositories.find((v) => v.name === repositoryName);
+    if (!repo)
+        throw new AppError_1.AppError(`Repository '${repositoryName}' not found`);
+    return repo;
+}
+exports.findRepositoryOrFail = findRepositoryOrFail;
+function filterPackages(config, options) {
+    const packagePatterns = (0, string_util_1.makePathPatterns)(options.packageNames);
+    return config.packages
+        .map((pkg) => {
+        pkg = Object.assign({}, pkg);
+        pkg.repositoryNames = (pkg.repositoryNames ?? []).filter((name) => {
+            const repo = findRepositoryOrFail(config, name);
+            return ((!options.repositoryNames ||
+                options.repositoryNames.includes(name)) &&
+                (!options.repositoryTypes ||
+                    options.repositoryTypes.includes(repo.type)));
+        });
+        return pkg;
+    })
+        .filter((pkg) => {
+        return ((typeof pkg.enabled !== "boolean" || pkg.enabled) &&
+            !!pkg.repositoryNames?.length &&
+            (!packagePatterns || (0, micromatch_1.isMatch)(pkg.name, packagePatterns)));
+    });
+}
+exports.filterPackages = filterPackages;
+function resolvePackagePath(value, params) {
+    return (0, string_util_1.render)(value, {
+        ...params,
+        ...{
+            temp: (0, fs_util_1.tmpDir)("pkg"),
+        },
+    });
+}
+exports.resolvePackagePath = resolvePackagePath;
+function resolveDatabaseName(value, params) {
+    return (0, string_util_1.render)(value, params);
+}
+exports.resolveDatabaseName = resolveDatabaseName;
+function resolvePackage(pkg, params) {
+    pkg = Object.assign({}, pkg);
+    const pkgParams = {
+        ...params,
+        packageName: pkg.name,
+        path: undefined,
+    };
+    if (pkg.path)
+        pkg.path = resolvePackagePath(pkg.path, pkgParams);
+    if (pkg.restorePath)
+        pkg.restorePath = resolvePackagePath(pkg.restorePath, {
+            ...pkgParams,
+            path: pkg.path,
+        });
+    return pkg;
+}
+exports.resolvePackage = resolvePackage;
+function resolvePackages(packages, params) {
+    return packages.map((pkg) => resolvePackage(pkg, params));
+}
+exports.resolvePackages = resolvePackages;
+exports.pkgPathParams = {
+    action: "{action}",
+    packageName: "{packageName}",
+    snapshotId: "{snapshotId}",
+    temp: "{temp}",
+};
+exports.pkgRestorePathParams = {
+    action: "{action}",
+    packageName: "{packageName}",
+    path: "{path}",
+    snapshotId: "{snapshotId}",
+    temp: "{temp}",
+};
+exports.dbNameParams = {
+    action: "{action}",
+    packageName: "{packageName}",
+    snapshotId: "{snapshotId}",
+    database: "{database}",
+};
+exports.params = {
+    pkgPath: exports.pkgPathParams,
+    pkgRestorePath: exports.pkgRestorePathParams,
+    dbName: exports.dbNameParams,
+};

package/lib/util/datatruck/paths-util.d.ts

@@ -0,0 +1,5 @@
+import { PathsObjectType } from "../../Config/PackageConfig";
+export declare function parsePaths(values: (string | PathsObjectType)[], options: {
+    cwd?: string;
+    verbose?: boolean;
+}): Promise<string[]>;

package/lib/util/datatruck/paths-util.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePaths = void 0;
+const process_util_1 = require("../process-util");
+async function parsePaths(values, options) {
+    let paths = [];
+    for (const value of values) {
+        if (typeof value === "string") {
+            paths.push(value);
+        }
+        else if (value.type === "spawn") {
+            const spawnResult = await (0, process_util_1.exec)(value.command, value.args, { cwd: options.cwd }, { log: options.verbose, stderr: { save: true }, stdout: { save: true } });
+            const spawnFiles = [spawnResult.stderr, spawnResult.stdout].flatMap((text) => text
+                .split(/\r?\n/)
+                .map((v) => v.trim())
+                .filter((v) => !!v.length));
+            paths.push(...spawnFiles);
+        }
+    }
+    return paths;
+}
+exports.parsePaths = parsePaths;

package/lib/util/datatruck/snapshot-util.d.ts

@@ -0,0 +1,4 @@
+import { SnapshotGroupByType } from "../../Action/SnapshotsAction";
+import { SnapshotResultType } from "../../Repository/RepositoryAbstract";
+import { FilterByLastOptionsType } from "../date-util";
+export declare function groupAndFilter<TSnapshot extends SnapshotResultType>(snapshots: TSnapshot[], groupByKey?: SnapshotGroupByType[], filter?: FilterByLastOptionsType | ((groupedSnapshots: TSnapshot[]) => FilterByLastOptionsType), reasons?: Record<number, string[]>): TSnapshot[];

package/lib/util/datatruck/snapshot-util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupAndFilter = void 0;
+const date_util_1 = require("../date-util");
+const object_util_1 = require("../object-util");
+function groupAndFilter(snapshots, groupByKey, filter, reasons) {
+    const grouped = groupByKey?.length
+        ? (0, object_util_1.groupBy)(snapshots, groupByKey)
+        : { "": snapshots };
+    const result = [];
+    for (const key in grouped) {
+        if (filter) {
+            const groupReasons = reasons
+                ? {}
+                : undefined;
+            result.push(...(0, date_util_1.filterByLast)(grouped[key], typeof filter === "function" ? filter(grouped[key]) : filter, groupReasons));
+            if (groupReasons && reasons) {
+                for (const groupItemIndex in groupReasons) {
+                    const snapshot = grouped[key][groupItemIndex];
+                    const snapshotIndex = snapshots.indexOf(snapshot);
+                    reasons[snapshotIndex] = groupReasons[groupItemIndex];
+                }
+            }
+        }
+        else {
+            result.push(...grouped[key]);
+        }
+    }
+    return snapshots.filter((snapshot) => result.includes(snapshot));
+}
+exports.groupAndFilter = groupAndFilter;

package/lib/util/date-util.d.ts

@@ -0,0 +1,12 @@
+export declare type FilterByLastOptionsType = {
+    last?: number;
+    lastMinutely?: number;
+    lastHourly?: number;
+    lastDaily?: number;
+    lastWeekly?: number;
+    lastMonthly?: number;
+    lastYearly?: number;
+};
+export declare function filterByLast<TItem extends {
+    date: string;
+}>(items: TItem[], options: FilterByLastOptionsType, reasons?: Record<number, string[]>): TItem[];

package/lib/util/date-util.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterByLast = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+const isoWeek_1 = __importDefault(require("dayjs/plugin/isoWeek"));
+dayjs_1.default.extend(isoWeek_1.default);
+dayjs_1.default.extend(advancedFormat_1.default);
+function filterByLast(items, options, reasons) {
+    const filters = {
+        last: { handler: (_, i) => i.toString(), value: options.last },
+        lastMinutely: {
+            handler: (d) => d.format("YYYYMMDDHHmm"),
+            value: options.lastMinutely,
+        },
+        lastHourly: {
+            handler: (d) => d.format("YYYYMMDDHH"),
+            value: options.lastHourly,
+        },
+        lastDaily: {
+            handler: (d) => d.format("YYYYMMDD"),
+            value: options.lastDaily,
+        },
+        lastMonthly: {
+            handler: (d) => d.format("YYYYMM"),
+            value: options.lastMonthly,
+        },
+        lastWeekly: {
+            handler: (d) => d.format("YYYYWW"),
+            value: options.lastWeekly,
+        },
+        lastYearly: { handler: (d) => d.format("YYYY"), value: options.lastYearly },
+    };
+    let someFilter = false;
+    for (const key in filters) {
+        const object = filters[key];
+        if (object?.value) {
+            someFilter = true;
+        }
+    }
+    if (!someFilter)
+        return items;
+    const validItems = items
+        .slice(0)
+        .sort((a, b) => b.date.localeCompare(a.date))
+        .filter((item, index) => {
+        const date = (0, dayjs_1.default)(item.date);
+        const itemIndex = items.indexOf(item);
+        let success = false;
+        for (const key in filters) {
+            const object = filters[key];
+            if (object?.value) {
+                const value = object.handler(date, index);
+                if (value != object.last) {
+                    success = true;
+                    if (reasons) {
+                        if (!reasons[itemIndex])
+                            reasons[itemIndex] = [];
+                        if (!reasons[itemIndex].includes(key))
+                            reasons[itemIndex].push(key);
+                    }
+                    object.last = value;
+                    object.value--;
+                }
+            }
+        }
+        return success;
+    });
+    return items.filter((item) => validItems.includes(item));
+}
+exports.filterByLast = filterByLast;

package/lib/util/entity-util.d.ts

@@ -0,0 +1,4 @@
+export declare function makeTableSelector<T>(tableName: string): {
+    (name?: keyof T | undefined): string;
+    toString: any;
+};

package/lib/util/entity-util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTableSelector = void 0;
+function makeTableSelector(tableName) {
+    const q = (value) => `\`${value}\``;
+    const cb = (name) => `${q(tableName)}${name ? `.${q(name)}` : ""}`;
+    cb.toString = cb;
+    return cb;
+}
+exports.makeTableSelector = makeTableSelector;

package/lib/util/fs-util.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+export declare function isLocalDir(path: string): boolean;
+export declare function isDirEmpty(path: string): Promise<boolean>;
+export declare function mkdirIfNotExists(path: string): Promise<string>;
+export declare function ensureEmptyDir(path: string): Promise<void>;
+export declare function existsDir(path: string): Promise<boolean>;
+export declare function writeJSONFile<T = any>(path: string, json: T): Promise<void>;
+export declare function readdirIfExists(path: string): Promise<string[]>;
+export declare const parseFileExtensions: string[];
+export declare function parseFile(path: string, jsKey?: string): Promise<any>;
+export declare function parsePackageFile(): {
+    name: string;
+    version: string;
+    description: string;
+};
+export declare function findFile(sourcePath: string, baseName: string, extensions: string[], errorMessage?: string): Promise<string>;
+export declare function existsFile(path: string): Promise<boolean>;
+export declare function parentTmpDir(): string;
+export declare function sessionTmpDir(): string;
+export declare function tmpDir(prefix: string, id?: string): string;
+export declare function mkTmpDir(prefix: string, id?: string): Promise<string>;
+export declare function readPartialFile(path: string, positions: [number, number?]): Promise<string>;
+export declare function checkFile(path: string): Promise<boolean>;
+export declare function checkDir(path: string): Promise<boolean>;
+export declare function forEachFile(dirPath: string, cb: (path: string, dir: boolean) => void, includeDir?: boolean): Promise<void>;
+export declare function writePathLists(options: {
+    paths: NodeJS.ReadableStream | string[];
+    packs?: {
+        include: string[];
+        exclude?: string[];
+        multiple?: boolean;
+    }[];
+}): Promise<{
+    path: string;
+    includedPackPaths: string[];
+    excludedPackPaths: string[];
+    total: {
+        all: number;
+        path: number;
+        packsPaths: number[];
+        multipleStats: Record<string, number>;
+    };
+}>;

package/lib/util/fs-util.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePathLists = exports.forEachFile = exports.checkDir = exports.checkFile = exports.readPartialFile = exports.mkTmpDir = exports.tmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.existsFile = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.readdirIfExists = exports.writeJSONFile = exports.existsDir = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isDirEmpty = exports.isLocalDir = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const fs_2 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const promises_1 = require("fs/promises");
+const micromatch_1 = require("micromatch");
+const os_1 = require("os");
+const path_1 = require("path");
+const path_2 = require("path");
+function isLocalDir(path) {
+    return /^[\/\.]|([A-Z]:)/i.test(path);
+}
+exports.isLocalDir = isLocalDir;
+async function isDirEmpty(path) {
+    const files = await (0, promises_1.readdir)(path);
+    return !files.length;
+}
+exports.isDirEmpty = isDirEmpty;
+async function mkdirIfNotExists(path) {
+    try {
+        await (0, fs_extra_1.mkdir)(path, {
+            recursive: true,
+        });
+    }
+    catch (e) { }
+    return path;
+}
+exports.mkdirIfNotExists = mkdirIfNotExists;
+async function ensureEmptyDir(path) {
+    if (!(await isDirEmpty(path)))
+        throw new Error(`Dir is not empty: ${path}`);
+}
+exports.ensureEmptyDir = ensureEmptyDir;
+async function existsDir(path) {
+    try {
+        const info = await (0, promises_1.stat)(path);
+        return info.isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.existsDir = existsDir;
+async function writeJSONFile(path, json) {
+    await (0, promises_1.writeFile)(path, JSON.stringify(json));
+}
+exports.writeJSONFile = writeJSONFile;
+async function readdirIfExists(path) {
+    if (!(await existsDir(path)))
+        return [];
+    return await (0, promises_1.readdir)(path);
+}
+exports.readdirIfExists = readdirIfExists;
+exports.parseFileExtensions = ["json", "js", "ts", "yaml", "yml"];
+async function parseFile(path, jsKey) {
+    if (!(0, path_2.isAbsolute)(path))
+        path = (0, path_1.join)(process.cwd(), path);
+    if (path.endsWith(".ts"))
+        require("ts-node").register();
+    if (path.endsWith(".yaml") || path.endsWith("yml")) {
+        const contents = await (0, promises_1.readFile)(path);
+        return require("yaml").parse(contents.toString());
+    }
+    else if (path.endsWith(".json")) {
+        return require(path);
+    }
+    else {
+        const object = require(path);
+        const value = jsKey ? object[jsKey] : object;
+        return typeof value === "function" ? await value() : value;
+    }
+}
+exports.parseFile = parseFile;
+function parsePackageFile() {
+    return require(`${__dirname}/../../package.json`);
+}
+exports.parsePackageFile = parsePackageFile;
+async function findFile(sourcePath, baseName, extensions, errorMessage = "Path not found") {
+    const info = await (0, promises_1.stat)(sourcePath);
+    let path;
+    if (info.isDirectory()) {
+        for (const ext of extensions) {
+            const extPath = (0, path_1.join)(sourcePath, baseName) + "." + ext;
+            if (await existsFile(extPath)) {
+                path = extPath;
+                break;
+            }
+        }
+    }
+    else {
+        path = sourcePath;
+    }
+    if (typeof path !== "string")
+        throw new Error(errorMessage);
+    return path;
+}
+exports.findFile = findFile;
+async function existsFile(path) {
+    try {
+        const info = await (0, promises_1.stat)(path);
+        return info.isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.existsFile = existsFile;
+function parentTmpDir() {
+    const tmpDir = (0, os_1.tmpdir)();
+    return (0, path_1.join)(tmpDir, "datatruck");
+}
+exports.parentTmpDir = parentTmpDir;
+function sessionTmpDir() {
+    return (0, path_1.join)(parentTmpDir(), process.pid.toString());
+}
+exports.sessionTmpDir = sessionTmpDir;
+function tmpDir(prefix, id) {
+    if (!id)
+        id = (0, crypto_1.randomBytes)(8).toString("hex");
+    return (0, path_1.join)(sessionTmpDir(), `${prefix}-${id}`);
+}
+exports.tmpDir = tmpDir;
+async function mkTmpDir(prefix, id) {
+    const path = tmpDir(prefix, id);
+    await (0, fs_extra_1.mkdir)(path, { recursive: true });
+    return path;
+}
+exports.mkTmpDir = mkTmpDir;
+async function readPartialFile(path, positions) {
+    let result = "";
+    const statResult = await (0, promises_1.stat)(path);
+    const size = statResult.size;
+    let [start, end] = positions;
+    if (start < 0)
+        start = size + start;
+    if (end && end < 0)
+        end = size + end;
+    if (typeof start === "number")
+        start = Math.min(Math.max(start, 0), size);
+    if (typeof end === "number")
+        end = Math.min(Math.max(end, 0), size);
+    return new Promise((resolve, reject) => {
+        const reader = (0, fs_1.createReadStream)(path, {
+            start: start,
+            end: end,
+        });
+        reader
+            .on("error", reject)
+            .on("data", (chunk) => {
+            result += chunk.toString();
+        })
+            .on("close", () => resolve(result));
+    });
+}
+exports.readPartialFile = readPartialFile;
+async function checkFile(path) {
+    try {
+        return (await (0, promises_1.stat)(path)).isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.checkFile = checkFile;
+async function checkDir(path) {
+    try {
+        return (await (0, promises_1.stat)(path)).isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.checkDir = checkDir;
+async function forEachFile(dirPath, cb, includeDir) {
+    const files = await (0, promises_1.readdir)(dirPath);
+    for (const file of files) {
+        const filePath = (0, path_1.join)(dirPath, file);
+        if ((await (0, promises_1.stat)(filePath)).isDirectory()) {
+            if (includeDir)
+                cb(filePath, true);
+            await forEachFile(filePath, cb, includeDir);
+        }
+        else {
+            cb(filePath, false);
+        }
+    }
+}
+exports.forEachFile = forEachFile;
+async function writePathLists(options) {
+    const tempDir = await mkTmpDir("path-lists");
+    const includedPaths = [];
+    const excludedPaths = [];
+    const included = [];
+    const excluded = [];
+    const multipleStats = {};
+    const total = new Array((options.packs?.length || 0) + 1).fill(0);
+    await Promise.all([
+        ...new Array((options.packs?.length || 0) + 1).fill(null).map((_, index) => new Promise((resolve, reject) => {
+            const path = (0, path_1.join)(tempDir, `${index}-included.txt`);
+            const stream = (0, fs_2.createWriteStream)(path);
+            includedPaths.push(path);
+            included.push(stream);
+            stream.on("close", resolve);
+            stream.on("error", reject);
+        })),
+        ...new Array(options.packs?.length || 0).fill(null).map((_, index) => new Promise((resolve, reject) => {
+            const path = (0, path_1.join)(tempDir, `${index}-excluded.txt`);
+            const stream = (0, fs_2.createWriteStream)(path);
+            excludedPaths.push(path);
+            excluded.push(stream);
+            stream.on("close", resolve);
+            stream.on("error", reject);
+        })),
+        new Promise(async (resolve) => {
+            const packDirectories = [];
+            for await (const value of options.paths) {
+                const entry = value.toString();
+                const isDir = entry.endsWith("/");
+                const matchEntry = isDir ? entry.slice(0, -1) : entry;
+                let packIndex = 1;
+                let matches = false;
+                for (const pack of options.packs || []) {
+                    if ((0, micromatch_1.isMatch)(matchEntry, pack.include) &&
+                        (!pack.exclude || !(0, micromatch_1.isMatch)(matchEntry, pack.exclude))) {
+                        if (isDir)
+                            packDirectories.push([packIndex - 1, entry]);
+                        included[packIndex].write(`${entry}\n`);
+                        if (!isDir)
+                            total[packIndex]++;
+                        matches = true;
+                        break;
+                    }
+                    packIndex++;
+                }
+                if (!matches) {
+                    const packDir = packDirectories.find(([, p]) => entry.startsWith(p));
+                    if (packDir) {
+                        const [i, v] = packDir;
+                        const multipleExclude = options.packs?.[i].exclude;
+                        if (multipleExclude && (0, micromatch_1.isMatch)(matchEntry, multipleExclude)) {
+                            included[0].write(`${entry}\n`);
+                            excluded[i].write(`${entry}\n`);
+                        }
+                        else {
+                            if (!multipleStats[v])
+                                multipleStats[v] = 0;
+                            multipleStats[v]++;
+                        }
+                    }
+                    else {
+                        included[0].write(`${entry}\n`);
+                    }
+                    if (!isDir)
+                        total[0]++;
+                }
+            }
+            for (const stream of [...included, ...excluded]) {
+                stream.end();
+            }
+            resolve();
+        }),
+    ]);
+    return {
+        path: includedPaths[0],
+        includedPackPaths: includedPaths.slice(1),
+        excludedPackPaths: excludedPaths,
+        total: {
+            all: total.reduce((p, v) => p + v, 0),
+            path: total[0],
+            packsPaths: total.slice(1),
+            multipleStats,
+        },
+    };
+}
+exports.writePathLists = writePathLists;

package/lib/util/math-util.d.ts

@@ -0,0 +1 @@
+export declare function progressPercent(total: number, current: number): number;

package/lib/util/math-util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressPercent = void 0;
+function progressPercent(total, current) {
+    return Number(((current / total) * 100).toFixed(2));
+}
+exports.progressPercent = progressPercent;

package/lib/util/object-util.d.ts

@@ -0,0 +1,7 @@
+export declare function merge<T extends Record<string, unknown>>(target: T, ...sources: Record<string, unknown>[]): T;
+export declare function push<T>(map: Record<string, T[]>, key: string, object: T): void;
+export declare function getErrorProperties(error: Error): Record<string, string>;
+declare type GroupByKeyParamType<TItem> = ((item: TItem) => string[] | string) | (keyof TItem)[] | keyof TItem;
+export declare function groupBy<TItem>(items: TItem[], keyOrCb: GroupByKeyParamType<TItem>): Record<string, TItem[]>;
+export declare function groupBy<TItem>(items: TItem[], keyOrCb: GroupByKeyParamType<TItem>, single: true): Record<string, TItem>;
+export {};

package/lib/util/object-util.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = exports.getErrorProperties = exports.push = exports.merge = void 0;
+function merge(target, ...sources) {
+    const isObject = (o) => typeof o === "object" && o !== null;
+    for (const source of sources)
+        for (const key in source) {
+            const a = source[key];
+            const b = target[key];
+            target[key] =
+                isObject(b) && isObject(a) ? merge(b, a) : source[key];
+        }
+    return target;
+}
+exports.merge = merge;
+function push(map, key, object) {
+    if (!map[key])
+        map[key] = [];
+    map[key].push(object);
+}
+exports.push = push;
+function getErrorProperties(error) {
+    const alt = {};
+    for (const key of Object.getOwnPropertyNames(error)) {
+        alt[key] = error[key];
+    }
+    return alt;
+}
+exports.getErrorProperties = getErrorProperties;
+function groupBy(items, keyOrCb, single) {
+    const keyCb = typeof keyOrCb === "function"
+        ? keyOrCb
+        : Array.isArray(keyOrCb)
+            ? (item) => keyOrCb.map((key) => item[key])
+            : (item) => item[keyOrCb];
+    const stringify = (keys) => typeof keys === "string"
+        ? keys
+        : keys.length == 1
+            ? keys[0]
+            : JSON.stringify(keys);
+    if (single) {
+        return items.reduce((result, item) => {
+            const resultKey = stringify(keyCb(item));
+            result[resultKey] = item;
+            return result;
+        }, {});
+    }
+    else {
+        return items.reduce((result, item) => {
+            const resultKey = stringify(keyCb(item));
+            if (!result[resultKey])
+                result[resultKey] = [];
+            result[resultKey].push(item);
+            return result;
+        }, {});
+    }
+}
+exports.groupBy = groupBy;