@azure/app-configuration
Version:
An isomorphic client library for the Azure App Configuration service.
315 lines (314 loc) • 11.3 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var helpers_exports = {};
__export(helpers_exports, {
assertResponse: () => assertResponse,
checkAndFormatIfAndIfNoneMatch: () => checkAndFormatIfAndIfNoneMatch,
errorMessageForUnexpectedSetting: () => errorMessageForUnexpectedSetting,
extractAfterTokenFromLinkHeader: () => extractAfterTokenFromLinkHeader,
extractAfterTokenFromNextLink: () => extractAfterTokenFromNextLink,
formatAcceptDateTime: () => formatAcceptDateTime,
formatConfigurationSettingsFiltersAndSelect: () => formatConfigurationSettingsFiltersAndSelect,
formatFieldsForSelect: () => formatFieldsForSelect,
formatFiltersAndSelect: () => formatFiltersAndSelect,
formatLabelsFiltersAndSelect: () => formatLabelsFiltersAndSelect,
formatSnapshotFiltersAndSelect: () => formatSnapshotFiltersAndSelect,
getScope: () => getScope,
hasUnderscoreResponse: () => hasUnderscoreResponse,
makeConfigurationSettingEmpty: () => makeConfigurationSettingEmpty,
quoteETag: () => quoteETag,
serializeAsConfigurationSettingParam: () => serializeAsConfigurationSettingParam,
snapshotInfoToGenerated: () => snapshotInfoToGenerated,
transformKeyValue: () => transformKeyValue,
transformKeyValueResponse: () => transformKeyValueResponse,
transformKeyValueResponseWithStatusCode: () => transformKeyValueResponseWithStatusCode,
transformSnapshotResponse: () => transformSnapshotResponse
});
module.exports = __toCommonJS(helpers_exports);
var import_models = require("../models.js");
var import_featureFlag = require("../featureFlag.js");
var import_secretReference = require("../secretReference.js");
var import_snapshotReference = require("../snapshotReference.js");
var import_core_util = require("@azure/core-util");
var import_logger = require("../logger.js");
function quoteETag(etag) {
if (etag === void 0 || etag === "*") {
return etag;
}
if (etag.startsWith('"') && etag.endsWith('"')) {
return etag;
}
if (etag.startsWith("'") && etag.endsWith("'")) {
return etag;
}
return `"${etag}"`;
}
function checkAndFormatIfAndIfNoneMatch(objectWithEtag, options) {
if (options.onlyIfChanged && options.onlyIfUnchanged) {
import_logger.logger.error(
"onlyIfChanged and onlyIfUnchanged are both specified",
options.onlyIfChanged,
options.onlyIfUnchanged
);
throw new Error("onlyIfChanged and onlyIfUnchanged are mutually-exclusive");
}
let ifMatch;
let ifNoneMatch;
if (options.onlyIfUnchanged) {
ifMatch = quoteETag(objectWithEtag.etag);
}
if (options.onlyIfChanged) {
ifNoneMatch = quoteETag(objectWithEtag.etag);
}
return {
ifMatch,
ifNoneMatch
};
}
function formatFiltersAndSelect(listConfigOptions) {
let acceptDatetime = void 0;
if (listConfigOptions.acceptDateTime) {
acceptDatetime = listConfigOptions.acceptDateTime.toISOString();
}
return {
key: listConfigOptions.keyFilter,
label: listConfigOptions.labelFilter,
// Ensure the tags are URL-encoded when encoding
tags: listConfigOptions.tagsFilter?.map((t) => encodeURIComponent(t)),
acceptDatetime,
select: formatFieldsForSelect(listConfigOptions.fields)
};
}
function formatConfigurationSettingsFiltersAndSelect(listConfigOptions) {
const { snapshotName: snapshot, ...options } = listConfigOptions;
return {
...formatFiltersAndSelect(options),
snapshot
};
}
function formatSnapshotFiltersAndSelect(listSnapshotOptions) {
return {
name: listSnapshotOptions.nameFilter,
status: listSnapshotOptions.statusFilter,
select: listSnapshotOptions.fields
};
}
function formatLabelsFiltersAndSelect(listLabelsOptions) {
return {
name: listLabelsOptions.nameFilter,
select: listLabelsOptions.fields
};
}
function formatAcceptDateTime(newOptions) {
return {
acceptDatetime: newOptions.acceptDateTime && newOptions.acceptDateTime.toISOString()
};
}
function extractAfterTokenFromNextLink(nextLink) {
const searchParams = new URLSearchParams(nextLink);
const afterToken = searchParams.get("after");
if (afterToken == null || Array.isArray(afterToken)) {
import_logger.logger.error("Invalid nextLink - invalid after token", afterToken, Array.isArray(afterToken));
throw new Error("Invalid nextLink - invalid after token");
}
return decodeURIComponent(afterToken);
}
function extractAfterTokenFromLinkHeader(link) {
const linkValue = link.split(";")[0];
const nextLink = linkValue.substring(1, linkValue.length - 1);
return extractAfterTokenFromNextLink(nextLink);
}
function makeConfigurationSettingEmpty(configurationSetting) {
const names = [
"contentType",
"description",
"etag",
"label",
"lastModified",
"isReadOnly",
"tags",
"value"
];
for (const name of names) {
configurationSetting[name] = void 0;
}
}
function transformKeyValue(kvp) {
const setting = {
value: void 0,
...kvp,
isReadOnly: !!kvp.locked,
lastModified: kvp.lastModified ? new Date(kvp.lastModified) : void 0
};
delete setting.locked;
if (!setting.label) {
delete setting.label;
}
if (!setting.contentType) {
delete setting.contentType;
}
return setting;
}
function isConfigSettingWithSecretReferenceValue(setting) {
return setting.contentType === import_secretReference.secretReferenceContentType && (0, import_core_util.isDefined)(setting.value) && typeof setting.value !== "string";
}
function isConfigSettingWithSnapshotReferenceValue(setting) {
return setting.contentType === import_snapshotReference.snapshotReferenceContentType && (0, import_core_util.isDefined)(setting.value) && typeof setting.value !== "string";
}
function isConfigSettingWithFeatureFlagValue(setting) {
return setting.contentType === import_featureFlag.featureFlagContentType && (0, import_core_util.isDefined)(setting.value) && typeof setting.value !== "string";
}
function isSimpleConfigSetting(setting) {
return typeof setting.value === "string" || !(0, import_core_util.isDefined)(setting.value);
}
function serializeAsConfigurationSettingParam(setting) {
if (isSimpleConfigSetting(setting)) {
return setting;
}
try {
if (isConfigSettingWithFeatureFlagValue(setting)) {
return import_featureFlag.FeatureFlagHelper.toConfigurationSettingParam(setting);
}
if (isConfigSettingWithSecretReferenceValue(setting)) {
return import_secretReference.SecretReferenceHelper.toConfigurationSettingParam(setting);
}
if (isConfigSettingWithSnapshotReferenceValue(setting)) {
return import_snapshotReference.SnapshotReferenceHelper.toConfigurationSettingParam(setting);
}
} catch (error) {
return setting;
}
import_logger.logger.error("Unable to serialize to a configuration setting", setting);
throw new TypeError(
`Unable to serialize the setting with key "${setting.key}" as a configuration setting`
);
}
function transformKeyValueResponseWithStatusCode(kvp, status) {
const source = kvp ?? {};
const response = {
...transformKeyValue(source),
statusCode: status ?? -1
};
if (hasUnderscoreResponse(source)) {
Object.defineProperty(response, "_response", {
enumerable: false,
value: source._response
});
}
return response;
}
function transformKeyValueResponse(kvp) {
const setting = transformKeyValue(kvp);
if (hasUnderscoreResponse(kvp)) {
Object.defineProperty(setting, "_response", {
enumerable: false,
value: kvp._response
});
}
delete setting.eTag;
return setting;
}
function transformSnapshotResponse(snapshot) {
const configSnapshot = {
...snapshot,
createdOn: snapshot.createdOn ? new Date(snapshot.createdOn) : void 0,
expiresOn: snapshot.expiresOn ? new Date(snapshot.expiresOn) : void 0,
itemCount: snapshot.itemsCount
};
if (hasUnderscoreResponse(snapshot)) {
Object.defineProperty(configSnapshot, "_response", {
enumerable: false,
value: snapshot._response
});
}
return configSnapshot;
}
function snapshotInfoToGenerated(snapshot) {
return {
...snapshot,
compositionType: snapshot.compositionType
};
}
function formatFieldsForSelect(fieldNames) {
if (fieldNames == null) {
return void 0;
}
const mappedFieldNames = fieldNames.map((fn) => {
switch (fn) {
case "lastModified":
return "last_modified";
case "contentType":
return "content_type";
case "isReadOnly":
return "locked";
default:
return fn;
}
});
return mappedFieldNames;
}
function errorMessageForUnexpectedSetting(key, expectedType) {
return `Setting with key ${key} is not a valid ${expectedType}, make sure to have the correct content-type and a valid non-null value.`;
}
function assertResponse(result) {
if (!hasUnderscoreResponse(result)) {
Object.defineProperty(result, "_response", {
enumerable: false,
value: "Something went wrong, _response(raw response) is supposed to be part of the response. Please file a bug at https://github.com/Azure/azure-sdk-for-js"
});
}
}
function hasUnderscoreResponse(result) {
return Object.prototype.hasOwnProperty.call(result, "_response");
}
function getScope(appConfigEndpoint, appConfigAudience) {
if (appConfigAudience) {
return `${appConfigAudience}/.default`;
} else if (appConfigEndpoint.endsWith("azconfig.azure.us") || appConfigEndpoint.endsWith("appconfig.azure.us")) {
return `${import_models.KnownAppConfigAudience.AzureGovernment}/.default`;
} else if (appConfigEndpoint.endsWith("azconfig.azure.cn") || appConfigEndpoint.endsWith("appconfig.azure.cn")) {
return `${import_models.KnownAppConfigAudience.AzureChina}/.default`;
} else {
return `${import_models.KnownAppConfigAudience.AzurePublicCloud}/.default`;
}
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
assertResponse,
checkAndFormatIfAndIfNoneMatch,
errorMessageForUnexpectedSetting,
extractAfterTokenFromLinkHeader,
extractAfterTokenFromNextLink,
formatAcceptDateTime,
formatConfigurationSettingsFiltersAndSelect,
formatFieldsForSelect,
formatFiltersAndSelect,
formatLabelsFiltersAndSelect,
formatSnapshotFiltersAndSelect,
getScope,
hasUnderscoreResponse,
makeConfigurationSettingEmpty,
quoteETag,
serializeAsConfigurationSettingParam,
snapshotInfoToGenerated,
transformKeyValue,
transformKeyValueResponse,
transformKeyValueResponseWithStatusCode,
transformSnapshotResponse
});
//# sourceMappingURL=helpers.js.map