@sqb/postgres 4.0.8 → 4.0.12

package/dist/PgAdapter.d.ts

@@ -0,0 +1,12 @@
+import { Adapter, ClientConfiguration, DataType } from '@sqb/connect';
+import '@sqb/postgres-dialect';
+export declare class PgAdapter implements Adapter {
+    driver: string;
+    dialect: string;
+    features: {
+        cursor: boolean;
+        schema: boolean;
+        fetchAsString: DataType[];
+    };
+    connect(config: ClientConfiguration): Promise<Adapter.Connection>;
+}

package/dist/PgAdapter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAdapter = void 0;
+const connect_1 = require("@sqb/connect");
+require("@sqb/postgres-dialect");
+const postgresql_client_1 = require("postgresql-client");
+const PgConnection_1 = require("./PgConnection");
+class PgAdapter {
+    constructor() {
+        this.driver = 'postgresql-client';
+        this.dialect = 'postgres';
+        this.features = {
+            cursor: true,
+            schema: true,
+            fetchAsString: [connect_1.DataType.DATE, connect_1.DataType.TIMESTAMP, connect_1.DataType.TIMESTAMPTZ]
+        };
+    }
+    async connect(config) {
+        const cfg = { ...config.driverOptions };
+        if (config.user)
+            cfg.user = config.user;
+        if (config.password)
+            cfg.password = config.password;
+        if (config.host)
+            cfg.host = config.host;
+        if (config.port)
+            cfg.port = config.port;
+        if (config.database)
+            cfg.database = config.database;
+        if (config.schema)
+            cfg.schema = config.schema;
+        const connection = new postgresql_client_1.Connection(cfg);
+        try {
+            await connection.connect();
+            return new PgConnection_1.PgConnection(connection);
+        }
+        catch (e) {
+            await connection.close(0);
+            throw e;
+        }
+    }
+}
+exports.PgAdapter = PgAdapter;

package/dist/PgConnection.d.ts

@@ -0,0 +1,22 @@
+import { Adapter, QueryRequest } from '@sqb/connect';
+import { Connection, FieldInfo } from 'postgresql-client';
+export declare class PgConnection implements Adapter.Connection {
+    private intlcon?;
+    constructor(conn: Connection);
+    get sessionId(): any;
+    close(): Promise<void>;
+    reset(): Promise<void>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    setSavepoint(savepoint: string): Promise<void>;
+    releaseSavepoint(savepoint: string): Promise<void>;
+    rollbackSavepoint(savepoint: string): Promise<void>;
+    getInTransaction(): boolean;
+    test(): Promise<void>;
+    getSchema(): Promise<string>;
+    setSchema(schema: string): Promise<void>;
+    onGenerateQuery(request: QueryRequest): void;
+    execute(query: QueryRequest): Promise<Adapter.Response>;
+    _convertFields(fields: FieldInfo[]): any[];
+}

package/dist/PgConnection.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgConnection = void 0;
+const connect_1 = require("@sqb/connect");
+const postgresql_client_1 = require("postgresql-client");
+const datatype_map_1 = require("./datatype-map");
+const SqbDataTypToOIDMap = {
+    [connect_1.DataType.BOOL]: postgresql_client_1.DataTypeOIDs.bool,
+    [connect_1.DataType.CHAR]: postgresql_client_1.DataTypeOIDs.char,
+    [connect_1.DataType.VARCHAR]: postgresql_client_1.DataTypeOIDs.varchar,
+    [connect_1.DataType.SMALLINT]: postgresql_client_1.DataTypeOIDs.int2,
+    [connect_1.DataType.INTEGER]: postgresql_client_1.DataTypeOIDs.int4,
+    [connect_1.DataType.BIGINT]: postgresql_client_1.DataTypeOIDs.int8,
+    [connect_1.DataType.FLOAT]: postgresql_client_1.DataTypeOIDs.float4,
+    [connect_1.DataType.DOUBLE]: postgresql_client_1.DataTypeOIDs.float8,
+    [connect_1.DataType.NUMBER]: postgresql_client_1.DataTypeOIDs.float8,
+    [connect_1.DataType.DATE]: postgresql_client_1.DataTypeOIDs.date,
+    [connect_1.DataType.TIMESTAMP]: postgresql_client_1.DataTypeOIDs.timestamp,
+    [connect_1.DataType.TIMESTAMPTZ]: postgresql_client_1.DataTypeOIDs.timestamptz,
+    [connect_1.DataType.TIME]: postgresql_client_1.DataTypeOIDs.time,
+    [connect_1.DataType.BINARY]: postgresql_client_1.DataTypeOIDs.bytea,
+    [connect_1.DataType.TEXT]: postgresql_client_1.DataTypeOIDs.text,
+    [connect_1.DataType.GUID]: postgresql_client_1.DataTypeOIDs.uuid,
+};
+class PgConnection {
+    constructor(conn) {
+        this.intlcon = conn;
+    }
+    get sessionId() {
+        return this.intlcon && this.intlcon.processID;
+    }
+    async close() {
+        if (!this.intlcon)
+            return;
+        await this.intlcon.close(0);
+        this.intlcon = undefined;
+    }
+    async reset() {
+        return this.rollback();
+    }
+    async startTransaction() {
+        if (!this.intlcon)
+            throw new Error('Can not start transaction for a closed db session');
+        await this.intlcon.startTransaction();
+    }
+    async commit() {
+        if (!this.intlcon)
+            throw new Error('Can not commit transaction for a closed db session');
+        await this.intlcon.commit();
+    }
+    async rollback() {
+        if (!this.intlcon)
+            return;
+        await this.intlcon.rollback();
+    }
+    async setSavepoint(savepoint) {
+        if (!this.intlcon)
+            throw new Error('Can not set savepoint for a closed db session');
+        return this.intlcon.savepoint(savepoint);
+    }
+    async releaseSavepoint(savepoint) {
+        if (!this.intlcon)
+            throw new Error('Can not release savepoint for a closed db session');
+        return this.intlcon.releaseSavepoint(savepoint);
+    }
+    async rollbackSavepoint(savepoint) {
+        if (!this.intlcon)
+            throw new Error('Can not rollback to a savepoint for a closed db session');
+        return this.intlcon.rollbackToSavepoint(savepoint);
+    }
+    getInTransaction() {
+        return !!(this.intlcon && this.intlcon.inTransaction);
+    }
+    async test() {
+        if (!this.intlcon)
+            throw new Error('DB session is closed');
+        await this.intlcon.query('select 1');
+    }
+    async getSchema() {
+        if (!this.intlcon)
+            throw new Error('DB session is closed');
+        const r = await this.intlcon.query('SHOW search_path');
+        if (r && r.rows && r.rows[0])
+            return r.rows[0][0];
+        return '';
+    }
+    async setSchema(schema) {
+        if (!this.intlcon)
+            throw new Error('Can not set schema of a closed db session');
+        await this.intlcon.execute('SET search_path TO ' + schema);
+    }
+    onGenerateQuery(request) {
+        if (this.intlcon) {
+            // eslint-disable-next-line dot-notation
+            request.dialectVersion = this.intlcon.sessionParameters['server_version'];
+        }
+    }
+    async execute(query) {
+        if (!this.intlcon)
+            throw new Error('Can not execute query with a closed db session');
+        const params = query.params?.map((v, i) => {
+            const paramOpts = Array.isArray(query.paramOptions) ? query.paramOptions[i] : undefined;
+            if (v != null && paramOpts && paramOpts.dataType) {
+                const oid = (0, datatype_map_1.dataTypeToOID)(paramOpts.dataType, paramOpts.isArray);
+                if (oid)
+                    return new postgresql_client_1.BindParam(oid, v);
+            }
+            return v;
+        });
+        const opts = {
+            autoCommit: query.autoCommit,
+            params,
+            cursor: query.cursor,
+            fetchCount: query.fetchRows,
+            objectRows: query.objectRows
+        };
+        if (query.fetchAsString) {
+            const items = query.fetchAsString.reduce((a, v) => {
+                const oid = SqbDataTypToOIDMap[v];
+                if (oid)
+                    a.push(oid);
+                return a;
+            }, []);
+            if (items.length)
+                opts.fetchAsString = items;
+        }
+        const resp = await this.intlcon.query(query.sql, opts);
+        const out = {};
+        if (resp.fields)
+            out.fields = this._convertFields(resp.fields);
+        if (resp.rows)
+            out.rows = resp.rows;
+        if (resp.cursor)
+            out.cursor = resp.cursor;
+        if (resp.rowType)
+            out.rowType = resp.rowType;
+        if (resp.rowsAffected)
+            out.rowsAffected = resp.rowsAffected;
+        return out;
+    }
+    _convertFields(fields) {
+        const result = [];
+        for (let i = 0; i < fields.length; i++) {
+            const v = fields[i];
+            const o = {
+                fieldName: v.fieldName,
+                dataType: v.dataTypeName,
+                elementDataType: v.elementDataTypeName,
+                jsType: v.jsType,
+                isArray: v.isArray,
+                _inf: v
+            };
+            result.push(o);
+        }
+        return result;
+    }
+}
+exports.PgConnection = PgConnection;

package/dist/datatype-map.d.ts

@@ -0,0 +1,3 @@
+import { DataType } from '@sqb/builder';
+import { OID } from 'postgresql-client';
+export declare function dataTypeToOID(dataType: DataType, isArray?: boolean): OID | undefined;

package/dist/datatype-map.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataTypeToOID = void 0;
+const builder_1 = require("@sqb/builder");
+const postgresql_client_1 = require("postgresql-client");
+function dataTypeToOID(dataType, isArray) {
+    if (dataType === builder_1.DataType.DATE)
+        return isArray ? postgresql_client_1.DataTypeOIDs._date : postgresql_client_1.DataTypeOIDs.date;
+    if (dataType === builder_1.DataType.BOOL)
+        return isArray ? postgresql_client_1.DataTypeOIDs._bool : postgresql_client_1.DataTypeOIDs.bool;
+    if (dataType === builder_1.DataType.CHAR)
+        return isArray ? postgresql_client_1.DataTypeOIDs._bpchar : postgresql_client_1.DataTypeOIDs.bpchar;
+    if (dataType === builder_1.DataType.SMALLINT)
+        return isArray ? postgresql_client_1.DataTypeOIDs._int2 : postgresql_client_1.DataTypeOIDs.int2;
+    if (dataType === builder_1.DataType.INTEGER)
+        return isArray ? postgresql_client_1.DataTypeOIDs._int4 : postgresql_client_1.DataTypeOIDs.int4;
+    if (dataType === builder_1.DataType.BIGINT)
+        return isArray ? postgresql_client_1.DataTypeOIDs._int8 : postgresql_client_1.DataTypeOIDs.int8;
+    if (dataType === builder_1.DataType.BINARY)
+        return isArray ? postgresql_client_1.DataTypeOIDs._bytea : postgresql_client_1.DataTypeOIDs.bytea;
+    if (dataType === builder_1.DataType.FLOAT)
+        return isArray ? postgresql_client_1.DataTypeOIDs._float4 : postgresql_client_1.DataTypeOIDs.float4;
+    if (dataType === builder_1.DataType.DOUBLE)
+        return isArray ? postgresql_client_1.DataTypeOIDs._float8 : postgresql_client_1.DataTypeOIDs.float8;
+    if (dataType === builder_1.DataType.GUID)
+        return isArray ? postgresql_client_1.DataTypeOIDs._uuid : postgresql_client_1.DataTypeOIDs.uuid;
+    if (dataType === builder_1.DataType.TEXT)
+        return isArray ? postgresql_client_1.DataTypeOIDs._text : postgresql_client_1.DataTypeOIDs.text;
+    if (dataType === builder_1.DataType.JSON)
+        return isArray ? postgresql_client_1.DataTypeOIDs._json : postgresql_client_1.DataTypeOIDs.json;
+}
+exports.dataTypeToOID = dataTypeToOID;

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sqb/postgres",
   "description": "SQB serialization extension for PostgreSQL database",
-  "version": "4.0.8",
-  "author": "Panates Ltd.",
+  "version": "4.0.12",
+  "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
   ],
@@ -27,10 +27,10 @@
     "putil-promisify": "^1.8.5"
   },
   "devDependencies": {
-    "postgresql-client": "^1.21.0"
+    "postgresql-client": "^2.0.0"
   },
   "peerDependencies": {
-    "postgresql-client": "^1.21.0",
+    "postgresql-client": "^2.0.0",
     "@sqb/postgres-dialect": "^4.x.x",
     "@sqb/builder": "^4.x.x",
     "@sqb/connect": "^4.x.x"
@@ -57,7 +57,6 @@
     "clean:dist": "rimraf ../../build/postgres",
     "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"
   }
 }