@backstage/config-loader 0.8.1 → 0.9.3-next.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @backstage/config-loader
 
+## 0.9.3-next.0
+
+### Patch Changes
+
+- f685e1398f: Loading of app configurations now reference the `@deprecated` construct from
+  JSDoc to determine if a property in-use has been deprecated. Users are notified
+  of deprecated keys in the format:
+
+  ```txt
+  The configuration key 'catalog.processors.githubOrg' of app-config.yaml is deprecated and may be removed soon. Configure a GitHub integration instead.
+  ```
+
+  When the `withDeprecatedKeys` option is set to `true` in the `process` method
+  of `loadConfigSchema`, the user will be notified that deprecated keys have been
+  identified in their app configuration.
+
+  The `backend-common` and `plugin-app-backend` packages have been updated to set
+  `withDeprecatedKeys` to true so that users are notified of deprecated settings
+  by default.
+
+- Updated dependencies
+  - @backstage/config@0.1.13-next.0
+
+## 0.9.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/config@0.1.12
+  - @backstage/errors@0.2.0
+
+## 0.9.1
+
+### Patch Changes
+
+- 84663d59a3: Bump `typescript-json-schema` from `^0.51.0` to `^0.52.0`.
+
+## 0.9.0
+
+### Minor Changes
+
+- f6722d2458: Removed deprecated option `env` from `LoadConfigOptions` and associated tests
+- 67d6cb3c7e: Removed deprecated option `configPaths` as it has been superseded by `configTargets`
+
+### Patch Changes
+
+- 1e7070443d: In case remote.reloadIntervalSeconds is passed, it must be a valid positive value
+
 ## 0.8.1
 
 ### Patch Changes

package/dist/index.cjs.js

@@ -64,7 +64,7 @@ function readEnvConfig(env) {
       }
     }
   }
-  return data ? [{data, context: "env"}] : [];
+  return data ? [{ data, context: "env" }] : [];
 }
 function safeJsonParse(str) {
   try {
@@ -139,13 +139,13 @@ async function applyConfigTransforms(initialDir, input, transforms) {
 
 const includeFileParser = {
   ".json": async (content) => JSON.parse(content),
-  ".yaml": async (content) => yaml__default['default'].parse(content),
-  ".yml": async (content) => yaml__default['default'].parse(content)
+  ".yaml": async (content) => yaml__default["default"].parse(content),
+  ".yml": async (content) => yaml__default["default"].parse(content)
 };
 function createIncludeTransform(env, readFile, substitute) {
   return async (input, baseDir) => {
     if (!isObject(input)) {
-      return {applied: false};
+      return { applied: false };
     }
     const [includeKey] = Object.keys(input).filter((key) => key.startsWith("$"));
     if (includeKey) {
@@ -153,7 +153,7 @@ function createIncludeTransform(env, readFile, substitute) {
         throw new Error(`include key ${includeKey} should not have adjacent keys`);
       }
     } else {
-      return {applied: false};
+      return { applied: false };
     }
     const rawIncludedValue = input[includeKey];
     if (typeof rawIncludedValue !== "string") {
@@ -168,13 +168,13 @@ function createIncludeTransform(env, readFile, substitute) {
       case "$file":
         try {
           const value = await readFile(path.resolve(baseDir, includeValue));
-          return {applied: true, value};
+          return { applied: true, value };
         } catch (error) {
           throw new Error(`failed to read file ${includeValue}, ${error}`);
         }
       case "$env":
         try {
-          return {applied: true, value: await env(includeValue)};
+          return { applied: true, value: await env(includeValue) };
         } catch (error) {
           throw new Error(`failed to read env ${includeValue}, ${error}`);
         }
@@ -217,7 +217,7 @@ function createIncludeTransform(env, readFile, substitute) {
 function createSubstitutionTransform(env) {
   return async (input) => {
     if (typeof input !== "string") {
-      return {applied: false};
+      return { applied: false };
     }
     const parts = input.split(/(\$?\$\{[^{}]*\})/);
     for (let i = 1; i < parts.length; i += 2) {
@@ -229,9 +229,9 @@ function createSubstitutionTransform(env) {
       }
     }
     if (parts.some((part) => part === void 0)) {
-      return {applied: true, value: void 0};
+      return { applied: true, value: void 0 };
     }
-    return {applied: true, value: parts.join("")};
+    return { applied: true, value: parts.join("") };
   };
 }
 
@@ -239,8 +239,9 @@ const CONFIG_VISIBILITIES = ["frontend", "backend", "secret"];
 const DEFAULT_CONFIG_VISIBILITY = "backend";
 
 function compileConfigSchemas(schemas) {
-  const visibilityByDataPath = new Map();
-  const ajv = new Ajv__default['default']({
+  const visibilityByDataPath = /* @__PURE__ */ new Map();
+  const deprecationByDataPath = /* @__PURE__ */ new Map();
+  const ajv = new Ajv__default["default"]({
     allErrors: true,
     allowUnionTypes: true,
     schemas: {
@@ -264,6 +265,19 @@ function compileConfigSchemas(schemas) {
         return true;
       };
     }
+  }).removeKeyword("deprecated").addKeyword({
+    keyword: "deprecated",
+    metaSchema: { type: "string" },
+    compile(deprecationDescription) {
+      return (_data, context) => {
+        if ((context == null ? void 0 : context.dataPath) === void 0) {
+          return false;
+        }
+        const normalizedPath = context.dataPath.replace(/\['?(.*?)'?\]/g, (_, segment) => `/${segment}`);
+        deprecationByDataPath.set(normalizedPath, deprecationDescription);
+        return true;
+      };
+    }
   });
   for (const schema of schemas) {
     try {
@@ -274,8 +288,8 @@ function compileConfigSchemas(schemas) {
   }
   const merged = mergeConfigSchemas(schemas.map((_) => _.value));
   const validate = ajv.compile(merged);
-  const visibilityBySchemaPath = new Map();
-  traverse__default['default'](merged, (schema, path) => {
+  const visibilityBySchemaPath = /* @__PURE__ */ new Map();
+  traverse__default["default"](merged, (schema, path) => {
     if (schema.visibility && schema.visibility !== "backend") {
       visibilityBySchemaPath.set(path, schema.visibility);
     }
@@ -289,17 +303,19 @@ function compileConfigSchemas(schemas) {
       return {
         errors: (_a = validate.errors) != null ? _a : [],
         visibilityByDataPath: new Map(visibilityByDataPath),
-        visibilityBySchemaPath
+        visibilityBySchemaPath,
+        deprecationByDataPath
       };
     }
     return {
       visibilityByDataPath: new Map(visibilityByDataPath),
-      visibilityBySchemaPath
+      visibilityBySchemaPath,
+      deprecationByDataPath
     };
   };
 }
 function mergeConfigSchemas(schemas) {
-  const merged = mergeAllOf__default['default']({allOf: schemas}, {
+  const merged = mergeAllOf__default["default"]({ allOf: schemas }, {
     ignoreAdditionalProperties: true,
     resolvers: {
       visibility(values, path) {
@@ -323,18 +339,18 @@ const req = typeof __non_webpack_require__ === "undefined" ? require : __non_web
 async function collectConfigSchemas(packageNames, packagePaths) {
   const schemas = new Array();
   const tsSchemaPaths = new Array();
-  const visitedPackageVersions = new Map();
-  const currentDir = await fs__default['default'].realpath(process.cwd());
+  const visitedPackageVersions = /* @__PURE__ */ new Map();
+  const currentDir = await fs__default["default"].realpath(process.cwd());
   async function processItem(item) {
     var _a, _b, _c, _d;
     let pkgPath = item.packagePath;
     if (pkgPath) {
-      const pkgExists = await fs__default['default'].pathExists(pkgPath);
+      const pkgExists = await fs__default["default"].pathExists(pkgPath);
       if (!pkgExists) {
         return;
       }
     } else if (item.name) {
-      const {name, parentPath} = item;
+      const { name, parentPath } = item;
       try {
         pkgPath = req.resolve(`${name}/package.json`, parentPath && {
           paths: [parentPath]
@@ -345,13 +361,13 @@ async function collectConfigSchemas(packageNames, packagePaths) {
     if (!pkgPath) {
       return;
     }
-    const pkg = await fs__default['default'].readJson(pkgPath);
+    const pkg = await fs__default["default"].readJson(pkgPath);
     let versions = visitedPackageVersions.get(pkg.name);
     if (versions == null ? void 0 : versions.has(pkg.version)) {
       return;
     }
     if (!versions) {
-      versions = new Set();
+      versions = /* @__PURE__ */ new Set();
       visitedPackageVersions.set(pkg.name, versions);
     }
     versions.add(pkg.version);
@@ -377,7 +393,7 @@ async function collectConfigSchemas(packageNames, packagePaths) {
           tsSchemaPaths.push(path.relative(currentDir, path.resolve(path.dirname(pkgPath), pkg.configSchema)));
         } else {
           const path$1 = path.resolve(path.dirname(pkgPath), pkg.configSchema);
-          const value = await fs__default['default'].readJson(path$1);
+          const value = await fs__default["default"].readJson(path$1);
           schemas.push({
             value,
             path: path.relative(currentDir, path$1)
@@ -390,11 +406,11 @@ async function collectConfigSchemas(packageNames, packagePaths) {
         });
       }
     }
-    await Promise.all(depNames.map((depName) => processItem({name: depName, parentPath: pkgPath})));
+    await Promise.all(depNames.map((depName) => processItem({ name: depName, parentPath: pkgPath })));
   }
   await Promise.all([
-    ...packageNames.map((name) => processItem({name, parentPath: currentDir})),
-    ...packagePaths.map((path) => processItem({name: path, packagePath: path}))
+    ...packageNames.map((name) => processItem({ name, parentPath: currentDir })),
+    ...packagePaths.map((path) => processItem({ name: path, packagePath: path }))
   ]);
   const tsSchemas = compileTsSchemas(tsSchemaPaths);
   return schemas.concat(tsSchemas);
@@ -420,7 +436,7 @@ function compileTsSchemas(paths) {
     try {
       value = typescriptJsonSchema.generateSchema(program, "Config", {
         required: true,
-        validationKeywords: ["visibility"]
+        validationKeywords: ["visibility", "deprecated"]
       }, [path$1.split(path.sep).join("/")]);
     } catch (error) {
       errors.assertError(error);
@@ -431,22 +447,27 @@ function compileTsSchemas(paths) {
     if (!value) {
       throw new Error(`Invalid schema in ${path$1}, missing Config export`);
     }
-    return {path: path$1, value};
+    return { path: path$1, value };
   });
   return tsSchemas;
 }
 
-function filterByVisibility(data, includeVisibilities, visibilityByDataPath, transformFunc, withFilteredKeys) {
+function filterByVisibility(data, includeVisibilities, visibilityByDataPath, deprecationByDataPath, transformFunc, withFilteredKeys, withDeprecatedKeys) {
   var _a;
   const filteredKeys = new Array();
+  const deprecatedKeys = new Array();
   function transform(jsonVal, visibilityPath, filterPath) {
     var _a2;
     const visibility = (_a2 = visibilityByDataPath.get(visibilityPath)) != null ? _a2 : DEFAULT_CONFIG_VISIBILITY;
     const isVisible = includeVisibilities.includes(visibility);
+    const deprecation = deprecationByDataPath.get(visibilityPath);
+    if (deprecation) {
+      deprecatedKeys.push({ key: filterPath, description: deprecation });
+    }
     if (typeof jsonVal !== "object") {
       if (isVisible) {
         if (transformFunc) {
-          return transformFunc(jsonVal, {visibility});
+          return transformFunc(jsonVal, { visibility });
         }
         return jsonVal;
       }
@@ -493,6 +514,7 @@ function filterByVisibility(data, includeVisibilities, visibilityByDataPath, tra
   }
   return {
     filteredKeys: withFilteredKeys ? filteredKeys : void 0,
+    deprecatedKeys: withDeprecatedKeys ? deprecatedKeys : void 0,
     data: (_a = transform(data, "", "")) != null ? _a : {}
   };
 }
@@ -522,7 +544,7 @@ function filterErrorsByVisibility(errors, includeVisibilities, visibilityByDataP
 }
 
 function errorsToError(errors) {
-  const messages = errors.map(({dataPath, message, params}) => {
+  const messages = errors.map(({ dataPath, message, params }) => {
     const paramStr = Object.entries(params).map(([name, value]) => `${name}=${value}`).join(" ");
     return `Config ${message || ""} { ${paramStr} } at ${dataPath}`;
   });
@@ -536,7 +558,7 @@ async function loadConfigSchema(options) {
   if ("dependencies" in options) {
     schemas = await collectConfigSchemas(options.dependencies, (_a = options.packagePaths) != null ? _a : []);
   } else {
-    const {serialized} = options;
+    const { serialized } = options;
     if ((serialized == null ? void 0 : serialized.backstageConfigSchemaVersion) !== 1) {
       throw new Error("Serialized configuration schema is invalid or has an invalid version number");
     }
@@ -544,7 +566,7 @@ async function loadConfigSchema(options) {
   }
   const validate = compileConfigSchemas(schemas);
   return {
-    process(configs, {visibility, valueTransform, withFilteredKeys} = {}) {
+    process(configs, { visibility, valueTransform, withFilteredKeys, withDeprecatedKeys } = {}) {
       const result = validate(configs);
       const visibleErrors = filterErrorsByVisibility(result.errors, visibility, result.visibilityByDataPath, result.visibilityBySchemaPath);
       if (visibleErrors.length > 0) {
@@ -552,14 +574,14 @@ async function loadConfigSchema(options) {
       }
       let processedConfigs = configs;
       if (visibility) {
-        processedConfigs = processedConfigs.map(({data, context}) => ({
+        processedConfigs = processedConfigs.map(({ data, context }) => ({
           context,
-          ...filterByVisibility(data, visibility, result.visibilityByDataPath, valueTransform, withFilteredKeys)
+          ...filterByVisibility(data, visibility, result.visibilityByDataPath, result.deprecationByDataPath, valueTransform, withFilteredKeys, withDeprecatedKeys)
         }));
       } else if (valueTransform) {
-        processedConfigs = processedConfigs.map(({data, context}) => ({
+        processedConfigs = processedConfigs.map(({ data, context }) => ({
           context,
-          ...filterByVisibility(data, Array.from(CONFIG_VISIBILITIES), result.visibilityByDataPath, valueTransform, withFilteredKeys)
+          ...filterByVisibility(data, Array.from(CONFIG_VISIBILITIES), result.visibilityByDataPath, result.deprecationByDataPath, valueTransform, withFilteredKeys, withDeprecatedKeys)
         }));
       }
       return processedConfigs;
@@ -583,21 +605,20 @@ function isValidUrl(url) {
 }
 
 async function loadConfig(options) {
-  const {configRoot, experimentalEnvFunc: envFunc, watch, remote} = options;
+  const { configRoot, experimentalEnvFunc: envFunc, watch, remote } = options;
   const configPaths = options.configTargets.slice().filter((e) => e.hasOwnProperty("path")).map((configTarget) => configTarget.path);
-  options.configPaths.forEach((cp) => {
-    if (!configPaths.includes(cp)) {
-      configPaths.push(cp);
-    }
-  });
   const configUrls = options.configTargets.slice().filter((e) => e.hasOwnProperty("url")).map((configTarget) => configTarget.url);
-  if (remote === void 0 && configUrls.length > 0) {
-    throw new Error(`Remote config detected but this feature is turned off`);
+  if (remote === void 0) {
+    if (configUrls.length > 0) {
+      throw new Error(`Please make sure you are passing the remote option when loading remote configurations. See https://backstage.io/docs/conf/writing#configuration-files for detailed info.`);
+    }
+  } else if (remote.reloadIntervalSeconds <= 0) {
+    throw new Error(`Remote config must be contain a non zero reloadIntervalSeconds: <seconds> value`);
   }
   if (configPaths.length === 0 && configUrls.length === 0) {
     configPaths.push(path.resolve(configRoot, "app-config.yaml"));
     const localConfig = path.resolve(configRoot, "app-config.local.yaml");
-    if (await fs__default['default'].pathExists(localConfig)) {
+    if (await fs__default["default"].pathExists(localConfig)) {
       configPaths.push(localConfig);
     }
   }
@@ -609,21 +630,21 @@ async function loadConfig(options) {
         throw new Error(`Config load path is not absolute: '${configPath}'`);
       }
       const dir = path.dirname(configPath);
-      const readFile = (path$1) => fs__default['default'].readFile(path.resolve(dir, path$1), "utf8");
-      const input = yaml__default['default'].parse(await readFile(configPath));
+      const readFile = (path$1) => fs__default["default"].readFile(path.resolve(dir, path$1), "utf8");
+      const input = yaml__default["default"].parse(await readFile(configPath));
       const substitutionTransform = createSubstitutionTransform(env);
       const data = await applyConfigTransforms(dir, input, [
         createIncludeTransform(env, readFile, substitutionTransform),
         substitutionTransform
       ]);
-      configs.push({data, context: path.basename(configPath)});
+      configs.push({ data, context: path.basename(configPath) });
     }
     return configs;
   };
   const loadRemoteConfigFiles = async () => {
     const configs = [];
     const readConfigFromUrl = async (url) => {
-      const response = await fetch__default['default'](url);
+      const response = await fetch__default["default"](url);
       if (!response.ok) {
         throw new Error(`Could not read config file at ${url}`);
       }
@@ -638,12 +659,12 @@ async function loadConfig(options) {
       if (!remoteConfigContent) {
         throw new Error(`Config is not valid`);
       }
-      const configYaml = yaml__default['default'].parse(remoteConfigContent);
+      const configYaml = yaml__default["default"].parse(remoteConfigContent);
       const substitutionTransform = createSubstitutionTransform(env);
       const data = await applyConfigTransforms(configRoot, configYaml, [
         substitutionTransform
       ]);
-      configs.push({data, context: configUrl});
+      configs.push({ data, context: configUrl });
     }
     return configs;
   };
@@ -663,7 +684,7 @@ async function loadConfig(options) {
   }
   const envConfigs = await readEnvConfig(process.env);
   const watchConfigFile = (watchProp) => {
-    const watcher = chokidar__default['default'].watch(configPaths, {
+    const watcher = chokidar__default["default"].watch(configPaths, {
       usePolling: process.env.NODE_ENV === "test"
     });
     let currentSerializedConfig = JSON.stringify(fileConfigs);