@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,385 @@
+"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;
+    };
+})();
+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.PrismaHealEtalonStore = exports.PrismaCLIArgsStore = exports.PrismaPendingSessionStore = exports.PrismaDeviceStore = void 0;
+const prisma_service_1 = require("./prisma-service");
+const typedi_1 = require("typedi");
+const semver = __importStar(require("semver"));
+const logger_1 = __importDefault(require("../logger"));
+class PrismaDeviceStore {
+    constructor() {
+        this.prisma = typedi_1.Container.get(prisma_service_1.PrismaService);
+    }
+    toIDevice(device) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return Object.assign(Object.assign({}, device), { cloud: device.cloud ? JSON.parse(device.cloud) : undefined, capability: device.capability ? JSON.parse(device.capability) : undefined, chromeDriverPath: device.chromeDriverPath ? JSON.parse(device.chromeDriverPath) : undefined, tags: device.tags ? JSON.parse(device.tags) : undefined, platform: (device.platform || 'android'), name: device.name || 'unknown', state: device.state || 'available', sdk: device.sdk || 'unknown', deviceType: device.deviceType || 'real', busy: (_a = device.busy) !== null && _a !== void 0 ? _a : false, userBlocked: (_b = device.userBlocked) !== null && _b !== void 0 ? _b : false, realDevice: (_c = device.realDevice) !== null && _c !== void 0 ? _c : true, lastHealthCheckAt: (_d = device.lastHealthCheckAt) !== null && _d !== void 0 ? _d : undefined, healthStatus: (_e = device.healthStatus) !== null && _e !== void 0 ? _e : 'Healthy', healthCheckError: (_f = device.healthCheckError) !== null && _f !== void 0 ? _f : undefined, batteryLevel: (_g = device.batteryLevel) !== null && _g !== void 0 ? _g : undefined, thermalStatus: (_h = device.thermalStatus) !== null && _h !== void 0 ? _h : undefined, storageFree: (_j = device.storageFree) !== null && _j !== void 0 ? _j : undefined, sessionProgress: (_k = device.sessionProgress) !== null && _k !== void 0 ? _k : '', totalHealedCount: (_l = device.totalHealedCount) !== null && _l !== void 0 ? _l : 0 });
+    }
+    fromIDevice(device) {
+        const data = Object.assign({}, device);
+        if (data.cloud && typeof data.cloud === 'object')
+            data.cloud = JSON.stringify(data.cloud);
+        if (data.capability && typeof data.capability === 'object')
+            data.capability = JSON.stringify(data.capability);
+        if (data.chromeDriverPath && typeof data.chromeDriverPath === 'object')
+            data.chromeDriverPath = JSON.stringify(data.chromeDriverPath);
+        if (data.tags && Array.isArray(data.tags))
+            data.tags = JSON.stringify(data.tags);
+        return data;
+    }
+    getAllDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.prisma.device.findMany();
+            return devices.map((d) => this.toIDevice(d));
+        });
+    }
+    getDevices(filterOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const where = {};
+            if (filterOptions.platform) {
+                where.platform = filterOptions.platform;
+            }
+            if (filterOptions.busy !== undefined) {
+                where.busy = filterOptions.busy;
+            }
+            if (filterOptions.offline !== undefined) {
+                where.offline = filterOptions.offline;
+            }
+            if (filterOptions.userBlocked !== undefined) {
+                where.userBlocked = filterOptions.userBlocked;
+            }
+            if (filterOptions.udid) {
+                if (Array.isArray(filterOptions.udid)) {
+                    if (filterOptions.udid.length > 0) {
+                        where.udid = { in: filterOptions.udid };
+                    }
+                }
+                else {
+                    where.udid = filterOptions.udid;
+                }
+            }
+            if (filterOptions.deviceType) {
+                where.deviceType = filterOptions.deviceType;
+            }
+            if (filterOptions.session_id && typeof filterOptions.session_id === 'string') {
+                where.session_id = filterOptions.session_id;
+            }
+            if (filterOptions.filterByHost) {
+                where.host = { contains: filterOptions.filterByHost };
+            }
+            // 1. Fetch narrowed result set from Database
+            const devices = yield this.prisma.device.findMany({ where });
+            let results = devices.map((d) => this.toIDevice(d));
+            // 2. Apply complex filters (Semver, Tags) in memory on the narrowed set
+            if (filterOptions.platformVersion) {
+                const coercedPlatformVersion = semver.coerce(filterOptions.platformVersion);
+                results = results.filter((obj) => {
+                    const coercedSDK = semver.coerce(obj.sdk);
+                    return !!(coercedSDK &&
+                        coercedPlatformVersion &&
+                        semver.eq(coercedSDK, coercedPlatformVersion));
+                });
+            }
+            if (filterOptions.minSDK) {
+                const coercedMinSDK = semver.coerce(filterOptions.minSDK);
+                if (coercedMinSDK) {
+                    results = results.filter((obj) => {
+                        const coercedSDK = semver.coerce(obj.sdk);
+                        return !!(coercedSDK && semver.gte(coercedSDK, coercedMinSDK));
+                    });
+                }
+            }
+            if (filterOptions.maxSDK) {
+                const coercedMaxSDK = semver.coerce(filterOptions.maxSDK);
+                if (coercedMaxSDK) {
+                    results = results.filter((obj) => {
+                        const coercedSDK = semver.coerce(obj.sdk);
+                        return !!(coercedSDK && semver.lte(coercedSDK, coercedMaxSDK));
+                    });
+                }
+            }
+            if (filterOptions.tags && filterOptions.tags.length > 0) {
+                results = results.filter((d) => {
+                    if (!d.tags)
+                        return false;
+                    return filterOptions.tags.every((tag) => d.tags.includes(tag));
+                });
+            }
+            return results;
+        });
+    }
+    updatedAllocatedDevice(device, updateData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updateDevice(device.udid, device.host, updateData);
+        });
+    }
+    updateDevice(udid, host, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = this.fromIDevice(update);
+            const result = yield this.prisma.device.updateMany({
+                where: { udid, host },
+                data,
+            });
+            logger_1.default.debug(`[PrismaStore] Update device ${udid} at ${host}: ${result.count} records affected`);
+        });
+    }
+    updateDevices(filter, updateFn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.prisma.device.findMany({ where: filter });
+            for (const d of devices) {
+                const idv = this.toIDevice(d);
+                updateFn(idv);
+                yield this.prisma.device.update({
+                    where: { udid_host: { udid: d.udid, host: d.host } },
+                    data: this.fromIDevice(idv),
+                });
+            }
+        });
+    }
+    addDevices(devices) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const added = [];
+            for (const device of devices) {
+                const data = this.fromIDevice(device);
+                // Use upsert to avoid race conditions and unique constraint errors
+                const d = yield this.prisma.device.upsert({
+                    where: { udid_host: { udid: device.udid, host: device.host } },
+                    update: data,
+                    create: data,
+                });
+                added.push(this.toIDevice(d));
+            }
+            return added;
+        });
+    }
+    removeDevices(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Principal Fix: Support partial host matching (e.g., "192.168.0.100" should match "http://192.168.0.100:4723")
+            // This is necessary because the device tracker passes the raw IP, not the full URL.
+            const whereClause = {};
+            if (filter.udid) {
+                whereClause.udid = filter.udid;
+            }
+            if (filter.host) {
+                // Use Prisma's `contains` for partial matching if host doesn't look like a full URL
+                if (filter.host.startsWith('http://') || filter.host.startsWith('https://')) {
+                    whereClause.host = filter.host;
+                }
+                else {
+                    whereClause.host = { contains: filter.host };
+                }
+            }
+            yield this.prisma.device.deleteMany({ where: whereClause });
+        });
+    }
+    clearStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.device.deleteMany();
+        });
+    }
+    findDevice(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.prisma.device.findFirst({ where: filter });
+            return device ? this.toIDevice(device) : null;
+        });
+    }
+    findDevices(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.prisma.device.findMany({ where: filter });
+            return devices.map((d) => this.toIDevice(d));
+        });
+    }
+    findAndLockDevice(filterOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Get candidate devices that match the filters and are NOT busy
+            const candidates = yield this.getDevices(Object.assign(Object.assign({}, filterOptions), { busy: false }));
+            // 2. Attempt to atomically lock them one by one
+            for (const device of candidates) {
+                const result = yield this.prisma.device.updateMany({
+                    where: {
+                        udid: device.udid,
+                        host: device.host,
+                        busy: false, // Double check it's still free
+                        offline: false,
+                    },
+                    data: {
+                        busy: true,
+                        lastCmdExecutedAt: Date.now(),
+                        sessionStartTime: Date.now(),
+                    },
+                });
+                if (result.count === 1) {
+                    logger_1.default.info(`[PrismaStore] Successfully locked device ${device.udid} atomically`);
+                    // Fetch the latest state to return
+                    const lockedDevice = yield this.prisma.device.findUnique({
+                        where: { udid_host: { udid: device.udid, host: device.host } },
+                    });
+                    return lockedDevice ? this.toIDevice(lockedDevice) : null;
+                }
+            }
+            return null;
+        });
+    }
+    resetMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.device.updateMany({
+                data: {
+                    totalHealedCount: 0,
+                },
+            });
+        });
+    }
+}
+exports.PrismaDeviceStore = PrismaDeviceStore;
+class PrismaPendingSessionStore {
+    constructor() {
+        this.prisma = typedi_1.Container.get(prisma_service_1.PrismaService);
+    }
+    addPendingSession(capability) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.pendingSession.upsert({
+                where: { capability_id: capability.capability_id },
+                update: {
+                    capability: JSON.stringify(capability),
+                    createdAt: capability.createdAt || Date.now(),
+                },
+                create: {
+                    capability_id: capability.capability_id,
+                    capability: JSON.stringify(capability),
+                    createdAt: capability.createdAt || Date.now(),
+                },
+            });
+        });
+    }
+    removePendingSession(sessionCapabilityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.prisma.pendingSession.delete({
+                    where: { capability_id: sessionCapabilityId },
+                });
+            }
+            catch (e) {
+                // ignore if not found
+            }
+        });
+    }
+    getAllPendingSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = yield this.prisma.pendingSession.findMany();
+            return sessions.map((s) => JSON.parse(s.capability));
+        });
+    }
+    remove(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.prisma.pendingSession.delete({
+                    where: { capability_id: session.capability_id },
+                });
+            }
+            catch (e) {
+                // ignore if not found
+            }
+        });
+    }
+}
+exports.PrismaPendingSessionStore = PrismaPendingSessionStore;
+class PrismaCLIArgsStore {
+    constructor() {
+        this.prisma = typedi_1.Container.get(prisma_service_1.PrismaService);
+    }
+    addCLIArgs(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.cLIArgs.create({
+                data: {
+                    args: JSON.stringify(args),
+                },
+            });
+        });
+    }
+    getCLIArgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = yield this.prisma.cLIArgs.findMany();
+            return entries.map((e) => JSON.parse(e.args));
+        });
+    }
+}
+exports.PrismaCLIArgsStore = PrismaCLIArgsStore;
+class PrismaHealEtalonStore {
+    constructor() {
+        this.prisma = typedi_1.Container.get(prisma_service_1.PrismaService);
+    }
+    saveSignature(etalon) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.locatorEtalon.upsert({
+                where: { selector: etalon.selector },
+                update: {
+                    strategy: etalon.strategy,
+                    attributes: JSON.stringify(etalon.attributes),
+                    nodeName: etalon.nodeName,
+                    lastSeen: new Date(),
+                },
+                create: {
+                    selector: etalon.selector,
+                    strategy: etalon.strategy,
+                    attributes: JSON.stringify(etalon.attributes),
+                    nodeName: etalon.nodeName,
+                    lastSeen: new Date(),
+                },
+            });
+        });
+    }
+    getSignature(selector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const etalon = yield this.prisma.locatorEtalon.findUnique({
+                where: { selector },
+            });
+            if (!etalon)
+                return null;
+            return Object.assign(Object.assign({}, etalon), { attributes: JSON.parse(etalon.attributes), lastSeen: etalon.lastSeen.getTime() });
+        });
+    }
+}
+exports.PrismaHealEtalonStore = PrismaHealEtalonStore;

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

@@ -0,0 +1,150 @@
+"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);
+};
+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.QueueService = void 0;
+const device_store_1 = require("./device-store");
+const prisma_service_1 = require("./prisma-service");
+const logger_1 = __importDefault(require("../logger"));
+const typedi_1 = require("typedi");
+let QueueService = class QueueService {
+    constructor(prisma) {
+        this.prisma = prisma;
+        this.deviceStore = device_store_1.DeviceStoreFactory.getStore();
+        this.pendingStore = device_store_1.DeviceStoreFactory.getPendingSessionStore();
+    }
+    /**
+     * Calculates the average session duration for a platform in milliseconds
+     * Defaults to 5 minutes (300,000 ms) if no history exists
+     */
+    getAverageSessionDuration(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const recentSessions = yield this.prisma.session.findMany({
+                    where: {
+                        device_platform: platform.toLowerCase(),
+                        endTime: { not: null },
+                    },
+                    orderBy: {
+                        endTime: 'desc',
+                    },
+                    take: 20,
+                    select: {
+                        startTime: true,
+                        endTime: true,
+                    },
+                });
+                if (recentSessions.length === 0) {
+                    return 300000; // 5 minutes default
+                }
+                const totalDuration = recentSessions.reduce((acc, session) => {
+                    const duration = session.endTime.getTime() - session.startTime.getTime();
+                    return acc + duration;
+                }, 0);
+                return Math.floor(totalDuration / recentSessions.length);
+            }
+            catch (e) {
+                logger_1.default.error(`Error calculating average session duration: ${e}`);
+                return 300000;
+            }
+        });
+    }
+    /**
+     * Returns queue status for a specific pending capability
+     */
+    getQueueStatus(capabilityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.default.info(`[QueueService] Fetching queue status for capability ID: ${capabilityId}`);
+            const allPending = yield this.pendingStore.getAllPendingSessions();
+            const sortedPending = allPending.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+            const index = sortedPending.findIndex((s) => s.capability_id === capabilityId);
+            if (index === -1)
+                return null;
+            const request = sortedPending[index];
+            const platform = (((_a = request.alwaysMatch) === null || _a === void 0 ? void 0 : _a.platformName) ||
+                request.platformName ||
+                'any').toLowerCase();
+            // Find devices that could potentially handle this request
+            const allDevices = yield this.deviceStore.getAllDevices();
+            const matchedDevices = allDevices.filter((d) => platform === 'any' || d.platform.toLowerCase() === platform);
+            const availableDevices = matchedDevices.filter((d) => !d.busy && !d.userBlocked && !d.offline);
+            // Position in terms of platform-specific queue
+            const platformSortedPending = sortedPending.filter((s) => {
+                var _a;
+                const sPlatform = (((_a = s.alwaysMatch) === null || _a === void 0 ? void 0 : _a.platformName) || s.platformName || 'any').toLowerCase();
+                return platform === 'any' || sPlatform === platform || sPlatform === 'any';
+            });
+            const platformIndex = platformSortedPending.findIndex((s) => s.capability_id === capabilityId);
+            const position = platformIndex + 1;
+            // ETA Calculation:
+            // We assume devices are occupied and will become free at a rate determined by AvgDuration.
+            const avgDuration = yield this.getAverageSessionDuration(platform);
+            // Simple heuristic: Wait time = (Position / Matched Devices) * AvgDuration
+            // If we have 10 devices and user is #10, wait time is ~AvgDuration / 10 if all were busy.
+            // However, if some are free, wait time is 0.
+            // For simplicity when queued: (Position / Max(1, MatchedDevices)) * AvgDuration
+            const matchedCount = Math.max(1, matchedDevices.length);
+            const etaInMs = availableDevices.length > 0 && position === 1
+                ? 0
+                : Math.floor((position / matchedCount) * avgDuration);
+            return {
+                position,
+                totalInQueue: platformSortedPending.length,
+                etaInMs,
+                platform,
+                matchedDevicesCount: matchedDevices.length,
+                availableDevicesCount: availableDevices.length,
+            };
+        });
+    }
+    /**
+     * Returns a high-level summary of the entire queue
+     */
+    getQueueSummary() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info('[QueueService] Calculating global queue summary');
+            const allPending = yield this.pendingStore.getAllPendingSessions();
+            const platforms = [
+                ...new Set(allPending.map((s) => { var _a; return (((_a = s.alwaysMatch) === null || _a === void 0 ? void 0 : _a.platformName) || s.platformName || 'any').toLowerCase(); })),
+            ];
+            const summary = {
+                total: allPending.length,
+                byPlatform: {},
+            };
+            for (const p of platforms) {
+                const pPending = allPending.filter((s) => { var _a; return (((_a = s.alwaysMatch) === null || _a === void 0 ? void 0 : _a.platformName) || s.platformName || 'any').toLowerCase() === p; });
+                const avgDuration = yield this.getAverageSessionDuration(p);
+                summary.byPlatform[p] = {
+                    count: pPending.length,
+                    avgDurationMs: avgDuration,
+                };
+            }
+            return summary;
+        });
+    }
+};
+exports.QueueService = QueueService;
+exports.QueueService = QueueService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService])
+], QueueService);

package/lib/src/data-service/web-config-service.js

@@ -0,0 +1,130 @@
+"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 __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.WebConfigService = void 0;
+const prisma_1 = require("../prisma");
+const typedi_1 = require("typedi");
+let WebConfigService = class WebConfigService {
+    constructor() {
+        this.CONFIG_ID = 'global';
+    }
+    getConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configs = yield prisma_1.prisma.webConfig.findMany({
+                where: { id: this.CONFIG_ID },
+            });
+            const result = {};
+            for (const config of configs) {
+                if (config.name === 'healthCheckIntervalMs') {
+                    result.healthCheckIntervalMs = parseInt(config.value);
+                }
+                else if (config.name === 'healthCheckSchedule') {
+                    result.healthCheckSchedule = config.value;
+                }
+                else if (config.name === 'buildCleanupDays') {
+                    result.buildCleanupDays = parseInt(config.value);
+                }
+                else if (config.name === 'buildCleanupMaxCount') {
+                    result.buildCleanupMaxCount = parseInt(config.value);
+                }
+                else if (config.name === 'buildCleanupSchedule') {
+                    result.buildCleanupSchedule = config.value;
+                }
+                else if (config.name === 'deleteBuildAssets') {
+                    result.deleteBuildAssets = config.value === 'true';
+                }
+            }
+            return result;
+        });
+    }
+    setConfig(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            if (config.healthCheckIntervalMs !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'healthCheckIntervalMs' },
+                    update: { value: config.healthCheckIntervalMs.toString() },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'healthCheckIntervalMs',
+                        value: config.healthCheckIntervalMs.toString(),
+                    },
+                }));
+            }
+            if (config.healthCheckSchedule !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'healthCheckSchedule' },
+                    update: { value: config.healthCheckSchedule },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'healthCheckSchedule',
+                        value: config.healthCheckSchedule,
+                    },
+                }));
+            }
+            if (config.buildCleanupDays !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'buildCleanupDays' },
+                    update: { value: config.buildCleanupDays.toString() },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'buildCleanupDays',
+                        value: config.buildCleanupDays.toString(),
+                    },
+                }));
+            }
+            if (config.buildCleanupMaxCount !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'buildCleanupMaxCount' },
+                    update: { value: config.buildCleanupMaxCount.toString() },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'buildCleanupMaxCount',
+                        value: config.buildCleanupMaxCount.toString(),
+                    },
+                }));
+            }
+            if (config.buildCleanupSchedule !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'buildCleanupSchedule' },
+                    update: { value: config.buildCleanupSchedule },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'buildCleanupSchedule',
+                        value: config.buildCleanupSchedule,
+                    },
+                }));
+            }
+            if (config.deleteBuildAssets !== undefined) {
+                promises.push(prisma_1.prisma.webConfig.upsert({
+                    where: { name: 'deleteBuildAssets' },
+                    update: { value: config.deleteBuildAssets.toString() },
+                    create: {
+                        id: this.CONFIG_ID,
+                        name: 'deleteBuildAssets',
+                        value: config.deleteBuildAssets.toString(),
+                    },
+                }));
+            }
+            yield Promise.all(promises);
+        });
+    }
+};
+exports.WebConfigService = WebConfigService;
+exports.WebConfigService = WebConfigService = __decorate([
+    (0, typedi_1.Service)()
+], WebConfigService);