@sqb/oracle 4.0.8 → 4.0.12

package/dist/OraAdapter.d.ts

@@ -0,0 +1,11 @@
+import { Adapter, ClientConfiguration } from '@sqb/connect';
+import '@sqb/oracle-dialect';
+export declare class OraAdapter implements Adapter {
+    driver: string;
+    dialect: string;
+    features: {
+        cursor: boolean;
+        schema: boolean;
+    };
+    connect(config: ClientConfiguration): Promise<Adapter.Connection>;
+}

package/dist/OraAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OraAdapter = void 0;
+const tslib_1 = require("tslib");
+require("@sqb/oracle-dialect");
+const oracledb_1 = tslib_1.__importDefault(require("oracledb"));
+const OraConnection_1 = require("./OraConnection");
+const helpers_1 = require("./helpers");
+class OraAdapter {
+    constructor() {
+        this.driver = 'oracledb';
+        this.dialect = 'oracle';
+        this.features = {
+            cursor: true,
+            schema: true,
+            // fetchAsString: [DataType.DATE, DataType.TIMESTAMP, DataType.TIMESTAMPTZ]
+        };
+    }
+    async connect(config) {
+        const cfg = (0, helpers_1.clientConfigurationToDriver)(config);
+        // Get oracle connection
+        const connection = await oracledb_1.default.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_1.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;
+        }
+    }
+}
+exports.OraAdapter = OraAdapter;

package/dist/OraConnection.d.ts

@@ -0,0 +1,22 @@
+import oracledb from 'oracledb';
+import { Adapter, QueryRequest } from '@sqb/connect';
+export declare const dataTypeNames: {
+    [x: number]: string;
+};
+export declare class OraConnection implements Adapter.Connection {
+    sessionId: string;
+    private intlcon?;
+    serverVersion: string;
+    private _inTransaction;
+    constructor(conn: oracledb.Connection, sessionId: string);
+    close(): Promise<void>;
+    reset(): Promise<void>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    test(): Promise<void>;
+    getSchema(): Promise<string>;
+    setSchema(schema: string): Promise<void>;
+    onGenerateQuery(prepared: QueryRequest): void;
+    execute(request: QueryRequest): Promise<Adapter.Response>;
+}

package/dist/OraConnection.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.dataTypeNames = {
+    [oracledb_1.default.DB_TYPE_BFILE]: 'BFILE',
+    [oracledb_1.default.DB_TYPE_BINARY_DOUBLE]: 'BINARY_DOUBLE',
+    [oracledb_1.default.DB_TYPE_BINARY_FLOAT]: 'BINARY_FLOAT',
+    [oracledb_1.default.DB_TYPE_BINARY_INTEGER]: 'BINARY_INTEGER',
+    [oracledb_1.default.DB_TYPE_BLOB]: 'BLOB',
+    [oracledb_1.default.DB_TYPE_BOOLEAN]: 'BOOLEAN',
+    [oracledb_1.default.DB_TYPE_CHAR]: 'CHAR',
+    [oracledb_1.default.DB_TYPE_CLOB]: 'CLOB',
+    [oracledb_1.default.DB_TYPE_CURSOR]: 'CURSOR',
+    [oracledb_1.default.DB_TYPE_DATE]: 'DATE',
+    [oracledb_1.default.DB_TYPE_INTERVAL_DS]: 'INTERVAL_DS',
+    [oracledb_1.default.DB_TYPE_INTERVAL_YM]: 'INTERVAL_YM',
+    [oracledb_1.default.DB_TYPE_LONG]: 'LONG',
+    [oracledb_1.default.DB_TYPE_LONG_RAW]: 'LONG_RAW',
+    [oracledb_1.default.DB_TYPE_NCHAR]: 'NCHAR',
+    [oracledb_1.default.DB_TYPE_NCLOB]: 'NCLOB',
+    [oracledb_1.default.DB_TYPE_NUMBER]: 'NUMBER',
+    [oracledb_1.default.DB_TYPE_NVARCHAR]: 'NVARCHAR',
+    [oracledb_1.default.DB_TYPE_OBJECT]: 'OBJECT',
+    [oracledb_1.default.DB_TYPE_RAW]: 'RAW',
+    [oracledb_1.default.DB_TYPE_ROWID]: 'ROWID',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP]: 'TIMESTAMP',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP_LTZ]: 'TIMESTAMP_LTZ',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP_TZ]: 'TIMESTAMP_TZ',
+    [oracledb_1.default.DB_TYPE_VARCHAR]: 'VARCHAR'
+};
+const fetchTypeMap = {
+    [oracledb_1.default.DB_TYPE_BFILE]: 'object',
+    [oracledb_1.default.DB_TYPE_BINARY_DOUBLE]: 'number',
+    [oracledb_1.default.DB_TYPE_BINARY_FLOAT]: 'number',
+    [oracledb_1.default.DB_TYPE_BINARY_INTEGER]: 'number',
+    [oracledb_1.default.DB_TYPE_BLOB]: 'object',
+    [oracledb_1.default.DB_TYPE_BOOLEAN]: 'boolean',
+    [oracledb_1.default.DB_TYPE_CHAR]: 'string',
+    [oracledb_1.default.DB_TYPE_CLOB]: 'object',
+    [oracledb_1.default.DB_TYPE_CURSOR]: 'object',
+    [oracledb_1.default.DB_TYPE_DATE]: 'Date',
+    [oracledb_1.default.DB_TYPE_INTERVAL_DS]: 'string',
+    [oracledb_1.default.DB_TYPE_INTERVAL_YM]: 'string',
+    [oracledb_1.default.DB_TYPE_LONG]: 'number',
+    [oracledb_1.default.DB_TYPE_LONG_RAW]: 'Buffer',
+    [oracledb_1.default.DB_TYPE_NCHAR]: 'string',
+    [oracledb_1.default.DB_TYPE_NCLOB]: 'object',
+    [oracledb_1.default.DB_TYPE_NUMBER]: 'number',
+    [oracledb_1.default.DB_TYPE_NVARCHAR]: 'string',
+    [oracledb_1.default.DB_TYPE_OBJECT]: 'object',
+    [oracledb_1.default.DB_TYPE_RAW]: 'Buffer',
+    [oracledb_1.default.DB_TYPE_ROWID]: 'number',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP]: 'Date',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP_LTZ]: 'Date',
+    [oracledb_1.default.DB_TYPE_TIMESTAMP_TZ]: 'Date',
+    [oracledb_1.default.DB_TYPE_VARCHAR]: 'string'
+};
+class OraConnection {
+    constructor(conn, sessionId) {
+        this.sessionId = sessionId;
+        this._inTransaction = false;
+        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_1.default.ok(this.intlcon, 'Can not start transaction for a closed db session');
+        this._inTransaction = true;
+    }
+    async commit() {
+        assert_1.default.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_1.default.ok(this.intlcon, 'DB session is closed');
+        await this.intlcon.execute('select 1 from dual', [], {});
+    }
+    async getSchema() {
+        assert_1.default.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_1.default.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_1.default.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_1.default.OUT_FORMAT_OBJECT : oracledb_1.default.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_1.OraCursor(response.resultSet, {
+                    rowType: request.objectRows ? 'object' : 'array',
+                    rowNumberIdx, rowNumberName
+                });
+        }
+        return out;
+    }
+}
+exports.OraConnection = OraConnection;

package/dist/OraCursor.d.ts

@@ -0,0 +1,17 @@
+import { ResultSet } from 'oracledb';
+import { Adapter, RowType } from '@sqb/connect';
+export declare class OraCursor implements Adapter.Cursor {
+    private _resultSet?;
+    private readonly _rowType;
+    private readonly _rowNumberIdx?;
+    private readonly _rowNumberName?;
+    constructor(resultSet: ResultSet<any>, opts: {
+        rowType: RowType;
+        rowNumberIdx?: number;
+        rowNumberName?: string;
+    });
+    get isClosed(): boolean;
+    get rowType(): RowType;
+    close(): Promise<void>;
+    fetch(nRows: number): Promise<any[] | undefined>;
+}

package/dist/OraCursor.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OraCursor = void 0;
+class OraCursor {
+    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);
+            });
+        });
+    }
+}
+exports.OraCursor = OraCursor;

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+import { ConnectionAttributes } from 'oracledb';
+import { ClientConfiguration } from '@sqb/connect';
+export declare function clientConfigurationToDriver(config: ClientConfiguration): ConnectionAttributes;

package/dist/helpers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientConfigurationToDriver = void 0;
+const tslib_1 = require("tslib");
+const url_1 = tslib_1.__importDefault(require("url"));
+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_1.default.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;
+}
+exports.clientConfigurationToDriver = clientConfigurationToDriver;

package/dist/index.d.ts

@@ -0,0 +1 @@
+import '@sqb/oracle-dialect';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = require("@sqb/connect");
+const OraAdapter_1 = require("./OraAdapter");
+require("@sqb/oracle-dialect");
+(0, connect_1.registerAdapter)(new OraAdapter_1.OraAdapter());

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sqb/oracle",
   "description": "SQB serialization extension for Oracle database",
-  "version": "4.0.8",
-  "author": "Panates Ltd.",
+  "version": "4.0.12",
+  "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
   ],
@@ -54,7 +54,6 @@
     "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",
-    "version": "#version"
+    "test": "TS_NODE_PROJECT='./test/tsconfig.json' mocha -r ts-node/register -r tsconfig-paths/register --reporter spec test/**/*.spec.ts"
   }
 }