ismx-nexo-node-app 0.4.104 → 0.4.106

package/dist/js/repository/Repository.js

@@ -1,5 +1,47 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = void 0;
+class Hash {
+    constructor(dict) {
+        this.size = null;
+        this[_a] = "Hash";
+        this.dict = dict !== null && dict !== void 0 ? dict : {};
+    }
+    add(value) {
+        this.dict[value] = null;
+        return this;
+    }
+    clear() {
+        this.dict = {};
+    }
+    delete(value) {
+        return delete this.dict[value];
+    }
+    forEach(callbackfn, thisArg) {
+        return Object.keys(this.dict).forEach((v) => callbackfn(v, v, this), thisArg);
+    }
+    has(value) {
+        return !!this.dict[value];
+    }
+    entries() {
+        return Object.entries(this.dict);
+    }
+    keys() {
+        return Object.keys(this.dict).values();
+    }
+    values() {
+        return Object.keys(this.dict).values();
+    }
+    length() {
+        return Object.keys(this.dict).length;
+    }
+    [Symbol.iterator]() {
+        return Object.keys(this.dict)[Symbol.iterator]();
+    }
+}
+exports.Hash = Hash;
+_a = Symbol.toStringTag;
 class Repository {
 }
 exports.default = Repository;

package/dist/js/repository/RepositoryDatabasePostgres.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const PostgresUtils_1 = __importDefault(require("./utils/PostgresUtils"));
 const RepositoryDatabase_1 = __importDefault(require("./RepositoryDatabase"));
+const Repository_1 = require("./Repository");
 class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
     constructor() {
         super();
@@ -220,6 +221,18 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
             return this.query(query, values).then((result) => { var _a, _b; return (_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : []; });
         });
     }
+    selectSet(tableName, select, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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_object_agg(u.${select}, NULL) as list
+            FROM ( SELECT DISTINCT u.${select} FROM ${schema}.${tableName} WHERE "user" = ${where} ) t`;
+            return this.query(query, values).then((result) => { var _a, _b; return new Repository_1.Hash((_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : {}); });
+        });
+    }
     toWhere(tableName, filters = {}, alias = "", index = 1) {
         let table = this.tables[tableName];
         let columns = PostgresUtils_1.default.columns(table);

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

@@ -3,5 +3,21 @@ export interface Pagination<T> {
     elements: T[];
 }
 export type Transient<T> = Omit<T, 'id'>;
+export declare class Hash<T extends string | number | symbol> implements Set<T> {
+    dict: Record<T, any>;
+    size: number;
+    constructor(dict?: Record<T, any>);
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    entries(): SetIterator<[T, T]>;
+    keys(): SetIterator<T>;
+    values(): SetIterator<T>;
+    length(): number;
+    [Symbol.iterator](): SetIterator<T>;
+    [Symbol.toStringTag]: string;
+}
 export default class Repository {
 }

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

@@ -10,7 +10,8 @@ export interface Chain {
     password: string;
     database: string;
 }
-export type Primitive = string | number | Date | null | undefined;
+export type Primitive = string | number | symbol;
+export type Valuable = Primitive | Date | null | undefined;
 export default abstract class RepositoryDatabase extends Repository {
     protected connected: boolean;
     protected chain: Chain;
@@ -27,36 +28,36 @@ export default abstract class RepositoryDatabase extends Repository {
     abstract query<E>(query: string, values: any[], options: QueryOptions): Promise<E[]>;
     abstract one<E>(tableName: string, id: string): Promise<E>;
     abstract any<E>(tableName: string, filters: {
-        [key: string]: Primitive | Array<any>;
+        [key: string]: Valuable | Array<any>;
     }): Promise<E>;
     abstract find<E>(tableName: string, filters: {
-        [key: string]: Primitive | Array<any>;
+        [key: string]: Valuable | Array<any>;
     }): Promise<E[]>;
     abstract group(tableName: string, key: string, value: string, filters: {
-        [p: string]: Primitive | Array<any>;
+        [p: string]: Valuable | Array<any>;
     }): Promise<{
         [p: string]: string[];
     }>;
     abstract add<E>(tableName: string, object: {
-        [key: string]: Primitive;
+        [key: string]: Valuable;
     } | any, id?: string): Promise<E>;
     abstract addAll<T>(tableName: string, objects: ({
-        [key: string]: Primitive;
+        [key: string]: Valuable;
     } | any)[]): Promise<T[]>;
     abstract update<T>(tableName: string, id: string, object: {
-        [key: string]: Primitive;
+        [key: string]: Valuable;
     } | any): Promise<T>;
     abstract page<T>(tableName: string, sortKey: string, maxResults: number, pageNumber: number, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<Pagination<T>>;
     abstract exist(tableName: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<boolean>;
     abstract count(tableName: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<number>;
     abstract select(tableName: string, select: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<string[]>;
     abstract delete<T>(tableName: string, id: string): Promise<T>;
     abstract deleteAll<T>(tableName: string, filters: Partial<T>): Promise<T[]>;

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

@@ -1,5 +1,5 @@
-import RepositoryDatabase, { Chain, Primitive, QueryOptions } from "./RepositoryDatabase";
-import { Pagination } from "./Repository";
+import RepositoryDatabase, { Chain, Valuable, QueryOptions, Primitive } from "./RepositoryDatabase";
+import { Hash, Pagination } from "./Repository";
 export interface Column {
     name: string;
     schema: string;
@@ -20,42 +20,43 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase {
     query<E>(query: string, values?: any[], options?: QueryOptions): Promise<E[]>;
     one<E>(tableName: string, id: string): Promise<E>;
     any<E>(tableName: string, filters?: {
-        [key: string]: Primitive | Array<any>;
+        [key: string]: Valuable | Array<any>;
     }): Promise<E>;
     find<T>(tableName: string, filters?: {
-        [key: string]: Primitive | Array<any>;
+        [key: string]: Valuable | Array<any>;
     }): Promise<T[]>;
     group(tableName: string, key: string, value: string, filters: {
-        [p: string]: Primitive | Array<any>;
+        [p: string]: Valuable | Array<any>;
     }): Promise<{
         [p: string]: any[];
     }>;
     add<E>(tableName: string, object: {
-        [key: string]: Primitive;
+        [key: string]: Valuable;
     } | any, id?: string): Promise<E>;
     addAll<T>(tableName: string, objects: ({
-        [key: string]: Primitive;
+        [key: string]: Valuable;
     } | any)[]): Promise<T[]>;
     update<T>(tableName: string, id: string, object: Partial<T>): Promise<T>;
     delete<T>(tableName: string, id: string): Promise<T>;
     deleteAll<T>(tableName: string, filters: Partial<T>): Promise<T[]>;
     page<T>(tableName: string, sortKey: string, maxResults?: number, pageNumber?: number, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<Pagination<T>>;
     exist(tableName: string, filters?: {
-        [p: string]: Primitive | Array<Primitive>;
+        [p: string]: Valuable | Array<Valuable>;
     }): Promise<boolean>;
     count(tableName: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<number>;
     select(tableName: string, select: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }): Promise<string[]>;
+    selectSet<T>(tableName: string, select: string, filters: Partial<T>): Promise<Hash<Primitive>>;
     toWhere(tableName: string, filters?: {
-        [key: string]: Primitive | Array<Primitive>;
+        [key: string]: Valuable | Array<Valuable>;
     }, alias?: string, index?: number): {
         where: string;
-        values: (string | number | Date | Primitive[])[];
+        values: (string | number | symbol | Date | Valuable[])[];
     };
     private introspect;
 }

package/dist/types/repository/utils/PostgresUtils.d.ts

@@ -1,12 +1,12 @@
 import { Column } from "../RepositoryDatabasePostgres";
-import { Primitive } from "../RepositoryDatabase";
+import { Valuable } from "../RepositoryDatabase";
 export default abstract class PostgresUtils {
     static camelToSnake(column: string): string;
     static snakeToCamel(obj: any): any;
     static columns(table: Column[]): string[];
     static isReservedWord(word: string): boolean;
     static bindOrDefault(table: Column[], object: {
-        [p: string]: Primitive;
+        [p: string]: Valuable;
     }, startIndex: any): {
         bindings: string[];
         values: any[];

package/package.json

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

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

@@ -5,6 +5,49 @@ export interface Pagination<T> {
 
 export type Transient<T> = Omit<T, 'id'>
 
+export class Hash<T extends string | number | symbol> implements Set<T>
+{
+    dict: Record<T, any>
+    size: number = null!;
+
+    constructor(dict?: Record<T, any>) {
+        this.dict = dict ?? {} as Record<T, any>;
+    }
+
+    add(value: T): this {
+        this.dict[value] = null;
+        return this;
+    }
+    clear(): void {
+        this.dict = {} as Record<T, any>;
+    }
+    delete(value: T): boolean {
+        return delete this.dict[value];
+    }
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void {
+        return Object.keys(this.dict).forEach((v) => callbackfn(v as T, v as T, this), thisArg);
+    }
+    has(value: T): boolean {
+        return !!this.dict[value];
+    }
+    entries(): SetIterator<[T, T]> {
+        return Object.entries(this.dict) as unknown as SetIterator<[T, T]>;
+    }
+    keys(): SetIterator<T> {
+        return Object.keys(this.dict).values() as SetIterator<T>;
+    }
+    values(): SetIterator<T> {
+        return Object.keys(this.dict).values() as SetIterator<T>;
+    }
+    length(): number {
+        return Object.keys(this.dict).length;
+    }
+    [Symbol.iterator](): SetIterator<T> {
+        return (Object.keys(this.dict) as T[])[Symbol.iterator]()
+    }
+    [Symbol.toStringTag]: string = "Hash";
+}
+
 export default class Repository {
 
 }

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

@@ -13,7 +13,8 @@ export interface Chain {
     database: string;
 }
 
-export type Primitive = string | number | Date | null | undefined;
+export type Primitive = string | number | symbol
+export type Valuable = Primitive | Date | null | undefined;
 
 export default abstract class RepositoryDatabase extends Repository
 {
@@ -52,25 +53,25 @@ export default abstract class RepositoryDatabase extends Repository
 
     abstract one<E>(tableName: string, id: string): Promise<E>;
 
-    abstract any<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E>;
+    abstract any<E>(tableName: string, filters: { [key: string]: Valuable | Array<any> }): Promise<E>;
 
-    abstract find<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E[]>;
+    abstract find<E>(tableName: string, filters: { [key: string]: Valuable | Array<any> }): Promise<E[]>;
 
-    abstract group(tableName: string, key: string, value: string, filters: { [p: string]: Primitive | Array<any> }): Promise<{ [p: string]: string[] }>
+    abstract group(tableName: string, key: string, value: string, filters: { [p: string]: Valuable | Array<any> }): Promise<{ [p: string]: string[] }>
 
-    abstract add<E>(tableName: string, object: {[key:string]:Primitive}|any, id?: string): Promise<E>;
+    abstract add<E>(tableName: string, object: {[key:string]:Valuable}|any, id?: string): Promise<E>;
 
-    abstract addAll<T>(tableName: string, objects: ({[key:string]:Primitive }|any)[]): Promise<T[]>;
+    abstract addAll<T>(tableName: string, objects: ({[key:string]:Valuable }|any)[]): Promise<T[]>;
 
-    abstract update<T>(tableName: string, id: string, object: {[key:string]:Primitive}|any): Promise<T>;
+    abstract update<T>(tableName: string, id: string, object: {[key:string]:Valuable}|any): Promise<T>;
 
-    abstract page<T>(tableName: string, sortKey: string, maxResults: number, pageNumber: number, filters?: {[key:string]:Primitive|Array<Primitive>}): Promise<Pagination<T>>;
+    abstract page<T>(tableName: string, sortKey: string, maxResults: number, pageNumber: number, filters?: {[key:string]:Valuable|Array<Valuable>}): Promise<Pagination<T>>;
 
-    abstract exist(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<boolean>;
+    abstract exist(tableName: string, filters?: { [key: string]: Valuable | Array<Valuable> }): Promise<boolean>;
 
-    abstract count(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<number>;
+    abstract count(tableName: string, filters?: { [key: string]: Valuable | Array<Valuable> }): Promise<number>;
 
-    abstract select(tableName: string, select: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<string[]>;
+    abstract select(tableName: string, select: string, filters?: { [key: string]: Valuable | Array<Valuable> }): Promise<string[]>;
 
     abstract delete<T>(tableName: string, id: string): Promise<T>;
 

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

@@ -1,6 +1,6 @@
 import PostgresUtils from "./utils/PostgresUtils";
-import RepositoryDatabase, {Chain, Primitive, QueryOptions} from "./RepositoryDatabase";
-import {Pagination} from "./Repository";
+import RepositoryDatabase, {Chain, Valuable, QueryOptions, Primitive} from "./RepositoryDatabase";
+import {Hash, Pagination} from "./Repository";
 
 export interface Column {
     name: string
@@ -66,12 +66,12 @@ 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]: Valuable | 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]: Valuable | Array<any> }={}): Promise<T[]>
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let schema = this.tables[tableName][0].schema;
@@ -80,7 +80,7 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         return this.query<T>(query, values);
     }
 
-    async group(tableName: string, key: string, value: string, filters: { [p: string]: Primitive | Array<any> }): Promise<{ [p: string]: any[] }> {
+    async group(tableName: string, key: string, value: string, filters: { [p: string]: Valuable | Array<any> }): Promise<{ [p: string]: any[] }> {
         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);
@@ -94,12 +94,12 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         });
     }
 
-    async add<E>(tableName: string, object: {[key:string]:Primitive}|any, id?: string): Promise<E>
+    async add<E>(tableName: string, object: {[key:string]:Valuable}|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 }|any)[]): Promise<T[]>
+    async addAll<T>(tableName: string, objects: ({[key:string]:Valuable }|any)[]): Promise<T[]>
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let table = this.tables[tableName];
@@ -153,7 +153,7 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         return this.query<T>(query, values);
     }
 
-    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]:Valuable|Array<Valuable>}={}): Promise<Pagination<T>>
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let table = this.tables[tableName];
@@ -171,11 +171,11 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         );
     }
 
-    async exist(tableName: string, filters: { [p: string]: Primitive | Array<Primitive> }={}): Promise<boolean> {
+    async exist(tableName: string, filters: { [p: string]: Valuable | Array<Valuable> }={}): Promise<boolean> {
         return (await this.count(tableName, filters)) > 0;
     }
 
-    async count(tableName: string, filters: { [key: string]: Primitive | Array<Primitive> }={}): Promise<number>
+    async count(tableName: string, filters: { [key: string]: Valuable | Array<Valuable> }={}): Promise<number>
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let schema = this.tables[tableName][0].schema;
@@ -184,7 +184,7 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         return this.query<{count:string}>(query, values).then((result) => Number.parseInt(result[0]?.count ?? "0"));
     }
 
-    async select(tableName: string, select: string, filters: { [key: string]: Primitive | Array<Primitive> }={}): Promise<string[]>
+    async select(tableName: string, select: string, filters: { [key: string]: Valuable | Array<Valuable> }={}): Promise<string[]>
     {
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
         let schema = this.tables[tableName][0].schema;
@@ -193,7 +193,18 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
         return this.query<{list:string[]}>(query, values).then((result) => result[0]?.list ?? []);
     }
 
-    toWhere(tableName: string, filters: { [key: string]: Primitive | Array<Primitive> }={}, alias:string = "", index=1)
+    async selectSet<T>(tableName: string, select: string, filters: Partial<T>): Promise<Hash<Primitive>>
+    {
+        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 as any);
+        let query = `
+            SELECT json_object_agg(u.${select}, NULL) as list
+            FROM ( SELECT DISTINCT u.${select} FROM ${schema}.${tableName} WHERE "user" = ${where} ) t`;
+        return this.query<{list:Record<Primitive, null>}>(query, values).then((result) => new Hash(result[0]?.list ?? {}));
+    }
+
+    toWhere(tableName: string, filters: { [key: string]: Valuable | Array<Valuable> }={}, alias:string = "", index=1)
     {
         let table = this.tables[tableName];
         let columns = PostgresUtils.columns(table);

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

@@ -1,5 +1,5 @@
 import {Column} from "../RepositoryDatabasePostgres";
-import {Primitive} from "../RepositoryDatabase";
+import {Valuable} from "../RepositoryDatabase";
 
 export default abstract class PostgresUtils
 {
@@ -41,7 +41,7 @@ export default abstract class PostgresUtils
 		return reservedWords.has(word.toLowerCase());
 	}
 
-	static bindOrDefault(table: Column[], object: { [p: string]: Primitive }, startIndex: any): { bindings: string[], values: any[] } {
+	static bindOrDefault(table: Column[], object: { [p: string]: Valuable }, startIndex: any): { bindings: string[], values: any[] } {
 
 		let index = startIndex;
 		let bindings: string[] = [];