@sqb/oracle 4.2.1 → 4.5.0

package/README.md

@@ -0,0 +1,67 @@
+
+<p style="text-align:center">
+  <img src="https://user-images.githubusercontent.com/3836517/32965280-1a2b63ce-cbe7-11e7-8ee1-ba47313503c5.png" width="500px" alt="SQB Logo"/>
+</p>
+
+<br>
+  
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+[![Dependencies][dependencies-image]][dependencies-url]
+[![DevDependencies][devdependencies-image]][devdependencies-url]
+[![Package Quality][quality-image]][quality-url]
+
+
+## About SQB
+
+SQB is an extensible, multi-dialect SQL query builder and Database connection wrapper for NodeJS.
+
+## Main goals
+
+- Single code base for any sql based database
+- Powerful and simplified query coding scheme
+- Fast applications with low memory requirements
+- Let applications work with large data tables efficiently
+- Support latest JavaScript language standards
+- Lightweight and extensible framework. 
+
+
+You can report bugs and discuss features on the [GitHub issues](https://github.com/sqbjs/sqb/issues) page
+
+Thanks to all of the great [contributions](https://github.com/sqbjs/sqb/graphs/contributors) to the project.
+
+You may want to check detailed [DOCUMENTATION](https://sqbjs.github.io/sqb/)
+
+
+## Installation
+
+```bash
+$ npm install @sqb/oracle --save
+```
+
+## Node Compatibility
+
+  - node >= 16.x
+  
+   
+### License
+SQB is available under [MIT](LICENSE) license.
+
+[npm-image]: https://img.shields.io/npm/v/@sqb/oracle.svg
+[npm-url]: https://npmjs.org/package/@sqb/oracle
+[travis-image]: https://img.shields.io/travis/sqbjs/@sqb/oracle/master.svg
+[travis-url]: https://travis-ci.org/sqbjs/@sqb/oracle
+[coveralls-image]: https://img.shields.io/coveralls/sqbjs/@sqb/oracle/master.svg
+[coveralls-url]: https://coveralls.io/r/sqbjs/@sqb/oracle
+[downloads-image]: https://img.shields.io/npm/dm/@sqb/oracle.svg
+[downloads-url]: https://npmjs.org/package/@sqb/oracle
+[gitter-image]: https://badges.gitter.im/sqbjs/@sqb/oracle.svg
+[gitter-url]: https://gitter.im/sqbjs/@sqb/oracle?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[dependencies-image]: https://david-dm.org/sqbjs/@sqb/oracle/status.svg
+[dependencies-url]:https://david-dm.org/sqbjs/@sqb/oracle
+[devdependencies-image]: https://david-dm.org/sqbjs/@sqb/oracle/dev-status.svg
+[devdependencies-url]:https://david-dm.org/sqbjs/@sqb/oracle?type=dev
+[quality-image]: http://npm.packagequality.com/shield/@sqb/oracle.png
+[quality-url]: http://packagequality.com/#?package=@sqb/oracle

package/{dist → cjs}/index.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("@sqb/oracle-dialect");
 const connect_1 = require("@sqb/connect");
-const OraAdapter_1 = require("./OraAdapter");
-(0, connect_1.registerAdapter)(new OraAdapter_1.OraAdapter());
+const ora_adapter_js_1 = require("./ora-adapter.js");
+(0, connect_1.registerAdapter)(new ora_adapter_js_1.OraAdapter());

package/{dist/OraAdapter.js → cjs/ora-adapter.js}

@@ -4,20 +4,18 @@ exports.OraAdapter = void 0;
 const tslib_1 = require("tslib");
 require("@sqb/oracle-dialect");
 const oracledb_1 = tslib_1.__importDefault(require("oracledb"));
-const helpers_1 = require("./helpers");
-const OraConnection_1 = require("./OraConnection");
+const helpers_js_1 = require("./helpers.js");
+const ora_connection_js_1 = require("./ora-connection.js");
 class OraAdapter {
-    constructor() {
-        this.driver = 'oracledb';
-        this.dialect = 'oracle';
-        this.features = {
-            cursor: true,
-            schema: true,
-            // fetchAsString: [DataType.DATE, DataType.TIMESTAMP, DataType.TIMESTAMPTZ]
-        };
-    }
+    driver = 'oracledb';
+    dialect = 'oracle';
+    features = {
+        cursor: true,
+        schema: true,
+        // fetchAsString: [DataType.DATE, DataType.TIMESTAMP, DataType.TIMESTAMPTZ]
+    };
     async connect(config) {
-        const cfg = (0, helpers_1.clientConfigurationToDriver)(config);
+        const cfg = (0, helpers_js_1.clientConfigurationToDriver)(config);
         // Get oracle connection
         const connection = await oracledb_1.default.getConnection(cfg);
         try {
@@ -26,7 +24,7 @@ class OraAdapter {
             const r = await connection.execute('select sid from v$mystat where rownum <= 1', [], {});
             if (r && r.rows)
                 sessionId = r.rows[0][0];
-            const oracon = new OraConnection_1.OraConnection(connection, sessionId);
+            const oracon = new ora_connection_js_1.OraConnection(connection, sessionId);
             /* Set default schema */
             if (config.schema)
                 await oracon.setSchema(config.schema);

package/{dist/OraConnection.js → cjs/ora-connection.js}

@@ -4,7 +4,7 @@ exports.OraConnection = exports.dataTypeNames = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const oracledb_1 = tslib_1.__importDefault(require("oracledb"));
-const OraCursor_1 = require("./OraCursor");
+const ora_cursor_js_1 = require("./ora-cursor.js");
 exports.dataTypeNames = {
     [oracledb_1.default.DB_TYPE_BFILE]: 'BFILE',
     [oracledb_1.default.DB_TYPE_BINARY_DOUBLE]: 'BINARY_DOUBLE',
@@ -60,9 +60,12 @@ const fetchTypeMap = {
     [oracledb_1.default.DB_TYPE_VARCHAR]: 'string'
 };
 class OraConnection {
+    sessionId;
+    intlcon;
+    serverVersion;
+    _inTransaction = false;
     constructor(conn, sessionId) {
         this.sessionId = sessionId;
-        this._inTransaction = false;
         this.intlcon = conn;
         this.serverVersion = '' + conn.oracleServerVersion;
     }
@@ -190,7 +193,7 @@ class OraConnection {
         else if (response.resultSet) {
             out.rowType = request.objectRows ? 'object' : 'array';
             out.cursor =
-                new OraCursor_1.OraCursor(response.resultSet, {
+                new ora_cursor_js_1.OraCursor(response.resultSet, {
                     rowType: request.objectRows ? 'object' : 'array',
                     rowNumberIdx, rowNumberName
                 });

package/{dist/OraCursor.js → cjs/ora-cursor.js}

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OraCursor = void 0;
 class OraCursor {
+    _resultSet;
+    _rowType;
+    _rowNumberIdx;
+    _rowNumberName;
     constructor(resultSet, opts) {
         this._rowType = opts.rowType;
         this._resultSet = resultSet;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/esm/helpers.js

@@ -0,0 +1,30 @@
+import url from "url";
+export function clientConfigurationToDriver(config) {
+    const cfg = {
+        user: config.user,
+        password: config.password,
+        ...config.driverOptions
+    };
+    if (config.host) {
+        let hostUrl = config.host || 'localhost';
+        if (!hostUrl.includes('://'))
+            hostUrl = 'oracle://' + hostUrl;
+        const parsed = url.parse(hostUrl, true);
+        const host = decodeURI(parsed.hostname || '');
+        const port = config.port ||
+            (parsed.port && parseInt(parsed.port, 10)) || 1521;
+        const database = config.database ||
+            (parsed.pathname && decodeURI(parsed.pathname.substring(1)));
+        cfg.connectString = `${host}:${port}${(database ? '/' + database : '')}`;
+        if (!cfg.externalAuth) {
+            if (parsed.auth) {
+                const a = parsed.auth.split(':');
+                if (!cfg.user && a[0])
+                    cfg.user = a[0];
+                if (!cfg.password && a[1])
+                    cfg.password = a[1];
+            }
+        }
+    }
+    return cfg;
+}

package/esm/index.js

@@ -0,0 +1,4 @@
+import '@sqb/oracle-dialect';
+import { registerAdapter } from '@sqb/connect';
+import { OraAdapter } from './ora-adapter.js';
+registerAdapter(new OraAdapter());

package/esm/ora-adapter.js

@@ -0,0 +1,35 @@
+import '@sqb/oracle-dialect';
+import oracledb from 'oracledb';
+import { clientConfigurationToDriver } from './helpers.js';
+import { OraConnection } from './ora-connection.js';
+export class OraAdapter {
+    driver = 'oracledb';
+    dialect = 'oracle';
+    features = {
+        cursor: true,
+        schema: true,
+        // fetchAsString: [DataType.DATE, DataType.TIMESTAMP, DataType.TIMESTAMPTZ]
+    };
+    async connect(config) {
+        const cfg = clientConfigurationToDriver(config);
+        // Get oracle connection
+        const connection = await oracledb.getConnection(cfg);
+        try {
+            /* Retrieve sessionId */
+            let sessionId;
+            const r = await connection.execute('select sid from v$mystat where rownum <= 1', [], {});
+            if (r && r.rows)
+                sessionId = r.rows[0][0];
+            const oracon = new OraConnection(connection, sessionId);
+            /* Set default schema */
+            if (config.schema)
+                await oracon.setSchema(config.schema);
+            return oracon;
+        }
+        catch (e) {
+            if (connection)
+                await connection.close();
+            throw e;
+        }
+    }
+}

package/esm/ora-connection.js

@@ -0,0 +1,199 @@
+import assert from 'assert';
+import oracledb from 'oracledb';
+import { OraCursor } from './ora-cursor.js';
+export const dataTypeNames = {
+    [oracledb.DB_TYPE_BFILE]: 'BFILE',
+    [oracledb.DB_TYPE_BINARY_DOUBLE]: 'BINARY_DOUBLE',
+    [oracledb.DB_TYPE_BINARY_FLOAT]: 'BINARY_FLOAT',
+    [oracledb.DB_TYPE_BINARY_INTEGER]: 'BINARY_INTEGER',
+    [oracledb.DB_TYPE_BLOB]: 'BLOB',
+    [oracledb.DB_TYPE_BOOLEAN]: 'BOOLEAN',
+    [oracledb.DB_TYPE_CHAR]: 'CHAR',
+    [oracledb.DB_TYPE_CLOB]: 'CLOB',
+    [oracledb.DB_TYPE_CURSOR]: 'CURSOR',
+    [oracledb.DB_TYPE_DATE]: 'DATE',
+    [oracledb.DB_TYPE_INTERVAL_DS]: 'INTERVAL_DS',
+    [oracledb.DB_TYPE_INTERVAL_YM]: 'INTERVAL_YM',
+    [oracledb.DB_TYPE_LONG]: 'LONG',
+    [oracledb.DB_TYPE_LONG_RAW]: 'LONG_RAW',
+    [oracledb.DB_TYPE_NCHAR]: 'NCHAR',
+    [oracledb.DB_TYPE_NCLOB]: 'NCLOB',
+    [oracledb.DB_TYPE_NUMBER]: 'NUMBER',
+    [oracledb.DB_TYPE_NVARCHAR]: 'NVARCHAR',
+    [oracledb.DB_TYPE_OBJECT]: 'OBJECT',
+    [oracledb.DB_TYPE_RAW]: 'RAW',
+    [oracledb.DB_TYPE_ROWID]: 'ROWID',
+    [oracledb.DB_TYPE_TIMESTAMP]: 'TIMESTAMP',
+    [oracledb.DB_TYPE_TIMESTAMP_LTZ]: 'TIMESTAMP_LTZ',
+    [oracledb.DB_TYPE_TIMESTAMP_TZ]: 'TIMESTAMP_TZ',
+    [oracledb.DB_TYPE_VARCHAR]: 'VARCHAR'
+};
+const fetchTypeMap = {
+    [oracledb.DB_TYPE_BFILE]: 'object',
+    [oracledb.DB_TYPE_BINARY_DOUBLE]: 'number',
+    [oracledb.DB_TYPE_BINARY_FLOAT]: 'number',
+    [oracledb.DB_TYPE_BINARY_INTEGER]: 'number',
+    [oracledb.DB_TYPE_BLOB]: 'object',
+    [oracledb.DB_TYPE_BOOLEAN]: 'boolean',
+    [oracledb.DB_TYPE_CHAR]: 'string',
+    [oracledb.DB_TYPE_CLOB]: 'object',
+    [oracledb.DB_TYPE_CURSOR]: 'object',
+    [oracledb.DB_TYPE_DATE]: 'Date',
+    [oracledb.DB_TYPE_INTERVAL_DS]: 'string',
+    [oracledb.DB_TYPE_INTERVAL_YM]: 'string',
+    [oracledb.DB_TYPE_LONG]: 'number',
+    [oracledb.DB_TYPE_LONG_RAW]: 'Buffer',
+    [oracledb.DB_TYPE_NCHAR]: 'string',
+    [oracledb.DB_TYPE_NCLOB]: 'object',
+    [oracledb.DB_TYPE_NUMBER]: 'number',
+    [oracledb.DB_TYPE_NVARCHAR]: 'string',
+    [oracledb.DB_TYPE_OBJECT]: 'object',
+    [oracledb.DB_TYPE_RAW]: 'Buffer',
+    [oracledb.DB_TYPE_ROWID]: 'number',
+    [oracledb.DB_TYPE_TIMESTAMP]: 'Date',
+    [oracledb.DB_TYPE_TIMESTAMP_LTZ]: 'Date',
+    [oracledb.DB_TYPE_TIMESTAMP_TZ]: 'Date',
+    [oracledb.DB_TYPE_VARCHAR]: 'string'
+};
+export class OraConnection {
+    sessionId;
+    intlcon;
+    serverVersion;
+    _inTransaction = false;
+    constructor(conn, sessionId) {
+        this.sessionId = sessionId;
+        this.intlcon = conn;
+        this.serverVersion = '' + conn.oracleServerVersion;
+    }
+    async close() {
+        if (!this.intlcon)
+            return;
+        await this.intlcon.close();
+        this.intlcon = undefined;
+    }
+    async reset() {
+        return this.rollback();
+    }
+    async startTransaction() {
+        assert.ok(this.intlcon, 'Can not start transaction for a closed db session');
+        this._inTransaction = true;
+    }
+    async commit() {
+        assert.ok(this.intlcon, 'Can not commit transaction for a closed db session');
+        await this.intlcon.commit();
+        this._inTransaction = false;
+    }
+    async rollback() {
+        if (!this.intlcon)
+            return;
+        await this.intlcon.rollback();
+        this._inTransaction = false;
+    }
+    async test() {
+        assert.ok(this.intlcon, 'DB session is closed');
+        await this.intlcon.execute('select 1 from dual', [], {});
+    }
+    async getSchema() {
+        assert.ok(this.intlcon, 'DB session is closed');
+        const r = await this.intlcon.execute('select sys_context( \'userenv\', \'current_schema\' ) from dual', [], { autoCommit: true });
+        if (r && r.rows && r.rows[0])
+            return r.rows[0][0];
+        return '';
+    }
+    async setSchema(schema) {
+        assert.ok(this.intlcon, 'Can not set schema of a closed db session');
+        await this.intlcon.execute('alter SESSION set CURRENT_SCHEMA = ' + schema, [], { autoCommit: true });
+    }
+    onGenerateQuery(prepared) {
+        prepared.dialect = 'oracle';
+        prepared.dialectVersion = this.serverVersion;
+    }
+    async execute(request) {
+        assert.ok(this.intlcon, 'Can not execute query with a closed db session');
+        const oraOptions = {
+            autoCommit: request.autoCommit,
+            extendedMetaData: true,
+            resultSet: request.cursor,
+            outFormat: request.objectRows ? oracledb.OUT_FORMAT_OBJECT : oracledb.OUT_FORMAT_ARRAY
+        };
+        if (request.cursor)
+            oraOptions.fetchArraySize = request.fetchRows;
+        else
+            oraOptions.maxRows = request.fetchRows;
+        const out = {};
+        this.intlcon.action = request.action || '';
+        let response = await this.intlcon.execute(request.sql, request.params || [], oraOptions);
+        if (response.rowsAffected)
+            out.rowsAffected = response.rowsAffected;
+        if (out.rowsAffected === 1 && request.returningFields) {
+            const m = request.sql.match(/\b(insert into|update)\b ("?\w+\.?\w+"?)/i);
+            if (m) {
+                const selectFields = request.returningFields.map(x => x.field + (x.alias ? ' as ' + x.alias : ''));
+                let sql = `select ${selectFields.join(',')} from ${m[2]}\n`;
+                if (m[1].toLowerCase() === 'insert into') {
+                    sql += 'where rowid=\'' + response.lastRowid + '\'';
+                    response = await this.intlcon.execute(sql);
+                }
+                else 
+                // Emulate update ... returning
+                if (m[1].toLowerCase() === 'update') {
+                    const m2 = request.sql.match(/where (.+)/);
+                    sql += (m2 ? ' where ' + m2[1] : '');
+                    response = await this.intlcon.execute(sql, request.params || [], oraOptions);
+                }
+            }
+        }
+        let fields;
+        let rowNumberIdx = -1;
+        let rowNumberName = '';
+        if (response.metaData) {
+            fields = out.fields = [];
+            for (const [idx, v] of response.metaData.entries()) {
+                if (v.name.toLowerCase() === 'row$number') {
+                    rowNumberIdx = idx;
+                    rowNumberName = v.name;
+                    continue;
+                }
+                const fieldInfo = {
+                    _inf: v,
+                    fieldName: v.name,
+                    dataType: v.dbTypeName || 'UNKNOWN',
+                    jsType: fetchTypeMap[v.fetchType || 2001]
+                };
+                if (v.dbTypeName === 'CHAR')
+                    fieldInfo.fixedLength = true;
+                // others
+                if (v.byteSize)
+                    fieldInfo.size = v.byteSize;
+                if (v.nullable)
+                    fieldInfo.nullable = v.nullable;
+                if (v.precision)
+                    fieldInfo.precision = v.precision;
+                fields.push(fieldInfo);
+            }
+        }
+        if (response.rows) {
+            out.rowType = request.objectRows ? 'object' : 'array';
+            out.rows = response.rows;
+            // remove row$number fields
+            if (out.rows && rowNumberIdx >= 0) {
+                for (const row of out.rows) {
+                    if (Array.isArray(row))
+                        row.splice(rowNumberIdx, 1);
+                    else
+                        delete row[rowNumberName];
+                }
+            }
+            return out;
+        }
+        else if (response.resultSet) {
+            out.rowType = request.objectRows ? 'object' : 'array';
+            out.cursor =
+                new OraCursor(response.resultSet, {
+                    rowType: request.objectRows ? 'object' : 'array',
+                    rowNumberIdx, rowNumberName
+                });
+        }
+        return out;
+    }
+}

package/esm/ora-cursor.js

@@ -0,0 +1,54 @@
+export class OraCursor {
+    _resultSet;
+    _rowType;
+    _rowNumberIdx;
+    _rowNumberName;
+    constructor(resultSet, opts) {
+        this._rowType = opts.rowType;
+        this._resultSet = resultSet;
+        this._rowNumberIdx = opts.rowNumberIdx;
+        this._rowNumberName = opts.rowNumberName;
+    }
+    get isClosed() {
+        return !this._resultSet;
+    }
+    get rowType() {
+        return this._rowType;
+    }
+    async close() {
+        if (!this._resultSet)
+            return;
+        const resultSet = this._resultSet;
+        return new Promise((resolve, reject) => {
+            resultSet.close(err => {
+                if (err)
+                    return reject(err);
+                this._resultSet = undefined;
+                resolve();
+            });
+        });
+    }
+    fetch(nRows) {
+        return new Promise((resolve, reject) => {
+            if (!this._resultSet)
+                return resolve(undefined);
+            const resultSet = this._resultSet;
+            resultSet.getRows(nRows, (err, rows) => {
+                if (err)
+                    return reject(err);
+                if (!(rows && rows.length))
+                    return resolve(undefined);
+                /* remove row$number fields */
+                if (this._rowNumberName) {
+                    for (const row of rows) {
+                        if (Array.isArray(row))
+                            row.splice(this._rowNumberIdx || 0, 1);
+                        else
+                            delete row[this._rowNumberName];
+                    }
+                }
+                resolve(rows);
+            });
+        });
+    }
+}

package/package.json

@@ -1,59 +1,76 @@
 {
-  "name": "@sqb/oracle",
-  "description": "SQB serialization extension for Oracle database",
-  "version": "4.2.1",
-  "author": "Panates",
-  "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>"
+  "name" : "@sqb/oracle",
+  "description" : "SQB serialization extension for Oracle database",
+  "version" : "4.5.0",
+  "author" : "Panates",
+  "contributors" : [
+    "Eray Hanoglu <e.hanoglu@panates.com>",
+    "Ilker Gurelli <i.gurelli@panates.com>"
   ],
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sqbjs/sqb.git",
-    "directory": "packages/oracle"
+  "license" : "Apache-2.0",
+  "repository" : {
+    "type" : "git",
+    "url" : "https://github.com/sqbjs/sqb.git",
+    "directory" : "packages/oracle"
   },
-  "keywords": [
-    "javascript",
-    "typescript",
-    "sql",
-    "query",
-    "builder",
-    "dialect",
-    "oracle",
-    "database"
-  ],
-  "devDependencies": {
-    "@types/oracledb": "^5.2.3",
-    "oracledb": "^5.4.0"
+  "scripts" : {
+    "compile" : "tsc",
+    "prebuild" : "npm run lint && npm run clean",
+    "build" : "npm run build:cjs && npm run build:esm",
+    "build:cjs" : "tsc -b tsconfig-build-cjs.json",
+    "build:esm" : "tsc -b tsconfig-build-esm.json",
+    "postbuild" : "cp README.md package.json ../../LICENSE ../../build/oracle && cp ../../package.cjs.json ../../build/oracle/cjs/package.json",
+    "lint" : "eslint .",
+    "test" : "jest",
+    "cover" : "jest --collect-coverage",
+    "clean" : "npm run clean:src | npm run clean:dist | npm run clean:cover",
+    "clean:src" : "ts-cleanup -s src --all",
+    "clean:dist" : "rimraf ../../build/oracle",
+    "clean:cover" : "rimraf ../../coverage/oracle"
   },
-  "peerDependencies": {
-    "@sqb/builder": "^4.2.0",
-    "@sqb/connect": "^4.2.0",
-    "@sqb/oracle-dialect": "^4.2.0",
-    "oracledb": "^5.x.x"
+  "devDependencies" : {
+    "@types/oracledb" : "^5.2.3",
+    "oracledb" : "^5.4.0"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "engines": {
-    "node": ">= 16.0"
+  "peerDependencies" : {
+    "@sqb/builder" : "^4.5.0",
+    "@sqb/connect" : "^4.5.0",
+    "@sqb/oracle-dialect" : "^4.5.0",
+    "oracledb" : "^5.x.x"
   },
-  "directories": {
-    "lib": "dist",
-    "test": "test"
+  "type" : "module",
+  "main" : "cjs/index.js",
+  "module" : "esm/index.js",
+  "types" : "esm/index.d.ts",
+  "exports" : {
+    "." : {
+      "require" : "./cjs/index.js",
+      "default" : "./esm/index.js"
+    },
+    "./cjs" : "./cjs/index.js",
+    "./esm" : "./esm/index.js"
   },
-  "files": [
+  "engines" : {
+    "node" : ">=16.0",
+    "npm" : ">=7.0.0"
+  },
+  "files" : [
+    "bin/",
+    "cjs/",
+    "esm/",
     "LICENSE",
-    "README",
-    "dist/"
+    "README.md"
   ],
-  "scripts": {
-    "build": "tsc -b tsconfig-build.json",
-    "prebuild": "npm run lint && npm run clean:dist",
-    "postbuild": "copyfiles package.json README.md LICENSE ../../build/oracle",
-    "clean": "ts-cleanup -s src --all & ts-cleanup -s test",
-    "clean:dist": "rimraf ../../build/oracle",
-    "compile": "tsc",
-    "lint": "eslint src/** --no-error-on-unmatched-pattern",
-    "test": "TS_NODE_PROJECT='./test/tsconfig.json' mocha -r ts-node/register -r tsconfig-paths/register --reporter spec test/**/*.spec.ts"
-  }
-}
+  "keywords" : [
+    "sqb",
+    "oracle",
+    "oracledb",
+    "pg",
+    "sql",
+    "query",
+    "builder",
+    "dialect",
+    "serializer",
+    "database"
+  ]
+}