smartdata/ts/smartdata.classes.doc.ts

340 lines
9.4 KiB
TypeScript
Raw Permalink Normal View History

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
export type TDocCreation = 'db' | 'new' | 'mixed';
2016-09-13 20:53:21 +00:00
export function globalSvDb() {
return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
console.log(`called svDb() on >${target.constructor.name}.${key}<`);
if (!target.globalSaveableProperties) {
target.globalSaveableProperties = [];
}
target.globalSaveableProperties.push(key);
};
}
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}<`);
if (!target.saveableProperties) {
target.saveableProperties = [];
}
target.saveableProperties.push(key);
};
2016-11-17 23:42:25 +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}<<`);
// 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
}
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');
2021-11-12 15:23:26 +00:00
}
}
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;
};
2024-06-18 18:12:14 +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>(
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));
const returnArray = [];
2021-11-12 15:23:26 +00:00
for (const foundDoc of foundDocs) {
const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
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>(
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;
}
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
}
/**
* 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
*/
@globalSvDb()
_createdAt: string = (new Date()).toISOString();
2024-04-13 23:24:21 +00:00
/**
* will be updated everytime the doc is saved
*/
@globalSvDb()
_updatedAt: string = (new Date()).toISOString();
2024-04-13 23:24:21 +00:00
/**
* an array of saveable properties of ALL doc
*/
public globalSaveableProperties: string[];
2022-05-16 22:33:44 +00:00
/**
* unique indexes
*/
public uniqueIndexes: string[];
/**
* an array of saveable properties of a specific doc
2022-05-16 22:33:44 +00:00
*/
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
this._updatedAt = (new Date()).toISOString();
2024-04-13 23:24:21 +00:00
switch (this.creationStatus) {
case 'db':
2020-09-25 21:05:21 +00:00
dbResult = await this.collection.update(self);
break;
case 'new':
2020-09-25 21:05:21 +00:00
dbResult = await this.collection.insert(self);
this.creationStatus = 'db';
break;
default:
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
}
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
}
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)) {
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
}
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
2024-05-31 16:47:48 +00:00
const saveableProperties = [
...this.globalSaveableProperties,
...this.saveableProperties
]
for (const propertyNameString of saveableProperties) {
saveableObject[propertyNameString] = this[propertyNameString];
}
2020-02-19 18:30:34 +00:00
return saveableObject as TImplements;
}
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
}