carlin 1.49.7 → 1.49.9

package/README.md

@@ -8,6 +8,26 @@ pnpm add -D carlin
 
 **[Documentation →](https://ttoss.dev/docs/carlin/)**
 
+## Typed Configuration
+
+Use `defineConfig` from `carlin/config` for typed `carlin.ts` files:
+
+```typescript
+import { defineConfig, requiredEnv } from 'carlin/config';
+
+export default defineConfig(({ environment }) => {
+  return {
+    environment,
+    parameters: {
+      DomainName: 'api.example.com',
+      DatabasePassword: requiredEnv({ name: 'DATABASE_PASSWORD' }),
+    },
+  };
+});
+```
+
+See the [configuration docs](https://ttoss.dev/docs/carlin/core-concepts/configuration) for the full flow from environment variables to CloudFormation parameters.
+
 ## License
 
 MIT © [Pedro Arantes](https://twitter.com/arantespp)

package/dist/chunk-3GQAWCBQ.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export { __name, __require };

package/dist/defineConfig.d.ts

@@ -0,0 +1,28 @@
+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;
+
+export { type CarlinConfig, type CarlinConfigContext, type CarlinConfigFactory, type CarlinParameter, type CarlinParameterValue, type CarlinParameters, type RequiredEnvOptions, defineConfig, requiredEnv };

package/dist/defineConfig.js

@@ -0,0 +1,136 @@
+import { __name } from './chunk-3GQAWCBQ.js';
+
+// src/defineConfig.ts
+var isRecord = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}, "isRecord");
+var isPromise = /* @__PURE__ */ __name((value) => {
+  return isRecord(value) && typeof value.then === "function";
+}, "isPromise");
+var getConfigRecord = /* @__PURE__ */ __name(({ config, path }) => {
+  if (!isRecord(config)) {
+    throw new Error(`${path} must resolve to an object.`);
+  }
+  return config;
+}, "getConfigRecord");
+var assertParameterValue = /* @__PURE__ */ __name(({ 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.`);
+  }
+}, "assertParameterValue");
+var validateParameterArray = /* @__PURE__ */ __name(({ 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
+    });
+  }
+}, "validateParameterArray");
+var validateParameterRecord = /* @__PURE__ */ __name(({ parameters, path }) => {
+  for (const [key, value] of Object.entries(parameters)) {
+    assertParameterValue({
+      key,
+      path,
+      value
+    });
+  }
+}, "validateParameterRecord");
+var validateParameters = /* @__PURE__ */ __name(({ 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.`);
+}, "validateParameters");
+var validateConfig = /* @__PURE__ */ __name(({ 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;
+}, "validateConfig");
+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"
+  });
+}
+__name(defineConfig, "defineConfig");
+var requiredEnv = /* @__PURE__ */ __name(({ name, message }) => {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(message || `Missing required environment variable: ${name}`);
+  }
+  return value;
+}, "requiredEnv");
+
+export { defineConfig, requiredEnv };

package/dist/index.d.ts

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