@quatrain/core 1.0.0-beta4 → 1.0.0-beta8

package/lib/Backend.d.ts

@@ -33,5 +33,6 @@ export interface BackendParameters {
     config?: any;
     fixtures?: any;
     softDelete?: boolean;
+    useNativeForeignKeys?: boolean;
     debug?: boolean;
 }

package/lib/backends/AbstractAdapter.d.ts

@@ -6,7 +6,9 @@ import { Filters } from './Filters';
 import { Query, QueryResultType } from './Query';
 import { SortAndLimit } from './SortAndLimit';
 import Middleware from './middlewares/Middleware';
+import { MiddlewareParams } from './middlewares/types/MiddlewareParams';
 export declare abstract class AbstractAdapter implements BackendInterface {
+    static PKEY_IDENTIFIER: any;
     protected _alias: string;
     protected _params: BackendParameters;
     protected _middlewares: Middleware[];
@@ -36,5 +38,5 @@ export declare abstract class AbstractAdapter implements BackendInterface {
     query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
     abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<any>>;
     log(message: string): void;
-    executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction): Promise<DataObjectClass<any>>;
+    executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction, params?: MiddlewareParams): Promise<DataObjectClass<any>>;
 }

package/lib/backends/AbstractAdapter.js

@@ -18,6 +18,7 @@ class AbstractAdapter {
         this._middlewares = [];
         this._alias = params.alias || '';
         this._middlewares = params.middlewares || [];
+        this._params = params;
     }
     setParam(key, value) {
         this._params[key] = value;
@@ -72,13 +73,14 @@ class AbstractAdapter {
             console.log(message);
         }
     }
-    executeMiddlewares(dataObject, action) {
+    executeMiddlewares(dataObject, action, params) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const middleware of this._middlewares) {
-                yield middleware.execute(dataObject, action);
+                yield middleware.execute(dataObject, action, params);
             }
             return dataObject;
         });
     }
 }
 exports.AbstractAdapter = AbstractAdapter;
+AbstractAdapter.PKEY_IDENTIFIER = 'id';

package/lib/backends/Query.d.ts

@@ -33,14 +33,14 @@ export declare class Query<T extends typeof BaseObjectCore> {
     sortings: Sorting[];
     limits: Limits;
     meta: any;
-    constructor(obj: T, parent?: T | undefined);
+    constructor(obj: T, parent?: T);
     get obj(): T;
     get parent(): T | undefined;
     /**
      * Declare query parent record
      * This may be need in some NoSQL backend to query subcollections
      */
-    set parent(parent: T);
+    set parent(parent: T | undefined);
     where(param: Filter | string, value?: any, operator?: any): this;
     sortBy(param: Sorting | string, order?: any): this;
     setLimits(limits: Limits): this;

package/lib/backends/Query.js

@@ -26,7 +26,7 @@ var returnAs;
     returnAs["AS_IS"] = "asIs";
 })(returnAs || (exports.returnAs = returnAs = {}));
 class Query {
-    constructor(obj, parent = undefined) {
+    constructor(obj, parent) {
         this._obj = obj;
         this._parent = parent;
         this.filters = [];
@@ -105,7 +105,7 @@ class Query {
             return { items: instances, meta };
         });
     }
-    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend()) {
+    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend(this._obj.DEFAULT_BACKEND)) {
         return __awaiter(this, void 0, void 0, function* () {
             //<DataObjectClass<any>[] | ObjectUri[] | Persisted<BaseObject>[]> {
             //</any><Array<T2> | Array<DataObject> | Array<ObjectUri>> {

package/lib/backends/index.d.ts

@@ -2,11 +2,11 @@ import { AbstractAdapter } from './AbstractAdapter';
 import { MockAdapter } from './MockAdapter';
 import { BackendError } from './BackendError';
 import { BackendInterface } from './types/BackendInterface';
-import * as BackendCollectionHierarchy from './types/BackendCollectionHierarchy';
+import * as CollectionHierarchy from './types/CollectionHierarchy';
 import { Query, QueryResultType, QueryMetaType } from './Query';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Sorting } from './Sorting';
 import { Limits } from './Limits';
 import { SortAndLimit } from './SortAndLimit';
-export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, BackendCollectionHierarchy, };
+export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, CollectionHierarchy, };

package/lib/backends/index.js

@@ -23,15 +23,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackendCollectionHierarchy = exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
+exports.CollectionHierarchy = exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
 const AbstractAdapter_1 = require("./AbstractAdapter");
 Object.defineProperty(exports, "AbstractAdapter", { enumerable: true, get: function () { return AbstractAdapter_1.AbstractAdapter; } });
 const MockAdapter_1 = require("./MockAdapter");
 Object.defineProperty(exports, "MockAdapter", { enumerable: true, get: function () { return MockAdapter_1.MockAdapter; } });
 const BackendError_1 = require("./BackendError");
 Object.defineProperty(exports, "BackendError", { enumerable: true, get: function () { return BackendError_1.BackendError; } });
-const BackendCollectionHierarchy = __importStar(require("./types/BackendCollectionHierarchy"));
-exports.BackendCollectionHierarchy = BackendCollectionHierarchy;
+const CollectionHierarchy = __importStar(require("./types/CollectionHierarchy"));
+exports.CollectionHierarchy = CollectionHierarchy;
 const Query_1 = require("./Query");
 Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return Query_1.Query; } });
 const Filter_1 = require("./Filter");

package/lib/backends/middlewares/InjectMetaMiddleware.d.ts

@@ -2,11 +2,12 @@ import { DataObjectClass } from '../../components';
 import { BackendAction } from '../../Backend';
 import { User } from '../../components/User';
 import Middleware from './Middleware';
+import { MiddlewareParams } from './types/MiddlewareParams';
 export interface InjectMetaMiddlewareParams {
     user: User;
 }
 export declare class InjectMetaMiddleware implements Middleware {
     protected _user: User;
     constructor(params: InjectMetaMiddlewareParams);
-    execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
+    execute(dataObject: DataObjectClass<any>, action: BackendAction, params?: MiddlewareParams): void;
 }

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -2,24 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InjectMetaMiddleware = void 0;
 const Backend_1 = require("../../Backend");
+const Core_1 = require("../../Core");
 class InjectMetaMiddleware {
     constructor(params) {
         this._user = params.user;
     }
-    execute(dataObject, action) {
+    execute(dataObject, action, params) {
+        Core_1.Core.log(`[MDW] Executing Middleware ${this.constructor.name}`);
+        const date = params && params.useDateFormat ? (new Date()).toISOString() : Date.now();
         switch (action) {
             // add properties existence validation
             case Backend_1.BackendAction.CREATE:
                 dataObject.set('createdBy', this._user);
-                dataObject.set('createdAt', Date.now());
+                dataObject.set('createdAt', date);
                 break;
             case Backend_1.BackendAction.UPDATE:
                 dataObject.set('updatedBy', this._user);
-                dataObject.set('updatedAt', Date.now());
+                dataObject.set('updatedAt', date);
                 break;
             case Backend_1.BackendAction.DELETE:
                 dataObject.set('deletedBy', this._user);
-                dataObject.set('deletedAt', Date.now());
+                dataObject.set('deletedAt', date);
                 break;
             default:
                 break;

package/lib/backends/middlewares/Middleware.d.ts

@@ -1,5 +1,5 @@
 import { BackendAction } from '../../Backend';
 import { DataObjectClass } from '../../components';
 export default interface Middleware {
-    execute: (dataObject: DataObjectClass<any>, action: BackendAction) => void;
+    execute: (dataObject: DataObjectClass<any>, action: BackendAction, params?: any) => void;
 }

package/lib/backends/middlewares/types/MiddlewareParams.d.ts

@@ -0,0 +1,3 @@
+export type MiddlewareParams = {
+    useDateFormat?: boolean;
+};

package/lib/backends/middlewares/types/MiddlewareParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/components/AbstractObject.d.ts

@@ -4,6 +4,7 @@ export declare abstract class AbstractObject {
     static PROPS_DEFINITION: DataObjectProperties;
     static COLLECTION: string | undefined;
     static PARENT_PROP: string | undefined;
+    static DEFAULT_BACKEND: string;
     static LABEL_KEY: string;
     protected _dataObject: DataObjectClass<any>;
     constructor(dao: DataObjectClass<any>);

package/lib/components/AbstractObject.js

@@ -70,5 +70,6 @@ class AbstractObject {
 }
 exports.AbstractObject = AbstractObject;
 AbstractObject.PROPS_DEFINITION = [];
+AbstractObject.DEFAULT_BACKEND = 'default';
 // Which property's value to use in backend as label for object reference
 AbstractObject.LABEL_KEY = 'name';

package/lib/components/BaseObject.js

@@ -37,6 +37,7 @@ exports.BaseObjectProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.NAME,
     },
     {

package/lib/components/BaseObjectCore.js

@@ -33,7 +33,10 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
                 base.push(property);
             }
         });
-        const dao = DataObject_1.DataObject.factory({ properties: base });
+        const dao = DataObject_1.DataObject.factory({
+            properties: base,
+            parentProp: this.PARENT_PROP,
+        });
         dao.uri.class = child;
         return dao;
     }

package/lib/components/DataObject.d.ts

@@ -3,6 +3,7 @@ import { PropertyClassType } from '../properties/types/PropertyClassType';
 import { AbstractObject } from './AbstractObject';
 import { ObjectUri } from './ObjectUri';
 import { DataObjectClass } from './types/DataObjectClass';
+import { toJSONParams } from './types/toJSONParams';
 export type CoreObject<T extends AbstractObject> = T;
 export type Properties = {
     [x: string]: PropertyClassType;
@@ -14,6 +15,7 @@ export interface DataObjectFactoryType {
 export interface DataObjectParams {
     uri?: string | ObjectUri;
     properties: DataObjectProperties;
+    parentProp?: string;
 }
 /**
  * Data objects constitute the agnostic glue between objects and backends.
@@ -26,6 +28,7 @@ export declare class DataObject implements DataObjectClass<any> {
     protected _properties: Properties;
     protected _persisted: boolean;
     protected _populated: boolean;
+    protected _parentProp: string | undefined;
     protected _proxied: any;
     /**
      * Has data been modified since last backend operation?
@@ -43,6 +46,12 @@ export declare class DataObject implements DataObjectClass<any> {
      */
     asProxy(): this;
     setProperties(properties: Properties): void;
+    /**
+     * Return a map of all propoerties or only those matching the provided type
+     * @param type
+     * @returns
+     */
+    getProperties(type?: string): {};
     addProperty(property: PropertyClassType): void;
     /**
      * Populate data object from instant data or backend query
@@ -75,6 +84,7 @@ export declare class DataObject implements DataObjectClass<any> {
     set uri(uri: ObjectUri);
     get uri(): ObjectUri;
     get class(): any;
+    get parentProp(): string | undefined;
     has(key: string): boolean;
     /**
      * Returns property matching key or throw
@@ -89,7 +99,7 @@ export declare class DataObject implements DataObjectClass<any> {
      * @returns any
      */
     val(key: string, transform?: string | undefined): any;
-    toJSON(objectsAsReferences?: boolean): {
+    toJSON(params?: boolean | toJSONParams): {
         [x: string]: any;
     };
     toReference(): {
@@ -97,7 +107,7 @@ export declare class DataObject implements DataObjectClass<any> {
         ref: string;
         uri: string;
     };
-    protected _dataToJSON(objectsAsReferences?: boolean): {};
+    protected _dataToJSON(objectsAsReferences?: boolean, ignoreUnchanged?: boolean, converters?: {}): {};
     read(): Promise<DataObjectClass<any>>;
     save(): Promise<DataObjectClass<any>>;
     delete(): Promise<DataObjectClass<any>>;

package/lib/components/DataObject.js

@@ -40,6 +40,7 @@ class DataObject {
             else {
                 this._objectUri = params.uri;
             }
+            this._parentProp = params.parentProp;
         }
         else {
             this._objectUri = new ObjectUri_1.ObjectUri();
@@ -75,9 +76,26 @@ class DataObject {
         // TODO check if doable
         this._properties = properties;
     }
+    /**
+     * Return a map of all propoerties or only those matching the provided type
+     * @param type
+     * @returns
+     */
+    getProperties(type) {
+        if (type) {
+            const matches = {};
+            for (let k of Object.keys(this._properties)) {
+                if (this._properties[k].constructor.name === type) {
+                    Reflect.set(matches, k, this._properties[k]);
+                }
+            }
+            return matches;
+        }
+        return this._properties;
+    }
     addProperty(property) {
         if (Object.keys(this._properties).includes(property.name)) {
-            throw new Error(`Property ${name} already exists`);
+            throw new Error(`Property ${property.name} already exists`);
         }
         this._properties[property.name] = property;
     }
@@ -118,10 +136,10 @@ class DataObject {
                         'label' in val &&
                         typeof val.label == 'string') {
                         const { ref, label } = val;
-                        Reflect.get(this._properties, key).set(new ObjectUri_1.ObjectUri(ref, label));
+                        Reflect.get(this._properties, key).set(new ObjectUri_1.ObjectUri(ref, label), false);
                     }
                     else {
-                        Reflect.get(this._properties, key).set(data[key]);
+                        Reflect.get(this._properties, key).set(data[key], false);
                     }
                 }
             }
@@ -190,6 +208,9 @@ class DataObject {
         // TODO get class type
         return this.uri.class;
     }
+    get parentProp() {
+        return this._parentProp;
+    }
     has(key) {
         return Reflect.has(this._properties, key);
     }
@@ -200,7 +221,7 @@ class DataObject {
      */
     get(key) {
         if (!Reflect.has(this._properties, key)) {
-            throw new ResourcesErrors_1.NotFoundError(`No property matching key ${key}`);
+            throw new ResourcesErrors_1.NotFoundError(`No property matching key '${key}'`);
         }
         return Reflect.get(this._properties, key);
     }
@@ -226,23 +247,34 @@ class DataObject {
             throw new Error(`Unknown property '${key}'`);
         }
     }
-    toJSON(objectsAsReferences = false) {
-        return Object.assign(Object.assign({}, (this.uri && { uid: this.uri.uid, path: this.uri.path })), this._dataToJSON(objectsAsReferences));
+    toJSON(params = false) {
+        let objectsAsReferences = false, withoutURIData = false, ignoreUnchanged = false, converters = {};
+        if (typeof params === 'object') {
+            // Any missing parameter should resolve to false
+            objectsAsReferences = Boolean(params.objectsAsReferences);
+            withoutURIData = Boolean(params.withoutURIData);
+            ignoreUnchanged = Boolean(params.ignoreUnchanged);
+            converters = params.converters;
+        }
+        return Object.assign(Object.assign({}, (!withoutURIData &&
+            this.uri && { uid: this.uri.uid, path: this.uri.path })), this._dataToJSON(objectsAsReferences, ignoreUnchanged, converters));
     }
     toReference() {
         return Object.assign(Object.assign({}, this._objectUri.toReference()), { label: this.val('name') || '' });
     }
-    _dataToJSON(objectsAsReferences = false) {
+    _dataToJSON(objectsAsReferences = false, ignoreUnchanged = false, converters = {}) {
         const data = {};
         Object.keys(this._properties).forEach((key) => {
             const prop = Reflect.get(this._properties, key);
+            if (ignoreUnchanged && prop.hasChanged === false)
+                return;
+            console.log(prop.constructor.name);
             switch (prop.constructor.name) {
                 case 'CollectionProperty':
                     // ignore
                     break;
                 case 'ObjectProperty':
                     const value = prop.val();
-                    console.log(value, typeof value);
                     Reflect.set(data, key, value
                         ? objectsAsReferences && !(value instanceof ObjectUri_1.ObjectUri)
                             ? value.asReference()
@@ -257,8 +289,12 @@ class DataObject {
                 case 'ArrayProperty':
                     Reflect.set(data, key, prop.val() || []);
                     break;
+                case 'DateTimeProperty':
+                    Reflect.set(data, key, prop.val(Reflect.get(converters, 'datetime')) || null);
+                    break;
                 default:
                     Reflect.set(data, key, prop.val() || null);
+                    break;
             }
         });
         return data;

package/lib/components/Entity.d.ts

@@ -1,12 +1,9 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-import { User } from './User';
-import { EntityClass } from './types/EntityClass';
-export declare const EntityProperties: any;
 export interface EntityType extends BaseObject {
-    users?: User[];
 }
-export declare class Entity extends BaseObjectCore implements EntityClass {
+export declare class Entity extends BaseObjectCore {
     static COLLECTION: string;
     static PROPS_DEFINITION: any[];
+    static factory(src?: any): Promise<Entity>;
 }

package/lib/components/Entity.js

@@ -22,32 +22,32 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = exports.EntityProperties = void 0;
+exports.Entity = void 0;
 const BaseObjectCore_1 = require("./BaseObjectCore");
 const BaseObject_1 = require("./BaseObject");
-const User_1 = require("./User");
-const CollectionProperty_1 = require("../properties/CollectionProperty");
+//import { User } from './User'
+//import { CollectionProperty } from '../properties/CollectionProperty'
 const StringProperty_1 = require("../properties/StringProperty");
 const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
-exports.EntityProperties = [
-    {
-        // surcharge property minLength and htmlType
-        name: 'name',
-        type: StringProperty_1.StringProperty.TYPE,
-        mandatory: true,
-        minLength: 1,
-        htmlType: htmlType.ORG,
-    },
-    {
-        name: 'users',
-        mandatory: true,
-        type: CollectionProperty_1.CollectionProperty.TYPE,
-        instanceOf: 'User',
-        parentKey: 'entity',
-    },
-];
 class Entity extends BaseObjectCore_1.BaseObjectCore {
+    static factory(src = undefined) {
+        const _super = Object.create(null, {
+            factory: { get: () => super.factory }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.factory.call(this, src, Entity);
+        });
+    }
 }
 exports.Entity = Entity;
 Entity.COLLECTION = 'entities';
@@ -61,11 +61,11 @@ Entity.PROPS_DEFINITION = [
         minLength: 1,
         htmlType: htmlType.ORG,
     },
-    {
-        name: 'users',
-        mandatory: true,
-        type: CollectionProperty_1.CollectionProperty.TYPE,
-        instanceOf: User_1.User,
-        parentKey: 'entity',
-    },
+    // {
+    //    name: 'users',
+    //    mandatory: true,
+    //    type: CollectionProperty.TYPE,
+    //    instanceOf: User,
+    //    parentKey: 'entity',
+    // },
 ];

package/lib/components/types/DataObjectClass.d.ts

@@ -1,5 +1,6 @@
 import { PropertyClassType } from '../../properties/types/PropertyClassType';
 import { ObjectUri } from '../ObjectUri';
+import { toJSONParams } from './toJSONParams';
 export interface DataObjectClass<T extends DataObjectClass<any>> {
     uri: ObjectUri;
     uid: any;
@@ -7,7 +8,9 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     path: any;
     class: any;
     properties: any;
+    parentProp: string | undefined;
     setProperties(properties: any): void;
+    getProperties(type: any): any;
     addProperty(property: PropertyClassType): void;
     populate(data?: any): Promise<T>;
     isPopulated(): boolean;
@@ -21,7 +24,7 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     delete(): Promise<T>;
     clone(data?: any): Promise<T>;
     toReference(): any;
-    toJSON(objectsAsReferences?: boolean): any;
+    toJSON(params?: boolean | toJSONParams): any;
     populateFromData(data: {
         [x: string]: unknown;
     }): this;

package/lib/components/types/toJSONParams.d.ts

@@ -0,0 +1,8 @@
+export type toJSONParams = {
+    objectsAsReferences?: boolean;
+    withoutURIData?: boolean;
+    ignoreUnchanged?: boolean;
+    converters?: {
+        [propType: string]: Function;
+    };
+};

package/lib/components/types/toJSONParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -24,10 +24,10 @@ import { BackendAction, BackendParameters, BackendParametersKeys, BackendRecordT
 import Middleware from './backends/middlewares/Middleware';
 import { UserType, User } from './components/User';
 import UserRepository from './components/UserRepository';
-import { Entity } from './components/Entity';
+import { EntityType, Entity } from './components/Entity';
 import EntityRepository from './components/EntityRepository';
 import { AuthAction, AuthParameters, AuthParametersKeys } from './Auth';
 import { AuthInterface, AbstractAuthAdapter, AuthenticationError } from './authentication';
 import { AbstractAdapter, MockAdapter, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
 import { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError } from './common/ResourcesErrors';
-export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, AuthAction, AuthParameters, AuthParametersKeys, AuthInterface, AbstractAuthAdapter, AuthenticationError, BackendParameters, BackendParametersKeys, BackendRecordType, BackendAction, BaseRepository, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, InjectKeywordsMiddleware, User, UserType, Proxy, UserRepository, Entity, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };
+export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, AuthAction, AuthParameters, AuthParametersKeys, AuthInterface, AbstractAuthAdapter, AuthenticationError, BackendParameters, BackendParametersKeys, BackendRecordType, BackendAction, BaseRepository, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, InjectKeywordsMiddleware, User, UserType, Proxy, UserRepository, Entity, EntityType, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };

package/lib/properties/ArrayProperty.d.ts

@@ -15,7 +15,7 @@ export declare class ArrayProperty extends BaseProperty {
     get minLength(): number;
     set maxLength(max: number);
     get maxLength(): number;
-    set(value: Array<any>): this;
+    set(value: Array<any>, setChanged?: boolean): this;
     get(transform?: Function | undefined): any;
     toJSON(): any[] | undefined;
 }

package/lib/properties/ArrayProperty.js

@@ -30,7 +30,7 @@ class ArrayProperty extends BaseProperty_1.BaseProperty {
     get maxLength() {
         return this._maxLength;
     }
-    set(value) {
+    set(value, setChanged = true) {
         if (!Array.isArray(value)) {
             throw new Error(`value ${JSON.stringify(value)} is not an array`);
         }
@@ -49,7 +49,7 @@ class ArrayProperty extends BaseProperty_1.BaseProperty {
             /\d/.test(joined)) {
             throw new Error(`Numbers are not allowed in value`);
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     get(transform = undefined) {
         return transform ? transform(this._value) : this._value;

package/lib/properties/BaseProperty.d.ts

@@ -16,6 +16,7 @@ export declare class BaseProperty implements PropertyClassType {
     static EVENT_ONCHANGE: string;
     static EVENT_ONDELETE: string;
     protected _parent: DataObjectClass<any> | undefined;
+    protected _id: string;
     protected _name: string;
     protected _value: any;
     protected _mandatory: boolean;
@@ -23,6 +24,7 @@ export declare class BaseProperty implements PropertyClassType {
     protected _allows: String[];
     protected _htmlType: PropertyHTMLType;
     protected _defaultValue: any;
+    protected _hasChanged: boolean;
     protected _events: {
         [key: EventTypes]: Function;
     };
@@ -33,7 +35,8 @@ export declare class BaseProperty implements PropertyClassType {
     get allows(): String[];
     set htmlType(type: PropertyHTMLType);
     get htmlType(): PropertyHTMLType;
-    set(value: any): this;
+    get hasChanged(): boolean;
+    set(value: any, setChanged?: boolean): this;
     val(transform?: any): any;
     protected _enable(value: boolean | undefined): boolean;
     toJSON(): any;

package/lib/properties/BaseProperty.js

@@ -10,11 +10,13 @@ class BaseProperty {
         this._htmlType = 'off';
         this._events = {};
         this._parent = config.parent;
+        this._id = config.id || config.name.toLowerCase();
         this._name = config.name;
         this._protected = config.protected || false;
         this._mandatory = config.mandatory || false;
         this._defaultValue = config.defaultValue;
         this._value = config.defaultValue;
+        this._hasChanged = false;
         this._htmlType = config.htmlType || 'off';
         if (typeof config.onChange === 'function') {
             this._events.onChange = config.onChange;
@@ -38,21 +40,31 @@ class BaseProperty {
     get htmlType() {
         return this._htmlType;
     }
-    set(value) {
+    get hasChanged() {
+        return this._hasChanged;
+    }
+    set(value, setChanged = true) {
         if (this._value !== undefined &&
             this._value !== null &&
             this._value !== this._defaultValue &&
             this._protected === true) {
             throw new Error(`Value '${this._name}' already defined as '${this._value}' and protected from change`);
         }
-        this._value = value;
+        if (value !== this._value) {
+            console.log(this.name, value, this._value);
+            this._value = value;
+            this._hasChanged = setChanged;
+        }
         if (this._events[BaseProperty.EVENT_ONCHANGE]) {
             this._events[BaseProperty.EVENT_ONCHANGE](this._parent);
         }
         return this;
     }
     val(transform = undefined) {
-        return transform ? transform(this._value) : this._value || this._defaultValue;
+        console.log(transform && transform(this._value), typeof transform);
+        return typeof transform === 'function'
+            ? transform(this._value)
+            : this._value || this._defaultValue;
     }
     _enable(value) {
         return value === undefined || value === true;

package/lib/properties/BooleanProperty.d.ts

@@ -3,5 +3,5 @@ export interface BooleanPropertyType extends BasePropertyType {
 }
 export declare class BooleanProperty extends BaseProperty {
     static TYPE: string;
-    set(value: boolean): this;
+    set(value: boolean, setChanged?: boolean): this;
 }

package/lib/properties/BooleanProperty.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BooleanProperty = void 0;
 const BaseProperty_1 = require("./BaseProperty");
 class BooleanProperty extends BaseProperty_1.BaseProperty {
-    set(value) {
-        return super.set(value);
+    set(value, setChanged = true) {
+        return super.set(value, setChanged);
     }
 }
 exports.BooleanProperty = BooleanProperty;

package/lib/properties/CollectionProperty.d.ts

@@ -20,7 +20,7 @@ export declare class CollectionProperty extends BaseProperty {
     protected _filters: Filter[] | Filter | undefined;
     constructor(config: CollectionPropertyType);
     protected _setQuery(filters?: Filter[]): Query<typeof BaseObjectCore>;
-    set(value: Array<any>): this;
+    set(value: Array<any>, setChanged?: boolean): this;
     /**
      * get objects matching collection class and filters
      * in the requested format

package/lib/properties/CollectionProperty.js

@@ -19,8 +19,9 @@ class CollectionProperty extends BaseProperty_1.BaseProperty {
         super(config);
         this._value = undefined;
         this._filters = undefined;
+        console.log(config);
         if (!config.instanceOf) {
-            throw new Error('Parameter instanceOf is mandatory');
+            throw new Error(`Parameter 'instanceOf' is mandatory`);
         }
         this._instanceOf =
             typeof config.instanceOf === 'string'
@@ -41,8 +42,8 @@ class CollectionProperty extends BaseProperty_1.BaseProperty {
         }
         return query;
     }
-    set(value) {
-        return super.set(value);
+    set(value, setChanged = true) {
+        return super.set(value, setChanged);
     }
     /**
      * get objects matching collection class and filters

package/lib/properties/DateTimeProperty.d.ts

@@ -6,6 +6,6 @@ export declare class DateTimeProperty extends BaseProperty {
     static TYPE: string;
     protected _timezone: string;
     constructor(config: DateTimePropertyType);
-    set(value: string | Date): this;
+    set(value: string | Date, setChanged?: boolean): this;
     get timezone(): string;
 }

package/lib/properties/DateTimeProperty.js

@@ -7,8 +7,8 @@ class DateTimeProperty extends BaseProperty_1.BaseProperty {
         super(config);
         this._timezone = config.timezone || 'Z';
     }
-    set(value) {
-        return super.set(value);
+    set(value, setChanged = true) {
+        return super.set(value, setChanged);
     }
     get timezone() {
         return this._timezone;

package/lib/properties/EnumProperty.d.ts

@@ -6,6 +6,6 @@ export declare class EnumProperty extends BaseProperty {
     static TYPE: string;
     protected _values: string[];
     constructor(config: EnumPropertyType);
-    set(value: string): this;
+    set(value: string, setChanged?: boolean): this;
     get values(): string[];
 }

package/lib/properties/EnumProperty.js

@@ -8,11 +8,11 @@ class EnumProperty extends BaseProperty_1.BaseProperty {
         this._values = [];
         this._values = config.values || [];
     }
-    set(value) {
+    set(value, setChanged = true) {
         if (value !== null && !this._values.includes(value)) {
             throw new Error(`Value '${value}' is not acceptable`);
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     get values() {
         return this._values;

package/lib/properties/HashProperty.d.ts

@@ -22,6 +22,6 @@ export declare class HashProperty extends StringProperty {
      * @returns
      */
     get(transform?: string | undefined): string | undefined;
-    set(value: string): this;
+    set(value: string, setChanged?: boolean): this;
     compare(value: string): boolean;
 }

package/lib/properties/HashProperty.js

@@ -42,8 +42,8 @@ class HashProperty extends StringProperty_1.StringProperty {
     get(transform) {
         return;
     }
-    set(value) {
-        return super.set(this._hash(value));
+    set(value, setChanged = true) {
+        return super.set(this._hash(value), setChanged);
     }
     compare(value) {
         return this._hash(value) === this._value;

package/lib/properties/MapProperty.d.ts

@@ -3,6 +3,6 @@ export interface MapPropertyType extends BasePropertyType {
 }
 export declare class MapProperty extends BaseProperty {
     static TYPE: string;
-    set(value: any): this;
+    set(value: any, setChanged?: boolean): this;
     toJSON(): {};
 }

package/lib/properties/MapProperty.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapProperty = void 0;
 const BaseProperty_1 = require("./BaseProperty");
 class MapProperty extends BaseProperty_1.BaseProperty {
-    set(value) {
+    set(value, setChanged = true) {
         if (typeof value !== 'object') {
             throw new Error(`value ${JSON.stringify(value)} is not an object`);
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     toJSON() {
         return this._value ? JSON.stringify(this._value) : {};

package/lib/properties/NumberProperty.d.ts

@@ -27,7 +27,7 @@ export declare class NumberProperty extends BaseProperty {
     protected _precision: number;
     protected _value: number | undefined;
     constructor(config: NumberPropertyType);
-    set(value: number): this;
+    set(value: number, setChanged?: boolean): this;
     val(transform?: string | undefined): string | number | undefined;
     set minVal(min: number | undefined);
     get minVal(): number | undefined;

package/lib/properties/NumberProperty.js

@@ -27,7 +27,7 @@ class NumberProperty extends BaseProperty_1.BaseProperty {
             this._sign = config.sign;
         }
     }
-    set(value) {
+    set(value, setChanged = true) {
         if (this._sign === NumberProperty.TYPE_UNSIGNED && value < 0) {
             throw new Error(`Value must be unsigned`);
         }
@@ -40,7 +40,7 @@ class NumberProperty extends BaseProperty_1.BaseProperty {
         if (this._type === NumberProperty.TYPE_INTEGER) {
             value = Math.floor(value);
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     val(transform = undefined) {
         switch (transform) {

package/lib/properties/ObjectProperty.d.ts

@@ -10,6 +10,6 @@ export declare class ObjectProperty extends BaseProperty {
     _instanceOf: any;
     constructor(config: ObjectPropertyType);
     val(transform?: string | undefined): any;
-    set(value: object): this;
+    set(value: object, setChanged?: boolean): this;
     toJSON(): any;
 }

package/lib/properties/ObjectProperty.js

@@ -63,13 +63,13 @@ class ObjectProperty extends BaseProperty_1.BaseProperty {
                 return this._value;
         }
     }
-    set(value) {
+    set(value, setChanged = true) {
         if (value instanceof ObjectUri_1.ObjectUri &&
             value instanceof DataObject_1.DataObject &&
             value.constructor.name !== this._instanceOf.constructor.name) {
             throw new Error(`value ${JSON.stringify(value)} is not an instance of ${this._instanceOf.constructor.name}`);
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     toJSON() {
         if (this._value instanceof ObjectUri_1.ObjectUri) {

package/lib/properties/StringProperty.d.ts

@@ -26,7 +26,7 @@ export declare class StringProperty extends BaseProperty {
      */
     protected _rawValue: boolean;
     constructor(config: StringPropertyType);
-    set(value: any): this;
+    set(value: any, setChanged?: boolean): this;
     get(transform?: string | undefined): string | undefined;
     set minLength(min: number);
     get minLength(): number;

package/lib/properties/StringProperty.js

@@ -27,7 +27,7 @@ class StringProperty extends BaseProperty_1.BaseProperty {
             this._allows.push(StringProperty.ALLOW_LETTERS);
         }
     }
-    set(value) {
+    set(value, setChanged = true) {
         if (value !== null && value !== undefined) {
             if (this._allows.includes(StringProperty.ALLOW_DIGITS) === false &&
                 /\d/.test(value)) {
@@ -52,7 +52,7 @@ class StringProperty extends BaseProperty_1.BaseProperty {
                 throw new Error(`${this._name}: value '${value}' is too long`);
             }
         }
-        return super.set(value);
+        return super.set(value, setChanged);
     }
     get(transform = undefined) {
         switch (transform) {

package/lib/properties/types/AbstractPropertyType.d.ts

@@ -1,5 +1,6 @@
 import { PropertyTypes } from './PropertyTypes';
 export interface AbstractPropertyType {
     name: string;
+    id?: string;
     type?: PropertyTypes;
 }

package/lib/properties/types/PropertyClassType.d.ts

@@ -1,8 +1,10 @@
 import { AbstractPropertyType } from './AbstractPropertyType';
 export interface PropertyClassType {
+    id?: string;
     name: string;
-    set(value: any): AbstractPropertyType;
+    set(value: any, setCahnged?: boolean): AbstractPropertyType;
     val(transform?: any): any;
     toJSON(): any;
     clone(): PropertyClassType;
+    hasChanged?: boolean;
 }

package/lib/utils/DataGenerator.d.ts

@@ -1,5 +1,4 @@
-import { BaseObject } from '../components/BaseObject';
-import { Proxy } from '../components/types/ProxyConstructor';
+import { AbstractObject } from '../components';
 /**
  * Generate data from model of object and save it in default backend
  * @param model
@@ -7,4 +6,4 @@ import { Proxy } from '../components/types/ProxyConstructor';
  * @param forcedValues
  * @returns
  */
-export declare const DataGenerator: <T extends BaseObject>(model: Proxy<T>, qty?: number, forcedValues?: any) => Promise<any>;
+export declare const DataGenerator: <T extends AbstractObject>(model: T, qty?: number, forcedValues?: any) => Promise<any>;

package/lib/utils/DataGenerator.js

@@ -47,8 +47,9 @@ const DataGenerator = (model, qty = 5, forcedValues = {}) => __awaiter(void 0, v
     const promises = [];
     Core_1.Core.log(`Starting to create ${qty} ${model.constructor.name} records`);
     for (let i = 0; i < qty; i++) {
-        const dao = yield model.core.dataObject.clone(); //model.dataObject.toJSON())
+        const dao = yield model.dataObject.clone();
         Object.keys(dao.properties).forEach((key) => {
+            console.log(`Getting property for '${key}'`);
             const property = dao.get(key);
             if (forcedValues[key]) {
                 property.set(forcedValues[key]);

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@quatrain/core",
-   "version": "1.0.0-beta4",
+   "version": "1.0.0-beta8",
    "description": "Core objects for business apps",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",