bd-orm 0.0.1

package/dist/_/BdORMCrud.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const BdORMBase_1 = __importStar(require("./BdORMBase"));
+const BdORMError_1 = require("./BdORMError");
+const _filerDataByTable = async (self) => {
+    const data = self.getData(true);
+    const columns = await self.constructor.getDbConnection().getTableColumns(self.getTable());
+    return Object.keys(data).reduce((acc, key) => {
+        if (columns.includes(key))
+            acc[key] = data[key];
+        return acc;
+    }, {});
+};
+class BdORMCrud extends BdORMBase_1.default {
+    static _DbConnection;
+    // Events
+    async beforeCreate(beforeCreateParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async beforeUpdate(beforeUpdateParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async beforeSave(beforeSaveParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async afterCreate(afterCreateParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async afterUpdate(afterUpdateParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async afterSave(afterSaveParams) {
+        /* Overschrijf deze functie indien nodig */
+    }
+    async beforeDelete() { }
+    async afterDelete() { }
+    _execDBConnectionMethod(method, ...args) {
+        //@ts-ignore
+        return this.constructor._DbConnection[method](...args);
+    }
+    async _create({ preventBeforeCreate = false, preventAfterCreate = false } = {}) {
+        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
+        (0, BdORMBase_1.definePropertyDescriptors)(this, result);
+        // important AFTER definePropertyDescriptors
+        if (primaryKeyValue)
+            this.setProperty(primaryKey, primaryKeyValue);
+        if (!preventAfterCreate)
+            await this.afterCreate();
+        this._setChangedProperties([]);
+        return {
+            [primaryKey]: primaryKeyValue,
+            ...result,
+        };
+    }
+    async _update({ preventBeforeUpdate = false, preventAfterUpdate = false } = {}) {
+        if (this.isNew())
+            throw new BdORMError_1.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() {
+        this.constructor.isMethodAllowed('delete', { throwErrorIfNotAllowed: true });
+        if (!this.id) {
+            throw new BdORMError_1.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 = [] } = {}) {
+        const self = this.constructor;
+        self.isMethodAllowed('duplicate', { throwErrorIfNotAllowed: true });
+        if (!asDraft && this.isNew())
+            throw new BdORMError_1.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, } = {}) {
+        this.constructor.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, values) {
+        const result = await this._DbConnection.list(this.VIEW, {
+            columns: 'COUNT(*) as count',
+            filters: where,
+            values,
+        });
+        return result[0].count;
+    }
+    static async create(data) {
+        const instance = new this(data);
+        await instance.save();
+        return instance;
+    }
+    static async fetch(where, values) {
+        const results = await this._DbConnection.list(this.VIEW, {
+            columns: this.COLUMNS_TO_FETCH,
+            filters: where,
+            values,
+        });
+        return results.map((result) => new this(result));
+    }
+    static async fetchById(id) {
+        return this.fetchByPrimaryKey(id);
+    }
+    static async fetchOne(where, values) {
+        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,
+            filters: where,
+            limit,
+            values,
+        });
+        return results?.length ? new this(results[0]) : undefined;
+    }
+    static async fetchByPrimaryKey(primaryKeyValue) {
+        const primaryKey = await this._DbConnection.getTablePrimaryKey(this.TABLE);
+        const result = await this._DbConnection.read(this.VIEW, primaryKeyValue, { primaryKey });
+        if (!result)
+            throw new BdORMError_1.BdORMError(`No entry found for ${this.VIEW} with ${this.PRIMARY_KEY} ${primaryKeyValue}`);
+        return new this(result);
+    }
+    static setDbConnection(dbConnection) {
+        if (this._DbConnection)
+            throw new BdORMError_1.BdORMError('DbConnection already set');
+        this._DbConnection = dbConnection;
+    }
+    static clearDbConnection() {
+        //@ts-ignore
+        this._DbConnection = undefined;
+    }
+    static getDbConnection() {
+        return this._DbConnection;
+    }
+}
+exports.default = BdORMCrud;

package/dist/_/BdORMError.d.ts

@@ -0,0 +1,4 @@
+export declare class BdORMError extends Error {
+    constructor(msg: string);
+    static staticNotImplemented(methodName: string): BdORMError;
+}

package/dist/_/BdORMError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BdORMError = void 0;
+class BdORMError extends Error {
+    constructor(msg) {
+        super(`[bd-Orm Error]: ${msg}`);
+        Error.captureStackTrace(this, BdORMError);
+        this.name = 'BdORMError';
+    }
+    static staticNotImplemented(methodName) {
+        return new BdORMError(`static ${methodName} not implemented! Set in derived class`);
+    }
+}
+exports.BdORMError = BdORMError;

package/dist/_/BdOrmConnection.d.ts

@@ -0,0 +1,32 @@
+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
+     */
+    abstract create(table: string, data: Record<string, any>, params?: {
+        primaryKey: string;
+    }): Promise<Record<string, any>>;
+    abstract read(table: string, primaryKeyValue: string | number, params?: {
+        primaryKey: string;
+    }): Promise<Record<string, any> | undefined>;
+    abstract update(table: string, data: any, params?: {
+        primaryKey: string;
+    }): Promise<void>;
+    abstract delete(table: string, primaryKeyValue: string | number, params?: {
+        primaryKey: string;
+    }): Promise<void>;
+    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>[]>;
+    abstract query(query: string, escapedValues?: any[]): Promise<Record<string, any>[]>;
+    abstract getTablePrimaryKey(table: string): Promise<string>;
+    abstract getTableColumns(table: string): Promise<string[]>;
+}

package/dist/_/BdOrmConnection.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BdOrmDbConnection {
+}
+exports.default = BdOrmDbConnection;

package/dist/_/cdsBaseOrm.d.ts

@@ -0,0 +1,12 @@
+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;
+}

package/dist/_/cdsBaseOrm.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BdORMBase_1 = __importDefault(require("./BdORMBase"));
+const cds_1 = __importDefault(require("@sap/cds"));
+/**
+ * Base class for CDS ORM
+ */
+class cdsBaseOrm extends BdORMBase_1.default {
+    /**
+     * Get the CDS model for the current table
+     * @returns the CDS model for the current table
+     */
+    static get CDS_MODEL() {
+        const namespace = this.TABLE.split('_')[0].toLowerCase();
+        return Object.values(cds_1.default.entities(namespace)).find((o) => 'name' in o && o.name.toUpperCase().replace(/\./g, '_') === this.TABLE);
+    }
+}
+exports.default = cdsBaseOrm;

package/dist/dbConnections/BdOrmDbConnectionCapHana/index.d.ts

@@ -0,0 +1,26 @@
+import BdOrmDbConnectionSQLBase from '../BdOrmDbConnectionSQLBase';
+import cds from '@sap/cds';
+export default class BdOrmDbConnectionCapHana extends BdOrmDbConnectionSQLBase {
+    protected _db(): Promise<cds.DatabaseService>;
+    close(): Promise<void>;
+    getTableColumns(table: string): Promise<string[]>;
+    /**
+     * Get the primary key of the table
+     */
+    getTablePrimaryKey(table: string): Promise<string>;
+    create(table: string, data: Record<string, any>): Promise<any>;
+    /**
+     * 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
+     */
+    list(table: string, options?: {
+        columns?: string | string[];
+        filters?: Record<string, any> | string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        values?: any[];
+    }): Promise<any>;
+    read(table: string, primaryKeyValue: string | number, { primaryKey }?: {
+        primaryKey?: string;
+    }): Promise<any>;
+}

package/dist/dbConnections/BdOrmDbConnectionCapHana/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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
+ */
+const BdORMError_1 = require("../../_/BdORMError");
+const BdOrmDbConnectionSQLBase_1 = __importDefault(require("../BdOrmDbConnectionSQLBase"));
+const utils_1 = require("./utils");
+const cds_1 = __importDefault(require("@sap/cds"));
+const PRIMARY_KEYS = {};
+const TABLE_COLUMNS = {};
+const remapResultColumns = (result, columns) => {
+    return Object.entries(result).reduce((resultMapped, [key, value]) => {
+        const column = columns.find(column => column.toUpperCase() === key.toUpperCase());
+        resultMapped[column ?? key] = value;
+        return resultMapped;
+    }, {});
+};
+class BdOrmDbConnectionCapHana extends BdOrmDbConnectionSQLBase_1.default {
+    async _db() {
+        return cds_1.default.db ? cds_1.default.db : await cds_1.default.connect.to('db');
+    }
+    async close() {
+        const db = await this._db();
+        //@ts-ignore jest zegt cds.disconnect does not exists
+        await db.disconnect();
+    }
+    async getTableColumns(table) {
+        const cdsColumns = (0, utils_1.getTableColumns)(table);
+        if (cdsColumns)
+            return cdsColumns;
+        if (TABLE_COLUMNS[table])
+            return TABLE_COLUMNS[table];
+        const tableInfo = await this.query(`SELECT COLUMN_NAME FROM TABLE_COLUMNS WHERE TABLE_NAME = '${table}'`);
+        if (tableInfo.length === 0)
+            throw new BdORMError_1.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
+     */
+    async getTablePrimaryKey(table) {
+        const primaryKey = (0, utils_1.getTablePrimaryKey)(table);
+        if (primaryKey)
+            return primaryKey;
+        if (PRIMARY_KEYS[table])
+            return PRIMARY_KEYS[table];
+        const tableInfo = 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_1.BdORMError(`No primary key found for table ${table}`);
+        return PRIMARY_KEYS[table];
+    }
+    async create(table, data) {
+        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
+     */
+    async list(table, options = {}) {
+        const results = await super.list(table, options), columns = await this.getTableColumns(table);
+        return results?.map((result) => remapResultColumns(result, columns));
+    }
+    async read(table, primaryKeyValue, { primaryKey } = {}) {
+        const result = await super.read(table, primaryKeyValue, { primaryKey }), columns = await this.getTableColumns(table);
+        return result ? remapResultColumns(result, columns) : result;
+    }
+}
+exports.default = BdOrmDbConnectionCapHana;

package/dist/dbConnections/BdOrmDbConnectionCapHana/utils.d.ts

@@ -0,0 +1,14 @@
+type Definitions = {
+    [table: string]: {
+        primaryKey: string;
+        columnNames: string[];
+    };
+};
+declare const getDefinitions: () => Definitions | undefined;
+declare const getTableDefinition: (table: string) => {
+    primaryKey: string;
+    columnNames: string[];
+} | undefined;
+declare const getTablePrimaryKey: (table: string) => string | undefined;
+declare const getTableColumns: (table: string) => string[] | undefined;
+export { getDefinitions, getTableDefinition, getTablePrimaryKey, getTableColumns };

package/dist/dbConnections/BdOrmDbConnectionCapHana/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableColumns = exports.getTablePrimaryKey = exports.getTableDefinition = exports.getDefinitions = void 0;
+const cds_1 = __importDefault(require("@sap/cds"));
+const _definitionCache = {};
+const getDefinitions = () => {
+    if (Object.keys(_definitionCache).length)
+        return _definitionCache;
+    const cdsDefinitions = (cds_1.default?.model?.definitions ?? cds_1.default.entities ?? {});
+    if (Object.keys(cdsDefinitions).length === 0)
+        return undefined;
+    Object.entries(cdsDefinitions).forEach(([key, { elements, name }]) => {
+        if (elements === undefined)
+            return;
+        _definitionCache[name.toLowerCase().replace(/\./g, '_')] = {
+            primaryKey: Object.entries(elements).find(([_, { key }]) => key)?.[0] ?? '',
+            columnNames: Object.entries(elements).map(([column]) => column),
+        };
+    });
+    return _definitionCache;
+};
+exports.getDefinitions = getDefinitions;
+const getTableDefinition = (table) => {
+    const definitions = getDefinitions();
+    if (!definitions)
+        return undefined;
+    const tableDefinition = definitions[table.toLowerCase().replace(/\./g, '_')];
+    if (!tableDefinition)
+        return undefined;
+    return tableDefinition;
+};
+exports.getTableDefinition = getTableDefinition;
+const getTablePrimaryKey = (table) => {
+    const tableDefinition = getTableDefinition(table);
+    if (!tableDefinition)
+        return undefined;
+    return tableDefinition.primaryKey;
+};
+exports.getTablePrimaryKey = getTablePrimaryKey;
+const getTableColumns = (table) => {
+    const tableDefinition = getTableDefinition(table);
+    if (!tableDefinition)
+        return undefined;
+    return tableDefinition.columnNames;
+};
+exports.getTableColumns = getTableColumns;

package/dist/dbConnections/BdOrmDbConnectionCapSqlite/index.d.ts

@@ -0,0 +1,22 @@
+import BdOrmDbConnectionSQLBase from '../BdOrmDbConnectionSQLBase';
+import cds from '@sap/cds';
+export default class BdOrmDbConnectionCapSqlite extends BdOrmDbConnectionSQLBase {
+    private readonly _csvFiles;
+    private _deployed;
+    private _dbPath;
+    protected _db(): Promise<cds.DatabaseService>;
+    getDb(): Promise<cds.DatabaseService>;
+    constructor(dbPath: string, options?: {
+        csvFiles: string[];
+    });
+    getTableColumns(table: string): Promise<string[]>;
+    /**
+     * Get the primary key of the table
+     */
+    getTablePrimaryKey(table: string): Promise<string>;
+    /**
+     * 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
+     */
+    fillTableFromCsvFile(table: string, csvFile: string): Promise<void>;
+}

package/dist/dbConnections/BdOrmDbConnectionCapSqlite/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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
+ */
+const BdORMError_1 = require("../../_/BdORMError");
+const BdOrmDbConnectionSQLBase_1 = __importDefault(require("../BdOrmDbConnectionSQLBase"));
+const utils_1 = require("./utils");
+const cds_1 = __importDefault(require("@sap/cds"));
+const PRIMARY_KEYS = {};
+const TABLE_INFO = {};
+class BdOrmDbConnectionCapSqlite extends BdOrmDbConnectionSQLBase_1.default {
+    _csvFiles = [];
+    _deployed = false;
+    _dbPath = '';
+    async _db() {
+        let db;
+        if (!this._deployed) {
+            //@ts-ignore jest zegt cds.deploy does not exists
+            await cds_1.default.deploy(this._dbPath).to('sqlite::memory:');
+            db = await cds_1.default.connect.to('db');
+            if (!this._csvFiles.length)
+                await (0, utils_1.addCsvFilesFromDBFolder)(db, this._dbPath);
+            else {
+                for (const csvFile of this._csvFiles) {
+                    await (0, utils_1.fillTableFromCsv)(db, csvFile.split('/').pop()?.replace('.csv', '').replace('-', '_'), csvFile);
+                }
+            }
+            await (0, utils_1.deployHdbViewFiles)(db, this._dbPath);
+            this._deployed = true;
+        }
+        return db ?? cds_1.default.connect.to('db');
+    }
+    async getDb() {
+        return this._db();
+    }
+    constructor(dbPath, options) {
+        super();
+        this._csvFiles = options?.csvFiles || [];
+        this._dbPath = dbPath;
+    }
+    async getTableColumns(table) {
+        if (TABLE_INFO[table])
+            return TABLE_INFO[table].map(info => info.name);
+        const 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
+     */
+    async getTablePrimaryKey(table) {
+        if (PRIMARY_KEYS[table])
+            return PRIMARY_KEYS[table];
+        const 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_1.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
+     */
+    async fillTableFromCsvFile(table, csvFile) {
+        const db = await this._db();
+        await (0, utils_1.fillTableFromCsv)(db, table, csvFile);
+    }
+}
+exports.default = BdOrmDbConnectionCapSqlite;

package/dist/dbConnections/BdOrmDbConnectionCapSqlite/utils.d.ts

@@ -0,0 +1,3 @@
+import cds from '@sap/cds';
+declare const log: (message: string) => void, fillTableFromCsv: (db: cds.DatabaseService, table: string, csvFile: string) => Promise<void>, findFiles: (currentPath: string, extname: string) => Promise<string[]>, addCsvFilesFromDBFolder: (db: cds.DatabaseService, dbPath: string) => Promise<void>, deployHdbViewFiles: (db: cds.DatabaseService, dbPath: string) => Promise<void>;
+export { addCsvFilesFromDBFolder, fillTableFromCsv, findFiles, log, deployHdbViewFiles };