@quatrain/core 0.5.0 → 0.5.3

package/README.md

@@ -11,13 +11,114 @@ and storage.
 
 ## How to install
 
-```javascript
+```bash
 yarn install @quatrain/core
 ```
 
 Quatrain Core comes with a built-in Mock backend adapter. Other adapters are available in
 different packages. For example, a Google Firestore adapter is available:
 
-```javascript
+```bash
 yarn install @quatrain/backend-firestore
 ```
+
+## How to use
+
+### Setup
+
+```ts
+import { Core } from '@quatrain/core'
+
+Core.addBackend(myAdapter, 'myDB', true)
+```
+
+### Create a model
+
+```ts
+import { BaseObjectCore } from '@quatrain/core'
+
+export type Cat = {
+   name: string
+   color: `#${string}`
+}
+
+export class CatCore extends BaseObjectCore {
+   static COLLECTION = 'cats'
+
+   static PROPERTIES = [
+      {
+         name: 'name',
+         type: Property.STRING,
+         minLength: 1,
+         maxLength: 32,
+      },
+      {
+         name: 'color',
+         type: Property.STRING,
+         minLength: 4,
+         maxLength: 7,
+      },
+   ]
+}
+```
+
+### Instantiate a model
+
+```ts
+const catData: Cat = {
+   name: 'Garfield',
+   color: '#ffa502',
+}
+
+const garfield = CatCore.fromObject(catData)
+
+console.log(garfield.name)
+// > "Garfield"
+console.log(garfield.color)
+// > "#ffa502"
+console.log(garfield.core)
+// > CatCore { ... }
+```
+
+### Interact with backend
+
+```ts
+// Let's save Garfield in our database
+garfield.core.save()
+
+// Now, let's retrieve Garfield in the database
+const persistedGarfield = await CatCore.fromBackend('garfield')
+```
+
+### Using repositories
+
+You can use repositories as an alternative way to persist and retrieve models in your backend.
+
+This module provides a BaseRepository class that you can extend and override to apply your business logic when doing backend operations.
+
+Let's create a repository for our Cat model, that prevents us from deleting a cat.
+
+```ts
+import { Core, BackendInterface, BaseRepository } from '@quatrain/core'
+
+export default class CatRepository extends BaseRepository<Cat> {
+   constructor(backendAdapter: BackendInterface = Core.getBackend()) {
+      super(CatCore, backendAdapter)
+   }
+
+   async delete(uid: string) {
+      throw Error("Don't delete the cats!")
+   }
+}
+```
+
+Now, let's use our new CatRepository.
+
+```ts
+const repository = new CatRepository()
+
+repository.create(garfield)
+repository.read('garfield')
+repository.update(persistedGarfield)
+repository.delete('garfield') // Will throw "Don't delete the cats!"
+```

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 { Proxy } from '../../components/types/ProxyConstructor';
 export interface InjectMetaMiddlewareParams {
-    user: User;
+    user: Proxy<User>;
 }
 export declare class InjectMetaMiddleware implements Middleware {
-    protected _user: User;
+    protected _user: Proxy<User>;
     constructor(params: InjectMetaMiddlewareParams);
     execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
 }

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -10,15 +10,15 @@ class InjectMetaMiddleware {
         switch (action) {
             // add properties existence validation
             case Backend_1.BackendAction.CREATE:
-                dataObject.set('createdBy', this._user);
+                dataObject.set('createdBy', this._user.core.dataObject.uri);
                 dataObject.set('createdAt', Date.now());
                 break;
             case Backend_1.BackendAction.UPDATE:
-                dataObject.set('updatedBy', this._user);
+                dataObject.set('updatedBy', this._user.core.dataObject.uri);
                 dataObject.set('updatedAt', Date.now());
                 break;
             case Backend_1.BackendAction.DELETE:
-                dataObject.set('deletedBy', this._user);
+                dataObject.set('deletedBy', this._user.core.dataObject.uri);
                 dataObject.set('deletedAt', Date.now());
                 break;
             default:

package/lib/components/DataObject.d.ts

@@ -65,7 +65,7 @@ export declare class DataObject implements DataObjectClass<any> {
     set uid(uid: string | undefined);
     get uid(): string | undefined;
     get data(): any;
-    set uri(uri: string | ObjectUri | undefined);
+    set uri(uri: ObjectUri);
     get uri(): ObjectUri;
     get class(): any;
     has(key: string): boolean;

package/lib/components/DataObject.js

@@ -85,7 +85,19 @@ class DataObject {
         if (this._populated === false) {
             for (const key in data) {
                 if (Reflect.get(this._properties, key)) {
-                    Reflect.get(this._properties, key).set(data[key]);
+                    const val = data[key];
+                    if (val &&
+                        typeof val === 'object' &&
+                        'ref' in val &&
+                        typeof val.ref == 'string' &&
+                        'label' in val &&
+                        typeof val.label == 'string') {
+                        const { ref, label } = val;
+                        Reflect.get(this._properties, key).set(new ObjectUri_1.ObjectUri(ref, label));
+                    }
+                    else {
+                        Reflect.get(this._properties, key).set(data[key]);
+                    }
                 }
             }
             this._populated = true;
@@ -141,7 +153,7 @@ class DataObject {
         return this._properties;
     }
     set uri(uri) {
-        this._objectUri = uri instanceof ObjectUri_1.ObjectUri ? uri : new ObjectUri_1.ObjectUri(uri);
+        this._objectUri = uri;
         if (this._objectUri.collection !== ObjectUri_1.ObjectUri.MISSING_COLLECTION) {
             this._persisted = true;
         }

package/lib/components/ObjectUri.js

@@ -19,7 +19,7 @@ class ObjectUri {
         this._label = '';
         this._str = str;
         this._label = label;
-        if (str.indexOf(':') !== -1) {
+        if (str.includes(':')) {
             const [backend, path] = str.split(':');
             this._backend = backend || Core_1.Core.defaultBackend;
             this._path = path;

package/package.json

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