bd-orm 0.0.1

package/.github/workflows/build-and-test.yml

@@ -0,0 +1,26 @@
+name: build and test
+
+on:
+    pull_request:
+        branches: [main]
+        paths:
+            - 'src/**'
+            - 'package.json'
+            - 'package-lock.json'
+
+jobs:
+    build-and-test:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 20
+            - name: install dependencies
+              run: npm ci
+            - run: npm run build
+              env:
+                  CI: true
+            - run: npm test
+              env:
+                  CI: true

package/.github/workflows/publish.yml

@@ -0,0 +1,36 @@
+name: Publish to npm
+
+on:
+    release:
+        types: [published]
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Set up Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 20
+                  registry-url: 'https://registry.npmjs.org/'
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: run tests
+              run: npm test
+              env:
+                  CI: true
+
+            - name: Build
+              run: npm run build
+              env:
+                  CI: true
+
+            - name: Publish
+              run: npm publish --access public
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_PUBLISH }}

package/.prettierrc.json

@@ -0,0 +1,14 @@
+{
+    "semi": true,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "printWidth": 120,
+    "tabWidth": 4,
+    "useTabs": false,
+    "arrowParens": "avoid",
+    "bracketSpacing": true,
+    "endOfLine": "auto",
+    "importOrderSeparation": true,
+    "importOrderSortSpecifiers": true,
+    "importOrderParserPlugins": ["typescript", "decorators-legacy"]
+}

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.0.1
+###### 16-07-2025
+- [INIT] First alpha release

package/README.md

@@ -0,0 +1,5 @@
+# bdORM
+NodeJS object-relational mapping (ORM)
+
+
+This repo is still under development and a stable release will follow

package/check NBR en TODO.txt

@@ -0,0 +1,32 @@
+gebruik van:
+- joi er uit
+
+renames:
+- getChangeFields -> getChangedProperties
+- isChanged -> hasPropertyValueChanged
+- countRows -> count
+
+Kijken of dit een specifiek nbr model moet worden:
+- check UPDATED_DATE en setChangeDateToCurrentDate
+- getTableName
+- FOREIGN_KEY en getForeignKey
+
+Controleren:
+- contructor origineel > kan niet met mixens overweg ?
+
+
+r uit:
+- get CDS_MODEL
+- cdsSelect()
+- deleteModels
+- registerModel
+- getSubModel
+- callbackPromise
+- createError
+- isModelError
+
+
+functie params gewijzigd:
+- duplicate was duplicate(deepcopy, { newData, excludeColumns }) is nu duplicate({ asDraft, newData, excludeColumns})
+
+

package/dist/_/BdORMBase.d.ts

@@ -0,0 +1,111 @@
+declare const definePropertyDescriptors: (instance: BdORMBase, data: Record<string, any>) => void;
+/**
+ * Class which only contains the getters and setters for the base ORM
+ */
+declare abstract class BdORMBase {
+    /**
+     * Properties will be defined in the constructor (see definePropertyDescriptors)
+     */
+    [key: string]: any;
+    /**
+     * @returns the model name
+     */
+    static getModelName(): string;
+    constructor(data?: Record<string, any>);
+    /**
+     * This method is ONLY used in the FETCH method
+     * @returns the columns to fetch from the database
+     */
+    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();
+     */
+    static readonly METHODS_NOT_ALLOWED: string[];
+    /**
+     * Get the primary key for the current table
+     * @returns the primary key for the current table
+     */
+    static readonly PRIMARY_KEY: string;
+    /**
+     * Specify which properties should be set as read-only.
+     * These properties can only be set once, when the object is created.
+     * @return array
+     */
+    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
+     */
+    static readonly PROPERTIES_NOT_ALLOWED_TO_DUPLICATE: string[];
+    /**
+     * Specify which properties are required when creating a new object.
+     * @return array
+     */
+    static readonly REQUIRED_PROPERTIES: string[];
+    static isMethodAllowed(method: string, { throwErrorIfNotAllowed }?: {
+        throwErrorIfNotAllowed?: boolean | undefined;
+    }): boolean;
+    /**
+     * Get the table name as used in the database
+     * @returns the table name as used in the database
+     */
+    static readonly DB_TABLE: string;
+    static get TABLE(): string;
+    /**
+     * Sometimes you want to use a custom view to read your model data
+     * @returns the view name as used in the database
+     */
+    static readonly DB_VIEW: string;
+    static get VIEW(): string;
+    protected _setChangedProperties(changedProperties: string[]): void;
+    /**
+     * @returns the changed properties
+     */
+    getChangedProperties(): string[];
+    /**
+     * @returns the data in json format
+     * @paaam {boolean} [preventFormatting=false] - prevent formatting of the data
+     */
+    getData(preventFormatting?: boolean): Record<string, any>;
+    /**
+     * @returns the primary key for the current table
+     */
+    getPrimaryKey(): string;
+    getPrimaryKeyValue(): number;
+    /**
+     * get the model property
+     */
+    getProperty(key: string, { preventFormatting }?: {
+        preventFormatting?: boolean | undefined;
+    }): string | number | null | undefined;
+    /**
+     * @returns the columns of the required properties needed to create a new object
+     */
+    getRequiredProperties(): string[];
+    /**
+     * Get the table name as used in the database
+     * @returns the table name as used in the database
+     */
+    getTable(): string;
+    /**
+     *
+     * @returns
+     */
+    hasChanges(): boolean;
+    /**
+     * Check if the property has been changed
+     */
+    hasPropertyValueChanged(property: string): boolean;
+    /**
+     * Check if the current object is a new object
+     * @returns true if the object is new, false if it is not
+     */
+    isNew(): boolean;
+    setProperty(property: string, value: any, { forceChange }?: {
+        forceChange?: boolean | undefined;
+    }): void;
+}
+export default BdORMBase;
+export { definePropertyDescriptors };

package/dist/_/BdORMBase.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePropertyDescriptors = void 0;
+const BdORMError_1 = require("./BdORMError");
+// Local variables
+const PROPERTIES_WEAKMAP = new WeakMap(), // memory leak prevention
+LOCAL_WEAKMAP = new WeakMap();
+// Helper methods
+const getLocalWeakMapValue = (instance, key) => {
+    const localWeakMap = LOCAL_WEAKMAP.get(instance) ?? {};
+    return key in localWeakMap ? localWeakMap[key] : null;
+}, getPropertyDescriptor = (instance, property) => {
+    let descriptor;
+    while (instance && !descriptor) {
+        descriptor = Object.getOwnPropertyDescriptor(instance, property);
+        instance = Object.getPrototypeOf(instance);
+    }
+    return descriptor;
+}, definePropertyDescriptors = (instance, data) => {
+    Object.keys(data).forEach(property => {
+        const propertyDefinion = getPropertyDescriptor(instance, property) ?? {};
+        if (!('get' in propertyDefinion) || propertyDefinion.get === undefined) {
+            propertyDefinion.get = () => {
+                const value = instance.getProperty(property);
+                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) => {
+                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_1.BdORMError(`Invalid property descriptor "${property}" ${propertyDefinion.value} in ${instance.constructor.name}`);
+        }
+        // data toevoegen
+        if (data[property] !== undefined)
+            instance[property] = data[property];
+    });
+};
+exports.definePropertyDescriptors = definePropertyDescriptors;
+/**
+ * Class which only contains the getters and setters for the base ORM
+ */
+class BdORMBase {
+    /**
+     * @returns the model name
+     */
+    static getModelName() {
+        return this.name;
+    }
+    constructor(data = {}) {
+        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_1.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
+     */
+    static COLUMNS_TO_FETCH = '*';
+    /**
+     * which default methods are not allowed to be used
+     * for example: ['delete'] will prevent you from using model.delete();
+     */
+    static METHODS_NOT_ALLOWED = [];
+    /**
+     * Get the primary key for the current table
+     * @returns the primary key for the current table
+     */
+    static PRIMARY_KEY = 'id';
+    /**
+     * Specify which properties should be set as read-only.
+     * These properties can only be set once, when the object is created.
+     * @return array
+     */
+    static PROPERTIES_NOT_ALLOWED_TO_CHANGE = [];
+    /**
+     * If there are values that should not be duplicated,
+     * specify here which properties those should be.
+     * @return array
+     */
+    static PROPERTIES_NOT_ALLOWED_TO_DUPLICATE = [];
+    /**
+     * Specify which properties are required when creating a new object.
+     * @return array
+     */
+    static REQUIRED_PROPERTIES = [];
+    static isMethodAllowed(method, { throwErrorIfNotAllowed = false } = {}) {
+        const allowed = !this.METHODS_NOT_ALLOWED.includes(method);
+        if (!allowed && throwErrorIfNotAllowed) {
+            throw new BdORMError_1.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
+     */
+    static DB_TABLE;
+    static get TABLE() {
+        if (!this.DB_TABLE)
+            throw BdORMError_1.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
+     */
+    static DB_VIEW;
+    static get VIEW() {
+        return this.DB_VIEW ?? this.TABLE;
+    }
+    _setChangedProperties(changedProperties) {
+        const local = LOCAL_WEAKMAP.get(this) || {};
+        LOCAL_WEAKMAP.set(this, {
+            ...local,
+            changedProperties,
+        });
+    }
+    /**
+     * @returns the changed properties
+     */
+    getChangedProperties() {
+        return !this.isNew() ? (getLocalWeakMapValue(this, 'changedProperties') ?? []) : [];
+    }
+    /**
+     * @returns the data in json format
+     * @paaam {boolean} [preventFormatting=false] - prevent formatting of the data
+     */
+    getData(preventFormatting = false) {
+        const data = {}, returnData = {};
+        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
+     */
+    getPrimaryKey() {
+        return this.constructor.PRIMARY_KEY;
+    }
+    getPrimaryKeyValue() {
+        return this.getProperty(this.getPrimaryKey());
+    }
+    /**
+     * get the model property
+     */
+    getProperty(key, { preventFormatting = false } = {}) {
+        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
+     */
+    getRequiredProperties() {
+        return this.constructor.REQUIRED_PROPERTIES;
+    }
+    /**
+     * Get the table name as used in the database
+     * @returns the table name as used in the database
+     */
+    getTable() {
+        return this.constructor.TABLE;
+    }
+    /**
+     *
+     * @returns
+     */
+    hasChanges() {
+        return this.getChangedProperties().length > 0;
+    }
+    /**
+     * Check if the property has been changed
+     */
+    hasPropertyValueChanged(property) {
+        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
+     */
+    isNew() {
+        return !this.getPrimaryKeyValue();
+    }
+    setProperty(property, value, { forceChange = false } = {}) {
+        // prevent overwrite of primary key
+        if (property === this.getPrimaryKey() && this.getPrimaryKeyValue() && this.getPrimaryKeyValue() !== value) {
+            throw new BdORMError_1.BdORMError(`Primary key cannot be changed from ${this.getPrimaryKeyValue()} to ${value}`);
+        }
+        // prevent overwrite of read-only properties
+        if (!forceChange &&
+            !this.isNew() &&
+            this.constructor.PROPERTIES_NOT_ALLOWED_TO_CHANGE.includes(property) &&
+            ![undefined, null].includes(this.getProperty(property)) &&
+            this.getProperty(property) != value // != is used to check for null and undefined
+        ) {
+            throw new BdORMError_1.BdORMError(`Property "${property}" is not allowed to be changed`);
+        }
+        if (!this.isNew() && this.getPrimaryKey() === property && this.getPrimaryKeyValue() !== value) {
+            throw new BdORMError_1.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)) && 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);
+    }
+}
+exports.default = BdORMBase;

package/dist/_/BdORMCrud.d.ts

@@ -0,0 +1,51 @@
+import BdORMBase from './BdORMBase';
+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;
+    newData?: {
+        [key: string]: string | boolean | null | number | BdORMDuplicateNewDataMethod;
+    };
+    excludeColumns?: string[];
+}
+export default class BdORMCrud extends BdORMBase {
+    private static _DbConnection;
+    protected beforeCreate<K extends string>(beforeCreateParams?: MethodParams<K>): Promise<void>;
+    protected beforeUpdate<K extends string>(beforeUpdateParams?: MethodParams<K>): Promise<void>;
+    protected beforeSave<K extends string>(beforeSaveParams?: MethodParams<K>): Promise<void>;
+    protected afterCreate<K extends string>(afterCreateParams?: MethodParams<K>): Promise<void>;
+    protected afterUpdate<K extends string>(afterUpdateParams?: MethodParams<K>): Promise<void>;
+    protected afterSave<K extends string>(afterSaveParams?: MethodParams<K>): Promise<void>;
+    protected beforeDelete(): Promise<void>;
+    protected afterDelete(): Promise<void>;
+    private _execDBConnectionMethod;
+    private _create;
+    private _update;
+    /**
+     * Delete an instance from the database
+     */
+    delete(): Promise<void>;
+    /**
+     * Duplicates the current instance and if the options asDraft is not defined or false it will be saved it to the database
+     */
+    duplicate({ asDraft, newData, excludeColumns }?: BdORMDuplicateParams): Promise<InstanceType<typeof BdORMCrud>>;
+    save({ beforeSaveParams, afterSaveParams, preventAfterSave, preventBeforeSave, }?: {
+        beforeSaveParams?: {} | undefined;
+        afterSaveParams?: {} | undefined;
+        preventAfterSave?: boolean | undefined;
+        preventBeforeSave?: boolean | undefined;
+    }): Promise<InstanceType<typeof BdORMCrud>>;
+    static count(where?: Record<string, any> | string, values?: any[]): Promise<number>;
+    static create<T extends typeof BdORMCrud>(this: T, data: any): Promise<InstanceType<T>>;
+    static fetch<T extends typeof BdORMCrud>(this: T, where?: Record<string, any> | string, values?: any[]): Promise<InstanceType<T>[]>;
+    static fetchById<T extends typeof BdORMCrud>(this: T, id: string | number): Promise<InstanceType<T> | undefined>;
+    static fetchOne<T extends typeof BdORMCrud>(this: T, where: Record<string, any> | string, values?: any[]): Promise<InstanceType<T> | undefined>;
+    static fetchByPrimaryKey<T extends typeof BdORMCrud>(this: T, primaryKeyValue: string | number): Promise<InstanceType<T> | undefined>;
+    static setDbConnection(dbConnection: InstanceType<typeof BdOrmDbConnection>): void;
+    static clearDbConnection(): void;
+    static getDbConnection(): BdOrmDbConnection;
+}
+export {};