@tomsd/redis-client 1.0.2 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Redis: () => Redis
+});
+module.exports = __toCommonJS(src_exports);
+var import_ioredis = __toESM(require("ioredis"), 1);
+var import_uuid = require("uuid");
+var Redis = class {
+  config;
+  redis;
+  constructor(config) {
+    this.config = config;
+    this.redis = void 0;
+  }
+  get keyProp() {
+    return this.config.keyProp ?? "_id";
+  }
+  get expireSeconds() {
+    return this.config.expireSeconds;
+  }
+  getRedis() {
+    this.redis = this.redis ?? new import_ioredis.default(this.config.options);
+    return this.redis;
+  }
+  async getKeys() {
+    const keyFilter = `${this.config?.options?.keyPrefix ?? ""}*`;
+    const sliceKey = (s) => s.slice(this.config?.options?.keyPrefix?.length ?? 0);
+    return await this.getRedis().keys(keyFilter).then((keys) => keys.map(sliceKey));
+  }
+  async get(key) {
+    return await this.getRedis().get(key).then((value) => {
+      if (value == null) {
+        return void 0;
+      }
+      return JSON.parse(value);
+    });
+  }
+  async set(value) {
+    const redis = this.getRedis();
+    const savingObj = {
+      [this.keyProp]: (0, import_uuid.v4)(),
+      ...value
+    };
+    const key = savingObj[this.keyProp];
+    return this.expireSeconds !== void 0 ? await redis.set(key, JSON.stringify(savingObj), "EX", this.expireSeconds).then(() => savingObj) : await redis.set(key, JSON.stringify(savingObj)).then(() => savingObj);
+  }
+  async del(key) {
+    return await this.getRedis().del(key);
+  }
+  disconnect() {
+    this.getRedis().disconnect();
+    this.redis = void 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Redis
+});

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+import IORedis, { RedisOptions } from 'ioredis';
+
+interface EasyRedisConfig {
+    keyProp?: string;
+    expireSeconds?: number;
+    options: RedisOptions;
+}
+declare class Redis<T = any> {
+    config: EasyRedisConfig;
+    protected redis: IORedis | undefined;
+    constructor(config: EasyRedisConfig);
+    get keyProp(): string;
+    get expireSeconds(): number | undefined;
+    getRedis(): IORedis;
+    getKeys(): Promise<string[]>;
+    get(key: string): Promise<T>;
+    set(value: T | Partial<T>): Promise<T>;
+    del(key: string): Promise<number>;
+    disconnect(): void;
+}
+
+export { Redis };

package/dist/{esm/index.d.ts → index.d.ts}

@@ -1,10 +1,11 @@
-import IORedis, { type RedisOptions } from "ioredis";
+import IORedis, { RedisOptions } from 'ioredis';
+
 interface EasyRedisConfig {
     keyProp?: string;
     expireSeconds?: number;
     options: RedisOptions;
 }
-export declare class Redis<T = any> {
+declare class Redis<T = any> {
     config: EasyRedisConfig;
     protected redis: IORedis | undefined;
     constructor(config: EasyRedisConfig);
@@ -17,4 +18,5 @@ export declare class Redis<T = any> {
     del(key: string): Promise<number>;
     disconnect(): void;
 }
-export {};
+
+export { Redis };

package/dist/index.js

@@ -0,0 +1,53 @@
+// src/index.ts
+import IORedis from "ioredis";
+import { v4 as uuid } from "uuid";
+var Redis = class {
+  config;
+  redis;
+  constructor(config) {
+    this.config = config;
+    this.redis = void 0;
+  }
+  get keyProp() {
+    return this.config.keyProp ?? "_id";
+  }
+  get expireSeconds() {
+    return this.config.expireSeconds;
+  }
+  getRedis() {
+    this.redis = this.redis ?? new IORedis(this.config.options);
+    return this.redis;
+  }
+  async getKeys() {
+    const keyFilter = `${this.config?.options?.keyPrefix ?? ""}*`;
+    const sliceKey = (s) => s.slice(this.config?.options?.keyPrefix?.length ?? 0);
+    return await this.getRedis().keys(keyFilter).then((keys) => keys.map(sliceKey));
+  }
+  async get(key) {
+    return await this.getRedis().get(key).then((value) => {
+      if (value == null) {
+        return void 0;
+      }
+      return JSON.parse(value);
+    });
+  }
+  async set(value) {
+    const redis = this.getRedis();
+    const savingObj = {
+      [this.keyProp]: uuid(),
+      ...value
+    };
+    const key = savingObj[this.keyProp];
+    return this.expireSeconds !== void 0 ? await redis.set(key, JSON.stringify(savingObj), "EX", this.expireSeconds).then(() => savingObj) : await redis.set(key, JSON.stringify(savingObj)).then(() => savingObj);
+  }
+  async del(key) {
+    return await this.getRedis().del(key);
+  }
+  disconnect() {
+    this.getRedis().disconnect();
+    this.redis = void 0;
+  }
+};
+export {
+  Redis
+};

package/package.json

@@ -1,32 +1,33 @@
 {
   "name": "@tomsd/redis-client",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "It's a wrapper of ioredis.",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/esm/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc --project tsconfig.cjs.json && tsc --project tsconfig.esm.json",
-    "format": "npm run format:src && npm run format:test",
-    "format:src": "prettier --write src/",
-    "format:test": "prettier --write __test__/",
-    "lint": "npm run lint:src && npm run lint:test",
-    "lint:src": "eslint src/**/*.ts",
-    "lint:test": "eslint __test__/**/*.ts",
+    "build": "tsup",
+    "lint": "biome check",
     "prepare": "husky",
     "start-redis": "docker run --rm -d -p 6379:6379 --name redis-instance redis:alpine",
     "stop-redis": "docker container stop redis-instance",
     "serve:doc": "mdbook --serve --directory docs",
-    "test": "jest"
+    "test": "vitest"
   },
   "lint-staged": {
     "src/**/*.ts": [
-      "npm run lint:src",
-      "npm run format:src"
+      "npm run lint"
     ],
     "__test__/**/*.ts": [
-      "npm run lint:test",
-      "npm run format:test"
+      "npm run lint"
     ]
   },
   "repository": {
@@ -43,24 +44,16 @@
   },
   "homepage": "https://github.com/tomsdoo/redis-client#readme",
   "devDependencies": {
-    "@babel/core": "7.26.0",
-    "@babel/preset-env": "7.26.0",
-    "@babel/preset-typescript": "7.26.0",
+    "@biomejs/biome": "1.9.4",
     "@tomsd/md-book": "1.3.3",
+    "@types/node": "22.10.1",
     "@types/uuid": "10.0.0",
-    "@typescript-eslint/eslint-plugin": "8.16.0",
-    "babel-jest": "29.7.0",
-    "eslint": "8.57.1",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-n": "17.14.0",
-    "eslint-plugin-promise": "7.2.1",
     "husky": "9.1.7",
-    "jest": "29.7.0",
     "lint-staged": "15.2.10",
-    "prettier": "3.4.1",
     "ts-node": "10.9.2",
-    "typescript": "5.7.2"
+    "tsup": "8.3.5",
+    "typescript": "5.7.2",
+    "vitest": "2.1.6"
   },
   "dependencies": {
     "ioredis": "5.4.1",

package/.eslintrc-love-temp.cjs

@@ -1,367 +0,0 @@
-// renaming standard-with-typescript -> eslint-config-love
-
-const rules = {
-  '@typescript-eslint/adjacent-overload-signatures': ['error'],
-  '@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
-  '@typescript-eslint/await-thenable': ['error'],
-  '@typescript-eslint/ban-ts-comment': ['error', {
-    'ts-expect-error': 'allow-with-description',
-    'ts-ignore': true,
-    'ts-nocheck': true,
-    'ts-check': false,
-    minimumDescriptionLength: 3
-  }],
-  '@typescript-eslint/ban-tslint-comment': ['error'],
-  '@typescript-eslint/no-empty-object-type': 'error',
-  '@typescript-eslint/no-unsafe-function-type': 'error',
-  '@typescript-eslint/no-wrapper-object-types': 'error',
-  '@typescript-eslint/block-spacing': ['error', 'always'],
-  '@typescript-eslint/brace-style': ['error', '1tbs', { allowSingleLine: true }],
-  '@typescript-eslint/class-literal-property-style': ['error', 'fields'],
-  '@typescript-eslint/comma-dangle': ['error', {
-    arrays: 'never',
-    objects: 'never',
-    imports: 'never',
-    exports: 'never',
-    functions: 'never',
-    enums: 'ignore',
-    generics: 'ignore',
-    tuples: 'ignore'
-  }],
-  '@typescript-eslint/comma-spacing': ['error', { before: false, after: true }],
-  '@typescript-eslint/consistent-generic-constructors': ['error', 'constructor'],
-  '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
-  '@typescript-eslint/consistent-type-assertions': [
-    'error',
-    {
-      assertionStyle: 'as',
-      objectLiteralTypeAssertions: 'never'
-    }
-  ],
-  '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
-  '@typescript-eslint/consistent-type-exports': ['error', {
-    fixMixedExportsWithInlineTypeSpecifier: true
-  }],
-  '@typescript-eslint/consistent-type-imports': ['error', {
-    prefer: 'type-imports',
-    disallowTypeAnnotations: true,
-    fixStyle: 'inline-type-imports'
-  }],
-  '@typescript-eslint/dot-notation': ['error',
-    {
-      allowIndexSignaturePropertyAccess: false,
-      allowKeywords: true,
-      allowPattern: '',
-      allowPrivateClassPropertyAccess: false,
-      allowProtectedClassPropertyAccess: false
-    }
-  ],
-  '@typescript-eslint/explicit-function-return-type': ['error', {
-    allowExpressions: true,
-    allowHigherOrderFunctions: true,
-    allowTypedFunctionExpressions: true,
-    allowDirectConstAssertionInArrowFunctions: true
-  }],
-  '@typescript-eslint/func-call-spacing': ['error', 'never'],
-  '@typescript-eslint/indent': ['error', 2, {
-    SwitchCase: 1,
-    VariableDeclarator: 1,
-    outerIIFEBody: 1,
-    MemberExpression: 1,
-    FunctionDeclaration: { parameters: 1, body: 1 },
-    FunctionExpression: { parameters: 1, body: 1 },
-    CallExpression: { arguments: 1 },
-    ArrayExpression: 1,
-    ObjectExpression: 1,
-    ImportDeclaration: 1,
-    flatTernaryExpressions: false,
-    ignoreComments: false,
-    ignoredNodes: [
-      'TemplateLiteral *',
-      'JSXElement',
-      'JSXElement > *',
-      'JSXAttribute',
-      'JSXIdentifier',
-      'JSXNamespacedName',
-      'JSXMemberExpression',
-      'JSXSpreadAttribute',
-      'JSXExpressionContainer',
-      'JSXOpeningElement',
-      'JSXClosingElement',
-      'JSXFragment',
-      'JSXOpeningFragment',
-      'JSXClosingFragment',
-      'JSXText',
-      'JSXEmptyExpression',
-      'JSXSpreadChild'
-    ],
-    offsetTernaryExpressions: true
-  }],
-  '@typescript-eslint/key-spacing': ['error', { beforeColon: false, afterColon: true }],
-  '@typescript-eslint/keyword-spacing': ['error', { before: true, after: true }],
-  '@typescript-eslint/member-delimiter-style': [
-    'error',
-    {
-      multiline: { delimiter: 'none' },
-      singleline: { delimiter: 'comma', requireLast: false }
-    }
-  ],
-  '@typescript-eslint/method-signature-style': ['error'],
-  '@typescript-eslint/naming-convention': ['error', {
-    selector: 'variableLike',
-    leadingUnderscore: 'allow',
-    trailingUnderscore: 'allow',
-    format: ['camelCase', 'PascalCase', 'UPPER_CASE']
-  }],
-  '@typescript-eslint/no-array-constructor': ['error'],
-  '@typescript-eslint/no-base-to-string': ['error'],
-  '@typescript-eslint/no-confusing-void-expression': ['error', { ignoreArrowShorthand: false, ignoreVoidOperator: false }],
-  '@typescript-eslint/no-dupe-class-members': ['error'],
-  '@typescript-eslint/no-dynamic-delete': ['error'],
-  '@typescript-eslint/no-empty-interface': ['error', { allowSingleExtends: true }],
-  '@typescript-eslint/no-extra-non-null-assertion': ['error'],
-  '@typescript-eslint/no-extra-parens': ['error', 'functions'],
-  '@typescript-eslint/no-extraneous-class': ['error', { allowWithDecorator: true }],
-  '@typescript-eslint/no-floating-promises': ['error'],
-  '@typescript-eslint/no-for-in-array': ['error'],
-  '@typescript-eslint/no-implied-eval': ['error'],
-  '@typescript-eslint/no-invalid-void-type': ['error'],
-  '@typescript-eslint/no-loss-of-precision': ['error'],
-  '@typescript-eslint/no-misused-new': ['error'],
-  '@typescript-eslint/no-misused-promises': ['error'],
-  '@typescript-eslint/no-namespace': ['error'],
-  '@typescript-eslint/no-non-null-asserted-optional-chain': ['error'],
-  '@typescript-eslint/no-non-null-assertion': ['error'],
-  '@typescript-eslint/no-redeclare': ['error', { builtinGlobals: false }],
-  '@typescript-eslint/no-this-alias': ['error', { allowDestructuring: true }],
-  '@typescript-eslint/only-throw-error': ['error'],
-  '@typescript-eslint/no-unnecessary-boolean-literal-compare': ['error'],
-  '@typescript-eslint/no-unnecessary-type-assertion': ['error'],
-  '@typescript-eslint/no-unnecessary-type-constraint': ['error'],
-  '@typescript-eslint/no-unsafe-argument': ['error'],
-  '@typescript-eslint/no-unused-expressions': ['error', {
-    allowShortCircuit: true,
-    allowTernary: true,
-    allowTaggedTemplates: true,
-    enforceForJSX: false
-  }],
-  '@typescript-eslint/no-unused-vars': ['error', {
-    args: 'none',
-    caughtErrors: 'none',
-    ignoreRestSiblings: true,
-    vars: 'all'
-  }],
-  '@typescript-eslint/no-use-before-define': ['error', {
-    functions: false,
-    classes: false,
-    enums: false,
-    variables: false,
-    typedefs: false
-  }],
-  '@typescript-eslint/no-useless-constructor': ['error'],
-  '@typescript-eslint/no-var-requires': ['error'],
-  '@typescript-eslint/non-nullable-type-assertion-style': ['error'],
-  '@typescript-eslint/object-curly-spacing': ['error', 'always'],
-  '@typescript-eslint/prefer-function-type': ['error'],
-  '@typescript-eslint/prefer-includes': ['error'],
-  '@typescript-eslint/prefer-nullish-coalescing': ['error', { ignoreConditionalTests: false, ignoreMixedLogicalExpressions: false }],
-  '@typescript-eslint/prefer-optional-chain': ['error'],
-  '@typescript-eslint/prefer-promise-reject-errors': ['error'],
-  '@typescript-eslint/prefer-readonly': ['error'],
-  '@typescript-eslint/prefer-reduce-type-parameter': ['error'],
-  '@typescript-eslint/prefer-return-this-type': ['error'],
-  '@typescript-eslint/prefer-ts-expect-error': ['error'],
-  '@typescript-eslint/promise-function-async': ['error'],
-  '@typescript-eslint/quotes': ['error', 'single', { avoidEscape: true, allowTemplateLiterals: false }],
-  '@typescript-eslint/require-array-sort-compare': ['error', { ignoreStringArrays: true }],
-  '@typescript-eslint/restrict-plus-operands': ['error', { skipCompoundAssignments: false }],
-  '@typescript-eslint/restrict-template-expressions': ['error', { allowNumber: true }],
-  '@typescript-eslint/return-await': ['error', 'always'],
-  '@typescript-eslint/semi': ['error', 'never'],
-  '@typescript-eslint/space-before-blocks': ['error', 'always'],
-  '@typescript-eslint/space-before-function-paren': ['error', 'always'],
-  '@typescript-eslint/space-infix-ops': ['error'],
-  '@typescript-eslint/strict-boolean-expressions': ['error', {
-    allowString: false,
-    allowNumber: false,
-    allowNullableObject: false,
-    allowNullableBoolean: false,
-    allowNullableString: false,
-    allowNullableNumber: false,
-    allowAny: false
-  }],
-  '@typescript-eslint/triple-slash-reference': ['error', { lib: 'never', path: 'never', types: 'never' }],
-  '@typescript-eslint/type-annotation-spacing': ['error'],
-  '@typescript-eslint/unbound-method': ['error', { ignoreStatic: false }],
-
-  'accessor-pairs': ['error', { setWithoutGet: true, getWithoutSet: false, enforceForClassMembers: true }],
-  'array-bracket-spacing': ['error', 'never'],
-  'array-callback-return': ['error', {
-    allowImplicit: false,
-    allowVoid: false,
-    checkForEach: false
-  }],
-  'arrow-spacing': ['error', { before: true, after: true }],
-  'comma-style': ['error', 'last'],
-  'computed-property-spacing': ['error', 'never', { enforceForClassMembers: true }],
-  'constructor-super': ['error'],
-  curly: ['error', 'multi-line'],
-  'default-case-last': ['error'],
-  'dot-location': ['error', 'property'],
-  'eol-last': ['error'],
-  eqeqeq: ['error', 'always', { null: 'ignore' }],
-  'generator-star-spacing': ['error', { before: true, after: true }],
-  'multiline-ternary': ['error', 'always-multiline'],
-  'new-cap': ['error', { newIsCap: true, capIsNew: false, properties: true }],
-  'new-parens': ['error'],
-  'no-async-promise-executor': ['error'],
-  'no-caller': ['error'],
-  'no-case-declarations': ['error'],
-  'no-class-assign': ['error'],
-  'no-compare-neg-zero': ['error'],
-  'no-cond-assign': ['error'],
-  'no-const-assign': ['error'],
-  'no-constant-condition': ['error', { checkLoops: false }],
-  'no-control-regex': ['error'],
-  'no-debugger': ['error'],
-  'no-delete-var': ['error'],
-  'no-dupe-args': ['error'],
-  'no-dupe-keys': ['error'],
-  'no-duplicate-case': ['error'],
-  'no-useless-backreference': ['error'],
-  'no-empty': ['error', { allowEmptyCatch: true }],
-  'no-empty-character-class': ['error'],
-  'no-empty-pattern': ['error'],
-  'no-eval': ['error'],
-  'no-ex-assign': ['error'],
-  'no-extend-native': ['error'],
-  'no-extra-bind': ['error'],
-  'no-extra-boolean-cast': ['error'],
-  'no-fallthrough': ['error'],
-  'no-floating-decimal': ['error'],
-  'no-func-assign': ['error'],
-  'no-global-assign': ['error'],
-  'no-import-assign': ['error'],
-  'no-invalid-regexp': ['error'],
-  'no-irregular-whitespace': ['error'],
-  'no-iterator': ['error'],
-  'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
-  'no-lone-blocks': ['error'],
-  'no-misleading-character-class': ['error'],
-  'no-prototype-builtins': ['error'],
-  'no-useless-catch': ['error'],
-  'no-mixed-operators': ['error', {
-    groups: [
-      ['==', '!=', '===', '!==', '>', '>=', '<', '<='],
-      ['&&', '||'],
-      ['in', 'instanceof']
-    ],
-    allowSamePrecedence: true
-  }],
-  'no-mixed-spaces-and-tabs': ['error'],
-  'no-multi-spaces': ['error'],
-  'no-multi-str': ['error'],
-  'no-multiple-empty-lines': ['error', { max: 1, maxBOF: 0, maxEOF: 0 }],
-  'no-new': ['error'],
-  'no-new-func': ['error'],
-  'no-new-object': ['error'],
-  'no-new-symbol': ['error'],
-  'no-new-wrappers': ['error'],
-  'no-obj-calls': ['error'],
-  'no-octal': ['error'],
-  'no-octal-escape': ['error'],
-  'no-proto': ['error'],
-  'no-regex-spaces': ['error'],
-  'no-return-assign': ['error', 'except-parens'],
-  'no-self-assign': ['error', { props: true }],
-  'no-self-compare': ['error'],
-  'no-sequences': ['error'],
-  'no-shadow-restricted-names': ['error'],
-  'no-sparse-arrays': ['error'],
-  'no-tabs': ['error'],
-  'no-template-curly-in-string': ['error'],
-  'no-this-before-super': ['error'],
-  'no-trailing-spaces': ['error'],
-  'no-undef-init': ['error'],
-  'no-unexpected-multiline': ['error'],
-  'no-unmodified-loop-condition': ['error'],
-  'no-unneeded-ternary': ['error', { defaultAssignment: false }],
-  'no-unreachable': ['error'],
-  'no-unreachable-loop': ['error'],
-  'no-unsafe-finally': ['error'],
-  'no-unsafe-negation': ['error'],
-  'no-useless-call': ['error'],
-  'no-useless-computed-key': ['error'],
-  'no-useless-escape': ['error'],
-  'no-useless-rename': ['error'],
-  'no-useless-return': ['error'],
-  'no-var': ['warn'],
-  'no-void': ['error', { allowAsStatement: true }],
-  'no-whitespace-before-property': ['error'],
-  'no-with': ['error'],
-  'object-curly-newline': ['error', { multiline: true, consistent: true }],
-  'object-property-newline': ['error', { allowMultiplePropertiesPerLine: true, allowAllPropertiesOnSameLine: false }],
-  'object-shorthand': ['warn', 'properties'],
-  'one-var': ['error', { initialized: 'never' }],
-  'operator-linebreak': ['error', 'after', { overrides: { '?': 'before', ':': 'before', '|>': 'before' } }],
-  'padded-blocks': ['error', { blocks: 'never', switches: 'never', classes: 'never' }],
-  'prefer-const': ['error', { destructuring: 'all', ignoreReadBeforeAssign: false }],
-  'prefer-regex-literals': ['error', { disallowRedundantWrapping: true }],
-  'quote-props': ['error', 'as-needed'],
-  'rest-spread-spacing': ['error', 'never'],
-  'semi-spacing': ['error', { before: false, after: true }],
-  'space-in-parens': ['error', 'never'],
-  'space-unary-ops': ['error', { words: true, nonwords: false }],
-  'spaced-comment': ['error', 'always', {
-    line: { markers: ['*package', '!', '/', ',', '='] },
-    block: { balanced: true, markers: ['*package', '!', ',', ':', '::', 'flow-include'], exceptions: ['*'] }
-  }],
-  'symbol-description': ['error'],
-  'template-curly-spacing': ['error', 'never'],
-  'template-tag-spacing': ['error', 'never'],
-  'unicode-bom': ['error', 'never'],
-  'use-isnan': ['error', {
-    enforceForSwitchCase: true,
-    enforceForIndexOf: true
-  }],
-  'valid-typeof': ['error', { requireStringLiterals: true }],
-  'wrap-iife': ['error', 'any', { functionPrototypeMethods: true }],
-  'yield-star-spacing': ['error', 'both'],
-  yoda: ['error', 'never'],
-
-  'import/export': ['error'],
-  'import/first': ['error'],
-  'import/no-absolute-path': ['error', { esmodule: true, commonjs: true, amd: false }],
-  'import/no-duplicates': ['error'],
-  'import/no-named-default': ['error'],
-  'import/no-webpack-loader-syntax': ['error'],
-
-  'n/handle-callback-err': ['error', '^(err|error)$'],
-  'n/no-callback-literal': ['error'],
-  'n/no-deprecated-api': ['error'],
-  'n/no-exports-assign': ['error'],
-  'n/no-new-require': ['error'],
-  'n/no-path-concat': ['error'],
-  'n/process-exit-as-throw': ['error'],
-
-  'promise/param-names': ['error']
-}
-
-const config = {
-  plugins: [
-    '@typescript-eslint',
-    'import',
-    'n',
-    'promise'
-  ],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: true
-  },
-  rules: {
-    ...rules
-  }
-
-}
-
-module.exports = config;

package/.eslintrc.json

@@ -1,17 +0,0 @@
-{
-  "env": {
-    "es2021": true,
-    "node": true
-  },
-  "extends": [
-    "./.eslintrc-love-temp.cjs",
-    "prettier"
-  ],
-  "overrides": [],
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module",
-    "project": "tsconfig.json"
-  },
-  "rules": {}
-}

package/dist/cjs/index.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Redis = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const uuid_1 = require("uuid");
-class Redis {
-    constructor(config) {
-        this.config = config;
-        this.redis = undefined;
-    }
-    get keyProp() {
-        var _a;
-        return (_a = this.config.keyProp) !== null && _a !== void 0 ? _a : "_id";
-    }
-    get expireSeconds() {
-        return this.config.expireSeconds;
-    }
-    getRedis() {
-        var _a;
-        this.redis = (_a = this.redis) !== null && _a !== void 0 ? _a : new ioredis_1.default(this.config.options);
-        return this.redis;
-    }
-    async getKeys() {
-        var _a, _b, _c;
-        const keyFilter = `${(_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.keyPrefix) !== null && _c !== void 0 ? _c : ""}*`;
-        const sliceKey = (s) => { var _a, _b, _c, _d; return s.slice((_d = (_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.keyPrefix) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0); };
-        return await this.getRedis()
-            .keys(keyFilter)
-            .then((keys) => keys.map(sliceKey));
-    }
-    async get(key) {
-        return await this.getRedis()
-            .get(key)
-            .then((value) => {
-            if (value == null) {
-                return undefined;
-            }
-            return JSON.parse(value);
-        });
-    }
-    async set(value) {
-        const redis = this.getRedis();
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const savingObj = {
-            [this.keyProp]: (0, uuid_1.v4)(),
-            ...value,
-        };
-        // @ts-expect-error prop name
-        const key = savingObj[this.keyProp];
-        return this.expireSeconds !== undefined
-            ? await redis
-                .set(key, JSON.stringify(savingObj), "EX", this.expireSeconds)
-                .then(() => savingObj)
-            : await redis.set(key, JSON.stringify(savingObj)).then(() => savingObj);
-    }
-    async del(key) {
-        return await this.getRedis().del(key);
-    }
-    disconnect() {
-        this.getRedis().disconnect();
-        this.redis = undefined;
-    }
-}
-exports.Redis = Redis;

package/dist/esm/index.js

@@ -1,74 +0,0 @@
-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 IORedis from "ioredis";
-import { v4 as uuid } from "uuid";
-export class Redis {
-    constructor(config) {
-        this.config = config;
-        this.redis = undefined;
-    }
-    get keyProp() {
-        var _a;
-        return (_a = this.config.keyProp) !== null && _a !== void 0 ? _a : "_id";
-    }
-    get expireSeconds() {
-        return this.config.expireSeconds;
-    }
-    getRedis() {
-        var _a;
-        this.redis = (_a = this.redis) !== null && _a !== void 0 ? _a : new IORedis(this.config.options);
-        return this.redis;
-    }
-    getKeys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const keyFilter = `${(_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.keyPrefix) !== null && _c !== void 0 ? _c : ""}*`;
-            const sliceKey = (s) => { var _a, _b, _c, _d; return s.slice((_d = (_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.keyPrefix) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0); };
-            return yield this.getRedis()
-                .keys(keyFilter)
-                .then((keys) => keys.map(sliceKey));
-        });
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getRedis()
-                .get(key)
-                .then((value) => {
-                if (value == null) {
-                    return undefined;
-                }
-                return JSON.parse(value);
-            });
-        });
-    }
-    set(value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redis = this.getRedis();
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const savingObj = Object.assign({ [this.keyProp]: uuid() }, value);
-            // @ts-expect-error prop name
-            const key = savingObj[this.keyProp];
-            return this.expireSeconds !== undefined
-                ? yield redis
-                    .set(key, JSON.stringify(savingObj), "EX", this.expireSeconds)
-                    .then(() => savingObj)
-                : yield redis.set(key, JSON.stringify(savingObj)).then(() => savingObj);
-        });
-    }
-    del(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getRedis().del(key);
-        });
-    }
-    disconnect() {
-        this.getRedis().disconnect();
-        this.redis = undefined;
-    }
-}

package/tryit/addArticle.ts

@@ -1,13 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  console.log(
-    await clients.articleRedis.set({
-      title: "john's article",
-      body: "body",
-      author: "john@test.test",
-    })
-  );
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());

package/tryit/addUser.ts

@@ -1,12 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  console.log(
-    await clients.userRedis.set({
-      name: "john",
-      email: "john@test.test",
-    })
-  )
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());

package/tryit/common.ts

@@ -1,31 +0,0 @@
-import { Redis } from "../src/";
-
-interface User {
-  email: string;
-  name: string;
-}
-
-interface Article {
-  _id: string;
-  author: string;
-  title: string;
-  body: string;
-}
-
-export const clients = {
-  userRedis: new Redis<User>({
-    keyProp: "email",
-    options: {
-      port: 6379,
-      host: "localhost",
-      keyPrefix: "user",
-    },
-  }),
-  articleRedis: new Redis<Article>({
-    options: {
-      port: 6379,
-      host: "localhost",
-      keyPrefix: "article",
-    },
-  }),
-};

package/tryit/delArticle.ts

@@ -1,20 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  const beforeKeys = await clients.articleRedis.getKeys();
-
-  const [ key, ...rest ] = beforeKeys;
-
-  console.log(
-    await clients.articleRedis.del(key)
-  );
-
-  const afterKeys = await clients.articleRedis.getKeys();
-  console.log({
-    beforeKeyCount: beforeKeys.length,
-    afterKeyCount: afterKeys.length,
-  });
-
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());

package/tryit/delUser.ts

@@ -1,19 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  const beforeKeys = await clients.userRedis.getKeys();
-
-  const [ key, ...rest ] = beforeKeys;
-
-  console.log(
-    await clients.userRedis.del(key)
-  );
-
-  const afterKeys = await clients.userRedis.getKeys();
-  console.log({
-    beforeKeyCount: beforeKeys.length,
-    afterKeyCount: afterKeys.length,
-  });
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());

package/tryit/getArticles.ts

@@ -1,13 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  const keys = await clients.articleRedis.getKeys();
-
-  for(const key of keys) {
-    console.log(
-      await clients.articleRedis.get(key)
-    );
-  }
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());

package/tryit/getUsers.ts

@@ -1,14 +0,0 @@
-import { clients } from "./common";
-
-(async () => {
-  const keys = await clients.userRedis.getKeys();
-
-  for(const key of keys) {
-    console.log(
-      await clients.userRedis.get(key)
-    );
-  }
-})()
-  .then(() => process.exit())
-  .catch(() => process.exit());
-

package/tryit/seed.ts

@@ -1,35 +0,0 @@
-import { clients } from "./common";
-
-const users = [
-  "alice",
-  "bob",
-  "charlie",
-]
-  .map(name => ({
-    name,
-    email: `${name}@test.test`,
-  }));
-
-const articles = users.map(user => ({
-  title: `${user.name}'s article`,
-  body: "some body",
-  author: user.email,
-}));
-
-(async () => {
-  for(const user of users){
-    await clients.userRedis.set(user);
-  }
-
-  for(const article of articles){
-    await clients.articleRedis.set(article);
-  }
-  
-})()
-  .then(() => {
-    process.exit();
-  })
-  .catch((e) => {
-    console.log(e);
-    process.exit();
-  });