bd-orm 0.0.1

package/src/dbConnections/BdOrmDbConnectionCapSqlite/index.ts

@@ -0,0 +1,89 @@
+/**
+ * Use this connection class when writing unit tests
+ *
+ * This class extends the BdOrmDbConnection and provides methods to interact with a SQLite in-memory database
+ * for unit testing purposes. It includes functionality to create, read, update, delete, and list records
+ * in the database, as well as to execute arbitrary queries.
+ *
+ * The class maintains a record of deployed databases and primary keys for tables to optimize database
+ * operations. It uses the SAP CDS framework for database connectivity and operations.
+ *
+ * it automatically fills the database with data from the CSV files that are found in the provided database folder
+ * or from the CSV files provided in the constructor
+ */
+import { BdORMError } from '../../_/BdORMError';
+import BdOrmDbConnectionSQLBase from '../BdOrmDbConnectionSQLBase';
+import { addCsvFilesFromDBFolder, deployHdbViewFiles, fillTableFromCsv } from './utils';
+import cds from '@sap/cds';
+
+type TableInfo = { pk: number; name: string; type: string };
+
+const PRIMARY_KEYS: Record<string, string> = {};
+const TABLE_INFO: Record<string, TableInfo[]> = {};
+
+export default class BdOrmDbConnectionCapSqlite extends BdOrmDbConnectionSQLBase {
+    private readonly _csvFiles: string[] = [];
+    private _deployed: boolean = false;
+    private _dbPath: string = '';
+
+    protected async _db() {
+        let db;
+        if (!this._deployed) {
+            //@ts-ignore jest zegt cds.deploy does not exists
+            await cds.deploy(this._dbPath).to('sqlite::memory:');
+            db = await cds.connect.to('db');
+            if (!this._csvFiles.length) await addCsvFilesFromDBFolder(db, this._dbPath);
+            else {
+                for (const csvFile of this._csvFiles) {
+                    await fillTableFromCsv(
+                        db,
+                        csvFile.split('/').pop()?.replace('.csv', '').replace('-', '_') as string,
+                        csvFile,
+                    );
+                }
+            }
+            await deployHdbViewFiles(db, this._dbPath);
+            this._deployed = true;
+        }
+        return db ?? cds.connect.to('db');
+    }
+
+    public async getDb() {
+        return this._db();
+    }
+
+    constructor(dbPath: string, options?: { csvFiles: string[] }) {
+        super();
+        this._csvFiles = options?.csvFiles || [];
+        this._dbPath = dbPath;
+    }
+
+    public async getTableColumns(table: string) {
+        if (TABLE_INFO[table]) return TABLE_INFO[table].map(info => info.name);
+        const tableInfo: [TableInfo] = await this.query(`PRAGMA table_info(${table})`);
+        TABLE_INFO[table] = tableInfo;
+        return tableInfo.map(info => info.name);
+    }
+
+    /**
+     * Get the primary key of the table
+     */
+    public async getTablePrimaryKey(table: string) {
+        if (PRIMARY_KEYS[table]) return PRIMARY_KEYS[table];
+        const tableInfo: [TableInfo] = await this.query(`PRAGMA table_info(${table})`);
+        TABLE_INFO[table] = tableInfo;
+        const primaryKey = tableInfo.find(info => info.pk === 1)?.name;
+        if (!primaryKey) throw new BdORMError(`No primary key found for table ${table}`);
+        PRIMARY_KEYS[table] = primaryKey;
+        return primaryKey;
+    }
+
+    /**
+     * Fills the database with data from the CSV files provided in the constructor
+     * note the table will be emptied before filling it with the data from the CSV file
+     */
+    public async fillTableFromCsvFile(table: string, csvFile: string) {
+        const db = await this._db();
+        await fillTableFromCsv(db, table, csvFile);
+    }
+}

package/src/dbConnections/BdOrmDbConnectionCapSqlite/utils.ts

@@ -0,0 +1,75 @@
+import { BdORMError } from '../../_/BdORMError';
+import cds from '@sap/cds';
+import csv from 'csv-parser';
+import fs from 'fs';
+import path from 'path';
+
+const log = (message: string) => {
+        console.log(`[BdOrmDbConnectionCapSqlite] ${message}`);
+    },
+    fillTableFromCsv = async (db: cds.DatabaseService, table: string, csvFile: string) => {
+        try {
+            const rows: Record<string, any>[] = [];
+            await new Promise<void>((resolve, reject) => {
+                fs.createReadStream(csvFile)
+                    .pipe(csv({ separator: ';' }))
+                    .on('data', (data: Record<string, any>) => rows.push(data))
+                    .on('end', () => resolve())
+                    .on('error', error => {
+                        reject(error);
+                    });
+            });
+            // empty db
+            await db.run(`DELETE FROM ${table}`);
+            for (const row of rows) {
+                const columns = Object.keys(row),
+                    placeholders = columns.map(() => '?').join(',');
+                await db.run(
+                    `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`,
+                    Object.values(row),
+                );
+            }
+            log(`Added ${rows.length} rows in ${table} from CSV file: ${csvFile}`);
+        } catch (error) {
+            throw new BdORMError(`Error while filling table from CSV: ${(error as Error).message}`);
+        }
+    },
+    findFiles = async (currentPath: string, extname: string) => {
+        let files: string[] = [];
+        //@ts-ignore
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        //@ts-ignore
+        for (const entry of entries) {
+            const entryPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                const subfiles = await findFiles(entryPath, extname);
+                files.push(...subfiles);
+            } else if (entry.isFile() && path.extname(entry.name) === extname) {
+                files.push(entryPath);
+            }
+        }
+        return files;
+    },
+    addCsvFilesFromDBFolder = async (db: cds.DatabaseService, dbPath: string) => {
+        try {
+            const csvFiles = await findFiles(dbPath, '.csv');
+            for (const csvFile of csvFiles) {
+                await fillTableFromCsv(
+                    db,
+                    csvFile.split('/').pop()?.replace('.csv', '').replace('-', '_') as string,
+                    csvFile,
+                );
+            }
+        } catch (error) {
+            throw new BdORMError(`Error while adding CsvFilesFromDbFolder: ${(error as Error).message}`);
+        }
+    },
+    deployHdbViewFiles = async (db: cds.DatabaseService, dbPath: string) => {
+        const hdbViewFiles = await findFiles(dbPath, '.hdbview');
+        for (const hdbViewFile of hdbViewFiles) {
+            const hdbView = fs.readFileSync(hdbViewFile, 'utf8');
+            const m = await db.run(`create ${hdbView}`);
+            log(`Deployed HDB view from file: ${hdbViewFile}`);
+        }
+    };
+export { addCsvFilesFromDBFolder, fillTableFromCsv, findFiles, log, deployHdbViewFiles };

package/src/dbConnections/BdOrmDbConnectionCapSqlite.test.ts

@@ -0,0 +1,41 @@
+import BdOrmDbConnectionCapSqlite from './BdOrmDbConnectionCapSqlite';
+
+describe('bd-orm baseORMCrud', () => {
+    const dbConnection = new BdOrmDbConnectionCapSqlite(__dirname + '/../test-assets/db');
+    it('check if csv import has worked and if read works', async () => {
+        const { firstname } = await dbConnection.read('BDORM_USER', 2);
+        expect(firstname).toBe('Barry');
+    });
+    it('create worked', async () => {
+        const user = await dbConnection.create('BDORM_USER', { firstname: 'John', lastname: 'Wayne' });
+        expect(user.firstname).toBe('John');
+        expect(user.lastname).toBe('Wayne');
+        expect(user.id).toBe(3);
+    });
+
+    it('update worked', async () => {
+        await dbConnection.update('BDORM_USER', { id: 1, firstname: 'Boomer' });
+        const { firstname } = await dbConnection.read('BDORM_USER', 1);
+        expect(firstname).toBe('Boomer');
+    });
+
+    it('delete worked', async () => {
+        const users = await dbConnection.list('BDORM_USER');
+        await dbConnection.delete('BDORM_USER', 1);
+        const deleted = await dbConnection.read('BDORM_USER', 1);
+        const usersAfterDelete = await dbConnection.list('BDORM_USER');
+        expect(deleted).toBeUndefined();
+        expect(usersAfterDelete).toHaveLength(users.length - 1);
+    });
+
+    it('query worked', async () => {
+        const users = await dbConnection.query('SELECT * FROM BDORM_USER WHERE id = 2');
+        expect(users[0].firstname).toBe('Barry');
+    });
+
+    it('query a view worked', async () => {
+        const user = await dbConnection.create('BDORM_USER', { firstname: 'Test', lastname: 'Persoon' });
+        const users = await dbConnection.query('SELECT * FROM USER_VIEW WHERE lastname = ?', ['Persoon']);
+        expect(users[0].fullname).toBe('Test Persoon');
+    });
+});

package/src/dbConnections/BdOrmDbConnectionSQLBase.ts

@@ -0,0 +1,124 @@
+/**
+ * Use this class as a base class for all SQL database connections
+ * It provides methods to interact with the database, such as create, read, update, delete, and list records.
+ * It also provides methods to execute raw SQL queries and manage database connections.
+ *
+ * This class is not meant to be used directly, but rather as a base class for other database connection classes.
+ * make sure yo u implement the _db method to return the correct database connection
+ * and the getTableColumns and getTablePrimaryKey methods to return the correct table columns and primary key
+ */
+import { BdORMError } from '../_/BdORMError';
+import BdOrmDbConnection from '../_/BdOrmConnection';
+
+abstract class BdOrmDbConnectionSQLBase extends BdOrmDbConnection {
+    protected async _db(): Promise<{ run: (query: string, values?: any[]) => Promise<any> }> {
+        throw new BdORMError(`_db not implemented for ${this.constructor.name}`);
+    }
+
+    public async close() {
+        throw new BdORMError(`close not implemented for ${this.constructor.name}`);
+    }
+
+    public async create(table: string, data: Record<string, any>) {
+        const columns = Object.keys(data),
+            placeholders = columns.map(() => '?').join(',');
+        const { lastInsertRowid }: { changes: number; lastInsertRowid: number } = await this.query(
+            `INSERT INTO ${table} (${columns.join(',')}) VALUES (${placeholders})`,
+            columns.map(column => data[column]),
+        );
+        const pk = await this.getTablePrimaryKey(table);
+        const result = await this.query(`SELECT * FROM ${table} WHERE ${pk} = ${lastInsertRowid}`);
+        return result[0];
+    }
+
+    public async delete(table: string, primaryKeyValue: string | number) {
+        const primaryKey = await this.getTablePrimaryKey(table);
+        await this.query(`DELETE FROM ${table} WHERE ${primaryKey} = ?`, [primaryKeyValue]);
+    }
+
+    public async getTableColumns(table: string): Promise<string[]> {
+        throw new BdORMError(`getTableColumns not implemented for ${this.constructor.name}`);
+    }
+
+    /**
+     * Get the primary key of the table
+     */
+    public async getTablePrimaryKey(table: string): Promise<string> {
+        throw new BdORMError(`getTablePrimaryKey not implemented for ${this.constructor.name}`);
+    }
+
+    public async list(
+        table: string,
+        {
+            filters,
+            columns = '*',
+            orderBy,
+            limit,
+            offset,
+            values = [],
+        }: {
+            columns?: string | string[];
+            filters?: Record<string, any> | string;
+            limit?: number;
+            offset?: number;
+            orderBy?: string;
+            values?: any[];
+        } = {},
+    ) {
+        let query = `SELECT ${columns} FROM ${table}`;
+        if (typeof filters === 'string') {
+            query += ` WHERE ${filters}`;
+        } else {
+            if (typeof filters === 'object' && Object.keys(filters).length > 0) {
+                values = [];
+                const whereClause = Object.keys(filters)
+                    .map(key => `${key} = ?`)
+                    .join(' AND ');
+                query += ` WHERE ${whereClause}`;
+                values.push(...Object.values(filters));
+            }
+            if (orderBy) query += ` ORDER BY ${orderBy}`;
+            if (limit) query += ` LIMIT ${limit}`;
+            if (offset) query += ` OFFSET ${offset}`;
+        }
+        return this.query(query, values);
+    }
+
+    public async query(query: string, escapedValues: any[] = []) {
+        const db = await this._db();
+        try {
+            return await db.run(query, escapedValues);
+        } catch (error) {
+            throw new BdORMError(
+                `Error executing db query: ${(error as Error)?.message}. \nQuery: ${query} \nValues: ${escapedValues}`,
+            );
+        }
+    }
+    /**
+     * Alias for query
+     */
+    public async run(query: string, escapedValues: any[] = []) {
+        return this.query(query, escapedValues);
+    }
+
+    public async read(table: string, primaryKeyValue: string | number, { primaryKey }: { primaryKey?: string } = {}) {
+        const pk = primaryKey ?? (await this.getTablePrimaryKey(table));
+        const result = await this.query(`SELECT * FROM ${table} WHERE ${pk} = ?`, [primaryKeyValue]);
+        return result?.[0] || undefined;
+    }
+
+    public async update(table: string, data: any) {
+        const setClause = Object.keys(data)
+                .map(key => `${key} = ?`)
+                .join(', '),
+            primaryKey = await this.getTablePrimaryKey(table),
+            primaryKeyValue = data[primaryKey];
+        if (!primaryKeyValue)
+            throw new BdORMError(`No primary key value found for table ${table}, data: ${JSON.stringify(data)}`);
+        await this.query(`UPDATE ${table} SET ${setClause} WHERE ${primaryKey} = ?`, [
+            ...Object.values(data),
+            primaryKeyValue,
+        ]);
+    }
+}
+export default BdOrmDbConnectionSQLBase;

package/src/index.ts

@@ -0,0 +1,8 @@
+import BdOrmDbConnectionCapSqlite from './dbConnections/BdOrmDbConnectionCapSqlite';
+import BaseORMCrud from './_/BdORMCrud';
+import BdOrmDbConnection from './_/BdOrmConnection';
+import BdOrmDbConnectionCapHana from './dbConnections/BdOrmDbConnectionCapHana';
+import BdOrmDbConnectionSQLBase from './dbConnections/BdOrmDbConnectionSQLBase';
+
+export default class BdOrm extends BaseORMCrud {}
+export { BdOrmDbConnection, BdOrmDbConnectionCapSqlite, BdOrmDbConnectionCapHana, BdOrmDbConnectionSQLBase };

package/src/test-assets/Post.ts

@@ -0,0 +1,16 @@
+import BdOrm from '..';
+
+interface Post {
+    id: number;
+    title: string;
+    content: string;
+    userId: number;
+}
+class Post extends BdOrm {
+    static readonly DB_TABLE: string = 'posts';
+    async fetchUser() {
+        //TODO; //User.fetch
+    }
+}
+
+export default Post;

package/src/test-assets/User.ts

@@ -0,0 +1,18 @@
+import BdOrm from '..';
+
+interface User {
+    id: number;
+    firstname: string;
+    lastname: string;
+    fullname?: string; // view property
+    email: string;
+    dateCreated: string;
+}
+class User extends BdOrm {
+    static readonly DB_TABLE = 'bdorm_user';
+    static readonly DB_VIEW = 'user_view';
+    static readonly PROPERTIES_NOT_ALLOWED_TO_CHANGE = ['dateCreated'];
+    static readonly PROPERTIES_NOT_ALLOWED_TO_DUPLICATE = ['dateCreated'];
+}
+
+export default User;

package/src/test-assets/db/BdOrm.cds

@@ -0,0 +1,20 @@
+namespace bdOrm;
+
+entity User {
+    key id                        : Integer;
+    firstname                     : String(50);     
+    lastname                          : String(50);
+    email                         : String(50);
+    dateCreated                   : DateTime default $now;
+    options                         : String(500);
+    deleted                        : DateTime;
+}
+
+entity Post {
+    key id                        : Integer;
+    userId                        : Integer;
+    title                        : String(50);
+    content                      : String(50);
+    dateCreated                   : DateTime default $now;
+    deleted                        : DateTime;
+}

package/src/test-assets/db/csv/bdorm-user.csv

@@ -0,0 +1,3 @@
+id;firstname;lastname;email;dateCreated;deleted
+1;John;Doe;john.doe@example.com;;
+2;Barry;Dam;barry.dam@example.com;;

package/src/test-assets/db/views/user.hdbview

@@ -0,0 +1,3 @@
+view USER_VIEW AS
+
+SELECT bdorm_user.*, firstname || ' ' ||  lastname as fullname  FROM bdorm_user;

package/src/test-assets/jestUtils.ts

@@ -0,0 +1,24 @@
+import { it, expect } from '@jest/globals';
+export const expectErrorMessage = async (fn: () => Promise<unknown>, message: string) => {
+    try {
+        await fn();
+        //@ts-ignore
+        fail('Expected an error to be thrown');
+    } catch (error) {
+        //@ts-ignore (excepct = jest)
+        if (error instanceof Error) return expect(error.message).toContain(message);
+        console.log(error);
+        //@ts-ignore (fail = jest fail)
+        fail('error is not of type Error');
+    }
+};
+
+export const expectToBes = (tests: Record<string, { test: () => any; toBe: any }>) => {
+    Object.entries(tests).forEach(([title, { test, toBe }]) => {
+        it(`${title} returns ${toBe}`, () => {
+            const value = test();
+            expect(value).toBe(toBe);
+            expect(value).not.toBe('RANDOM VALUE 1234567890');
+        });
+    });
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "commonjs",
+        "lib": ["ES2022"],
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "dist",
+        "allowJs": true,
+        "declaration": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "**/*.test.ts"]
+}

package/validate-package.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const exec = require('child_process').exec;
+const core = require('@actions/core');
+const semver = require('semver');
+
+const successColor = '\x1b[42m';
+const errorColor = '\x1b[41m';
+
+const packageJson = fs.readFileSync('./package.json', 'utf8');
+const { name: packageName, version: packageVersion } = JSON.parse(packageJson);
+
+const logResult = (message, { failed } = {}) => console.log(failed ? errorColor : successColor, message, '\x1b[0m');
+
+exec(`npm view ${packageName} dist-tags --json`, (err, stdout) => {
+    let isFirstDeployment = false;
+
+    if (err) {
+        /* if the is an error with 'code E404', it means that there is no package
+         * with this name found in the registry, which means it is the first deployment!
+         * is the error someting else, we exit
+         */
+        if (!err.message.includes('code E404')) {
+            console.error(err);
+            process.exit(1); // Exit with error code
+        }
+        isFirstDeployment = true;
+    }
+
+    // check whether packageVersion is a proper semantic version
+    if (!semver.valid(packageVersion)) {
+        logResult('❌ De versie in het package.json is niet valide! Bekijk https://semver.org/ voor meer info.', {
+            failed: true,
+        });
+        process.exit(1); // Exit with error code
+    }
+
+    console.log(stdout);
+    // parse output of stdout, but keep in mind whether it is the first deployment or not!
+    const { beta, latest, next } = JSON.parse(
+        isFirstDeployment || stdout.trim().length === 0
+            ? JSON.stringify({ beta: undefined, latest: undefined, next: undefined })
+            : stdout.trim(),
+    );
+
+    console.log(`versiecheck:`);
+    console.log(` - laatst gedeployede latest versie: ${latest ?? 'geen eerdere release'}`);
+    console.log(` - laatste beta versie: ${beta ?? 'geen eerdere release'}`);
+    console.log(` - laatste next versie: ${next ?? 'geen eerdere release'}`);
+    console.log(`versie in package.json: ${packageVersion}`);
+
+    // this function will exit the process if local version is lower than on the registry
+    const verifyVersion = (version, errorMessage) => {
+        if (!version) {
+            // no version information available, falling back to default (0.0.0)
+            version = '0.0.0';
+        }
+        if (semver.lte(packageVersion, version)) {
+            logResult(`❌ ${errorMessage}`, { failed: true });
+            process.exit(1);
+        }
+    };
+
+    const prereleaseComponents = semver.prerelease(packageVersion);
+    const isPrerelease = !!prereleaseComponents;
+
+    /**
+     * we'll use this tag as output of this file. We need to determine what kind of version the package.json is using now..
+     * supported release kinds;
+     * - regular release. Example: 0.7.1 => publishtag 'latest'
+     * - beta release. Example: 1.3.0-beta.1 => publishtag 'beta'
+     * - next release. Example: 1.0.0-next.0 => publishtag 'next'
+     */
+    let publishTag;
+
+    if (!isPrerelease) {
+        verifyVersion(
+            latest,
+            `package.json versie is nog niet opgehoogd ten opzichte van laatste release op npm (${packageVersion} vs ${latest})`,
+        );
+        publishTag = 'latest';
+    }
+
+    if (isPrerelease) {
+        const [kind] = prereleaseComponents;
+        if (kind === 'beta') {
+            // beta version
+            verifyVersion(
+                beta,
+                `package.json versie is nog niet opgehoogd ten opzichte van laatste release op npm (${packageVersion} vs ${beta})`,
+            );
+            publishTag = 'beta';
+        } else if (kind === 'next') {
+            // next version
+            verifyVersion(
+                next,
+                `package.json versie is nog niet opgehoogd ten opzichte van laatste release op npm (${packageVersion} vs ${next})`,
+            );
+            publishTag = 'next';
+        } else {
+            console.error(
+                `een onbekend soort prerelease is gevonden; '${kind}'. We ondersteunen enkel 'next' en 'beta'`,
+            );
+            process.exit(1);
+        }
+    }
+
+    // if we've arrived here, we are sure the package.json version is a valid semver string and we determined our publish tag
+    // this is used for github actions
+    core.setOutput('publishtag', publishTag);
+    isFirstDeployment
+        ? logResult('✔ Eerste release van dit package!')
+        : logResult('✔ package.json versie is opgehoogd ten opzichte van de vorige versie!');
+});