@xenon-device-management/xenon 1.1.0

package/lib/src/data-service/device-store.js

@@ -0,0 +1,345 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceStoreFactory = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const semver_1 = __importDefault(require("semver"));
+const db_1 = require("./db");
+const prisma_store_1 = require("./prisma-store");
+const config_1 = require("../config");
+/**
+ * LokiJS Implementation of Device Store (Legacy/Internal)
+ */
+class LokiDeviceStore {
+    constructor() {
+        this.log = logger_1.default.scope('LokiStore');
+    }
+    getAllDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.DeviceModel).chain().find().data();
+        });
+    }
+    getDevices(filterOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const basicFilter = process.env.NODE_ENV === 'test'
+                ? {}
+                : { host: { $ne: undefined }, userBlocked: { $ne: undefined } };
+            const allInColl = (yield db_1.XenonDatabase.DeviceModel).find(basicFilter);
+            const filtered = allInColl.filter((device) => {
+                var _a;
+                // Platform Filter
+                if (filterOptions.platform) {
+                    const match = (device.platform || '').toLowerCase() === filterOptions.platform.toLowerCase();
+                    // if (!match) console.error(`[LokiStore] Platform Mismatch: ${device.udid} (${device.platform} vs ${filterOptions.platform})`);
+                    if (!match)
+                        return false;
+                }
+                // Platform Version Filter
+                if (filterOptions.platformVersion) {
+                    const coercedFilterVersion = semver_1.default.coerce(filterOptions.platformVersion);
+                    const coercedDeviceVersion = semver_1.default.coerce(device.sdk || '');
+                    if (!coercedFilterVersion ||
+                        !coercedDeviceVersion ||
+                        !semver_1.default.eq(coercedDeviceVersion, coercedFilterVersion))
+                        return false;
+                }
+                // Name Filter
+                if ((_a = filterOptions.name) === null || _a === void 0 ? void 0 : _a.trim()) {
+                    const nameRegex = new RegExp(filterOptions.name.trim(), 'i');
+                    if (!nameRegex.test(device.name || ''))
+                        return false;
+                }
+                // UDID Filter
+                if (filterOptions.udid) {
+                    if (Array.isArray(filterOptions.udid)) {
+                        if (filterOptions.udid.length > 0 && !filterOptions.udid.includes(device.udid))
+                            return false;
+                    }
+                    else if (device.udid !== filterOptions.udid) {
+                        return false;
+                    }
+                }
+                // Device Type Filter
+                if (filterOptions.deviceType) {
+                    if (device.deviceType !== filterOptions.deviceType)
+                        return false;
+                }
+                // Host Filter
+                if (filterOptions.filterByHost) {
+                    const hostFilter = filterOptions.filterByHost.toLowerCase();
+                    if (!(device.host || '').toLowerCase().includes(hostFilter))
+                        return false;
+                }
+                // Session ID Filter
+                if (filterOptions.session_id) {
+                    if (device.session_id !== filterOptions.session_id)
+                        return false;
+                }
+                // Busy / Offline / UserBlocked Filters
+                if (filterOptions.busy !== undefined && device.busy !== filterOptions.busy)
+                    return false;
+                if (filterOptions.offline !== undefined && device.offline !== filterOptions.offline)
+                    return false;
+                if (filterOptions.userBlocked !== undefined &&
+                    device.userBlocked !== filterOptions.userBlocked)
+                    return false;
+                // minSDK Filter
+                if (filterOptions.minSDK) {
+                    const coercedMinSDK = semver_1.default.coerce(filterOptions.minSDK);
+                    const coercedSDK = semver_1.default.coerce(device.sdk || '');
+                    if (!coercedMinSDK || !coercedSDK || !semver_1.default.gte(coercedSDK, coercedMinSDK))
+                        return false;
+                }
+                // maxSDK Filter
+                if (filterOptions.maxSDK) {
+                    const coercedMaxSDK = semver_1.default.coerce(filterOptions.maxSDK);
+                    const coercedSDK = semver_1.default.coerce(device.sdk || '');
+                    if (!coercedMaxSDK || !coercedSDK || !semver_1.default.lte(coercedSDK, coercedMaxSDK))
+                        return false;
+                }
+                return true;
+            });
+            return filtered.sort((a, b) => {
+                try {
+                    const vA = semver_1.default.coerce(a.sdk || '0.0.0');
+                    const vB = semver_1.default.coerce(b.sdk || '0.0.0');
+                    if (vA && vB) {
+                        if (semver_1.default.gt(vA, vB))
+                            return -1;
+                        if (semver_1.default.lt(vA, vB))
+                            return 1;
+                    }
+                }
+                catch (e) {
+                    // Ignore sort errors
+                }
+                return 0;
+            });
+        });
+    }
+    updateDevice(udid, host, updateData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel)
+                .chain()
+                .find({ udid, host })
+                .update((device) => {
+                Object.assign(device, updateData);
+            });
+        });
+    }
+    updateDevices(filter, updateFn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).update(updateFn);
+        });
+    }
+    addDevices(devices) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceModel = yield db_1.XenonDatabase.DeviceModel;
+            const added = [];
+            for (const device of devices) {
+                const existing = deviceModel.findOne({ udid: device.udid, host: device.host });
+                if (!existing) {
+                    const cleanDevice = Object.assign({}, device);
+                    if (cleanDevice.host === undefined)
+                        cleanDevice.host = 'Local';
+                    if (cleanDevice.userBlocked === undefined)
+                        cleanDevice.userBlocked = false;
+                    if (cleanDevice.busy === undefined)
+                        cleanDevice.busy = false;
+                    if (cleanDevice.offline === undefined)
+                        cleanDevice.offline = false;
+                    // @ts-ignore - LokiJS adds $loki metadata that we need to strip before insert
+                    delete cleanDevice['$loki'];
+                    // @ts-ignore
+                    delete cleanDevice['meta'];
+                    deviceModel.insert(cleanDevice);
+                    added.push(cleanDevice);
+                }
+            }
+            return added;
+        });
+    }
+    removeDevices(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).remove();
+        });
+    }
+    clearStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+        });
+    }
+    findDevice(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.DeviceModel).findOne(filter);
+        });
+    }
+    findDevices(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.DeviceModel).find(filter);
+        });
+    }
+    findAndLockDevice(filterOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDevices(filterOptions);
+            const available = devices.find((d) => !d.busy && !d.userBlocked);
+            if (available) {
+                yield this.updateDevice(available.udid, available.host, { busy: true });
+                return available;
+            }
+            return null;
+        });
+    }
+    resetMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel)
+                .chain()
+                .find()
+                .update((device) => {
+                device.totalHealedCount = 0;
+            });
+        });
+    }
+}
+class LokiPendingSessionStore {
+    addPendingSession(capability) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.PendingSessionsModel).insert(capability);
+        });
+    }
+    removePendingSession(sessionCapabilityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.PendingSessionsModel)
+                .chain()
+                .find({ capability_id: sessionCapabilityId })
+                .remove();
+        });
+    }
+    getAllPendingSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.PendingSessionsModel).chain().find().data();
+        });
+    }
+    remove(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.PendingSessionsModel).remove(session);
+        });
+    }
+}
+class LokiCLIArgsStore {
+    addCLIArgs(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.CLIArgs).insert(args);
+        });
+    }
+    getCLIArgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.CLIArgs).chain().find().data();
+        });
+    }
+}
+class LokiHealEtalonStore {
+    constructor() {
+        this.collectionName = 'locator-etalons';
+    }
+    getCollection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield db_1.XenonDatabase.db;
+            let coll = db.getCollection(this.collectionName);
+            if (!coll) {
+                coll = db.addCollection(this.collectionName, { unique: ['selector'] });
+            }
+            return coll;
+        });
+    }
+    saveSignature(etalon) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coll = yield this.getCollection();
+            const existing = coll.findOne({ selector: etalon.selector });
+            if (existing) {
+                Object.assign(existing, etalon);
+                coll.update(existing);
+            }
+            else {
+                coll.insert(etalon);
+            }
+        });
+    }
+    getSignature(selector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coll = yield this.getCollection();
+            return coll.findOne({ selector });
+        });
+    }
+}
+/**
+ * Factory for Device Store.
+ * Determines storage type based on config.
+ */
+class DeviceStoreFactory {
+    static getStorageType() {
+        if (process.env.NODE_ENV === 'test')
+            return 'loki';
+        const type = process.env.XENON_STORAGE_TYPE || config_1.config.databaseProvider;
+        if (type === 'sqlite' || type === 'postgresql' || type === 'prisma')
+            return 'prisma';
+        return 'loki';
+    }
+    static getStore() {
+        if (!this._deviceStore) {
+            if (this.getStorageType() === 'prisma') {
+                this._deviceStore = new prisma_store_1.PrismaDeviceStore();
+            }
+            else {
+                this._deviceStore = new LokiDeviceStore();
+            }
+        }
+        return this._deviceStore;
+    }
+    static getPendingSessionStore() {
+        if (!this._pendingSessionStore) {
+            if (this.getStorageType() === 'prisma') {
+                this._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+            }
+            else {
+                this._pendingSessionStore = new LokiPendingSessionStore();
+            }
+        }
+        return this._pendingSessionStore;
+    }
+    static getCLIArgsStore() {
+        if (!this._cliArgsStore) {
+            if (this.getStorageType() === 'prisma') {
+                this._cliArgsStore = new prisma_store_1.PrismaCLIArgsStore();
+            }
+            else {
+                this._cliArgsStore = new LokiCLIArgsStore();
+            }
+        }
+        return this._cliArgsStore;
+    }
+    static getHealEtalonStore() {
+        if (!this._healEtalonStore) {
+            if (this.getStorageType() === 'prisma') {
+                const { PrismaHealEtalonStore } = require('./prisma-store');
+                this._healEtalonStore = new PrismaHealEtalonStore();
+            }
+            else {
+                this._healEtalonStore = new LokiHealEtalonStore();
+            }
+        }
+        return this._healEtalonStore;
+    }
+}
+exports.DeviceStoreFactory = DeviceStoreFactory;

package/lib/src/data-service/pending-sessions-service.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNewPendingSession = addNewPendingSession;
+exports.removePendingSession = removePendingSession;
+const device_store_1 = require("./device-store");
+const store = device_store_1.DeviceStoreFactory.getPendingSessionStore();
+function addNewPendingSession(capability) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.addPendingSession(capability);
+    });
+}
+function removePendingSession(sessionCapabilityId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.removePendingSession(sessionCapabilityId);
+    });
+}

package/lib/src/data-service/pluginArgs.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCLIArgs = addCLIArgs;
+exports.getCLIArgs = getCLIArgs;
+const device_store_1 = require("./device-store");
+const store = device_store_1.DeviceStoreFactory.getCLIArgsStore();
+function addCLIArgs(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.addCLIArgs(args);
+    });
+}
+function getCLIArgs() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield store.getCLIArgs();
+    });
+}

package/lib/src/data-service/prisma-service.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaService = void 0;
+const client_1 = require("@prisma/client");
+const config_1 = require("../config");
+const typedi_1 = require("typedi");
+let PrismaService = class PrismaService extends client_1.PrismaClient {
+    constructor() {
+        super({
+            datasources: {
+                db: {
+                    url: config_1.config.databaseUrl,
+                },
+            },
+        });
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], PrismaService);