ismx-nexo-node-app 0.3.24

package/src/main/node/business/BusinessProxy.ts

@@ -0,0 +1,57 @@
+import { HttpResponse, HttpRequest } from "../api/Service"
+import fetch, {Body, Headers} from 'node-fetch';
+import {Wrapper} from "../api/ServiceRestFormal";
+
+export interface Module {
+    id: string;
+    tag: string;
+    host: string;
+}
+
+export default class BusinessProxy
+{
+    private modules: {[key:string]: Module} = {};
+
+    setModules(modules: {[key:string]: Module}) {
+        this.modules = modules
+    }
+
+    async callFormal<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<Res | undefined> {
+        let response = await this.call<Req, Wrapper<Res>>(tag, method, endpoint, request);
+        if (response?.code === "0") return response.data;
+        else throw response;
+    }
+
+    async call<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<Res> {
+        let module = this.modules[tag];
+        if (!module) throw new Error(`Module ${tag} does not exist`);
+
+        let headers = new Headers();
+        headers.set('Content-Type', 'application/json');
+        headers.set('Cache-Control', 'no-cache');
+        headers.set('Pragma', 'no-cache');
+        for (let header in request.headers)
+            headers.set(header, request.headers[header]);
+
+        let response = null;
+        try {
+            response = await fetch(`${module.host}${endpoint}${this.map(request.query)}`, {
+                method: method,
+                body: method !== "GET" ? JSON.stringify(request.body) : undefined,
+                headers: headers,
+            });
+        } catch (error) { throw new Error(`Module ${tag} is not responding`); }
+
+        if (response.ok) return await response.json();
+        else throw await response.json();
+    }
+
+    private map(query: { [key:string]: string } = {}) {
+        let queryString = "?"
+        for (const param in query) {
+            if (query[param] === undefined) continue;
+            queryString += `${param}=${query[param]}&`
+        }
+        return queryString;
+    }
+}

package/src/main/node/business/BusinessServer.ts

@@ -0,0 +1,76 @@
+import Service, {HttpRequest, HttpResponse} from "../api/Service";
+import express from "express";
+import core from "express"
+import Business from "./Business";
+import cors from 'cors';
+
+export default class BusinessServer extends Business
+{
+    private app: core.Express;
+    protected onStarted?: ()=>any;
+    protected onRequest?: (request: HttpRequest) => any;
+    protected onResponse?: (request: HttpRequest, response: HttpResponse) => HttpResponse<any> | undefined;
+    protected onError?: (request: HttpRequest, error: Error) => HttpResponse<any> | undefined | void
+    protected onEnd?: (request: HttpRequest, response: HttpResponse) => any;
+
+    constructor() {
+        super()
+        this.app = express();
+        this.app.use(express.urlencoded({ extended: false }));
+        this.app.use(express.json());
+        this.app.use(cors());
+
+        this.publish = this.publish.bind(this);
+    }
+
+    start(port: number) {
+        this.app.listen(port, this.onStarted)
+    }
+
+    setServices(services: Service<any, any>[]) {
+        services.forEach(this.publish);
+    }
+
+    private publish<Req=any, Res=any>(service: Service<Req, Res>) {
+        switch (service.method) {
+            case "GET": this.app.get(service.endpoint, this.run(service)); break;
+            case "POST": this.app.post(service.endpoint, this.run(service)); break;
+            case "PUT": this.app.put(service.endpoint, this.run(service)); break;
+            case "DELETE": this.app.delete(service.endpoint, this.run(service)); break;
+            case "PATCH": this.app.patch(service.endpoint, this.run(service)); break;
+            case "*": this.app.all(service.endpoint, this.run(service)); break;
+        }
+    }
+
+    private run<Req=any, Res=any>(service: Service<Req, Res>) { return async(request: any, socket: any) =>
+    {
+        let code;
+        let response: HttpResponse<Res> = HttpResponse.ko(500, "Internal server error");
+
+        // Asigna un valor único a la llamada de la API.
+        request.id = Math.ceil(Math.random() * 1000000).toString();
+        request.timestamp = new Date();
+
+        let indexParams = request.url.indexOf('?');
+        let endpoint = indexParams > 0 ? request.url.substring(0,indexParams) : request.url
+        request.endpoint = !!endpoint ? endpoint : "/";
+
+        try {
+            try { this.onRequest?.(request); } catch(e) { }
+            response = await service.serve?.(request);
+            response.httpCode = response.httpCode ?? 200;
+            try { response = (this.onResponse?.(request, response) ?? response) } catch(e) { }
+
+        } catch (error: any) {
+            this.onError?.(request, error);
+            let debug = error.message;
+            if (!error.code) error = { code: "-1", description: "Internal server error", debug };
+            let content = { code: error.code, description: error.description, debug };
+            response = HttpResponse.ko(error.httpCode, content);
+
+        } finally {
+            socket.status(response?.httpCode ?? 500).send(response?.content);
+            try { this.onEnd?.(request, response); } catch(e) { }
+        }
+    }}
+}

package/src/main/node/business/BusinessState.ts

@@ -0,0 +1,4 @@
+export default class BusinessState<Model>
+{
+
+}

package/src/main/node/business/BusinessThread.ts

@@ -0,0 +1,19 @@
+import Business from "./Business";
+
+export default abstract class BusinessThread extends Business
+{
+	constructor() {
+		super();
+		setTimeout(() => {
+			setInterval(() => {
+				try { this.run() }
+				catch (err) { this.onError() }
+			}, this.interval());
+		}, this.delay())
+	}
+
+	abstract run(): void
+	abstract interval(): number
+	abstract delay(): number
+	onError() {}
+}

package/src/main/node/business/utils/CryptoUtils.ts

@@ -0,0 +1,32 @@
+import crypto from "crypto";
+
+export default abstract class CryptoUtils {
+
+	static zeroPad(buf: Buffer, blocksize: number) {
+		const pad = Buffer.alloc((blocksize - (buf.length % blocksize)) % blocksize, 0);
+		return Buffer.concat([buf, pad]);
+	}
+
+	static encrypt3DES(key: string, message: string)
+	{
+		const keyBuf = Buffer.from(key, 'base64');
+		const iv = Buffer.alloc(8, 0);
+
+		const messageBuf = Buffer.from(message.toString(), 'utf8');
+		const paddedMessageBuf = CryptoUtils.zeroPad(messageBuf, 8);
+
+		const cipher = crypto.createCipheriv('des-ede3-cbc', keyBuf, iv);
+		cipher.setAutoPadding(false);
+		const encryptedBuf = Buffer.concat([
+			cipher.update(paddedMessageBuf), cipher.final()
+		]);
+
+		const maxLength = Math.ceil(messageBuf.length / 8) * 8;
+		return encryptedBuf.slice(0, maxLength);
+	}
+
+	static sha256Sign(merchantKey: string, orderId: string, encodedOrder: string) {
+		const orderKeyBuf = CryptoUtils.encrypt3DES(merchantKey, orderId);
+		return crypto.createHmac('sha256', orderKeyBuf).update(encodedOrder).digest('base64');
+	}
+}

package/src/main/node/business/utils/NumberUtils.ts

@@ -0,0 +1,6 @@
+export default abstract class NumberUtils {
+
+    static random(lower:number, upper:number) {
+        return Math.floor(Math.random() * (upper + 1 - lower)) + lower;
+    }
+}

package/src/main/node/business/utils/StringUtils.ts

@@ -0,0 +1,20 @@
+export default abstract class StringUtils {
+
+	static base64Decode(base64: string) {
+		return Buffer.from(base64, 'base64');
+	}
+
+ 	static base64Encode(buffer: Buffer) {
+		return buffer.toString('base64');
+	}
+
+	static base64UrlDecode(base64: string) {
+		let base64String = base64.replace(/-/g, '+').replace(/_/g, '/');
+
+		const padding = base64String.length % 4;
+		if (padding === 2) base64String += '==';
+		else if (padding === 3) base64String += '=';
+
+		return StringUtils.base64Decode(base64String);
+	}
+}

package/src/main/node/index.ts

@@ -0,0 +1,45 @@
+import BaseService, { HttpRequest as BaseHttpRequest, HttpResponse as BaseHttpResponse } from "./api/Service"
+export const Service = BaseService;
+export interface HttpRequest extends BaseHttpRequest {}
+export const HttpResponse = BaseHttpResponse;
+
+import BaseServiceRest from "./api/ServiceRest"
+export const ServiceRest = BaseServiceRest;
+
+import BaseServiceRestFormal, { Wrapper as BaseWrapper } from "./api/ServiceRestFormal"
+export const ServiceRestFormal = BaseServiceRestFormal;
+export interface Wrapper<T> extends BaseWrapper<T> {}
+
+import BaseServiceRestFormalTemplate from "./api/ServiceRestFormalTemplate"
+export const ServiceRestFormalTemplate = BaseServiceRestFormalTemplate;
+
+
+import BaseBusiness from "./business/Business";
+export const Business = BaseBusiness;
+
+import BaseBusinessState from "./business/BusinessState";
+export const BusinessState = BaseBusinessState;
+
+import BaseBusinessProxy, { Module as BaseModule } from "./business/BusinessProxy";
+export const BusinessProxy = BaseBusinessProxy;
+export interface Module extends BaseModule {}
+
+import BaseBusinessServer from "./business/BusinessServer";
+export const BusinessServer = BaseBusinessServer;
+
+import BaseBusinessThread from "./business/BusinessThread";
+export const BusinessThread = BaseBusinessThread;
+
+import BaseBusinessErrors, { FormalError as BaseFormalError } from "./business/BusinessErrors";
+export const BusinessErrors = BaseBusinessErrors;
+export interface FormalError extends BaseFormalError {}
+
+import BaseBusinessLogger from "./business/BusinessLogger";
+export const BusinessLogger = BaseBusinessLogger;
+
+
+import BaseRepository from "./repository/Repository";
+export const Repository = BaseRepository
+
+import BaseRepositoryPostgres from "./repository/RepositoryPostgres";
+export const RepositoryPostgres = BaseRepositoryPostgres

package/src/main/node/repository/Repository.ts

@@ -0,0 +1,3 @@
+export default class Repository {
+
+}

package/src/main/node/repository/RepositoryPostgres.ts

@@ -0,0 +1,246 @@
+import pg, {ClientConfig, QueryResult, QueryResultRow} from "pg";
+import PostgresUtils from "./utils/PostgresUtils";
+
+export interface QueryOptions {
+    schema?: string;
+    filters?: string;
+}
+
+export interface Chain extends ClientConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    schema: string;
+}
+
+export interface Column {
+    name: string
+    default?: string
+}
+
+export interface Pagination<T> {
+    total: number;
+    elements: T[];
+}
+
+export type Primitive = string | number | Date | null | undefined;
+
+export default abstract class RepositoryPostgres
+{
+    protected chain!: Chain;
+
+    protected client!: pg.Client;
+
+    private connected: boolean = false;
+
+    private tables: { [key: string]: Column[] } = {};
+
+    private onConnectListeners: (()=>void)[] = [];
+
+    private onQueryWillExecuteListeners: ((key:string)=>void)[] = [];
+
+    private onQueryDidExecuteListeners: ((key:string)=>void)[] = [];
+
+    private onIntrospectedListener: ((tables: { [p: string]: Column[] })=>void)[] = [];
+
+    private introspectIntervalTime = 5 * 60 * 1000
+
+    private schema: string = "public";
+
+    constructor()
+    {
+        this.query = this.query.bind(this)
+        this.one = this.one.bind(this)
+        this.add = this.add.bind(this)
+        this.update = this.update.bind(this)
+        this.del = this.del.bind(this)
+        this.introspect = this.introspect.bind(this)
+    }
+
+    init(chain: Chain)
+    {
+        this.chain = chain;
+        this.schema = chain.schema || "public";
+        this.connect(chain);
+    }
+
+    isConnected() {
+        return this.connected;
+    }
+
+    addOnConnect(listener: () => void) { this.onConnectListeners.push(listener); }
+    addOnQueryWillExecuteListener(listener: (query: string) => void) { this.onQueryWillExecuteListeners.push(listener); }
+    setIntrospectInterval(time: number) { this.introspectIntervalTime = time; }
+    addOnIntrospected(listener: (tables: { [p: string]: Column[] })=>void) { this.onIntrospectedListener.push(listener); }
+
+    connect(connection: Chain) {
+        this.client = new pg.Client(connection);
+        this.client.connect().then(async () => {
+            await this.introspect();
+            setInterval(this.introspect, this.introspectIntervalTime);
+            this.connected = true;
+            this.onConnectListeners.map(l => l());
+        });
+    }
+
+    async native(query: string, values: any[] = [], options: QueryOptions = {}): Promise<QueryResult>
+    {
+        this.onQueryWillExecuteListeners.forEach((l) => l(query));
+        let cursor = this.client.query(query, values);
+        this.onQueryDidExecuteListeners.forEach((l) => l(query));
+        return cursor;
+    }
+
+    async query<E>(query: string, values: any[] = [], options: QueryOptions = {}): Promise<E[]>
+    {
+        return await this.native(query, values, options).then((result) => {
+            return PostgresUtils.snakeToCamel(result.rows);
+        });
+    }
+
+    async one<E>(tableName: string, id: string): Promise<E>
+    {
+        return this.any<E>(tableName, { id });
+    }
+
+    async any<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E>
+    {
+        return await this.find<E>(tableName, filters).then((rows) => rows[0]);
+    }
+
+    async find<T>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<T[]>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let { where, values } = this.toQuery(tableName, filters);
+        let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where}`
+        return this.query<T>(query, values);
+    }
+
+    async all_depr<E>(tableName: string, options: QueryOptions = {}): Promise<E[]>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let table = this.tables[tableName];
+        let schema = options.schema ?? this.schema;
+
+        return this.query(`
+            SELECT * FROM ${schema}.${tableName} 
+            WHERE ${ options.filters ?? "TRUE" }
+        `);
+    }
+
+    async add<E>(tableName: string, object: {[key:string]:Primitive} | any, id?: string): Promise<E>
+    {
+        return this.addAll<E>(tableName, [ { id: id, ...object } ]).then((rows) => rows[0]);
+    }
+
+    async addAll<T>(tableName: string, objects: {[key:string]:Primitive }[]): Promise<T[]>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let table = this.tables[tableName];
+        let columns = PostgresUtils.columns(table);
+        let query = `INSERT INTO ${this.schema}.${tableName} (${columns.join(",")}) VALUES `;
+
+        let values = []; let index = 1;
+        for (let object of objects) {
+            let { bindings, values: valueList } = PostgresUtils.bindOrDefault(table, object, index);
+            index += valueList.length;
+            values.push(...valueList)
+            query += `(${bindings.join(",")}), `;
+        }
+        query = query.slice(0, -2);
+        query += ` RETURNING *`;
+
+        return this.query(query, values);
+    }
+
+    async update(tableName: string, id: string, object: {[key:string]:Primitive})
+    {
+        if (!id) throw new Error(`field 'id' is mandatory when updating ${tableName}`);
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let table = this.tables[tableName];
+        let columns = PostgresUtils.columns(table);
+
+        let params = columns.map((column, index) => `\$${index+2}`).join(",");
+        let values = [ id, ...columns.map((column) => object[PostgresUtils.stringToCamel(column)]) ];
+        let query = `UPDATE ${this.schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `
+        query += `RETURNING *`;
+
+        return this.query(query, values);
+    }
+
+    async page<T>(tableName: string, sortKey: string, maxResults: number = 50, pageNumber: number = 0, filters?: {[key:string]:Primitive|Array<Primitive>}): Promise<Pagination<T>>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let table = this.tables[tableName];
+        let columns = PostgresUtils.columns(table);
+        let offset = maxResults * pageNumber;
+
+        let { where, values } = this.toQuery(tableName, filters, "", 4);
+        let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${ where } ORDER BY $1 LIMIT $2 OFFSET $3`;
+        let elements = this.query<T>(query, [sortKey, maxResults, offset, ...values])
+
+        let total = this.count(tableName, filters)
+        return Promise.all([total, elements]).then(
+            ([total, elements]) => ({ total, elements })
+        );
+    }
+
+    async count(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<number>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let { where, values } = this.toQuery(tableName, filters);
+        let query = `SELECT count(*) as count FROM ${this.schema}.${tableName} WHERE ${where}`
+        return this.query<{count:number}>(query, values).then((result) => result[0].count);
+    }
+
+    async select(tableName: string, select: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<string[]>
+    {
+        if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
+        let { where, values } = this.toQuery(tableName, filters);
+        let query = `SELECT json_agg(${select}) as list FROM ${this.schema}.${tableName} WHERE ${where}`
+        return this.query<{list:string[]}>(query, values).then((result) => result[0].list);
+    }
+
+    async del(tableName: string, id: string)
+    {
+        throw new Error(`not implemented yet`);
+    }
+
+    private toQuery(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }, alias:string = "", index=1)
+    {
+        let table = this.tables[tableName];
+        let columns = PostgresUtils.columns(table);
+        let elements = Object.entries(filters ?? []);
+        let where = "TRUE"; let iter = index; let values = [];
+
+        for (let [key, value] of elements) {
+            let colum = PostgresUtils.camelToSnake(key)
+            if (key !== "id" && !columns.includes(colum)) continue;
+            if (alias !== "") alias += "."
+            if (value instanceof Array) where += ` AND ${alias}${colum} = ANY(\$${iter++})`
+            else where += ` AND ${alias}${colum}=\$${iter++}`
+            values.push(value);
+        }
+
+        return { where, values };
+    }
+
+    private async introspect()  {
+        let result = await this.native(`
+            SELECT table_name as name,
+                   json_agg(json_build_object('name', column_name, 'default', column_default)) as columns
+            FROM information_schema.columns
+            WHERE (table_schema = $1 or table_schema = 'public')
+            GROUP BY table_name
+        `, [this.schema]);
+
+        for (let table of result.rows)
+            this.tables[table["name"]] = table["columns"];
+
+        this.onIntrospectedListener.forEach((l) => l(this.tables));
+
+    }
+
+}

package/src/main/node/repository/RepositoryRest.ts

@@ -0,0 +1,70 @@
+import Repository from './Repository';
+import {HttpRequest, HttpResponse} from "../api/Service";
+import QueryUtils from "./utils/QueryUtils";
+
+export interface RestResponse<E=any> extends Response {
+  timestamp?: Date;
+  duration?: number;
+}
+
+export interface RestOptions {
+  interceptor: (response: RestResponse) => void;
+}
+
+export default class RepositoryRest<S=any> extends Repository
+{
+  private readonly baseUrl: string;
+
+  private readonly interceptor?: (response: RestResponse) => void;
+
+  private onRequestListener?: (method: string, endpoint: string, request: HttpRequest)=>void;
+
+  constructor(baseUrl: string, options?: RestOptions) {
+    super();
+    this.baseUrl = baseUrl;
+    this.interceptor = options?.interceptor;
+  }
+
+  setOnRequestListener(listener: (method: string, endpoint: string, request: HttpRequest)=>void) {
+    this.onRequestListener = listener;
+  }
+
+  async call<E = S>(
+    method: string = 'GET',
+    endpoint: string = '/',
+    request: HttpRequest = {},
+  ): Promise<RestResponse<E>>
+  {
+    // Especifica el método de la llamada HTTP al recurso.
+    request.method = method;
+
+    // Completa la información de las cabeceras con cabeceras comunes por llamada a API.
+    let headers = new Headers(request.headers);
+    headers.set('Content-Type', 'application/json');
+    headers.set('Cache-Control', 'no-cache');
+    headers.set('Pragma', 'no-cache');
+    for (let header in request.headers)
+      headers.set(header, request.headers[header]);
+
+    // Notifica que una petición REST va a ser realizada
+    this.onRequestListener?.(method, endpoint, request);
+
+    // Realiza la llamada a la API con las cabeceras y la URL base de la llamada.
+    let timestamp = new Date();
+    let call = fetch(this.baseUrl + endpoint + QueryUtils.map(request.query), {
+      ...request,
+      headers
+    });
+
+    // Añade información adicional a la respuesta y devuelve el resultado (o el error en su caso).
+    return call.then((res: Response) => {
+      let response: RestResponse<E> = res;
+      response.duration = new Date().valueOf() - timestamp.valueOf()
+      response.timestamp = timestamp;
+      this.interceptor?.(response);
+      return response;
+    });
+  }
+
+
+}

package/src/main/node/repository/RepositoryRestFormal.ts

@@ -0,0 +1,37 @@
+import RepositoryRest from "./RepositoryRest";
+import {Wrapper} from "../api/ServiceRestFormal";
+import {HttpRequest} from "../api/Service";
+import { FormalError } from "../business/BusinessErrors";
+
+export default class RepositoryRestFormal<S=any> extends RepositoryRest<Wrapper<S>> {
+
+	constructor(baseUrl: string, ...methods: RepositoryRest[]) {
+		super(baseUrl);
+	}
+
+	async call<E = S>(
+		method: string = 'GET',
+		endpoint: string = '/',
+		request: HttpRequest = {},
+	): Promise<E> {
+
+		request.body = JSON.stringify(request.body);
+
+		return super.call<E>(method, endpoint, request)
+			.then(async (call) => {
+				let json = await call.json();
+				if (json.code === "0") return json.data;
+				else { // @ts-ignore
+					throw new FormalError(json.code, json.description, call);
+				}
+
+			})
+			.catch((error: any) => {
+				// @ts-ignore
+				if (error instanceof FormalError) throw error;
+				else { // @ts-ignore
+					throw new FormalError("-1", "ConnectionError", undefined, error)
+				}
+			});
+	}
+}

package/src/main/node/repository/utils/PostgresUtils.ts

@@ -0,0 +1,59 @@
+import {Column, Primitive} from "../RepositoryPostgres";
+
+export default abstract class PostgresUtils
+{
+	static stringToCamel(column: string): string
+	{
+		return column.toLowerCase().replace(/([-_][a-z])/g, group =>
+			group.toUpperCase().replace('-', '').replace('_', '')
+		);
+	}
+
+	static camelToSnake(column: string) {
+		return column.replace(/([A-Z])/g, '_$1').toLowerCase();
+	}
+
+	static snakeToCamel(obj: any): any
+	{
+		if (Array.isArray(obj)) return obj.map(el => PostgresUtils.snakeToCamel(el));
+		else if (typeof obj === 'function' || obj !== Object(obj) || obj instanceof Date) return obj;
+		else return PostgresUtils.fromEntries(
+				Object.entries(obj).map(([key, value]) => [
+					key.replace(/([-_][a-z])/gi, c => c.toUpperCase().replace(/[-_]/g, '')),
+					PostgresUtils.snakeToCamel(value),
+				]),
+			);
+	}
+
+	static columns(table: Column[]): string[] {
+		return table.map((t) => t.name);
+	}
+
+	static bindOrDefault(table: Column[], object: { [p: string]: Primitive }, startIndex: any): { bindings: string[], values: any[] } {
+
+		let index = startIndex;
+		let bindings: string[] = [];
+		let values: any[] = []
+		table.forEach((colum) => {
+			let value = object[PostgresUtils.stringToCamel(colum.name)];
+			if (value !== undefined || colum.default === undefined) {
+				bindings.push(`\$${index++}`)
+				values.push(value)
+			} else bindings.push("DEFAULT")
+		});
+		return { bindings, values }
+	}
+
+	static valueOrDefault(columns: [string], object:any):string[] {
+		return columns.map((column) => {
+			return object[PostgresUtils.stringToCamel(column)];
+		});
+	}
+
+	static fromEntries(iterable: [string,any][]): {[key:string]:any} {
+		const result: {[key:string]:any} = {};
+		for (const [key, value] of iterable)
+			result[key] = value;
+		return result;
+	}
+}