@solidev/data 0.0.1-alpha.0

package/esm2020/lib/data/data-model.mjs

@@ -0,0 +1,287 @@
+import { PROPERTY_METADATA_KEY, } from './fields/base';
+import { FormControl, FormGroup } from '@angular/forms';
+import { throwError } from 'rxjs';
+import { tap } from 'rxjs/operators';
+/**
+ * Base class for data model.
+ *
+ * Each class must have a static __name
+ * primary field is given with id field.
+ *
+ * Some methods are provided to be used with a collection, mostly for CRUD operations.
+ *
+ */
+export class DataModel {
+    /**
+     * Constructor for data model instance.
+     * A matching collection can be provided.
+     * ___fields readonly property is also populated from Reflected metadata
+     *
+     * @param _coll collection used for CRUD, etc..
+     */
+    constructor(_coll) {
+        this._coll = _coll;
+        const md = Reflect.getMetadata(PROPERTY_METADATA_KEY, this);
+        // istanbul ignore if
+        if (!md) {
+            // This should never occur as all datamodel have at least id field
+            throw new Error('No property metadata found for this object; is there a property in current collection ?');
+        }
+        // Get all fields from current class and its parents
+        const fields = new Map();
+        let parent = Object.getPrototypeOf(this);
+        while (parent.constructor.name !== 'Object') {
+            for (const f of md.keys()) {
+                const fieldName = f.split('__')[1];
+                if (fields.has(fieldName)) {
+                    continue;
+                }
+                if (f.indexOf(parent.constructor.__name + '__') === 0) {
+                    fields.set(fieldName, md.get(f));
+                }
+            }
+            parent = Object.getPrototypeOf(parent);
+        }
+        this._F = Object.freeze(fields);
+    }
+    get _collection() {
+        return this._coll;
+    }
+    set _collection(coll) {
+        this._coll = coll;
+    }
+    /**
+     *  HashMap of fields metadata (type, name, manager, etc...)
+     */
+    get F() {
+        // istanbul ignore if
+        if (!this._F) {
+            throw new Error('Invalid data model, fields metadata is missing');
+        }
+        return this._F;
+    }
+    // Return field names iterator
+    get FN() {
+        return this.F.keys();
+    }
+    /**
+     * Loads model data from json.
+     * If partial is true, only fields with matching data keys will be loaded
+     * @param data
+     * @param options
+     */
+    fromJson(data, { partial, check } = {
+        partial: false,
+        check: false,
+    }) {
+        const errors = {};
+        let haveError = false;
+        for (const f of this.FN) {
+            if (!partial || (partial && Object.keys(data).indexOf(f) !== -1)) {
+                const ferr = this.setFV(f, this.FM(f).fromJson(data[f]), check);
+                if (ferr !== null) {
+                    errors[f] = ferr;
+                    haveError = true;
+                }
+            }
+        }
+        return haveError ? errors : null;
+    }
+    toJson(fields) {
+        if (fields && !Array.isArray(fields)) {
+            fields = [fields];
+        }
+        const out = {};
+        const fl = this.F;
+        for (const f of this.FN) {
+            const mgr = this.FM(f);
+            if (!fields || fields.length === 0) {
+                if (mgr.readonly) {
+                    continue;
+                }
+                out[f] = fl.get(f).manager.toJson(this.FV(f));
+            }
+            else {
+                if (fields.indexOf(f) !== -1) {
+                    out[f] = fl.get(f).manager.toJson(this.FV(f));
+                }
+            }
+        }
+        return out;
+    }
+    action(method, name, { body = undefined, update = false, updatePartial = true, updateCheck = false, 
+    // updateRaise = false,
+    params = {}, headers = {}, } = {}) {
+        if (this._coll === undefined) {
+            return throwError(() => new Error('Missing collection'));
+        }
+        return this._coll
+            .action(this, method, name, {
+            body,
+            params,
+            headers,
+        })
+            .pipe(tap((result) => {
+            if (update) {
+                this.fromJson(result, {
+                    partial: updatePartial,
+                    check: updateCheck,
+                });
+                return this;
+            }
+            return result;
+        }));
+    }
+    // Called on model, returns the manager for a field.
+    FM(field) {
+        if (this.F.has(field)) {
+            return this.F.get(field).manager;
+        }
+        throw new Error(`${field} not found in ${Object.keys(this.F).join(',')} model ${this}`);
+    }
+    // Return field value, without typing
+    FV(field) {
+        return this[field];
+    }
+    /**
+     * Set field value. If check is true, only set value if all validators pass.
+     *
+     * The validation result is returned.
+     *
+     * @param field field name
+     * @param value field valued
+     * @param check default false
+     * @return null or ValidationError
+     */
+    setFV(field, value, check = false) {
+        if (check) {
+            const fc = new FormControl(value);
+            for (const v of this.FM(field).validators) {
+                const val = v(fc);
+                if (val !== null) {
+                    console.error(val);
+                    return val;
+                }
+            }
+        }
+        this[field] = value;
+        return null;
+    }
+    FC(field) {
+        if (field === undefined) {
+            field = Array.from(this.FN).filter((n) => !this.FM(n).readonly);
+        }
+        if (Array.isArray(field)) {
+            const fg = {};
+            for (const f of field) {
+                fg[f] = this.FC(f);
+            }
+            return new FormGroup(fg);
+        }
+        return this.FM(field).formControl(this);
+    }
+    save({ updateModel = true } = {
+        updateModel: true,
+    }) {
+        if (this._coll) {
+            return this._coll.save(this, { updateModel });
+        }
+        return throwError(() => new Error('Missing collection'));
+    }
+    update(fields = [], { updateModel = true } = {
+        updateModel: true,
+    }) {
+        if (this._coll) {
+            return this._coll.update(this, fields, { updateModel });
+        }
+        return throwError(() => new Error('Missing collection'));
+    }
+}
+/**
+ * data model name
+ * this need to be given because class name is not fully available because of minification.
+ */
+DataModel.__name = '';
+//
+// export class TreeDataModel extends DataModel {
+//   static override __name = 'TreeDataModel';
+//   @detailsField({
+//     model: this,
+//     many: true,
+//     description: 'Parents',
+//   })
+//   public parents_details?: this[];
+//
+//   @foreignKeyField({
+//     required: false,
+//     description: 'Structure parente',
+//     related: 'Structure',
+//   })
+//   public parent?: number;
+//
+//   @integerField({
+//     required: false,
+//     readonly: true,
+//     description: 'ID Tree',
+//   })
+//   public tree_id!: number;
+//
+//   @integerField({
+//     required: false,
+//     readonly: true,
+//     description: 'MPTT left',
+//   })
+//   public lft!: number;
+//
+//   @integerField({
+//     required: false,
+//     readonly: true,
+//     description: 'MPTT right',
+//   })
+//   public rght!: number;
+//
+//   @integerField({
+//     required: false,
+//     readonly: true,
+//     description: 'Niveau hiérarchique',
+//   })
+//   public level!: number;
+//
+//   public get parent_details(): this | null {
+//     if (this.parents_details) {
+//       const out = this.parents_details[this.parents_details.length - 1];
+//       out.parents_details = this.parents_details.slice(
+//         0,
+//         this.parents_details.length - 1
+//       );
+//       return out;
+//     }
+//     return null;
+//   }
+//
+//   public set parent_details(d: this | null) {
+//     console.log(d);
+//     this.parents_details = d?.parents_details;
+//   }
+//
+//   public _display(): string {
+//     const out: string[] = [];
+//     if (this.parents_details) {
+//       for (const p of this.parents_details) {
+//         if ((p as any).code) {
+//           out.push(`[${(p as any).code}] ${(p as any).name}`);
+//         } else {
+//           out.push((p as any).name);
+//         }
+//       }
+//     }
+//     if ((this as any).code) {
+//       out.push(`[${(this as any).code}] ${(this as any).name}`);
+//     } else {
+//       out.push((this as any).name);
+//     }
+//
+//     return out.join(' : ');
+//   }
+// }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-model.js","sourceRoot":"","sources":["../../../../../projects/data/src/lib/data/data-model.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseFieldManager,\n  IFieldStoredMetadata,\n  PROPERTY_METADATA_KEY,\n} from './fields/base';\nimport { FormControl, FormGroup, ValidationErrors } from '@angular/forms';\nimport { Collection } from './data-collection';\nimport { Observable, throwError } from 'rxjs';\nimport { tap } from 'rxjs/operators';\n\nexport type DataModelFields = Readonly<Map<string, IFieldStoredMetadata<any>>>;\n\n/**\n * Base class for data model.\n *\n * Each class must have a static __name\n * primary field is given with id field.\n *\n * Some methods are provided to be used with a collection, mostly for CRUD operations.\n *\n */\nexport class DataModel {\n  /**\n   * data model name\n   * this need to be given because class name is not fully available because of minification.\n   */\n  protected static readonly __name: string = '';\n\n  /**\n   * Primary field; readonly; must be created and auto incremented on db side.\n   */\n  // @primaryField({\n  //   description: 'ID',\n  //   help: 'Identifiant primaire',\n  // })\n  public id!: number;\n  private readonly _F: DataModelFields;\n\n  /**\n   * Constructor for data model instance.\n   * A matching collection can be provided.\n   * ___fields readonly property is also populated from Reflected metadata\n   *\n   * @param _coll collection used for CRUD, etc..\n   */\n  constructor(protected _coll?: Collection<any>) {\n    const md: Map<string, IFieldStoredMetadata<any>> | undefined =\n      Reflect.getMetadata(PROPERTY_METADATA_KEY, this);\n    // istanbul ignore if\n    if (!md) {\n      // This should never occur as all datamodel have at least id field\n      throw new Error(\n        'No property metadata found for this object; is there a property in current collection ?'\n      );\n    }\n    // Get all fields from current class and its parents\n    const fields = new Map<string, IFieldStoredMetadata<any>>();\n    let parent = Object.getPrototypeOf(this);\n    while (parent.constructor.name !== 'Object') {\n      for (const f of md.keys()) {\n        const fieldName = f.split('__')[1];\n        if (fields.has(fieldName)) {\n          continue;\n        }\n        if (f.indexOf(parent.constructor.__name + '__') === 0) {\n          fields.set(fieldName, md.get(f)!);\n        }\n      }\n      parent = Object.getPrototypeOf(parent);\n    }\n    this._F = Object.freeze(fields);\n  }\n\n  public get _collection(): Collection<any> {\n    return this._coll as Collection<any>;\n  }\n\n  public set _collection(coll: Collection<any>) {\n    this._coll = coll;\n  }\n\n  /**\n   *  HashMap of fields metadata (type, name, manager, etc...)\n   */\n  public get F(): DataModelFields {\n    // istanbul ignore if\n    if (!this._F) {\n      throw new Error('Invalid data model, fields metadata is missing');\n    }\n    return this._F;\n  }\n\n  // Return field names iterator\n  public get FN(): IterableIterator<string> {\n    return this.F.keys();\n  }\n\n  /**\n   * Loads model data from json.\n   * If partial is true, only fields with matching data keys will be loaded\n   * @param data\n   * @param options\n   */\n  public fromJson(\n    data: { [index: string]: any },\n    { partial, check }: { partial?: boolean; check?: boolean } = {\n      partial: false,\n      check: false,\n    }\n  ): null | ValidationErrors {\n    const errors: { [index: string]: null | ValidationErrors } = {};\n    let haveError = false;\n    for (const f of this.FN) {\n      if (!partial || (partial && Object.keys(data).indexOf(f) !== -1)) {\n        const ferr = this.setFV(f, this.FM(f).fromJson(data[f]), check);\n        if (ferr !== null) {\n          errors[f] = ferr;\n          haveError = true;\n        }\n      }\n    }\n    return haveError ? errors : null;\n  }\n\n  public toJson(fields?: string | string[]): any {\n    if (fields && !Array.isArray(fields)) {\n      fields = [fields];\n    }\n    const out: { [index: string]: any } = {};\n    const fl = this.F;\n    for (const f of this.FN) {\n      const mgr = this.FM(f);\n      if (!fields || fields.length === 0) {\n        if (mgr.readonly) {\n          continue;\n        }\n        out[f] = fl.get(f)!.manager.toJson(this.FV(f));\n      } else {\n        if (fields.indexOf(f) !== -1) {\n          out[f] = fl.get(f)!.manager.toJson(this.FV(f));\n        }\n      }\n    }\n    return out;\n  }\n\n  public action<T, RT extends { [index: string]: any }>(\n    method: 'POST' | 'PATCH' | 'GET' | 'DELETE' | 'PUT',\n    name: string,\n    {\n      body = undefined,\n      update = false,\n      updatePartial = true,\n      updateCheck = false,\n      // updateRaise = false,\n      params = {},\n      headers = {},\n    }: {\n      body?: { [_index: string]: any };\n      update?: boolean;\n      updatePartial?: boolean;\n      updateCheck?: boolean;\n      // updateRaise?: boolean;\n      params?: { [_index: string]: string };\n      headers?: { [_index: string]: string };\n    } = {}\n  ): Observable<RT> {\n    if (this._coll === undefined) {\n      return throwError(() => new Error('Missing collection'));\n    }\n    return this._coll\n      .action<RT>(this, method, name, {\n        body,\n        params,\n        headers,\n      })\n      .pipe(\n        tap((result) => {\n          if (update) {\n            this.fromJson(result, {\n              partial: updatePartial,\n              check: updateCheck,\n            });\n            return this;\n          }\n          return result;\n        })\n      );\n  }\n\n  // Called on model, returns the manager for a field.\n  public FM<FT>(field: string): BaseFieldManager<FT> {\n    if (this.F.has(field)) {\n      return this.F.get(field)!.manager;\n    }\n    throw new Error(\n      `${field} not found in ${Object.keys(this.F).join(',')} model ${this}`\n    );\n  }\n\n  // Return field value, without typing\n  public FV<FT>(field: string): FT {\n    return (this as any)[field] as FT;\n  }\n\n  /**\n   * Set field value. If check is true, only set value if all validators pass.\n   *\n   * The validation result is returned.\n   *\n   * @param field field name\n   * @param value field valued\n   * @param check default false\n   * @return null or ValidationError\n   */\n  public setFV<FT>(\n    field: string,\n    value: FT,\n    check: boolean = false\n  ): null | ValidationErrors {\n    if (check) {\n      const fc = new FormControl(value);\n\n      for (const v of this.FM(field).validators) {\n        const val = v(fc);\n        if (val !== null) {\n          console.error(val);\n          return val;\n        }\n      }\n    }\n    (this as any)[field] = value;\n    return null;\n  }\n\n  // Called on model with a list of fields, returns a FormGroup with\n  // these fields, or only the form control for one field.\n  public FC(): FormGroup;\n  public FC(field: string): FormControl;\n  public FC(field: string[]): FormGroup;\n  public FC(field?: string | string[]): FormControl | FormGroup {\n    if (field === undefined) {\n      field = Array.from(this.FN).filter((n) => !this.FM(n).readonly);\n    }\n    if (Array.isArray(field)) {\n      const fg: { [index: string]: FormControl } = {};\n      for (const f of field) {\n        fg[f] = this.FC(f) as FormControl;\n      }\n      return new FormGroup(fg);\n    }\n    return this.FM(field).formControl(this);\n  }\n\n  public save(\n    { updateModel = true }: { updateModel?: boolean } = {\n      updateModel: true,\n    }\n  ): Observable<this> {\n    if (this._coll) {\n      return this._coll.save(this, { updateModel });\n    }\n    return throwError(() => new Error('Missing collection'));\n  }\n\n  public update(\n    fields: string[] = [],\n    { updateModel = true }: { updateModel?: boolean } = {\n      updateModel: true,\n    }\n  ): Observable<this> {\n    if (this._coll) {\n      return this._coll.update(this, fields, { updateModel });\n    }\n    return throwError(() => new Error('Missing collection'));\n  }\n}\n\n//\n// export class TreeDataModel extends DataModel {\n//   static override __name = 'TreeDataModel';\n//   @detailsField({\n//     model: this,\n//     many: true,\n//     description: 'Parents',\n//   })\n//   public parents_details?: this[];\n//\n//   @foreignKeyField({\n//     required: false,\n//     description: 'Structure parente',\n//     related: 'Structure',\n//   })\n//   public parent?: number;\n//\n//   @integerField({\n//     required: false,\n//     readonly: true,\n//     description: 'ID Tree',\n//   })\n//   public tree_id!: number;\n//\n//   @integerField({\n//     required: false,\n//     readonly: true,\n//     description: 'MPTT left',\n//   })\n//   public lft!: number;\n//\n//   @integerField({\n//     required: false,\n//     readonly: true,\n//     description: 'MPTT right',\n//   })\n//   public rght!: number;\n//\n//   @integerField({\n//     required: false,\n//     readonly: true,\n//     description: 'Niveau hiérarchique',\n//   })\n//   public level!: number;\n//\n//   public get parent_details(): this | null {\n//     if (this.parents_details) {\n//       const out = this.parents_details[this.parents_details.length - 1];\n//       out.parents_details = this.parents_details.slice(\n//         0,\n//         this.parents_details.length - 1\n//       );\n//       return out;\n//     }\n//     return null;\n//   }\n//\n//   public set parent_details(d: this | null) {\n//     console.log(d);\n//     this.parents_details = d?.parents_details;\n//   }\n//\n//   public _display(): string {\n//     const out: string[] = [];\n//     if (this.parents_details) {\n//       for (const p of this.parents_details) {\n//         if ((p as any).code) {\n//           out.push(`[${(p as any).code}] ${(p as any).name}`);\n//         } else {\n//           out.push((p as any).name);\n//         }\n//       }\n//     }\n//     if ((this as any).code) {\n//       out.push(`[${(this as any).code}] ${(this as any).name}`);\n//     } else {\n//       out.push((this as any).name);\n//     }\n//\n//     return out.join(' : ');\n//   }\n// }\n"]}

package/esm2020/lib/data/data-parameters.mjs

@@ -0,0 +1,34 @@
+import { InjectionToken } from "@angular/core";
+/**
+ * DATA_API_URL: stores data api base url
+ */
+export const DATA_API_URL = new InjectionToken("data.api.url");
+/**
+ * DATA_MAX_TRANSFERSTATE_TIME: max duration to use transferstate time
+ * If DATA_MAX_TRANSFERSTATE_TIME is zero, TransferState is not used
+ */
+export const DATA_MAX_TRANSFERSTATE_TIME = new InjectionToken("data.max.transfer.state");
+export const BootstrapDataDisplayConfig = {
+    dispEdit: {
+        defaultMode: "dd",
+        inputClasses: {
+            "input.text": "form-control",
+            "input.email": "form-control",
+            "input.datetime": "form-control",
+            "input.date": "form-control",
+            "input.number": "form-control",
+            "input.decimal": "form-control",
+            "input.checkbox": "form-control",
+            "input.password": "form-control",
+            "textarea": "form-control",
+            "quill": "",
+            "fkselect": "form-control",
+            "select": "form-select"
+        },
+    }
+};
+/**
+ * DATA_DISPLAY_CONFIG: display config & default classes injection token
+ */
+export const DATA_DISPLAY_CONFIG = new InjectionToken("data.display.config");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1wYXJhbWV0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGF0YS9zcmMvbGliL2RhdGEvZGF0YS1wYXJhbWV0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQVMsY0FBYyxDQUFDLENBQUM7QUFDdkU7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQVMseUJBQXlCLENBQUMsQ0FBQztBQVlqRyxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBc0I7SUFDM0QsUUFBUSxFQUFFO1FBQ1IsV0FBVyxFQUFFLElBQUk7UUFDakIsWUFBWSxFQUFFO1lBQ1osWUFBWSxFQUFFLGNBQWM7WUFDNUIsYUFBYSxFQUFFLGNBQWM7WUFDN0IsZ0JBQWdCLEVBQUUsY0FBYztZQUNoQyxZQUFZLEVBQUUsY0FBYztZQUM1QixjQUFjLEVBQUUsY0FBYztZQUM5QixlQUFlLEVBQUUsY0FBYztZQUMvQixnQkFBZ0IsRUFBRSxjQUFjO1lBQ2hDLGdCQUFnQixFQUFDLGNBQWM7WUFDL0IsVUFBVSxFQUFFLGNBQWM7WUFDMUIsT0FBTyxFQUFFLEVBQUU7WUFDWCxVQUFVLEVBQUUsY0FBYztZQUMxQixRQUFRLEVBQUUsYUFBYTtTQUN4QjtLQUNGO0NBQ0YsQ0FBQztBQUdGOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQW9CLHFCQUFxQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG4vKipcbiAqIERBVEFfQVBJX1VSTDogc3RvcmVzIGRhdGEgYXBpIGJhc2UgdXJsXG4gKi9cbmV4cG9ydCBjb25zdCBEQVRBX0FQSV9VUkwgPSBuZXcgSW5qZWN0aW9uVG9rZW48c3RyaW5nPihcImRhdGEuYXBpLnVybFwiKTtcbi8qKlxuICogREFUQV9NQVhfVFJBTlNGRVJTVEFURV9USU1FOiBtYXggZHVyYXRpb24gdG8gdXNlIHRyYW5zZmVyc3RhdGUgdGltZVxuICogSWYgREFUQV9NQVhfVFJBTlNGRVJTVEFURV9USU1FIGlzIHplcm8sIFRyYW5zZmVyU3RhdGUgaXMgbm90IHVzZWRcbiAqL1xuZXhwb3J0IGNvbnN0IERBVEFfTUFYX1RSQU5TRkVSU1RBVEVfVElNRSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxudW1iZXI+KFwiZGF0YS5tYXgudHJhbnNmZXIuc3RhdGVcIik7XG5cbi8qKlxuICogRGF0YURpc3BsYXlDb25maWcgaW50ZXJmYWNlIHByb3ZpZGVzIGRlZmF1bHQgdmFsdWVzIGZvciBkaXNwbGF5IGNsYXNzZXNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEYXRhRGlzcGxheUNvbmZpZyB7XG4gIGRpc3BFZGl0OiB7XG4gICAgZGVmYXVsdE1vZGU6IFwiaW5saW5lXCIgfCBcImRkXCI7XG4gICAgaW5wdXRDbGFzc2VzOiB7W2luZGV4OiBzdHJpbmddOiBzdHJpbmd9O1xuICB9O1xufVxuXG5leHBvcnQgY29uc3QgQm9vdHN0cmFwRGF0YURpc3BsYXlDb25maWc6IERhdGFEaXNwbGF5Q29uZmlnID0ge1xuICBkaXNwRWRpdDoge1xuICAgIGRlZmF1bHRNb2RlOiBcImRkXCIsXG4gICAgaW5wdXRDbGFzc2VzOiB7XG4gICAgICBcImlucHV0LnRleHRcIjogXCJmb3JtLWNvbnRyb2xcIixcbiAgICAgIFwiaW5wdXQuZW1haWxcIjogXCJmb3JtLWNvbnRyb2xcIixcbiAgICAgIFwiaW5wdXQuZGF0ZXRpbWVcIjogXCJmb3JtLWNvbnRyb2xcIixcbiAgICAgIFwiaW5wdXQuZGF0ZVwiOiBcImZvcm0tY29udHJvbFwiLFxuICAgICAgXCJpbnB1dC5udW1iZXJcIjogXCJmb3JtLWNvbnRyb2xcIixcbiAgICAgIFwiaW5wdXQuZGVjaW1hbFwiOiBcImZvcm0tY29udHJvbFwiLFxuICAgICAgXCJpbnB1dC5jaGVja2JveFwiOiBcImZvcm0tY29udHJvbFwiLFxuICAgICAgXCJpbnB1dC5wYXNzd29yZFwiOlwiZm9ybS1jb250cm9sXCIsXG4gICAgICBcInRleHRhcmVhXCI6IFwiZm9ybS1jb250cm9sXCIsXG4gICAgICBcInF1aWxsXCI6IFwiXCIsXG4gICAgICBcImZrc2VsZWN0XCI6IFwiZm9ybS1jb250cm9sXCIsXG4gICAgICBcInNlbGVjdFwiOiBcImZvcm0tc2VsZWN0XCJcbiAgICB9LFxuICB9XG59O1xuXG5cbi8qKlxuICogREFUQV9ESVNQTEFZX0NPTkZJRzogZGlzcGxheSBjb25maWcgJiBkZWZhdWx0IGNsYXNzZXMgaW5qZWN0aW9uIHRva2VuXG4gKi9cbmV4cG9ydCBjb25zdCBEQVRBX0RJU1BMQVlfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPERhdGFEaXNwbGF5Q29uZmlnPihcImRhdGEuZGlzcGxheS5jb25maWdcIik7XG4iXX0=

package/esm2020/lib/data/data-query.mjs

@@ -0,0 +1,147 @@
+import { combineLatest, ReplaySubject, share, } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+export class Queryset {
+    constructor(_coll, options = {}) {
+        this._coll = _coll;
+        /** Current filter data */
+        this.filterData = {};
+        /** Current sorter data */
+        this.sortData = [];
+        /** Current fields */
+        this.fields = [];
+        /** Current page size */
+        this.pageSize = 500;
+        /** Current page number */
+        this.page = 1;
+        this._pristine = true;
+        this._loading = new ReplaySubject(1);
+        this._meta = new ReplaySubject(1);
+        this._results = new ReplaySubject(1);
+        /** Default options */
+        this.options = { emitFields: true };
+        Object.assign(this.options, options);
+    }
+    /** Pristine status (true if it has not collected results yet) */
+    get pristine() {
+        return this._pristine;
+    }
+    /** Loading status (true if currently fetching data) */
+    get loading() {
+        return this._loading.asObservable();
+    }
+    /** Results meta part observable */
+    get meta() {
+        return this._meta.asObservable();
+    }
+    /** Results data part observable */
+    get results() {
+        return this._results.asObservable();
+    }
+    /** Full results observable (results, loading, meta) */
+    get full() {
+        if (!this._full) {
+            this._full = combineLatest([this.results, this.loading, this.meta]);
+        }
+        return this._full.pipe(share());
+    }
+    /**
+     * Update current filter data. Null or undefined values are removed from filter data.
+     * @param params filter data
+     * @param update boolean to update filter data instead of recreating it from scratch
+     */
+    filter(params = {}, update = false) {
+        if (!update) {
+            this.filterData = {};
+        }
+        for (const k of Object.keys(params)) {
+            if (params[k] === undefined || params[k] === null) {
+                delete this.filterData[k];
+            }
+            else {
+                this.filterData[k] = params[k];
+            }
+        }
+        return this;
+    }
+    /**
+     * Update sorting parameters, list of strings giving sort parameters e.g. sort("+name", "-id").
+     * @param sorting strings of sort parameters
+     */
+    sort(...sorting) {
+        this.sortData = sorting;
+        return this;
+    }
+    /**
+     * Update page size.
+     * @param pageSize required page size
+     */
+    paginateBy(pageSize = 20) {
+        this.pageSize = pageSize;
+        return this;
+    }
+    /**
+     * Update current page number.
+     * @param page required pqge
+     * @param fragment TODO: fragment usage for router usage
+     */
+    setPage(page = 1, fragment) {
+        if (page !== this.page) {
+            this.page = page;
+            // if (this.options.router) {
+            //   // TODO: check and fix usage of fragment/query params
+            //   const frag = fragment
+            //     ? fragment
+            //     : this.options.hash || this.options.name;
+            //   const _ = this.options.router.navigate([], {
+            //     queryParams: { page: page.toString() },
+            //     fragment: frag,
+            //     queryParamsHandling: 'merge',
+            //   });
+            // }
+        }
+        return this;
+    }
+    setFields(fields) {
+        this.fields = fields;
+        return this;
+    }
+    getQueryParams() {
+        const f = {};
+        Object.assign(f, this.filterData);
+        if (this.sortData.length) {
+            f['ordering'] = this.sortData.join(',');
+        }
+        f['page_size'] = this.pageSize;
+        f['page'] = this.page;
+        if (this.options.emitFields && this.fields.length) {
+            f['fields'] = this.fields.join(',');
+        }
+        return f;
+    }
+    get(refresh = true) {
+        console.log('queryset:get', this, refresh);
+        if (!refresh && !this._pristine) {
+            return this.results;
+        }
+        this._loading.next(true);
+        return this._coll
+            .raw({
+            method: 'GET',
+            params: this.getQueryParams(),
+        })
+            .pipe(switchMap((result) => {
+            // Process results
+            this._meta.next({ nav: result.nav, parameters: result.parameters });
+            const out = [];
+            for (const r of result.results) {
+                const m = this._coll.fromJson(r);
+                out.push(m);
+            }
+            this._pristine = false;
+            this._loading.next(false);
+            this._results.next(out);
+            return this.results;
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-query.js","sourceRoot":"","sources":["../../../../../projects/data/src/lib/data/data-query.ts"],"names":[],"mappings":"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","sourcesContent":["import { Collection } from './data-collection';\nimport { DataModel } from './data-model';\nimport {\n  combineLatest,\n  firstValueFrom,\n  Observable,\n  ReplaySubject,\n  share,\n} from 'rxjs';\nimport { first, switchMap } from 'rxjs/operators';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nexport interface FilterData {\n  [index: string]: string | number | boolean | undefined | null;\n}\n\nexport type SortData = string;\n\n/**\n * Queryset parameters\n */\nexport interface IQuerysetOptions {\n  /** Emit fields list */\n  emitFields?: boolean;\n  /** Queryset name */\n  name?: string;\n  /** TODO: see usage */\n  route?: ActivatedRoute;\n  /** TODO: see usage */\n  router?: Router;\n  /** TODO: see usage */\n  hash?: string;\n}\n\nexport interface IQueryNav {\n  page: number;\n  page_size: number;\n}\n\nexport interface IQueryMetaNav {\n  count: number;\n  next: number | null;\n  page: number;\n  pages: number;\n  prev: number | null;\n  size: number;\n}\n\nexport interface IQueryMetaNavParams {\n  page: string;\n  page_size: string;\n}\n\nexport interface IQueryMeta {\n  nav: IQueryMetaNav;\n  parameters: IQueryMetaNavParams;\n}\n\nexport interface IQueryFullResponse<T> extends IQueryMeta {\n  results: T[];\n}\n\nexport class Queryset<T extends DataModel> {\n  /** Current filter data */\n  public filterData: FilterData = {};\n  /** Current sorter data */\n  public sortData: SortData[] = [];\n  /** Current fields */\n  public fields: string[] = [];\n  /** Current page size */\n  public pageSize = 500;\n  /** Current page number */\n  public page = 1;\n\n  public options: IQuerysetOptions;\n  constructor(protected _coll: Collection<T>, options: IQuerysetOptions = {}) {\n    /** Default options */\n    this.options = { emitFields: true };\n    Object.assign(this.options, options);\n  }\n\n  private _pristine = true;\n  /** Pristine status (true if it has not collected results yet) */\n  public get pristine(): boolean {\n    return this._pristine;\n  }\n\n  private _loading = new ReplaySubject<boolean>(1);\n  /** Loading status (true if currently fetching data) */\n  public get loading(): Observable<boolean> {\n    return this._loading.asObservable();\n  }\n\n  private _meta = new ReplaySubject<IQueryMeta>(1);\n  /** Results meta part observable */\n  public get meta(): Observable<IQueryMeta> {\n    return this._meta.asObservable();\n  }\n\n  private _results = new ReplaySubject<T[]>(1);\n  /** Results data part observable */\n  public get results(): Observable<T[]> {\n    return this._results.asObservable();\n  }\n\n  private _full?: Observable<[T[], boolean, IQueryMeta]>;\n  /** Full results observable (results, loading, meta) */\n  public get full(): Observable<[T[], boolean, IQueryMeta]> {\n    if (!this._full) {\n      this._full = combineLatest([this.results, this.loading, this.meta]);\n    }\n    return this._full.pipe(share());\n  }\n\n  /**\n   * Update current filter data. Null or undefined values are removed from filter data.\n   * @param params filter data\n   * @param update boolean to update filter data instead of recreating it from scratch\n   */\n  public filter(params: FilterData = {}, update: boolean = false): Queryset<T> {\n    if (!update) {\n      this.filterData = {};\n    }\n    for (const k of Object.keys(params)) {\n      if (params[k] === undefined || params[k] === null) {\n        delete this.filterData[k];\n      } else {\n        this.filterData[k] = params[k];\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Update sorting parameters, list of strings giving sort parameters e.g. sort(\"+name\", \"-id\").\n   * @param sorting strings of sort parameters\n   */\n  public sort(...sorting: string[]): Queryset<T> {\n    this.sortData = sorting;\n    return this;\n  }\n\n  /**\n   * Update page size.\n   * @param pageSize required page size\n   */\n  public paginateBy(pageSize: number = 20): Queryset<T> {\n    this.pageSize = pageSize;\n    return this;\n  }\n\n  /**\n   * Update current page number.\n   * @param page required pqge\n   * @param fragment TODO: fragment usage for router usage\n   */\n  public setPage(page: number = 1, fragment?: string): Queryset<T> {\n    if (page !== this.page) {\n      this.page = page;\n      // if (this.options.router) {\n      //   // TODO: check and fix usage of fragment/query params\n      //   const frag = fragment\n      //     ? fragment\n      //     : this.options.hash || this.options.name;\n      //   const _ = this.options.router.navigate([], {\n      //     queryParams: { page: page.toString() },\n      //     fragment: frag,\n      //     queryParamsHandling: 'merge',\n      //   });\n      // }\n    }\n    return this;\n  }\n\n  public setFields(fields: string[]): Queryset<T> {\n    this.fields = fields;\n    return this;\n  }\n\n  public getQueryParams(): FilterData {\n    const f: FilterData = {};\n    Object.assign(f, this.filterData);\n    if (this.sortData.length) {\n      f['ordering'] = this.sortData.join(',');\n    }\n    f['page_size'] = this.pageSize;\n    f['page'] = this.page;\n    if (this.options.emitFields && this.fields.length) {\n      f['fields'] = this.fields.join(',');\n    }\n    return f;\n  }\n\n  public get(refresh: boolean = true): Observable<T[]> {\n    console.log('queryset:get', this, refresh);\n    if (!refresh && !this._pristine) {\n      return this.results;\n    }\n    this._loading.next(true);\n    return this._coll\n      .raw<IQueryFullResponse<T>>({\n        method: 'GET',\n        params: this.getQueryParams() as any,\n      })\n      .pipe(\n        switchMap((result) => {\n          // Process results\n          this._meta.next({ nav: result.nav, parameters: result.parameters });\n          const out: T[] = [];\n          for (const r of result.results) {\n            const m = this._coll.fromJson(r);\n            out.push(m);\n          }\n          this._pristine = false;\n          this._loading.next(false);\n          this._results.next(out);\n          return this.results;\n        })\n      );\n  }\n}\n"]}

package/esm2020/lib/data/data-query.mock.mjs

@@ -0,0 +1,46 @@
+import { combineLatest, of } from "rxjs";
+export class QuerysetMock {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    constructor(_coll, options = {}) {
+        this._coll = _coll;
+        this.options = options;
+        this.mockData = [];
+        this.filterData = {};
+        this.sortData = [];
+        this.pageSize = 100;
+        this.page = 1;
+        this.pristine = true;
+        this.loading = of(false);
+    }
+    get results() {
+        return of(this.mockData || this._coll.mockValues);
+    }
+    get meta() {
+        return of({
+            nav: { count: 100, next: 1, page: 1, pages: 10, prev: null, size: 10 },
+            parameters: { page: "page", page_size: "page_size" }
+        });
+    }
+    get full() {
+        return combineLatest([this.results, this.loading, this.meta]);
+    }
+    filter(params = {}) {
+        return this;
+    }
+    sort(...sorting) {
+        return this;
+    }
+    paginateBy(pageSize = 20) {
+        return this;
+    }
+    setPage(page) {
+        return this;
+    }
+    getQueryParams() {
+        return {};
+    }
+    get() {
+        return of(this.mockData || this._coll.mockValues);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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