bd-orm 0.0.1

package/src/_/BdORMCrud.ts

@@ -0,0 +1,240 @@
+import BdORMBase, { definePropertyDescriptors } from './BdORMBase';
+import { BdORMError } from './BdORMError';
+import type BdOrmDbConnection from './BdOrmConnection';
+
+type MethodParams<K extends string> = {
+    [key in K]?: any;
+};
+
+export type BdORMDuplicateNewDataMethod = (v: any) => string | boolean | null | number;
+export interface BdORMDuplicateParams {
+    asDraft?: boolean; // if true, the duplicate will be created as a draft and not saved to the db
+    newData?: { [key: string]: string | boolean | null | number | BdORMDuplicateNewDataMethod };
+    excludeColumns?: string[];
+}
+
+const _filerDataByTable = async (self: BdORMCrud): Promise<Record<string, any>> => {
+    const data = self.getData(true);
+    const columns = await (self.constructor as typeof BdORMCrud).getDbConnection().getTableColumns(self.getTable());
+    return Object.keys(data).reduce((acc, key) => {
+        if (columns.includes(key)) acc[key] = data[key];
+        return acc;
+    }, {} as Record<string, any>);
+};
+
+export default class BdORMCrud extends BdORMBase {
+    private static _DbConnection: InstanceType<typeof BdOrmDbConnection>;
+
+    // Events
+    protected async beforeCreate<K extends string>(beforeCreateParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async beforeUpdate<K extends string>(beforeUpdateParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async beforeSave<K extends string>(beforeSaveParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async afterCreate<K extends string>(afterCreateParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async afterUpdate<K extends string>(afterUpdateParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async afterSave<K extends string>(afterSaveParams?: MethodParams<K>) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    protected async beforeDelete() {}
+    protected async afterDelete() {}
+
+    private _execDBConnectionMethod(
+        method: 'create',
+        table: string,
+        data: Record<string, any>,
+    ): Promise<Record<string, any>>;
+    private _execDBConnectionMethod(
+        method: 'update',
+        table: string,
+        data: Record<string, any>,
+        options?: { primaryKey: string },
+    ): Promise<Record<string, any>>;
+    private _execDBConnectionMethod(
+        method: 'delete',
+        table: string,
+        primaryKeyValue: string | number,
+        options?: { primaryKey: string },
+    ): Promise<unknown>;
+    private _execDBConnectionMethod(method: keyof BdOrmDbConnection, ...args: any[]): Promise<any> {
+        //@ts-ignore
+        return (this.constructor as typeof BdORMCrud)._DbConnection[method](...args);
+    }
+
+    private async _create({ preventBeforeCreate = false, preventAfterCreate = false } = {}): Promise<
+        Record<string, any>
+    > {
+        if (!preventBeforeCreate) await this.beforeCreate();
+        const data = await _filerDataByTable(this),
+            primaryKey = this.getPrimaryKey();
+        if (primaryKey in data) delete data[primaryKey];
+        const result = { ...(await this._execDBConnectionMethod('create', this.getTable(), data)) };
+        const primaryKeyValue = primaryKey in result ? result[primaryKey] : false;
+        if (primaryKeyValue) delete result[primaryKey];
+        // when creating a new entry, it is not necessary to add all columns
+        // and with an insert, you get all columns back from the db
+        // so recreate the propertyDescriptors
+        definePropertyDescriptors(this, result);
+        // important AFTER definePropertyDescriptors
+        if (primaryKeyValue) this.setProperty(primaryKey, primaryKeyValue);
+        if (!preventAfterCreate) await this.afterCreate();
+        this._setChangedProperties([]);
+        return {
+            [primaryKey]: primaryKeyValue,
+            ...result,
+        };
+    }
+
+    private async _update({ preventBeforeUpdate = false, preventAfterUpdate = false } = {}): Promise<void> {
+        if (this.isNew()) throw new BdORMError('Cannot update an new instance');
+        if (!preventBeforeUpdate) await this.beforeUpdate();
+        const data = await _filerDataByTable(this);
+        await this._execDBConnectionMethod('update', this.getTable(), data, {
+            primaryKey: this.getPrimaryKey(),
+        });
+        if (!preventAfterUpdate) await this.afterUpdate();
+    }
+
+    /**
+     * Delete an instance from the database
+     */
+    async delete(): Promise<void> {
+        (this.constructor as typeof BdORMCrud).isMethodAllowed('delete', { throwErrorIfNotAllowed: true });
+        if (!this.id) {
+            throw new BdORMError('Cannot delete an instance without an id');
+        }
+        await this.beforeDelete();
+        await this._execDBConnectionMethod('delete', this.getTable(), this.getPrimaryKeyValue(), {
+            primaryKey: this.getPrimaryKey(),
+        });
+        await this.afterDelete();
+    }
+
+    /**
+     * Duplicates the current instance and if the options asDraft is not defined or false it will be saved it to the database
+     */
+    async duplicate({ asDraft = false, newData = {}, excludeColumns = [] }: BdORMDuplicateParams = {}): Promise<
+        InstanceType<typeof BdORMCrud>
+    > {
+        const self = this.constructor as typeof BdORMCrud;
+        self.isMethodAllowed('duplicate', { throwErrorIfNotAllowed: true });
+        if (!asDraft && this.isNew()) throw new BdORMError('Cannot duplicate an new instance');
+        const data = { ...this.getData(true) };
+        const primaryKey = this.getPrimaryKey();
+        if (primaryKey in data) delete data[primaryKey];
+        for (const key in data) {
+            if (excludeColumns.includes(key) || self.PROPERTIES_NOT_ALLOWED_TO_DUPLICATE.includes(key)) {
+                delete data[key];
+                continue;
+            }
+            if (key in newData) data[key] = typeof newData[key] === 'function' ? newData[key](data[key]) : newData[key];
+        }
+        const newInstance = new self(data);
+        if (!asDraft) await newInstance.save({ preventBeforeSave: true, preventAfterSave: true });
+        return newInstance;
+    }
+
+    async save({
+        beforeSaveParams = {},
+        afterSaveParams = {},
+        preventAfterSave = false,
+        preventBeforeSave = false,
+    } = {}): Promise<InstanceType<typeof BdORMCrud>> {
+        (this.constructor as typeof BdORMCrud).isMethodAllowed('save', { throwErrorIfNotAllowed: true });
+        await this.beforeSave(beforeSaveParams);
+        if (this.isNew()) {
+            await this._create({ preventBeforeCreate: preventBeforeSave, preventAfterCreate: preventAfterSave });
+        } else {
+            await this._update({ preventBeforeUpdate: preventBeforeSave, preventAfterUpdate: preventAfterSave });
+        }
+        if (!preventAfterSave) {
+            await this.afterSave(afterSaveParams);
+        }
+        return this;
+    }
+
+    // STATICS
+
+    static async count(where?: Record<string, any> | string, values?: any[]): Promise<number> {
+        const result = await this._DbConnection.list(this.VIEW, {
+            columns: 'COUNT(*) as count',
+            filters: where,
+            values,
+        });
+        return result[0].count;
+    }
+
+    static async create<T extends typeof BdORMCrud>(this: T, data: any): Promise<InstanceType<T>> {
+        const instance = new this(data) as InstanceType<T>;
+        await instance.save();
+        return instance;
+    }
+
+    public static async fetch<T extends typeof BdORMCrud>(
+        this: T,
+        where?: Record<string, any> | string,
+        values?: any[],
+    ): Promise<InstanceType<T>[]> {
+        const results = await this._DbConnection.list(this.VIEW, {
+            columns: this.COLUMNS_TO_FETCH as string,
+            filters: where,
+            values,
+        });
+        return results.map((result: Record<string, any>) => new this(result) as InstanceType<T>);
+    }
+
+    public static async fetchById<T extends typeof BdORMCrud>(
+        this: T,
+        id: string | number,
+    ): Promise<InstanceType<T> | undefined> {
+        return this.fetchByPrimaryKey(id);
+    }
+
+    public static async fetchOne<T extends typeof BdORMCrud>(
+        this: T,
+        where: Record<string, any> | string,
+        values?: any[],
+    ): Promise<InstanceType<T> | undefined> {
+        let limit;
+        if (typeof where === 'string') where += ' LIMIT 1';
+        else limit = 1;
+        const results = await this._DbConnection.list(this.VIEW, {
+            columns: this.COLUMNS_TO_FETCH as string,
+            filters: where,
+            limit,
+            values,
+        });
+        return results?.length ? (new this(results[0]) as InstanceType<T>) : undefined;
+    }
+
+    public static async fetchByPrimaryKey<T extends typeof BdORMCrud>(
+        this: T,
+        primaryKeyValue: string | number,
+    ): Promise<InstanceType<T> | undefined> {
+        const primaryKey = await this._DbConnection.getTablePrimaryKey(this.TABLE);
+        const result = await this._DbConnection.read(this.VIEW, primaryKeyValue, { primaryKey });
+        if (!result)
+            throw new BdORMError(`No entry found for ${this.VIEW} with ${this.PRIMARY_KEY} ${primaryKeyValue}`);
+        return new this(result) as InstanceType<T>;
+    }
+
+    public static setDbConnection(dbConnection: InstanceType<typeof BdOrmDbConnection>) {
+        if (this._DbConnection) throw new BdORMError('DbConnection already set');
+        this._DbConnection = dbConnection;
+    }
+    public static clearDbConnection() {
+        //@ts-ignore
+        this._DbConnection = undefined;
+    }
+    public static getDbConnection() {
+        return this._DbConnection;
+    }
+}

package/src/_/BdORMError.ts

@@ -0,0 +1,10 @@
+export class BdORMError extends Error {
+    constructor(msg: string) {
+        super(`[bd-Orm Error]: ${msg}`);
+        Error.captureStackTrace(this, BdORMError);
+        this.name = 'BdORMError';
+    }
+    static staticNotImplemented(methodName: string) {
+        return new BdORMError(`static ${methodName} not implemented! Set in derived class`);
+    }
+}

package/src/_/BdORMbase.test.ts

@@ -0,0 +1,166 @@
+import { expectErrorMessage, expectToBes } from '../test-assets/jestUtils';
+import BaseORM from './BdORMBase';
+import { BdORMError } from './BdORMError';
+
+describe('bd-orm baseORM', () => {
+    describe('Errors if implementation has not been done', () => {
+        const staticGetters = ['TABLE'];
+        class SubTestWithOutImplementations extends BaseORM {}
+        it('Static getters', () => {
+            staticGetters.forEach(method => {
+                expectErrorMessage(async () => {
+                    //@ts-ignore
+                    SubTestWithOutImplementations[method];
+                }, BdORMError.staticNotImplemented(`get ${method}()`).message);
+            });
+        });
+    });
+
+    describe('public getters', () => {
+        interface Sub {
+            name: string;
+            age: number;
+        }
+        class Sub extends BaseORM {
+            public static PROPERTIES_NOT_ALLOWED_TO_CHANGE = ['name'];
+            public static DB_TABLE = 'Sub_TABLE';
+        }
+        const newSubInstance = new Sub({
+            name: 'Barry Dam',
+            age: 38,
+        });
+
+        // All tests below are in case of a NEW entry
+
+        expectToBes({
+            'getTable()': {
+                test: () => newSubInstance.getTable(),
+                toBe: 'Sub_TABLE',
+            },
+            VIEW: { test: () => Sub.VIEW, toBe: 'Sub_TABLE' },
+            getPrimaryKey: { test: () => newSubInstance.getPrimaryKey(), toBe: 'id' },
+            getPrimaryKeyValue: { test: () => newSubInstance.getPrimaryKeyValue(), toBe: 0 },
+            getProperty: {
+                test: () => newSubInstance.getProperty('name'),
+                toBe: 'Barry Dam',
+            },
+            getData: {
+                test: () => JSON.stringify(newSubInstance.getData()),
+                toBe: JSON.stringify({ name: 'Barry Dam', age: 38, id: 0 }),
+            },
+            getModelName: { test: () => Sub.getModelName(), toBe: 'Sub' },
+            setProperty: {
+                test: () => {
+                    newSubInstance.setProperty('age', 40);
+                    const a = newSubInstance.getProperty('age'),
+                        b = newSubInstance.age;
+                    return b === a && a === 40;
+                },
+                toBe: true,
+            },
+            isNew: {
+                test: () => newSubInstance.isNew(),
+                toBe: true,
+            },
+            name: {
+                test: () => {
+                    newSubInstance.name = 'John Doe';
+                    return newSubInstance.getProperty('name');
+                },
+                toBe: 'John Doe',
+            },
+        });
+
+        // All tests below are in case of a existing entry
+        const existingSubInstance = new Sub({
+            id: 1,
+            name: 'Barry Dam',
+            age: 38,
+        });
+
+        it("Should not allow to change the primary key after it's set", () => {
+            expectErrorMessage(async () => {
+                existingSubInstance.id = 2;
+            }, 'Primary key cannot be changed from 1 to 2');
+        });
+
+        it("Should not allow to change the name after it's set", () => {
+            expectErrorMessage(async () => {
+                existingSubInstance.setProperty('name', 'new name');
+            }, 'Property "name" is not allowed to be changed');
+            expectErrorMessage(async () => {
+                existingSubInstance.name = 'new name';
+            }, 'Property "name" is not allowed to be changed');
+        });
+    });
+
+    describe('Property changed checks', () => {
+        class PropChanged extends BaseORM {
+            public static get TABLE(): string {
+                return 'PropChanged_TABLE';
+            }
+
+            static get PROPERTIES_NOT_ALLOWED_TO_CHANGE() {
+                return ['age'];
+            }
+        }
+        const propChangedNewInstance = new PropChanged({
+                name: 'Barry Dam',
+                age: 38,
+            }),
+            propChangedExistingInstance = new PropChanged({
+                id: 1,
+                name: 'Barry Dam',
+                age: 38,
+            });
+        it('hasChanges checks', () => {
+            expect(propChangedNewInstance.hasChanges()).toBe(false);
+            propChangedNewInstance.name = 'John Doe';
+            // since the name has changed, but the instance is new, it should still return false
+            expect(propChangedNewInstance.hasChanges()).toBe(false);
+            // existing instance fetched from db should not have changes
+            expect(propChangedExistingInstance.hasChanges()).toBe(false);
+            // same name as before, so no changes
+            propChangedExistingInstance.name = 'Barry Dam';
+            expect(propChangedExistingInstance.hasChanges()).toBe(false);
+            // name has changed, so changes
+            propChangedExistingInstance.name = 'John Doe';
+            expect(propChangedExistingInstance.hasChanges()).toBe(true);
+        });
+        it('hasPropertyChanged checks', () => {
+            expect(propChangedNewInstance.hasPropertyValueChanged('name')).toBe(false);
+            propChangedNewInstance.name = 'John Doe';
+            expect(propChangedNewInstance.hasPropertyValueChanged('name')).toBe(false);
+            propChangedExistingInstance.name = 'John Doe';
+            expect(propChangedExistingInstance.hasPropertyValueChanged('name')).toBe(true);
+        });
+        it("Should throw an error if a property that can't be changed is changed", () => {
+            expectErrorMessage(async () => {
+                propChangedExistingInstance.age = 40;
+            }, 'Property "age" is not allowed to be changed');
+        });
+    });
+
+    describe('Constructor checks', () => {
+        interface ConstructorBdOrm {
+            id: number;
+            name: string;
+        }
+        class ConstructorBdOrm extends BaseORM {
+            public static get REQUIRED_PROPERTIES(): string[] {
+                return ['name'];
+            }
+        }
+
+        it('Should throw an error if a required property is not set', () => {
+            expectErrorMessage(async () => {
+                new ConstructorBdOrm();
+            }, 'Property "name" is required');
+        });
+
+        it('Should set the primary key to 0 on creating a new instance', () => {
+            const orm = new ConstructorBdOrm({ name: 'test' });
+            expect(orm.id).toBe(0);
+        });
+    });
+});

package/src/_/BdOrmConnection.ts

@@ -0,0 +1,39 @@
+export default abstract class BdOrmDbConnection {
+    /**
+     * Create a new entry in the table
+     * @param table The table to create the entry in
+     * @param data The data to create the entry with
+     * @param params Additional parameters
+     * @returns The created entry
+     */
+    public abstract create(
+        table: string,
+        data: Record<string, any>,
+        params?: { primaryKey: string },
+    ): Promise<Record<string, any>>;
+    public abstract read(
+        table: string,
+        primaryKeyValue: string | number,
+        params?: { primaryKey: string },
+    ): Promise<Record<string, any> | undefined>;
+    public abstract update(table: string, data: any, params?: { primaryKey: string }): Promise<void>;
+    public abstract delete(
+        table: string,
+        primaryKeyValue: string | number,
+        params?: { primaryKey: string },
+    ): Promise<void>;
+    public abstract list(
+        table: string,
+        params?: {
+            columns?: string | string[];
+            filters?: Record<string, any> | string;
+            limit?: number;
+            offset?: number;
+            orderBy?: string;
+            values?: any[];
+        },
+    ): Promise<Record<string, any>[]>;
+    public abstract query(query: string, escapedValues?: any[]): Promise<Record<string, any>[]>;
+    public abstract getTablePrimaryKey(table: string): Promise<string>;
+    public abstract getTableColumns(table: string): Promise<string[]>;
+}

package/src/_/cdsBaseOrm.ts

@@ -0,0 +1,18 @@
+import BaseORM from './BdORMBase';
+import cds from '@sap/cds';
+
+/**
+ * Base class for CDS ORM
+ */
+export default abstract class cdsBaseOrm extends BaseORM {
+    /**
+     * Get the CDS model for the current table
+     * @returns the CDS model for the current table
+     */
+    static get CDS_MODEL(): cds.entity | undefined {
+        const namespace = this.TABLE.split('_')[0].toLowerCase();
+        return Object.values(cds.entities(namespace)).find(
+            (o: any) => 'name' in o && o.name.toUpperCase().replace(/\./g, '_') === this.TABLE,
+        );
+    }
+}

package/src/dbConnections/BdOrmDbConnectionCapHana/index.ts

@@ -0,0 +1,95 @@
+/**
+ * Use this connection when your project is using SAP CAP and running a SAP HANA DB
+ * This class extends the BdOrmDbConnectionSQLBase and provides methods to interact with a SQLite database
+ * Need to work with unit tests? use the BdOrmDbConnectionCapSqlite class
+ */
+import { BdORMError } from '../../_/BdORMError';
+import BdOrmDbConnectionSQLBase from '../BdOrmDbConnectionSQLBase';
+import { getTableColumns, getTablePrimaryKey } from './utils';
+import cds from '@sap/cds';
+
+const PRIMARY_KEYS: Record<string, string> = {};
+const TABLE_COLUMNS: Record<string, string[]> = {};
+
+const remapResultColumns = (result: Record<string, any>, columns: string[]) => {
+    return Object.entries(result).reduce((resultMapped, [key, value]) => {
+        const column = columns.find(column => column.toUpperCase() === key.toUpperCase());
+        resultMapped[column ?? key] = value;
+        return resultMapped;
+    }, {} as Record<string, any>);
+};
+
+export default class BdOrmDbConnectionCapHana extends BdOrmDbConnectionSQLBase {
+    protected async _db() {
+        return cds.db ? cds.db : await cds.connect.to('db');
+    }
+
+    public async close() {
+        const db = await this._db();
+        //@ts-ignore jest zegt cds.disconnect does not exists
+        await db.disconnect();
+    }
+
+    public async getTableColumns(table: string): Promise<string[]> {
+        const cdsColumns = getTableColumns(table);
+        if (cdsColumns) return cdsColumns;
+        if (TABLE_COLUMNS[table]) return TABLE_COLUMNS[table];
+        const tableInfo: { COLUMN_NAME: string }[] = await this.query(
+            `SELECT COLUMN_NAME FROM TABLE_COLUMNS WHERE TABLE_NAME = '${table}'`,
+        );
+        if (tableInfo.length === 0) throw new BdORMError(`No columns found for table ${table}`);
+        TABLE_COLUMNS[table] = tableInfo.map(info => info.COLUMN_NAME);
+        return TABLE_COLUMNS[table];
+    }
+
+    /**
+     * Get the primary key of the table
+     */
+    public async getTablePrimaryKey(table: string): Promise<string> {
+        const primaryKey = getTablePrimaryKey(table);
+        if (primaryKey) return primaryKey;
+        if (PRIMARY_KEYS[table]) return PRIMARY_KEYS[table];
+        const tableInfo: [{ COLUMN_NAME: string }] = await this.query(
+            `SELECT COLUMN_NAME FROM SYS.INDEX_COLUMNS WHERE TABLE_NAME = '${table}' AND CONSTRAINT = 'PRIMARY KEY'`,
+        );
+        PRIMARY_KEYS[table] = tableInfo[0]?.COLUMN_NAME;
+        if (!PRIMARY_KEYS[table]) throw new BdORMError(`No primary key found for table ${table}`);
+        return PRIMARY_KEYS[table];
+    }
+
+    public async create(table: string, data: Record<string, any>) {
+        const columns = Object.keys(data),
+            placeholders = columns.map(() => '?').join(','),
+            pk = await this.getTablePrimaryKey(table);
+        await this.query(
+            `INSERT INTO ${table} (${columns.join(',')}) VALUES (${placeholders})`,
+            columns.map(column => data[column]),
+        );
+        const result = await this.query(`SELECT * FROM ${table} ORDER BY ${pk} DESC LIMIT 1`);
+        return result[0];
+    }
+
+    /**
+     * Custom overwrites for list and read > hana stores the db columns in uppercase, so we need to convert the columns to what is defined in the cds file
+     */
+    public async list(
+        table: string,
+        options: {
+            columns?: string | string[];
+            filters?: Record<string, any> | string;
+            limit?: number;
+            offset?: number;
+            orderBy?: string;
+            values?: any[];
+        } = {},
+    ) {
+        const results = await super.list(table, options),
+            columns = await this.getTableColumns(table);
+        return results?.map((result: Record<string, any>) => remapResultColumns(result, columns));
+    }
+    public async read(table: string, primaryKeyValue: string | number, { primaryKey }: { primaryKey?: string } = {}) {
+        const result = await super.read(table, primaryKeyValue, { primaryKey }),
+            columns = await this.getTableColumns(table);
+        return result ? remapResultColumns(result, columns) : result;
+    }
+}

package/src/dbConnections/BdOrmDbConnectionCapHana/utils.ts

@@ -0,0 +1,47 @@
+import cds from '@sap/cds';
+
+type CdsElements = {
+    [column: string]: { key?: boolean };
+};
+type Definitions = { [table: string]: { primaryKey: string; columnNames: string[] } };
+
+const _definitionCache: Definitions = {} as Definitions;
+
+const getDefinitions = () => {
+    if (Object.keys(_definitionCache).length) return _definitionCache;
+    const cdsDefinitions = (cds?.model?.definitions ?? cds.entities ?? {}) as unknown as {
+        [table: string]: {
+            name: string;
+            elements: CdsElements;
+        };
+    };
+    if (Object.keys(cdsDefinitions).length === 0) return undefined;
+    Object.entries(cdsDefinitions).forEach(([key, { elements, name }]) => {
+        if (elements === undefined) return;
+        (_definitionCache as unknown as Definitions)[name.toLowerCase().replace(/\./g, '_') as unknown as string] = {
+            primaryKey: Object.entries(elements).find(([_, { key }]) => key)?.[0] ?? '',
+            columnNames: Object.entries(elements).map(([column]) => column),
+        };
+    });
+    return _definitionCache;
+};
+
+const getTableDefinition = (table: string) => {
+    const definitions = getDefinitions();
+    if (!definitions) return undefined;
+    const tableDefinition = definitions[table.toLowerCase().replace(/\./g, '_')];
+    if (!tableDefinition) return undefined;
+    return tableDefinition;
+};
+const getTablePrimaryKey = (table: string) => {
+    const tableDefinition = getTableDefinition(table);
+    if (!tableDefinition) return undefined;
+    return tableDefinition.primaryKey;
+};
+const getTableColumns = (table: string) => {
+    const tableDefinition = getTableDefinition(table);
+    if (!tableDefinition) return undefined;
+    return tableDefinition.columnNames;
+};
+
+export { getDefinitions, getTableDefinition, getTablePrimaryKey, getTableColumns };

package/src/dbConnections/BdOrmDbConnectionCapHana.test.ts

@@ -0,0 +1,18 @@
+import BdOrmDbConnectionCapSqlite from '../dbConnections/BdOrmDbConnectionCapSqlite';
+import { getDefinitions, getTableColumns, getTablePrimaryKey } from './BdOrmDbConnectionCapHana/utils';
+
+describe('BdOrmDbConnectionCapHana', () => {
+    let dbConnection: BdOrmDbConnectionCapSqlite;
+    //beforeEach(() => {
+    dbConnection = new BdOrmDbConnectionCapSqlite(__dirname + '/../test-assets/db');
+    //});
+
+    test('Get the table info', async () => {
+        const db = await dbConnection.getDb();
+        //console.log(getDefinitions());
+        const pk = getTablePrimaryKey('bdorm_user');
+        expect(pk).toBe('id');
+        const columns = getTableColumns('bdorm_user');
+        expect(columns).toEqual(['id', 'firstname', 'lastname', 'email', 'dateCreated', 'options', 'deleted']);
+    });
+});