@gyldendalas/gyldendal-divine-api 1.1.8 → 1.2.0

package/README.md

@@ -42,4 +42,98 @@ is issued for that name.
 | polly | `http://127.0.0.1:3200` | `systime-appear-polly` docker-compose-development; its container port 3000 is taken by nuxt dev. Synthesis needs AWS credentials, and the container's CORS preflight currently rejects the `Authorization` header this SDK sends |
 | quiz (Gale CMS) | `https://galecms.test.tibalo.dk/api` | no local Gale, shared test instance |
 
-Run a service on a different port by passing `serviceUrl` to its constructor.
+Gale also has a QA installation, which is not an environment of its own —
+`quiz` is the only service that has one. It is exported as `GALE_QA_URL` and
+applied as an override, so the URL stays in this package:
+
+```ts
+import { GALE_QA_URL } from '@gyldendalas/gyldendal-divine-api';
+
+environmentOverrides: { quiz: GALE_QA_URL }
+```
+
+TYPO3 asks for it per site through `site.sso.sso_overrides.galeQaEndpointEnabled`.
+It is a testing arrangement, so the caller decides whether to honour it: a
+constructor override is applied in production too, unlike the ambient ones
+below.
+
+### Running a mix of local and hosted services
+
+`environment` picks one environment for everything, which is rarely what
+local development wants: usually one service runs on your machine and the
+rest should come from staging. `environmentOverrides` says which environment
+an individual service resolves in, keyed by the service names in
+`src/services/service_urls.ts`:
+
+```ts
+const divine = {
+  environment,          // the installationpurpose, as always
+  myAccountId,
+  environmentOverrides: { highlight: 'local' }
+};
+
+new HighlightService(divine);   // http://127.0.0.1:4120
+new TaggingService(divine);     // https://staging-tagging.services.systime.dk
+```
+
+Build that object once where the application starts and hand the same one to
+every service, so the mix lives in a single place.
+
+Note that it names an *environment*, not a URL. The override keeps reading
+the table, so a service that moves — including the local port of the very
+service you overrode — still moves for you on the next version of this
+package. That is the whole point of keeping the URLs in here, and a caller
+who writes a URL down has stepped out of it.
+
+For the endpoints the table cannot know about — a service on a non-standard
+port, a tunnel, a colleague's branch deploy — an override may be a URL
+instead:
+
+```ts
+environmentOverrides: { highlight: 'http://127.0.0.1:9999' }
+```
+
+`serviceUrl` still works and still beats everything else. It is the right
+tool for a service this package does not know at all, and the wrong one for
+local development, where it silently opts you out of every future change to
+that service's address.
+
+### Overrides without touching the application
+
+An override can also come from the machine rather than from the code, which
+keeps it out of the repository entirely. Per service, either:
+
+- the environment variable `DIVINE_ENV_<SERVICE>` — `DIVINE_ENV_HIGHLIGHT`,
+  `DIVINE_ENV_PDF_GENERATOR`, and so on;
+- `globalThis.__divineEnvironmentOverrides`, set by a dev-only Nuxt plugin or
+  an injected script, which is the only one of the two that reaches the
+  browser bundle.
+
+Both take the same values as `environmentOverrides`. An `environmentOverrides`
+entry in the code beats them, the environment variable beats `globalThis`,
+and neither is read at all when `environment` is `production`: configuration
+that arrives out of band is a hazard there whatever it happens to say.
+
+### Every override is reported
+
+An applied override — from any of the four mechanisms, `serviceUrl`
+included — writes a line like this the first time it resolves:
+
+```
+[gyldendal-divine-api] highlight is overridden: resolved to http://127.0.0.1:4120 instead of its "development" endpoint (source: environmentOverrides).
+```
+
+The failure mode all of this has is a forgotten override: an entry that
+reached a release, or a variable exported three weeks ago and since
+forgotten. So the notice is not silenced in production, where it matters
+most, and it names the source, because "highlight is on 127.0.0.1" is a
+puzzle on its own and stops being one as soon as it says which knob did it.
+
+It is written once per process per distinct override, not once per request,
+since a warning on every call is a warning nobody reads. Pass `onOverride` to
+send it somewhere other than `console.warn`, which this package writes to
+nowhere else:
+
+```ts
+new HighlightService({ ...divine, onOverride: ({ message }) => logger.warn(message) });
+```

package/dist/index.cjs

@@ -45,6 +45,206 @@ function extractJWTPayload(token) {
 	return payload;
 }
 //#endregion
+//#region src/services/service_urls.ts
+/**
+* The `installationpurpose` values a caller may pass as `environment`, which
+* is more values than there are places to point them at.
+*/
+const ENVIRONMENTS = [
+	"production",
+	"development",
+	"testing",
+	"local",
+	"test"
+];
+function isServiceEnvironment(value) {
+	return ENVIRONMENTS.includes(value);
+}
+const TARGETS = {
+	production: "production",
+	development: "staging",
+	testing: "staging",
+	local: "local",
+	test: "mock"
+};
+/**
+* The hosted hostnames are written out rather than derived from the service
+* name: `solr-proxy-staging.eu-west-1`, `ai-bot-service-staging.eu-west-1`
+* and the whole of `quiz` already break whatever pattern one would derive,
+* and a wrong host is worth more than the repetition costs.
+*
+* The local ports are the reserved 4110-4180 block documented in the README.
+*/
+const SERVICE_URLS = {
+	userSettings: {
+		production: (d) => `https://user-settings-service.services.${d}`,
+		staging: (d) => `https://staging-user-settings-service.services.${d}`,
+		local: () => "http://127.0.0.1:4110",
+		mock: () => "https://localhost:3010/services/usersettingsservice"
+	},
+	highlight: {
+		production: (d) => `https://highlights.services.${d}`,
+		staging: (d) => `https://staging-highlights.services.${d}`,
+		local: () => "http://127.0.0.1:4120",
+		mock: () => "https://localhost:3010/services/highlight"
+	},
+	pdfGenerator: {
+		production: (d) => `https://pdfgenerator.services.${d}`,
+		staging: (d) => `https://staging-pdfgenerator.services.${d}`,
+		local: () => "http://127.0.0.1:4130",
+		mock: () => "https://localhost:3010/services/pdfgenerator"
+	},
+	writingTask: {
+		production: (d) => `https://writingtask.services.${d}`,
+		staging: (d) => `https://staging-writingtask.services.${d}`,
+		local: () => "http://127.0.0.1:4140",
+		mock: () => "https://localhost:3010/services/writingtask"
+	},
+	solrProxy: {
+		production: (d) => `https://solr-proxy.eu-west-1.${d}`,
+		staging: (d) => `https://solr-proxy-staging.eu-west-1.${d}`,
+		local: () => "http://127.0.0.1:4150",
+		mock: () => "https://localhost:3010/services/solrproxy"
+	},
+	tagging: {
+		production: (d) => `https://tagging.services.${d}`,
+		staging: (d) => `https://staging-tagging.services.${d}`,
+		local: () => "http://127.0.0.1:4160",
+		mock: () => "https://localhost:3010/services/tagging"
+	},
+	aiBot: {
+		production: (d) => `https://ai-bot-service.eu-west-1.${d}`,
+		staging: (d) => `https://ai-bot-service-staging.eu-west-1.${d}`,
+		local: () => "http://127.0.0.1:4170",
+		mock: () => "https://localhost:3010/services/aibotservice"
+	},
+	cookieConsentLog: {
+		production: (d) => `https://cookieconsentlog.services.${d}`,
+		staging: (d) => `https://staging-cookieconsentlog.services.${d}`,
+		local: () => "http://127.0.0.1:4180",
+		mock: () => "https://localhost:3010/services/cookieconsentlog"
+	},
+	polly: {
+		production: (d) => `https://appear-polly.services.${d}`,
+		staging: (d) => `https://staging-appear-polly.services.${d}`,
+		local: () => "http://127.0.0.1:3200",
+		mock: () => "https://localhost:3010/services/polly"
+	},
+	quiz: {
+		production: () => "https://api.iquiz.dk/api",
+		staging: () => "https://galecms.test.tibalo.dk/api",
+		local: () => "https://galecms.test.tibalo.dk/api",
+		mock: () => "https://localhost:3010/galeapi/api"
+	}
+};
+/**
+* Gale CMS's QA installation, which is not a target of its own: `quiz` is the
+* only service with a QA endpoint, and a fifth `Target` would oblige the other
+* nine to name one they do not have.
+*
+* It is reached by overriding `quiz` with it, so the URL stays in this file
+* and a caller who turns it on keeps tracking this package:
+*
+* ```ts
+* environmentOverrides: { quiz: GALE_QA_URL }
+* ```
+*
+* TYPO3 asks for it through `site.sso.sso_overrides.galeQaEndpointEnabled`,
+* which is a testing arrangement: honour it outside production only.
+*/
+const GALE_QA_URL = "https://galecms.qa.tibalo.dk/api";
+/** Where `service` answers in `environment`. */
+function resolveServiceUrl(service, environment, baseDomain) {
+	if (!isServiceEnvironment(environment)) throw new Error(`Unknown environment: ${environment}`);
+	return SERVICE_URLS[service][TARGETS[environment]](baseDomain);
+}
+//#endregion
+//#region src/services/service_overrides.ts
+/**
+* Pointing one service somewhere else than the rest.
+*
+* A caller developing locally usually wants most services from staging and
+* one from their own machine. The override says which *environment* that one
+* service resolves in, not which URL it answers on, so the caller keeps
+* tracking `service_urls.ts` for every service they did not name — and for
+* the named one too, whenever its local port moves.
+*
+* A URL is still accepted for the cases the table cannot know about (a
+* service on a non-standard port, a tunnel, a colleague's branch deploy).
+*
+* Every override is reported, because the failure mode of all of this is a
+* forgotten one: an `environmentOverrides` entry that reached a release, or
+* an environment variable exported three weeks ago.
+*/
+/**
+* Set by a dev-only Nuxt plugin or an injected script, and the only way to
+* reach the browser bundle, where there is no `process.env`.
+*/
+const GLOBAL_OVERRIDES_KEY = "__divineEnvironmentOverrides";
+/** `pdfGenerator` is configured as `DIVINE_ENV_PDF_GENERATOR`. */
+function overrideEnvVarName(service) {
+	return `DIVINE_ENV_${service.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase()}`;
+}
+/**
+* An override the developer's machine carries rather than the application's
+* code. `process.env` is read through a computed key so a bundler treats it
+* as a lookup rather than inlining a build-time value, and both accesses are
+* guarded because neither global exists everywhere this package runs.
+*
+* The environment variable wins: it is set per run of the application, so it
+* is the more deliberate of the two.
+*/
+function ambientOverride(service) {
+	const fromEnv = typeof process !== "undefined" && process.env ? process.env[overrideEnvVarName(service)] : void 0;
+	if (fromEnv) return {
+		value: fromEnv,
+		source: "env"
+	};
+	const fromGlobal = globalThis[GLOBAL_OVERRIDES_KEY]?.[service];
+	if (fromGlobal) return {
+		value: fromGlobal,
+		source: "globalThis"
+	};
+}
+/** An override that is not an environment name has to be a URL we can call. */
+function overrideToUrl(value, service, source) {
+	if (/^https?:\/\//.test(value)) return value;
+	throw new Error(`Invalid ${source} override for ${service}: "${value}" is neither an environment (${ENVIRONMENTS.join(", ")}) nor an http(s) URL.`);
+}
+/**
+* Already-reported overrides, so a warning survives being read.
+* `getUrlPrefix()` runs on every request, and an override that warns on every
+* one of them is an override nobody reads.
+*
+* This is process-wide mutable state, which is exactly what a per-request
+* `environment` must never be kept in — but it only ever suppresses output,
+* and "once per process" is the cadence a server operator wants anyway.
+*/
+const reported = /* @__PURE__ */ new Set();
+/** Test seam: forget what has already been reported. */
+function resetOverrideReports() {
+	reported.clear();
+}
+const defaultReporter = (details) => console.warn(details.message);
+/**
+* Report an override the first time it resolves. Deliberately not silenced in
+* production: an `environmentOverrides` entry that reached a release is the
+* single thing this is here to catch.
+*/
+function reportOverride({ service, environment, resolved, source }, onOverride) {
+	const key = `${source}:${service}:${resolved}`;
+	if (reported.has(key)) return;
+	reported.add(key);
+	const message = `[gyldendal-divine-api] ${service} is overridden: resolved to ${resolved} instead of its "${environment}" endpoint (source: ${source}).`;
+	(onOverride ?? defaultReporter)({
+		service,
+		environment,
+		resolved,
+		source,
+		message
+	});
+}
+//#endregion
 //#region src/services/base_service.ts
 var HTTPError = class extends Error {
 	response;
@@ -61,19 +261,69 @@ var BaseService = class {
 	environment;
 	myAccountId;
 	baseDomain;
-	constructor({ bearerToken = void 0, apiKey = void 0, serviceUrl = void 0, environment = "production", myAccountId = "SYSTIMEMYACCOUNT", baseDomain = "systime.dk" }) {
+	environmentOverrides;
+	onOverride;
+	/**
+	* This service's entry in `SERVICE_URLS`, declared by every service in this
+	* package. A subclass of our own that declares none resolves nothing from
+	* the table and has to be given a `serviceUrl`.
+	*/
+	serviceName;
+	constructor({ bearerToken = void 0, apiKey = void 0, serviceUrl = void 0, environment = "production", myAccountId = "SYSTIMEMYACCOUNT", baseDomain = "systime.dk", environmentOverrides = void 0, onOverride = void 0 }) {
 		this.bearerToken = bearerToken;
 		this.apiKey = apiKey;
 		this.serviceUrl = serviceUrl;
 		this.environment = environment.toLowerCase();
 		this.myAccountId = myAccountId;
 		this.baseDomain = baseDomain;
+		this.environmentOverrides = environmentOverrides;
+		this.onOverride = onOverride;
+	}
+	/**
+	* The override that applies to this service, if any. An explicit
+	* `environmentOverrides` entry beats the developer's ambient configuration,
+	* and ambient configuration is not read at all in production: config that
+	* arrives out of band is a hazard there whatever it happens to say.
+	*/
+	findOverride() {
+		if (!this.serviceName) return;
+		const explicit = this.environmentOverrides?.[this.serviceName];
+		if (explicit) return {
+			value: explicit,
+			source: "environmentOverrides"
+		};
+		if (this.environment === "production") return;
+		return ambientOverride(this.serviceName);
 	}
+	/**
+	* Where this service answers, for the environment it was constructed with
+	* or for the one an override names in its place. Ignores `serviceUrl`;
+	* `getUrlPrefix()` is what honours that.
+	*/
 	discoverUrlPrefix() {
-		throw new Error("Method not implemented.");
+		const service = this.serviceName;
+		if (!service) throw new Error("Method not implemented.");
+		const override = this.findOverride();
+		if (!override) return resolveServiceUrl(service, this.environment, this.baseDomain);
+		const resolved = isServiceEnvironment(override.value) ? resolveServiceUrl(service, override.value, this.baseDomain) : overrideToUrl(override.value, service, override.source);
+		reportOverride({
+			service,
+			environment: this.environment,
+			resolved,
+			source: override.source
+		}, this.onOverride);
+		return resolved;
 	}
 	getUrlPrefix() {
-		if (this.serviceUrl) return this.serviceUrl;
+		if (this.serviceUrl) {
+			if (this.serviceName) reportOverride({
+				service: this.serviceName,
+				environment: this.environment,
+				resolved: this.serviceUrl,
+				source: "serviceUrl"
+			}, this.onOverride);
+			return this.serviceUrl;
+		}
 		return this.discoverUrlPrefix();
 	}
 	async addAuthHeaders(requestHeaders) {
@@ -147,16 +397,7 @@ var BaseService = class {
 //#endregion
 //#region src/services/tagging_service.ts
 var TaggingService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://tagging.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-tagging.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4160`;
-			case "test": return `https://localhost:3010/services/tagging`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "tagging";
 	async getTagsByResource({ identity, resource_type, resource_name, tag_name, timeout = 3e3 }) {
 		const url = `${this.getUrlPrefix()}/tags/by_resource/${identity}${resource_type ? `/${resource_type}` : ""}${resource_name ? `/${resource_name}` : ""}${tag_name ? `/${tag_name}` : ""}`;
 		const headers = new Headers();
@@ -218,16 +459,7 @@ let SSMLSpeechSpeeds = /* @__PURE__ */ function(SSMLSpeechSpeeds) {
 	return SSMLSpeechSpeeds;
 }({});
 var PollyService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://appear-polly.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-appear-polly.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:3200`;
-			case "test": return `https://localhost:3010/services/polly`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "polly";
 	async synthesize({ body, timeout = 3e3 }) {
 		const url = `${this.getUrlPrefix()}/synthesizeSpeech`;
 		const headers = new Headers();
@@ -243,16 +475,7 @@ var PollyService = class extends BaseService {
 //#endregion
 //#region src/services/cookie_consent_log.ts
 var CookieConsentLog = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://cookieconsentlog.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-cookieconsentlog.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4180`;
-			case "test": return `https://localhost:3010/services/cookieconsentlog`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "cookieConsentLog";
 	async logCookieConsent({ body, timeout = 3e3 }) {
 		const url = `${this.getUrlPrefix()}/log`;
 		const headers = new Headers();
@@ -274,16 +497,7 @@ let HighlightResultType = /* @__PURE__ */ function(HighlightResultType) {
 	return HighlightResultType;
 }({});
 var HighlightService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://highlights.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-highlights.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4120`;
-			case "test": return `https://localhost:3010/services/highlight`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "highlight";
 	async search({ search, timeout = 3e3 }) {
 		const url = `${this.getUrlPrefix()}/v2/search`;
 		const headers = new Headers();
@@ -355,16 +569,7 @@ var HighlightService = class extends BaseService {
 //#endregion
 //#region src/services/user_settings_base.ts
 var UserSettingsBase = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://user-settings-service.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-user-settings-service.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4110`;
-			case "test": return `https://localhost:3010/services/usersettingsservice`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "userSettings";
 };
 //#endregion
 //#region src/services/user_settings_clientsettings.ts
@@ -527,16 +732,7 @@ var UserSettingsMRU = class extends UserSettingsBase {
 //#endregion
 //#region src/services/pdf_generator.ts
 var PdfGeneratorService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://pdfgenerator.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-pdfgenerator.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4130`;
-			case "test": return `https://localhost:3010/services/pdfgenerator`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "pdfGenerator";
 	async pdfFromSiteMap({ body, timeout = 3e3 }) {
 		const url = `${this.getUrlPrefix()}/sitemap`;
 		const headers = new Headers();
@@ -878,16 +1074,7 @@ var UserFolders = class extends TaggingService {
 //#endregion
 //#region src/services/ai_bot_service.ts
 var AIBotService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://ai-bot-service.eu-west-1.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://ai-bot-service-staging.eu-west-1.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4170`;
-			case "test": return `https://localhost:3010/services/aibotservice`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "aiBot";
 	async constructChatUrl({ interactivityId, isbn, stream }) {
 		if (interactivityId && isbn) throw new Error("interactivityId and isbn are mutually exclusive");
 		if (!interactivityId && !isbn) throw new Error("Either interactivityId or isbn must be provided");
@@ -934,28 +1121,23 @@ var AIBotService = class extends BaseService {
 //#region src/services/quiz_service.ts
 const REQUEST_TIMEOUT = 1e4;
 var QuizService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return "https://api.iquiz.dk/api";
-			case "development":
-			case "testing":
-			case "local": return "https://galecms.test.tibalo.dk/api";
-			case "test": return `https://localhost:3010/galeapi/api`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "quiz";
 	/**
 	* Where a mediafile `identifier` is served from: the API prefix without its
-	* path, so the host mapping stays in `discoverUrlPrefix()` alone and an
-	* explicit `serviceUrl` is honoured the way `getUrlPrefix()` honours it.
+	* path, so the host mapping stays in `SERVICE_URLS` alone and everything
+	* that can redirect the API — an explicit `serviceUrl`, a per-service
+	* override — carries the media with it.
 	*
-	* The exception is the mock environment, where the app serves the fixtures
-	* itself and their identifiers are already relative to it — unless a
-	* `serviceUrl` is set, which overrides the environment there as everywhere.
+	* The exception is the mock server, where the app serves the fixtures
+	* itself and their identifiers are already relative to it. That is asked of
+	* the resolved prefix rather than of `environment`, so it stays true when a
+	* caller is sent to the mock by an override, and stops being true when one
+	* sends them somewhere real from the mock environment.
 	*/
 	getMediaUrlPrefix() {
-		if (!this.serviceUrl && this.environment === "test") return "";
-		return new URL(this.getUrlPrefix()).origin;
+		const prefix = this.getUrlPrefix();
+		if (prefix === resolveServiceUrl("quiz", "test", this.baseDomain)) return "";
+		return new URL(prefix).origin;
 	}
 	makeHeaders(extra) {
 		const headers = new Headers();
@@ -1171,16 +1353,7 @@ var QuizService = class extends BaseService {
 * token as the highlight service does.
 */
 var WritingTaskService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://writingtask.services.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://staging-writingtask.services.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4140`;
-			case "test": return `https://localhost:3010/services/writingtask`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "writingTask";
 	/** Answers stored for the given content ids, one bucket per cid. */
 	async getResponse({ userId, isbn, pid, cids, timeout = 5e3 }) {
 		const url = `${this.getUrlPrefix()}/getResponse`;
@@ -1240,25 +1413,19 @@ var WritingTaskService = class extends BaseService {
 //#endregion
 //#region src/services/solr_proxy_service.ts
 var SolrProxyService = class extends BaseService {
-	discoverUrlPrefix() {
-		switch (this.environment) {
-			case "production": return `https://solr-proxy.eu-west-1.${this.baseDomain}`;
-			case "development":
-			case "testing": return `https://solr-proxy-staging.eu-west-1.${this.baseDomain}`;
-			case "local": return `http://127.0.0.1:4150`;
-			case "test": return `https://localhost:3010/services/solrproxy`;
-			default: throw new Error(`Unknown environment: ${this.environment}`);
-		}
-	}
+	serviceName = "solrProxy";
 };
 //#endregion
 exports.AIBotService = AIBotService;
 exports.CookieConsentLog = CookieConsentLog;
+exports.ENVIRONMENTS = ENVIRONMENTS;
+exports.GALE_QA_URL = GALE_QA_URL;
 exports.HighlightResultType = HighlightResultType;
 exports.HighlightService = HighlightService;
 exports.PdfGeneratorService = PdfGeneratorService;
 exports.PollyService = PollyService;
 exports.QuizService = QuizService;
+exports.SERVICE_URLS = SERVICE_URLS;
 exports.SSMLSpeechSpeeds = SSMLSpeechSpeeds;
 exports.SolrProxyService = SolrProxyService;
 exports.TaggingService = TaggingService;
@@ -1268,6 +1435,13 @@ exports.UserSettingsClientSettings = UserSettingsClientSettings;
 exports.UserSettingsContinue = UserSettingsContinue;
 exports.UserSettingsMRU = UserSettingsMRU;
 exports.WritingTaskService = WritingTaskService;
+exports.ambientOverride = ambientOverride;
 exports.getJwtExpiry = getJwtExpiry;
+exports.isServiceEnvironment = isServiceEnvironment;
+exports.overrideEnvVarName = overrideEnvVarName;
+exports.overrideToUrl = overrideToUrl;
+exports.reportOverride = reportOverride;
+exports.resetOverrideReports = resetOverrideReports;
+exports.resolveServiceUrl = resolveServiceUrl;
 
 //# sourceMappingURL=index.cjs.map