carlin 1.49.14 → 1.49.15

package/bin/carlin.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../dist/index.js';
+import '../dist/index.mjs';

package/dist/defineConfig.d.mts

@@ -0,0 +1,32 @@
+//#region src/defineConfig.d.ts
+type CarlinParameterValue = string | number | undefined;
+type CarlinParameter = {
+  key: string;
+  value?: string | number;
+  usePreviousValue?: boolean;
+  resolvedValue?: string;
+};
+type CarlinParameters = CarlinParameter[] | Record<string, CarlinParameterValue>;
+type CarlinConfigContext = {
+  branch?: string;
+  environment?: string;
+  project?: string;
+};
+type CarlinConfig = {
+  parameters?: CarlinParameters;
+  environments?: Record<string, CarlinConfig>;
+  [key: string]: unknown;
+};
+type CarlinConfigFactory<Config extends CarlinConfig = CarlinConfig> = (context: CarlinConfigContext) => Config | Promise<Config>;
+type RequiredEnvOptions = {
+  name: string;
+  message?: string;
+};
+declare function defineConfig<Config extends CarlinConfig>(config: Config): Config;
+declare function defineConfig<Config extends CarlinConfig>(config: CarlinConfigFactory<Config>): CarlinConfigFactory<Config>;
+declare const requiredEnv: ({
+  name,
+  message
+}: RequiredEnvOptions) => string;
+//#endregion
+export { CarlinConfig, CarlinConfigContext, CarlinConfigFactory, CarlinParameter, CarlinParameterValue, CarlinParameters, RequiredEnvOptions, defineConfig, requiredEnv };

package/dist/defineConfig.mjs

@@ -0,0 +1,103 @@
+//#region src/defineConfig.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const isPromise = (value) => {
+	return isRecord(value) && typeof value.then === "function";
+};
+const getConfigRecord = ({ config, path }) => {
+	if (!isRecord(config)) throw new Error(`${path} must resolve to an object.`);
+	return config;
+};
+const assertParameterValue = ({ key, path, usePreviousValue, value }) => {
+	if (usePreviousValue) return;
+	if (value === void 0 || value === null || value === "") throw new Error(`${path}.${key} must have a value.`);
+	if (typeof value !== "string" && typeof value !== "number") throw new Error(`${path}.${key} must be a string or number.`);
+};
+const validateParameterArray = ({ parameters, path }) => {
+	for (const [index, parameter] of parameters.entries()) {
+		if (!isRecord(parameter)) throw new Error(`${path}[${index}] must be an object.`);
+		if (typeof parameter.key !== "string" || parameter.key.length === 0) throw new Error(`${path}[${index}].key must be a non-empty string.`);
+		assertParameterValue({
+			key: parameter.key,
+			path,
+			usePreviousValue: parameter.usePreviousValue === true,
+			value: parameter.value
+		});
+	}
+};
+const validateParameterRecord = ({ parameters, path }) => {
+	for (const [key, value] of Object.entries(parameters)) assertParameterValue({
+		key,
+		path,
+		value
+	});
+};
+const validateParameters = ({ parameters, path }) => {
+	if (parameters === void 0) return;
+	if (Array.isArray(parameters)) {
+		validateParameterArray({
+			parameters,
+			path
+		});
+		return;
+	}
+	if (isRecord(parameters)) {
+		validateParameterRecord({
+			parameters,
+			path
+		});
+		return;
+	}
+	throw new Error(`${path} must be an object or an array.`);
+};
+const validateConfig = ({ config, path }) => {
+	const pendingConfigs = [{
+		config,
+		path
+	}];
+	const configRecord = getConfigRecord({
+		config,
+		path
+	});
+	for (const pendingConfig of pendingConfigs) {
+		const currentConfig = getConfigRecord(pendingConfig);
+		validateParameters({
+			parameters: currentConfig.parameters,
+			path: `${pendingConfig.path}.parameters`
+		});
+		if (currentConfig.environments === void 0) continue;
+		if (!isRecord(currentConfig.environments)) throw new Error(`${pendingConfig.path}.environments must be an object.`);
+		for (const [environment, environmentConfig] of Object.entries(currentConfig.environments)) pendingConfigs.push({
+			config: environmentConfig,
+			path: `${pendingConfig.path}.environments.${environment}`
+		});
+	}
+	return configRecord;
+};
+function defineConfig(config) {
+	if (typeof config === "function") return (context) => {
+		const resolvedConfig = config(context);
+		if (isPromise(resolvedConfig)) return resolvedConfig.then((asyncConfig) => {
+			return validateConfig({
+				config: asyncConfig,
+				path: "config"
+			});
+		});
+		return validateConfig({
+			config: resolvedConfig,
+			path: "config"
+		});
+	};
+	return validateConfig({
+		config,
+		path: "config"
+	});
+}
+const requiredEnv = ({ name, message }) => {
+	const value = process.env[name];
+	if (!value) throw new Error(message || `Missing required environment variable: ${name}`);
+	return value;
+};
+//#endregion
+export { defineConfig, requiredEnv };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };