- feat: remove unnecessary migrations, controllers and models files.

- feat: metable store
- feat: metable store with settings store.
- feat: settings middleware to auto-save and load.
- feat: DI db manager to master container.
- feat: write some logs to sale invoices.
This commit is contained in:
Ahmed Bouhuolia
2020-09-03 16:51:48 +02:00
parent abefba22ee
commit 9ee7ed89ec
98 changed files with 1697 additions and 2052 deletions

View File

@@ -1,266 +0,0 @@
export default class MetableCollection {
/**
* Constructor method.
*/
constructor() {
this.metadata = [];
this.KEY_COLUMN = 'key';
this.VALUE_COLUMN = 'value';
this.TYPE_COLUMN = 'type';
this.model = null;
this.extraColumns = [];
this.extraQuery = (query, meta) => {
query.where('key', meta[this.KEY_COLUMN]);
};
}
/**
* Set model of this metadata collection.
* @param {Object} model -
*/
setModel(model) {
this.model = model;
}
/**
* Sets a extra columns.
* @param {Array} columns -
*/
setExtraColumns(columns) {
this.extraColumns = columns;
}
/**
* Find the given metadata key.
* @param {String} key -
* @return {object} - Metadata object.
*/
findMeta(payload) {
const { key, extraColumns } = this.parsePayload(payload);
return this.allMetadata().find((meta) => {
const isSameKey = meta.key === key;
const sameExtraColumns = this.extraColumns.some((extraColumn) => {
return !extraColumns || (extraColumns[extraColumn] === meta[extraColumn]);
});
return isSameKey && sameExtraColumns;
});
}
/**
* Retrieve all metadata.
*/
allMetadata() {
return this.metadata.filter((meta) => !meta.markAsDeleted);
}
/**
* Retrieve metadata of the given key.
* @param {String} key -
* @param {Mixied} defaultValue -
*/
getMeta(payload, defaultValue) {
const metadata = this.findMeta(payload);
return metadata ? metadata.value : defaultValue || false;
}
/**
* Markes the metadata to should be deleted.
* @param {String} key -
*/
removeMeta(key) {
const metadata = this.findMeta(key);
if (metadata) {
metadata.markAsDeleted = true;
}
}
/**
* Remove all meta data of the given group.
* @param {*} group
*/
removeAllMeta(group = 'default') {
this.metadata = this.metadata.map((meta) => ({
...meta,
markAsDeleted: true,
}));
}
setExtraQuery(callback) {
this.extraQuery = callback;
}
/**
* Set the meta data to the stack.
* @param {String} key -
* @param {String} value -
*/
setMeta(payload, ...args) {
if (Array.isArray(key)) {
const metadata = key;
metadata.forEach((meta) => {
this.setMeta(meta.key, meta.value);
});
return;
}
const { key, value, ...extraColumns } = this.parsePayload(payload, args[0]);
const metadata = this.findMeta(payload);
if (metadata) {
metadata.value = value;
metadata.markAsUpdated = true;
} else {
this.metadata.push({
value, key, ...extraColumns, markAsInserted: true,
});
}
}
parsePayload(payload, value) {
return typeof payload !== 'object' ? { key: payload, value } : { ...payload };
}
/**
* Saved the modified/deleted and inserted metadata.
*/
async saveMeta() {
const inserted = this.metadata.filter((m) => (m.markAsInserted === true));
const updated = this.metadata.filter((m) => (m.markAsUpdated === true));
const deleted = this.metadata.filter((m) => (m.markAsDeleted === true));
const opers = [];
if (deleted.length > 0) {
deleted.forEach((meta) => {
const deleteOper = this.model.query().onBuild((query, result) => {
this.extraQuery(query, meta);
return result;
}).delete();
opers.push(deleteOper);
});
}
inserted.forEach((meta) => {
const insertOper = this.model.query().insert({
[this.KEY_COLUMN]: meta.key,
[this.VALUE_COLUMN]: meta.value,
...this.extraColumns.reduce((obj, column) => {
if (typeof meta[column] !== 'undefined') {
obj[column] = meta[column];
}
return obj;
}, {}),
});
opers.push(insertOper);
});
updated.forEach((meta) => {
const updateOper = this.model.query().onBuild((query) => {
this.extraQuery(query, meta);
}).patch({
[this.VALUE_COLUMN]: meta.value,
});
opers.push(updateOper);
});
await Promise.all(opers);
}
/**
* Loads the metadata from the storage.
* @param {String|Array} key -
* @param {Boolean} force -
*/
async load() {
const metadata = await this.query();
const metadataArray = this.mapMetadataCollection(metadata);
metadataArray.forEach((meta) => {
this.metadata.push(meta);
});
}
/**
* Format the metadata before saving to the database.
* @param {String|Number|Boolean} value -
* @param {String} valueType -
* @return {String|Number|Boolean} -
*/
static formatMetaValue(value, valueType) {
let parsedValue;
switch (valueType) {
case 'number':
parsedValue = `${value}`;
break;
case 'boolean':
parsedValue = value ? '1' : '0';
break;
case 'json':
parsedValue = JSON.stringify(parsedValue);
break;
default:
parsedValue = value;
break;
}
return parsedValue;
}
/**
* Mapping and parse metadata to collection entries.
* @param {Meta} attr -
* @param {String} parseType -
*/
mapMetadata(attr, parseType = 'parse') {
return {
key: attr[this.KEY_COLUMN],
value: (parseType === 'parse')
? MetableCollection.parseMetaValue(
attr[this.VALUE_COLUMN],
this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
)
: MetableCollection.formatMetaValue(
attr[this.VALUE_COLUMN],
this.TYPE_COLUMN ? attr[this.TYPE_COLUMN] : false,
),
...this.extraColumns.map((extraCol) => ({
[extraCol]: attr[extraCol] || null,
})),
};
}
/**
* Parse the metadata to the collection.
* @param {Array} collection -
*/
mapMetadataToCollection(metadata, parseType = 'parse') {
return metadata.map((model) => this.mapMetadataToCollection(model, parseType));
}
/**
* Load metadata to the metable collection.
* @param {Array} meta -
*/
from(meta) {
if (Array.isArray(meta)) {
meta.forEach((m) => { this.from(m); });
return;
}
this.metadata.push(meta);
}
toArray() {
return this.metadata;
}
/**
* Static method to load metadata to the collection.
* @param {Array} meta
*/
static from(meta) {
const collection = new MetableCollection();
collection.from(meta);
return collection;
}
}

View File

@@ -0,0 +1,204 @@
import { Model } from 'objection';
import { omit, isEmpty } from 'lodash';
import {
IMetadata,
IMetaQuery,
IMetableStore,
} from '@/interfaces';
import { itemsStartWith } from '@/utils';
export default class MetableStore implements IMetableStore{
metadata: IMetadata[];
model: Model;
extraColumns: string[];
/**
* Constructor method.
*/
constructor() {
this.metadata = [];
this.model = null;
this.extraColumns = [];
}
/**
* Sets a extra columns.
* @param {Array} columns -
*/
setExtraColumns(columns: string[]): void {
this.extraColumns = columns;
}
/**
* Find the given metadata key.
* @param {string|IMetaQuery} query -
* @returns {IMetadata} - Metadata object.
*/
find(query: string|IMetaQuery): IMetadata {
const { key, value, ...extraColumns } = this.parseQuery(query);
return this.metadata.find((meta: IMetadata) => {
const isSameKey = meta.key === key;
const sameExtraColumns = this.extraColumns
.some((extraColumn: string) => extraColumns[extraColumn] === meta[extraColumn]);
const isSameExtraColumns = (sameExtraColumns || isEmpty(extraColumns));
return isSameKey && isSameExtraColumns;
});
}
/**
* Retrieve all metadata.
* @returns {IMetadata[]}
*/
all(): IMetadata[] {
return this.metadata
.filter((meta: IMetadata) => !meta._markAsDeleted)
.map((meta: IMetadata) => omit(
meta,
itemsStartWith(Object.keys(meta), '_')
));
}
/**
* Retrieve metadata of the given key.
* @param {String} key -
* @param {Mixied} defaultValue -
*/
get(query: string|IMetaQuery, defaultValue: any): any|false {
const metadata = this.find(query);
return metadata ? metadata.value : defaultValue || false;
}
/**
* Markes the metadata to should be deleted.
* @param {String} key -
*/
remove(query: string|IMetaQuery): void {
const metadata: IMetadata = this.find(query);
if (metadata) {
metadata._markAsDeleted = true;
}
}
/**
* Remove all meta data of the given group.
* @param {string} group
*/
removeAll(group: string = 'default'): void {
this.metadata = this.metadata.map((meta) => ({
...meta,
_markAsDeleted: true,
}));
}
/**
* Set the meta data to the stack.
* @param {String} key -
* @param {String} value -
*/
set(query: IMetaQuery|IMetadata[]|string, metaValue?: any): void {
if (Array.isArray(query)) {
const metadata = query;
metadata.forEach((meta: IMetadata) => {
this.set(meta.key, meta.value);
});
return;
}
const { key, value, ...extraColumns } = this.parseQuery(query);
const metadata = this.find(query);
const newValue = metaValue || value;
if (metadata) {
metadata.value = newValue;
metadata._markAsUpdated = true;
} else {
this.metadata.push({
value: newValue,
key,
...extraColumns,
_markAsInserted: true,
});
}
}
/**
* Parses query query.
* @param query
* @param value
*/
parseQuery(query: string|IMetaQuery): IMetaQuery {
return typeof query !== 'object' ? { key: query } : { ...query };
}
/**
* Format the metadata before saving to the database.
* @param {string|number|boolean} value -
* @param {string} valueType -
* @return {string|number|boolean} -
*/
static formatMetaValue(
value: string|boolean|number,
valueType: string
) : string|number|boolean {
let parsedValue;
switch (valueType) {
case 'number':
parsedValue = `${value}`;
break;
case 'boolean':
parsedValue = value ? '1' : '0';
break;
case 'json':
parsedValue = JSON.stringify(parsedValue);
break;
default:
parsedValue = value;
break;
}
return parsedValue;
}
/**
* Parse the metadata to the collection.
* @param {Array} collection -
*/
mapMetadataToCollection(metadata: IMetadata[], parseType: string = 'parse') {
return metadata.map((model) => this.mapMetadataToCollection(model, parseType));
}
/**
* Load metadata to the metable collection.
* @param {Array} meta -
*/
from(meta: []) {
if (Array.isArray(meta)) {
meta.forEach((m) => { this.from(m); });
return;
}
this.metadata.push(meta);
}
/**
*
* @returns {array}
*/
toArray(): IMetadata[] {
return this.metadata;
}
/**
* Static method to load metadata to the collection.
* @param {Array} meta
*/
static from(meta) {
const collection = new MetableCollection();
collection.from(meta);
return collection;
}
}

View File

@@ -0,0 +1,213 @@
import { Model } from 'objection';
import {
IMetadata,
IMetableStoreStorage,
} from '@/interfaces';
import MetableStore from './MetableStore';
export default class MetableDBStore extends MetableStore implements IMetableStoreStorage{
model: Model;
KEY_COLUMN: string;
VALUE_COLUMN: string;
TYPE_COLUMN: string;
extraQuery: Function;
loaded: Boolean;
/**
* Constructor method.
*/
constructor() {
super();
this.loaded = false;
this.KEY_COLUMN = 'key';
this.VALUE_COLUMN = 'value';
this.TYPE_COLUMN = 'type';
this.model = null;
this.extraQuery = (query, meta) => {
query.where('key', meta[this.KEY_COLUMN]);
};
}
/**
* Set model of this metadata collection.
* @param {Object} model -
*/
setModel(model: Model) {
this.model = model;
}
/**
* Sets a extra query callback.
* @param callback
*/
setExtraQuery(callback) {
this.extraQuery = callback;
}
/**
* Saves the modified, deleted and insert metadata.
*/
save() {
this.validateStoreIsLoaded();
return Promise.all([
this.saveUpdated(this.metadata),
this.saveDeleted(this.metadata),
this.saveInserted(this.metadata),
]);
}
/**
* Saves the updated metadata.
* @param {IMetadata[]} metadata -
* @returns {Promise}
*/
saveUpdated(metadata: IMetadata[]) {
const updated = metadata.filter((m) => (m._markAsUpdated === true));
const opers = [];
updated.forEach((meta) => {
const updateOper = this.model.query().onBuild((query) => {
this.extraQuery(query, meta);
}).patch({
[this.VALUE_COLUMN]: meta.value,
}).then(() => {
meta._markAsUpdated = false;
});
opers.push(updateOper);
});
return Promise.all(opers);
}
/**
* Saves the deleted metadata.
* @param {IMetadata[]} metadata -
* @returns {Promise}
*/
saveDeleted(metadata: IMetadata[]) {
const deleted = metadata.filter((m: IMetadata) => (m._markAsDeleted === true));
const opers: Promise<void> = [];
if (deleted.length > 0) {
deleted.forEach((meta) => {
const deleteOper = this.model.query().onBuild((query) => {
this.extraQuery(query, meta);
}).delete().then(() => {
meta._markAsDeleted = false;
});
opers.push(deleteOper);
});
}
return Promise.all(opers);
}
/**
* Saves the inserted metadata.
* @param {IMetadata[]} metadata -
* @returns {Promise}
*/
saveInserted(metadata: IMetadata[]) {
const inserted = metadata.filter((m: IMetadata) => (m._markAsInserted === true));
const opers: Promise<void> = [];
inserted.forEach((meta) => {
const insertData = {
[this.KEY_COLUMN]: meta.key,
[this.VALUE_COLUMN]: meta.value,
...this.extraColumns.reduce((obj, column) => {
if (typeof meta[column] !== 'undefined') {
obj[column] = meta[column];
}
return obj;
}, {}),
};
const insertOper = this.model.query()
.insert(insertData)
.then(() => {
meta._markAsInserted = false;
});
opers.push(insertOper);
});
return Promise.all(opers);
}
/**
* Loads the metadata from the storage.
* @param {String|Array} key -
* @param {Boolean} force -
*/
async load() {
const metadata = await this.model.query();
const mappedMetadata = this.mapMetadataCollection(metadata);
mappedMetadata.forEach((meta: IMetadata) => {
this.metadata.push(meta);
});
this.loaded = true;
}
/**
* Format the metadata before saving to the database.
* @param {String|Number|Boolean} value -
* @param {String} valueType -
* @return {String|Number|Boolean} -
*/
static formatMetaValue(value: string|number|boolean, valueType: striung|false) {
let parsedValue: string|number|boolean;
switch (valueType) {
case 'number':
parsedValue = `${value}`;
break;
case 'boolean':
parsedValue = value ? '1' : '0';
break;
case 'json':
parsedValue = JSON.stringify(parsedValue);
break;
default:
parsedValue = value;
break;
}
return parsedValue;
}
/**
* Mapping and parse metadata to collection entries.
* @param {Meta} attr -
* @param {String} parseType -
*/
mapMetadata(metadata: IMetadata) {
return {
key: metadata[this.KEY_COLUMN],
value: MetableDBStore.formatMetaValue(
metadata[this.VALUE_COLUMN],
this.TYPE_COLUMN ? metadata[this.TYPE_COLUMN] : false,
),
...this.extraColumns.reduce((obj, extraCol: string) => {
obj[extraCol] = metadata[extraCol] || null;
return obj;
}, {}),
};
}
/**
* Parse the metadata to the collection.
* @param {Array} collection -
*/
mapMetadataCollection(metadata: IMetadata[]) {
return metadata.map((model) => this.mapMetadata(model));
}
/**
* Throw error in case the store is not loaded yet.
*/
private validateStoreIsLoaded() {
if (!this.loaded) {
throw new Error('You could not save the store before loaded from the storage.');
}
}
}