@quatrain/core 1.0.0-beta2 → 1.0.0-beta21

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.d.ts

@@ -59,6 +59,15 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      */
     protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
     asReference(): any;
-    query(): Query<any>;
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj: any): Query<any>;
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query(): Query<typeof BaseObjectCore>;
 }

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;
     }
@@ -146,9 +149,18 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     asReference() {
         return this._dataObject.toReference();
     }
-    query() {
-        return new Query_1.Query(this.constructor.prototype);
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj) {
+        return new Query_1.Query(obj, this);
     }
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query() {
         return new Query_1.Query(this);
     }

package/lib/components/BaseRepository.d.ts

@@ -12,6 +12,7 @@ export default class BaseRepository<T extends BaseObject> {
     backendAdapter: BackendInterface;
     constructor(model: typeof BaseObjectCore, backendAdapter?: BackendInterface);
     protected getDataObjectFromUid(uid: string): Promise<DataObjectClass<any>>;
+    protected getDataObjectFromPath(path: string): Promise<DataObjectClass<any>>;
     create<B extends BaseObjectCore>(obj: B, uid?: string): Promise<any>;
     read(key: string): Promise<any>;
     update(obj: BaseObjectCore): Promise<any>;

package/lib/components/BaseRepository.js

@@ -58,17 +58,35 @@ class BaseRepository {
             return dataObject;
         });
     }
+    getDataObjectFromPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = DataObject_1.DataObject.factory({
+                properties: this._model.PROPS_DEFINITION,
+                uri: path,
+            });
+            dataObject.uid = path.substring(path.lastIndexOf('/') + 1);
+            return dataObject;
+        });
+    }
     create(obj, uid) {
         return __awaiter(this, void 0, void 0, function* () {
             const savedObj = yield this.backendAdapter.create(obj.dataObject, uid);
-            return this._model.fromDataObject(savedObj); //as Persisted<T>
+            return this._model.fromDataObject(savedObj);
         });
     }
     read(key) {
         return __awaiter(this, void 0, void 0, function* () {
-            const uid = key.indexOf('/') !== -1 ? key.substring(key.lastIndexOf('/') + 1) : key;
             try {
-                const dataObject = yield this.getDataObjectFromUid(uid);
+                let dataObject;
+                if (key.split('/').length <= 2) {
+                    const uid = key.indexOf('/') !== -1
+                        ? key.substring(key.lastIndexOf('/') + 1)
+                        : key;
+                    dataObject = yield this.getDataObjectFromUid(uid);
+                }
+                else {
+                    dataObject = yield this.getDataObjectFromPath(key);
+                }
                 const response = yield this.backendAdapter.read(dataObject);
                 const obj = this._model.fromDataObject(response);
                 // TODO should be moved to the backend middleware

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,16 +247,28 @@ 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
@@ -256,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 Entity extends BaseObject {
-    users: User;
+export interface EntityType extends BaseObject {
 }
-export declare class EntityCore 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,36 +22,36 @@ 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.EntityCore = 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 EntityCore extends BaseObjectCore_1.BaseObjectCore {
+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.EntityCore = EntityCore;
-EntityCore.COLLECTION = 'entities';
-EntityCore.PROPS_DEFINITION = [
+exports.Entity = Entity;
+Entity.COLLECTION = 'entities';
+Entity.PROPS_DEFINITION = [
     ...BaseObject_1.BaseObjectProperties,
     {
         // surcharge property minLength and htmlType
@@ -61,11 +61,11 @@ EntityCore.PROPS_DEFINITION = [
         minLength: 1,
         htmlType: htmlType.ORG,
     },
-    {
-        name: 'users',
-        mandatory: true,
-        type: CollectionProperty_1.CollectionProperty.TYPE,
-        instanceOf: User_1.UserCore,
-        parentKey: 'entity',
-    },
+    // {
+    //    name: 'users',
+    //    mandatory: true,
+    //    type: CollectionProperty.TYPE,
+    //    instanceOf: User,
+    //    parentKey: 'entity',
+    // },
 ];

package/lib/components/EntityRepository.d.ts

@@ -1,6 +1,6 @@
 import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
-import { Entity } from './Entity';
-export default class EntityRepository extends BaseRepository<Entity> {
+import { EntityType } from './Entity';
+export default class EntityRepository extends BaseRepository<EntityType> {
     constructor(backendAdapter?: BackendInterface);
 }

package/lib/components/EntityRepository.js

@@ -8,7 +8,7 @@ const BaseRepository_1 = __importDefault(require("./BaseRepository"));
 const Entity_1 = require("./Entity");
 class EntityRepository extends BaseRepository_1.default {
     constructor(backendAdapter = Core_1.Core.getBackend()) {
-        super(Entity_1.EntityCore, backendAdapter);
+        super(Entity_1.Entity, backendAdapter);
     }
 }
 exports.default = EntityRepository;

package/lib/components/ObjectUri.d.ts

@@ -10,19 +10,38 @@ export declare class ObjectUri {
     protected _collection: string | undefined;
     protected _label: string | undefined;
     protected _objClass: any;
+    protected _parent: ObjectUri | undefined;
     /**
      * create object uri from string:
      * ex: 'xyz', '@backend:xyz', 'collection/xyz', '@backend:collection/xyz'
      * some backends will need a collection or table name, some may deduct it from object
-     * @param str
+     * @param str partial or full resource path
+     * @param label optional label to describe path
      */
     constructor(str?: string, label?: string | undefined);
     set class(objClass: any);
     get class(): any;
     get backend(): string;
+    /**
+     * Returns the full path of the resource
+     * including optional parents' path
+     * @returns string
+     */
     get path(): string;
+    /**
+     * Returns the own path of the resource
+     * without the optional parents' paths
+     * @returns string
+     */
+    get ownPath(): string;
+    get parent(): ObjectUri | undefined;
     set label(label: string | undefined);
     get label(): string | undefined;
+    /**
+     * Return the full path litteral
+     * including the backend alias
+     * @returns string
+     */
     get literal(): string;
     set path(path: string);
     get uid(): string | undefined;

package/lib/components/ObjectUri.js

@@ -7,7 +7,8 @@ class ObjectUri {
      * create object uri from string:
      * ex: 'xyz', '@backend:xyz', 'collection/xyz', '@backend:collection/xyz'
      * some backends will need a collection or table name, some may deduct it from object
-     * @param str
+     * @param str partial or full resource path
+     * @param label optional label to describe path
      */
     constructor(str = '', label = '') {
         this._pairs = [];
@@ -28,34 +29,38 @@ class ObjectUri {
             this._path = str;
         }
         const parts = this._path.split(ObjectUri.DEFAULT);
-        if (parts.length === 1) {
+        const isFilePath = parts[parts.length - 1].indexOf('.') !== -1;
+        if (isFilePath) {
+            this._uid = parts[parts.length - 1];
+        }
+        else if (parts.length === 1) {
             // It is allowed to only give the uid part of the uri
-            // provided that collection will be injected by another mean
+            // provided that collection will be injected by another means
             this._uid = parts[0].length > 0 ? parts[0] : undefined;
             this._collection = ObjectUri.MISSING_COLLECTION;
             this._pairs.push(`${ObjectUri.MISSING_COLLECTION}${ObjectUri.DEFAULT}${this._uid}`);
             this._label = label || this._uid;
         }
         else if (parts.length % 2 === 0) {
-            // General case is a path containing pairs of collection/uid
-            let i = 0;
-            while (i < parts.length) {
-                this._collection = parts[i];
-                this._uid = parts[i + 1];
-                this._pairs.push(`${parts[i]}${ObjectUri.DEFAULT}${parts[i + 1]}`);
-                i += 2;
+            this._path = parts.slice(parts.length - 2).join(ObjectUri.DEFAULT);
+            this._uid = parts[parts.length - 1];
+            this._collection = parts[parts.length - 2];
+            if (parts.length > 2) {
+                this._parent = new ObjectUri(parts.slice(0, parts.length - 2).join(ObjectUri.DEFAULT));
             }
             this._label = label || this._uid;
         }
-        else {
+        else if (!isFilePath) {
+            // if the last part is not a filename with extension, throw error
             throw new Error(`Path parts number must be 1 or even, received: '${str}'`);
         }
     }
     set class(objClass) {
-        var _a;
         this._objClass = objClass;
         if (objClass) {
-            this._collection = objClass.COLLECTION || ((_a = objClass.name) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+            this._collection =
+                objClass.COLLECTION ||
+                    (objClass.name && objClass.name.toLowerCase());
         }
         else {
             this._collection = undefined;
@@ -67,17 +72,42 @@ class ObjectUri {
     get backend() {
         return this._backend;
     }
+    /**
+     * Returns the full path of the resource
+     * including optional parents' path
+     * @returns string
+     */
     get path() {
+        return this._parent
+            ? `${this._parent.path}${ObjectUri.DEFAULT}${this._path}`
+            : this._path;
+    }
+    /**
+     * Returns the own path of the resource
+     * without the optional parents' paths
+     * @returns string
+     */
+    get ownPath() {
         return this._path;
     }
+    get parent() {
+        return this._parent;
+    }
     set label(label) {
         this._label = label;
     }
     get label() {
         return this._label;
     }
+    /**
+     * Return the full path litteral
+     * including the backend alias
+     * @returns string
+     */
     get literal() {
-        return `${this._backend}:${this._pairs.join(ObjectUri.DEFAULT)}`;
+        return this._str.includes(':')
+            ? this._str
+            : `${this._backend}:${this._str}`;
     }
     set path(path) {
         // if (this._path && this._path !== ObjectUri.DEFAULT) {

package/lib/components/User.d.ts

@@ -1,6 +1,6 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-export interface User extends BaseObject {
+export interface UserType extends BaseObject {
     name: string;
     firstname: string;
     lastname: string;
@@ -10,8 +10,8 @@ export interface User extends BaseObject {
     email: string;
 }
 export declare const UserProperties: any;
-export declare class UserCore extends BaseObjectCore {
+export declare class User extends BaseObjectCore {
     static PROPS_DEFINITION: any;
     static COLLECTION: string;
-    static factory(src?: any): Promise<UserCore>;
+    static factory(src?: any): Promise<User>;
 }

package/lib/components/User.js

@@ -32,7 +32,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserCore = exports.UserProperties = void 0;
+exports.User = exports.UserProperties = void 0;
 const BaseObjectCore_1 = require("./BaseObjectCore");
 const properties_1 = require("../properties");
 const HashProperty_1 = require("../properties/HashProperty");
@@ -97,33 +97,40 @@ exports.UserProperties = [
         fullSearch: true,
         htmlType: htmlType.EMAIL,
     },
+    {
+        name: 'phone',
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        htmlType: htmlType.OFF,
+    },
     {
         name: 'password',
         mandatory: true,
         type: HashProperty_1.HashProperty.TYPE,
         algorithm: HashProperty_1.HashProperty.ALGORITHM_SHA256,
-        salt: '',
+        salt: '', // you should override it in your code
         minLength: 5,
-        maxLength: 20,
+        maxLength: 20, // this is for the clear password
         htmlType: htmlType.PASSWORD,
     },
     {
         name: 'entity',
         mandatory: false,
         type: properties_1.ObjectProperty.TYPE,
-        instanceOf: Entity_1.EntityCore,
+        instanceOf: Entity_1.Entity,
     },
 ];
-class UserCore extends BaseObjectCore_1.BaseObjectCore {
+class User 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, UserCore);
+            return _super.factory.call(this, src, User);
         });
     }
 }
-exports.UserCore = UserCore;
-UserCore.PROPS_DEFINITION = exports.UserProperties;
-UserCore.COLLECTION = 'user';
+exports.User = User;
+User.PROPS_DEFINITION = exports.UserProperties;
+User.COLLECTION = 'user';

package/lib/components/UserRepository.d.ts

@@ -1,7 +1,7 @@
 import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
-import { User } from './User';
-export default class UserRepository extends BaseRepository<User> {
+import { UserType } from './User';
+export default class UserRepository extends BaseRepository<UserType> {
     constructor(backendAdapter?: BackendInterface);
-    getFromEmail(email: string): Promise<User>;
+    getFromEmail(email: string): Promise<UserType>;
 }

package/lib/components/UserRepository.js

@@ -19,11 +19,11 @@ const User_1 = require("./User");
 const UNAUTHORIZED_ERROR = `Wrong password or email`;
 class UserRepository extends BaseRepository_1.default {
     constructor(backendAdapter) {
-        super(User_1.UserCore, backendAdapter);
+        super(User_1.User, backendAdapter);
     }
     getFromEmail(email) {
         return __awaiter(this, void 0, void 0, function* () {
-            const query = new backends_1.Query(User_1.UserCore);
+            const query = new backends_1.Query(User_1.User);
             query.where('email', email).batch(1);
             const { items } = yield this.query(query);
             if (items.length == 0) {