# rik-database

> Database ORM RIK 0.0.12-0

Latest version **1.4.5** (published 2018-02-02) · MIT license · 0 weekly downloads

## Install

```sh
npm install rik-database
pnpm add rik-database
yarn add rik-database
bun add rik-database
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.4.5 |
| Published | 2018-02-02 |
| First published | 2017-10-30 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 7 |
| Known vulnerabilities | 0 (+3 in 2 direct dependencies) |
| Install scripts | no |
| Author | andrew_gd |
| Maintainers | andrew_gd |
| Keywords | database, typescript, PostgreSQL, ORM |

## Links

- npm: https://www.npmjs.com/package/rik-database
- Repository: https://bitbucket.org/andrew_gd/rik-database
- Homepage: https://bitbucket.org/andrew_gd/rik-database#readme
- npm.io page: https://npm.io/package/rik-database

## Dependencies (7)

- [pg](https://npm.io/package/pg.md) ^7.4.0
- [glob](https://npm.io/package/glob.md) ^7.1.2
- [knex](https://npm.io/package/knex.md) ^0.14.0
- [objection](https://npm.io/package/objection.md) ^0.9.0
- [@types/glob](https://npm.io/package/@types/glob.md) ^5.0.33
- [@types/knex](https://npm.io/package/@types/knex.md) 0.0.65
- [compare-version](https://npm.io/package/compare-version.md) ^0.1.2

## Alternatives

- [mobx-react](https://npm.io/package/mobx-react.md) — 2.8M weekly downloads
- [rc-tree](https://npm.io/package/rc-tree.md) — 2.6M weekly downloads
- [@react-oauth/google](https://npm.io/package/@react-oauth/google.md) — 1.3M weekly downloads
- [@wagmi/connectors](https://npm.io/package/@wagmi/connectors.md) — 877.0K weekly downloads
- [vee-validate](https://npm.io/package/vee-validate.md) — 836.4K weekly downloads

## Recent versions

- 1.4.5 (latest) — 2018-02-02
- 1.4.4 — 2018-02-01
- 1.4.3 — 2018-02-01
- 1.4.2 — 2018-01-31
- 1.4.1 — 2018-01-31
- 1.4.0 — 2018-01-25
- 1.3.4 — 2018-01-19
- 1.1.2 — 2018-01-18
- 1.3.3 — 2018-01-02
- 1.3.2 — 2017-12-27
- 1.3.1 — 2017-12-26
- 1.3.0 — 2017-12-22
- 1.2.7 — 2017-12-20
- 1.2.6 — 2017-12-19
- 1.2.5 — 2017-12-13
- … 27 more at https://npm.io/package/rik-database/versions

## README

#### Provides a database classes for a specific project named 'RIK'

## Examples

```ts
import { 
    Version, 
    IVersion, 
    DbSettings, 
    Rik, 
    NetworkGlobalSettings,
    NetworkInterfaceSettings, 
    INetworkInterfaceSettings,
    Plst } from 'rik-database';

const config = {
    client: 'pg',
    connection: 
    { 
        host: 'your host', 
        user: 'user', 
        password: 'password', 
        database: 'databaseName', 
        port: 'your port' 
    } 
};  

DbSettings.setConfig(config);

export class Db {

    public async getDataVersion(): Promise<void> {
        let data = await Version.query().orderBy('id', 'desc').first();

        console.log('\n+------- Versions -------+');
        if(data){ console.log(data); }
        else{ console.log('Table is empty.'); }
    }

    public async addNewVersion(version: IVersion): Promise<void> {
        let newVersion = await Version.query().insert(version);       
        console.log('\nNew version has been added. Version: ', newVersion);
    }

    public async updateVersion(id: number, version: IVersion): Promise<void> {
        let updateVersion = await Version.query().patchAndFetchById(id, version);      
        console.log('\nVersion has been updated. Version: ', updateVersion);
    }

    public async deleteVersionBy(id: number): Promise<void> {
        let deletedVersion = await Version.query().deleteById(id);
        console.log('\nVesions has been deleted, numbers: ', deletedVersion);
    }

    public async getTfzu(req: number): Promise<void> {
        let task = Plst.query().skipUndefined()
                            .select('ECO1','PNUM','a.ATTE as FZ_TFZU_1')
                            .leftOuterJoin('ATST as a', Rik.raw('cast("PLST"."FZ_TFZU_1" as int)'), 'a.ATNU')
                            .where('PLST.PNUM', '=', req)
                            .andWhere('PLST.GPR1', '>', 0)
                            .andWhere('PLST.WALO', '=', 0);
        
        console.log('[SQL]: ', task.toSql());    
        let data = await task;        

        console.log(data);
    }

    /**Inserting object array  */
    public async setSettings(req: any, res: any): Promise<void> {
        try {

            let set = [
                new NetworkInterfaceSettings({
                    name: 'et34',
                    method_name: 'auto',
                    ip_address: '127.0.0.1',
                    gateway: '127.0.0.1'
                }),
                new NetworkInterfaceSettings({
                    name: 'et82',
                    method_name: 'manual',
                    ip_address: '127.0.0.1',
                    gateway: '127.0.0.1'
                })
            ];

            let task = NetworkInterfaceSettings.query().insertAndFetch(set);

            console.log('sql request:', task.toSql());

            let data = await task;

            console.log(data);
        } catch (error) {
            console.log('[SEARCHDB:setSettings]:', error);
        }
    }

    public async setSettingsWithTransaction(req: any, res: any): Prommise<void> {
        try {

            if(req){

                const { interfacesSettings } = req;

                //region NetworkInterfaceSettings
                const interfacesSettingsItems = new Array<NetworkInterfaceSettings>();
                const interfacesSettingsInsertsItems = new Array<NetworkInterfaceSettings>();
                const interfacesSettingsUpdatesItems = new Array<NetworkInterfaceSettings>();
                //endregion

                //region For typescript
                const networkInterfacesSettings = interfacesSettings as Array<INetworkInterfaceSettings>;  
                //endregion
                
                //region Creates instances items 
                if(interfacesSettings instanceof Array && networkInterfacesSettings !== null && networkInterfacesSettings.length > 0){
                                                       
                    networkInterfacesSettings.forEach(element => {
                        interfacesSettingsItems.push(new NetworkInterfaceSettings(element));
                    });                   
                }
                //endregion

                //region gets items which are needed to update or gets items which are needed to insert
                if(interfacesSettingsItems.length > 0){
                    for (let i = 0; i < interfacesSettingsItems.length; i++) {
                        let item = interfacesSettingsItems[i];
                        
                        let updateInterfaceItem = await NetworkInterfaceSettings.query().where('name', '=', item.name);
                        if(updateInterfaceItem !== null && updateInterfaceItem !== undefined && updateInterfaceItem.length > 0){
                            interfacesSettingsUpdatesItems.push(item)
                        }
                        else{
                            interfacesSettingsInsertsItems.push(item);
                        }
                    }
                }
                //endregion

                console.log('updates interfaces items', interfacesSettingsUpdatesItems);
                console.log('inserts interfaces items', interfacesSettingsInsertsItems);
                
                let countItems = 0                 
                
                function addItems (params: number | Array<number>) {
                    if(params instanceof Array){
                        countItems += params.length;
                    }
                    else{
                        countItems += params;
                    }
                }       

                const trx = await Rik.transaction.start(DbSettings.knex);
                try {

                    let insertsInterfacesItems = await NetworkInterfaceSettings.query(trx).insertAndFetch(interfacesSettingsInsertsItems);
                    addItems(insertsInterfacesItems.length);                        

                    for (let i = 0; i < interfacesSettingsUpdatesItems.length; i++) {
                        let item = interfacesSettingsUpdatesItems[i];
                        
                        let result = await NetworkInterfaceSettings.query(trx).patch(item).where('name', '=', item.name);
                        
                        addItems(result);
                    }
                    await trx.commit();
                } catch (error) {
                    trx.rollback(error);
                    throw error;
                }

                console.log('Updated and inserted item numbers:', countItems);                                    
            }
        } catch (error) {
            console.log('[setSettings]:', error);
        }
    }
}

(async () => {
    try {      
        let db = new Db();
        et version = { current_version: '2.2.2.5', description: 'Some info' }

        let interfacesSettings = [
            {
                name: 'eqwe1',
                method_name: 'auto',
                ip_address: '127.0.0.1',
                gateway: '127.0.0.1',
            },
            {
                name: 'et24fn62',
                method_name: 'manual',
                ip_address: '127.0.0.1',
                gateway: '127.0.0.1',
            }
        ];

        let req = {
            interfacesSettings
        }

        //await db.getDataVersion();
        //await db.addNewVersion(version)
        //await db.updateVersion(9, version);
        //await db.deleteVersionBy(10);
        //console.log('config: ', DbSettings.config);
        //await db.getTfzu(1);
        //await db.setSettings(3, 4);
        await db.setSettingsWithTransaction(req, 4);

} catch (error) { console.error(error); } })()

---
_Source: https://npm.io/package/rik-database · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._