@hapiboo/flux 1.0.4 → 1.1.1

package/dist/application.d.ts

@@ -1,18 +1,18 @@
 import { IResponsePromiseVoid, IResponsePromise } from '@hapiboo/core';
 import { IDBProviderFlux, IFluxModule, IFluxObject, IFluxDBFilter, IFluxIndexData } from './interfaces';
-import { FluxObjectCreator } from './types';
+import { FluxDBObjectCreator } from './types';
 export declare namespace fluxApplication {
     function registerModule(module: IFluxModule): void;
     function initialize(dbProvider: IDBProviderFlux): void;
     function start(): void;
     namespace repository {
         function initializeModels(): IResponsePromiseVoid;
-        function countModel(source: FluxObjectCreator): IResponsePromise<number>;
-        function deleteModel(source: FluxObjectCreator, identifier: string): IResponsePromiseVoid;
-        function createModel<T extends IFluxObject>(source: FluxObjectCreator, item: T): IResponsePromise<T>;
-        function updateModel<T extends IFluxObject>(source: FluxObjectCreator, item: T): IResponsePromise<T>;
-        function readModel<T extends IFluxObject>(source: FluxObjectCreator, identifier: string): IResponsePromise<T>;
-        function readArray<T extends IFluxObject>(source: FluxObjectCreator, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
-        function queryArray<T extends IFluxObject>(source: FluxObjectCreator, index: string, data: IFluxIndexData, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+        function countModel(source: FluxDBObjectCreator): IResponsePromise<number>;
+        function deleteModel(source: FluxDBObjectCreator, identifier: string): IResponsePromiseVoid;
+        function createModel<T extends IFluxObject>(source: FluxDBObjectCreator, item: T): IResponsePromise<T>;
+        function updateModel<T extends IFluxObject>(source: FluxDBObjectCreator, item: T): IResponsePromise<T>;
+        function readModel<T extends IFluxObject>(source: FluxDBObjectCreator, identifier: string): IResponsePromise<T>;
+        function readArray<T extends IFluxObject>(source: FluxDBObjectCreator, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
+        function queryArray<T extends IFluxObject>(source: FluxDBObjectCreator, index: string, data: IFluxIndexData, filter: IFluxDBFilter | undefined, queryLimit: number | undefined): IResponsePromise<T[]>;
     }
 }

package/dist/application.js

@@ -65,12 +65,23 @@ var fluxApplication;
     (function (objects) {
         const modelCache = new Map();
         const columnCache = new Map();
+        const calculatedColumnCache = new Map();
         const idCache = new Map();
         const indexesCache = new Map();
         function getValue(source, propertyKey) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return source[propertyKey];
         }
+        function callValueFunction(source, methodKey) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const method = source[methodKey];
+            if (typeof method === 'function') {
+                return method.call(source);
+            }
+            else {
+                return undefined;
+            }
+        }
         function getModel(source) {
             const model = modelCache.get(source);
             if (!model) {
@@ -89,6 +100,7 @@ var fluxApplication;
                 return;
             const tableName = decorators_1.hapibooDecorators.getTableName(source);
             const columnsInfo = decorators_1.hapibooDecorators.getColumnsInfo(source);
+            const calculatedColumnsInfo = decorators_1.hapibooDecorators.getCalculatedColumnsInfo(source);
             const identifierKey = decorators_1.hapibooDecorators.getIdentifierProperty(source);
             const indexesInfo = decorators_1.hapibooDecorators.getIndexesInfo(source);
             const indexes = indexesInfo.map((index) => {
@@ -107,15 +119,23 @@ var fluxApplication;
                     if (sCOl.info.type !== 'S' && sCOl.info.type !== 'N') {
                         throw new Error(`Index sort column '${index.sort}' in model '${source.name}' has invalid type '${sCOl.info.type}'. Only 'String' and 'Number' are allowed.`);
                     }
+                    return {
+                        name: index.name,
+                        key: kCol.info,
+                        sort: sCOl?.info
+                    };
+                }
+                else {
+                    return {
+                        name: index.name,
+                        key: kCol.info,
+                        sort: { name: 'id', type: 'S' }
+                    };
                 }
-                return {
-                    name: index.name,
-                    key: kCol.info,
-                    sort: sCOl?.info
-                };
             });
             modelCache.set(source, { table: tableName, id: '' });
             columnCache.set(source, columnsInfo);
+            calculatedColumnCache.set(source, calculatedColumnsInfo);
             idCache.set(source, identifierKey);
             indexesCache.set(source, indexes);
         }
@@ -132,6 +152,7 @@ var fluxApplication;
         function getModelWriter(source, item) {
             const model = getModel(source);
             const columns = columnCache.get(source) || [];
+            const calculatedColumns = calculatedColumnCache.get(source) || [];
             const identifierKey = idCache.get(source) || 'id';
             const values = new core_1.Dictionary();
             columns.forEach((col) => {
@@ -140,10 +161,16 @@ var fluxApplication;
                     values.push(col.info.name, value);
                 }
             });
+            calculatedColumns.forEach((col) => {
+                const value = callValueFunction(item, col.methodKey);
+                if (value !== undefined) {
+                    values.push(col.info.name, value);
+                }
+            });
             return {
                 table: model.table,
                 id: getValue(item, identifierKey),
-                columns: columns.map(col => col.info),
+                columns: [...columns.map(col => col.info), ...calculatedColumns.map(col => col.info)],
                 values: values
             };
         }

package/dist/decorators.d.ts

@@ -1,20 +1,26 @@
 import 'reflect-metadata';
-import { FluxColumnExposed, FluxObjectCreator } from './types';
+import { FluxDBColumnExposed, FluxDBObjectCreator } from './types';
 import { IFluxColumnInfo } from './interfaces';
 export declare function FluxTable(name: string): ClassDecorator;
-export declare function FluxIdentifier(): PropertyDecorator;
-export declare function FluxExposedColumn(name: string, type?: FluxColumnExposed): PropertyDecorator;
 export declare function FluxIndex(name: string, key: string, sort: string | undefined): ClassDecorator;
+export declare function FluxIndexSimple(name: string, key: string): ClassDecorator;
+export declare function FluxIdentifier(): PropertyDecorator;
+export declare function FluxColumn(name: string, type?: FluxDBColumnExposed): PropertyDecorator;
+export declare function FluxColumnCalculated(name: string, type?: FluxDBColumnExposed): MethodDecorator;
 export declare namespace hapibooDecorators {
-    function getTableName(target: FluxObjectCreator): string;
-    function getIdentifierProperty(target: FluxObjectCreator): string;
-    function getIndexesInfo(target: FluxObjectCreator): {
+    function getTableName(target: FluxDBObjectCreator): string;
+    function getIdentifierProperty(target: FluxDBObjectCreator): string;
+    function getIndexesInfo(target: FluxDBObjectCreator): {
         name: string;
         key: string;
         sort: string | undefined;
     }[];
-    function getColumnsInfo(target: FluxObjectCreator): {
+    function getColumnsInfo(target: FluxDBObjectCreator): {
         info: IFluxColumnInfo;
         propertyKey: string | symbol;
     }[];
+    function getCalculatedColumnsInfo(target: FluxDBObjectCreator): {
+        info: IFluxColumnInfo;
+        methodKey: string | symbol;
+    }[];
 }

package/dist/decorators.js

@@ -2,37 +2,54 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hapibooDecorators = void 0;
 exports.FluxTable = FluxTable;
-exports.FluxIdentifier = FluxIdentifier;
-exports.FluxExposedColumn = FluxExposedColumn;
 exports.FluxIndex = FluxIndex;
+exports.FluxIndexSimple = FluxIndexSimple;
+exports.FluxIdentifier = FluxIdentifier;
+exports.FluxColumn = FluxColumn;
+exports.FluxColumnCalculated = FluxColumnCalculated;
 require("reflect-metadata");
 const types_1 = require("./types");
 const META_TABLE = Symbol('meta:class:table');
 const META_INDEX = Symbol('meta:class:index');
 const META_IDENTIFIER = Symbol('meta:field:id');
 const META_COLUMN = Symbol('meta:field:column');
+const META_COLUMN_FUNCTION = Symbol('meta:field:column_function');
 function FluxTable(name) {
     return target => {
         Reflect.defineMetadata(META_TABLE, { name }, target);
     };
 }
+function FluxIndex(name, key, sort) {
+    return target => {
+        const indexes = Reflect.getMetadata(META_INDEX, target) || [];
+        indexes.push({ name, key, sort });
+        Reflect.defineMetadata(META_INDEX, indexes, target);
+    };
+}
+function FluxIndexSimple(name, key) {
+    return target => {
+        const indexes = Reflect.getMetadata(META_INDEX, target) || [];
+        indexes.push({ name, key, sort: undefined });
+        Reflect.defineMetadata(META_INDEX, indexes, target);
+    };
+}
 function FluxIdentifier() {
     return (target, key) => {
         Reflect.defineMetadata(META_IDENTIFIER, { propertyKey: key }, target.constructor);
     };
 }
-function FluxExposedColumn(name, type = types_1.FluxColumnExposed.String) {
+function FluxColumn(name, type = types_1.FluxDBColumnExposed.String) {
     return (target, key) => {
         const fields = Reflect.getMetadata(META_COLUMN, target.constructor) || [];
         fields.push({ propertyKey: key, info: { name, type } });
         Reflect.defineMetadata(META_COLUMN, fields, target.constructor);
     };
 }
-function FluxIndex(name, key, sort) {
-    return target => {
-        const indexes = Reflect.getMetadata(META_INDEX, target) || [];
-        indexes.push({ name, key, sort });
-        Reflect.defineMetadata(META_INDEX, indexes, target);
+function FluxColumnCalculated(name, type = types_1.FluxDBColumnExposed.String) {
+    return (target, key, _descriptor) => {
+        const methods = Reflect.getMetadata(META_COLUMN_FUNCTION, target.constructor) || [];
+        methods.push({ methodKey: key, info: { name, type } });
+        Reflect.defineMetadata(META_COLUMN_FUNCTION, methods, target.constructor);
     };
 }
 var hapibooDecorators;
@@ -57,4 +74,9 @@ var hapibooDecorators;
         return metadata ? metadata : [];
     }
     hapibooDecorators.getColumnsInfo = getColumnsInfo;
+    function getCalculatedColumnsInfo(target) {
+        const metadata = Reflect.getMetadata(META_COLUMN_FUNCTION, target);
+        return metadata ? metadata : [];
+    }
+    hapibooDecorators.getCalculatedColumnsInfo = getCalculatedColumnsInfo;
 })(hapibooDecorators || (exports.hapibooDecorators = hapibooDecorators = {}));

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { IFluxIndexInfo, IFluxColumnInfo, IFluxIndexData, IFluxDataModel, IFluxDataModelDefinition, IFluxDataModelWriter, IFluxDataModelReader, IFluxDBFilter, IFluxDBCondition, IFluxDBSubCondition, IFluxObject, IFluxModule, IDBProviderFlux } from './interfaces';
-import { FluxColumn, FluxColumnIndex, FluxColumnExposed, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorValues, FluxDBFilterOperatorCollection } from './types';
-import { FluxTable, FluxIndex, FluxExposedColumn, FluxIdentifier } from './decorators';
+import { FluxDBColumn, FluxDBColumnIndex, FluxDBColumnExposed, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorValues, FluxDBFilterOperatorCollection } from './types';
+import { FluxTable, FluxIndex, FluxIdentifier, FluxColumn, FluxColumnCalculated } from './decorators';
 import { fluxApplication } from './application';
 import { conditionBuilder } from './conditions';
-export { FluxColumn, FluxColumnIndex, FluxColumnExposed };
+export { FluxDBColumn, FluxDBColumnIndex, FluxDBColumnExposed };
 export { IFluxIndexInfo, IFluxColumnInfo, IFluxIndexData };
 export { IFluxDataModel, IFluxDataModelDefinition, IFluxDataModelWriter, IFluxDataModelReader };
 export { IFluxDBFilter, IFluxDBCondition, IFluxDBSubCondition };
@@ -12,4 +12,4 @@ export { IFluxObject, IFluxModule };
 export { IDBProviderFlux };
 export { conditionBuilder };
 export { fluxApplication };
-export { FluxTable, FluxIndex, FluxExposedColumn, FluxIdentifier };
+export { FluxTable, FluxIndex, FluxIdentifier, FluxColumn, FluxColumnCalculated };

package/dist/index.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FluxIdentifier = exports.FluxExposedColumn = exports.FluxIndex = exports.FluxTable = exports.fluxApplication = exports.conditionBuilder = exports.FluxColumnExposed = exports.FluxColumnIndex = exports.FluxColumn = void 0;
+exports.FluxColumnCalculated = exports.FluxColumn = exports.FluxIdentifier = exports.FluxIndex = exports.FluxTable = exports.fluxApplication = exports.conditionBuilder = exports.FluxDBColumnExposed = exports.FluxDBColumnIndex = exports.FluxDBColumn = void 0;
 const types_1 = require("./types");
-Object.defineProperty(exports, "FluxColumn", { enumerable: true, get: function () { return types_1.FluxColumn; } });
-Object.defineProperty(exports, "FluxColumnIndex", { enumerable: true, get: function () { return types_1.FluxColumnIndex; } });
-Object.defineProperty(exports, "FluxColumnExposed", { enumerable: true, get: function () { return types_1.FluxColumnExposed; } });
+Object.defineProperty(exports, "FluxDBColumn", { enumerable: true, get: function () { return types_1.FluxDBColumn; } });
+Object.defineProperty(exports, "FluxDBColumnIndex", { enumerable: true, get: function () { return types_1.FluxDBColumnIndex; } });
+Object.defineProperty(exports, "FluxDBColumnExposed", { enumerable: true, get: function () { return types_1.FluxDBColumnExposed; } });
 const decorators_1 = require("./decorators");
 Object.defineProperty(exports, "FluxTable", { enumerable: true, get: function () { return decorators_1.FluxTable; } });
 Object.defineProperty(exports, "FluxIndex", { enumerable: true, get: function () { return decorators_1.FluxIndex; } });
-Object.defineProperty(exports, "FluxExposedColumn", { enumerable: true, get: function () { return decorators_1.FluxExposedColumn; } });
 Object.defineProperty(exports, "FluxIdentifier", { enumerable: true, get: function () { return decorators_1.FluxIdentifier; } });
+Object.defineProperty(exports, "FluxColumn", { enumerable: true, get: function () { return decorators_1.FluxColumn; } });
+Object.defineProperty(exports, "FluxColumnCalculated", { enumerable: true, get: function () { return decorators_1.FluxColumnCalculated; } });
 const application_1 = require("./application");
 Object.defineProperty(exports, "fluxApplication", { enumerable: true, get: function () { return application_1.fluxApplication; } });
 const conditions_1 = require("./conditions");

package/dist/interfaces.d.ts

@@ -1,8 +1,8 @@
 import { Dictionary, IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
-import { FluxColumnExposed, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorCollection, FluxDBFilterOperatorValues, FluxObjectCreator } from './types';
+import { FluxDBColumnExposed, FluxDBFilterLogic, FluxDBFilterOperator, FluxDBFilterOperatorCollection, FluxDBFilterOperatorValues, FluxDBObjectCreator } from './types';
 export interface IFluxColumnInfo {
     name: string;
-    type: FluxColumnExposed;
+    type: FluxDBColumnExposed;
 }
 export interface IFluxIndexInfo {
     name: string;
@@ -54,7 +54,7 @@ export interface IFluxObject {
 }
 export interface IFluxModule {
     name: string;
-    models: FluxObjectCreator[];
+    models: FluxDBObjectCreator[];
     initialize?: () => void;
     start?: () => IResponsePromiseVoid;
 }

package/dist/types.d.ts

@@ -1,14 +1,14 @@
 import { IFluxObject } from './interfaces';
-export declare const FluxColumnIndex: {
+export declare const FluxDBColumnIndex: {
     readonly String: "S";
     readonly Number: "N";
 };
-export declare const FluxColumnExposed: {
+export declare const FluxDBColumnExposed: {
     readonly String: "S";
     readonly Number: "N";
     readonly Boolean: "BOOL";
 };
-export declare const FluxColumn: {
+export declare const FluxDBColumn: {
     readonly String: "S";
     readonly Number: "N";
     readonly Boolean: "BOOL";
@@ -16,11 +16,11 @@ export declare const FluxColumn: {
     readonly List: "L";
     readonly Object: "M";
 };
-export type FluxColumnIndex = typeof FluxColumnIndex[keyof typeof FluxColumnIndex];
-export type FluxColumnExposed = typeof FluxColumnExposed[keyof typeof FluxColumnExposed];
-export type FluxColumn = typeof FluxColumn[keyof typeof FluxColumn];
+export type FluxDBColumnIndex = typeof FluxDBColumnIndex[keyof typeof FluxDBColumnIndex];
+export type FluxDBColumnExposed = typeof FluxDBColumnExposed[keyof typeof FluxDBColumnExposed];
+export type FluxDBColumn = typeof FluxDBColumn[keyof typeof FluxDBColumn];
 export type FluxDBFilterOperator = '=' | '<>' | 'EXISTS' | 'NOT EXISTS';
 export type FluxDBFilterOperatorValues = '<' | '<=' | '>' | '>=';
 export type FluxDBFilterOperatorCollection = 'IN';
 export type FluxDBFilterLogic = 'AND' | 'OR';
-export type FluxObjectCreator<T extends IFluxObject = IFluxObject> = new () => T;
+export type FluxDBObjectCreator<T extends IFluxObject = IFluxObject> = new () => T;

package/dist/types.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FluxColumn = exports.FluxColumnExposed = exports.FluxColumnIndex = void 0;
-exports.FluxColumnIndex = {
+exports.FluxDBColumn = exports.FluxDBColumnExposed = exports.FluxDBColumnIndex = void 0;
+exports.FluxDBColumnIndex = {
     String: 'S',
     Number: 'N',
 };
-exports.FluxColumnExposed = {
+exports.FluxDBColumnExposed = {
     String: 'S',
     Number: 'N',
     Boolean: 'BOOL',
 };
-exports.FluxColumn = {
+exports.FluxDBColumn = {
     String: 'S',
     Number: 'N',
     Boolean: 'BOOL',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hapiboo/flux",
-  "version": "1.0.4",
+  "version": "1.1.1",
   "description": "MK13 Studio Hapiboo Flux - Modular Application Services",
   "author": "MK13 Studio",
   "license": "ISC",