@robhan-cdk-lib/aws_mwaa 0.0.0

package/lib/validation/environment-base.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateName = validateName;
+exports.validateAirflowConfigurationOptions = validateAirflowConfigurationOptions;
+exports.validateLoggingConfiguration = validateLoggingConfiguration;
+exports.validateNetworkConfiguration = validateNetworkConfiguration;
+exports.validateDagS3Path = validateDagS3Path;
+exports.validateMaxWebservers = validateMaxWebservers;
+exports.validateMaxWorkers = validateMaxWorkers;
+exports.validateMinWebservers = validateMinWebservers;
+exports.validateMinWorkers = validateMinWorkers;
+exports.validatePluginsS3ObjectVersion = validatePluginsS3ObjectVersion;
+exports.validatePluginsS3Path = validatePluginsS3Path;
+exports.validateRequirementsS3ObjectVersion = validateRequirementsS3ObjectVersion;
+exports.validateRequirementsS3Path = validateRequirementsS3Path;
+exports.validateSchedulers = validateSchedulers;
+exports.validateStartupScriptS3ObjectVersion = validateStartupScriptS3ObjectVersion;
+exports.validateStartupScriptS3Path = validateStartupScriptS3Path;
+exports.validateWeeklyMaintenanceWindowStart = validateWeeklyMaintenanceWindowStart;
+const utils_1 = require("@robhan-cdk-lib/utils");
+const environment_base_1 = require("../environment-base");
+function validateName(name) {
+    const errors = [];
+    if (typeof name !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: name,
+        min: 1,
+        max: 80,
+    }));
+    errors.push(...(0, utils_1.validateRegExp)({
+        regExp: /^[a-zA-Z][0-9a-zA-Z-_]*$/,
+        value: name,
+    }));
+    return errors;
+}
+function validateAirflowConfigurationOptions(airflowConfigurationOptions) {
+    const errors = [];
+    if (typeof airflowConfigurationOptions !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    for (const [key, value] of Object.entries(airflowConfigurationOptions)) {
+        errors.push(...(0, utils_1.validateStringLength)({
+            value: key,
+            min: 1,
+            max: 64,
+            message: `key "${key}" must be between 1 and 64 characters long`,
+        }));
+        errors.push(...(0, utils_1.validateRegExp)({
+            regExp: /^[a-z]+([a-z0-9._]*[a-z0-9_]+)?$/,
+            value: key,
+            messagePrefix: `key "${key}" `,
+        }));
+        if (typeof value !== 'string') {
+            errors.push(`value for key "${key}" must be a string`);
+            continue; // No need to check further if not a string
+        }
+        errors.push(...(0, utils_1.validateStringLength)({
+            value: value,
+            min: 1,
+            max: 65536,
+            message: `value for key "${key}" must be between 1 and 65536 characters long`,
+        }));
+    }
+    return errors;
+}
+function validateModuleLoggingConfiguration(moduleLoggingConfiguration) {
+    const errors = [];
+    if (typeof moduleLoggingConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const moduleLoggingConfigurationObject = moduleLoggingConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: moduleLoggingConfigurationObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['cloudWatchLogGroup', 'enabled', 'logLevel'],
+    }));
+    if (moduleLoggingConfigurationObject.enabled !== undefined) {
+        if (typeof moduleLoggingConfigurationObject.enabled !== 'boolean') {
+            errors.push('enabled: must be a boolean');
+        }
+    }
+    return errors;
+}
+function validateLoggingConfiguration(loggingConfiguration) {
+    const errors = [];
+    if (typeof loggingConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const loggingConfigurationObject = loggingConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: loggingConfigurationObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['dagProcessingLogs', 'schedulerLogs', 'taskLogs', 'webServerLogs', 'workerLogs'],
+    }));
+    if (loggingConfigurationObject.dagProcessingLogs !== undefined) {
+        errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.dagProcessingLogs).map(error => `dagProcessingLogs: ${error}`));
+    }
+    if (loggingConfigurationObject.schedulerLogs !== undefined) {
+        errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.schedulerLogs).map(error => `schedulerLogs: ${error}`));
+    }
+    if (loggingConfigurationObject.taskLogs !== undefined) {
+        errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.taskLogs).map(error => `taskLogs: ${error}`));
+    }
+    if (loggingConfigurationObject.webServerLogs !== undefined) {
+        errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.webServerLogs).map(error => `webServerLogs: ${error}`));
+    }
+    if (loggingConfigurationObject.workerLogs !== undefined) {
+        errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.workerLogs).map(error => `workerLogs: ${error}`));
+    }
+    return errors;
+}
+function validateNetworkConfiguration(networkConfiguration) {
+    const errors = [];
+    if (typeof networkConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const networkConfigurationObject = networkConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: networkConfigurationObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['securityGroups', 'subnets'],
+    }));
+    if (networkConfigurationObject.securityGroups !== undefined) {
+        if (!Array.isArray(networkConfigurationObject.securityGroups)) {
+            errors.push('securityGroups: must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: networkConfigurationObject.securityGroups,
+                min: 1,
+                max: 5,
+                messagePrefix: 'securityGroups: ',
+            }));
+        }
+    }
+    if (networkConfigurationObject.subnets !== undefined) {
+        if (!Array.isArray(networkConfigurationObject.subnets)) {
+            errors.push('subnets: must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: networkConfigurationObject.subnets,
+                min: 2,
+                max: 2,
+                messagePrefix: 'subnets: ',
+            }));
+        }
+    }
+    return errors;
+}
+function validateDagS3Path(dagS3Path) {
+    const errors = [];
+    if (typeof dagS3Path !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: dagS3Path,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateMaxWebservers(props) {
+    const errors = [];
+    if (props.maxWebservers !== undefined) {
+        if (typeof props.maxWebservers !== 'number') {
+            return ['must be a number'];
+        }
+        if (props.environmentClass) {
+            if (props.environmentClass === environment_base_1.EnvironmentClass.MW1_MICRO) {
+                errors.push(...(0, utils_1.validateNumberRange)({
+                    value: props.maxWebservers,
+                    min: 1,
+                    max: 1,
+                }));
+            }
+            else {
+                errors.push(...(0, utils_1.validateNumberRange)({
+                    value: props.maxWebservers,
+                    min: 2,
+                    max: 5,
+                }));
+            }
+        }
+    }
+    return errors;
+}
+function validateMaxWorkers(maxWorkers) {
+    const errors = [];
+    if (typeof maxWorkers !== 'number') {
+        return ['must be a number'];
+    }
+    errors.push(...(0, utils_1.validateNumberRange)({
+        value: maxWorkers,
+        min: 1,
+    }));
+    return errors;
+}
+function validateMinWebservers(props) {
+    const errors = [];
+    if (props.minWebservers !== undefined) {
+        if (typeof props.minWebservers !== 'number') {
+            return ['must be a number'];
+        }
+        if (props.environmentClass) {
+            if (props.environmentClass === environment_base_1.EnvironmentClass.MW1_MICRO) {
+                errors.push(...(0, utils_1.validateNumberRange)({
+                    value: props.minWebservers,
+                    min: 1,
+                    max: 1,
+                }));
+            }
+            else {
+                errors.push(...(0, utils_1.validateNumberRange)({
+                    value: props.minWebservers,
+                    min: 2,
+                    max: 5,
+                }));
+            }
+        }
+    }
+    return errors;
+}
+function validateMinWorkers(minWorkers) {
+    const errors = [];
+    if (typeof minWorkers !== 'number') {
+        return ['must be a number'];
+    }
+    errors.push(...(0, utils_1.validateNumberRange)({
+        value: minWorkers,
+        min: 1,
+    }));
+    return errors;
+}
+function validatePluginsS3ObjectVersion(pluginsS3ObjectVersion) {
+    const errors = [];
+    if (typeof pluginsS3ObjectVersion !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: pluginsS3ObjectVersion,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validatePluginsS3Path(pluginsS3Path) {
+    const errors = [];
+    if (typeof pluginsS3Path !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: pluginsS3Path,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateRequirementsS3ObjectVersion(requirementsS3ObjectVersion) {
+    const errors = [];
+    if (typeof requirementsS3ObjectVersion !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: requirementsS3ObjectVersion,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateRequirementsS3Path(requirementsS3Path) {
+    const errors = [];
+    if (typeof requirementsS3Path !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: requirementsS3Path,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateSchedulers(schedulers) {
+    const errors = [];
+    if (typeof schedulers !== 'number') {
+        return ['must be a number'];
+    }
+    errors.push(...(0, utils_1.validateNumberRange)({
+        value: schedulers,
+        min: 1,
+        max: 5,
+    }));
+    return errors;
+}
+function validateStartupScriptS3ObjectVersion(startupScriptS3ObjectVersion) {
+    const errors = [];
+    if (typeof startupScriptS3ObjectVersion !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: startupScriptS3ObjectVersion,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateStartupScriptS3Path(startupScriptS3Path) {
+    const errors = [];
+    if (typeof startupScriptS3Path !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: startupScriptS3Path,
+        min: 1,
+        max: 1024,
+    }));
+    return errors;
+}
+function validateWeeklyMaintenanceWindowStart(weeklyMaintenanceWindowStart) {
+    const errors = [];
+    if (typeof weeklyMaintenanceWindowStart !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: weeklyMaintenanceWindowStart,
+        min: 1,
+        max: 9,
+    }));
+    errors.push(...(0, utils_1.validateRegExp)({
+        value: weeklyMaintenanceWindowStart,
+        regExp: /^.*(MON|TUE|WED|THU|FRI|SAT|SUN):([01]\d|2[0-3]):(00|30).*$/,
+    }));
+    return errors;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-base.js","sourceRoot":"","sources":["../../src/validation/environment-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { validateArrayLength, validateNumberRange, validateObjectAttributes, validateRegExp, validateStringLength } from '@robhan-cdk-lib/utils';\nimport { EnvironmentProps } from '../environment';\nimport { EnvironmentClass, LoggingConfiguration, ModuleLoggingConfiguration, NetworkConfiguration } from '../environment-base';\n\nexport function validateName(name: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof name !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: name,\n    min: 1,\n    max: 80,\n  }));\n\n  errors.push(...validateRegExp({\n    regExp: /^[a-zA-Z][0-9a-zA-Z-_]*$/,\n    value: name,\n  }));\n\n  return errors;\n}\n\nexport function validateAirflowConfigurationOptions(airflowConfigurationOptions: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof airflowConfigurationOptions !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  for (const [key, value] of Object.entries(airflowConfigurationOptions)) {\n    errors.push(...validateStringLength({\n      value: key,\n      min: 1,\n      max: 64,\n      message: `key \"${key}\" must be between 1 and 64 characters long`,\n    }));\n\n    errors.push(...validateRegExp({\n      regExp: /^[a-z]+([a-z0-9._]*[a-z0-9_]+)?$/,\n      value: key,\n      messagePrefix: `key \"${key}\" `,\n    }));\n\n    if (typeof value !== 'string') {\n      errors.push(`value for key \"${key}\" must be a string`);\n      continue; // No need to check further if not a string\n    }\n\n    errors.push(...validateStringLength({\n      value: value,\n      min: 1,\n      max: 65536,\n      message: `value for key \"${key}\" must be between 1 and 65536 characters long`,\n    }));\n  }\n\n  return errors;\n}\n\nfunction validateModuleLoggingConfiguration(moduleLoggingConfiguration: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof moduleLoggingConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const moduleLoggingConfigurationObject = moduleLoggingConfiguration as ModuleLoggingConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: moduleLoggingConfigurationObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['cloudWatchLogGroup', 'enabled', 'logLevel'],\n  }));\n\n  if (moduleLoggingConfigurationObject.enabled !== undefined) {\n    if (typeof moduleLoggingConfigurationObject.enabled !== 'boolean') {\n      errors.push('enabled: must be a boolean');\n    }\n  }\n\n  return errors;\n}\n\nexport function validateLoggingConfiguration(loggingConfiguration: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof loggingConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const loggingConfigurationObject = loggingConfiguration as LoggingConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: loggingConfigurationObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['dagProcessingLogs', 'schedulerLogs', 'taskLogs', 'webServerLogs', 'workerLogs'],\n  }));\n\n  if (loggingConfigurationObject.dagProcessingLogs !== undefined) {\n    errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.dagProcessingLogs).map(error => `dagProcessingLogs: ${error}`));\n  }\n\n  if (loggingConfigurationObject.schedulerLogs !== undefined) {\n    errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.schedulerLogs).map(error => `schedulerLogs: ${error}`));\n  }\n\n  if (loggingConfigurationObject.taskLogs !== undefined) {\n    errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.taskLogs).map(error => `taskLogs: ${error}`));\n  }\n\n  if (loggingConfigurationObject.webServerLogs !== undefined) {\n    errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.webServerLogs).map(error => `webServerLogs: ${error}`));\n  }\n\n  if (loggingConfigurationObject.workerLogs !== undefined) {\n    errors.push(...validateModuleLoggingConfiguration(loggingConfigurationObject.workerLogs).map(error => `workerLogs: ${error}`));\n  }\n\n  return errors;\n}\n\nexport function validateNetworkConfiguration(networkConfiguration: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof networkConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const networkConfigurationObject = networkConfiguration as NetworkConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: networkConfigurationObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['securityGroups', 'subnets'],\n  }));\n\n  if (networkConfigurationObject.securityGroups !== undefined) {\n    if (!Array.isArray(networkConfigurationObject.securityGroups)) {\n      errors.push('securityGroups: must be an array');\n    } else {\n      errors.push(...validateArrayLength({\n        value: networkConfigurationObject.securityGroups,\n        min: 1,\n        max: 5,\n        messagePrefix: 'securityGroups: ',\n      }));\n    }\n  }\n\n  if (networkConfigurationObject.subnets !== undefined) {\n    if (!Array.isArray(networkConfigurationObject.subnets)) {\n      errors.push('subnets: must be an array');\n    } else {\n      errors.push(...validateArrayLength({\n        value: networkConfigurationObject.subnets,\n        min: 2,\n        max: 2,\n        messagePrefix: 'subnets: ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\nexport function validateDagS3Path(dagS3Path: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof dagS3Path !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: dagS3Path,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateMaxWebservers(props: EnvironmentProps): string[] {\n  const errors: string[] = [];\n\n  if (props.maxWebservers !== undefined) {\n    if (typeof props.maxWebservers !== 'number') {\n      return ['must be a number'];\n    }\n\n    if (props.environmentClass) {\n      if (props.environmentClass === EnvironmentClass.MW1_MICRO) {\n        errors.push(...validateNumberRange({\n          value: props.maxWebservers,\n          min: 1,\n          max: 1,\n        }));\n      } else {\n        errors.push(...validateNumberRange({\n          value: props.maxWebservers,\n          min: 2,\n          max: 5,\n        }));\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function validateMaxWorkers(maxWorkers: any): string[] {\n  const errors: string[] = [];\n\n  if (\n    typeof maxWorkers !== 'number'\n  ) {\n    return ['must be a number'];\n  }\n\n  errors.push(...validateNumberRange({\n    value: maxWorkers,\n    min: 1,\n  }));\n\n  return errors;\n}\n\nexport function validateMinWebservers(props: EnvironmentProps): string[] {\n  const errors: string[] = [];\n\n  if (props.minWebservers !== undefined) {\n    if (typeof props.minWebservers !== 'number') {\n      return ['must be a number'];\n    }\n\n    if (props.environmentClass) {\n      if (props.environmentClass === EnvironmentClass.MW1_MICRO) {\n        errors.push(...validateNumberRange({\n          value: props.minWebservers,\n          min: 1,\n          max: 1,\n        }));\n      } else {\n        errors.push(...validateNumberRange({\n          value: props.minWebservers,\n          min: 2,\n          max: 5,\n        }));\n      }\n    }\n  }\n\n  return errors;\n}\n\nexport function validateMinWorkers(minWorkers: any): string[] {\n  const errors: string[] = [];\n\n  if (\n    typeof minWorkers !== 'number'\n  ) {\n    return ['must be a number'];\n  }\n\n  errors.push(...validateNumberRange({\n    value: minWorkers,\n    min: 1,\n  }));\n\n  return errors;\n}\n\nexport function validatePluginsS3ObjectVersion(pluginsS3ObjectVersion: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof pluginsS3ObjectVersion !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: pluginsS3ObjectVersion,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validatePluginsS3Path(pluginsS3Path: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof pluginsS3Path !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: pluginsS3Path,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateRequirementsS3ObjectVersion(requirementsS3ObjectVersion: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof requirementsS3ObjectVersion !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: requirementsS3ObjectVersion,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateRequirementsS3Path(requirementsS3Path: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof requirementsS3Path !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: requirementsS3Path,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateSchedulers(schedulers: any): string[] {\n  const errors: string[] = [];\n\n  if (\n    typeof schedulers !== 'number'\n  ) {\n    return ['must be a number'];\n  }\n\n  errors.push(...validateNumberRange({\n    value: schedulers,\n    min: 1,\n    max: 5,\n  }));\n\n  return errors;\n}\n\nexport function validateStartupScriptS3ObjectVersion(startupScriptS3ObjectVersion: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof startupScriptS3ObjectVersion !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: startupScriptS3ObjectVersion,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateStartupScriptS3Path(startupScriptS3Path: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof startupScriptS3Path !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: startupScriptS3Path,\n    min: 1,\n    max: 1024,\n  }));\n\n  return errors;\n}\n\nexport function validateWeeklyMaintenanceWindowStart(weeklyMaintenanceWindowStart: any): string[] {\n  const errors: string[] = [];\n\n  if (typeof weeklyMaintenanceWindowStart !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: weeklyMaintenanceWindowStart,\n    min: 1,\n    max: 9,\n  }));\n\n  errors.push(...validateRegExp({\n    value: weeklyMaintenanceWindowStart,\n    regExp: /^.*(MON|TUE|WED|THU|FRI|SAT|SUN):([01]\\d|2[0-3]):(00|30).*$/,\n  }));\n\n\n  return errors;\n}"]}

package/package.json

@@ -0,0 +1,155 @@
+{
+  "name": "@robhan-cdk-lib/aws_mwaa",
+  "description": "AWS CDK Construct Library for Amazon Managed Workflows for Apache Airflow",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/robert-hanuschke/cdk-aws_mwaa.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:dotnet": "npx projen package:dotnet",
+    "package:go": "npx projen package:go",
+    "package:java": "npx projen package:java",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Robert Hanuschke",
+    "email": "robhan-cdk-lib@hanuschke.eu",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.0",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "aws-cdk-lib": "2.221.0",
+    "commit-and-tag-version": "^12",
+    "constructs": "10.0.5",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.2.0",
+    "jest-junit": "^16",
+    "jsii": "~5.8.0",
+    "jsii-diff": "^1.118.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.118.0",
+    "jsii-rosetta": "~5.8.0",
+    "projen": "^0.98.10",
+    "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.221.0",
+    "constructs": "^10.0.5"
+  },
+  "dependencies": {
+    "@robhan-cdk-lib/utils": "^0.0.90"
+  },
+  "keywords": [
+    "Airflow",
+    "Amazon Managed Workflows for Apache Airflow",
+    "cdk"
+  ],
+  "main": "lib/index.js",
+  "license": "MIT",
+  "version": "0.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "java": {
+        "package": "io.github.roberthanuschke.cdk.aws.mwaa",
+        "maven": {
+          "groupId": "io.github.robert-hanuschke",
+          "artifactId": "cdk-aws-mwaa"
+        }
+      },
+      "python": {
+        "distName": "robhan_cdk_lib.aws_mwaa",
+        "module": "robhan_cdk_lib.aws_mwaa"
+      },
+      "dotnet": {
+        "namespace": "Robhan.CdkLib",
+        "packageId": "Robhan.CdkLib.AwsMwaa"
+      },
+      "go": {
+        "moduleName": "github.com/robert-hanuschke/robhan-cdk-lib-aws-mwaa"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}