@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/src/services/token/mintedLifetime.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Nothing a credential mints outlives it.
+ *
+ * `credentialExpiresAt` is req.auth.credentialExpiresAt: when the credential
+ * making the request stops working (a Bearer token's `exp`, an API key's
+ * `expiresAt`), as epoch ms, or undefined for one that doesn't expire (a key
+ * without an expiry, a dashboard sign-in, which renews itself).
+ *
+ * Through 2.14 a 1-hour Bearer token could make itself an API key that never
+ * expired (POST /profile/tokens, POST /apikeys), or mint a fresh 1-hour token
+ * before it expired, and so on for ever (POST /auth/token).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintedLifetimeSec = mintedLifetimeSec;
+exports.keyExpiryWithin = keyExpiryWithin;
+/**
+ * A minted token's lifetime in seconds: `defaultSec`, cut to what is left of
+ * the credential minting it, less a second so the minted token's `exp`
+ * can't round past it. Throws when nothing is left.
+ */
+function mintedLifetimeSec(defaultSec, credentialExpiresAt) {
+    if (credentialExpiresAt === undefined)
+        return defaultSec;
+    const left = Math.floor((credentialExpiresAt - Date.now()) / 1000) - 1;
+    if (left < 1)
+        throw new Error('the credential used to mint this token has expired');
+    return Math.min(defaultSec, left);
+}
+/**
+ * An API key's expiry, made with a credential that may itself expire: the
+ * expiry asked for, or the credential's when none was asked for; an error
+ * when the one asked for is later than the credential's, or the credential
+ * has already expired.
+ */
+function keyExpiryWithin(requested, credentialExpiresAt) {
+    if (credentialExpiresAt === undefined)
+        return { expiresAt: requested };
+    // Token verification allows 60 s of clock skew, so a request can arrive on
+    // a credential just past its exp: it must not make a key already expired.
+    if (credentialExpiresAt <= Date.now()) {
+        return { error: 'the credential you are using has expired' };
+    }
+    if (requested && requested.getTime() > credentialExpiresAt) {
+        return {
+            error: 'expiresAt can be no later than the credential you are using, which expires at ' +
+                new Date(credentialExpiresAt).toISOString(),
+        };
+    }
+    return { expiresAt: requested !== null && requested !== void 0 ? requested : new Date(credentialExpiresAt) };
+}

package/lib/src/services/webhookEvents.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * What each webhook event carries.
+ *
+ * One shape per event, documented here and nowhere else. A webhook turns it
+ * into a message in three ways, and all three read these names:
+ *
+ * - the built-in Slack message (`type: slack`, `NotificationService`);
+ * - the generic JSON body, `{ "event": "<event>", "payload": { ... } }`;
+ * - a custom template, where `{{name}}` stands for a name below, `{{eventType}}`
+ *   for the event itself, and `{{a.b}}` or `{{list.0.b}}` reaches inside.
+ *
+ * The dashboard offers the names below as template chips
+ * (`web/src/components/webhook-settings/webhookEvents.ts`; a spec keeps the two
+ * lists equal). A device event also carries the device's other fields, which
+ * may change: only the names listed are promised.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_TYPES = exports.WEBHOOK_EVENTS = void 0;
+exports.isEventType = isEventType;
+exports.sessionFailedPayload = sessionFailedPayload;
+exports.renderTemplate = renderTemplate;
+const DEVICE_VARIABLES = [
+    { name: 'udid', description: "The device's id" },
+    { name: 'name', description: "The device's name" },
+    { name: 'host', description: 'The machine it is plugged into' },
+    { name: 'platform', description: 'android or ios' },
+];
+const sampleDevice = () => ({
+    udid: 'test-device-udid',
+    name: 'Test Device',
+    host: '127.0.0.1',
+    platform: 'android',
+});
+exports.WEBHOOK_EVENTS = {
+    device_offline: {
+        when: 'A device is no longer reported by its machine (unplugged, or its machine stopped).',
+        variables: DEVICE_VARIABLES,
+        sample: sampleDevice,
+    },
+    device_new: {
+        when: 'A device is detected for the first time.',
+        variables: DEVICE_VARIABLES,
+        sample: sampleDevice,
+    },
+    session_failed: {
+        when: 'A session ends as failed, once per session: the test marked it failed, a command failed, ' +
+            'it timed out for inactivity, its driver crashed, or its heartbeat stopped. Not when the ' +
+            'server itself shuts down, and not for a session that was already failed when the server ' +
+            'started.',
+        variables: [
+            { name: 'sessionId', description: "The session's id" },
+            { name: 'sessionName', description: "The session's name, if the test gave it one" },
+            { name: 'failureReason', description: 'Why it failed' },
+            { name: 'udid', description: "The device's id" },
+            { name: 'deviceName', description: "The device's name" },
+            { name: 'platform', description: 'android or ios' },
+            { name: 'osVersion', description: "The device's OS version" },
+            { name: 'startTime', description: 'When it started (ISO 8601)' },
+            { name: 'endTime', description: 'When it ended (ISO 8601)' },
+        ],
+        sample: () => ({
+            sessionId: 'test-session-id',
+            sessionName: 'Checkout flow',
+            failureReason: 'Test message: element not found',
+            udid: 'test-device-udid',
+            deviceName: 'Test Device',
+            platform: 'android',
+            osVersion: '14',
+            startTime: new Date(Date.now() - 150000).toISOString(),
+            endTime: new Date().toISOString(),
+        }),
+    },
+    selector_health_digest: {
+        when: 'The Selector Health digest is sent. `hotspots` lists the most healed selectors, each ' +
+            'with `healCount`, `originalSelector` and, when there is one, `suggestedRewrite`; reach ' +
+            'into it with `{{hotspots.0.originalSelector}}`.',
+        variables: [
+            { name: 'windowDays', description: 'How many days the digest covers' },
+            { name: 'totalHeals', description: 'Heals in that time' },
+            { name: 'distinctSelectors', description: 'Selectors that were healed' },
+        ],
+        sample: () => ({
+            windowDays: 30,
+            totalHeals: 12,
+            distinctSelectors: 3,
+            hotspots: [
+                {
+                    healCount: 7,
+                    originalSelector: "//*[@text='Log in']",
+                    suggestedRewrite: '~login-button',
+                },
+            ],
+        }),
+    },
+};
+exports.EVENT_TYPES = Object.keys(exports.WEBHOOK_EVENTS);
+function isEventType(value) {
+    return typeof value === 'string' && exports.EVENT_TYPES.includes(value);
+}
+/**
+ * `session_failed`'s payload. Not the row: a row has the session's
+ * capabilities, the keys that created it and its AI analysis, and its names
+ * are the database's (`failure_reason`). Unknown values are empty text, never
+ * missing, so a template never shows "undefined" or "null".
+ */
+function sessionFailedPayload(session) {
+    var _a, _b, _c;
+    const iso = (value) => value ? new Date(value).toISOString() : '';
+    return {
+        sessionId: session.id,
+        sessionName: (_a = session.name) !== null && _a !== void 0 ? _a : '',
+        failureReason: (_b = session.failure_reason) !== null && _b !== void 0 ? _b : '',
+        udid: session.device_udid,
+        deviceName: (_c = session.device_name) !== null && _c !== void 0 ? _c : '',
+        platform: session.device_platform,
+        osVersion: session.device_version,
+        startTime: iso(session.startTime),
+        endTime: iso(session.endTime),
+    };
+}
+function lookup(data, path) {
+    let value = data;
+    for (const key of path.trim().split('.')) {
+        value = value === null || value === undefined ? undefined : value[key];
+    }
+    return value;
+}
+const asText = (value) => typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
+/** `{{name}}` filled in from `data` as text; a name `data` doesn't have stays as written. */
+function fill(text, data) {
+    return text.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+        const value = lookup(data, path);
+        return value === undefined ? match : asText(value);
+    });
+}
+function fillStrings(node, data) {
+    if (typeof node === 'string')
+        return fill(node, data);
+    if (Array.isArray(node))
+        return node.map((item) => fillStrings(item, data));
+    if (node && typeof node === 'object') {
+        return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, fillStrings(value, data)]));
+    }
+    return node;
+}
+/**
+ * The body a custom template sends for an event.
+ *
+ * A template that is JSON as written is filled in string by string, so a
+ * value with a quote, a backslash or a line break (an error message, say)
+ * cannot break it. Any other template, such as `{"n": {{totalHeals}}}` or
+ * plain text, is filled in as text, then sent as JSON if the result parses,
+ * and as `{ "text": "<result>" }` if not.
+ */
+function renderTemplate(template, data) {
+    let written;
+    try {
+        written = JSON.parse(template);
+    }
+    catch (_a) {
+        written = undefined;
+    }
+    if (written !== null && typeof written === 'object')
+        return fillStrings(written, data);
+    const text = fill(template, data);
+    try {
+        return JSON.parse(text);
+    }
+    catch (_b) {
+        return { text };
+    }
+}

package/lib/src/sessions/SessionManager.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_MANAGER = exports.SessionManager = void 0;
+exports.SESSION_MANAGER = exports.SessionManager = exports.HUB_RESTART_CATEGORY = void 0;
 const os_1 = __importDefault(require("os"));
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
@@ -62,6 +62,12 @@ const device_store_1 = require("../data-service/device-store");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+/**
+ * The `failure_category` of a session a restart ended: one still running at
+ * boot that couldn't be picked up again. The failure analysis writes every
+ * other category (`ANALYSIS_CATEGORIES`).
+ */
+exports.HUB_RESTART_CATEGORY = 'HUB_RESTART';
 /**
  * SessionManager with persistence and recovery capabilities.
  *
@@ -306,7 +312,7 @@ let SessionManager = class SessionManager {
                         status: 'failed',
                         endTime: new Date(),
                         failure_reason: reason,
-                        failure_category: 'HUB_RESTART',
+                        failure_category: exports.HUB_RESTART_CATEGORY,
                     },
                 });
             }

package/lib/src/sessions/sessionMemory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgetSessionMemory = forgetSessionMemory;
+const typedi_1 = require("typedi");
+const OmniVisionService_1 = require("../services/omni-vision/OmniVisionService");
+const AutowaitService_1 = require("../services/autowait/AutowaitService");
+/**
+ * Drop what this server keeps in memory for a session's commands: the
+ * elements its finds and heals found in screenshots (OmniVisionService) and
+ * its autowait settings (AutowaitService). Called however the session ends
+ * here: the test's delete (SessionLifecycleService.deleteSession), Appium's
+ * new-command timeout or a crash (XenonPlugin.onUnexpectedShutdown), the idle
+ * release (releaseBlockedDevices), a stale heartbeat (OrphanSweeper) and a
+ * shutdown's drain (stopSessionForShutdown). Safe to call more than once.
+ *
+ * Through 2.14 the elements were never dropped, and the autowait settings
+ * only by the interceptor on `deleteSession`, a command Appium never hands
+ * it: XenonPlugin answers `deleteSession` itself.
+ */
+function forgetSessionMemory(sessionId) {
+    if (!sessionId)
+        return;
+    typedi_1.Container.get(OmniVisionService_1.OmniVisionService).forgetSession(sessionId);
+    typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(sessionId);
+}

package/lib/test/helpers/fake-adb.js

@@ -0,0 +1,58 @@
+"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.fakeAdb = fakeAdb;
+exports.useFakeAdb = useFakeAdb;
+const typedi_1 = require("typedi");
+const AndroidDeviceManager_1 = __importDefault(require("../../src/device-managers/AndroidDeviceManager"));
+const container_registration_1 = require("./container-registration");
+function fakeAdb(answers = {}) {
+    const fake = {
+        calls: [],
+        answers,
+        commands(udid) {
+            return fake.calls
+                .filter((args) => udid === undefined || args[1] === udid)
+                .map((args) => args.slice(2).join(' '));
+        },
+    };
+    return fake;
+}
+/**
+ * Registers `fake` as every phone's adb for the enclosing `describe`. Returns
+ * nothing: the registration is put back after each test.
+ */
+function useFakeAdb(get) {
+    let restore;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(AndroidDeviceManager_1.default);
+        typedi_1.Container.set(AndroidDeviceManager_1.default, {
+            getAdbForDevice: (udid) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    adbExec: (args) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const fake = get();
+                        fake.calls.push(args);
+                        const key = args.slice(args[0] === '-s' ? 2 : 0).join(' ');
+                        const answer = (_a = fake.answers[`${udid} ${key}`]) !== null && _a !== void 0 ? _a : fake.answers[key];
+                        if (answer instanceof Error)
+                            throw answer;
+                        return answer !== null && answer !== void 0 ? answer : '';
+                    }),
+                });
+            }),
+        });
+    });
+    afterEach(() => restore());
+}

package/lib/test/helpers/fake-ai-provider.js

@@ -0,0 +1,188 @@
+"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.OLLAMA_URL = exports.PROVIDERS = void 0;
+exports.useFakeAiProviders = useFakeAiProviders;
+const axios_1 = __importDefault(require("axios"));
+const sinon_1 = __importDefault(require("sinon"));
+const config_1 = require("../../src/config");
+exports.PROVIDERS = ['gemini', 'openai', 'anthropic', 'ollama'];
+const AI_SETTINGS = [
+    'aiProvider',
+    'aiModel',
+    'aiBaseUrl',
+    'geminiApiKey',
+    'openaiApiKey',
+    'anthropicApiKey',
+    'geminiModel',
+    'openaiModel',
+    'anthropicModel',
+    'ollamaModel',
+];
+exports.OLLAMA_URL = 'http://ollama.test:11434';
+function json(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        // The OpenAI and Anthropic SDKs retry a 429 after a pause unless told not to.
+        headers: { 'content-type': 'application/json', 'x-should-retry': 'false' },
+    });
+}
+function okBody(provider, text) {
+    switch (provider) {
+        case 'gemini':
+            return {
+                candidates: [
+                    { content: { role: 'model', parts: [{ text }] }, finishReason: 'STOP', index: 0 },
+                ],
+            };
+        case 'openai':
+            return {
+                id: 'chatcmpl-test',
+                object: 'chat.completion',
+                created: 0,
+                model: 'test',
+                choices: [
+                    { index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' },
+                ],
+            };
+        case 'anthropic':
+            return {
+                id: 'msg_test',
+                type: 'message',
+                role: 'assistant',
+                model: 'test',
+                content: [{ type: 'text', text }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 1, output_tokens: 1 },
+            };
+        default:
+            return { response: text };
+    }
+}
+function errorBody(provider, status, said) {
+    const message = said !== null && said !== void 0 ? said : (status === 429 ? 'Resource has been exhausted (e.g. check quota).' : `HTTP ${status}`);
+    switch (provider) {
+        case 'gemini':
+            return { error: { code: status, message, status: 'RESOURCE_EXHAUSTED' } };
+        case 'anthropic':
+            return { type: 'error', error: { type: 'rate_limit_error', message } };
+        default:
+            return { error: { message, type: 'requests', code: 'rate_limit_exceeded' } };
+    }
+}
+function aborted() {
+    const err = new Error('This operation was aborted');
+    err.name = 'AbortError';
+    return err;
+}
+/** Resolves never, and rejects as fetch does when the request's signal aborts. */
+function hangUntilAborted(signal) {
+    return new Promise((_, reject) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return reject(aborted());
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => reject(aborted()));
+    });
+}
+function useFakeAiProviders() {
+    let saved = {};
+    let savedMockEnv;
+    let provider = 'gemini';
+    let current = { status: 500 };
+    let ollamaUp = true;
+    const calls = [];
+    const sandbox = sinon_1.default.createSandbox();
+    beforeEach(() => {
+        saved = Object.fromEntries(AI_SETTINGS.map((k) => [k, config_1.config[k]]));
+        savedMockEnv = process.env.GEMINI_API_KEY;
+        // 'mock' would put the service in its built-in mock mode.
+        if (process.env.GEMINI_API_KEY === 'mock')
+            delete process.env.GEMINI_API_KEY;
+        for (const k of AI_SETTINGS)
+            config_1.config[k] = undefined;
+        config_1.config.aiProvider = 'gemini';
+        calls.length = 0;
+        current = { status: 500 };
+        ollamaUp = true;
+        sandbox.stub(globalThis, 'fetch').callsFake(((_url, init) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const signal = (_a = init === null || init === void 0 ? void 0 : init.signal) !== null && _a !== void 0 ? _a : undefined;
+            calls.push({ provider, body: String((_b = init === null || init === void 0 ? void 0 : init.body) !== null && _b !== void 0 ? _b : ''), signal });
+            if (current === 'hang')
+                return hangUntilAborted(signal);
+            if ('text' in current)
+                return json(200, okBody(provider, current.text));
+            return json(current.status, errorBody(provider, current.status, current.message));
+        })));
+        // Ollama: its health check answers, then the generate call as told.
+        sandbox.stub(axios_1.default, 'get').callsFake(((url) => __awaiter(this, void 0, void 0, function* () {
+            if (url.startsWith(exports.OLLAMA_URL)) {
+                if (ollamaUp)
+                    return { status: 200, data: { models: [] } };
+                throw Object.assign(new Error(`connect ECONNREFUSED ${exports.OLLAMA_URL}`), {
+                    code: 'ECONNREFUSED',
+                });
+            }
+            throw new Error(`no network in tests: GET ${url}`);
+        })));
+        sandbox.stub(axios_1.default, 'post').callsFake(((url, body, cfg) => __awaiter(this, void 0, void 0, function* () {
+            if (!url.startsWith(exports.OLLAMA_URL))
+                throw new Error(`no network in tests: POST ${url}`);
+            const signal = cfg === null || cfg === void 0 ? void 0 : cfg.signal;
+            calls.push({ provider: 'ollama', body: JSON.stringify(body), signal });
+            if (current === 'hang')
+                return hangUntilAborted(signal);
+            if ('text' in current)
+                return { status: 200, data: okBody('ollama', current.text) };
+            const err = new Error(`Request failed with status code ${current.status}`);
+            err.response = {
+                status: current.status,
+                data: errorBody('ollama', current.status, current.message),
+            };
+            throw err;
+        })));
+    });
+    afterEach(() => {
+        sandbox.restore();
+        for (const k of AI_SETTINGS)
+            config_1.config[k] = saved[k];
+        if (savedMockEnv === undefined)
+            delete process.env.GEMINI_API_KEY;
+        else
+            process.env.GEMINI_API_KEY = savedMockEnv;
+    });
+    return {
+        calls,
+        use(name, opts = {}) {
+            provider = name;
+            const model = `test-${name}-${Math.random().toString(36).slice(2)}`;
+            const key = opts.key === false ? undefined : 'test-key';
+            config_1.config.aiProvider = name;
+            if (name === 'gemini')
+                Object.assign(config_1.config, { geminiApiKey: key, geminiModel: model });
+            if (name === 'openai')
+                Object.assign(config_1.config, { openaiApiKey: key, openaiModel: model });
+            if (name === 'anthropic')
+                Object.assign(config_1.config, { anthropicApiKey: key, anthropicModel: model });
+            if (name === 'ollama')
+                Object.assign(config_1.config, { aiBaseUrl: exports.OLLAMA_URL, ollamaModel: model });
+            return { model };
+        },
+        answer(answer) {
+            current = answer;
+        },
+        ollamaUp(up) {
+            ollamaUp = up;
+        },
+    };
+}

package/lib/test/helpers/fake-device-table.js

@@ -1,7 +1,8 @@
 "use strict";
 /**
- * An in-memory device table to stub `prisma.device` with, so a spec runs the
- * real PrismaDeviceStore. It follows Prisma's rules: `undefined` leaves a
+ * In-memory tables to stub `prisma.device` (fakeDeviceTable) and
+ * `prisma.deviceSetting` (fakeDeviceSettingTable) with, so a spec runs the
+ * real PrismaDeviceStore. They follow Prisma's rules: `undefined` leaves a
  * column alone, `null` clears it, an upsert takes `create` for a new row and
  * `update` for a known one, and `{ contains }` matches a substring (the store
  * uses it for a host that isn't a URL).
@@ -16,31 +17,69 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeDeviceSettingTable = fakeDeviceSettingTable;
 exports.fakeDeviceTable = fakeDeviceTable;
-function fakeDeviceTable(seed) {
+const key = (udid, host) => `${udid}|${host}`;
+const matches = (row, where) => {
+    if (!where)
+        return true;
+    return Object.entries(where).every(([field, cond]) => {
+        var _a;
+        if (field === 'OR')
+            return cond.some((w) => matches(row, w));
+        if (field === 'AND')
+            return cond.every((w) => matches(row, w));
+        if (cond && typeof cond === 'object' && 'in' in cond)
+            return cond.in.includes(row[field]);
+        if (cond && typeof cond === 'object' && 'contains' in cond)
+            return String((_a = row[field]) !== null && _a !== void 0 ? _a : '').includes(cond.contains);
+        return row[field] === cond;
+    });
+};
+const write = (row, data) => {
+    for (const [field, value] of Object.entries(data))
+        if (value !== undefined)
+            row[field] = value;
+};
+/**
+ * The saved settings of phones (DeviceSetting), to stub `prisma.deviceSetting`
+ * with beside fakeDeviceTable, so the store's settings don't reach a database.
+ */
+function fakeDeviceSettingTable(seed = []) {
     const rows = new Map();
-    const key = (udid, host) => `${udid}|${host}`;
-    const matches = (row, where) => {
-        if (!where)
-            return true;
-        return Object.entries(where).every(([field, cond]) => {
-            var _a;
-            if (field === 'OR')
-                return cond.some((w) => matches(row, w));
-            if (field === 'AND')
-                return cond.every((w) => matches(row, w));
-            if (cond && typeof cond === 'object' && 'in' in cond)
-                return cond.in.includes(row[field]);
-            if (cond && typeof cond === 'object' && 'contains' in cond)
-                return String((_a = row[field]) !== null && _a !== void 0 ? _a : '').includes(cond.contains);
-            return row[field] === cond;
-        });
-    };
-    const write = (row, data) => {
-        for (const [field, value] of Object.entries(data))
-            if (value !== undefined)
-                row[field] = value;
+    for (const r of seed)
+        rows.set(key(r.udid, r.host), Object.assign({ userBlocked: false }, r));
+    return {
+        row: (udid, host) => [...rows.values()].find((r) => r.udid === udid && (host === undefined || r.host === host)),
+        delegate: {
+            findMany: (...args_1) => __awaiter(this, [...args_1], void 0, function* (args = {}) { return [...rows.values()].filter((r) => matches(r, args.where)).map((r) => (Object.assign({}, r))); }),
+            upsert: (_a) => __awaiter(this, [_a], void 0, function* ({ where, create, update, }) {
+                const k = key(where.udid_host.udid, where.udid_host.host);
+                const found = rows.get(k);
+                if (found) {
+                    write(found, update);
+                    return Object.assign({}, found);
+                }
+                const created = { userBlocked: false };
+                write(created, create);
+                rows.set(k, created);
+                return Object.assign({}, created);
+            }),
+            deleteMany: (...args_1) => __awaiter(this, [...args_1], void 0, function* (args = {}) {
+                let count = 0;
+                for (const [k, r] of rows) {
+                    if (matches(r, args.where)) {
+                        rows.delete(k);
+                        count++;
+                    }
+                }
+                return { count };
+            }),
+        },
     };
+}
+function fakeDeviceTable(seed) {
+    const rows = new Map();
     const defaults = () => ({
         busy: false,
         userBlocked: false,