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

package/__tests__/db/drivers/MySQLDriver.test.ts

@@ -1,140 +0,0 @@
-import MySQLDriver from '../../../src/db/drivers/MySQLDriver';
-import {
-  DbConnection,
-  DbResource,
-  DbSchema,
-  DbTable,
-  DbColumn,
-} from '../../../src/db/resource/DbResource';
-import { DBType } from '../../../src/db/resource/types/DBType';
-import * as mysql from 'mysql2/promise';
-import { ResultSetHeader } from 'mysql2/promise';
-import { GeneralColumnType } from '../../../src/db/resource/types/GeneralColumnType';
-
-const baseConnectOption = {
-  host: '127.0.0.1',
-  port: 6001,
-  user: 'testuser',
-  password: 'testpass',
-  database: 'testdb',
-};
-const connectOption = {
-  ...baseConnectOption,
-  db_type: DBType.MySQL,
-  enviroment: 'ut',
-};
-
-const CREATE_TABLE_STATEMENT = `
-CREATE TABLE testtable (
-  ID int auto_increment PRIMARY KEY,
-  n0 BIT,
-  n1 TINYINT COMMENT 'MAX 127',
-  n2 SMALLINT COMMENT 'MAX 32767',
-  n3 MEDIUMINT COMMENT 'MAX 8388607',
-  n4 BIGINT COMMENT 'MAX 9223372036854775807',
-  f1 DECIMAL(6,4),
-  f2 FLOAT,
-  f3 DOUBLE,
-
-  d1 DATE COMMENT '“Zero” Value 0000-00-00',
-  d2 TIME COMMENT '“Zero” Value 00:00:00', 
-  d3 DATETIME COMMENT '“Zero” Value 0000-00-00 00:00:00',
-  d4 TIMESTAMP COMMENT '“Zero” Value 0000-00-00 00:00:00', 
-  d5 YEAR COMMENT '“Zero” Value 0000',
-
-  s1 CHAR(10),
-  s2 VARCHAR(10), 
-  s3 TEXT,
-  s4 ENUM('a','b','c') COMMENT 'A list of a,b or c', 
-  s5 BINARY(10),
-  s6 VARBINARY(10),
-  s7 BLOB,
-  s8 SET('a','b','c'),
-
-  g1 geometry NOT NULL,
-
-  j1 JSON COMMENT 'JSON data type'
-
-) COMMENT='table with various data types'
-`;
-
-describe('MySQLDriver', () => {
-  let driver: MySQLDriver;
-  let conRes: DbConnection;
-  let con: mysql.Connection;
-
-  beforeAll(async () => {
-    driver = createDriver();
-
-    con = await mysql.createConnection(baseConnectOption);
-
-    await con.connect();
-
-    await con.execute('DROP TABLE IF EXISTS testtable');
-
-    await con.execute<ResultSetHeader>(CREATE_TABLE_STATEMENT);
-  });
-
-  afterAll(async () => {
-    await driver.asyncClose();
-    con.destroy();
-  });
-
-  it('asyncConnect', async () => {
-    expect(await driver.asyncConnect()).toBe('');
-  });
-
-  describe('getName', () => {
-    it('should return constructor name', () => {
-      expect(driver.getName()).toBe('MySQLDriver');
-    });
-  });
-
-  describe('asyncGetResouces', () => {
-    let testDbRes: DbResource;
-    let testSchemaRes: DbSchema;
-    let testTableRes: DbTable;
-
-    it('should return Database resource', async () => {
-      const dbRootRes = await driver.getResouces({});
-      expect(dbRootRes).toHaveLength(1);
-      testDbRes = dbRootRes[0];
-      expect(testDbRes.getName()).toBe(driver.getConnectionRes().database);
-    });
-
-    it('should have Schema resource', async () => {
-      expect(testDbRes.getChildren()).toHaveLength(1);
-      testSchemaRes = testDbRes.getChildren()[0];
-      expect(testSchemaRes.getName()).toBe('testdb');
-    });
-
-    it('should have Table resource', async () => {
-      testTableRes = testSchemaRes.getChildByName('testtable') as DbTable;
-      expect(testTableRes.getName()).toBe('testtable');
-      expect(testTableRes.table_type).toBe('TABLE');
-      expect(testTableRes.comment).toBe('table with various data types');
-    });
-
-    it('should have Column resource', async () => {
-      // ID
-      const idRes = testTableRes.getChildByName('ID') as DbColumn;
-      expect(idRes.col_type).toBe(GeneralColumnType.INTEGER);
-      expect(idRes.nullable).toBe(false);
-      expect(idRes.key).toBe('PRI');
-      expect(idRes.extra).toBe('auto_increment');
-      // n0
-      const n0Res = testTableRes.getChildByName('n0') as DbColumn;
-      expect(n0Res.col_type).toBe(GeneralColumnType.BIT);
-      expect(n0Res.nullable).toBe(true);
-      // n1
-      const n1Res = testTableRes.getChildByName('n1') as DbColumn;
-      expect(n1Res.col_type).toBe(GeneralColumnType.TINYINT);
-      expect(n1Res.nullable).toBe(true);
-    });
-  });
-
-  function createDriver(): MySQLDriver {
-    conRes = new DbConnection(connectOption);
-    return new MySQLDriver(conRes);
-  }
-});

package/__tests__/db/drivers/PostgresDriver.test.ts

@@ -1,139 +0,0 @@
-import PostgresDriver from '../../../src/db/drivers/PostgresDriver';
-import {
-  DbConnection,
-  DbResource,
-  DbSchema,
-  DbTable,
-  DbColumn,
-} from '../../../src/db/resource/DbResource';
-import { DBType } from '../../../src/db/resource/types/DBType';
-import { default as pg } from 'pg';
-import { GeneralColumnType } from '../../../src/db/resource/types/GeneralColumnType';
-
-const baseConnectOption = {
-  host: '127.0.0.1',
-  port: 6002,
-  user: 'testuser',
-  password: 'testpass',
-  database: 'testdb',
-};
-const connectOption = {
-  ...baseConnectOption,
-  db_type: DBType.Postgres,
-  enviroment: 'ut',
-};
-
-const CREATE_TABLE_STATEMENT = `
-CREATE TABLE testtable (
-  ID SERIAL NOT NULL PRIMARY KEY,
-  n0 BIT,
-  n1 INT,
-  n2 BIGINT,
-  n3 SMALLSERIAL,
-  n4 BIGSERIAL,
-  f1 NUMERIC(6,4),
-  f2 DOUBLE PRECISION,
-  f3 REAL,
-
-  d1 DATE,
-  d2 TIME, 
-  d3 TIMESTAMP, 
-  d4 TIMESTAMP WITH TIME ZONE, 
-  d5 INTERVAL YEAR,
-
-  s1 CHAR(10),
-  s2 VARCHAR(10), 
-  s3 TEXT,
-  s4 mood, 
-  s5 BYTEA,
-  s6 uuid,
-
-  j1 JSON
-
-)`;
-
-describe('PostgresDriver', () => {
-  let driver: PostgresDriver;
-  let conRes: DbConnection;
-  let client: pg.Client;
-
-  beforeAll(async () => {
-    driver = createDriver();
-
-    client = new pg.Client(baseConnectOption);
-
-    await client.connect();
-
-    await client.query('DROP TABLE IF EXISTS testtable');
-    await client.query('DROP TYPE IF EXISTS mood');
-    await client.query("CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy')");
-
-    await client.query(CREATE_TABLE_STATEMENT);
-
-    await client.query(
-      "COMMENT ON TABLE testtable IS 'table with various data types'",
-    );
-  });
-
-  afterAll(async () => {
-    await driver.asyncClose();
-    client.end();
-  });
-
-  it('asyncConnect', async () => {
-    expect(await driver.asyncConnect()).toBe('');
-  });
-
-  describe('getName', () => {
-    it('should return constructor name', () => {
-      expect(driver.getName()).toBe('PostgresDriver');
-    });
-  });
-
-  describe('asyncGetResouces', () => {
-    let testDbRes: DbResource;
-    let testSchemaRes: DbSchema;
-    let testTableRes: DbTable;
-
-    it('should return Database resource', async () => {
-      const dbRootRes = await driver.getResouces({});
-      testDbRes = dbRootRes.find((it) => it.name === 'testdb');
-      expect(testDbRes.getName()).toBe(driver.getConnectionRes().database);
-    });
-
-    it('should have Schema resource', async () => {
-      expect(testDbRes.getChildren()).toHaveLength(1);
-      testSchemaRes = testDbRes.getChildren()[0];
-      expect(testSchemaRes.getName()).toBe('public');
-    });
-
-    it('should have Table resource', async () => {
-      testTableRes = testSchemaRes.getChildByName('testtable') as DbTable;
-      expect(testTableRes.getName()).toBe('testtable');
-      expect(testTableRes.table_type).toBe('TABLE');
-      expect(testTableRes.comment).toBe('table with various data types');
-    });
-
-    it('should have Column resource', async () => {
-      // ID
-      const idRes = testTableRes.getChildByName('ID') as DbColumn;
-      expect(idRes.col_type).toBe(GeneralColumnType.INTEGER);
-      expect(idRes.nullable).toBe(false);
-      expect(idRes.key).toBe('PRI');
-      expect(idRes.default).toContain('nextval');
-      // n0
-      const n0Res = testTableRes.getChildByName('n0') as DbColumn;
-      expect(n0Res.col_type).toBe(GeneralColumnType.BIT);
-      expect(n0Res.nullable).toBe(true);
-      // n1
-      const n1Res = testTableRes.getChildByName('n1') as DbColumn;
-      expect(n1Res.col_type).toBe(GeneralColumnType.INTEGER);
-      expect(n1Res.nullable).toBe(true);
-    });
-  });
-
-  function createDriver(): PostgresDriver {
-    conRes = new DbConnection(connectOption);
-    return new PostgresDriver(conRes);
-  }
-});

package/__tests__/db/drivers/RedisDriver.test.ts

@@ -1,156 +0,0 @@
-import RedisDriver from '../../../src/db/drivers/RedisDriver';
-import { Redis, RedisOptions } from 'ioredis';
-import {
-  DbConnection,
-  DbKey,
-  RedisDatabase,
-} from '../../../src/db/resource/DbResource';
-import {
-  RedisCommandType,
-  RedisRequest,
-} from '../../../src/service/request/redis_request';
-import { RedisKeyType } from '../../../src/db/resource/types/RedisKeyType';
-
-const connectOption: RedisOptions = {
-  port: 6000, // Redis port
-  host: '127.0.0.1', // Redis host
-  password: 'testpass',
-};
-
-describe('RedisDriver', () => {
-  let redisClient: Redis;
-  let driver: RedisDriver;
-
-  beforeAll(async () => {
-    redisClient = new Redis({ ...connectOption, db: 0 });
-    driver = createDriver();
-    await redisClient.flushall();
-    await redisClient.set('s1', 'text', 'EX', 100);
-    const user = {
-      name: 'Bob',
-      // The value of a Redis key can not be a number.
-      // We can write `age: 20` here but ioredis will convert it to a string anyway.
-      age: '20',
-      description: 'I am a programmer',
-    };
-
-    await redisClient.mset(user);
-    await redisClient.hmset('user-hash', user);
-    await redisClient.zadd(
-      'sortedSet',
-      1,
-      'one',
-      2,
-      'dos',
-      4,
-      'quatro',
-      3,
-      'three',
-    );
-    await redisClient.set('n1', 1);
-    await redisClient.rpush('list3', '1', '2', '3');
-  });
-
-  afterAll(async () => {
-    await redisClient.quit();
-    await driver.asyncClose();
-  });
-
-  it('asyncConnect', async () => {
-    expect(await driver.asyncConnect()).toBe('');
-  });
-
-  describe('getName', () => {
-    it('should return constructor name', () => {
-      expect(driver.getName()).toBe('RedisDriver');
-    });
-  });
-
-  describe('asyncGetResouces', () => {
-    let testRedisDb0Res: RedisDatabase;
-
-    it('should return Database resource', async () => {
-      const dbRootRes = await driver.getResouces({});
-      expect(dbRootRes).toHaveLength(16);
-      testRedisDb0Res = dbRootRes[0] as RedisDatabase;
-      expect(testRedisDb0Res.getName()).toBe(
-        driver.getConnectionRes().database,
-      );
-    });
-  });
-
-  describe('asyncScan', () => {
-    it('should return values', async () => {
-      const keys = await driver.scan(
-        0,
-        '*',
-        1000,
-        true,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        () => {},
-      );
-      let key = keys.find((it) => it.name === 'n1');
-      expect(key.val).toBe('1');
-      expect(key.type).toBe(RedisKeyType.string);
-      expect(key.ttl).toBe(-1);
-
-      key = keys.find((it) => it.name === 'age');
-      expect(key.val).toBe('20');
-      expect(key.type).toBe(RedisKeyType.string);
-
-      key = keys.find((it) => it.name === 'name');
-      expect(key.val).toBe('Bob');
-      expect(key.type).toBe(RedisKeyType.string);
-
-      key = keys.find((it) => it.name === 'description');
-      expect(key.val).toBe('I am a programmer');
-      expect(key.type).toBe(RedisKeyType.string);
-
-      key = keys.find((it) => it.name === 'user-hash');
-      expect(key.val).toEqual({
-        name: 'Bob',
-        age: '20',
-        description: 'I am a programmer',
-      });
-      expect(key.type).toBe(RedisKeyType.hash);
-
-      key = keys.find((it) => it.name === 'list3');
-      expect(key.val).toEqual(['1', '2', '3']);
-      expect(key.type).toBe(RedisKeyType.list);
-
-      key = keys.find((it) => it.name === 'sortedSet');
-      expect(key.val).toEqual(['one', 'dos', 'three', 'quatro']);
-      expect(key.type).toBe(RedisKeyType.zset);
-    });
-  });
-
-  describe('RedisCommandType.GetValue', () => {
-    it('should return values', async () => {
-      const key = (await driver.executeCommand(
-        createRedisRequest(RedisCommandType.GetValue, {
-          key: 'n1',
-          type: RedisKeyType.string,
-        }),
-      )) as DbKey;
-      expect(key.val).toBe('1');
-      expect(key.ttl).toBe(-1);
-    });
-  });
-
-  function createDriver(): RedisDriver {
-    const con = new DbConnection({ ...connectOption, database: '0' });
-    return new RedisDriver(con);
-  }
-
-  function createRedisRequest(
-    command: RedisCommandType,
-    options: { key?: string; type?: RedisKeyType },
-  ): RedisRequest {
-    return {
-      connection_id: '1',
-      index: 0,
-      command,
-      ...options,
-    };
-  }
-});

package/jest.config.js

@@ -1,18 +0,0 @@
-export default {
-  testEnvironment: 'node',
-  preset: 'ts-jest/presets/default-esm',
-  transform: {
-    '^.+\\.m?[tj]s?$': ['ts-jest', { useESM: true }],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.(m)?js$': '$1',
-  },
-  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(m)?ts$',
-  coverageDirectory: 'coverage',
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    'src/**/*.mts',
-    '!src/**/*.d.ts',
-    '!src/**/*.d.mts',
-  ],
-};

package/src/db/DBError.ts

@@ -1,26 +0,0 @@
-export default class DBError extends Error {
-  public code: any;
-  public errno: any;
-  public sqlMessage: any;
-  public sqlState: any;
-
-  constructor(
-    message: any,
-    code: any,
-    errno: any,
-    sqlMessage: any,
-    sqlState: any,
-  ) {
-    super(message);
-    this.name = this.constructor.name;
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(this, this.constructor);
-    } else {
-      this.stack = new Error(message).stack;
-    }
-    this.code = code;
-    this.errno = errno;
-    this.sqlMessage = sqlMessage;
-    this.sqlState = sqlState;
-  }
-}