bd-orm 0.0.1

package/src/_/BdORMBase.ts

@@ -0,0 +1,288 @@
+import { BdORMError } from './BdORMError';
+
+// Local variables
+const PROPERTIES_WEAKMAP = new WeakMap(), // memory leak prevention
+    LOCAL_WEAKMAP = new WeakMap();
+
+// Helper methods
+const getLocalWeakMapValue = (instance: BdORMBase, key: string) => {
+        const localWeakMap = LOCAL_WEAKMAP.get(instance) ?? {};
+        return key in localWeakMap ? localWeakMap[key] : null;
+    },
+    getPropertyDescriptor = (instance: BdORMBase, property: string) => {
+        let descriptor;
+        while (instance && !descriptor) {
+            descriptor = Object.getOwnPropertyDescriptor(instance, property);
+            instance = Object.getPrototypeOf(instance);
+        }
+        return descriptor;
+    },
+    definePropertyDescriptors = (instance: BdORMBase, data: Record<string, any>) => {
+        Object.keys(data).forEach(property => {
+            const propertyDefinion = getPropertyDescriptor(instance, property) ?? {};
+            if (!('get' in propertyDefinion) || propertyDefinion.get === undefined) {
+                propertyDefinion.get = () => {
+                    const value = instance.getProperty(property) as string;
+                    if (typeof value === 'string' && (value.trim().startsWith('{') || value.trim().startsWith('['))) {
+                        try {
+                            return JSON.parse(value);
+                        } catch (e) {
+                            return value;
+                        }
+                    }
+                    return value;
+                };
+            }
+            if (!('set' in propertyDefinion) || propertyDefinion.set === undefined) {
+                propertyDefinion.set = (value: any) => {
+                    if (value && typeof value === 'object') {
+                        try {
+                            instance.setProperty(property, JSON.stringify(value));
+                        } catch (e) {
+                            instance.setProperty(property, value);
+                        }
+                        return;
+                    }
+                    instance.setProperty(property, value);
+                };
+            }
+            if ('value' in propertyDefinion && propertyDefinion.value === undefined) {
+                delete propertyDefinion.value;
+                if ('writable' in propertyDefinion) delete propertyDefinion.writable;
+            }
+            try {
+                Object.defineProperty(instance, property, propertyDefinion);
+            } catch (e) {
+                throw new BdORMError(
+                    `Invalid property descriptor "${property}" ${propertyDefinion.value} in ${instance.constructor.name}`,
+                );
+            }
+            // data toevoegen
+            if (data[property] !== undefined) instance[property] = data[property];
+        });
+    };
+
+/**
+ * Class which only contains the getters and setters for the base ORM
+ */
+abstract class BdORMBase {
+    /**
+     * Properties will be defined in the constructor (see definePropertyDescriptors)
+     */
+    [key: string]: any;
+
+    /**
+     * @returns the model name
+     */
+    public static getModelName(): string {
+        return this.name;
+    }
+
+    constructor(data: Record<string, any> = {}) {
+        const ormData = { ...data };
+        // primary key to 0 if not present
+        const primaryKey = this.getPrimaryKey();
+        if (!(primaryKey in ormData)) {
+            ormData[primaryKey] = 0; // 0 means new entry
+        }
+        // required property check
+        if (this.getRequiredProperties().length > 0) {
+            this.getRequiredProperties().forEach(property => {
+                if (!(property in ormData)) throw new BdORMError(`Property "${property}" is required`);
+            });
+        }
+        // set properties
+        definePropertyDescriptors(this, ormData);
+    }
+
+    /**
+     * This method is ONLY used in the FETCH method
+     * @returns the columns to fetch from the database
+     */
+    public static readonly COLUMNS_TO_FETCH: string | string[] = '*';
+
+    /**
+     * which default methods are not allowed to be used
+     * for example: ['delete'] will prevent you from using model.delete();
+     */
+    public static readonly METHODS_NOT_ALLOWED: string[] = [];
+
+    /**
+     * Get the primary key for the current table
+     * @returns the primary key for the current table
+     */
+    public static readonly PRIMARY_KEY: string = 'id';
+
+    /**
+     * Specify which properties should be set as read-only.
+     * These properties can only be set once, when the object is created.
+     * @return array
+     */
+    public static readonly PROPERTIES_NOT_ALLOWED_TO_CHANGE: string[] = [];
+
+    /**
+     * If there are values that should not be duplicated,
+     * specify here which properties those should be.
+     * @return array
+     */
+    public static readonly PROPERTIES_NOT_ALLOWED_TO_DUPLICATE: string[] = [];
+
+    /**
+     * Specify which properties are required when creating a new object.
+     * @return array
+     */
+    public static readonly REQUIRED_PROPERTIES: string[] = [];
+
+    public static isMethodAllowed(method: string, { throwErrorIfNotAllowed = false } = {}): boolean {
+        const allowed = !this.METHODS_NOT_ALLOWED.includes(method);
+        if (!allowed && throwErrorIfNotAllowed) {
+            throw new BdORMError(`Method "${method}" not allowed`);
+        }
+        return allowed;
+    }
+
+    /**
+     * Get the table name as used in the database
+     * @returns the table name as used in the database
+     */
+    public static readonly DB_TABLE: string;
+    public static get TABLE(): string {
+        if (!this.DB_TABLE) throw BdORMError.staticNotImplemented('get TABLE()');
+        return this.DB_TABLE;
+    }
+
+    /**
+     * Sometimes you want to use a custom view to read your model data
+     * @returns the view name as used in the database
+     */
+    public static readonly DB_VIEW: string;
+    public static get VIEW(): string {
+        return this.DB_VIEW ?? this.TABLE;
+    }
+
+    protected _setChangedProperties(changedProperties: string[]): void {
+        const local = LOCAL_WEAKMAP.get(this) || {};
+        LOCAL_WEAKMAP.set(this, {
+            ...local,
+            changedProperties,
+        });
+    }
+
+    /**
+     * @returns the changed properties
+     */
+    public getChangedProperties(): string[] {
+        return !this.isNew() ? (getLocalWeakMapValue(this, 'changedProperties') ?? []) : [];
+    }
+
+    /**
+     * @returns the data in json format
+     * @paaam {boolean} [preventFormatting=false] - prevent formatting of the data
+     */
+    getData(preventFormatting = false): Record<string, any> {
+        const data: Record<string, any> = {},
+            returnData: Record<string, any> = {};
+        const properties = PROPERTIES_WEAKMAP.get(this) ?? {};
+        Object.keys(properties).forEach(property => {
+            data[property] = this.getProperty(property, { preventFormatting });
+            returnData[property] = preventFormatting ? data[property] : (this[property] ?? data[property]);
+        });
+        return returnData;
+    }
+
+    /**
+     * @returns the primary key for the current table
+     */
+    public getPrimaryKey(): string {
+        return (this.constructor as typeof BdORMBase).PRIMARY_KEY;
+    }
+
+    public getPrimaryKeyValue(): number {
+        return this.getProperty(this.getPrimaryKey()) as number;
+    }
+
+    /**
+     * get the model property
+     */
+    public getProperty(key: string, { preventFormatting = false } = {}): string | number | null | undefined {
+        const properties = PROPERTIES_WEAKMAP.get(this) ?? {};
+        let value = key in properties ? properties[key] : null; // never properties[key] as it can be set to null, undefined or 0
+        if (!preventFormatting && value instanceof Buffer) value = value.toString();
+        return value;
+    }
+
+    /**
+     * @returns the columns of the required properties needed to create a new object
+     */
+    public getRequiredProperties(): string[] {
+        return (this.constructor as typeof BdORMBase).REQUIRED_PROPERTIES;
+    }
+
+    /**
+     * Get the table name as used in the database
+     * @returns the table name as used in the database
+     */
+    public getTable(): string {
+        return (this.constructor as typeof BdORMBase).TABLE;
+    }
+
+    /**
+     *
+     * @returns
+     */
+    public hasChanges(): boolean {
+        return this.getChangedProperties().length > 0;
+    }
+
+    /**
+     * Check if the property has been changed
+     */
+    public hasPropertyValueChanged(property: string): boolean {
+        return this.getChangedProperties().includes(property);
+    }
+
+    /**
+     * Check if the current object is a new object
+     * @returns true if the object is new, false if it is not
+     */
+    public isNew(): boolean {
+        return !this.getPrimaryKeyValue();
+    }
+
+    public setProperty(property: string, value: any, { forceChange = false } = {}): void {
+        // prevent overwrite of primary key
+        if (property === this.getPrimaryKey() && this.getPrimaryKeyValue() && this.getPrimaryKeyValue() !== value) {
+            throw new BdORMError(`Primary key cannot be changed from ${this.getPrimaryKeyValue()} to ${value}`);
+        }
+        // prevent overwrite of read-only properties
+        if (
+            !forceChange &&
+            !this.isNew() &&
+            (this.constructor as typeof BdORMBase).PROPERTIES_NOT_ALLOWED_TO_CHANGE.includes(property) &&
+            ![undefined, null].includes(this.getProperty(property) as null) &&
+            this.getProperty(property) != value // != is used to check for null and undefined
+        ) {
+            throw new BdORMError(`Property "${property}" is not allowed to be changed`);
+        }
+        if (!this.isNew() && this.getPrimaryKey() === property && this.getPrimaryKeyValue() !== value) {
+            throw new BdORMError(`Primary key "${property}" is not allowed to be changed`);
+        }
+        // set changed flag
+        const origValue = this.getProperty(property);
+        if (![undefined, null].includes(this.getProperty(property) as null) && origValue !== value) {
+            // todo set orig
+            const changedProperties = this.getChangedProperties();
+            if (!changedProperties.includes(property)) {
+                changedProperties.push(property);
+                this._setChangedProperties(changedProperties);
+            }
+        }
+        // waarde instellen
+        const properties = PROPERTIES_WEAKMAP.get(this) ?? {};
+        properties[property] = value;
+        PROPERTIES_WEAKMAP.set(this, properties);
+    }
+}
+
+export default BdORMBase;
+export { definePropertyDescriptors };

package/src/_/BdORMCrud.test.ts

@@ -0,0 +1,198 @@
+import BdOrmDbConnectionCapSqlite from '../dbConnections/BdOrmDbConnectionCapSqlite';
+import BdOrm from '../index';
+import User from '../test-assets/User';
+import { expectErrorMessage } from '../test-assets/jestUtils';
+import cds from '@sap/cds';
+
+describe('bd-orm BdORMCrud', () => {
+    let dbConnection: BdOrmDbConnectionCapSqlite;
+    //beforeEach(() => {
+    BdOrm.clearDbConnection();
+    dbConnection = new BdOrmDbConnectionCapSqlite(__dirname + '/../test-assets/db');
+    BdOrm.setDbConnection(dbConnection);
+    //});
+
+    it('Prevent setting the db connection twice', () => {
+        expectErrorMessage(async () => BdOrm.setDbConnection(dbConnection), 'DbConnection already set');
+    });
+
+    it("Count the number of users in the database, it's 2", async () => {
+        const count = await User.count();
+        expect(count).toBe(2);
+    });
+
+    it('Create a user ', async () => {
+        const user = new User({ firstname: 'Test', lastname: 'Persoon' });
+        await user.save();
+        expect(user.id).toBe(3);
+        const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = 3');
+        expect(results[0].firstname).toBe('Test');
+        expect(results[0].lastname).toBe('Persoon');
+        // alternate creation method
+        const user2 = await User.create({ firstname: 'Test2', lastname: 'Persoon2' });
+        expect(user2.id).toBe(4);
+        const results2 = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = 4');
+        expect(results2[0].firstname).toBe('Test2');
+        expect(results2[0].lastname).toBe('Persoon2');
+    });
+
+    it('Create a user with properties that are not in the table', async () => {
+        const user = new User({ firstname: 'Invalid', lastname: 'Property', invalidprop: 'sadf' });
+        await user.save();
+        const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = ?', [user.id]);
+        expect(results[0].firstname).toBe('Invalid');
+        expect(results[0].lastname).toBe('Property');
+    });
+
+    it('Delete a user', async () => {
+        // first add a user
+        const user = await User.create({ firstname: 'Delete', lastname: 'Me' });
+        const id = user.id;
+        const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = ?', [id]);
+        expect(results).toHaveLength(1);
+        // then delete the user
+        await user.delete();
+        const resultsAfterDelete = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = ?', [id]);
+        expect(resultsAfterDelete).toHaveLength(0);
+        const resultsAfterDelete2 = await dbConnection.query('SELECT * FROM bdorm_user WHERE firstname = ?', [
+            'Delete',
+        ]);
+        expect(resultsAfterDelete2).toHaveLength(0);
+    });
+
+    it('Fetch a user by id', async () => {
+        const user = await User.fetchByPrimaryKey(1);
+        expect(user).toBeInstanceOf(User);
+        expect(user?.firstname).toBe('John');
+        expect(user?.lastname).toBe('Doe');
+
+        const user2 = await User.fetchById(2);
+        expect(user2).toBeInstanceOf(User);
+        expect(user2?.firstname).toBe('Barry');
+        expect(user2?.lastname).toBe('Dam');
+    });
+
+    it('Fetch multiple users', async () => {
+        const users = await User.fetch();
+        expect(users[0]).toBeInstanceOf(User);
+        expect(users[1]).toBeInstanceOf(User);
+        expect(users[0].firstname).toBe('John');
+        expect(users[1].firstname).toBe('Barry');
+    });
+
+    it('Fetch with a where clause as object', async () => {
+        const users = await User.fetch({ firstname: 'John' });
+        expect(users).toHaveLength(1);
+        expect(users[0].firstname).toBe('John');
+        expect(users[0].lastname).toBe('Doe');
+    });
+
+    it('Fetch with a where clause as string', async () => {
+        const users = await User.fetch('firstname = ?', ['Barry']);
+        expect(users).toHaveLength(1);
+        expect(users[0].firstname).toBe('Barry');
+        expect(users[0].lastname).toBe('Dam');
+    });
+
+    it("Fetch where clause that doesn't match", async () => {
+        const user = await User.fetch({ firstname: 'Barry', lastname: 'Doe' });
+        expect(user.length).toBe(0);
+    });
+
+    it('Fetch One', async () => {
+        const user = await User.fetchOne({ firstname: 'Barry' });
+        expect(user).toBeInstanceOf(User);
+        expect(user?.firstname).toBe('Barry');
+        expect(user?.lastname).toBe('Dam');
+    });
+
+    it('Update a user', async () => {
+        const user = await User.fetchById(1);
+        expect(user).toBeInstanceOf(User);
+        if (!user) throw new Error('User not found');
+        const firstname = user.firstname;
+        user.firstname = 'Jane';
+        await user.save();
+        const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = 1');
+        expect(results[0].firstname).toBe('Jane');
+        user.firstname = firstname;
+        await user.save();
+        const results2 = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = 1');
+        expect(results2[0].firstname).toBe('John');
+    });
+
+    it('Should save JSON options as a string in the db', async () => {
+        const user = new User({ firstname: 'Json', lastname: 'Persoon', options: { test: 'test 123' } });
+        await user.save();
+        const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE firstname = ?', ['Json']);
+        expect(results[0].options).toBe('{"test":"test 123"}');
+        const userJSON = await User.fetchOne({ firstname: 'Json' });
+        expect(userJSON?.options).toEqual({ test: 'test 123' });
+        expect(userJSON?.options?.test).toEqual('test 123');
+    });
+
+    it('Should not allow me to run delete and save', async () => {
+        class userNotAllowedDeleteAndSave extends User {
+            static readonly METHODS_NOT_ALLOWED = ['save', 'delete'];
+        }
+        const user = new userNotAllowedDeleteAndSave({ firstname: 'Json', lastname: 'Persoon' });
+        expectErrorMessage(async () => {
+            await user.save();
+        }, 'Method "save" not allowed');
+        expectErrorMessage(async () => {
+            await user.delete();
+        }, 'Method "delete" not allowed');
+    });
+
+    it('Columns to fetch is altered and works correctly', async () => {
+        class UserWithColumnsToFetch extends User {
+            static readonly COLUMNS_TO_FETCH = ['id', 'firstname'];
+        }
+        const users = await UserWithColumnsToFetch.fetch();
+        expect(users[0]).toBeInstanceOf(UserWithColumnsToFetch);
+        expect(users[0].firstname).toBe('John');
+        expect(users[0].lastname).toBeUndefined();
+        class UserWithColumnsToFetch2 extends User {
+            static readonly COLUMNS_TO_FETCH = 'id, firstname, lastname as achternaam';
+        }
+        const user = await UserWithColumnsToFetch2.fetchOne('firstname = ? and lastname = ?', ['John', 'Doe']);
+        expect(user).toBeInstanceOf(UserWithColumnsToFetch2);
+        expect(user?.firstname).toBe('John');
+        expect(user?.lastname).toBeUndefined();
+        expect(user?.achternaam).toBe('Doe');
+        expect(user?.fullname).toBeUndefined();
+    });
+
+    describe('Duplicate tests', () => {
+        it('Should duplicate the user as draft and remove dateCreated', async () => {
+            const user = await User.fetchById(1); // John Doe
+            const user2 = await user?.duplicate({ asDraft: true });
+            expect(user2).toBeInstanceOf(User);
+            expect(user2?.firstname).toBe('John');
+            expect(user2?.lastname).toBe('Doe');
+            expect(user2?.isNew()).toBe(true);
+            expect(user2?.dateCreated).toBeUndefined();
+        });
+        it('Should duplicate the user as draft and set the firstname to Johnny', async () => {
+            const user = await User.fetchById(1); // John Doe
+            const user2 = await user?.duplicate({ asDraft: true, newData: { firstname: 'Johnny' } });
+            expect(user2).toBeInstanceOf(User);
+            expect(user2?.firstname).toBe('Johnny');
+            expect(user2?.lastname).toBe('Doe');
+            expect(user2?.isNew()).toBe(true);
+        });
+        it('Should duplicate the user and save it to the DB', async () => {
+            const user = await User.fetchById(1); // John Doe
+            const user2 = await user?.duplicate();
+            expect(user2).toBeInstanceOf(User);
+            expect(user2?.firstname).toBe('John');
+            expect(user2?.lastname).toBe('Doe');
+            expect(user2?.isNew()).toBe(false);
+            expect(user2?.dateCreated).not.toBeUndefined();
+            const results = await dbConnection.query('SELECT * FROM bdorm_user WHERE id = ?', [user2?.id]);
+            expect(results[0].firstname).toBe('John');
+            expect(results[0].lastname).toBe('Doe');
+            expect(results[0].id).toBe(user2?.id);
+        });
+    });
+});