refactor: rewrite using dbus-next

Author: MessiasLima

package.json

@@ -19,7 +19,6 @@
         "start": "ts-node src/"
     },
     "dependencies": {
-        "dbus-native": "^0.4.0",
         "dbus-next": "^0.10.2",
         "reflect-metadata": "^0.1.13",
         "rxjs": "^7.5.5",

src/di/package-kit.register.ts

@@ -0,0 +1,10 @@
+import { InjectionToken } from 'tsyringe';
+import { container } from 'tsyringe';
+import { MessageBus, systemBus } from 'dbus-next';
+
+export const INJECTION_TOKEN_SYSTEM_BUS: InjectionToken<string> =
+    'node.bus.system';
+
+container.register<MessageBus>(INJECTION_TOKEN_SYSTEM_BUS, {
+    useValue: systemBus(),
+});

src/di/service.registerer.ts

@@ -1,21 +1,12 @@
-import { PackageKit } from './packagekit';
+import 'reflect-metadata';
 import { container } from 'tsyringe';
+import { PackagekitProvider } from './packagekit.provider';
 import { TransactionProvider } from './transaction.provider';
-import { SearchFilter } from './search-filter.enum';
 
-async function teste() {
-    try {
-        console.log('getting interface');
-        const packageKit = await PackageKit.create();
-        const transactionPath = await packageKit.createTransaction();
-        const transactionProvider = container.resolve(TransactionProvider);
-        const transaction = await transactionProvider.getTransaction(
-            transactionPath
-        );
-        await transaction.cancel();
-    } catch (e) {
-        console.error(e);
-    }
+export function getPackageKitProvider(): PackagekitProvider {
+    return container.resolve(PackagekitProvider);
 }
 
-teste().then();
+export function getTransactionProvider(): TransactionProvider {
+    return container.resolve(TransactionProvider);
+}

src/index.ts

@@ -0,0 +1,5 @@
+import { ClientInterface } from 'dbus-next';
+
+export interface PackageKit extends ClientInterface {
+    CreateTransaction(): Promise<string>;
+}

src/interface.provider.ts

@@ -0,0 +1,5 @@
+import { ClientInterface } from 'dbus-next';
+
+export interface Transaction extends ClientInterface {
+    Close(): Promise<void>;
+}

src/interface/packagekit-dbus.interface.ts

@@ -0,0 +1,28 @@
+import { inject, injectable } from 'tsyringe';
+import { INJECTION_TOKEN_SYSTEM_BUS } from './di/package-kit.register';
+import { MessageBus } from 'dbus-next';
+import { PackageKit } from './interface/packagekit.interface';
+
+@injectable()
+export class PackagekitProvider {
+    static readonly PACKAGE_KIT_OBJECT_NAME = 'org.freedesktop.PackageKit';
+    private static readonly PACKAGE_KIT_INTERFACE_NAME =
+        'org.freedesktop.PackageKit';
+    private static readonly PACKAGE_KIT_OBJECT_PATH =
+        '/org/freedesktop/PackageKit';
+
+    constructor(@inject(INJECTION_TOKEN_SYSTEM_BUS) private bus: MessageBus) {}
+
+    getPackageKit(): Promise<PackageKit> {
+        return this.bus
+            .getProxyObject(
+                PackagekitProvider.PACKAGE_KIT_OBJECT_NAME,
+                PackagekitProvider.PACKAGE_KIT_OBJECT_PATH
+            )
+            .then((packageKitProxyObject) =>
+                packageKitProxyObject.getInterface<PackageKit>(
+                    PackagekitProvider.PACKAGE_KIT_INTERFACE_NAME
+                )
+            );
+    }
+}

src/interface/packagekit.interface.ts

@@ -1,37 +1,26 @@
 import { inject, injectable } from 'tsyringe';
-import { InterfaceProvider } from './interface.provider';
-import { Transaction } from './transaction';
+import { INJECTION_TOKEN_SYSTEM_BUS } from './di/package-kit.register';
+import { MessageBus } from 'dbus-next';
+import { Transaction } from './interface/transaction.interface';
+import { PackagekitProvider } from './packagekit.provider';
 
 @injectable()
 export class TransactionProvider {
-    private transactionCache: any = {};
+    private static readonly TRANSACTION_INTERFACE_NAME =
+        'org.freedesktop.PackageKit.Transaction';
 
-    constructor(private interfaceProvider: InterfaceProvider) {}
+    constructor(@inject(INJECTION_TOKEN_SYSTEM_BUS) private bus: MessageBus) {}
 
     getTransaction(transactionPath: string): Promise<Transaction> {
-        if (this.transactionCache[transactionPath]) {
-            return Promise.resolve(this.transactionCache[transactionPath]);
-        }
-
-        return this.interfaceProvider
-            .getTransactionInterface(transactionPath)
-            .then((transactionDbus) => {
-                const transaction = new Transaction(
-                    transactionDbus,
-                    transactionPath
-                );
-                this.handleNewCreatedTransactions(transactionPath, transaction);
-                return transaction;
-            });
-    }
-
-    private handleNewCreatedTransactions(
-        transactionPath: string,
-        transaction: Transaction
-    ): void {
-        this.transactionCache[transactionPath] = transaction;
-        transaction.onDestroy.subscribe((transaction) => {
-            this.transactionCache[transaction.path] = null;
-        });
+        return this.bus
+            .getProxyObject(
+                PackagekitProvider.PACKAGE_KIT_OBJECT_NAME,
+                transactionPath
+            )
+            .then((transactionProxyObject) =>
+                transactionProxyObject.getInterface<Transaction>(
+                    TransactionProvider.TRANSACTION_INTERFACE_NAME
+                )
+            );
     }
 }