@mediusinc/mng-commons-data-api-class 5.0.0-rc.0

package/README.md

@@ -0,0 +1,16 @@
+# Medius Commons Data API as Class
+
+Commons Data API library for REST communication with backends built with `medius-data` v4 and pre v4 (aka Medius QueryParam).
+OpenAPI Typescript Node generator is used to generate models. 
+
+Abstract API service class are available for easier development of API services.
+
+## Namestitev
+
+```bash
+pnpm i @mediusinc/mng-commons-data-api-class
+```
+
+## Dependencies within commons
+
+- `@mediusinc/mng-commons/core`

package/esm2022/index.mjs

@@ -0,0 +1,9 @@
+// models
+export * from './lib/models/query-result.model';
+// serder
+export * from './lib/serder/object-serializer';
+// services
+export * from './lib/services/api.abstract.service';
+export * from './lib/services/crud-api.abstract.service';
+export * from './lib/services/get-all-api.abstract.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUztBQUNULGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsU0FBUztBQUNULGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MsV0FBVztBQUNYLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLDZDQUE2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gbW9kZWxzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvcXVlcnktcmVzdWx0Lm1vZGVsJztcblxuLy8gc2VyZGVyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJkZXIvb2JqZWN0LXNlcmlhbGl6ZXInO1xuXG4vLyBzZXJ2aWNlc1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvYXBpLmFic3RyYWN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvY3J1ZC1hcGkuYWJzdHJhY3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9nZXQtYWxsLWFwaS5hYnN0cmFjdC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/models/query-result.model.mjs

@@ -0,0 +1,24 @@
+export class QueryResult {
+    static fromArray(pageData, allDataCount) {
+        const mqr = new QueryResult();
+        mqr.totalCount = allDataCount ?? pageData.length;
+        mqr.data = pageData;
+        return mqr;
+    }
+    static { this.attributeTypeMap = [
+        {
+            name: 'totalCount',
+            baseName: 'totalCount',
+            type: 'number'
+        },
+        {
+            name: 'data',
+            baseName: 'data',
+            type: 'Array<T>'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return QueryResult.attributeTypeMap;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktcmVzdWx0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9tb2RlbHMvcXVlcnktcmVzdWx0Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxXQUFXO0lBTXBCLE1BQU0sQ0FBQyxTQUFTLENBQU8sUUFBZ0IsRUFBRSxZQUFxQjtRQUMxRCxNQUFNLEdBQUcsR0FBRyxJQUFJLFdBQVcsRUFBUSxDQUFDO1FBQ3BDLEdBQUcsQ0FBQyxVQUFVLEdBQUcsWUFBWSxJQUFJLFFBQVEsQ0FBQyxNQUFNLENBQUM7UUFDakQsR0FBRyxDQUFDLElBQUksR0FBRyxRQUFRLENBQUM7UUFDcEIsT0FBTyxHQUFHLENBQUM7SUFDZixDQUFDO2FBRU0scUJBQWdCLEdBQTZCO1FBQ2hEO1lBQ0ksSUFBSSxFQUFFLFlBQVk7WUFDbEIsUUFBUSxFQUFFLFlBQVk7WUFDdEIsSUFBSSxFQUFFLFFBQVE7U0FDakI7UUFDRDtZQUNJLElBQUksRUFBRSxNQUFNO1lBQ1osUUFBUSxFQUFFLE1BQU07WUFDaEIsSUFBSSxFQUFFLFVBQVU7U0FDbkI7S0FDSixDQUFDO0lBRUYsTUFBTSxDQUFDLG1CQUFtQjtRQUN0QixPQUFPLFdBQVcsQ0FBQyxnQkFBZ0IsQ0FBQztJQUN4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDbGFzc0F0dHJpYnV0ZURlZn0gZnJvbSAnQG1lZGl1c2luYy9tbmctY29tbW9ucy9jb3JlJztcblxuZXhwb3J0IGNsYXNzIFF1ZXJ5UmVzdWx0PEl0ZW0+IGltcGxlbWVudHMgSU1lZGl1c1F1ZXJ5UmVzdWx0VjI8SXRlbT4ge1xuICAgIHRvdGFsQ291bnQ/OiBudW1iZXI7XG4gICAgZGF0YT86IEFycmF5PEl0ZW0+O1xuXG4gICAgc3RhdGljIGRpc2NyaW1pbmF0b3I/OiBzdHJpbmc7XG5cbiAgICBzdGF0aWMgZnJvbUFycmF5PEl0ZW0+KHBhZ2VEYXRhOiBJdGVtW10sIGFsbERhdGFDb3VudD86IG51bWJlcikge1xuICAgICAgICBjb25zdCBtcXIgPSBuZXcgUXVlcnlSZXN1bHQ8SXRlbT4oKTtcbiAgICAgICAgbXFyLnRvdGFsQ291bnQgPSBhbGxEYXRhQ291bnQgPz8gcGFnZURhdGEubGVuZ3RoO1xuICAgICAgICBtcXIuZGF0YSA9IHBhZ2VEYXRhO1xuICAgICAgICByZXR1cm4gbXFyO1xuICAgIH1cblxuICAgIHN0YXRpYyBhdHRyaWJ1dGVUeXBlTWFwOiBBcnJheTxDbGFzc0F0dHJpYnV0ZURlZj4gPSBbXG4gICAgICAgIHtcbiAgICAgICAgICAgIG5hbWU6ICd0b3RhbENvdW50JyxcbiAgICAgICAgICAgIGJhc2VOYW1lOiAndG90YWxDb3VudCcsXG4gICAgICAgICAgICB0eXBlOiAnbnVtYmVyJ1xuICAgICAgICB9LFxuICAgICAgICB7XG4gICAgICAgICAgICBuYW1lOiAnZGF0YScsXG4gICAgICAgICAgICBiYXNlTmFtZTogJ2RhdGEnLFxuICAgICAgICAgICAgdHlwZTogJ0FycmF5PFQ+J1xuICAgICAgICB9XG4gICAgXTtcblxuICAgIHN0YXRpYyBnZXRBdHRyaWJ1dGVUeXBlTWFwKCkge1xuICAgICAgICByZXR1cm4gUXVlcnlSZXN1bHQuYXR0cmlidXRlVHlwZU1hcDtcbiAgICB9XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSU1lZGl1c1F1ZXJ5UmVzdWx0VjI8SXRlbT4ge1xuICAgIHRvdGFsQ291bnQ/OiBudW1iZXI7XG4gICAgZGF0YT86IEFycmF5PEl0ZW0+O1xufVxuIl19

package/esm2022/lib/serder/object-serializer.mjs

@@ -0,0 +1,184 @@
+import { DateUtil, TypeRegistry, findReflectTypeName } from '@mediusinc/mng-commons/core';
+export class ObjectSerializer {
+    constructor() {
+        this._logCategory = 'ObjectSerializer';
+        this._primitives = ['string', 'boolean', 'double', 'integer', 'long', 'float', 'number', 'any'];
+        this.dateTimeInUtc = false;
+        this.dateTimeWithTimezone = true;
+        this.dateTimeWithMillis = true;
+    }
+    static { this._instance = new ObjectSerializer(); }
+    get primitives() {
+        return this._primitives;
+    }
+    /**
+     * Only use one instance of object (out of Angular context)
+     */
+    static get() {
+        return ObjectSerializer._instance;
+    }
+    configure(config) {
+        if (config.dateTimeInUtc !== undefined) {
+            this.dateTimeInUtc = config.dateTimeInUtc;
+        }
+        if (config.dateTimeWithTimezone !== undefined) {
+            this.dateTimeWithTimezone = config.dateTimeWithTimezone;
+        }
+        if (config.dateTimeWithMillis !== undefined) {
+            this.dateTimeWithMillis = config.dateTimeWithMillis;
+        }
+    }
+    findCorrectType(data, expectedTypeName) {
+        if (data == undefined) {
+            return expectedTypeName;
+        }
+        else if (this._primitives.indexOf(expectedTypeName.toLowerCase()) !== -1) {
+            return expectedTypeName;
+        }
+        else if (expectedTypeName === 'Date') {
+            return expectedTypeName;
+        }
+        else {
+            const enumType = TypeRegistry.get().findEnum(expectedTypeName);
+            if (enumType) {
+                return expectedTypeName;
+            }
+            const type = TypeRegistry.get().findType(expectedTypeName);
+            if (!type) {
+                return expectedTypeName; // w/e we don't know the type
+            }
+            // Check the discriminator
+            const discriminatorProperty = type.discriminator;
+            if (discriminatorProperty == null) {
+                return expectedTypeName; // the type does not have a discriminator. use it.
+            }
+            else {
+                if (data[discriminatorProperty]) {
+                    const discriminatorType = data[discriminatorProperty];
+                    const type = TypeRegistry.get().findType(expectedTypeName);
+                    if (type) {
+                        return discriminatorType; // use the type given in the discriminator
+                    }
+                    else {
+                        return expectedTypeName; // discriminator did not map to a type
+                    }
+                }
+                else {
+                    return expectedTypeName; // discriminator was not present (or an empty string)
+                }
+            }
+        }
+    }
+    serializeClass(data, type) {
+        return this.serialize(data, findReflectTypeName(type) ?? undefined);
+    }
+    serializeClassArray(data, type) {
+        return this.serialize(data, `Array<${findReflectTypeName(type)}>`);
+    }
+    serialize(data, typeName, subtype) {
+        if (data == undefined) {
+            return data;
+        }
+        else if (typeName && this._primitives.indexOf(typeName.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (typeName && typeName.lastIndexOf('Array<', 0) === 0) {
+            // string.startsWith pre es6
+            let subType = typeName.replace('Array<', ''); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            const transformedData = [];
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < data.length; index++) {
+                const datum = data[index];
+                transformedData.push(this.serialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (typeName === 'Date') {
+            const dateOnly = subtype?.toLowerCase() === 'date';
+            return DateUtil.toIsoString(data, dateOnly ? 'date' : 'date-time', {
+                utc: this.dateTimeInUtc,
+                noTimezone: !this.dateTimeWithTimezone,
+                noMillis: !this.dateTimeWithMillis
+            });
+        }
+        else if (typeName) {
+            const enumType = TypeRegistry.get().findEnum(typeName);
+            if (enumType) {
+                return data;
+            }
+            const type = TypeRegistry.get().findType(typeName);
+            if (!type) {
+                // in case we dont know the type
+                return data;
+            }
+            // Get the actual type of this object
+            const correctedTypeName = this.findCorrectType(data, typeName);
+            const correctedType = TypeRegistry.get().findType(correctedTypeName);
+            // get the map for the correct type.
+            const attributeTypes = correctedType.getAttributeTypeMap();
+            const instance = {};
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < attributeTypes.length; index++) {
+                const attributeType = attributeTypes[index];
+                instance[attributeType.baseName] = this.serialize(data[attributeType.name], attributeType.type, attributeType.subtype);
+            }
+            return instance;
+        }
+        else {
+            return data;
+        }
+    }
+    deserializeClass(data, type) {
+        return this.deserialize(data, findReflectTypeName(type) ?? undefined);
+    }
+    deserializeClassArray(data, type) {
+        return this.deserialize(data, `Array<${findReflectTypeName(type)}>`);
+    }
+    deserialize(data, type) {
+        // polymorphism may change the actual type.
+        if (data == undefined || !type) {
+            return data;
+        }
+        const correctedTypeName = this.findCorrectType(data, type);
+        if (this._primitives.indexOf(correctedTypeName.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (correctedTypeName.lastIndexOf('Array<', 0) === 0) {
+            // string.startsWith pre es6
+            let subType = correctedTypeName.replace('Array<', ''); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            const transformedData = [];
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < data.length; index++) {
+                const datum = data[index];
+                transformedData.push(this.deserialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (correctedTypeName === 'Date') {
+            return new Date(data);
+        }
+        else {
+            const enumType = TypeRegistry.get().findEnum(correctedTypeName);
+            if (enumType) {
+                // is Enum
+                return data;
+            }
+            const correctedType = TypeRegistry.get().findType(correctedTypeName);
+            if (!correctedType) {
+                // dont know the type
+                return data;
+            }
+            const instance = new correctedType();
+            const attributeTypes = correctedType.getAttributeTypeMap();
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < attributeTypes.length; index++) {
+                const attributeType = attributeTypes[index];
+                instance[attributeType.name] = this.deserialize(data[attributeType.baseName], attributeType.type);
+            }
+            return instance;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-serializer.js","sourceRoot":"","sources":["../../../../src/lib/serder/object-serializer.ts"],"names":[],"mappings":"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","sourcesContent":["import {ClassAttributeDef, ClassType, DateUtil, TypeRegistry, findReflectTypeName} from '@mediusinc/mng-commons/core';\n\nexport class ObjectSerializer {\n    private static _instance: ObjectSerializer = new ObjectSerializer();\n    private readonly _logCategory = 'ObjectSerializer';\n    private readonly _primitives: string[] = ['string', 'boolean', 'double', 'integer', 'long', 'float', 'number', 'any'];\n\n    private dateTimeInUtc = false;\n    private dateTimeWithTimezone = true;\n    private dateTimeWithMillis = true;\n\n    public get primitives() {\n        return this._primitives;\n    }\n\n    /**\n     * Only use one instance of object (out of Angular context)\n     */\n    public static get(): ObjectSerializer {\n        return ObjectSerializer._instance;\n    }\n\n    public configure(config: {dateTimeInUtc?: boolean; dateTimeWithTimezone?: boolean; dateTimeWithMillis?: boolean}): void {\n        if (config.dateTimeInUtc !== undefined) {\n            this.dateTimeInUtc = config.dateTimeInUtc;\n        }\n        if (config.dateTimeWithTimezone !== undefined) {\n            this.dateTimeWithTimezone = config.dateTimeWithTimezone;\n        }\n        if (config.dateTimeWithMillis !== undefined) {\n            this.dateTimeWithMillis = config.dateTimeWithMillis;\n        }\n    }\n\n    public findCorrectType(data: any, expectedTypeName: string): string {\n        if (data == undefined) {\n            return expectedTypeName;\n        } else if (this._primitives.indexOf(expectedTypeName.toLowerCase()) !== -1) {\n            return expectedTypeName;\n        } else if (expectedTypeName === 'Date') {\n            return expectedTypeName;\n        } else {\n            const enumType = TypeRegistry.get().findEnum(expectedTypeName);\n            if (enumType) {\n                return expectedTypeName;\n            }\n\n            const type = TypeRegistry.get().findType(expectedTypeName);\n            if (!type) {\n                return expectedTypeName; // w/e we don't know the type\n            }\n\n            // Check the discriminator\n            const discriminatorProperty = type.discriminator;\n            if (discriminatorProperty == null) {\n                return expectedTypeName; // the type does not have a discriminator. use it.\n            } else {\n                if (data[discriminatorProperty]) {\n                    const discriminatorType = data[discriminatorProperty];\n                    const type = TypeRegistry.get().findType(expectedTypeName);\n                    if (type) {\n                        return discriminatorType; // use the type given in the discriminator\n                    } else {\n                        return expectedTypeName; // discriminator did not map to a type\n                    }\n                } else {\n                    return expectedTypeName; // discriminator was not present (or an empty string)\n                }\n            }\n        }\n    }\n\n    public serializeClass<T>(data: T, type: ClassType<T>) {\n        return this.serialize(data, findReflectTypeName(type) ?? undefined);\n    }\n\n    public serializeClassArray<T>(data: Array<T>, type: ClassType<T>) {\n        return this.serialize(data, `Array<${findReflectTypeName(type)}>`);\n    }\n\n    public serialize(data: any, typeName?: string, subtype?: string) {\n        if (data == undefined) {\n            return data;\n        } else if (typeName && this._primitives.indexOf(typeName.toLowerCase()) !== -1) {\n            return data;\n        } else if (typeName && typeName.lastIndexOf('Array<', 0) === 0) {\n            // string.startsWith pre es6\n            let subType: string = typeName.replace('Array<', ''); // Array<Type> => Type>\n            subType = subType.substring(0, subType.length - 1); // Type> => Type\n            const transformedData: any[] = [];\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < data.length; index++) {\n                const datum = data[index];\n                transformedData.push(this.serialize(datum, subType));\n            }\n            return transformedData;\n        } else if (typeName === 'Date') {\n            const dateOnly = subtype?.toLowerCase() === 'date';\n            return DateUtil.toIsoString(data, dateOnly ? 'date' : 'date-time', {\n                utc: this.dateTimeInUtc,\n                noTimezone: !this.dateTimeWithTimezone,\n                noMillis: !this.dateTimeWithMillis\n            });\n        } else if (typeName) {\n            const enumType = TypeRegistry.get().findEnum(typeName);\n            if (enumType) {\n                return data;\n            }\n\n            const type = TypeRegistry.get().findType(typeName);\n            if (!type) {\n                // in case we dont know the type\n                return data;\n            }\n\n            // Get the actual type of this object\n            const correctedTypeName = this.findCorrectType(data, typeName);\n            const correctedType = TypeRegistry.get().findType(correctedTypeName);\n\n            // get the map for the correct type.\n            const attributeTypes = correctedType.getAttributeTypeMap() as Array<ClassAttributeDef>;\n            const instance: {[index: string]: any} = {};\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < attributeTypes.length; index++) {\n                const attributeType = attributeTypes[index];\n                instance[attributeType.baseName] = this.serialize(data[attributeType.name], attributeType.type, attributeType.subtype);\n            }\n            return instance;\n        } else {\n            return data;\n        }\n    }\n\n    public deserializeClass<T>(data: any, type: ClassType<T>): T {\n        return this.deserialize(data, findReflectTypeName(type) ?? undefined);\n    }\n\n    public deserializeClassArray<T>(data: any, type: ClassType<T>): Array<T> {\n        return this.deserialize(data, `Array<${findReflectTypeName(type)}>`);\n    }\n\n    public deserialize(data: any, type?: string) {\n        // polymorphism may change the actual type.\n        if (data == undefined || !type) {\n            return data;\n        }\n\n        const correctedTypeName = this.findCorrectType(data, type);\n\n        if (this._primitives.indexOf(correctedTypeName.toLowerCase()) !== -1) {\n            return data;\n        } else if (correctedTypeName.lastIndexOf('Array<', 0) === 0) {\n            // string.startsWith pre es6\n            let subType: string = correctedTypeName.replace('Array<', ''); // Array<Type> => Type>\n            subType = subType.substring(0, subType.length - 1); // Type> => Type\n            const transformedData: any[] = [];\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < data.length; index++) {\n                const datum = data[index];\n                transformedData.push(this.deserialize(datum, subType));\n            }\n            return transformedData;\n        } else if (correctedTypeName === 'Date') {\n            return new Date(data);\n        } else {\n            const enumType = TypeRegistry.get().findEnum(correctedTypeName);\n            if (enumType) {\n                // is Enum\n                return data;\n            }\n\n            const correctedType = TypeRegistry.get().findType(correctedTypeName);\n            if (!correctedType) {\n                // dont know the type\n                return data;\n            }\n            const instance = new correctedType();\n            const attributeTypes = correctedType.getAttributeTypeMap() as Array<ClassAttributeDef>;\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < attributeTypes.length; index++) {\n                const attributeType = attributeTypes[index];\n                instance[attributeType.name] = this.deserialize(data[attributeType.baseName], attributeType.type);\n            }\n            return instance;\n        }\n    }\n}\n"]}

package/esm2022/lib/services/api.abstract.service.mjs

@@ -0,0 +1,55 @@
+import { HttpClient } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { ObjectSerializer } from '../serder/object-serializer';
+export class ACommonsBaseApiService {
+    constructor() {
+        this.objectSerializer = ObjectSerializer.get();
+        this.http = inject(HttpClient);
+    }
+    getUrl(...pathSegments) {
+        let baseUrl = this.getBasePath();
+        if (baseUrl.endsWith('/')) {
+            baseUrl = baseUrl.substring(0, baseUrl.length - 1);
+        }
+        const serviceBasePath = this.getServiceBasePath();
+        let path = [serviceBasePath, ...pathSegments].filter(s => s && s.length).join('/');
+        // omit first and last '/'
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+        if (path.endsWith('/')) {
+            path = path.substring(0, path.length - 1);
+        }
+        // replace any double '//' from path that could come from joining paths
+        path = path.replace('//', '/');
+        return `${baseUrl}/${path}`;
+    }
+    deserializeQueryResult(item, qrType) {
+        return this.deserializeClass(item, qrType);
+    }
+    deserializeClass(item, type) {
+        return this.objectSerializer.deserializeClass(item, type);
+    }
+    deserializeClassArray(item, type) {
+        return this.objectSerializer.deserializeClassArray(item, type);
+    }
+    serializeClass(item, type) {
+        return this.objectSerializer.serializeClass(item, type);
+    }
+    serializeClassArray(item, type) {
+        return this.objectSerializer.serializeClassArray(item, type);
+    }
+}
+export class ACommonsApiService extends ACommonsBaseApiService {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    deserialize(item) {
+        return this.deserializeClass(item, this.type);
+    }
+    serialize(item) {
+        return this.serializeClass(item, this.type);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/crud-api.abstract.service.mjs

@@ -0,0 +1,82 @@
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { ACommonsGetAllApiService } from './get-all-api.abstract.service';
+export class ACommonsCrudApiService extends ACommonsGetAllApiService {
+    constructor(fetchType, requestType, queryResultType) {
+        super(fetchType, queryResultType);
+        this.requestType = requestType;
+    }
+    createPost(item, params) {
+        const url = this.getUrl(this.getCreatePostPath(item));
+        return this.http
+            .post(url, this.serializeRequest(item), {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    getByIdGet(id, params, locale) {
+        const url = this.getUrl(this.getGetByIdGetPath(id));
+        if (params && locale) {
+            params = params.set('lang', locale);
+        }
+        else if (locale) {
+            params = new HttpParams().set('lang', locale);
+        }
+        return this.http
+            .get(url, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    updatePut(id, item, params) {
+        const url = this.getUrl(this.getUpdatePutPath(id, item));
+        return this.http
+            .put(url, this.serializeRequest(item), {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    removeDelete(id, item, params) {
+        const url = this.getUrl(this.getRemoveDeletePath(id, item));
+        return this.http
+            .request('delete', url, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            body: item ? this.serialize(item) : undefined,
+            params: params
+        })
+            .pipe(map(res => (res ? this.deserialize(res) : null)));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getCreatePostPath(item) {
+        return '';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getUpdatePutPath(id, item) {
+        return ``;
+    }
+    getGetByIdGetPath(id) {
+        return `/${id}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getRemoveDeletePath(id, item) {
+        return `/${id}`;
+    }
+    deserializeRequest(item) {
+        return this.deserializeClass(item, this.requestType);
+    }
+    serializeRequest(item) {
+        return this.serializeClass(item, this.requestType);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud-api.abstract.service.js","sourceRoot":"","sources":["../../../../src/lib/services/crud-api.abstract.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpParams} from '@angular/common/http';\n\nimport {Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {ClassType, IdType} from '@mediusinc/mng-commons/core';\n\nimport {QueryResult} from '../models/query-result.model';\nimport {ACommonsGetAllApiService} from './get-all-api.abstract.service';\n\nexport interface ICommonsCrudApiService<FetchType, RequestType> {\n    createPost?(item: RequestType, params?: HttpParams): Observable<FetchType>;\n\n    getByIdGet?(id: IdType, params?: HttpParams, locale?: string): Observable<FetchType>;\n\n    updatePut?(id: IdType, item: RequestType, params?: HttpParams): Observable<FetchType>;\n\n    removeDelete?(id: IdType, item?: FetchType, params?: HttpParams): Observable<FetchType | null>;\n}\n\nexport abstract class ACommonsCrudApiService<FetchType, RequestType, QueryResultType extends QueryResult<any>>\n    extends ACommonsGetAllApiService<FetchType, QueryResultType>\n    implements ICommonsCrudApiService<FetchType, RequestType>\n{\n    protected constructor(\n        fetchType: ClassType<FetchType>,\n        protected requestType: ClassType<RequestType>,\n        queryResultType: ClassType<QueryResultType>\n    ) {\n        super(fetchType, queryResultType);\n    }\n\n    public createPost(item: RequestType, params?: HttpParams): Observable<FetchType> {\n        const url = this.getUrl(this.getCreatePostPath(item));\n        return this.http\n            .post<unknown>(url, this.serializeRequest(item), {\n                withCredentials: true,\n                observe: 'body',\n                reportProgress: false,\n                params: params\n            })\n            .pipe(map(res => this.deserialize(res)));\n    }\n\n    public getByIdGet(id: IdType, params?: HttpParams, locale?: string): Observable<FetchType> {\n        const url = this.getUrl(this.getGetByIdGetPath(id));\n        if (params && locale) {\n            params = params.set('lang', locale);\n        } else if (locale) {\n            params = new HttpParams().set('lang', locale);\n        }\n        return this.http\n            .get<unknown>(url, {\n                withCredentials: true,\n                observe: 'body',\n                reportProgress: false,\n                params: params\n            })\n            .pipe(map(res => this.deserialize(res)));\n    }\n\n    public updatePut(id: IdType, item: RequestType, params?: HttpParams): Observable<FetchType> {\n        const url = this.getUrl(this.getUpdatePutPath(id, item));\n        return this.http\n            .put<unknown>(url, this.serializeRequest(item), {\n                withCredentials: true,\n                observe: 'body',\n                reportProgress: false,\n                params: params\n            })\n            .pipe(map(res => this.deserialize(res)));\n    }\n\n    public removeDelete(id: IdType, item?: FetchType, params?: HttpParams): Observable<FetchType | null> {\n        const url = this.getUrl(this.getRemoveDeletePath(id, item));\n        return this.http\n            .request<unknown>('delete', url, {\n                withCredentials: true,\n                observe: 'body',\n                reportProgress: false,\n                body: item ? this.serialize(item) : undefined,\n                params: params\n            })\n            .pipe(map(res => (res ? this.deserialize(res) : null)));\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    protected getCreatePostPath(item: RequestType): string {\n        return '';\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    protected getUpdatePutPath(id: IdType, item: RequestType): string {\n        return ``;\n    }\n\n    protected getGetByIdGetPath(id: IdType): string {\n        return `/${id}`;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    protected getRemoveDeletePath(id: IdType, item?: FetchType) {\n        return `/${id}`;\n    }\n\n    protected deserializeRequest(item: any): RequestType {\n        return this.deserializeClass(item, this.requestType);\n    }\n\n    protected serializeRequest(item: RequestType): any {\n        return this.serializeClass(item, this.requestType);\n    }\n}\n"]}

package/esm2022/lib/services/get-all-api.abstract.service.mjs

@@ -0,0 +1,49 @@
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { DataListParamsUtil } from '@mediusinc/mng-commons/core';
+import { ACommonsApiService } from './api.abstract.service';
+export class ACommonsGetAllApiService extends ACommonsApiService {
+    constructor(fetchType, queryResultType) {
+        super(fetchType);
+        this.queryResultType = queryResultType;
+    }
+    getAllGet(requestParams, params, locale) {
+        const url = this.getUrl(this.getGetAllGetPath());
+        if (!params) {
+            params = new HttpParams();
+        }
+        if (locale) {
+            params = params.set('lang', locale);
+        }
+        if (requestParams?.limit) {
+            params = params.set('limit', requestParams.limit);
+        }
+        if (requestParams?.offset) {
+            params = params.set('offset', requestParams.offset);
+        }
+        const sort = DataListParamsUtil.sortToUrlQuery(requestParams);
+        if (sort) {
+            params = params.set('sort', sort);
+        }
+        if (requestParams?.filters) {
+            Object.keys(requestParams.filters).forEach(key => {
+                const value = DataListParamsUtil.paramsFilterToUrlQuery(requestParams, key);
+                if (value) {
+                    params = params.set(key, value);
+                }
+            });
+        }
+        return this.http
+            .get(url, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserializeQueryResult(res, this.queryResultType)));
+    }
+    getGetAllGetPath() {
+        return '/get-all';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/mediusinc-mng-commons-data-api-class.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lZGl1c2luYy1tbmctY29tbW9ucy1kYXRhLWFwaS1jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/tableview/index.mjs

@@ -0,0 +1,3 @@
+export * from './tableview-crud.data-provider';
+export * from './tableview-crud-create';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90YWJsZXZpZXcvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGFibGV2aWV3LWNydWQuZGF0YS1wcm92aWRlcic7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxldmlldy1jcnVkLWNyZWF0ZSc7XG4iXX0=

package/esm2022/tableview/mediusinc-mng-commons-data-api-class-tableview.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLXRhYmxldmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RhYmxldmlldy9zcmMvbWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLXRhYmxldmlldy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/tableview/tableview-crud-create.mjs

@@ -0,0 +1,40 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewDescriptor, TableviewInputBuilder } from '@mediusinc/mng-commons/tableview/api';
+import { TableviewCrudDataProvider } from './tableview-crud.data-provider';
+function prepareBuilder(type, requestType, service, modelConfig, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey), TableviewCrudDataProvider.create(type, requestType, service, modelConfig?.idProperty), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+/**
+ * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.
+ * Sorts and filters are expected to be keys of class.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns A tableview instance with descriptor, data provider and actions.
+ */
+export function tableviewCrud(type, requestType, service, modelConfig, buildFn) {
+    return prepareBuilder(type, requestType, service, modelConfig, buildFn);
+}
+/**
+ * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.
+ * @param {TypeDescriptor<Sorts>} sorts - The available sort keys of get all request.
+ * @param {TypeDescriptor<Filters>} filters - The available filter keys of get all request.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns A tableview instance with descriptor, data provider and actions.
+ */
+export function tableviewCrudWithSortAndFilter(type, requestType, service, sorts, filters, modelConfig, buildFn) {
+    return prepareBuilder(type, requestType, service, modelConfig, buildFn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-crud-create.js","sourceRoot":"","sources":["../../../tableview/src/tableview-crud-create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AAK/C,OAAO,EAAC,mBAAmB,EAA2B,qBAAqB,EAAC,MAAM,sCAAsC,CAAC;AAEzH,OAAO,EAAC,yBAAyB,EAAgC,MAAM,gCAAgC,CAAC;AAExG,SAAS,cAAc,CAOnB,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,WAIC,EACD,OASS;IAET,MAAM,OAAO,GAAG,IAAI,qBAAqB,CAQrC,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,CAAC,EAClH,yBAAyB,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,EACrF,MAAM,CAAC,QAAQ,CAAC,CACnB,CAAC;IACF,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;IACnB,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAOzB,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,WAIC,EACD,OASS;IAET,OAAO,cAAc,CAA+C,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAC1H,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,8BAA8B,CAO1C,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,KAA4B,EAC5B,OAAgC,EAChC,WAIC,EACD,OASS;IAET,OAAO,cAAc,CAA+C,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAC1H,CAAC","sourcesContent":["import {Injector, inject} from '@angular/core';\n\nimport {ICommonsCrudApiService, ICommonsGetAllApiService, QueryResult} from '@mediusinc/mng-commons-data-api-class';\nimport {ClassType, ServiceClassType} from '@mediusinc/mng-commons/core';\nimport {TypeDescriptor} from '@mediusinc/mng-commons/model';\nimport {TableviewDescriptor, TableviewDescriptorInst, TableviewInputBuilder} from '@mediusinc/mng-commons/tableview/api';\n\nimport {TableviewCrudDataProvider, TableviewCrudDataProviderInst} from './tableview-crud.data-provider';\n\nfunction prepareBuilder<\n    Model,\n    RequestModel,\n    Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n    Sorts,\n    Filters extends keyof any\n>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewInputBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    const builder = new TableviewInputBuilder<\n        Model,\n        Service,\n        TableviewDescriptorInst<Model, Sorts, Filters>,\n        TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n        Sorts,\n        Filters\n    >(\n        TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey),\n        TableviewCrudDataProvider.create(type, requestType, service, modelConfig?.idProperty),\n        inject(Injector)\n    );\n    buildFn?.(builder);\n    return builder.build();\n}\n\n/**\n * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.\n * Sorts and filters are expected to be keys of class.\n *\n * @param {ClassType<Model>} type - The class representing the model.\n * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.\n * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.\n * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.\n * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.\n *\n * @returns A tableview instance with descriptor, data provider and actions.\n */\nexport function tableviewCrud<\n    Model,\n    RequestModel,\n    Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewInputBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    return prepareBuilder<Model, RequestModel, Service, Sorts, Filters>(type, requestType, service, modelConfig, buildFn);\n}\n\n/**\n * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.\n *\n * @param {ClassType<Model>} type - The class representing the model.\n * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.\n * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.\n * @param {TypeDescriptor<Sorts>} sorts - The available sort keys of get all request.\n * @param {TypeDescriptor<Filters>} filters - The available filter keys of get all request.\n * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.\n * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.\n *\n * @returns A tableview instance with descriptor, data provider and actions.\n */\nexport function tableviewCrudWithSortAndFilter<\n    Model,\n    RequestModel,\n    Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n    Sorts,\n    Filters extends keyof any\n>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    sorts: TypeDescriptor<Sorts>,\n    filters: TypeDescriptor<Filters>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewInputBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    return prepareBuilder<Model, RequestModel, Service, Sorts, Filters>(type, requestType, service, modelConfig, buildFn);\n}\n"]}