kintone-migrator 0.21.4 → 0.22.0

package/dist/index.mjs

@@ -625,31 +625,36 @@ function isNodeError(error) {
 }
 
 //#endregion
-//#region src/core/adapters/local/actionStorage.ts
-var LocalFileActionStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read action file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write action file: ${this.filePath}`, error);
+//#region src/core/adapters/local/storage.ts
+function createLocalFileStorage(filePath, label = "file") {
+	return {
+		async get() {
+			try {
+				return {
+					exists: true,
+					content: await readFile(filePath, "utf-8")
+				};
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
+				throw new SystemError(SystemErrorCode.StorageError, `Failed to read ${label}: ${filePath}`, error);
+			}
+		},
+		async update(content) {
+			try {
+				await mkdir(dirname(filePath), { recursive: true });
+				await writeFile(filePath, content, "utf-8");
+			} catch (error) {
+				throw new SystemError(SystemErrorCode.StorageError, `Failed to write ${label}: ${filePath}`, error);
+			}
 		}
-	}
-};
+	};
+}
+
+//#endregion
+//#region src/core/adapters/local/actionStorage.ts
+function createLocalFileActionStorage(filePath) {
+	return createLocalFileStorage(filePath, "action file");
+}
 
 //#endregion
 //#region src/core/adapters/kintone/customizationConfigurator.ts
@@ -1379,30 +1384,9 @@ var KintoneRecordManager = class {
 
 //#endregion
 //#region src/core/adapters/local/customizationStorage.ts
-var LocalFileCustomizationStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read customization config file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write customization config file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileCustomizationStorage(filePath) {
+	return createLocalFileStorage(filePath, "customization config file");
+}
 
 //#endregion
 //#region src/core/adapters/local/fileWriter.ts
@@ -1419,57 +1403,15 @@ var LocalFileWriter = class {
 
 //#endregion
 //#region src/core/adapters/local/schemaStorage.ts
-var LocalFileSchemaStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read schema file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write schema file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileSchemaStorage(filePath) {
+	return createLocalFileStorage(filePath, "schema file");
+}
 
 //#endregion
 //#region src/core/adapters/local/seedStorage.ts
-var LocalFileSeedStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read seed file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write seed file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileSeedStorage(filePath) {
+	return createLocalFileStorage(filePath, "seed file");
+}
 
 //#endregion
 //#region src/core/application/container/cli.ts
@@ -1488,7 +1430,7 @@ function createCliContainer(config) {
 	});
 	return {
 		formConfigurator: new KintoneFormConfigurator(client, config.appId),
-		schemaStorage: new LocalFileSchemaStorage(config.schemaFilePath),
+		schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -1499,7 +1441,7 @@ function createSeedCliContainer(config) {
 			auth: buildKintoneAuth(config.auth),
 			guestSpaceId: config.guestSpaceId
 		}), config.appId),
-		seedStorage: new LocalFileSeedStorage(config.seedFilePath)
+		seedStorage: createLocalFileSeedStorage(config.seedFilePath)
 	};
 }
 function createCustomizationCliContainer(config) {
@@ -1510,7 +1452,7 @@ function createCustomizationCliContainer(config) {
 	});
 	return {
 		customizationConfigurator: new KintoneCustomizationConfigurator(client, config.appId),
-		customizationStorage: new LocalFileCustomizationStorage(config.customizeFilePath),
+		customizationStorage: createLocalFileCustomizationStorage(config.customizeFilePath),
 		fileUploader: new KintoneFileUploader(client),
 		fileDownloader: new KintoneFileDownloader(client),
 		fileWriter: new LocalFileWriter(),
@@ -1528,7 +1470,7 @@ function createActionCliContainer(config) {
 	});
 	return {
 		actionConfigurator: new KintoneActionConfigurator(client, config.appId),
-		actionStorage: new LocalFileActionStorage(config.actionFilePath),
+		actionStorage: createLocalFileActionStorage(config.actionFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -2237,6 +2179,55 @@ function resolveFilePath(options) {
 	return options.cliValue ?? options.envVar ?? (options.app && options.appFileField?.(options.app)) ?? (options.app ? join(options.defaultDir, `${options.app.name}.yaml`) : options.defaultFileName);
 }
 
+//#endregion
+//#region src/cli/createDomainConfigResolver.ts
+/**
+* Factory that eliminates per-domain boilerplate for CLI config resolution.
+*
+* Returns three functions — `resolveFilePath`, `resolveContainerConfig`, and
+* `resolveAppContainerConfig` — whose behavior is driven by the supplied
+* domain-specific options.
+*
+* `envVar` is a thunk (not a plain value) so that `process.env` look-ups
+* happen at call time rather than at module-load time, which keeps tests
+* deterministic and respects runtime env overrides.
+*/
+function createDomainConfigResolver(options) {
+	function resolveDomainFilePath(cliValues, app) {
+		return resolveFilePath({
+			cliValue: cliValues[options.fileArgKey],
+			envVar: options.envVar(),
+			appFileField: options.appFileField,
+			app,
+			defaultDir: options.defaultDir,
+			defaultFileName: options.defaultFileName
+		});
+	}
+	function resolveContainerConfig(cliValues) {
+		const config = resolveConfig(cliValues);
+		return options.buildConfig({
+			baseUrl: config.baseUrl,
+			auth: config.auth,
+			appId: config.appId,
+			guestSpaceId: config.guestSpaceId
+		}, resolveDomainFilePath(cliValues));
+	}
+	function resolveAppContainerConfig(app, projectConfig, cliValues) {
+		const config = resolveAppCliConfig(app, projectConfig, cliValues);
+		return options.buildConfig({
+			baseUrl: config.baseUrl,
+			auth: config.auth,
+			appId: config.appId,
+			guestSpaceId: config.guestSpaceId
+		}, resolveDomainFilePath(cliValues, app));
+	}
+	return {
+		resolveFilePath: resolveDomainFilePath,
+		resolveContainerConfig,
+		resolveAppContainerConfig
+	};
+}
+
 //#endregion
 //#region src/cli/actionConfig.ts
 const actionArgs = {
@@ -2247,36 +2238,17 @@ const actionArgs = {
 		description: "Action file path (default: actions.yaml)"
 	}
 };
-function resolveActionFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["action-file"],
-		envVar: process.env.ACTION_FILE_PATH,
-		appFileField: (a) => a.actionFile,
-		app,
-		defaultDir: "action",
-		defaultFileName: "actions.yaml"
-	});
-}
-function resolveActionContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		actionFilePath: resolveActionFilePath(cliValues)
-	};
-}
-function resolveActionAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		actionFilePath: resolveActionFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveActionFilePath, resolveContainerConfig: resolveActionContainerConfig, resolveAppContainerConfig: resolveActionAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "action-file",
+	envVar: () => process.env.ACTION_FILE_PATH,
+	appFileField: (a) => a.actionFile,
+	defaultDir: "action",
+	defaultFileName: "actions.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		actionFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/action/apply.ts
@@ -2522,30 +2494,9 @@ var KintoneAdminNotesConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/adminNotesStorage.ts
-var LocalFileAdminNotesStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read admin notes file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write admin notes file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileAdminNotesStorage(filePath) {
+	return createLocalFileStorage(filePath, "admin notes file");
+}
 
 //#endregion
 //#region src/core/application/container/adminNotesCli.ts
@@ -2557,7 +2508,7 @@ function createAdminNotesCliContainer(config) {
 	});
 	return {
 		adminNotesConfigurator: new KintoneAdminNotesConfigurator(client, config.appId),
-		adminNotesStorage: new LocalFileAdminNotesStorage(config.adminNotesFilePath),
+		adminNotesStorage: createLocalFileAdminNotesStorage(config.adminNotesFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -2572,36 +2523,17 @@ const adminNotesArgs = {
 		description: "Admin notes file path (default: admin-notes.yaml)"
 	}
 };
-function resolveAdminNotesFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["admin-notes-file"],
-		envVar: process.env.ADMIN_NOTES_FILE_PATH,
-		appFileField: (a) => a.adminNotesFile,
-		app,
-		defaultDir: "admin-notes",
-		defaultFileName: "admin-notes.yaml"
-	});
-}
-function resolveAdminNotesContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		adminNotesFilePath: resolveAdminNotesFilePath(cliValues)
-	};
-}
-function resolveAdminNotesAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		adminNotesFilePath: resolveAdminNotesFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveAdminNotesFilePath, resolveContainerConfig: resolveAdminNotesContainerConfig, resolveAppContainerConfig: resolveAdminNotesAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "admin-notes-file",
+	envVar: () => process.env.ADMIN_NOTES_FILE_PATH,
+	appFileField: (a) => a.adminNotesFile,
+	defaultDir: "admin-notes",
+	defaultFileName: "admin-notes.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		adminNotesFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/admin-notes/apply.ts
@@ -2903,30 +2835,9 @@ var KintoneAppPermissionConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/appPermissionStorage.ts
-var LocalFileAppPermissionStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read app permission file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write app permission file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileAppPermissionStorage(filePath) {
+	return createLocalFileStorage(filePath, "app permission file");
+}
 
 //#endregion
 //#region src/core/application/container/appPermissionCli.ts
@@ -2938,7 +2849,7 @@ function createAppPermissionCliContainer(config) {
 	});
 	return {
 		appPermissionConfigurator: new KintoneAppPermissionConfigurator(client, config.appId),
-		appPermissionStorage: new LocalFileAppPermissionStorage(config.appAclFilePath),
+		appPermissionStorage: createLocalFileAppPermissionStorage(config.appAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -2953,36 +2864,17 @@ const appAclArgs = {
 		description: "App ACL file path (default: app-acl.yaml)"
 	}
 };
-function resolveAppAclFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["app-acl-file"],
-		envVar: process.env.APP_ACL_FILE_PATH,
-		appFileField: (a) => a.appAclFile,
-		app,
-		defaultDir: "app-acl",
-		defaultFileName: "app-acl.yaml"
-	});
-}
-function resolveAppAclContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		appAclFilePath: resolveAppAclFilePath(cliValues)
-	};
-}
-function resolveAppAclAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		appAclFilePath: resolveAppAclFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveAppAclFilePath, resolveContainerConfig: resolveAppAclContainerConfig, resolveAppContainerConfig: resolveAppAclAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "app-acl-file",
+	envVar: () => process.env.APP_ACL_FILE_PATH,
+	appFileField: (a) => a.appAclFile,
+	defaultDir: "app-acl",
+	defaultFileName: "app-acl.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		appAclFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/app-acl/apply.ts
@@ -3292,36 +3184,17 @@ const customizeArgs = {
 		description: "Customization config file path (default: customize.yaml)"
 	}
 };
-function resolveCustomizeFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["customize-file"],
-		envVar: process.env.CUSTOMIZE_FILE_PATH,
-		appFileField: (a) => a.customizeFile,
-		app,
-		defaultDir: "customize",
-		defaultFileName: "customize.yaml"
-	});
-}
-function resolveCustomizeConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		customizeFilePath: resolveCustomizeFilePath(cliValues)
-	};
-}
-function resolveCustomizeAppConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		customizeFilePath: resolveCustomizeFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveCustomizeFilePath, resolveContainerConfig: resolveCustomizeConfig, resolveAppContainerConfig: resolveCustomizeAppConfig } = createDomainConfigResolver({
+	fileArgKey: "customize-file",
+	envVar: () => process.env.CUSTOMIZE_FILE_PATH,
+	appFileField: (a) => a.customizeFile,
+	defaultDir: "customize",
+	defaultFileName: "customize.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		customizeFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/core/domain/customization/services/configSerializer.ts
@@ -3720,30 +3593,9 @@ var KintoneFieldPermissionConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/fieldPermissionStorage.ts
-var LocalFileFieldPermissionStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read field permission file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write field permission file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileFieldPermissionStorage(filePath) {
+	return createLocalFileStorage(filePath, "field permission file");
+}
 
 //#endregion
 //#region src/core/application/container/fieldPermissionCli.ts
@@ -3755,7 +3607,7 @@ function createFieldPermissionCliContainer(config) {
 	});
 	return {
 		fieldPermissionConfigurator: new KintoneFieldPermissionConfigurator(client, config.appId),
-		fieldPermissionStorage: new LocalFileFieldPermissionStorage(config.fieldAclFilePath),
+		fieldPermissionStorage: createLocalFileFieldPermissionStorage(config.fieldAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -3858,36 +3710,17 @@ const fieldAclArgs = {
 		description: "Field ACL file path (default: field-acl.yaml)"
 	}
 };
-function resolveFieldAclFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["field-acl-file"],
-		envVar: process.env.FIELD_ACL_FILE_PATH,
-		appFileField: (a) => a.fieldAclFile,
-		app,
-		defaultDir: "field-acl",
-		defaultFileName: "field-acl.yaml"
-	});
-}
-function resolveFieldAclContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		fieldAclFilePath: resolveFieldAclFilePath(cliValues)
-	};
-}
-function resolveFieldAclAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		fieldAclFilePath: resolveFieldAclFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveFieldAclFilePath, resolveContainerConfig: resolveFieldAclContainerConfig, resolveAppContainerConfig: resolveFieldAclAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "field-acl-file",
+	envVar: () => process.env.FIELD_ACL_FILE_PATH,
+	appFileField: (a) => a.fieldAclFile,
+	defaultDir: "field-acl",
+	defaultFileName: "field-acl.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		fieldAclFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/field-acl/apply.ts
@@ -4169,30 +4002,9 @@ var KintoneGeneralSettingsConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/generalSettingsStorage.ts
-var LocalFileGeneralSettingsStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read general settings file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write general settings file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileGeneralSettingsStorage(filePath) {
+	return createLocalFileStorage(filePath, "general settings file");
+}
 
 //#endregion
 //#region src/core/application/container/generalSettingsCli.ts
@@ -4204,7 +4016,7 @@ function createGeneralSettingsCliContainer(config) {
 	});
 	return {
 		generalSettingsConfigurator: new KintoneGeneralSettingsConfigurator(client, config.appId),
-		generalSettingsStorage: new LocalFileGeneralSettingsStorage(config.settingsFilePath),
+		generalSettingsStorage: createLocalFileGeneralSettingsStorage(config.settingsFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -4438,30 +4250,9 @@ var KintoneNotificationConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/notificationStorage.ts
-var LocalFileNotificationStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read notification file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write notification file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileNotificationStorage(filePath) {
+	return createLocalFileStorage(filePath, "notification file");
+}
 
 //#endregion
 //#region src/core/application/container/notificationCli.ts
@@ -4473,7 +4264,7 @@ function createNotificationCliContainer(config) {
 	});
 	return {
 		notificationConfigurator: new KintoneNotificationConfigurator(client, config.appId),
-		notificationStorage: new LocalFileNotificationStorage(config.notificationFilePath),
+		notificationStorage: createLocalFileNotificationStorage(config.notificationFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -4522,30 +4313,9 @@ var KintonePluginConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/pluginStorage.ts
-var LocalFilePluginStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read plugin file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write plugin file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFilePluginStorage(filePath) {
+	return createLocalFileStorage(filePath, "plugin file");
+}
 
 //#endregion
 //#region src/core/application/container/pluginCli.ts
@@ -4557,7 +4327,7 @@ function createPluginCliContainer(config) {
 	});
 	return {
 		pluginConfigurator: new KintonePluginConfigurator(client, config.appId),
-		pluginStorage: new LocalFilePluginStorage(config.pluginFilePath),
+		pluginStorage: createLocalFilePluginStorage(config.pluginFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -4700,30 +4470,9 @@ var KintoneProcessManagementConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/processManagementStorage.ts
-var LocalFileProcessManagementStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read process management file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write process management file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileProcessManagementStorage(filePath) {
+	return createLocalFileStorage(filePath, "process management file");
+}
 
 //#endregion
 //#region src/core/application/container/processManagementCli.ts
@@ -4735,7 +4484,7 @@ function createProcessManagementCliContainer(config) {
 	});
 	return {
 		processManagementConfigurator: new KintoneProcessManagementConfigurator(client, config.appId),
-		processManagementStorage: new LocalFileProcessManagementStorage(config.processFilePath),
+		processManagementStorage: createLocalFileProcessManagementStorage(config.processFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -4824,30 +4573,9 @@ var KintoneRecordPermissionConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/recordPermissionStorage.ts
-var LocalFileRecordPermissionStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read record permission file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write record permission file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileRecordPermissionStorage(filePath) {
+	return createLocalFileStorage(filePath, "record permission file");
+}
 
 //#endregion
 //#region src/core/application/container/recordPermissionCli.ts
@@ -4859,7 +4587,7 @@ function createRecordPermissionCliContainer(config) {
 	});
 	return {
 		recordPermissionConfigurator: new KintoneRecordPermissionConfigurator(client, config.appId),
-		recordPermissionStorage: new LocalFileRecordPermissionStorage(config.recordAclFilePath),
+		recordPermissionStorage: createLocalFileRecordPermissionStorage(config.recordAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -5081,30 +4809,9 @@ var KintoneReportConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/reportStorage.ts
-var LocalFileReportStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read report file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write report file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileReportStorage(filePath) {
+	return createLocalFileStorage(filePath, "report file");
+}
 
 //#endregion
 //#region src/core/application/container/reportCli.ts
@@ -5116,7 +4823,7 @@ function createReportCliContainer(config) {
 	});
 	return {
 		reportConfigurator: new KintoneReportConfigurator(client, config.appId),
-		reportStorage: new LocalFileReportStorage(config.reportFilePath),
+		reportStorage: createLocalFileReportStorage(config.reportFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -5216,30 +4923,9 @@ var KintoneViewConfigurator = class {
 
 //#endregion
 //#region src/core/adapters/local/viewStorage.ts
-var LocalFileViewStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read view file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write view file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileViewStorage(filePath) {
+	return createLocalFileStorage(filePath, "view file");
+}
 
 //#endregion
 //#region src/core/application/container/viewCli.ts
@@ -5251,7 +4937,7 @@ function createViewCliContainer(config) {
 	});
 	return {
 		viewConfigurator: new KintoneViewConfigurator(client, config.appId),
-		viewStorage: new LocalFileViewStorage(config.viewFilePath),
+		viewStorage: createLocalFileViewStorage(config.viewFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
 	};
 }
@@ -5376,30 +5062,9 @@ var KintoneSpaceReader = class {
 
 //#endregion
 //#region src/core/adapters/local/projectConfigStorage.ts
-var LocalFileProjectConfigStorage = class {
-	constructor(filePath) {
-		this.filePath = filePath;
-	}
-	async get() {
-		try {
-			return {
-				exists: true,
-				content: await readFile(this.filePath, "utf-8")
-			};
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { exists: false };
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to read project config file: ${this.filePath}`, error);
-		}
-	}
-	async update(content) {
-		try {
-			await mkdir(dirname(this.filePath), { recursive: true });
-			await writeFile(this.filePath, content, "utf-8");
-		} catch (error) {
-			throw new SystemError(SystemErrorCode.StorageError, `Failed to write project config file: ${this.filePath}`, error);
-		}
-	}
-};
+function createLocalFileProjectConfigStorage(filePath) {
+	return createLocalFileStorage(filePath, "project config file");
+}
 
 //#endregion
 //#region src/core/application/container/initCli.ts
@@ -5410,7 +5075,7 @@ function createInitCliContainer(config) {
 			auth: buildKintoneAuth(config.auth),
 			guestSpaceId: config.guestSpaceId
 		})),
-		projectConfigStorage: new LocalFileProjectConfigStorage(config.configFilePath)
+		projectConfigStorage: createLocalFileProjectConfigStorage(config.configFilePath)
 	};
 }
 
@@ -6534,36 +6199,17 @@ const notificationArgs = {
 		description: "Notification file path (default: notification.yaml)"
 	}
 };
-function resolveNotificationFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["notification-file"],
-		envVar: process.env.NOTIFICATION_FILE_PATH,
-		appFileField: (a) => a.notificationFile,
-		app,
-		defaultDir: "notification",
-		defaultFileName: "notification.yaml"
-	});
-}
-function resolveNotificationContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		notificationFilePath: resolveNotificationFilePath(cliValues)
-	};
-}
-function resolveNotificationAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		notificationFilePath: resolveNotificationFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveNotificationFilePath, resolveContainerConfig: resolveNotificationContainerConfig, resolveAppContainerConfig: resolveNotificationAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "notification-file",
+	envVar: () => process.env.NOTIFICATION_FILE_PATH,
+	appFileField: (a) => a.notificationFile,
+	defaultDir: "notification",
+	defaultFileName: "notification.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		notificationFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/notification/apply.ts
@@ -6723,36 +6369,17 @@ const pluginArgs = {
 		description: "Plugin file path (default: plugins.yaml)"
 	}
 };
-function resolvePluginFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["plugin-file"],
-		envVar: process.env.PLUGIN_FILE_PATH,
-		appFileField: (a) => a.pluginFile,
-		app,
-		defaultDir: "plugin",
-		defaultFileName: "plugins.yaml"
-	});
-}
-function resolvePluginContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		pluginFilePath: resolvePluginFilePath(cliValues)
-	};
-}
-function resolvePluginAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		pluginFilePath: resolvePluginFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolvePluginFilePath, resolveContainerConfig: resolvePluginContainerConfig, resolveAppContainerConfig: resolvePluginAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "plugin-file",
+	envVar: () => process.env.PLUGIN_FILE_PATH,
+	appFileField: (a) => a.pluginFile,
+	defaultDir: "plugin",
+	defaultFileName: "plugins.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		pluginFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/plugin/apply.ts
@@ -6998,36 +6625,17 @@ const processArgs = {
 		description: "Process management file path (default: process.yaml)"
 	}
 };
-function resolveProcessFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["process-file"],
-		envVar: process.env.PROCESS_FILE_PATH,
-		appFileField: (a) => a.processFile,
-		app,
-		defaultDir: "process",
-		defaultFileName: "process.yaml"
-	});
-}
-function resolveProcessContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		processFilePath: resolveProcessFilePath(cliValues)
-	};
-}
-function resolveProcessAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		processFilePath: resolveProcessFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveProcessFilePath, resolveContainerConfig: resolveProcessContainerConfig, resolveAppContainerConfig: resolveProcessAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "process-file",
+	envVar: () => process.env.PROCESS_FILE_PATH,
+	appFileField: (a) => a.processFile,
+	defaultDir: "process",
+	defaultFileName: "process.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		processFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/process/apply.ts
@@ -7377,36 +6985,17 @@ const recordAclArgs = {
 		description: "Record ACL file path (default: record-acl.yaml)"
 	}
 };
-function resolveRecordAclFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["record-acl-file"],
-		envVar: process.env.RECORD_ACL_FILE_PATH,
-		appFileField: (a) => a.recordAclFile,
-		app,
-		defaultDir: "record-acl",
-		defaultFileName: "record-acl.yaml"
-	});
-}
-function resolveRecordAclContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		recordAclFilePath: resolveRecordAclFilePath(cliValues)
-	};
-}
-function resolveRecordAclAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		recordAclFilePath: resolveRecordAclFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveRecordAclFilePath, resolveContainerConfig: resolveRecordAclContainerConfig, resolveAppContainerConfig: resolveRecordAclAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "record-acl-file",
+	envVar: () => process.env.RECORD_ACL_FILE_PATH,
+	appFileField: (a) => a.recordAclFile,
+	defaultDir: "record-acl",
+	defaultFileName: "record-acl.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		recordAclFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/record-acl/apply.ts
@@ -7745,36 +7334,17 @@ const reportArgs = {
 		description: "Report file path (default: reports.yaml)"
 	}
 };
-function resolveReportFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["report-file"],
-		envVar: process.env.REPORT_FILE_PATH,
-		appFileField: (a) => a.reportFile,
-		app,
-		defaultDir: "report",
-		defaultFileName: "reports.yaml"
-	});
-}
-function resolveReportContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		reportFilePath: resolveReportFilePath(cliValues)
-	};
-}
-function resolveReportAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		reportFilePath: resolveReportFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveReportFilePath, resolveContainerConfig: resolveReportContainerConfig, resolveAppContainerConfig: resolveReportAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "report-file",
+	envVar: () => process.env.REPORT_FILE_PATH,
+	appFileField: (a) => a.reportFile,
+	defaultDir: "report",
+	defaultFileName: "reports.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		reportFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/report/apply.ts
@@ -9166,45 +8736,10 @@ var override_default = define({
 	}
 });
 
-//#endregion
-//#region src/core/adapters/empty/appDeployer.ts
-var EmptyAppDeployer = class {
-	async deploy() {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyAppDeployer.deploy not implemented");
-	}
-};
-
-//#endregion
-//#region src/core/adapters/empty/formConfigurator.ts
-var EmptyFormConfigurator = class {
-	async getFields() {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.getFields not implemented");
-	}
-	async addFields(_fields) {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.addFields not implemented");
-	}
-	async updateFields(_fields) {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.updateFields not implemented");
-	}
-	async deleteFields(_fieldCodes) {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.deleteFields not implemented");
-	}
-	async getLayout() {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.getLayout not implemented");
-	}
-	async updateLayout(_layout) {
-		throw new SystemError(SystemErrorCode.InternalServerError, "EmptyFormConfigurator.updateLayout not implemented");
-	}
-};
-
 //#endregion
 //#region src/core/application/container/validateCli.ts
 function createValidateCliContainer(config) {
-	return {
-		formConfigurator: new EmptyFormConfigurator(),
-		schemaStorage: new LocalFileSchemaStorage(config.schemaFilePath),
-		appDeployer: new EmptyAppDeployer()
-	};
+	return { schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath) };
 }
 
 //#endregion
@@ -9494,36 +9029,17 @@ async function upsertSeed({ container, input }) {
 
 //#endregion
 //#region src/cli/commands/seed/config.ts
-function resolveSeedFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["seed-file"],
-		envVar: process.env.SEED_FILE_PATH,
-		appFileField: (a) => a.seedFile,
-		app,
-		defaultDir: "seeds",
-		defaultFileName: "seed.yaml"
-	});
-}
-function resolveSeedConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		seedFilePath: resolveSeedFilePath(cliValues)
-	};
-}
-function resolveSeedAppConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		seedFilePath: resolveSeedFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveSeedFilePath, resolveContainerConfig: resolveSeedConfig, resolveAppContainerConfig: resolveSeedAppConfig } = createDomainConfigResolver({
+	fileArgKey: "seed-file",
+	envVar: () => process.env.SEED_FILE_PATH,
+	appFileField: (a) => a.seedFile,
+	defaultDir: "seeds",
+	defaultFileName: "seed.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		seedFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/seed/apply.ts
@@ -9831,36 +9347,17 @@ const settingsArgs = {
 		description: "General settings file path (default: settings.yaml)"
 	}
 };
-function resolveSettingsFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["settings-file"],
-		envVar: process.env.SETTINGS_FILE_PATH,
-		appFileField: (a) => a.settingsFile,
-		app,
-		defaultDir: "settings",
-		defaultFileName: "settings.yaml"
-	});
-}
-function resolveSettingsContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		settingsFilePath: resolveSettingsFilePath(cliValues)
-	};
-}
-function resolveSettingsAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		settingsFilePath: resolveSettingsFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveSettingsFilePath, resolveContainerConfig: resolveSettingsContainerConfig, resolveAppContainerConfig: resolveSettingsAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "settings-file",
+	envVar: () => process.env.SETTINGS_FILE_PATH,
+	appFileField: (a) => a.settingsFile,
+	defaultDir: "settings",
+	defaultFileName: "settings.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		settingsFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/settings/apply.ts
@@ -10043,36 +9540,17 @@ const viewArgs = {
 		description: "View file path (default: views.yaml)"
 	}
 };
-function resolveViewFilePath(cliValues, app) {
-	return resolveFilePath({
-		cliValue: cliValues["view-file"],
-		envVar: process.env.VIEW_FILE_PATH,
-		appFileField: (a) => a.viewFile,
-		app,
-		defaultDir: "view",
-		defaultFileName: "views.yaml"
-	});
-}
-function resolveViewContainerConfig(cliValues) {
-	const config = resolveConfig(cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		viewFilePath: resolveViewFilePath(cliValues)
-	};
-}
-function resolveViewAppContainerConfig(app, projectConfig, cliValues) {
-	const config = resolveAppCliConfig(app, projectConfig, cliValues);
-	return {
-		baseUrl: config.baseUrl,
-		auth: config.auth,
-		appId: config.appId,
-		guestSpaceId: config.guestSpaceId,
-		viewFilePath: resolveViewFilePath(cliValues, app)
-	};
-}
+const { resolveFilePath: resolveViewFilePath, resolveContainerConfig: resolveViewContainerConfig, resolveAppContainerConfig: resolveViewAppContainerConfig } = createDomainConfigResolver({
+	fileArgKey: "view-file",
+	envVar: () => process.env.VIEW_FILE_PATH,
+	appFileField: (a) => a.viewFile,
+	defaultDir: "view",
+	defaultFileName: "views.yaml",
+	buildConfig: (base, filePath) => ({
+		...base,
+		viewFilePath: filePath
+	})
+});
 
 //#endregion
 //#region src/cli/commands/view/apply.ts