@l-v-yonsama/multi-platform-database-drivers 0.1.1

package/src/db/resource/types/DBType.ts

@@ -0,0 +1,43 @@
+export enum DBType {
+  ODBC = 50,
+  MySQL = 100,
+  Postgres = 110,
+  Firestore = 150,
+  Mongodb = 200,
+  Redis = 300,
+  AwsS3 = 400,
+  Minio = 402,
+  IndexedDB = 500,
+  Unknown = 9999,
+}
+export namespace DBType {
+  export function parse(s: number): DBType {
+    return s;
+  }
+  export function isAwsOrMinio(s: any): boolean {
+    if (DBType.AwsS3 == s || DBType.Minio == s) {
+      return true;
+    }
+    if ('AwsS3' === s || 'Minio' === s) {
+      return true;
+    }
+    return false;
+  }
+  export function isRDB(s: any): boolean {
+    if (DBType.ODBC == s || DBType.MySQL == s || DBType.Postgres == s) {
+      return true;
+    }
+    return false;
+  }
+  export function currentSupportList(): any[] {
+    const r: any[] = [];
+    r.push({ value: DBType.ODBC, name: 'ODBC' });
+    r.push({ value: DBType.MySQL, name: 'MySQL' });
+    r.push({ value: DBType.Postgres, name: 'Postgres' });
+    r.push({ value: DBType.Redis, name: 'Redis' });
+    r.push({ value: DBType.AwsS3, name: 'AwsS3' });
+    r.push({ value: DBType.Minio, name: 'Minio' });
+    r.push({ value: DBType.IndexedDB, name: 'IndexedDB' });
+    return r;
+  }
+}

package/src/db/resource/types/GeneralColumnType.ts

@@ -0,0 +1,321 @@
+import { EnumValues } from 'enum-values';
+
+export enum GeneralColumnType {
+  BIT,
+  VARBIT,
+  BOOLEAN,
+  CHAR,
+  VARCHAR,
+  TINYTEXT,
+  MEDIUMTEXT,
+  TEXT,
+  LONGTEXT,
+  CLOB,
+  INET,
+  TINYINT,
+  SMALLINT,
+  MEDIUMINT,
+  INTEGER,
+  BIGINT,
+  DECIMAL,
+  LONG,
+  LONGLONG,
+  NUMERIC,
+  FLOAT,
+  DOUBLE_PRECISION,
+  REAL,
+  SERIAL,
+  MONEY,
+  JSON,
+  JSONB,
+  LINE,
+  LSEG,
+  MACADDR,
+  PATH,
+  PG_LSN,
+  POINT,
+  POLYGON,
+  TIME,
+  TIME_WITH_TIME_ZONE,
+  DATE,
+  TIMESTAMP,
+  TIMESTAMP_WITH_TIME_ZONE,
+  YEAR,
+  ENUM,
+  SET,
+  TSQUERY,
+  TSVECTOR,
+  TXID_SNAPSHOT,
+  UUID,
+  CIDR,
+  CIRCLE,
+  BOX,
+  BYTEA,
+  BINARY,
+  BLOB,
+  MEDIUMBLOB,
+  LONGBLOB,
+  XML,
+  NAME,
+  ARRAY,
+  XID,
+  INTERVAL,
+  OID,
+  REGTYPE,
+  REGPROC,
+  PG_NODE_TREE,
+  PG_NDISTINCT,
+  PG_DEPENDENCIES,
+  OBJECT,
+  UNKNOWN = -1,
+}
+export namespace GeneralColumnType {
+  export function parse(s: string | null | undefined): GeneralColumnType {
+    if (s === undefined || s === null) {
+      return GeneralColumnType.UNKNOWN;
+    }
+    s = s.toUpperCase();
+    if ('VAR_STRING' === s) {
+      return GeneralColumnType.VARCHAR;
+    } else if ('TINY' === s) {
+      return GeneralColumnType.TINYINT;
+    } else if ('DATETIME' === s || 'TIMESTAMP(6)' === s) {
+      return GeneralColumnType.TIMESTAMP;
+    } else if ('VARCHAR2' === s) {
+      return GeneralColumnType.VARCHAR;
+    } else if ('NUMBER' === s) {
+      return GeneralColumnType.NUMERIC;
+    }
+    const list = EnumValues.getNamesAndValues(GeneralColumnType);
+    const m = list.find((a) => a.name === s);
+    if (m) {
+      return <number>m.value;
+    }
+    return GeneralColumnType.UNKNOWN;
+  }
+  export function isNumericLike(type: GeneralColumnType): boolean {
+    switch (type) {
+      // number
+      case GeneralColumnType.TINYINT:
+      case GeneralColumnType.SMALLINT:
+      case GeneralColumnType.MEDIUMINT:
+      case GeneralColumnType.INTEGER:
+      case GeneralColumnType.LONG:
+      case GeneralColumnType.LONGLONG:
+      case GeneralColumnType.BIGINT:
+      case GeneralColumnType.SERIAL:
+      case GeneralColumnType.MONEY:
+      case GeneralColumnType.YEAR:
+      case GeneralColumnType.FLOAT:
+      case GeneralColumnType.DOUBLE_PRECISION:
+      case GeneralColumnType.NUMERIC:
+      case GeneralColumnType.DECIMAL:
+        return true;
+    }
+    return false;
+  }
+  export function parseHandsonType(type: GeneralColumnType): string {
+    switch (type) {
+      // number
+      case GeneralColumnType.TINYINT:
+      case GeneralColumnType.SMALLINT:
+      case GeneralColumnType.MEDIUMINT:
+      case GeneralColumnType.INTEGER:
+      case GeneralColumnType.LONG:
+      case GeneralColumnType.LONGLONG:
+      case GeneralColumnType.BIGINT:
+      case GeneralColumnType.SERIAL:
+      case GeneralColumnType.MONEY:
+      case GeneralColumnType.YEAR:
+        return 'numeric_integers';
+      case GeneralColumnType.FLOAT:
+      case GeneralColumnType.DOUBLE_PRECISION:
+      case GeneralColumnType.NUMERIC:
+      case GeneralColumnType.DECIMAL:
+        return 'numeric_decimals';
+      case GeneralColumnType.DATE:
+        return 'date';
+      case GeneralColumnType.TIMESTAMP:
+      case GeneralColumnType.TIMESTAMP_WITH_TIME_ZONE:
+        return 'timestamp';
+      case GeneralColumnType.BIT:
+        return 'text';
+      case GeneralColumnType.VARBIT:
+        return 'text';
+      case GeneralColumnType.BOOLEAN:
+        return 'checkbox';
+      case GeneralColumnType.BOX:
+        return 'text';
+      // blob
+      case GeneralColumnType.BYTEA:
+      case GeneralColumnType.BLOB:
+      case GeneralColumnType.MEDIUMBLOB:
+      case GeneralColumnType.LONGBLOB:
+      case GeneralColumnType.BINARY:
+        return 'text';
+      case GeneralColumnType.INET:
+        return 'text';
+      case GeneralColumnType.CHAR:
+        return 'text';
+      case GeneralColumnType.VARCHAR:
+        return 'text';
+      case GeneralColumnType.CIDR:
+        return 'text';
+      case GeneralColumnType.CIRCLE:
+        return 'text';
+      case GeneralColumnType.JSON:
+        return 'text';
+      case GeneralColumnType.JSONB:
+        return 'text';
+      case GeneralColumnType.LINE:
+        return 'text';
+      case GeneralColumnType.LSEG:
+        return 'text';
+      case GeneralColumnType.MACADDR:
+        return 'text';
+      case GeneralColumnType.PATH:
+        return 'text';
+      case GeneralColumnType.PG_LSN:
+        return 'text';
+      case GeneralColumnType.POINT:
+        return 'text';
+      case GeneralColumnType.POLYGON:
+        return 'text';
+      case GeneralColumnType.REAL:
+        return 'text';
+      case GeneralColumnType.TINYTEXT:
+      case GeneralColumnType.MEDIUMTEXT:
+      case GeneralColumnType.TEXT:
+      case GeneralColumnType.LONGTEXT:
+      case GeneralColumnType.CLOB:
+        return 'text';
+      case GeneralColumnType.TIME:
+        return 'text';
+      case GeneralColumnType.TIME_WITH_TIME_ZONE:
+        return 'text';
+      case GeneralColumnType.TSQUERY:
+        return 'text';
+      case GeneralColumnType.TSVECTOR:
+        return 'text';
+      case GeneralColumnType.TXID_SNAPSHOT:
+        return 'text';
+      case GeneralColumnType.UUID:
+        return 'text';
+      case GeneralColumnType.XML:
+        return 'text';
+      // enum, set
+      case GeneralColumnType.ENUM:
+      case GeneralColumnType.SET:
+        return 'text';
+      case GeneralColumnType.UNKNOWN:
+        return 'text';
+      default:
+        return 'text';
+    }
+  }
+
+  export function parseFaIconType(type: GeneralColumnType): string {
+    switch (type) {
+      // string
+      case GeneralColumnType.CHAR:
+      case GeneralColumnType.VARCHAR:
+      case GeneralColumnType.TINYTEXT:
+      case GeneralColumnType.MEDIUMTEXT:
+      case GeneralColumnType.TEXT:
+      case GeneralColumnType.LONGTEXT:
+      case GeneralColumnType.CLOB:
+        return 'fa-font';
+      // time
+      case GeneralColumnType.TIME:
+      case GeneralColumnType.TIME_WITH_TIME_ZONE:
+        return 'fa-clock';
+      // date
+      case GeneralColumnType.DATE:
+        return 'fa-calendar';
+      // datetime
+      case GeneralColumnType.TIMESTAMP:
+      case GeneralColumnType.TIMESTAMP_WITH_TIME_ZONE:
+        return 'fa-calendar-times';
+      // int, long
+      case GeneralColumnType.TINYINT:
+      case GeneralColumnType.SMALLINT:
+      case GeneralColumnType.INTEGER:
+      case GeneralColumnType.BIGINT:
+      case GeneralColumnType.LONG:
+      case GeneralColumnType.LONGLONG:
+      case GeneralColumnType.SERIAL:
+        return 'fa-sort-numeric-down';
+      // float, double, real
+      case GeneralColumnType.DECIMAL:
+      case GeneralColumnType.FLOAT:
+      case GeneralColumnType.DOUBLE_PRECISION:
+      case GeneralColumnType.REAL:
+        return 'fa-sort-numeric-down';
+      // number
+      case GeneralColumnType.NUMERIC:
+        return 'fa-sort-numeric-down';
+      // money
+      case GeneralColumnType.MONEY:
+        return 'fa-money-bill-alt';
+      // bit
+      case GeneralColumnType.BIT:
+      case GeneralColumnType.VARBIT:
+        return 'fa-chess-board';
+      // boolean
+      case GeneralColumnType.BOOLEAN:
+        return 'fa-chess-board';
+      // json
+      case GeneralColumnType.JSON:
+      case GeneralColumnType.JSONB:
+        return 'fa-code';
+      // binary or blob
+      case GeneralColumnType.BINARY:
+      case GeneralColumnType.BYTEA:
+      case GeneralColumnType.BLOB:
+      case GeneralColumnType.MEDIUMBLOB:
+      case GeneralColumnType.LONGBLOB:
+        return 'fa-chess-board';
+      // array
+      case GeneralColumnType.ARRAY:
+        return 'fa-list';
+      // object
+      case GeneralColumnType.OBJECT:
+        return 'fa-folder';
+      // etc
+      case GeneralColumnType.BOX:
+      case GeneralColumnType.CIDR:
+      case GeneralColumnType.CIRCLE:
+      case GeneralColumnType.INET:
+      case GeneralColumnType.LINE:
+      case GeneralColumnType.LSEG:
+      case GeneralColumnType.MACADDR:
+      case GeneralColumnType.PATH:
+      case GeneralColumnType.PG_LSN:
+      case GeneralColumnType.POINT:
+      case GeneralColumnType.POLYGON:
+      case GeneralColumnType.TSQUERY:
+      case GeneralColumnType.TSVECTOR:
+      case GeneralColumnType.TXID_SNAPSHOT:
+      case GeneralColumnType.UUID:
+      case GeneralColumnType.XML:
+      case GeneralColumnType.NAME:
+      case GeneralColumnType.XID:
+      case GeneralColumnType.INTERVAL:
+      case GeneralColumnType.OID:
+      case GeneralColumnType.REGTYPE:
+      case GeneralColumnType.REGPROC:
+      case GeneralColumnType.PG_NODE_TREE:
+      case GeneralColumnType.PG_NDISTINCT:
+      case GeneralColumnType.PG_DEPENDENCIES:
+      case GeneralColumnType.UNKNOWN:
+        return 'fa-question-circle';
+      // enum, set
+      case GeneralColumnType.ENUM:
+        return 'fa-list';
+      case GeneralColumnType.SET:
+        return 'fa-list-ol';
+      default:
+        return 'fa-question-circle';
+    }
+  }
+}

package/src/db/resource/types/MySQLColumnType.ts

@@ -0,0 +1,134 @@
+import { EnumValues } from 'enum-values';
+import { FieldPacket } from 'mysql2';
+
+export enum MySQLColumnType {
+  DECIMAL = 0x00, // DECIMAL
+  TINYINT = 0x01, // TINYINT, 1 byte
+  SMALLINT = 0x02, // SMALLINT, 2 bytes
+  INTEGER = 3, // (3) integer
+  FLOAT = 0x04, // FLOAT, 4-8 bytes
+  REAL = 0x05, // (5) REAL, DOUBLE, 8 bytes
+  NULL = 0x06, // NULL (used for prepared statements, I think)
+  TIMESTAMP = 0x07, // TIMESTAMP
+  BIGINT = 0x08, // BIGINT, 8 bytes
+  MEDIUMINT = 0x09, // MEDIUMINT, 3 bytes
+  DATE = 0x0a, // DATE
+  TIME = 0x0b, // TIME
+  DATETIME = 0x0c, // DATETIME
+  YEAR = 0x0d, // YEAR, 1 byte (don't ask)
+  NEWDATE = 0x0e, // ?
+  BIT = 0x10, // BIT, 1-8 byte
+  TIMESTAMP2 = 0x11, // TIMESTAMP with fractional seconds
+  DATETIME2 = 0x12, // DATETIME with fractional seconds
+  TIME2 = 0x13, // TIME with fractional seconds
+  JSON = 0xf5, // (245)JSON
+  NUMERIC = 0xf6, // (246)DECIMAL
+  ENUM = 0xf7, // ENUM
+  SET = 0xf8, // SET
+  // TINY_BLOB = 0xf9, // TINYBLOB, TINYTEXT
+  // MEDIUM_BLOB = 0xfa, // MEDIUMBLOB, MEDIUMTEXT
+  // LONG_BLOB = 0xfb, // LONGBLOG, LONGTEXT
+  // BLOB = 0xfc, // (252)BLOB, TEXT
+  VARCHAR = 0xfd, // (253)VARCHAR, VARBINARY
+  POINT = 0xff, // (255)GEOMETRY,
+  TINYTEXT = 1001, // (252)BLOB, TINYTEXT(length: 765, flags: 16,)
+  TEXT = 1002, // (252)TEXt(length: 196605, flags: 16)
+  BLOB = 1012, // (252)BLOB(length: 65535, flags: 144)
+  MEDIUMTEXT = 1003, // (252)BLOB, TEXt(length: 50331645,, flags: 16)
+  MEDIUMBLOB = 1013, // (252)MEDIUMBLOB(length: 16777215,, flags: 144)
+  LONGTEXT = 1004, // (252)BLOB, long TEXT(length: 4294967295,flags: 16)
+  LONGBLOB = 1014, // (252)LONGBLOB,(length: 4294967295,flags: 144)
+  CHAR = 2001, // (254)CHAR(flags: 20483,)
+  BINARY = 2002, // (254)BINARY(flags: 128,)
+  UNKNOWN,
+}
+export namespace MySQLColumnType {
+  export function parseByFieldInfo(fieldInfo: FieldPacket): number {
+    if (fieldInfo === undefined || fieldInfo === null) {
+      return MySQLColumnType.UNKNOWN;
+    }
+    const numOfType = fieldInfo.type.valueOf();
+    const numOfLength = fieldInfo.length || fieldInfo['columnLength'];
+    const flags = fieldInfo.flags;
+    switch (numOfType) {
+      case 252:
+        if (flags === 144) {
+          if (numOfLength === 4294967295) {
+            return MySQLColumnType.LONGBLOB;
+          } else if (numOfLength === 16777215) {
+            return MySQLColumnType.MEDIUMBLOB;
+          } else if (numOfLength === 65535) {
+            return MySQLColumnType.BLOB;
+          }
+          if (numOfLength === 262140) {
+            // Default type
+            return MySQLColumnType.UNKNOWN;
+          }
+        } else {
+          if (
+            numOfLength === 4294967295 ||
+            numOfLength === 589815 ||
+            numOfLength === 589779
+          ) {
+            // flags:17, (length: 589815 | 589779) information_schema.COLUMNS.GENERATION_EXPRESSION => longtext
+            return MySQLColumnType.LONGTEXT;
+          } else if (numOfLength === 50331645) {
+            return MySQLColumnType.MEDIUMTEXT;
+          } else if (numOfLength === 196605) {
+            return MySQLColumnType.TEXT;
+          } else if (numOfLength === 765) {
+            return MySQLColumnType.TINYTEXT;
+          }
+        }
+        console.error(`L83 can't parse from `, fieldInfo);
+        return MySQLColumnType.UNKNOWN;
+      case 254:
+        if (flags === 128) {
+          return MySQLColumnType.BINARY;
+        }
+        return MySQLColumnType.CHAR;
+      default:
+        break;
+    }
+    const e = EnumValues.getNamesAndValues(MySQLColumnType).find(
+      (a) => a.value === numOfType,
+    );
+    if (e) {
+      return e.value as number;
+    }
+    // console.error(`can't parse from `, fieldInfo);
+    return MySQLColumnType.UNKNOWN;
+  }
+
+  export function parse(s: number | string | undefined): MySQLColumnType {
+    if (s === undefined || s === null) {
+      return MySQLColumnType.UNKNOWN;
+    }
+    if (typeof s === 'number') {
+      if (EnumValues.getNameFromValue(MySQLColumnType, s) === null) {
+        return MySQLColumnType.UNKNOWN;
+      }
+      return s;
+    }
+    s = s.toUpperCase();
+    if ('CHAR' === s || 'CHARACTER' === s) {
+      return MySQLColumnType.CHAR;
+    } else if ('INT' === s) {
+      return MySQLColumnType.INTEGER;
+    } else if ('POLYGON' === s) {
+      return MySQLColumnType.POINT;
+    } else if ('DOUBLE' === s) {
+      return MySQLColumnType.REAL;
+    } else if ('LONGLONG' === s) {
+      return MySQLColumnType.BIGINT;
+    }
+    const e = EnumValues.getNamesAndValues(MySQLColumnType).find(
+      (a) => a.name === s,
+    );
+    if (e) {
+      return e.value as MySQLColumnType;
+    }
+    // console.error(`can't parse from `, s, typeof s);
+    return MySQLColumnType.UNKNOWN;
+  }
+}

package/src/db/resource/types/ODBCVendorType.ts

@@ -0,0 +1,3 @@
+export enum ODBCVendorType {
+  Oracle = 'Oracle',
+}

package/src/db/resource/types/PostgresColumnType.ts

@@ -0,0 +1,94 @@
+import { EnumValues } from 'enum-values';
+
+export enum PostgresColumnType {
+  BIGINT = 20,
+  BIT = 1560,
+  VARBIT = 1562,
+  BOOLEAN = 16,
+  BOX = 603,
+  BYTEA = 17,
+  CHAR = 1042,
+  VARCHAR = 1043,
+  CIDR = 650,
+  CIRCLE = 718,
+  DATE = 1082,
+  DOUBLE_PRECISION = 701,
+  INET = 869,
+  INTEGER = 23,
+  JSON = 114,
+  JSONB = 3802,
+  LINE = 628,
+  LSEG = 601,
+  MACADDR = 829,
+  MONEY = 790,
+  NUMERIC = 1700,
+  PATH = 602,
+  PG_LSN = 3220,
+  POINT = 600,
+  POLYGON = 604,
+  REAL = 700,
+  SMALLINT = 21,
+  // SERIAL = 23, dosen't use. INTEGER
+  TEXT = 25,
+  TIME = 1083,
+  TIME_WITH_TIME_ZONE = 1266,
+  TIMESTAMP = 1114,
+  TIMESTAMP_WITH_TIME_ZONE = 1184,
+  TSQUERY = 3615,
+  TSVECTOR = 3614,
+  TXID_SNAPSHOT = 2970,
+  UUID = 2950,
+  XML = 142,
+  NAME,
+  ARRAY,
+  XID,
+  INTERVAL,
+  OID,
+  REGTYPE,
+  REGPROC,
+  PG_NODE_TREE,
+  PG_NDISTINCT,
+  PG_DEPENDENCIES,
+  UNKNOWN = -1,
+}
+export namespace PostgresColumnType {
+  export function parse(s: number | string | undefined): PostgresColumnType {
+    if (s === undefined || s === null) {
+      return PostgresColumnType.UNKNOWN;
+    }
+    if (typeof s === 'number') {
+      if (EnumValues.getNameFromValue(PostgresColumnType, s) === null) {
+        return PostgresColumnType.UNKNOWN;
+      }
+      return s;
+    }
+    s = s.toUpperCase().replace(/"/g, '');
+    if ('CHAR' === s || 'CHARACTER' === s) {
+      return PostgresColumnType.CHAR;
+    } else if ('CHARACTER VARYING' === s) {
+      return PostgresColumnType.VARCHAR;
+    } else if ('DOUBLE PRECISION' === s) {
+      return PostgresColumnType.DOUBLE_PRECISION;
+    } else if ('ANYARRAY' === s) {
+      return PostgresColumnType.ARRAY;
+    } else if ('TIMESTAMP WITH TIME ZONE' === s) {
+      return PostgresColumnType.TIMESTAMP_WITH_TIME_ZONE;
+    } else if ('TIMESTAMP WITHOUT TIME ZONE' === s) {
+      return PostgresColumnType.TIMESTAMP;
+    } else if ('TIME WITH TIME ZONE' === s) {
+      return PostgresColumnType.TIME_WITH_TIME_ZONE;
+    } else if ('ABSTIME' === s || 'TIME WITHOUT TIME ZONE' === s) {
+      return PostgresColumnType.TIME;
+    } else if ('BIT VARYING' === s) {
+      return PostgresColumnType.VARBIT;
+    }
+    const e = EnumValues.getNamesAndValues(PostgresColumnType).find(
+      (a) => a.name === s,
+    );
+    if (e) {
+      return e.value as PostgresColumnType;
+    }
+    // console.error(`can't parse from `, s, typeof s);
+    return PostgresColumnType.UNKNOWN;
+  }
+}

package/src/db/resource/types/RedisKeyType.ts

@@ -0,0 +1,48 @@
+import { EnumValues } from 'enum-values';
+
+export enum RedisKeyType {
+  string = 10,
+  list = 20,
+  set = 30,
+  zset = 40,
+  hash = 50,
+  UNKNOWN,
+}
+export namespace RedisKeyType {
+  export function parse(s: string | number | undefined): RedisKeyType {
+    if (s === undefined) {
+      return RedisKeyType.UNKNOWN;
+    }
+    if (typeof s === 'string') {
+      s = s.toLowerCase();
+      const list = EnumValues.getNamesAndValues(RedisKeyType);
+      const m = list.find((a) => a.name === s);
+      if (m) {
+        return <number>m.value;
+      }
+      console.log('type=', s, ' is unknown.');
+      return RedisKeyType.UNKNOWN;
+    }
+    try {
+      return s;
+    } catch (e) {
+      console.log('type=', s, ' is unknown.');
+      return RedisKeyType.UNKNOWN;
+    }
+  }
+  export function parseFaIconType(type: RedisKeyType): string {
+    switch (type) {
+      case RedisKeyType.string:
+        return 'fa-font';
+      case RedisKeyType.list:
+        return 'fa-list';
+      case RedisKeyType.set:
+      case RedisKeyType.zset:
+        return 'fa-list-ol';
+      case RedisKeyType.hash:
+        return 'fa-h-square';
+      default:
+        return 'fa-question-circle';
+    }
+  }
+}

package/src/db/resource/types/ResourceType.ts

@@ -0,0 +1,10 @@
+export enum ResourceType {
+  Connection,
+  Database,
+  Schema,
+  Table,
+  Column,
+  Key,
+  Bucket,
+  Owner,
+}

package/src/main.ts

@@ -0,0 +1 @@
+console.log('hoge');

package/src/service/request/general_db_request.ts

@@ -0,0 +1,20 @@
+export interface GeneralDbRequest {
+    command: GeneralDbCommandType;
+    connection_id?: string;
+    connection_def_name?: string;
+    label?: string;
+    sql?: string;
+    needs_column_resolve?: boolean;
+    options?: any;
+}
+
+export enum GeneralDbCommandType {
+    CountTables = 'CountTables',
+    ListByParams = 'ListByParams',
+    ListProposals = 'ListProposals',
+    ExecuteSql = 'ExecuteSql',
+    TestConnection = 'TestConnection',
+    ToggleConnection = 'ToggleConnection',
+    BatchInsertFromArray = 'BatchInsertFromArray'
+}
+

package/src/service/request/redis_request.ts

@@ -0,0 +1,21 @@
+import { RedisKeyType } from '../../db/resource/types/RedisKeyType';
+
+export interface RedisRequest {
+    connection_id: string;
+    index: number;
+    command: RedisCommandType;
+    key?: string;
+    type?: RedisKeyType;
+    options?: any;
+}
+
+export enum RedisCommandType {
+    Dbsize = 'dbsize',
+    Flushall = 'Flushall',
+    Flushdb = 'Flushdb',
+    GetValue = 'GetValue',
+    Info = 'info',
+    Scan = 'Scan',
+    SetValue = 'SetValue',
+}
+