@quatrain/core 1.0.0-beta4 → 1.0.0-beta7

package/lib/backends/AbstractAdapter.d.ts

@@ -7,6 +7,7 @@ import { Query, QueryResultType } from './Query';
 import { SortAndLimit } from './SortAndLimit';
 import Middleware from './middlewares/Middleware';
 export declare abstract class AbstractAdapter implements BackendInterface {
+    static PKEY_IDENTIFIER: any;
     protected _alias: string;
     protected _params: BackendParameters;
     protected _middlewares: Middleware[];

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;
@@ -82,3 +83,4 @@ class AbstractAdapter {
     }
 }
 exports.AbstractAdapter = AbstractAdapter;
+AbstractAdapter.PKEY_IDENTIFIER = 'id';

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/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

@@ -14,6 +14,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 +27,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?
@@ -75,6 +77,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

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();
@@ -190,6 +191,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 +204,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);
     }
@@ -242,7 +246,6 @@ class DataObject {
                     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()

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

@@ -7,6 +7,7 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     path: any;
     class: any;
     properties: any;
+    parentProp: string | undefined;
     setProperties(properties: any): void;
     addProperty(property: PropertyClassType): void;
     populate(data?: any): Promise<T>;

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/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'

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-beta7",
    "description": "Core objects for business apps",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",