@quatrain/core 0.2.0 → 0.4.0

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectMetaMiddleware = void 0;
+const actions = __importStar(require("../../Backend"));
+class InjectMetaMiddleware {
+    constructor(params) {
+        this._user = params.user;
+    }
+    execute(dataObject, action) {
+        switch (action) {
+            // add properties existence validation
+            case actions.CREATE:
+                dataObject.set('createdBy', this._user);
+                dataObject.set('createdAt', Date.now());
+            case actions.UPDATE:
+                dataObject.set('updatedBy', this._user);
+                dataObject.set('updatedAt', Date.now());
+            case actions.DELETE:
+                dataObject.set('deletedBy', this._user);
+                dataObject.set('deleteddAt', Date.now());
+            default:
+                break;
+        }
+        return;
+    }
+}
+exports.InjectMetaMiddleware = InjectMetaMiddleware;

package/lib/components/AbstractObject.d.ts

@@ -1,23 +1,26 @@
-import { DataObject } from './DataObject';
+import { DataObjectClass } from './types/DataObjectClass';
 import { DataObjectProperties } from '../properties/';
+import { Query } from '../backends/Query';
 export declare abstract class AbstractObject {
     static PROPS_DEFINITION: DataObjectProperties;
     static COLLECTION: string;
     static LABEL_KEY: string;
-    protected _dataObject: DataObject;
-    constructor(dao: DataObject);
+    protected _dataObject: DataObjectClass<any>;
+    constructor(dao: DataObjectClass<any>);
     get(key: string): any;
-    set(key: string, val: any): DataObject;
+    set(key: string, val: any): any;
     val(key: string): any;
-    get backend(): string | undefined;
+    get backend(): any;
     get path(): string;
-    get uid(): string | undefined;
-    get dataObject(): DataObject;
+    get uid(): any;
+    get dataObject(): DataObjectClass<any>;
     get uri(): import("./ObjectUri").ObjectUri;
     toJSON(): {
-        literal: string;
+        backend: string;
         ref: string;
-        label: string | undefined;
+        label: string;
     };
-    save(uid?: string | undefined): Promise<DataObject>;
+    save(): Promise<DataObjectClass<any>>;
+    delete(): Promise<DataObjectClass<any>>;
+    static query(): Query<typeof AbstractObject>;
 }

package/lib/components/AbstractObject.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractObject = void 0;
+const Query_1 = require("../backends/Query");
 class AbstractObject {
     constructor(dao) {
         this._dataObject = dao;
@@ -49,11 +50,19 @@ class AbstractObject {
         var _b;
         return typeof this.uri === 'string' ? this.uri : (_b = this.uri) === null || _b === void 0 ? void 0 : _b.toJSON();
     }
-    save(uid = undefined) {
+    save() {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this._dataObject.save(uid);
+            return yield this._dataObject.save();
         });
     }
+    delete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._dataObject.delete();
+        });
+    }
+    static query() {
+        return new Query_1.Query(this);
+    }
 }
 exports.AbstractObject = AbstractObject;
 _a = AbstractObject;

package/lib/components/BaseObject.d.ts

@@ -1,16 +1,15 @@
 import { ObjectUri } from './ObjectUri';
+import { DataObjectClass } from './types/DataObjectClass';
+import { BaseObjectClass } from './types/BaseObjectClass';
 import { AbstractObject } from './AbstractObject';
-import { DataObjectProperties } from '../properties';
-import { Query } from '../backends';
-export declare class BaseObject extends AbstractObject {
-    static PROPS_DEFINITION: DataObjectProperties;
+import { Query } from '../backends/Query';
+export declare class BaseObject extends AbstractObject implements BaseObjectClass {
+    static PROPS_DEFINITION: any;
+    static getProperty(key: string): any;
     get status(): string;
     set status(status: string);
-    static factory<T extends BaseObject>(src?: string | ObjectUri | object | undefined): Promise<T | BaseObject>;
-    asReference(): {
-        label: any;
-        ref: string;
-        uri: string;
-    };
-    query(): Query<this>;
+    static daoFactory(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<DataObjectClass<any>>;
+    static factory<T extends BaseObject>(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<T | BaseObject>;
+    asReference(): any;
+    query(): Query<any>;
 }

package/lib/components/BaseObject.js

@@ -10,51 +10,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObject = void 0;
-const DataObject_1 = require("./DataObject");
 const ObjectUri_1 = require("./ObjectUri");
 const AbstractObject_1 = require("./AbstractObject");
 const BaseObjectProperties_1 = require("./BaseObjectProperties");
-const backends_1 = require("../backends");
+const Query_1 = require("../backends/Query");
+const DataObject_1 = require("./DataObject");
 class BaseObject extends AbstractObject_1.AbstractObject {
+    static getProperty(key) {
+        return BaseObject.PROPS_DEFINITION.find((prop) => prop.name === key);
+    }
     get status() {
         return this._dataObject.val('status');
     }
     set status(status) {
         this._dataObject.set('status', status);
     }
-    static factory(src = undefined) {
+    static daoFactory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // merge base properties with additional or redefined ones
-                const base = BaseObjectProperties_1.BaseObjectProperties;
-                // this.PROPS_DEFINITION &&
-                this.PROPS_DEFINITION.forEach((property) => {
-                    // manage parent properties potential redeclaration
-                    const found = base.findIndex((el) => el.name === property.name);
-                    if (found !== -1) {
-                        base[found] = Object.assign(base[found], property);
-                    }
-                    else {
-                        base.push(property);
-                    }
-                });
-                //console.log('props to add', JSON.stringify(base))
-                // create data object
-                const dao = yield DataObject_1.DataObject.factory(this.prototype, base);
-                if (src instanceof ObjectUri_1.ObjectUri) {
-                    dao.uri = src;
-                    yield dao.populate();
-                }
-                else if (typeof src === 'string') {
-                    dao.uri.path = src;
-                    yield dao.populate();
+            // merge base properties with additional or redefined ones
+            const base = BaseObjectProperties_1.BaseObjectProperties;
+            // this.PROPS_DEFINITION &&
+            this.PROPS_DEFINITION.forEach((property) => {
+                // manage parent properties potential redeclaration
+                const found = base.findIndex((el) => el.name === property.name);
+                if (found !== -1) {
+                    base[found] = Object.assign(base[found], property);
                 }
-                else if (src instanceof Object) {
-                    dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
-                    dao.uri.collection = this.COLLECTION;
-                    yield dao.populate(src);
+                else {
+                    base.push(property);
                 }
-                return new this(dao);
+            });
+            // create data object
+            const dao = yield DataObject_1.DataObject.factory({ properties: base });
+            dao.uri.class = child;
+            if (src instanceof ObjectUri_1.ObjectUri) {
+                dao.uri = src;
+                yield dao.read();
+            }
+            else if (typeof src === 'string') {
+                dao.uri.path = src;
+                yield dao.read();
+            }
+            else if (src instanceof Object) {
+                dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
+                dao.uri.collection = this.COLLECTION;
+                yield dao.populate(src);
+            }
+            return dao;
+        });
+    }
+    static factory(src = undefined, child = this) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dao = yield this.daoFactory(src, child);
+                return Reflect.construct(this, [dao]);
             }
             catch (err) {
                 console.log(err.message);
@@ -66,7 +75,7 @@ class BaseObject extends AbstractObject_1.AbstractObject {
         return this._dataObject.toReference();
     }
     query() {
-        return new backends_1.Query(this);
+        return new Query_1.Query(this.constructor.prototype);
     }
 }
 exports.BaseObject = BaseObject;

package/lib/components/BaseObjectProperties.d.ts

@@ -1,15 +1,13 @@
-import { DataObjectProperties } from '../properties';
-import * as statuses from '../statuses';
-import { User } from './User';
+import { UserClass } from './types/UserClass';
 import { ObjectUri } from './ObjectUri';
 export interface BaseObjectType {
     name: string;
-    status: typeof statuses.CREATED | typeof statuses.PENDING | typeof statuses.ACTIVE | typeof statuses.DELETED;
-    createdBy?: User | ObjectUri;
+    status: string;
+    createdBy?: UserClass | ObjectUri;
     createdAt?: number;
-    updatedBy?: User | ObjectUri;
+    updatedBy?: UserClass | ObjectUri;
     updatedAt?: number;
-    deletedBy?: User | ObjectUri;
+    deletedBy?: UserClass | ObjectUri;
     deletedAt?: number;
 }
-export declare const BaseObjectProperties: DataObjectProperties;
+export declare const BaseObjectProperties: any;

package/lib/components/BaseObjectProperties.js

@@ -24,20 +24,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObjectProperties = void 0;
-const Property_1 = require("../properties/Property");
 const statuses = __importStar(require("../statuses"));
+const StringProperty_1 = require("../properties/StringProperty");
+const ObjectProperty_1 = require("../properties/ObjectProperty");
+const EnumProperty_1 = require("../properties/EnumProperty");
+const DateTimeProperty_1 = require("../properties/DateTimeProperty");
+const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
 exports.BaseObjectProperties = [
     {
         name: 'name',
         mandatory: true,
-        type: Property_1.Property.TYPE_STRING,
+        type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        htmlType: htmlType.NAME,
     },
     {
         name: 'status',
         mandatory: true,
-        type: Property_1.Property.TYPE_ENUM,
+        type: EnumProperty_1.EnumProperty.TYPE,
         values: [
             statuses.CREATED,
             statuses.PENDING,
@@ -48,35 +53,35 @@ exports.BaseObjectProperties = [
     },
     {
         name: 'createdBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
         mandatory: true,
         protected: true,
     },
     {
         name: 'createdAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
         mandatory: true,
         protected: true,
     },
     {
         name: 'updatedBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
     },
     {
         name: 'updatedAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
     },
     {
         name: 'deletedBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
         protected: true,
     },
     {
         name: 'deletedAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
         protected: true,
     },
 ];

package/lib/components/DataObject.d.ts

@@ -1,23 +1,29 @@
+import { DataObjectProperties } from '../properties';
+import { PropertyClassType } from '../properties/types/PropertyClassType';
 import { AbstractObject } from './AbstractObject';
 import { ObjectUri } from './ObjectUri';
+import { DataObjectClass } from './types/DataObjectClass';
+export declare type CoreObject<T extends AbstractObject> = T;
+export declare type Properties = {
+    [x: string]: PropertyClassType;
+};
 export interface DataObjectFactoryType {
     path: string;
     [x: string]: any;
 }
-export declare type CoreObject<T extends AbstractObject> = T;
+export interface DataObjectParams {
+    uri?: string | ObjectUri;
+    properties: DataObjectProperties;
+}
 /**
  * Data objects constitute the agnostic glue between objects and backends.
  * They handle data and identifiers in a protected registry
  * This is what backends and objects manipulate, oblivious of the other.
  */
-export declare class DataObject {
-    protected _class: CoreObject<any>;
+export declare class DataObject implements DataObjectClass<any> {
     protected _objectUri: ObjectUri;
-    protected _obj: any;
     protected _uid: string | undefined;
-    protected _properties: {
-        [x: string]: any;
-    };
+    protected _properties: Properties;
     protected _persisted: boolean;
     protected _populated: boolean;
     /**
@@ -26,11 +32,11 @@ export declare class DataObject {
     protected _modified: boolean;
     /**
      * Constructor is protected, use factory() instead
-     * @param objClass AbstractObject
-     * @param properties array of properties instances
+     * @param params object of parameters
      */
-    protected constructor(objClass: AbstractObject, properties: any[] | undefined);
+    protected constructor(params: DataObjectParams | undefined);
     protected _init(properties: any[]): void;
+    setProperties(properties: Properties): void;
     /**
      * Populate data object from instant data or backend query
      * @param data
@@ -38,23 +44,22 @@ export declare class DataObject {
     populate(data?: any): Promise<DataObject>;
     isPopulated(): boolean;
     isPersisted(): boolean;
-    get properties(): {
-        [x: string]: any;
-    };
+    get properties(): Properties;
     get backend(): string | undefined;
-    get class(): any;
     get path(): string;
     set uid(uid: string | undefined);
     get uid(): string | undefined;
     get data(): any;
     set uri(uri: string | ObjectUri | undefined);
     get uri(): ObjectUri;
+    get class(): any;
+    has(key: string): boolean;
     /**
      * Returns property matching key or throw
      * @param key string
      * @returns BaseProperty
      */
-    get(key: string): any;
+    get(key: string): PropertyClassType;
     set(key: string, val: any): this;
     /**
      * Get value of given property
@@ -71,13 +76,15 @@ export declare class DataObject {
         uri: string;
     };
     protected _dataToJSON(): {};
-    read(): Promise<DataObject>;
-    save(desiredUid?: string | undefined): Promise<DataObject>;
+    read(): Promise<DataObjectClass<any>>;
+    save(): Promise<DataObjectClass<any>>;
+    delete(): Promise<DataObjectClass<any>>;
     /**
      * Data object must be created from factory in order for async-loaded data to be available
      * @param className
      * @param param
      * @returns DataObject
      */
-    static factory(className: any, param?: any[] | undefined): Promise<DataObject>;
+    static factory(param?: DataObjectParams | undefined): Promise<DataObject>;
+    clone(data?: any): Promise<DataObject>;
 }

package/lib/components/DataObject.js

@@ -21,10 +21,9 @@ const ObjectUri_1 = require("./ObjectUri");
 class DataObject {
     /**
      * Constructor is protected, use factory() instead
-     * @param objClass AbstractObject
-     * @param properties array of properties instances
+     * @param params object of parameters
      */
-    constructor(objClass, properties) {
+    constructor(params) {
         this._uid = undefined;
         this._properties = {};
         this._persisted = false;
@@ -33,20 +32,30 @@ class DataObject {
          * Has data been modified since last backend operation?
          */
         this._modified = false;
-        this._class = objClass;
-        this._objectUri = new ObjectUri_1.ObjectUri();
-        if (Array.isArray(properties)) {
-            this._init(properties);
+        if (params) {
+            if (typeof params.uri !== 'object') {
+                this._objectUri = new ObjectUri_1.ObjectUri(params.uri);
+            }
+            else {
+                this._objectUri = params.uri;
+            }
+        }
+        else {
+            this._objectUri = new ObjectUri_1.ObjectUri();
+        }
+        if (params && Array.isArray(params.properties)) {
+            this._init(params.properties);
         }
     }
     _init(properties) {
-        // console.log(
-        //    `Preparing properties for instance of ${this._class.constructor.name}`
-        // )
         properties.forEach((prop) => {
             this._properties[prop.name] = Property_1.Property.factory(prop, this);
         });
     }
+    setProperties(properties) {
+        // TODO check if doable
+        this._properties = properties;
+    }
     /**
      * Populate data object from instant data or backend query
      * @param data
@@ -84,9 +93,6 @@ class DataObject {
     get backend() {
         return this._objectUri ? this._objectUri.backend : undefined;
     }
-    get class() {
-        return this._class;
-    }
     get path() {
         return this._objectUri ? this._objectUri.path : '';
     }
@@ -104,10 +110,20 @@ class DataObject {
     }
     set uri(uri) {
         this._objectUri = uri instanceof ObjectUri_1.ObjectUri ? uri : new ObjectUri_1.ObjectUri(uri);
+        if (this._objectUri.collection !== ObjectUri_1.ObjectUri.MISSING_COLLECTION) {
+            this._persisted = true;
+        }
     }
     get uri() {
         return this._objectUri;
     }
+    get class() {
+        // TODO get class type
+        return this.uri.class;
+    }
+    has(key) {
+        return Reflect.has(this._properties, key);
+    }
     /**
      * Returns property matching key or throw
      * @param key string
@@ -122,7 +138,7 @@ class DataObject {
         }
     }
     set(key, val) {
-        if (!Reflect.has(this._properties, key)) {
+        if (!this.has(key)) {
             throw new Error(`Unknown property in data object: ${key}`);
         }
         this._properties[key].set(val);
@@ -136,7 +152,7 @@ class DataObject {
      * @returns any
      */
     val(key) {
-        if (Reflect.get(this._properties, key)) {
+        if (this.has(key)) {
             return Reflect.get(this._properties, key).val();
         }
         else {
@@ -147,19 +163,19 @@ class DataObject {
         return Object.assign(Object.assign({}, (this._uid && { uid: this._uid })), this._dataToJSON());
     }
     toReference() {
-        var _a;
-        return Object.assign(Object.assign({}, (_a = this._objectUri) === null || _a === void 0 ? void 0 : _a.toReference()), { label: this.val('name') });
+        return Object.assign(Object.assign({}, this._objectUri.toReference()), { label: this.val('name') || '' });
     }
     _dataToJSON() {
         const data = {};
         Object.keys(this._properties).forEach((key) => {
             const prop = Reflect.get(this._properties, key);
-            if (typeof prop.val() === 'object' &&
-                Reflect.has(prop.val(), 'toJSON')) {
-                Reflect.set(data, key, prop.val().toJSON());
-            }
-            else if (prop !== undefined) {
-                Reflect.set(data, key, prop.val());
+            const value = prop.val();
+            switch (prop.constructor.name) {
+                case 'ObjectProperty':
+                    Reflect.set(data, key, value ? value.toJSON() : null);
+                    break;
+                default:
+                    Reflect.set(data, key, value || null);
             }
         });
         return data;
@@ -167,7 +183,7 @@ class DataObject {
     read() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return this.populate(Core_1.Core.getBackend().read(this));
+                return this.populate(yield Core_1.Core.getBackend().read(this));
             }
             catch (err) {
                 console.log(err.message);
@@ -175,14 +191,20 @@ class DataObject {
             }
         });
     }
-    save(desiredUid = undefined) {
+    save() {
         return __awaiter(this, void 0, void 0, function* () {
             const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
             this._persisted = true;
             this._modified = false;
-            return this._uid
-                ? yield backend.update(this)
-                : yield backend.create(this, desiredUid);
+            return this.uid ? backend.update(this) : backend.create(this);
+        });
+    }
+    delete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
+            this._persisted = false;
+            this._modified = false;
+            return yield backend.delete(this);
         });
     }
     /**
@@ -191,13 +213,10 @@ class DataObject {
      * @param param
      * @returns DataObject
      */
-    static factory(className, param = undefined) {
+    static factory(param = undefined) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (className === undefined) {
-                throw new Error(`className is a require value`);
-            }
             try {
-                return new this(className, param);
+                return new this(param);
             }
             catch (err) {
                 console.log(err);
@@ -205,5 +224,16 @@ class DataObject {
             }
         });
     }
+    clone(data = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cloned = yield DataObject.factory();
+            cloned.uri.class = this.uri.class;
+            cloned.setProperties(this._properties);
+            if (data) {
+                yield cloned.populate(data);
+            }
+            return cloned;
+        });
+    }
 }
 exports.DataObject = DataObject;

package/lib/components/Entity.d.ts

@@ -0,0 +1,6 @@
+import { BaseObject } from './BaseObject';
+import { EntityClass } from './types/EntityClass';
+export declare class Entity extends BaseObject implements EntityClass {
+    static PROPS_DEFINITION: any;
+    static factory(src?: any): Promise<Entity>;
+}

package/lib/components/Entity.js

@@ -0,0 +1,26 @@
+"use strict";
+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 = void 0;
+const BaseObject_1 = require("./BaseObject");
+const EntityProperties_1 = require("./EntityProperties");
+class Entity extends BaseObject_1.BaseObject {
+    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.PROPS_DEFINITION = EntityProperties_1.EntityProperties;

package/lib/components/EntityProperties.d.ts

@@ -0,0 +1 @@
+export declare const EntityProperties: any;