@tenonhq/dovetail-core 0.0.85

package/dist/recentEdits.js

@@ -0,0 +1,66 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeRecentEdit = writeRecentEdit;
+const fs = __importStar(require("fs"));
+const projectFiles_1 = require("./projectFiles");
+const MAX_ENTRIES = 5;
+function getFilePath() {
+    return (0, projectFiles_1.getRecentEditsPath)();
+}
+function writeRecentEdit(context) {
+    var filePath = getFilePath();
+    var edits = [];
+    try {
+        if (fs.existsSync(filePath)) {
+            edits = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+    }
+    catch (e) {
+        edits = [];
+    }
+    edits.unshift({
+        tableName: context.tableName,
+        name: context.name,
+        targetField: context.targetField,
+        sys_id: context.sys_id,
+        scope: context.scope,
+        timestamp: new Date().toISOString(),
+    });
+    if (edits.length > MAX_ENTRIES) {
+        edits = edits.slice(0, MAX_ENTRIES);
+    }
+    fs.writeFileSync(filePath, JSON.stringify(edits, null, 2));
+}

package/dist/schemaCommand.js

@@ -0,0 +1,85 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaPullCommand = schemaPullCommand;
+const dovetail_schema_1 = require("@tenonhq/dovetail-schema");
+const Logger_1 = require("./Logger");
+const ConfigManager = __importStar(require("./config"));
+const path_1 = __importDefault(require("path"));
+async function schemaPullCommand(args) {
+    const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+    if (!SN_USER || !SN_PASSWORD || !SN_INSTANCE) {
+        throw new Error("Missing ServiceNow credentials. Ensure SN_INSTANCE, SN_USER, and SN_PASSWORD are set in your .env file or environment.");
+    }
+    const config = ConfigManager.getConfig();
+    const configScopes = config.scopes ? Object.keys(config.scopes) : [];
+    if (configScopes.length === 0) {
+        throw new Error("No scopes configured in dove.config.js. Add scopes to the 'scopes' object in your configuration.");
+    }
+    // If --scope flag is provided, filter to that single scope
+    let scopes = configScopes;
+    if (args.scope) {
+        if (!configScopes.includes(args.scope)) {
+            throw new Error(`Scope "${args.scope}" is not configured in dove.config.js. Available scopes: ${configScopes.join(", ")}`);
+        }
+        scopes = [args.scope];
+    }
+    const rootDir = ConfigManager.getRootDir();
+    const outputDir = args.output
+        ? path_1.default.resolve(args.output)
+        : path_1.default.join(rootDir, "schema");
+    try {
+        const index = await (0, dovetail_schema_1.pullSchema)({
+            instance: SN_INSTANCE,
+            username: SN_USER,
+            password: SN_PASSWORD,
+            outputDir,
+            scopes,
+        });
+        Logger_1.logger.success(`Schema pull complete! ${index.total_tables} tables across ${index.applications.length} applications written to ${outputDir}`);
+    }
+    catch (e) {
+        let message;
+        if (e instanceof Error)
+            message = e.message;
+        else
+            message = String(e);
+        Logger_1.logger.error("Schema pull failed: " + message);
+        throw e;
+    }
+}

package/dist/snClient.js

@@ -0,0 +1,519 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapSNResponse = exports.defaultClient = exports.snClient = exports.processPushResponse = exports.retryOnHttpErr = exports.retryOnErr = void 0;
+exports.setBenchmarkSink = setBenchmarkSink;
+exports._resetDovetailApiFallback = _resetDovetailApiFallback;
+exports._isUsingLegacyClaudePath = _isUsingLegacyClaudePath;
+exports._callDovetailApi = _callDovetailApi;
+exports.unwrapTableAPIFirstItem = unwrapTableAPIFirstItem;
+const axios_1 = __importDefault(require("axios"));
+const axios_cookiejar_support_1 = require("axios-cookiejar-support");
+const axios_rate_limit_1 = __importDefault(require("axios-rate-limit"));
+const tough_cookie_1 = require("tough-cookie");
+const genericUtils_1 = require("./genericUtils");
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+// Benchmark sink. Null when --benchmark is off; zero overhead in that case.
+let _benchmarkSink = null;
+function setBenchmarkSink(sink) {
+    _benchmarkSink = sink;
+}
+// Local helper to strip _ directive keys before sending to ServiceNow API.
+// Defined here (not imported from config.ts) to avoid circular dependencies.
+function _stripUnderscoreKeys(obj) {
+    var result = {};
+    var keys = Object.keys(obj || {});
+    for (var i = 0; i < keys.length; i++) {
+        if (keys[i].charAt(0) !== "_") {
+            result[keys[i]] = obj[keys[i]];
+        }
+    }
+    return result;
+}
+const retryOnErr = async (f, allowedRetries, msBetween = 0, onRetry) => {
+    try {
+        return await f();
+    }
+    catch (e) {
+        const newRetries = allowedRetries - 1;
+        if (newRetries <= 0) {
+            throw e;
+        }
+        if (onRetry) {
+            onRetry(newRetries);
+        }
+        await (0, genericUtils_1.wait)(msBetween);
+        return (0, exports.retryOnErr)(f, newRetries, msBetween, onRetry);
+    }
+};
+exports.retryOnErr = retryOnErr;
+function _getHttpStatus(e) {
+    if (axios_1.default.isAxiosError(e) && e.response) {
+        return e.response.status;
+    }
+    return undefined;
+}
+// Dovetail server-side Scripted REST API was renamed from "Claude" (path
+// /api/cadso/claude/*) to "Dovetail" (path /api/cadso/dovetail/*). On instances
+// where the rename hasn't been imported yet, the new path returns 404. We try
+// the dovetail path first; if it 404s we fall back to the legacy claude path
+// for the rest of the session, with a one-time deprecation warning.
+let _dovetailApiUseLegacyClaudePath = false;
+function _dovetailEndpoint(op) {
+    return _dovetailApiUseLegacyClaudePath
+        ? "api/cadso/claude/" + op
+        : "api/cadso/dovetail/" + op;
+}
+// Exported for tests only: reset the latched fallback state between test cases.
+function _resetDovetailApiFallback() {
+    _dovetailApiUseLegacyClaudePath = false;
+}
+// Exported for tests only: inspect the latched fallback state.
+function _isUsingLegacyClaudePath() {
+    return _dovetailApiUseLegacyClaudePath;
+}
+async function _callDovetailApi(op, call) {
+    try {
+        return await call(_dovetailEndpoint(op));
+    }
+    catch (e) {
+        if (!_dovetailApiUseLegacyClaudePath && _getHttpStatus(e) === 404) {
+            Logger_1.logger.warn("[deprecation] /api/cadso/dovetail/" + op +
+                " returned 404. Falling back to legacy /api/cadso/claude/" + op +
+                ". Re-import the Dovetail Scripted REST API XML on your ServiceNow instance to silence this warning.");
+            _dovetailApiUseLegacyClaudePath = true;
+            return await call(_dovetailEndpoint(op));
+        }
+        throw e;
+    }
+}
+function _getRetryAfterMs(e) {
+    if (axios_1.default.isAxiosError(e) && e.response && e.response.headers) {
+        var retryAfter = e.response.headers["retry-after"];
+        if (retryAfter) {
+            var seconds = Number(retryAfter);
+            if (!isNaN(seconds) && seconds > 0) {
+                return seconds * 1000;
+            }
+        }
+    }
+    return 10000; // Default 10s for 429 without Retry-After
+}
+const retryOnHttpErr = async (f, recSummary) => {
+    var maxServerRetries = 3;
+    var backoffMs = 1000;
+    var attempt = 0;
+    while (true) {
+        try {
+            return await f();
+        }
+        catch (e) {
+            var status = _getHttpStatus(e);
+            attempt++;
+            // 401/403: Auth failure — fail immediately
+            if (status === 401 || status === 403) {
+                var authMsg = status === 401 ? "Unauthorized" : "Forbidden";
+                Logger_1.logger.error(authMsg + " (" + status + ") pushing " + recSummary +
+                    ". Verify your ServiceNow credentials and permissions.");
+                throw e;
+            }
+            // 404: Record not found — fail immediately
+            if (status === 404) {
+                Logger_1.logger.error("Record not found (404) pushing " + recSummary +
+                    ". The record may have been deleted from the instance.");
+                throw e;
+            }
+            // 429: Rate limited — honor Retry-After, then retry
+            if (status === 429) {
+                var retryWait = _getRetryAfterMs(e);
+                Logger_1.logger.warn("Rate limited (429) pushing " + recSummary +
+                    ". Waiting " + Math.round(retryWait / 1000) + "s before retry.");
+                await (0, genericUtils_1.wait)(retryWait);
+                continue;
+            }
+            // 500/502/503: Server error — exponential backoff, max 3 retries
+            if (status === 500 || status === 502 || status === 503) {
+                if (attempt > maxServerRetries) {
+                    Logger_1.logger.error("Server error (" + status + ") pushing " + recSummary +
+                        " after " + maxServerRetries + " retries. Giving up.");
+                    throw e;
+                }
+                var cappedBackoff = Math.min(backoffMs, 8000);
+                Logger_1.logger.warn("Server error (" + status + ") pushing " + recSummary +
+                    ". Retrying in " + (cappedBackoff / 1000) + "s (" +
+                    (maxServerRetries - attempt) + " retries left).");
+                await (0, genericUtils_1.wait)(cappedBackoff);
+                backoffMs = backoffMs * 2;
+                continue;
+            }
+            // Unknown status or non-HTTP error — retry once, then fail
+            if (attempt > 1) {
+                var errDetail = status ? "HTTP " + status : "unknown error";
+                Logger_1.logger.error("Push failed for " + recSummary + " (" + errDetail +
+                    ") after 1 retry. Giving up.");
+                throw e;
+            }
+            var retryDetail = status ? "HTTP " + status : "unknown error";
+            Logger_1.logger.warn("Unexpected error (" + retryDetail + ") pushing " + recSummary +
+                ". Retrying once.");
+            await (0, genericUtils_1.wait)(1000);
+        }
+    }
+};
+exports.retryOnHttpErr = retryOnHttpErr;
+const processPushResponse = (response, recSummary) => {
+    const { status } = response;
+    if (status === 404) {
+        return {
+            success: false,
+            message: `Could not find ${recSummary} on the server.`,
+        };
+    }
+    if (status < 200 || status > 299) {
+        return {
+            success: false,
+            message: `Failed to push ${recSummary}. Recieved an unexpected response (${status})`,
+        };
+    }
+    return {
+        success: true,
+        message: `${recSummary} pushed successfully!`,
+    };
+};
+exports.processPushResponse = processPushResponse;
+const snClient = (baseURL, username, password) => {
+    const jar = new tough_cookie_1.CookieJar();
+    const rawAxios = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
+        withCredentials: true,
+        auth: {
+            username,
+            password,
+        },
+        headers: {
+            "Content-Type": "application/json",
+        },
+        baseURL,
+        jar,
+    }));
+    // Request interceptor: stamp startedAt so the response interceptor can
+    // compute durationMs. Only when a benchmark sink is attached — when it
+    // isn't, this is a single property assignment and does not change shape.
+    rawAxios.interceptors.request.use(function (cfg) {
+        if (_benchmarkSink) {
+            cfg._benchStartedAt = Date.now();
+        }
+        return cfg;
+    });
+    rawAxios.interceptors.response.use(function (response) {
+        if (!_benchmarkSink)
+            return response;
+        var startedAt = response.config && response.config._benchStartedAt;
+        if (!startedAt)
+            return response;
+        var url = (response.config && response.config.url) || "";
+        var payload = response.data;
+        var responseBytes = 0;
+        try {
+            responseBytes = payload ? JSON.stringify(payload).length : 0;
+        }
+        catch (e) {
+            responseBytes = 0;
+        }
+        var tableCount = 0;
+        var result = payload && payload.result;
+        if (result && typeof result === "object") {
+            if (url.indexOf("bulkDownload") !== -1) {
+                tableCount = Object.keys(result).length;
+            }
+            else if (url.indexOf("getManifest") !== -1 && result.tables) {
+                tableCount = Object.keys(result.tables).length;
+            }
+        }
+        _benchmarkSink.recordHttp({
+            path: url,
+            tableCount: tableCount,
+            durationMs: Date.now() - startedAt,
+            statusCode: response.status,
+            responseBytes: responseBytes,
+        });
+        return response;
+    }, function (error) {
+        // Preserve original rejection; don't record errored requests (they skew
+        // latency tails without adding signal for the "scales the same" question).
+        return Promise.reject(error);
+    });
+    const client = (0, axios_rate_limit_1.default)(rawAxios, { maxRPS: 20 });
+    const getAppList = () => {
+        const endpoint = "api/sinc/sincronia/getAppList";
+        return client.get(endpoint);
+    };
+    const updateATFfile = (contents, sysId) => {
+        const endpoint = "api/sinc/sincronia/pushATFfile";
+        try {
+            return client.post(endpoint, { file: contents, sys_id: sysId });
+        }
+        catch (e) {
+            throw e;
+        }
+    };
+    const updateRecord = (table, recordId, fields) => {
+        if (table === "sys_atf_step") {
+            updateATFfile(fields["inputs.script"], recordId);
+        }
+        const endpoint = `api/now/table/${table}/${recordId}`;
+        return client.patch(endpoint, fields);
+    };
+    const getScopeId = (scopeName) => {
+        const endpoint = "api/now/table/sys_scope";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `scope=${scopeName}`,
+                sysparm_fields: "sys_id",
+            },
+        });
+    };
+    const getUserSysId = (userName = process.env.SN_USER) => {
+        const endpoint = "api/now/table/sys_user";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `user_name=${userName}`,
+                sysparm_fields: "sys_id",
+            },
+        });
+    };
+    const getCurrentAppUserPrefSysId = (userSysId) => {
+        const endpoint = `api/now/table/sys_user_preference`;
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `user=${userSysId}^name=apps.current_app`,
+                sysparm_fields: "sys_id",
+            },
+        });
+    };
+    const updateCurrentAppUserPref = (appSysId, userPrefSysId) => {
+        const endpoint = `api/now/table/sys_user_preference/${userPrefSysId}`;
+        return client.put(endpoint, { value: appSysId });
+    };
+    const createCurrentAppUserPref = (appSysId, userSysId) => {
+        const endpoint = `api/now/table/sys_user_preference`;
+        return client.post(endpoint, {
+            value: appSysId,
+            name: "apps.current_app",
+            type: "string",
+            user: userSysId,
+        });
+    };
+    const getCurrentScope = () => {
+        const endpoint = "api/sinc/sincronia/getCurrentScope";
+        return client.get(endpoint);
+    };
+    const createUpdateSet = (updateSetName, scopeSysId, description) => {
+        const endpoint = `api/now/table/sys_update_set`;
+        const data = {
+            name: updateSetName,
+            state: "in progress",
+        };
+        if (scopeSysId) {
+            data.application = scopeSysId;
+        }
+        if (description) {
+            data.description = description;
+        }
+        return client.post(endpoint, data);
+    };
+    const getCurrentUpdateSetUserPref = (userSysId) => {
+        const endpoint = `api/now/table/sys_user_preference`;
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `user=${userSysId}^name=sys_update_set`,
+                sysparm_fields: "sys_id",
+            },
+        });
+    };
+    const updateCurrentUpdateSetUserPref = (updateSetSysId, userPrefSysId) => {
+        const endpoint = `api/now/table/sys_user_preference/${userPrefSysId}`;
+        return client.put(endpoint, { value: updateSetSysId });
+    };
+    const createCurrentUpdateSetUserPref = (updateSetSysId, userSysId) => {
+        const endpoint = `api/now/table/sys_user_preference`;
+        return client.put(endpoint, {
+            value: updateSetSysId,
+            name: "sys_update_set",
+            type: "string",
+            user: userSysId,
+        });
+    };
+    const getMissingFiles = (missingFiles, tableOptions) => {
+        const endpoint = `api/sinc/sincronia/bulkDownload`;
+        const tableCount = Object.keys(missingFiles).length;
+        FileLogger_1.fileLogger.debug("Bulk downloading files for " + tableCount + " tables");
+        return client.post(endpoint, { missingFiles, tableOptions });
+    };
+    const getManifest = (scope, config, withFiles = false) => {
+        const endpoint = `api/sinc/sincronia/getManifest/${scope}`;
+        const { includes = {}, excludes = {}, tableOptions = {}, scopes = {}, } = config;
+        // Strip _ directive keys before sending to ServiceNow API
+        var cleanIncludes = _stripUnderscoreKeys(includes);
+        var cleanExcludes = _stripUnderscoreKeys(excludes);
+        FileLogger_1.fileLogger.debug("Fetching manifest for scope " + scope + (withFiles ? " (with file contents)" : " (structure only)"));
+        return client.post(endpoint, {
+            includes: cleanIncludes,
+            excludes: cleanExcludes,
+            tableOptions,
+            withFiles,
+            getContents: withFiles, // ServiceNow expects getContents, not withFiles
+        });
+    };
+    const changeUpdateSet = (params) => {
+        return _callDovetailApi("changeUpdateSet", (endpoint) => client.get(endpoint, { params }));
+    };
+    const getCurrentUpdateSet = (scope) => {
+        const params = {};
+        if (scope) {
+            params.scope = scope;
+        }
+        return _callDovetailApi("currentUpdateSet", (endpoint) => client.get(endpoint, { params }));
+    };
+    const changeScope = (scope) => {
+        return _callDovetailApi("changeScope", (endpoint) => client.get(endpoint, { params: { scope } }));
+    };
+    const pushWithUpdateSet = (updateSetSysId, table, recordSysId, fields) => {
+        return _callDovetailApi("pushWithUpdateSet", (endpoint) => client.post(endpoint, {
+            update_set_sys_id: updateSetSysId,
+            table,
+            record_sys_id: recordSysId,
+            fields,
+        }));
+    };
+    const createRecord = (params) => {
+        return _callDovetailApi("createRecord", (endpoint) => client.post(endpoint, params));
+    };
+    const deleteRecord = (params) => {
+        return _callDovetailApi("deleteRecord", (endpoint) => client.post(endpoint, params));
+    };
+    return {
+        getAppList,
+        updateRecord,
+        getScopeId,
+        getUserSysId,
+        getCurrentAppUserPrefSysId,
+        updateCurrentAppUserPref,
+        createCurrentAppUserPref,
+        getCurrentScope,
+        createUpdateSet,
+        getCurrentUpdateSetUserPref,
+        updateCurrentUpdateSetUserPref,
+        createCurrentUpdateSetUserPref,
+        getMissingFiles,
+        getManifest,
+        changeUpdateSet,
+        getCurrentUpdateSet,
+        changeScope,
+        pushWithUpdateSet,
+        createRecord,
+        deleteRecord,
+        client, // Expose the axios client for custom queries
+    };
+};
+exports.snClient = snClient;
+let internalClient = undefined;
+const defaultClient = () => {
+    if (internalClient) {
+        return internalClient;
+    }
+    const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+    internalClient = (0, exports.snClient)(`https://${SN_INSTANCE}/`, SN_USER, SN_PASSWORD);
+    return internalClient;
+};
+exports.defaultClient = defaultClient;
+const unwrapSNResponse = async (clientPromise) => {
+    try {
+        const resp = await clientPromise;
+        // Log response summary for key endpoints
+        if (resp.config && resp.config.url) {
+            const url = resp.config.url;
+            const result = resp.data.result;
+            if (url.includes("getManifest") && result && result.tables) {
+                const tableCount = Object.keys(result.tables).length;
+                FileLogger_1.fileLogger.debug("Manifest received: " + tableCount + " tables (status " + resp.status + ")");
+            }
+            else if (url.includes("bulkDownload") && result) {
+                const tableCount = Object.keys(result).length;
+                FileLogger_1.fileLogger.debug("Bulk download received: " + tableCount + " tables (status " + resp.status + ")");
+            }
+        }
+        return resp.data.result;
+    }
+    catch (e) {
+        const instance = process.env.SN_INSTANCE || "unknown";
+        if (axios_1.default.isAxiosError(e) && e.response) {
+            const status = e.response.status;
+            const statusText = e.response.statusText || "";
+            const method = ((e.config && e.config.method) || "").toUpperCase();
+            const url = (e.config && e.config.url) || "";
+            const data = e.response.data;
+            // Extract ServiceNow-shaped error message if present (`{error: {message, detail}, status}`)
+            let snMessage = "";
+            if (data && typeof data === "object") {
+                if (data.error && typeof data.error === "object" && data.error.message) {
+                    snMessage = " — " + String(data.error.message);
+                }
+                else if (typeof data.message === "string") {
+                    snMessage = " — " + data.message;
+                }
+            }
+            // Pull scope out of /getManifest/:scope URLs for easy grepping
+            let scope;
+            const manifestMatch = url.match(/\/getManifest\/([^/?]+)/);
+            if (manifestMatch)
+                scope = manifestMatch[1];
+            Logger_1.logger.error("Error from " + instance + ": HTTP " + status + " " +
+                method + " " + url + snMessage);
+            FileLogger_1.fileLogger.debug("REST error detail", {
+                instance: instance,
+                scope: scope,
+                method: method,
+                url: url,
+                status: status,
+                statusText: statusText,
+                responseData: data,
+                responseHeaders: e.response.headers,
+            });
+        }
+        else {
+            // Non-Axios error: preserve today's behaviour, add debug detail
+            let message;
+            if (e instanceof Error)
+                message = e.message;
+            else
+                message = String(e);
+            Logger_1.logger.error("Error from " + instance + ": " + message);
+            FileLogger_1.fileLogger.debug("Non-Axios error detail", {
+                instance: instance,
+                errorName: e instanceof Error ? e.name : undefined,
+                errorStack: e instanceof Error ? e.stack : undefined,
+                message: message,
+            });
+        }
+        throw e;
+    }
+};
+exports.unwrapSNResponse = unwrapSNResponse;
+async function unwrapTableAPIFirstItem(clientPromise, extractField) {
+    try {
+        const resp = await (0, exports.unwrapSNResponse)(clientPromise);
+        if (resp.length === 0) {
+            throw new Error("Response was not a populated array!");
+        }
+        if (!extractField) {
+            return resp[0];
+        }
+        return resp[0][extractField];
+    }
+    catch (e) {
+        throw e;
+    }
+}