jr-common-micro 0.6.1-dev

package/dist/utils/minimatch/matcher_collection.d.ts

@@ -0,0 +1,9 @@
+import { Minimatch } from '.';
+declare const _default: {
+    new (matchers: (Minimatch | string)[]): {
+        matchers: Minimatch[];
+        match(value: string): boolean;
+        mayContain(value: string): boolean;
+    };
+};
+export = _default;

package/dist/utils/minimatch/matcher_collection.js

@@ -0,0 +1,30 @@
+'use strict';
+const _1 = require(".");
+module.exports = class MatcherCollection {
+    matchers;
+    constructor(matchers) {
+        this.matchers = matchers.map((matcher) => {
+            return typeof matcher === 'string' ? new _1.Minimatch(matcher) : matcher;
+        });
+    }
+    match(value) {
+        for (let i = 0; i < this.matchers.length; i++) {
+            if (this.matchers[i].match(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    mayContain(value) {
+        let parts = value.split(/\/|\\/g).filter(Boolean);
+        for (let i = 0; i < this.matchers.length; i++) {
+            let matcher = this.matchers[i];
+            for (let j = 0; j < matcher.set.length; j++) {
+                if (matcher.matchOne(parts, matcher.set[j], true)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+};

package/dist/utils/minimatch/unescape.d.ts

@@ -0,0 +1,2 @@
+import { MinimatchOptions } from './index';
+export declare const unescape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, "windowsPathsNoEscape">) => string;

package/dist/utils/minimatch/unescape.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescape = void 0;
+const unescape = (s, { windowsPathsNoEscape = false, } = {}) => {
+    return windowsPathsNoEscape
+        ? s.replace(/\[([^\/\\])\]/g, '$1')
+        : s
+            .replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2')
+            .replace(/\\([^\/])/g, '$1');
+};
+exports.unescape = unescape;

package/dist/utils/types.d.ts

@@ -0,0 +1,70 @@
+import { Logger } from '@nestjs/common';
+export type JwtUser = {
+    email: string;
+    sub: string;
+    roles: string[];
+    [k: string]: any;
+};
+export type RpcDataType = {
+    user?: JwtUser;
+};
+export interface PrismaGeneralFilterType {
+}
+export type PrismaWhereType = PrismaGeneralFilterType & {
+    [key: string]: null | string | number | boolean | bigint | PrismaStringFilter | PrismaWhereType | PrismaWhereType[];
+};
+export type PrismaStringFilter = {
+    equals?: string;
+    in?: string[];
+    notIn?: string[];
+    lt?: string;
+    lte?: string;
+    gt?: string;
+    gte?: string;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    not?: NestedStringFilter | string;
+};
+export type NestedStringFilter = {
+    equals?: string;
+    in?: string[];
+    notIn?: string[];
+    lt?: string;
+    lte?: string;
+    gt?: string;
+    gte?: string;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    not?: NestedStringFilter | string;
+};
+export type PrismaOrderType = {
+    [key: string]: PrismaSortOrderType;
+};
+export type PrismaSortOrderType = 'asc' | 'desc';
+export type CurrencyParity = {
+    base: string;
+    quote: string;
+};
+export type ObjectLiteral<T = any> = {
+    [key: string]: T;
+};
+declare global {
+    interface BigInt {
+        toJSON: () => string;
+    }
+    interface String {
+        unpadEnd(unfillStr: string): string;
+        unpadStart(unfillStr: string): string;
+    }
+}
+declare module 'rxjs' {
+    interface Observable<T> {
+        getLastValue(options?: ObservableOptions<T>): Promise<T>;
+    }
+}
+interface ObservableOptions<T> {
+    logger?: Logger;
+}
+export {};

package/dist/utils/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rxjs_1 = require("rxjs");
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
+rxjs_1.Observable.prototype.getLastValue = async function (options = {}) {
+    try {
+        return await (0, rxjs_1.lastValueFrom)(this);
+    }
+    catch (error) {
+        const { logger } = options;
+        logger?.error('Failed to get last value:', error);
+        throw error;
+    }
+};
+String.prototype.unpadEnd = function (unfillStr) {
+    return this.replace(new RegExp(unfillStr + '+$'), '');
+};
+String.prototype.unpadStart = function (unfillStr) {
+    return this.replace(new RegExp('^' + unfillStr + '+'), '');
+};

package/dist/utils/walk_sync.d.ts

@@ -0,0 +1,25 @@
+import fsNode from 'fs';
+import { Minimatch, MinimatchOptions } from './minimatch';
+export declare function walkSync(baseDir: string, inputOptions?: _walkSyncInner.Options | (string | Minimatch)[]): string[];
+declare namespace _walkSyncInner {
+    function entries(baseDir: string, inputOptions?: Options | (string | Minimatch)[]): Entry[];
+    interface Options {
+        includeBasePath?: boolean;
+        globs?: (string | Minimatch)[];
+        ignore?: (string | Minimatch)[];
+        directories?: boolean;
+        fs?: typeof fsNode;
+        globOptions?: MinimatchOptions;
+    }
+    class Entry {
+        relativePath: string;
+        basePath: string;
+        mode: number;
+        size: number;
+        mtime: number;
+        constructor(relativePath: string, basePath: string, mode: number, size: number, mtime: number);
+        get fullPath(): string;
+        isDirectory(): boolean;
+    }
+}
+export {};

package/dist/utils/walk_sync.js

@@ -0,0 +1,184 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkSync = walkSync;
+const tslib_1 = require("tslib");
+const ensure_posix_path_1 = tslib_1.__importDefault(require("ensure-posix-path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const minimatch_1 = require("./minimatch");
+const matcher_collection_1 = tslib_1.__importDefault(require("./minimatch/matcher_collection"));
+function walkSync(baseDir, inputOptions) {
+    const options = handleOptions(inputOptions);
+    let mapFunct;
+    if (options.includeBasePath) {
+        mapFunct = function (entry) {
+            return (entry.basePath.split(path_1.default.sep).join('/').replace(/\/+$/, '') +
+                '/' +
+                entry.relativePath);
+        };
+    }
+    else {
+        mapFunct = function (entry) {
+            return entry.relativePath;
+        };
+    }
+    return _walkSync(baseDir, options, null, []).map(mapFunct);
+}
+function getStat(path, fs = fs_1.default) {
+    try {
+        return fs.statSync(path);
+    }
+    catch (error) {
+        if (error !== null &&
+            typeof error === 'object' &&
+            (error.code === 'ENOENT' ||
+                error.code === 'ENOTDIR' ||
+                error.code === 'EPERM')) {
+            return;
+        }
+        throw error;
+    }
+}
+var _walkSyncInner;
+(function (_walkSyncInner) {
+    function entries(baseDir, inputOptions) {
+        const options = handleOptions(inputOptions);
+        return _walkSync((0, ensure_posix_path_1.default)(baseDir), options, null, []);
+    }
+    _walkSyncInner.entries = entries;
+    class Entry {
+        relativePath;
+        basePath;
+        mode;
+        size;
+        mtime;
+        constructor(relativePath, basePath, mode, size, mtime) {
+            this.relativePath = relativePath;
+            this.basePath = basePath;
+            this.mode = mode;
+            this.size = size;
+            this.mtime = mtime;
+        }
+        get fullPath() {
+            return `${this.basePath}/${this.relativePath}`;
+        }
+        isDirectory() {
+            return (this.mode & 61440) === 16384;
+        }
+    }
+    _walkSyncInner.Entry = Entry;
+})(_walkSyncInner || (_walkSyncInner = {}));
+function isDefined(val) {
+    return typeof val !== 'undefined';
+}
+function handleOptions(_options) {
+    let options = {};
+    if (Array.isArray(_options)) {
+        options.globs = _options;
+    }
+    else if (_options) {
+        options = _options;
+    }
+    return options;
+}
+function applyGlobOptions(globs, options) {
+    return globs?.map((glob) => {
+        if (typeof glob === 'string') {
+            return new minimatch_1.Minimatch(glob, options);
+        }
+        return glob;
+    });
+}
+function handleRelativePath(_relativePath) {
+    if (_relativePath == null) {
+        return '';
+    }
+    else if (_relativePath.slice(-1) !== '/') {
+        return _relativePath + '/';
+    }
+    else {
+        return _relativePath;
+    }
+}
+function lexicographically(a, b) {
+    const aPath = a.relativePath;
+    const bPath = b.relativePath;
+    if (aPath === bPath) {
+        return 0;
+    }
+    else if (aPath < bPath) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+function _walkSync(baseDir, options, _relativePath, visited) {
+    const fs = options.fs ?? fs_1.default;
+    const relativePath = handleRelativePath(_relativePath);
+    const realPath = fs.realpathSync(baseDir + '/' + relativePath);
+    if (visited.indexOf(realPath) >= 0) {
+        return [];
+    }
+    else {
+        visited.push(realPath);
+    }
+    try {
+        const globOptions = options.globOptions;
+        const ignorePatterns = isDefined(globOptions)
+            ? applyGlobOptions(options.ignore, globOptions)
+            : options.ignore;
+        const globs = isDefined(globOptions)
+            ? applyGlobOptions(options.globs, globOptions)
+            : options.globs;
+        let globMatcher;
+        let ignoreMatcher;
+        let results = [];
+        if (ignorePatterns) {
+            ignoreMatcher = new matcher_collection_1.default(ignorePatterns);
+        }
+        if (globs) {
+            globMatcher = new matcher_collection_1.default(globs);
+        }
+        if (globMatcher && !globMatcher.mayContain(relativePath)) {
+            return results;
+        }
+        const names = fs.readdirSync(baseDir + '/' + relativePath);
+        const entries = names
+            .map((name) => {
+            let entryRelativePath = relativePath + name;
+            if (ignoreMatcher && ignoreMatcher.match(entryRelativePath)) {
+                return;
+            }
+            let fullPath = baseDir + '/' + entryRelativePath;
+            let stats = getStat(fullPath, fs);
+            if (stats && stats.isDirectory()) {
+                return new _walkSyncInner.Entry(entryRelativePath + '/', baseDir, stats.mode, stats.size, stats.mtime.getTime());
+            }
+            else {
+                return new _walkSyncInner.Entry(entryRelativePath, baseDir, (stats && stats.mode) || 0, (stats && stats.size) || 0, (stats && stats.mtime.getTime()) || 0);
+            }
+        })
+            .filter(isDefined);
+        const sortedEntries = entries.sort(lexicographically);
+        for (let i = 0; i < sortedEntries.length; ++i) {
+            let entry = sortedEntries[i];
+            if (entry.isDirectory()) {
+                if (options.directories !== false &&
+                    (!globMatcher || globMatcher.match(entry.relativePath))) {
+                    results.push(entry);
+                }
+                results = results.concat(_walkSync(baseDir, options, entry.relativePath, visited));
+            }
+            else {
+                if (!globMatcher || globMatcher.match(entry.relativePath)) {
+                    results.push(entry);
+                }
+            }
+        }
+        return results;
+    }
+    finally {
+        visited.pop();
+    }
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "jr-common-micro",
+  "version": "0.6.1-dev",
+  "description": "",
+  "author": "",
+  "private": false,
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "packageManager": "yarn@1.22.22",
+  "dependencies": {
+    "@bufbuild/buf": "1.31.0",
+    "@bufbuild/protoc-gen-es": "1.9.0",
+    "@connectrpc/protoc-gen-connect-es": "1.4.0",
+    "@grpc/grpc-js": "1.13.4",
+    "@nestjs/cache-manager": "3.0.1",
+    "@nestjs/cli": "11.0.7",
+    "@nestjs/common": "11.1.3",
+    "@nestjs/config": "4.0.2",
+    "@nestjs/core": "11.1.3",
+    "@nestjs/jwt": "11.0.0",
+    "@nestjs/microservices": "11.1.3",
+    "@nestjs/passport": "11.0.5",
+    "@nestjs/platform-express": "11.1.3",
+    "@nestjs/platform-fastify": "11.1.3",
+    "@nestjs/schedule": "6.0.0",
+    "@nestjs/schematics": "11.0.5",
+    "@nestjs/swagger": "11.2.0",
+    "@nestjs/testing": "11.1.3",
+    "@types/bcrypt": "5.0.2",
+    "bcrypt": "6.0.0",
+    "date-fns": "4.1.0",
+    "ensure-posix-path": "1.1.1",
+    "export-all-files-in-folder": "0.1.0",
+    "export-files": "3.0.2",
+    "ioredis": "5.6.1",
+    "kafkajs": "2.2.4",
+    "mime": "4.0.7",
+    "nest-winston": "1.10.2",
+    "nestjs-proto-gen-ts": "1.0.21",
+    "nestjs-zod": "4.3.1",
+    "passport-jwt": "4.0.1",
+    "prisma": "6.10.1",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.2",
+    "ts-proto": "2.7.5",
+    "type-fest": "4.41.0",
+    "winston": "3.17.0",
+    "zod": "3.25.67"
+  },
+  "devDependencies": {
+    "@types/express": "5.0.3",
+    "@types/jest": "30.0.0",
+    "@types/node": "20.14.13",
+    "@types/supertest": "6.0.3",
+    "@typescript-eslint/eslint-plugin": "8.34.1",
+    "@typescript-eslint/parser": "8.34.1",
+    "eslint": "9.29.0",
+    "eslint-config-prettier": "10.1.5",
+    "eslint-plugin-prettier": "5.5.0",
+    "jest": "30.0.2",
+    "jest-mock-extended": "4.0.0",
+    "prettier": "3.5.3",
+    "source-map-support": "0.5.21",
+    "supertest": "7.1.1",
+    "ts-jest": "29.4.0",
+    "ts-loader": "9.5.2",
+    "ts-node": "10.9.2",
+    "tsconfig-paths": "4.2.0",
+    "typescript": "5.8.3"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist; yarn compile; npx tsc; yarn fix-folders",
+    "compile": "rm -rf src/proto/*; npx buf generate proto; yarn put-index",
+    "fix-folders": "mv dist dist2; mv dist2/src dist; rm -rf dist2",
+    "put-index": "node put-index.js",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "DOTENV_CONFIG_PATH=.env.test jest --setupFiles=dotenv/config",
+    "test:watch": "DOTENV_CONFIG_PATH=.env.test jest --watch --setupFiles=dotenv/config",
+    "test:cov": "DOTENV_CONFIG_PATH=.env.test jest --coverage --setupFiles=dotenv/config"
+  }
+}