@docupace/ihub-config 1.1.24-admin.2 → 1.1.25

package/dist/config-service.js

@@ -11,228 +11,8 @@ import { builtInProviders } from './providers/index.js';
 import { deepMergeResolvers, } from './resolvers/index.js';
 import { dump, load } from 'js-yaml';
 import { buildQuery } from '@docupace/ihub-core/query';
-import jp from 'jsonpath';
 const FULL_OBJECT_EXPRESSION_PATTERN = /^\${(.*?)}$/;
 const INLINE_OBJECT_EXPRESSION_PATTERN = /\${(.*?)}/g;
-function isNamedObjectArray(value) {
-    return (Array.isArray(value) &&
-        value.every((item) => item !== null &&
-            typeof item === 'object' &&
-            typeof item.name === 'string'));
-}
-// An override element counts as "self-contained" when it carries enough of
-// its own definition to render on its own — a real attribute path (or paths)
-// or a computed expression — as opposed to a thin `{ name, visible }`-style
-// reference that only makes sense resolved against a base/predefined
-// counterpart of the same name. `paths` (plural) is `Column`'s shape;
-// `path` (singular) is `TableCriteria`'s — both must count, or a resolved
-// filter-criterion `$ref` (which only ever has a singular `path`) is wrongly
-// treated as a dangling reference and silently dropped, even though it just
-// resolved successfully.
-function isSelfContainedOverrideElement(item) {
-    const paths = item.paths;
-    return ((Array.isArray(paths) && paths.length > 0) ||
-        (typeof item.path === 'string' && item.path.length > 0) ||
-        (typeof item.expression === 'string' && item.expression.length > 0));
-}
-/**
- * Merge semantics for a config sub-path override against the value already
- * at that JSONPath. Generic — used for any typename/sub-path the
- * configPath/subPath mechanism resolves, not just `Table.columns`.
- *
- * When both the current value and the override value are arrays of objects
- * each carrying a string `name`, override elements are merged onto their
- * base counterpart by name (override wins per-attribute, everything else
- * inherited) instead of the override replacing the array wholesale. This is
- * what makes a saved override non-destructive:
- * - Reordering falls out of the override array's own element order.
- * - "Hiding" an element is an attribute override (e.g. `visible: false`) on
- *   an element that's still present, not a deletion.
- * - A base element the override never mentions is appended unchanged, so a
- *   base element added later still surfaces for someone with an existing
- *   override, instead of being permanently absent from their frozen array.
- * - An override element naming something not found in the base is kept
- *   as-is when it's self-contained (has its own path(s)/expression — e.g. a
- *   hand-authored column), or silently dropped when it's a thin reference
- *   whose target (e.g. a predefined column) no longer exists — this never
- *   throws; the stale reference just doesn't round-trip into the next save.
- *
- * Any other shape (scalars, plain objects, arrays without a `name` key) is
- * returned untouched, so the caller's plain whole-value replace applies
- * exactly as it did before this merge existed.
- */
-function mergeSubPathOverrideValue(base, override) {
-    if (!isNamedObjectArray(override) || !isNamedObjectArray(base)) {
-        return override;
-    }
-    const baseByName = new Map(base.map((item) => [item.name, item]));
-    const merged = [];
-    const seenNames = new Set();
-    for (const overrideItem of override) {
-        // Guard against a corrupted/hand-edited override array carrying two
-        // elements with the same name — only the first is kept, so the merged
-        // result never has duplicate names.
-        if (seenNames.has(overrideItem.name)) {
-            continue;
-        }
-        seenNames.add(overrideItem.name);
-        const baseItem = baseByName.get(overrideItem.name);
-        if (baseItem) {
-            merged.push({ ...baseItem, ...overrideItem });
-        }
-        else if (isSelfContainedOverrideElement(overrideItem)) {
-            merged.push(overrideItem);
-        }
-        // else: a thin reference to a name that no longer resolves — drop it.
-    }
-    const mergedNames = new Set(merged.map((item) => item.name));
-    const untouchedBaseItems = base.filter((item) => !mergedNames.has(item.name));
-    return [...merged, ...untouchedBaseItems];
-}
-// Marks each element of a fully-folded named-object array with whether it
-// would still show up — present *and* not hidden — without the layer stored
-// at the identity's own scope tier (`withoutOwnScope`, the same
-// broadest-to-narrowest fold as `mergedValue` minus that one layer; see
-// `applyConfigPathOverride`, where both folds are computed).
-//
-// This drives two decisions in the editing client, both about what its own
-// scope's override has to say explicitly to get the effect the user asked
-// for:
-// - Removing an entry: `inherited` means hiding it (`visible: false`) is
-//   required, since deleting it from this scope's override would just have
-//   the next resolution fold bring it back from a broader layer. Not
-//   inherited means a plain delete suffices.
-// - Adding/re-showing an entry: not inherited means the client must pin
-//   `visible: true` on it, since the broader fold either doesn't have it at
-//   all or has it hidden — and per-attribute merge semantics would otherwise
-//   inherit that `visible: false` straight through this scope's own
-//   override, leaving the entry invisible no matter how it's re-added.
-// Hidden-ness is folded into `inherited` (rather than reported as a separate
-// flag) precisely because both decisions only ever care whether the entry
-// would be *there*, and a broader-hidden entry is exactly as absent from the
-// user's view as a missing one.
-//
-// Only stamps when both values are named-object arrays; any other shape
-// (scalar, plain object, unnamed array) is returned unchanged, mirroring
-// `mergeSubPathOverrideValue`'s own shape guard.
-function stampInherited(mergedValue, withoutOwnScope) {
-    if (!isNamedObjectArray(mergedValue) ||
-        !isNamedObjectArray(withoutOwnScope)) {
-        return mergedValue;
-    }
-    const inheritedByName = new Map(withoutOwnScope.map((item) => [item.name, item]));
-    return mergedValue.map((item) => {
-        const counterpart = inheritedByName.get(item.name);
-        return {
-            ...item,
-            inherited: !!counterpart && counterpart.visible !== false,
-        };
-    });
-}
-function isRefElement(item) {
-    return (item !== null &&
-        typeof item === 'object' &&
-        typeof item.$ref === 'string');
-}
-// Resolves a config-path override array element's fragment-only `$ref`
-// (e.g. `"#$.predefinedColumns[?(@.name=='email')]"`) against `refRoot` —
-// the config-path's own sibling fields, not another file. This is
-// deliberately narrower than `template`'s YAML `$ref` (processed by
-// `processReferencedObject`/`getRefConfig`, which loads another config
-// file): an override-array `$ref` only ever supports the `#<jsonpath>`
-// self-reference form, resolved with the already-vendored `jsonpath`
-// package (the same one `applyConfigPathOverride` uses for `subPath`
-// strings). A ref that doesn't start with `#`, resolves to nothing, or
-// resolves to a non-object is treated the same as any other unresolved
-// override reference elsewhere in this module — silently dropped rather
-// than thrown, so a stale reference just doesn't round-trip into the next
-// save. Multiple matches take the first, in JSONPath document order.
-//
-// The resolved object keeps the original fragment string under `ref` (not
-// `$ref` — GraphQL field names can't start with `$`) rather than dropping
-// it once resolved. Without this, a client re-saving the array unchanged
-// (e.g. reordering a different column) would have no way to tell this
-// element apart from a plain inline column and would flatten it back into
-// a frozen copy on that save — exactly the staleness problem `$ref` exists
-// to avoid. `Column.ref` (the GraphQL field) surfaces it back to the client
-// so `docupace-ui-main` can keep re-emitting the same `$ref` indefinitely.
-function resolveOverrideElementRef(item, refRoot) {
-    const ref = item.$ref;
-    if (!ref.startsWith('#')) {
-        return undefined;
-    }
-    const [match] = jp.query(refRoot, ref.slice(1));
-    if (match === null || typeof match !== 'object') {
-        return undefined;
-    }
-    const { $ref: _unusedRef, ...localOverrides } = item;
-    return {
-        ...match,
-        ...localOverrides,
-        ref,
-    };
-}
-// Expands any `$ref` elements of a config-path override array into the
-// full object they point at (merged with whatever local attributes the
-// element carries alongside `$ref`, e.g. `visible`) before the array is
-// handed to `mergeSubPathOverrideValue`. Runs first so that a `{ $ref,
-// visible }` stub — which has no `name` of its own — always arrives at the
-// name-keyed merge as a proper named object; `mergeSubPathOverrideValue`
-// itself needs no `$ref` awareness.
-function expandRefOverrideElements(value, refRoot) {
-    if (!Array.isArray(value)) {
-        return value;
-    }
-    return value
-        .map((item) => isRefElement(item) ? resolveOverrideElementRef(item, refRoot) : item)
-        .filter((item) => item !== undefined);
-}
-// Builds the object a config-path override's `$ref` fragments resolve
-// against: the config being overridden, overlaid with the *raw* (not yet
-// merged) override value of every other simple top-level subPath in this
-// same patch (e.g. `$.predefinedColumns`). Using the raw override value
-// rather than depending on loop order elsewhere in
-// `applyConfigPathOverride` means a `$.columns` override's `$ref` into
-// `$.predefinedColumns` resolves correctly regardless of which subPath
-// happens to be processed first. Only single-segment paths (`$.foo`) are
-// overlaid — nested subPaths (`$.filter.criteria`) fall back to whatever
-// value is already on `config`, which is fine since nothing currently
-// needs to `$ref` into a nested subPath.
-//
-// `subPathPatch` (the `all` half of `SubPathOverrideLayers`) carries an
-// *ordered* array of layers per jsonPath
-// (broadest to narrowest — see `ConfigurationOverrideResult.subPaths`), not
-// a single already-resolved value. The overlay uses only the narrowest
-// (last) layer, same approximation as before cascading existed: a catalog
-// like `$.predefinedColumns`/`$.predefinedFilters` is always saved as a full
-// replacement at a single scope in practice (never a partial patch spread
-// across tiers), so the narrowest present layer already *is* effectively
-// the whole value — exactly what this overlay used before this function
-// took an array at all.
-function buildRefResolutionRoot(config, subPathPatch) {
-    const overlay = {};
-    for (const [jsonPath, layers] of Object.entries(subPathPatch)) {
-        const topLevelMatch = /^\$\.([^.[]+)$/.exec(jsonPath);
-        if (topLevelMatch && layers.length) {
-            overlay[topLevelMatch[1]] = layers[layers.length - 1];
-        }
-    }
-    return { ...config, ...overlay };
-}
-// Normalizes a provider's resolve() result into the pair of folds
-// `applyConfigPathOverride` works with. `inherited` stays `null` (rather
-// than defaulting to `{}`) when the provider doesn't report it, so the
-// fallback there stays distinguishable from "reported, but this path has no
-// broader layer".
-function toSubPathOverrideLayers(override) {
-    if (!override.subPaths) {
-        return null;
-    }
-    return {
-        all: override.subPaths,
-        inherited: override.inheritedSubPaths ?? null,
-    };
-}
 export class ConfigFileStore {
     localPath;
     remotePath;
@@ -375,7 +155,6 @@ class ConfigService {
     configInjectorResolvers;
     providers;
     resolvers;
-    configurationOverrideProvider;
     constructor(model, configStores, extensionOptions = {}) {
         this.configStores = configStores;
         this.model = model;
@@ -388,8 +167,6 @@ class ConfigService {
         this.resolvers = extensionOptions.resolvers
             ? { ...extensionOptions.resolvers }
             : {};
-        this.configurationOverrideProvider =
-            extensionOptions.configurationOverrideProvider;
         if (this.model) {
             this.generateResolvers();
         }
@@ -455,34 +232,12 @@ class ConfigService {
         }
         return processedData;
     }
-    applyReferenceExtensions(processedData, referenceConfig) {
-        if (typeof referenceConfig?.extend !== 'object') {
-            return processedData;
-        }
-        const { extend } = referenceConfig;
-        for (const key in extend) {
-            const extensionValue = extend[key];
-            if (!Array.isArray(extensionValue)) {
-                throw new GraphQLError(`$ref.extend.${key} must be an array; received ${typeof extensionValue}`);
-            }
-            const baseValue = processedData[key];
-            if (baseValue === undefined) {
-                processedData[key] = extensionValue;
-                continue;
-            }
-            if (!Array.isArray(baseValue)) {
-                throw new GraphQLError(`$ref.extend.${key} can only extend an array property; "${key}" resolved to ${typeof baseValue}`);
-            }
-            processedData[key] = [...baseValue, ...extensionValue];
-        }
-        return processedData;
-    }
     async processReferencedObject(configPath, obj, context, values) {
         const referenceConfig = obj.$ref;
         const refConfigPath = typeof referenceConfig === 'object' && referenceConfig.refPath
             ? referenceConfig.refPath
             : referenceConfig;
-        const imageData = await this.processImageReference(refConfigPath, context);
+        const imageData = await this.processImageReference(refConfigPath);
         if (imageData) {
             return imageData;
         }
@@ -491,7 +246,6 @@ class ConfigService {
             ? this.updatePathValues(referencedData, referenceConfig.path)
             : referencedData;
         processedData = this.applyReferenceOverrides(processedData, referenceConfig);
-        processedData = this.applyReferenceExtensions(processedData, referenceConfig);
         processedData = await this.processObjectExpressions(processedData, values, context);
         return this.processObject(configPath, processedData, context, values);
     }
@@ -508,16 +262,7 @@ class ConfigService {
             const builtInQueryResolvers = {
                 pages: () => ({
                     getPageConfig: async (obj, context) => {
-                        // `impersonateRoleId`/`impersonateGeneral` are a plain
-                        // pass-through onto context here — this engine never inspects
-                        // identity itself; the host's resolveCurrentIdentity is what
-                        // interprets them and enforces the admin-only restriction.
-                        const impersonation = obj.impersonateRoleId
-                            ? { impersonateRoleId: obj.impersonateRoleId }
-                            : obj.impersonateGeneral
-                                ? { impersonateGeneral: true }
-                                : null;
-                        const pageConfig = await this.getPageConfig(obj.path, impersonation ? { ...context, ...impersonation } : context, true, obj.context);
+                        const pageConfig = await this.getPageConfig(obj.path, context, true, obj.context);
                         return pageConfig;
                     },
                     getAIConfig: async (obj, context) => {
@@ -601,37 +346,29 @@ class ConfigService {
             return deepMergeResolvers(builtInMutationResolvers, hostMutationResolvers);
         };
     }
-    // Applies any stored config-path sub-path overrides across the whole
-    // config tree before processConfig's own recursive walk runs, so that
-    // overridden values (which may introduce new sub-config) still go
-    // through provider injection/__typename dispatch below.
-    //
-    // rootSubPathOverrides lets a caller that already resolved overrides for
-    // the root config (e.g. getConfigFromStore, which fetches the whole-object
-    // and sub-path overrides together in one round trip) hand them in directly
-    // instead of having the root node re-resolved a second time below; nested
-    // nodes discovered deeper in the tree are still resolved individually,
-    // since their configPaths aren't known until the tree has been loaded.
-    async processConfig(config, context, processProviders, rootSubPathOverrides) {
-        const overriddenConfig = await this.applyConfigPathOverride(config, context, processProviders, rootSubPathOverrides);
-        return this.processConfigTree(overriddenConfig, context, processProviders);
-    }
-    async processConfigTree(config, context, processProviders) {
+    async processConfig(config, context, processProviders) {
         if (!config) {
             return config;
         }
         // Handle arrays
         if (Array.isArray(config)) {
-            return Promise.all(config.map((item) => this.processConfigTree(item, context, processProviders)));
+            return Promise.all(config.map((item) => this.processConfig(item, context, processProviders)));
         }
         // Handle objects
         if (typeof config === 'object') {
             // Recursively process all properties of config
             let processedConfig = { ...config };
             for (const key in processedConfig) {
-                processedConfig[key] = await this.processConfigTree(processedConfig[key], context, processProviders);
+                processedConfig[key] = await this.processConfig(processedConfig[key], context, processProviders);
+            }
+            // First process the current object if it has __typename
+            if (processedConfig?.__typename && processProviders) {
+                const providerClass = this.providers[processedConfig.__typename];
+                if (providerClass) {
+                    const provider = new providerClass();
+                    processedConfig = await provider.processConfig(processedConfig, this, context);
+                }
             }
-            processedConfig = await this.applyTypenameProvider(processedConfig, context, processProviders);
             return processedConfig;
         }
         if (processProviders) {
@@ -639,104 +376,6 @@ class ConfigService {
         }
         return config;
     }
-    // Walks the whole config tree up front (pre-order) and, for every object
-    // that declares a configPath, deep-sets any stored sub-path overrides
-    // (JSONPath-addressed, e.g. "$.columns" or "$.filter.criteria").
-    //
-    // preFetchedSubPaths is only honored for the root node of the walk (the
-    // one being called with a defined third argument); nested calls always
-    // omit it so their own configPath gets resolved fresh.
-    async applyConfigPathOverride(config, context, processProviders, preFetchedSubPaths) {
-        if (!config) {
-            return config;
-        }
-        if (Array.isArray(config)) {
-            return Promise.all(config.map((item) => this.applyConfigPathOverride(item, context, processProviders)));
-        }
-        if (typeof config !== 'object') {
-            return config;
-        }
-        let result = config;
-        if (processProviders) {
-            const subPathPatch = preFetchedSubPaths !== undefined
-                ? preFetchedSubPaths
-                : result.configPath && this.configurationOverrideProvider
-                    ? toSubPathOverrideLayers(await this.configurationOverrideProvider.resolve(result.configPath, context))
-                    : null;
-            if (subPathPatch) {
-                const refRoot = buildRefResolutionRoot(result, subPathPatch.all);
-                // Deep-clone once, up front — `jp.value` mutates its target in
-                // place, and a shallow `{ ...result }` per jsonPath only protects
-                // the top level. A nested subPath (e.g. `$.filter.criteria`) would
-                // otherwise still mutate `result.filter`, which is the *same*
-                // object reference as the original, potentially-shared config
-                // (e.g. reused across tables via `extend`/fragment composition).
-                // Config values are always plain JSON (from YAML/domain storage),
-                // so a JSON round-trip clone is sufficient and avoids
-                // `structuredClone`'s cross-realm `instanceof` pitfalls (its output
-                // fails `instanceof Object` checks — e.g. inside the `jsonpath`
-                // package — when the calling code runs in a different VM
-                // realm/context, as test sandboxes commonly do).
-                result = JSON.parse(JSON.stringify(result));
-                for (const [jsonPath, layers] of Object.entries(subPathPatch.all)) {
-                    // A single malformed override (an unparseable `$ref` JSONPath, or
-                    // a jsonPath that doesn't resolve to a settable location) must not
-                    // abort resolution of the rest of this config tree — that would
-                    // take down the page for every user over one bad admin-authored
-                    // row. Log and skip just this jsonPath instead.
-                    try {
-                        const currentValue = jp.value(result, jsonPath);
-                        const expandedLayers = layers.map((layer) => expandRefOverrideElements(layer, refRoot));
-                        // `layers` is ordered broadest to narrowest (general, tenant,
-                        // role, user — see `ConfigurationOverrideResult.subPaths`), so
-                        // folding them in order onto `currentValue` cascades correctly:
-                        // each layer only patches what it mentions, inheriting
-                        // everything else from the fold so far.
-                        const mergedValue = expandedLayers.reduce(mergeSubPathOverrideValue, currentValue);
-                        // The same fold minus the identity's own-scope layer — "what
-                        // this identity would see with no override of its own", which
-                        // is what `inherited` is stamped against. The provider reports
-                        // those layers explicitly (`inheritedSubPaths`) because the
-                        // tier a layer is stored at isn't recoverable from the values
-                        // alone; dropping the last layer is only a fallback for a
-                        // provider that doesn't, and is wrong whenever the identity has
-                        // no row of its own yet (the layer dropped is then a broader
-                        // one that very much still applies).
-                        const inheritedLayers = subPathPatch.inherited
-                            ? (subPathPatch.inherited[jsonPath] ?? [])
-                            : layers.slice(0, -1);
-                        const withoutOwnScope = inheritedLayers
-                            .map((layer) => expandRefOverrideElements(layer, refRoot))
-                            .reduce(mergeSubPathOverrideValue, currentValue);
-                        const finalValue = stampInherited(mergedValue, withoutOwnScope);
-                        const applied = jp.value(result, jsonPath, finalValue);
-                        if (applied === undefined) {
-                            throw new Error(`does not resolve to a settable location: "${jsonPath}"`);
-                        }
-                    }
-                    catch (error) {
-                        log.warn(`Skipping configuration override for "${result.configPath}" at "${jsonPath}": ${error.message}`);
-                    }
-                }
-            }
-        }
-        const overriddenEntries = await Promise.all(Object.entries(result).map(async ([key, value]) => [
-            key,
-            await this.applyConfigPathOverride(value, context, processProviders),
-        ]));
-        return Object.fromEntries(overriddenEntries);
-    }
-    async applyTypenameProvider(processedConfig, context, processProviders) {
-        if (!processedConfig?.__typename || !processProviders) {
-            return processedConfig;
-        }
-        const providerClass = this.providers[processedConfig.__typename];
-        if (!providerClass) {
-            return processedConfig;
-        }
-        const provider = new providerClass();
-        return await provider.processConfig(processedConfig, this, context);
-    }
     async getRefConfig(configPath, refConfigPath, context, values) {
         let fullPath;
         if (refConfigPath.startsWith('.')) {
@@ -823,21 +462,13 @@ class ConfigService {
         };
         return await processValue(object);
     }
-    async processImageReference(refConfigPath, context) {
+    async processImageReference(refConfigPath) {
         const SUPPORTED_IMAGE_FORMATS = ['.jpg', '.jpeg', '.png', '.svg'];
         // Check if the reference is an image file
         const ext = path.extname(refConfigPath).toLowerCase();
         if (!SUPPORTED_IMAGE_FORMATS.includes(ext)) {
             return null;
         }
-        const override = await this.configurationOverrideProvider?.resolve(refConfigPath, context);
-        if (override?.whole?.contentType) {
-            return {
-                data: override.whole.value,
-                mimeType: override.whole.contentType,
-                hash: createHash('sha256').update(override.whole.value).digest('hex'),
-            };
-        }
         let standardStore;
         for (const store of this.configStores) {
             if (store instanceof ConfigFileStore) {
@@ -889,33 +520,19 @@ class ConfigService {
                 return 'application/octet-stream';
         }
     }
-    // Resolves the whole-object override and any sub-path overrides for
-    // configPath together, in one provider round trip, instead of fetching
-    // them separately at different points of the processing pipeline. The
-    // sub-path overrides are handed back alongside the config so callers can
-    // thread them into processConfig rather than re-resolving them later.
-    async getConfigFromStore(configPath, context) {
-        const override = await this.configurationOverrideProvider?.resolve(configPath, context);
-        const subPathOverrides = override
-            ? toSubPathOverrideLayers(override)
-            : null;
-        if (override?.whole && !override.whole.contentType) {
-            return { config: load(override.whole.value), subPathOverrides };
-        }
+    async getConfigFromStore(path) {
         const exceptions = [];
         for (const [index, configStore] of this.configStores.entries()) {
             try {
-                const config = await configStore.getConfig(configPath);
-                return { config, subPathOverrides };
+                return await configStore.getConfig(path);
             }
             catch (e) {
                 exceptions.push(e);
                 if (index == this.configStores.length - 1) {
-                    throw new GraphQLError(`Config not found in path in any store: ${configPath}`, { originalError: exceptions });
+                    throw new GraphQLError(`Config not found in path in any store: ${path}`, { originalError: exceptions });
                 }
             }
         }
-        return { config: undefined, subPathOverrides };
     }
     async hasConfig(configPath) {
         return (await Promise.all(this.configStores.map((configStore) => configStore.hasConfig(configPath)))).some(Boolean);
@@ -925,9 +542,9 @@ class ConfigService {
         return this.getDirectConfig(globalPath, context, values, processProviders);
     }
     async getDirectConfig(configPath, context, values, processProviders) {
-        const { config: obj, subPathOverrides } = await this.getConfigFromStore(configPath, context);
+        const obj = await this.getConfigFromStore(configPath);
         const fullObj = await this.processObject(configPath, obj, context, values);
-        const processedObj = await this.processConfig(fullObj, context, processProviders, subPathOverrides);
+        const processedObj = await this.processConfig(fullObj, context, processProviders);
         return processedObj;
     }
     async listDirectConfigs(configPath) {
@@ -1278,22 +895,21 @@ class ConfigService {
     }
     async getPageConfig(pagePath, context, processConfig, rulesContext) {
         const globalPath = path.join('global', 'pages', pagePath);
-        const { config: obj, subPathOverrides } = await this.getConfigFromStore(globalPath, context);
+        const obj = await this.getConfigFromStore(globalPath);
         const fullObj = await this.processObject(globalPath, obj, context, null);
         const matchingRuleGroups = await this.getRuleGroups(rulesContext, context);
         const configToProcess = this.applyFieldRuleOverrides(fullObj, matchingRuleGroups);
-        return await this.processConfig(configToProcess, context, processConfig, subPathOverrides);
+        return await this.processConfig(configToProcess, context, processConfig);
     }
     async init() {
         return Promise.all(this.configStores.map((configStore) => configStore.init()));
     }
 }
-export const defaultConfigService = ({ model, configStores, configInjectorResolvers, providers, resolvers, configurationOverrideProvider, }) => {
+export const defaultConfigService = ({ model, configStores, configInjectorResolvers, providers, resolvers, }) => {
     const extensionOptions = {
         configInjectorResolvers,
         providers,
         resolvers,
-        configurationOverrideProvider,
     };
     return new ConfigService(model, configStores.map((configStore) => new ConfigFileStore(configStore)), extensionOptions);
 };