ismx-nexo-node-app 0.3.36 → 0.3.38

package/dist/js/index.js

@@ -54,19 +54,33 @@ exports.BusinessState = BusinessState_1.default;
 const BusinessProxy_1 = __importDefault(require("./business/BusinessProxy"));
 exports.BusinessProxy = BusinessProxy_1.default;
 const BusinessServer_1 = __importDefault(require("./business/BusinessServer"));
-exports.BusinessServer = BusinessServer_1.default;
+class BusinessServer extends BusinessServer_1.default {
+}
+exports.BusinessServer = BusinessServer;
 const BusinessThread_1 = __importDefault(require("./business/BusinessThread"));
-exports.BusinessThread = BusinessThread_1.default;
+class BusinessThread extends BusinessThread_1.default {
+}
+exports.BusinessThread = BusinessThread;
 const BusinessErrors_1 = __importDefault(require("./business/BusinessErrors"));
-exports.BusinessErrors = BusinessErrors_1.default;
+class BusinessErrors extends BusinessErrors_1.default {
+}
+exports.BusinessErrors = BusinessErrors;
 const BusinessLogger_1 = __importDefault(require("./business/BusinessLogger"));
-exports.BusinessLogger = BusinessLogger_1.default;
+class BusinessLogger extends BusinessLogger_1.default {
+}
+exports.BusinessLogger = BusinessLogger;
 const CryptoUtils_1 = __importDefault(require("./business/utils/CryptoUtils"));
-exports.CryptoUtils = CryptoUtils_1.default;
+class CryptoUtils extends CryptoUtils_1.default {
+}
+exports.CryptoUtils = CryptoUtils;
 const NumberUtils_1 = __importDefault(require("./business/utils/NumberUtils"));
-exports.NumberUtils = NumberUtils_1.default;
+class NumberUtils extends NumberUtils_1.default {
+}
+exports.NumberUtils = NumberUtils;
 const StringUtils_1 = __importDefault(require("./business/utils/StringUtils"));
-exports.StringUtils = StringUtils_1.default;
+class StringUtils extends StringUtils_1.default {
+}
+exports.StringUtils = StringUtils;
 /**************************************************************/
 const Repository_1 = __importDefault(require("./repository/Repository"));
 exports.Repository = Repository_1.default;
@@ -79,4 +93,6 @@ class RepositoryDatabasePostgres extends RepositoryDatabasePostgres_1.default {
 }
 exports.RepositoryDatabasePostgres = RepositoryDatabasePostgres;
 const QueryUtils_1 = __importDefault(require("./repository/utils/QueryUtils"));
-exports.QueryUtils = QueryUtils_1.default;
+class QueryUtils extends QueryUtils_1.default {
+}
+exports.QueryUtils = QueryUtils;

package/dist/js/repository/RepositoryDatabasePostgres.js

@@ -20,14 +20,12 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
         super();
         this.introspectIntervalTime = 60 * 60 * 1000;
         this.tables = {};
-        this.schema = "public";
         this.onIntrospectedListeners = [];
         this.native = this.native.bind(this);
         this.introspect = this.introspect.bind(this);
     }
     init(chain) {
         super.init(chain);
-        this.schema = chain.schema || "public";
         this.connect(chain);
     }
     addOnIntrospectedListener(listener) {
@@ -64,33 +62,21 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
             return this.any(tableName, { id });
         });
     }
-    any(tableName, filters) {
-        return __awaiter(this, void 0, void 0, function* () {
+    any(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, filters = {}) {
             return yield this.find(tableName, filters).then((rows) => rows[0]);
         });
     }
-    find(tableName, filters) {
-        return __awaiter(this, void 0, void 0, function* () {
+    find(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, filters = {}) {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
+            let schema = this.tables[tableName][0].schema;
             let { where, values } = this.toWhere(tableName, filters);
-            let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where}`;
+            let query = `SELECT * FROM ${schema}.${tableName} WHERE ${where}`;
             return this.query(query, values);
         });
     }
-    all_depr(tableName_1) {
-        return __awaiter(this, arguments, void 0, function* (tableName, options = {}) {
-            var _a, _b;
-            if (!this.tables[tableName])
-                throw new Error(`table ${tableName} does not exist`);
-            let table = this.tables[tableName];
-            let schema = (_a = options.schema) !== null && _a !== void 0 ? _a : this.schema;
-            return this.query(`
-            SELECT * FROM ${schema}.${tableName} 
-            WHERE ${(_b = options.filters) !== null && _b !== void 0 ? _b : "TRUE"}
-        `);
-        });
-    }
     add(tableName, object, id) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.addAll(tableName, [Object.assign({ id: id }, object)]).then((rows) => rows[0]);
@@ -101,8 +87,9 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
             let table = this.tables[tableName];
+            let schema = table[0].schema;
             let columns = PostgresUtils_1.default.columns(table);
-            let query = `INSERT INTO ${this.schema}.${tableName} (${columns.join(",")}) VALUES `;
+            let query = `INSERT INTO ${schema}.${tableName} (${columns.join(",")}) VALUES `;
             let values = [];
             let index = 1;
             for (let object of objects) {
@@ -123,43 +110,47 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
             let table = this.tables[tableName];
+            let schema = table[0].schema;
             let columns = PostgresUtils_1.default.columns(table);
             let params = columns.map((column, index) => `\$${index + 2}`).join(",");
             let values = [id, ...columns.map((column) => object[PostgresUtils_1.default.stringToCamel(column)])];
-            let query = `UPDATE ${this.schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `;
+            let query = `UPDATE ${schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `;
             query += `RETURNING *`;
             return this.query(query, values).then((result) => result[0]);
         });
     }
     page(tableName_1, sortKey_1) {
-        return __awaiter(this, arguments, void 0, function* (tableName, sortKey, maxResults = 50, pageNumber = 0, filters) {
+        return __awaiter(this, arguments, void 0, function* (tableName, sortKey, maxResults = 50, pageNumber = 0, filters = {}) {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
             let table = this.tables[tableName];
+            let schema = table[0].schema;
             let columns = PostgresUtils_1.default.columns(table);
             let offset = maxResults * pageNumber;
             let { where, values } = this.toWhere(tableName, filters, "", 4);
-            let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where} ORDER BY $1 LIMIT $2 OFFSET $3`;
+            let query = `SELECT * FROM ${schema}.${tableName} WHERE ${where} ORDER BY $1 LIMIT $2 OFFSET $3`;
             let elements = this.query(query, [sortKey, maxResults, offset, ...values]);
             let total = this.count(tableName, filters);
             return Promise.all([total, elements]).then(([total, elements]) => ({ total, elements }));
         });
     }
-    count(tableName, filters) {
-        return __awaiter(this, void 0, void 0, function* () {
+    count(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, filters = {}) {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
+            let schema = this.tables[tableName][0].schema;
             let { where, values } = this.toWhere(tableName, filters);
-            let query = `SELECT count(*) as count FROM ${this.schema}.${tableName} WHERE ${where}`;
+            let query = `SELECT count(*) as count FROM ${schema}.${tableName} WHERE ${where}`;
             return this.query(query, values).then((result) => result[0].count);
         });
     }
-    select(tableName, select, filters) {
-        return __awaiter(this, void 0, void 0, function* () {
+    select(tableName_1, select_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, select, filters = {}) {
             if (!this.tables[tableName])
                 throw new Error(`table ${tableName} does not exist`);
+            let schema = this.tables[tableName][0].schema;
             let { where, values } = this.toWhere(tableName, filters);
-            let query = `SELECT json_agg(u.${select}) as list FROM ${this.schema}.${tableName} u WHERE ${where}`;
+            let query = `SELECT json_agg(u.${select}) as list FROM ${schema}.${tableName} u WHERE ${where}`;
             return this.query(query, values).then((result) => result[0].list);
         });
     }
@@ -168,7 +159,7 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
             throw new Error(`not implemented yet`);
         });
     }
-    toWhere(tableName, filters, alias = "", index = 1) {
+    toWhere(tableName, filters = {}, alias = "", index = 1) {
         let table = this.tables[tableName];
         let columns = PostgresUtils_1.default.columns(table);
         let elements = Object.entries(filters !== null && filters !== void 0 ? filters : []);
@@ -193,11 +184,10 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             let result = yield this.native(`
             SELECT table_name as name,
-                   json_agg(json_build_object('name', column_name, 'default', column_default)) as columns
+                   json_agg(json_build_object('name', column_name, 'schema', table_schema, '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.onIntrospectedListeners.forEach((l) => l(this.tables));

package/dist/js/repository/RepositoryRestFormal.js

@@ -29,15 +29,15 @@ class RepositoryRestFormal extends RepositoryRest_1.default {
                 if (json.code === "0")
                     return json.data;
                 else { // @ts-ignore
-                    throw new BusinessErrors_1.FormalError(json.code, json.description, call);
+                    throw new FormalError(json.code, json.description, call);
                 }
             }))
                 .catch((error) => {
                 // @ts-ignore
-                if (error instanceof BusinessErrors_1.FormalError)
+                if (error instanceof FormalError)
                     throw error;
                 else { // @ts-ignore
-                    throw new BusinessErrors_1.FormalError("-1", "ConnectionError", undefined, error);
+                    throw new FormalError("-1", "ConnectionError", undefined, error);
                 }
             });
         });

package/dist/types/index.d.ts

@@ -26,21 +26,28 @@ export declare const BusinessProxy: typeof BaseBusinessProxy;
 export interface Module extends BaseModule {
 }
 import BaseBusinessServer from "./business/BusinessServer";
-export declare const BusinessServer: typeof BaseBusinessServer;
+export declare class BusinessServer extends BaseBusinessServer {
+}
 import BaseBusinessThread from "./business/BusinessThread";
-export declare const BusinessThread: typeof BaseBusinessThread;
+export declare abstract class BusinessThread extends BaseBusinessThread {
+}
 import BaseBusinessErrors, { FormalError as BaseFormalError } from "./business/BusinessErrors";
-export declare const BusinessErrors: typeof BaseBusinessErrors;
+export declare class BusinessErrors extends BaseBusinessErrors {
+}
 export interface FormalError extends BaseFormalError {
 }
 import BaseBusinessLogger from "./business/BusinessLogger";
-export declare const BusinessLogger: typeof BaseBusinessLogger;
+export declare class BusinessLogger extends BaseBusinessLogger {
+}
 import _CryptoUtils from "./business/utils/CryptoUtils";
-export declare const CryptoUtils: typeof _CryptoUtils;
+export declare abstract class CryptoUtils extends _CryptoUtils {
+}
 import _NumberUtils from "./business/utils/NumberUtils";
-export declare const NumberUtils: typeof _NumberUtils;
+export declare abstract class NumberUtils extends _NumberUtils {
+}
 import _StringUtils from "./business/utils/StringUtils";
-export declare const StringUtils: typeof _StringUtils;
+export declare abstract class StringUtils extends _StringUtils {
+}
 /**************************************************************/
 import BaseRepository from "./repository/Repository";
 export declare const Repository: typeof BaseRepository;
@@ -51,4 +58,5 @@ import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres
 export declare class RepositoryDatabasePostgres extends _RepositoryDatabasePostgres {
 }
 import _QueryUtils from "./repository/utils/QueryUtils";
-export declare const QueryUtils: typeof _QueryUtils;
+export declare abstract class QueryUtils extends _QueryUtils {
+}

package/dist/types/repository/RepositoryDatabase.d.ts

@@ -10,7 +10,6 @@ export interface Chain {
     user: string;
     password: string;
     database: string;
-    schema: string;
 }
 export interface Pagination<T> {
     total: number;
@@ -38,7 +37,6 @@ export default abstract class RepositoryDatabase extends Repository {
     abstract find<E>(tableName: string, filters: {
         [key: string]: Primitive | Array<any>;
     }): Promise<E[]>;
-    abstract all_depr<E>(tableName: string, options: QueryOptions): Promise<E[]>;
     abstract add<E>(tableName: string, object: {
         [key: string]: Primitive;
     } | any, id?: string): Promise<E>;

package/dist/types/repository/RepositoryDatabasePostgres.d.ts

@@ -2,13 +2,13 @@ import pg, { QueryResult } from "pg";
 import RepositoryDatabase, { Chain, Pagination, Primitive, QueryOptions } from "./RepositoryDatabase";
 export interface Column {
     name: string;
+    schema: string;
     default?: string;
 }
 export default class RepositoryDatabasePostgres extends RepositoryDatabase {
     private readonly introspectIntervalTime;
     protected client: pg.Client;
     private tables;
-    private schema;
     constructor();
     init(chain: Chain): void;
     private onIntrospectedListeners;
@@ -19,13 +19,12 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase {
     native(query: string, values?: any[], options?: QueryOptions): Promise<QueryResult>;
     query<E>(query: string, values?: any[], options?: QueryOptions): Promise<E[]>;
     one<E>(tableName: string, id: string): Promise<E>;
-    any<E>(tableName: string, filters: {
+    any<E>(tableName: string, filters?: {
         [key: string]: Primitive | Array<any>;
     }): Promise<E>;
-    find<T>(tableName: string, filters: {
+    find<T>(tableName: string, filters?: {
         [key: string]: Primitive | Array<any>;
     }): Promise<T[]>;
-    all_depr<E>(tableName: string, options?: QueryOptions): Promise<E[]>;
     add<E>(tableName: string, object: {
         [key: string]: Primitive;
     } | any, id?: string): Promise<E>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ismx-nexo-node-app",
-  "version": "0.3.36",
+  "version": "0.3.38",
   "description": "",
   "scripts": {
     "build": "rm -rf ./dist && npx tsc",

package/src/main/node/index.ts

@@ -26,26 +26,26 @@ export const BusinessProxy = BaseBusinessProxy;
 export interface Module extends BaseModule {}
 
 import BaseBusinessServer from "./business/BusinessServer";
-export const BusinessServer = BaseBusinessServer;
+export class BusinessServer extends BaseBusinessServer {}
 
 import BaseBusinessThread from "./business/BusinessThread";
-export const BusinessThread = BaseBusinessThread;
+export abstract class BusinessThread extends BaseBusinessThread {}
 
 import BaseBusinessErrors, { FormalError as BaseFormalError } from "./business/BusinessErrors";
-export const BusinessErrors = BaseBusinessErrors;
+export class BusinessErrors extends BaseBusinessErrors {}
 export interface FormalError extends BaseFormalError {}
 
 import BaseBusinessLogger from "./business/BusinessLogger";
-export const BusinessLogger = BaseBusinessLogger;
+export class BusinessLogger extends BaseBusinessLogger {}
 
 import _CryptoUtils from "./business/utils/CryptoUtils";
-export const CryptoUtils = _CryptoUtils;
+export abstract class CryptoUtils extends _CryptoUtils {}
 
 import _NumberUtils from "./business/utils/NumberUtils";
-export const NumberUtils = _NumberUtils;
+export abstract class NumberUtils extends _NumberUtils {}
 
 import _StringUtils from "./business/utils/StringUtils";
-export const StringUtils = _StringUtils;
+export abstract class StringUtils extends _StringUtils {}
 
 /**************************************************************/
 
@@ -59,4 +59,4 @@ import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres
 export class RepositoryDatabasePostgres extends _RepositoryDatabasePostgres {}
 
 import _QueryUtils from "./repository/utils/QueryUtils";
-export const QueryUtils = _QueryUtils;
+export abstract class QueryUtils extends _QueryUtils {}

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

@@ -12,7 +12,6 @@ export interface Chain {
     user: string;
     password: string;
     database: string;
-    schema: string;
 }
 
 export interface Pagination<T> {
@@ -63,8 +62,6 @@ export default abstract class RepositoryDatabase extends Repository
 
     abstract find<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E[]>;
 
-    abstract all_depr<E>(tableName: string, options: QueryOptions): Promise<E[]>;
-
     abstract add<E>(tableName: string, object: {[key:string]:Primitive}|any, id?: string): Promise<E>;
 
     abstract addAll<T>(tableName: string, objects: ({[key:string]:Primitive }|any)[]): Promise<T[]>;

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

@@ -4,6 +4,7 @@ import RepositoryDatabase, {Chain, Pagination, Primitive, QueryOptions} from "./
 
 export interface Column {
     name: string
+    schema: string
     default?: string
 }
 
@@ -15,8 +16,6 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
 
     private tables: { [key: string]: Column[] } = {};
 
-    private schema: string = "public";
-
     constructor() {
         super();
         this.native = this.native.bind(this);
@@ -26,7 +25,6 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
     init(chain: Chain)
     {
         super.init(chain);
-        this.schema = chain.schema || "public";
         this.connect(chain);
     }
 
@@ -65,31 +63,20 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         return this.any<E>(tableName, { id });
     }
 
-    async any<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E>
+    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[]>
+    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 schema = this.tables[tableName][0].schema;
         let { where, values } = this.toWhere(tableName, filters);
-        let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where}`
+        let query = `SELECT * FROM ${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]);
@@ -99,8 +86,9 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let table = this.tables[tableName];
+        let schema = table[0].schema;
         let columns = PostgresUtils.columns(table);
-        let query = `INSERT INTO ${this.schema}.${tableName} (${columns.join(",")}) VALUES `;
+        let query = `INSERT INTO ${schema}.${tableName} (${columns.join(",")}) VALUES `;
 
         let values = []; let index = 1;
         for (let object of objects) {
@@ -120,25 +108,27 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         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 schema = table[0].schema;
         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 `
+        let query = `UPDATE ${schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `
         query += `RETURNING *`;
 
         return this.query<T>(query, values).then((result) => result[0]);
     }
 
-    async page<T>(tableName: string, sortKey: string, maxResults: number = 50, pageNumber: number = 0, filters?: {[key:string]:Primitive|Array<Primitive>}): Promise<Pagination<T>>
+    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 schema = table[0].schema;
         let columns = PostgresUtils.columns(table);
         let offset = maxResults * pageNumber;
 
         let { where, values } = this.toWhere(tableName, filters, "", 4);
-        let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${ where } ORDER BY $1 LIMIT $2 OFFSET $3`;
+        let query = `SELECT * FROM ${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)
@@ -147,19 +137,21 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         );
     }
 
-    async count(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<number>
+    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 schema = this.tables[tableName][0].schema;
         let { where, values } = this.toWhere(tableName, filters);
-        let query = `SELECT count(*) as count FROM ${this.schema}.${tableName} WHERE ${where}`
+        let query = `SELECT count(*) as count FROM ${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[]>
+    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 schema = this.tables[tableName][0].schema;
         let { where, values } = this.toWhere(tableName, filters);
-        let query = `SELECT json_agg(u.${select}) as list FROM ${this.schema}.${tableName} u WHERE ${where}`
+        let query = `SELECT json_agg(u.${select}) as list FROM ${schema}.${tableName} u WHERE ${where}`
         return this.query<{list:string[]}>(query, values).then((result) => result[0].list);
     }
 
@@ -168,7 +160,7 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         throw new Error(`not implemented yet`);
     }
 
-    toWhere(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }, alias:string = "", index=1)
+    toWhere(tableName: string, filters: { [key: string]: Primitive | Array<Primitive> }={}, alias:string = "", index=1)
     {
         let table = this.tables[tableName];
         let columns = PostgresUtils.columns(table);
@@ -190,11 +182,10 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
     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
+                   json_agg(json_build_object('name', column_name, 'schema', table_schema, '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"];

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

@@ -1,7 +1,6 @@
 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>> {