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

package/.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+insert_final_newline = false
+trim_trailing_whitespace = false
+
+[*.{js,json,ts,mts,yml,yaml}]
+indent_size = 2
+indent_style = space

package/.eslintignore

@@ -0,0 +1 @@
+/**/*.js

package/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "env": {
+    "browser": false,
+    "jest": true,
+    "node": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "tsconfig.json",
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint", "jest"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:jest/recommended",
+    "prettier"
+  ],
+  "rules": {
+    // The following rule is enabled only to supplement the inline suppression
+    // examples, and because it is not a recommended rule, you should either
+    // disable it, or understand what it enforces.
+    // https://typescript-eslint.io/rules/explicit-function-return-type/
+    "@typescript-eslint/explicit-function-return-type": "warn",
+    "no-async-promise-executor": "warn",
+    "@typescript-eslint/no-namespace": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/ban-types": "off"
+  }
+}

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,50 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      # E2E テストを Docker Compose で実行する
+      - name: run test on docker-compose
+        run: |
+          docker-compose -f ./unit-test.yml build
+          docker-compose -f ./unit-test.yml up -d
+      - name: wait
+        run: docker-compose -f unit-test.yml exec -T mysql bash -c "mysqladmin --wait --count 60 ping -pp@ssw0rd --protocol=tcp || exit 1"
+      - name: wait2
+        run: |
+          while [ "$(curl -I  http://localhost:6003/minio/health/live  -o /dev/null -w '%{http_code}\n' -s)" != "200" ]
+          do
+            echo "waiting"
+            sleep 2
+          done
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/.prettierrc

@@ -0,0 +1,12 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "overrides": [
+    {
+      "files": ["*.ts", "*.mts"],
+      "options": {
+        "parser": "typescript"
+      }
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,7 @@
+# Prepare
+
+```sh
+docker-compose -f unit-test.yml build
+
+docker-compose -f unit-test.yml up -d
+```

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

@@ -0,0 +1,97 @@
+import AwsS3Driver from '../../../src/db/drivers/AwsS3Driver';
+import {
+  DbConnection,
+  DbDatabase,
+  DbS3Bucket,
+  DbS3Owner,
+} from '../../../src/db/resource/DbResource';
+import { DBType } from '../../../src/db/resource/types/DBType';
+
+const connectOption = {
+  port: 6003,
+  user: 'testuser', // aws:accessKeyId
+  password: 'testpass', // aws:secretAccessKey
+  url: 'http://127.0.0.1:6003',
+  region: 'us-west-1',
+};
+
+describe('AwsS3Driver', () => {
+  let driver: AwsS3Driver;
+  const bucket = 'testbucket';
+
+  beforeAll(async () => {
+    driver = createDriver();
+    await driver.asyncConnect();
+    try {
+      await driver.removeBucket({ bucket });
+    } catch (e) {
+      // The specified bucket does not exist
+      // console.error('error:' + e.message);
+    }
+    await driver.createBucket({ bucket });
+    await driver.putObject({ bucket, key: 'text/abc.txt', body: 'abc' });
+    await driver.putObject({
+      bucket,
+      key: 'text/folder/abc.txt',
+      body: 'abc',
+    });
+    await driver.putObject({ bucket, key: 'text/empty.txt', body: '' });
+  });
+
+  afterAll(async () => {
+    await driver.asyncClose();
+  });
+
+  describe('getName', () => {
+    it('should return constructor name', () => {
+      expect(driver.getName()).toBe('AwsS3Driver');
+    });
+  });
+
+  describe('asyncGetResouces', () => {
+    let testDbRes: DbDatabase;
+    let testBucketRes: DbS3Bucket;
+
+    it('should return Database resource', async () => {
+      const dbRootRes = await driver.getResouces({});
+      expect(dbRootRes).toHaveLength(1);
+      testDbRes = dbRootRes[0] as DbDatabase;
+      expect(testDbRes.getName()).toBe('S3');
+    });
+
+    it('should have DbS3Bucket resource', async () => {
+      testBucketRes = testDbRes.getChildByName(bucket) as DbS3Bucket;
+      expect(testBucketRes.getName()).toBe(bucket);
+    });
+
+    it('should have DbS3Owner resource', async () => {
+      const owner = testDbRes.getChildByName('minio') as DbS3Owner;
+      expect(owner.getName()).toBe('minio');
+    });
+
+    it('should have values', async () => {
+      const textValue = await driver.getValueByKey({
+        bucket,
+        key: 'text/abc.txt',
+      });
+      expect(textValue).toBe('abc');
+
+      const textValue2 = await driver.getValueByKey({
+        bucket,
+        key: 'text/folder/abc.txt',
+      });
+      expect(textValue2).toBe('abc');
+
+      const textValue3 = await driver.getValueByKey({
+        bucket,
+        key: 'text/empty.txt',
+      });
+      expect(textValue3).toBe('');
+    });
+  });
+
+  function createDriver(): AwsS3Driver {
+    const con = new DbConnection({ ...connectOption, db_type: DBType.Minio });
+    return new AwsS3Driver(con);
+  }
+});

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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,18 @@
+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',
+  ],
+};