2022-05-16 22:33:44 +00:00
|
|
|
import * as plugins from './smartdata.plugins.js';
|
2016-09-13 20:53:21 +00:00
|
|
|
|
2022-05-16 22:33:44 +00:00
|
|
|
import { SmartdataDb } from './smartdata.classes.db.js';
|
|
|
|
import { SmartdataDbCursor } from './smartdata.classes.cursor.js';
|
2023-06-24 21:57:34 +00:00
|
|
|
import { type IManager, SmartdataCollection } from './smartdata.classes.collection.js';
|
2022-05-16 22:33:44 +00:00
|
|
|
import { SmartdataDbWatcher } from './smartdata.classes.watcher.js';
|
2016-09-13 20:53:21 +00:00
|
|
|
|
2018-07-08 21:48:14 +00:00
|
|
|
export type TDocCreation = 'db' | 'new' | 'mixed';
|
2016-09-13 20:53:21 +00:00
|
|
|
|
2016-11-17 23:42:25 +00:00
|
|
|
/**
|
2016-11-17 23:59:57 +00:00
|
|
|
* saveable - saveable decorator to be used on class properties
|
2016-11-17 23:42:25 +00:00
|
|
|
*/
|
2016-11-18 12:56:15 +00:00
|
|
|
export function svDb() {
|
2020-02-19 18:30:34 +00:00
|
|
|
return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
|
2020-09-25 20:42:38 +00:00
|
|
|
console.log(`called svDb() on >${target.constructor.name}.${key}<`);
|
2018-01-14 16:32:04 +00:00
|
|
|
if (!target.saveableProperties) {
|
|
|
|
target.saveableProperties = [];
|
|
|
|
}
|
|
|
|
target.saveableProperties.push(key);
|
|
|
|
};
|
2016-11-17 23:42:25 +00:00
|
|
|
}
|
2016-09-13 23:02:11 +00:00
|
|
|
|
2018-07-10 19:27:16 +00:00
|
|
|
/**
|
|
|
|
* unique index - decorator to mark a unique index
|
|
|
|
*/
|
|
|
|
export function unI() {
|
2020-02-19 18:30:34 +00:00
|
|
|
return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
|
2020-09-25 20:42:38 +00:00
|
|
|
console.log(`called unI on >>${target.constructor.name}.${key}<<`);
|
2018-07-10 19:27:16 +00:00
|
|
|
|
|
|
|
// mark the index as unique
|
|
|
|
if (!target.uniqueIndexes) {
|
|
|
|
target.uniqueIndexes = [];
|
|
|
|
}
|
|
|
|
target.uniqueIndexes.push(key);
|
|
|
|
|
|
|
|
// and also save it
|
|
|
|
if (!target.saveableProperties) {
|
|
|
|
target.saveableProperties = [];
|
|
|
|
}
|
|
|
|
target.saveableProperties.push(key);
|
|
|
|
};
|
2019-01-07 01:41:38 +00:00
|
|
|
}
|
2018-07-10 19:27:16 +00:00
|
|
|
|
2021-11-12 15:23:26 +00:00
|
|
|
export const convertFilterForMongoDb = (filterArg: { [key: string]: any }) => {
|
|
|
|
const convertedFilter: { [key: string]: any } = {};
|
|
|
|
const convertFilterArgument = (keyPathArg2: string, filterArg2: any) => {
|
|
|
|
if (typeof filterArg2 === 'object') {
|
|
|
|
for (const key of Object.keys(filterArg2)) {
|
|
|
|
if (key.startsWith('$')) {
|
|
|
|
convertedFilter[keyPathArg2] = filterArg2;
|
|
|
|
return;
|
|
|
|
} else if (key.includes('.')) {
|
|
|
|
throw new Error('keys cannot contain dots');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const key of Object.keys(filterArg2)) {
|
|
|
|
convertFilterArgument(`${keyPathArg2}.${key}`, filterArg2[key]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
convertedFilter[keyPathArg2] = filterArg2;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
for (const key of Object.keys(filterArg)) {
|
|
|
|
convertFilterArgument(key, filterArg[key]);
|
|
|
|
}
|
|
|
|
return convertedFilter;
|
|
|
|
};
|
|
|
|
|
2021-06-09 12:10:08 +00:00
|
|
|
export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends IManager = any> {
|
2017-02-25 10:37:05 +00:00
|
|
|
/**
|
|
|
|
* the collection object an Doc belongs to
|
|
|
|
*/
|
2020-09-10 10:12:17 +00:00
|
|
|
public static collection: SmartdataCollection<any>;
|
|
|
|
public collection: SmartdataCollection<any>;
|
2021-09-17 20:34:15 +00:00
|
|
|
public static defaultManager;
|
2021-06-09 13:38:14 +00:00
|
|
|
public static manager;
|
2021-06-09 12:10:08 +00:00
|
|
|
public manager: TManager;
|
2016-11-17 23:42:25 +00:00
|
|
|
|
2022-05-16 22:33:44 +00:00
|
|
|
// STATIC
|
2021-11-12 15:23:26 +00:00
|
|
|
public static createInstanceFromMongoDbNativeDoc<T>(
|
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
|
|
|
mongoDbNativeDocArg: any
|
|
|
|
): T {
|
|
|
|
const newInstance = new this();
|
|
|
|
(newInstance as any).creationStatus = 'db';
|
|
|
|
for (const key of Object.keys(mongoDbNativeDocArg)) {
|
|
|
|
newInstance[key] = mongoDbNativeDocArg[key];
|
|
|
|
}
|
|
|
|
return newInstance;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gets all instances as array
|
|
|
|
* @param this
|
|
|
|
* @param filterArg
|
|
|
|
* @returns
|
|
|
|
*/
|
2020-08-18 15:10:44 +00:00
|
|
|
public static async getInstances<T>(
|
2021-06-06 15:48:37 +00:00
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
2020-08-18 15:10:44 +00:00
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T>
|
|
|
|
): Promise<T[]> {
|
2021-11-12 15:23:26 +00:00
|
|
|
const foundDocs = await (this as any).collection.findAll(convertFilterForMongoDb(filterArg));
|
2018-01-14 16:32:04 +00:00
|
|
|
const returnArray = [];
|
2021-11-12 15:23:26 +00:00
|
|
|
for (const foundDoc of foundDocs) {
|
|
|
|
const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
|
2018-01-14 16:32:04 +00:00
|
|
|
returnArray.push(newInstance);
|
|
|
|
}
|
|
|
|
return returnArray;
|
|
|
|
}
|
|
|
|
|
2021-11-12 15:23:26 +00:00
|
|
|
/**
|
|
|
|
* gets the first matching instance
|
|
|
|
* @param this
|
|
|
|
* @param filterArg
|
|
|
|
* @returns
|
|
|
|
*/
|
2020-08-18 15:10:44 +00:00
|
|
|
public static async getInstance<T>(
|
2021-06-06 15:48:37 +00:00
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
2020-08-18 15:10:44 +00:00
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T>
|
|
|
|
): Promise<T> {
|
2021-11-12 15:23:26 +00:00
|
|
|
const foundDoc = await (this as any).collection.findOne(convertFilterForMongoDb(filterArg));
|
|
|
|
if (foundDoc) {
|
|
|
|
const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
|
|
|
|
return newInstance;
|
|
|
|
} else {
|
|
|
|
return null;
|
2018-01-14 16:32:04 +00:00
|
|
|
}
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2016-11-17 23:42:25 +00:00
|
|
|
|
2024-03-26 12:21:36 +00:00
|
|
|
/**
|
|
|
|
* get a unique id prefixed with the class name
|
|
|
|
*/
|
2024-03-26 12:22:33 +00:00
|
|
|
public static async getNewId<T = any>(this: plugins.tsclass.typeFest.Class<T>, lengthArg: number = 20) {
|
2024-03-27 16:30:14 +00:00
|
|
|
return `${(this as any).className}:${plugins.smartunique.shortId(lengthArg)}`;
|
2024-03-26 12:21:36 +00:00
|
|
|
}
|
|
|
|
|
2021-11-12 15:23:26 +00:00
|
|
|
/**
|
|
|
|
* get cursor
|
|
|
|
* @returns
|
|
|
|
*/
|
|
|
|
public static async getCursor<T>(
|
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T>
|
|
|
|
) {
|
2022-05-17 21:54:26 +00:00
|
|
|
const collection: SmartdataCollection<T> = (this as any).collection;
|
|
|
|
const cursor: SmartdataDbCursor<T> = await collection.getCursor(
|
|
|
|
convertFilterForMongoDb(filterArg),
|
|
|
|
this as any as typeof SmartDataDbDoc
|
2021-11-12 18:02:29 +00:00
|
|
|
);
|
2021-11-12 15:23:26 +00:00
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
2022-05-16 22:33:44 +00:00
|
|
|
/**
|
|
|
|
* watch the collection
|
2022-11-01 17:23:57 +00:00
|
|
|
* @param this
|
|
|
|
* @param filterArg
|
|
|
|
* @param forEachFunction
|
2022-05-16 22:33:44 +00:00
|
|
|
*/
|
2022-11-01 17:23:57 +00:00
|
|
|
public static async watch<T>(
|
2022-05-16 22:33:44 +00:00
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T>
|
|
|
|
) {
|
|
|
|
const collection: SmartdataCollection<T> = (this as any).collection;
|
|
|
|
const watcher: SmartdataDbWatcher<T> = await collection.watch(
|
2022-05-17 21:54:26 +00:00
|
|
|
convertFilterForMongoDb(filterArg),
|
2022-11-01 17:23:57 +00:00
|
|
|
this as any
|
2022-05-16 22:33:44 +00:00
|
|
|
);
|
|
|
|
return watcher;
|
|
|
|
}
|
|
|
|
|
2021-11-12 15:23:26 +00:00
|
|
|
/**
|
|
|
|
* run a function for all instances
|
|
|
|
* @returns
|
|
|
|
*/
|
|
|
|
public static async forEach<T>(
|
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T>,
|
|
|
|
forEachFunction: (itemArg: T) => Promise<any>
|
|
|
|
) {
|
|
|
|
const cursor: SmartdataDbCursor<T> = await (this as any).getCursor(filterArg);
|
2021-11-12 18:02:29 +00:00
|
|
|
await cursor.forEach(forEachFunction);
|
2021-11-12 15:23:26 +00:00
|
|
|
}
|
|
|
|
|
2024-04-15 16:34:13 +00:00
|
|
|
/**
|
|
|
|
* returns a count of the documents in the collection
|
|
|
|
*/
|
|
|
|
public static async getCount<T>(
|
|
|
|
this: plugins.tsclass.typeFest.Class<T>,
|
|
|
|
filterArg: plugins.tsclass.typeFest.PartialDeep<T> = ({} as any)
|
|
|
|
) {
|
|
|
|
const collection: SmartdataCollection<T> = (this as any).collection;
|
|
|
|
return await collection.getCount(filterArg);
|
|
|
|
}
|
|
|
|
|
2022-05-16 22:33:44 +00:00
|
|
|
// INSTANCE
|
|
|
|
|
|
|
|
/**
|
|
|
|
* how the Doc in memory was created, may prove useful later.
|
|
|
|
*/
|
|
|
|
public creationStatus: TDocCreation = 'new';
|
|
|
|
|
2024-04-13 23:24:21 +00:00
|
|
|
/**
|
|
|
|
* updated from db in any case where doc comes from db
|
|
|
|
*/
|
|
|
|
@svDb()
|
2024-04-15 12:26:21 +00:00
|
|
|
_createdAt: string = (new Date()).toISOString();
|
2024-04-13 23:24:21 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* will be updated everytime the doc is saved
|
|
|
|
*/
|
|
|
|
@svDb()
|
2024-04-15 12:26:21 +00:00
|
|
|
_updatedAt: string = (new Date()).toISOString();
|
2024-04-13 23:24:21 +00:00
|
|
|
|
2022-05-16 22:33:44 +00:00
|
|
|
/**
|
|
|
|
* unique indexes
|
|
|
|
*/
|
|
|
|
public uniqueIndexes: string[];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* an array of saveable properties of a doc
|
|
|
|
*/
|
|
|
|
public saveableProperties: string[];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* name
|
|
|
|
*/
|
|
|
|
public name: string;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* primary id in the database
|
|
|
|
*/
|
|
|
|
public dbDocUniqueId: string;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* class constructor
|
|
|
|
*/
|
|
|
|
constructor() {}
|
|
|
|
|
2017-02-25 10:37:05 +00:00
|
|
|
/**
|
|
|
|
* saves this instance but not any connected items
|
|
|
|
* may lead to data inconsistencies, but is faster
|
|
|
|
*/
|
2019-09-02 14:42:29 +00:00
|
|
|
public async save() {
|
2019-01-08 13:37:17 +00:00
|
|
|
// tslint:disable-next-line: no-this-assignment
|
2019-09-02 14:42:29 +00:00
|
|
|
const self: any = this;
|
2020-09-25 21:05:21 +00:00
|
|
|
let dbResult: any;
|
2024-04-13 23:24:21 +00:00
|
|
|
|
2024-04-15 12:26:21 +00:00
|
|
|
this._updatedAt = (new Date()).toISOString();
|
2024-04-13 23:24:21 +00:00
|
|
|
|
2018-01-12 00:22:58 +00:00
|
|
|
switch (this.creationStatus) {
|
2018-07-08 21:48:14 +00:00
|
|
|
case 'db':
|
2020-09-25 21:05:21 +00:00
|
|
|
dbResult = await this.collection.update(self);
|
2018-01-14 16:32:04 +00:00
|
|
|
break;
|
2018-07-08 21:48:14 +00:00
|
|
|
case 'new':
|
2020-09-25 21:05:21 +00:00
|
|
|
dbResult = await this.collection.insert(self);
|
2018-07-08 21:48:14 +00:00
|
|
|
this.creationStatus = 'db';
|
2018-01-12 00:22:58 +00:00
|
|
|
break;
|
|
|
|
default:
|
2018-07-08 21:48:14 +00:00
|
|
|
console.error('neither new nor in db?');
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2020-09-25 21:05:21 +00:00
|
|
|
return dbResult;
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2016-09-13 23:02:11 +00:00
|
|
|
|
2019-01-08 17:45:30 +00:00
|
|
|
/**
|
|
|
|
* deletes a document from the database
|
|
|
|
*/
|
2019-09-02 14:58:19 +00:00
|
|
|
public async delete() {
|
2020-09-10 10:12:17 +00:00
|
|
|
await this.collection.delete(this);
|
2019-09-02 14:58:19 +00:00
|
|
|
}
|
2019-01-08 17:45:30 +00:00
|
|
|
|
2017-02-25 10:37:05 +00:00
|
|
|
/**
|
|
|
|
* also store any referenced objects to DB
|
|
|
|
* better for data consistency
|
|
|
|
*/
|
2023-07-21 18:08:18 +00:00
|
|
|
public saveDeep(savedMapArg: plugins.lik.ObjectMap<SmartDataDbDoc<any, any>> = null) {
|
2017-02-25 10:37:05 +00:00
|
|
|
if (!savedMapArg) {
|
2023-07-21 18:08:18 +00:00
|
|
|
savedMapArg = new plugins.lik.ObjectMap<SmartDataDbDoc<any, any>>();
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2018-01-14 16:32:04 +00:00
|
|
|
savedMapArg.add(this);
|
|
|
|
this.save();
|
2019-09-02 14:42:29 +00:00
|
|
|
for (const propertyKey of Object.keys(this)) {
|
|
|
|
const property: any = this[propertyKey];
|
2018-07-09 22:02:04 +00:00
|
|
|
if (property instanceof SmartDataDbDoc && !savedMapArg.checkForObject(property)) {
|
2018-01-14 16:32:04 +00:00
|
|
|
property.saveDeep(savedMapArg);
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2016-09-13 20:53:21 +00:00
|
|
|
}
|
2017-02-25 10:37:05 +00:00
|
|
|
}
|
2018-01-12 00:22:58 +00:00
|
|
|
|
2023-02-06 10:43:11 +00:00
|
|
|
/**
|
|
|
|
* updates an object from db
|
|
|
|
*/
|
|
|
|
public async updateFromDb() {
|
2023-08-14 23:01:16 +00:00
|
|
|
const mongoDbNativeDoc = await this.collection.findOne(await this.createIdentifiableObject());
|
2023-02-06 10:43:11 +00:00
|
|
|
for (const key of Object.keys(mongoDbNativeDoc)) {
|
|
|
|
this[key] = mongoDbNativeDoc[key];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-08 17:45:30 +00:00
|
|
|
/**
|
|
|
|
* creates a saveable object so the instance can be persisted as json in the database
|
|
|
|
*/
|
2020-02-19 18:30:34 +00:00
|
|
|
public async createSavableObject(): Promise<TImplements> {
|
|
|
|
const saveableObject: unknown = {}; // is not exposed to outside, so any is ok here
|
2019-01-08 17:45:30 +00:00
|
|
|
for (const propertyNameString of this.saveableProperties) {
|
2018-01-14 16:32:04 +00:00
|
|
|
saveableObject[propertyNameString] = this[propertyNameString];
|
2018-01-12 00:22:58 +00:00
|
|
|
}
|
2020-02-19 18:30:34 +00:00
|
|
|
return saveableObject as TImplements;
|
2018-01-12 00:22:58 +00:00
|
|
|
}
|
2019-01-08 17:45:30 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* creates an identifiable object for operations that require filtering
|
|
|
|
*/
|
|
|
|
public async createIdentifiableObject() {
|
|
|
|
const identifiableObject: any = {}; // is not exposed to outside, so any is ok here
|
|
|
|
for (const propertyNameString of this.uniqueIndexes) {
|
|
|
|
identifiableObject[propertyNameString] = this[propertyNameString];
|
|
|
|
}
|
|
|
|
return identifiableObject;
|
|
|
|
}
|
2016-09-13 20:53:21 +00:00
|
|
|
}
|