bd-orm 0.0.1

package/dist/dbConnections/BdOrmDbConnectionCapSqlite/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployHdbViewFiles = exports.log = exports.findFiles = exports.fillTableFromCsv = exports.addCsvFilesFromDBFolder = void 0;
+const BdORMError_1 = require("../../_/BdORMError");
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const log = (message) => {
+    console.log(`[BdOrmDbConnectionCapSqlite] ${message}`);
+}, fillTableFromCsv = async (db, table, csvFile) => {
+    try {
+        const rows = [];
+        await new Promise((resolve, reject) => {
+            fs_1.default.createReadStream(csvFile)
+                .pipe((0, csv_parser_1.default)({ separator: ';' }))
+                .on('data', (data) => 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_1.BdORMError(`Error while filling table from CSV: ${error.message}`);
+    }
+}, findFiles = async (currentPath, extname) => {
+    let files = [];
+    //@ts-ignore
+    const entries = fs_1.default.readdirSync(currentPath, { withFileTypes: true });
+    //@ts-ignore
+    for (const entry of entries) {
+        const entryPath = path_1.default.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            const subfiles = await findFiles(entryPath, extname);
+            files.push(...subfiles);
+        }
+        else if (entry.isFile() && path_1.default.extname(entry.name) === extname) {
+            files.push(entryPath);
+        }
+    }
+    return files;
+}, addCsvFilesFromDBFolder = async (db, dbPath) => {
+    try {
+        const csvFiles = await findFiles(dbPath, '.csv');
+        for (const csvFile of csvFiles) {
+            await fillTableFromCsv(db, csvFile.split('/').pop()?.replace('.csv', '').replace('-', '_'), csvFile);
+        }
+    }
+    catch (error) {
+        throw new BdORMError_1.BdORMError(`Error while adding CsvFilesFromDbFolder: ${error.message}`);
+    }
+}, deployHdbViewFiles = async (db, dbPath) => {
+    const hdbViewFiles = await findFiles(dbPath, '.hdbview');
+    for (const hdbViewFile of hdbViewFiles) {
+        const hdbView = fs_1.default.readFileSync(hdbViewFile, 'utf8');
+        const m = await db.run(`create ${hdbView}`);
+        log(`Deployed HDB view from file: ${hdbViewFile}`);
+    }
+};
+exports.log = log;
+exports.fillTableFromCsv = fillTableFromCsv;
+exports.findFiles = findFiles;
+exports.addCsvFilesFromDBFolder = addCsvFilesFromDBFolder;
+exports.deployHdbViewFiles = deployHdbViewFiles;

package/dist/dbConnections/BdOrmDbConnectionSQLBase.d.ts

@@ -0,0 +1,32 @@
+import BdOrmDbConnection from '../_/BdOrmConnection';
+declare abstract class BdOrmDbConnectionSQLBase extends BdOrmDbConnection {
+    protected _db(): Promise<{
+        run: (query: string, values?: any[]) => Promise<any>;
+    }>;
+    close(): Promise<void>;
+    create(table: string, data: Record<string, any>): Promise<any>;
+    delete(table: string, primaryKeyValue: string | number): Promise<void>;
+    getTableColumns(table: string): Promise<string[]>;
+    /**
+     * Get the primary key of the table
+     */
+    getTablePrimaryKey(table: string): Promise<string>;
+    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[];
+    }): Promise<any>;
+    query(query: string, escapedValues?: any[]): Promise<any>;
+    /**
+     * Alias for query
+     */
+    run(query: string, escapedValues?: any[]): Promise<any>;
+    read(table: string, primaryKeyValue: string | number, { primaryKey }?: {
+        primaryKey?: string;
+    }): Promise<any>;
+    update(table: string, data: any): Promise<void>;
+}
+export default BdOrmDbConnectionSQLBase;

package/dist/dbConnections/BdOrmDbConnectionSQLBase.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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
+ */
+const BdORMError_1 = require("../_/BdORMError");
+const BdOrmConnection_1 = __importDefault(require("../_/BdOrmConnection"));
+class BdOrmDbConnectionSQLBase extends BdOrmConnection_1.default {
+    async _db() {
+        throw new BdORMError_1.BdORMError(`_db not implemented for ${this.constructor.name}`);
+    }
+    async close() {
+        throw new BdORMError_1.BdORMError(`close not implemented for ${this.constructor.name}`);
+    }
+    async create(table, data) {
+        const columns = Object.keys(data), placeholders = columns.map(() => '?').join(',');
+        const { lastInsertRowid } = 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];
+    }
+    async delete(table, primaryKeyValue) {
+        const primaryKey = await this.getTablePrimaryKey(table);
+        await this.query(`DELETE FROM ${table} WHERE ${primaryKey} = ?`, [primaryKeyValue]);
+    }
+    async getTableColumns(table) {
+        throw new BdORMError_1.BdORMError(`getTableColumns not implemented for ${this.constructor.name}`);
+    }
+    /**
+     * Get the primary key of the table
+     */
+    async getTablePrimaryKey(table) {
+        throw new BdORMError_1.BdORMError(`getTablePrimaryKey not implemented for ${this.constructor.name}`);
+    }
+    async list(table, { filters, columns = '*', orderBy, limit, offset, values = [], } = {}) {
+        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);
+    }
+    async query(query, escapedValues = []) {
+        const db = await this._db();
+        try {
+            return await db.run(query, escapedValues);
+        }
+        catch (error) {
+            throw new BdORMError_1.BdORMError(`Error executing db query: ${error?.message}. \nQuery: ${query} \nValues: ${escapedValues}`);
+        }
+    }
+    /**
+     * Alias for query
+     */
+    async run(query, escapedValues = []) {
+        return this.query(query, escapedValues);
+    }
+    async read(table, primaryKeyValue, { primaryKey } = {}) {
+        const pk = primaryKey ?? (await this.getTablePrimaryKey(table));
+        const result = await this.query(`SELECT * FROM ${table} WHERE ${pk} = ?`, [primaryKeyValue]);
+        return result?.[0] || undefined;
+    }
+    async update(table, data) {
+        const setClause = Object.keys(data)
+            .map(key => `${key} = ?`)
+            .join(', '), primaryKey = await this.getTablePrimaryKey(table), primaryKeyValue = data[primaryKey];
+        if (!primaryKeyValue)
+            throw new BdORMError_1.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,
+        ]);
+    }
+}
+exports.default = BdOrmDbConnectionSQLBase;

package/dist/index.d.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/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BdOrmDbConnectionSQLBase = exports.BdOrmDbConnectionCapHana = exports.BdOrmDbConnectionCapSqlite = exports.BdOrmDbConnection = void 0;
+const BdOrmDbConnectionCapSqlite_1 = __importDefault(require("./dbConnections/BdOrmDbConnectionCapSqlite"));
+exports.BdOrmDbConnectionCapSqlite = BdOrmDbConnectionCapSqlite_1.default;
+const BdORMCrud_1 = __importDefault(require("./_/BdORMCrud"));
+const BdOrmConnection_1 = __importDefault(require("./_/BdOrmConnection"));
+exports.BdOrmDbConnection = BdOrmConnection_1.default;
+const BdOrmDbConnectionCapHana_1 = __importDefault(require("./dbConnections/BdOrmDbConnectionCapHana"));
+exports.BdOrmDbConnectionCapHana = BdOrmDbConnectionCapHana_1.default;
+const BdOrmDbConnectionSQLBase_1 = __importDefault(require("./dbConnections/BdOrmDbConnectionSQLBase"));
+exports.BdOrmDbConnectionSQLBase = BdOrmDbConnectionSQLBase_1.default;
+class BdOrm extends BdORMCrud_1.default {
+}
+exports.default = BdOrm;

package/dist/test-assets/Post.d.ts

@@ -0,0 +1,12 @@
+import BdOrm from '..';
+interface Post {
+    id: number;
+    title: string;
+    content: string;
+    userId: number;
+}
+declare class Post extends BdOrm {
+    static readonly DB_TABLE: string;
+    fetchUser(): Promise<void>;
+}
+export default Post;

package/dist/test-assets/Post.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = __importDefault(require(".."));
+class Post extends __1.default {
+    static DB_TABLE = 'posts';
+    async fetchUser() {
+        //TODO; //User.fetch
+    }
+}
+exports.default = Post;

package/dist/test-assets/User.d.ts

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

package/dist/test-assets/User.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = __importDefault(require(".."));
+class User extends __1.default {
+    static DB_TABLE = 'bdorm_user';
+    static DB_VIEW = 'user_view';
+    static PROPERTIES_NOT_ALLOWED_TO_CHANGE = ['dateCreated'];
+    static PROPERTIES_NOT_ALLOWED_TO_DUPLICATE = ['dateCreated'];
+}
+exports.default = User;

package/dist/test-assets/jestUtils.d.ts

@@ -0,0 +1,5 @@
+export declare const expectErrorMessage: (fn: () => Promise<unknown>, message: string) => Promise<void>;
+export declare const expectToBes: (tests: Record<string, {
+    test: () => any;
+    toBe: any;
+}>) => void;

package/dist/test-assets/jestUtils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectToBes = exports.expectErrorMessage = void 0;
+const globals_1 = require("@jest/globals");
+const expectErrorMessage = async (fn, message) => {
+    try {
+        await fn();
+        //@ts-ignore
+        fail('Expected an error to be thrown');
+    }
+    catch (error) {
+        //@ts-ignore (excepct = jest)
+        if (error instanceof Error)
+            return (0, globals_1.expect)(error.message).toContain(message);
+        console.log(error);
+        //@ts-ignore (fail = jest fail)
+        fail('error is not of type Error');
+    }
+};
+exports.expectErrorMessage = expectErrorMessage;
+const expectToBes = (tests) => {
+    Object.entries(tests).forEach(([title, { test, toBe }]) => {
+        (0, globals_1.it)(`${title} returns ${toBe}`, () => {
+            const value = test();
+            (0, globals_1.expect)(value).toBe(toBe);
+            (0, globals_1.expect)(value).not.toBe('RANDOM VALUE 1234567890');
+        });
+    });
+};
+exports.expectToBes = expectToBes;

package/jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('jest').Config} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    workerIdleMemoryLimit: '512MB',
+    roots: ['./src'],
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "bd-orm",
+    "version": "0.0.1",
+    "description": "NodeJS object-relational mapping (ORM)",
+    "author": "Barry Dam",
+    "main": "dist/index.js",
+    "exports": "./dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prebuild": "rm -rf dist",
+        "test": "jest",
+        "validatePackageVersion": "node validate-package-version.js",
+        "version:bump": "npm version --git-tag-version=false patch",
+        "version:bump:major": "npm version --git-tag-version=false major",
+        "version:bump:minor": "npm version --git-tag-version=false minor",
+        "version:bump:beta": "npm version --git-tag-version=false --preid=beta prerelease",
+        "version:bump:next": "npm version --git-tag-version=false --preid=next prerelease"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/BarryDam/bdorm.git"
+    },
+    "keywords": [
+        "NodeJs",
+        "ORM",
+        "SQL",
+        "DB",
+        "Model"
+    ],
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/BarryDam/bdorm/issues"
+    },
+    "homepage": "https://github.com/BarryDam/bdorm#readme",
+    "devDependencies": {
+        "@actions/core": "^1.11.1",
+        "@cap-js/cds-types": "^0.10.0",
+        "@cap-js/sqlite": "^1.10.0",
+        "@sap/dev-cap-tools": "^1.44.1",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.14.1",
+        "csv-parser": "^3.2.0",
+        "jest": "^29.7.0",
+        "prettier": "^3.5.3",
+        "semver": "^7.7.2",
+        "ts-jest": "^29.3.2",
+        "typescript": "^5.8.3"
+    },
+    "dependencies": {
+        "@sap/cds-dk": "^8.9.1"
+    }
+}