@unstablestudios/terraform 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1283 @@
+// src/types/config.ts
+function expr(value) {
+  return { __hclExpression: true, value };
+}
+function isHclExpression(value) {
+  return typeof value === "object" && value !== null && "__hclExpression" in value && value.__hclExpression === true;
+}
+
+// src/hcl/generator.ts
+var DEFAULT_OPTIONS = {
+  indent: "  ",
+  includeEmpty: false
+};
+function toHcl(value, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  return formatValue(value, 0, opts);
+}
+function formatBlock(block, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { type, labels, body, nestedBlocks } = block;
+  const labelStr = labels.map((l) => `"${l}"`).join(" ");
+  const header = labelStr ? `${type} ${labelStr}` : type;
+  const bodyLines = formatBody(body, 1, opts);
+  const nestedLines = nestedBlocks?.map((nb) => formatNestedBlock(nb, 1, opts)).join("\n") ?? "";
+  const content = [bodyLines, nestedLines].filter(Boolean).join("\n");
+  return `${header} {
+${content}
+}`;
+}
+function formatNestedBlock(block, depth, opts) {
+  const indent = opts.indent.repeat(depth);
+  const { type, labels, body, nestedBlocks } = block;
+  const labelStr = labels.map((l) => `"${l}"`).join(" ");
+  const header = labelStr ? `${type} ${labelStr}` : type;
+  const bodyLines = formatBody(body, depth + 1, opts);
+  const nestedLines = nestedBlocks?.map((nb) => formatNestedBlock(nb, depth + 1, opts)).join("\n") ?? "";
+  const content = [bodyLines, nestedLines].filter(Boolean).join("\n");
+  return `${indent}${header} {
+${content}
+${indent}}`;
+}
+function formatBody(obj, depth, opts) {
+  const indent = opts.indent.repeat(depth);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (!opts.includeEmpty && (value === null || value === void 0)) {
+      continue;
+    }
+    const formattedValue = formatValue(value, depth, opts);
+    lines.push(`${indent}${key} = ${formattedValue}`);
+  }
+  return lines.join("\n");
+}
+function formatValue(value, depth, opts) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (isHclExpression(value)) {
+    return value.value;
+  }
+  if (typeof value === "string") {
+    if (value.includes("\n")) {
+      return formatHeredoc(value);
+    }
+    return `"${escapeString(value)}"`;
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Array.isArray(value)) {
+    return formatArray(value, depth, opts);
+  }
+  if (typeof value === "object") {
+    return formatObject(value, depth, opts);
+  }
+  return String(value);
+}
+function formatArray(arr, depth, opts) {
+  if (arr.length === 0) {
+    return "[]";
+  }
+  const allSimple = arr.every(
+    (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+  );
+  if (allSimple && arr.length <= 5) {
+    const items2 = arr.map((v) => formatValue(v, depth, opts));
+    return `[${items2.join(", ")}]`;
+  }
+  const indent = opts.indent.repeat(depth + 1);
+  const closeIndent = opts.indent.repeat(depth);
+  const items = arr.map((v) => `${indent}${formatValue(v, depth + 1, opts)}`);
+  return `[
+${items.join(",\n")}
+${closeIndent}]`;
+}
+function formatObject(obj, depth, opts) {
+  const entries = Object.entries(obj).filter(
+    ([, v]) => opts.includeEmpty || v !== null && v !== void 0
+  );
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const indent = opts.indent.repeat(depth + 1);
+  const closeIndent = opts.indent.repeat(depth);
+  const items = entries.map(([k, v]) => `${indent}${k} = ${formatValue(v, depth + 1, opts)}`);
+  return `{
+${items.join("\n")}
+${closeIndent}}`;
+}
+function formatHeredoc(value) {
+  return `<<-EOF
+${value}
+EOF`;
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function generateVariable(name, config, opts = {}) {
+  const body = {};
+  if (config.type) body.type = { __hclExpression: true, value: config.type };
+  if (config.description) body.description = config.description;
+  if (config.default !== void 0) body.default = config.default;
+  if (config.sensitive !== void 0) body.sensitive = config.sensitive;
+  if (config.nullable !== void 0) body.nullable = config.nullable;
+  const block = {
+    type: "variable",
+    labels: [name],
+    body,
+    nestedBlocks: config.validation ? [
+      {
+        type: "validation",
+        labels: [],
+        body: {
+          condition: config.validation.condition,
+          error_message: config.validation.error_message
+        }
+      }
+    ] : void 0
+  };
+  return formatBlock(block, opts);
+}
+function generateOutput(name, config, opts = {}) {
+  const body = {
+    value: config.value
+  };
+  if (config.description) body.description = config.description;
+  if (config.sensitive !== void 0) body.sensitive = config.sensitive;
+  if (config.depends_on) {
+    body.depends_on = { __hclExpression: true, value: `[${config.depends_on.map((d) => d.value).join(", ")}]` };
+  }
+  const block = {
+    type: "output",
+    labels: [name],
+    body
+  };
+  return formatBlock(block, opts);
+}
+function generateProvider(config, opts = {}) {
+  const body = { ...config.config };
+  if (config.alias) body.alias = config.alias;
+  const block = {
+    type: "provider",
+    labels: [config.provider],
+    body
+  };
+  return formatBlock(block, opts);
+}
+function generateResource(config, opts = {}) {
+  const body = { ...config.config };
+  if (config.depends_on) {
+    body.depends_on = { __hclExpression: true, value: `[${config.depends_on.map((d) => d.value).join(", ")}]` };
+  }
+  if (config.count !== void 0) body.count = config.count;
+  if (config.for_each !== void 0) body.for_each = config.for_each;
+  if (config.provider) body.provider = config.provider;
+  const nestedBlocks = [];
+  if (config.lifecycle) {
+    const lifecycleBody = {};
+    if (config.lifecycle.create_before_destroy !== void 0) {
+      lifecycleBody.create_before_destroy = config.lifecycle.create_before_destroy;
+    }
+    if (config.lifecycle.prevent_destroy !== void 0) {
+      lifecycleBody.prevent_destroy = config.lifecycle.prevent_destroy;
+    }
+    if (config.lifecycle.ignore_changes) {
+      lifecycleBody.ignore_changes = config.lifecycle.ignore_changes;
+    }
+    if (config.lifecycle.replace_triggered_by) {
+      lifecycleBody.replace_triggered_by = {
+        __hclExpression: true,
+        value: `[${config.lifecycle.replace_triggered_by.map((d) => d.value).join(", ")}]`
+      };
+    }
+    nestedBlocks.push({
+      type: "lifecycle",
+      labels: [],
+      body: lifecycleBody
+    });
+  }
+  const block = {
+    type: "resource",
+    labels: [config.type, config.name],
+    body,
+    nestedBlocks: nestedBlocks.length > 0 ? nestedBlocks : void 0
+  };
+  return formatBlock(block, opts);
+}
+function generateDataSource(config, opts = {}) {
+  const body = { ...config.config };
+  if (config.depends_on) {
+    body.depends_on = { __hclExpression: true, value: `[${config.depends_on.map((d) => d.value).join(", ")}]` };
+  }
+  if (config.count !== void 0) body.count = config.count;
+  if (config.for_each !== void 0) body.for_each = config.for_each;
+  if (config.provider) body.provider = config.provider;
+  const block = {
+    type: "data",
+    labels: [config.type, config.name],
+    body
+  };
+  return formatBlock(block, opts);
+}
+function generateModule(config, opts = {}) {
+  const body = {
+    source: config.source,
+    ...config.config
+  };
+  if (config.version) body.version = config.version;
+  if (config.depends_on) {
+    body.depends_on = { __hclExpression: true, value: `[${config.depends_on.map((d) => d.value).join(", ")}]` };
+  }
+  if (config.count !== void 0) body.count = config.count;
+  if (config.for_each !== void 0) body.for_each = config.for_each;
+  if (config.providers) {
+    const providersObj = {};
+    for (const [key, value] of Object.entries(config.providers)) {
+      providersObj[key] = value;
+    }
+    body.providers = providersObj;
+  }
+  const block = {
+    type: "module",
+    labels: [config.name],
+    body
+  };
+  return formatBlock(block, opts);
+}
+function generateLocals(locals, opts = {}) {
+  const block = {
+    type: "locals",
+    labels: [],
+    body: locals
+  };
+  return formatBlock(block, opts);
+}
+function generateTerraformBlock(config, opts = {}) {
+  const body = {};
+  if (config.required_version) {
+    body.required_version = config.required_version;
+  }
+  const nestedBlocks = [];
+  if (config.required_providers) {
+    const providersBody = {};
+    for (const [name, provider] of Object.entries(config.required_providers)) {
+      providersBody[name] = {
+        source: provider.source,
+        ...provider.version ? { version: provider.version } : {}
+      };
+    }
+    nestedBlocks.push({
+      type: "required_providers",
+      labels: [],
+      body: providersBody
+    });
+  }
+  if (config.backend) {
+    nestedBlocks.push({
+      type: "backend",
+      labels: [config.backend.type],
+      body: config.backend.config
+    });
+  }
+  const block = {
+    type: "terraform",
+    labels: [],
+    body,
+    nestedBlocks: nestedBlocks.length > 0 ? nestedBlocks : void 0
+  };
+  return formatBlock(block, opts);
+}
+function generateTerraformConfig(config, opts = {}) {
+  const sections = [];
+  if (config.terraform) {
+    sections.push(generateTerraformBlock(config.terraform, opts));
+  }
+  if (config.providers) {
+    for (const provider of config.providers) {
+      sections.push(generateProvider(provider, opts));
+    }
+  }
+  if (config.variables) {
+    for (const [name, variable] of Object.entries(config.variables)) {
+      sections.push(generateVariable(name, variable, opts));
+    }
+  }
+  if (config.locals && Object.keys(config.locals).length > 0) {
+    sections.push(generateLocals(config.locals, opts));
+  }
+  if (config.dataSources) {
+    for (const dataSource of config.dataSources) {
+      sections.push(generateDataSource(dataSource, opts));
+    }
+  }
+  if (config.resources) {
+    for (const resource of config.resources) {
+      sections.push(generateResource(resource, opts));
+    }
+  }
+  if (config.modules) {
+    for (const module of config.modules) {
+      sections.push(generateModule(module, opts));
+    }
+  }
+  if (config.outputs) {
+    for (const [name, output] of Object.entries(config.outputs)) {
+      sections.push(generateOutput(name, output, opts));
+    }
+  }
+  return sections.join("\n\n");
+}
+
+// src/hcl/writer.ts
+var DEFAULT_HEADER = "# This file is generated. Do not edit manually.";
+function prepareContent(content, header) {
+  if (header === void 0) {
+    return `${DEFAULT_HEADER}
+
+${content}`;
+  }
+  if (header === "") {
+    return content;
+  }
+  return `${header}
+
+${content}`;
+}
+function generateTerraformFile(config, options = {}) {
+  const content = generateTerraformConfig(config, options);
+  return prepareContent(content, options.header);
+}
+function generateTerraformFiles(config, options = {}) {
+  const ext = options.extension ?? ".tf";
+  const results = [];
+  const mainConfig = {
+    terraform: config.terraform,
+    providers: config.providers,
+    locals: config.locals,
+    dataSources: config.dataSources,
+    resources: config.resources,
+    modules: config.modules
+  };
+  const mainContent = generateTerraformConfig(mainConfig, options);
+  if (mainContent.trim()) {
+    results.push({
+      path: `main${ext}`,
+      content: prepareContent(mainContent, options.header)
+    });
+  }
+  if (config.variables && Object.keys(config.variables).length > 0) {
+    const varsConfig = {
+      variables: config.variables
+    };
+    const varsContent = generateTerraformConfig(varsConfig, options);
+    results.push({
+      path: `variables${ext}`,
+      content: prepareContent(varsContent, options.header)
+    });
+  }
+  if (config.outputs && Object.keys(config.outputs).length > 0) {
+    const outputsConfig = {
+      outputs: config.outputs
+    };
+    const outputsContent = generateTerraformConfig(outputsConfig, options);
+    results.push({
+      path: `outputs${ext}`,
+      content: prepareContent(outputsContent, options.header)
+    });
+  }
+  return results;
+}
+function createFileWriter(writeFile) {
+  return async (results, basePath = "") => {
+    for (const result of results) {
+      const fullPath = basePath ? `${basePath}/${result.path}` : result.path;
+      await writeFile(fullPath, result.content);
+    }
+  };
+}
+function formatForTfvars(values) {
+  const lines = [];
+  for (const [key, value] of Object.entries(values)) {
+    if (value === void 0) continue;
+    if (typeof value === "string") {
+      lines.push(`${key} = "${escapeString2(value)}"`);
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      lines.push(`${key} = ${value}`);
+    } else if (value === null) {
+      lines.push(`${key} = null`);
+    } else if (Array.isArray(value)) {
+      lines.push(`${key} = ${formatArray2(value)}`);
+    } else if (typeof value === "object") {
+      lines.push(`${key} = ${formatObject2(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function escapeString2(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function formatArray2(arr, depth = 0) {
+  if (arr.length === 0) return "[]";
+  const indent = "  ".repeat(depth + 1);
+  const closeIndent = "  ".repeat(depth);
+  const items = arr.map((item) => {
+    if (typeof item === "string") return `${indent}"${escapeString2(item)}"`;
+    if (typeof item === "number" || typeof item === "boolean") return `${indent}${item}`;
+    if (item === null) return `${indent}null`;
+    if (Array.isArray(item)) return `${indent}${formatArray2(item, depth + 1)}`;
+    if (typeof item === "object") return `${indent}${formatObject2(item, depth + 1)}`;
+    return `${indent}${item}`;
+  });
+  return `[
+${items.join(",\n")}
+${closeIndent}]`;
+}
+function formatObject2(obj, depth = 0) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "{}";
+  const indent = "  ".repeat(depth + 1);
+  const closeIndent = "  ".repeat(depth);
+  const items = entries.map(([key, value]) => {
+    if (typeof value === "string") return `${indent}${key} = "${escapeString2(value)}"`;
+    if (typeof value === "number" || typeof value === "boolean") return `${indent}${key} = ${value}`;
+    if (value === null) return `${indent}${key} = null`;
+    if (Array.isArray(value)) return `${indent}${key} = ${formatArray2(value, depth + 1)}`;
+    if (typeof value === "object") return `${indent}${key} = ${formatObject2(value, depth + 1)}`;
+    return `${indent}${key} = ${value}`;
+  });
+  return `{
+${items.join("\n")}
+${closeIndent}}`;
+}
+
+// src/config/terraform.ts
+var TerraformConfigBuilder = class {
+  constructor() {
+    this.config = {};
+  }
+  /**
+   * Set required Terraform version
+   */
+  requiredVersion(version) {
+    if (!this.config.terraform) this.config.terraform = {};
+    this.config.terraform.required_version = version;
+    return this;
+  }
+  /**
+   * Add a required provider
+   */
+  requiredProvider(name, provider) {
+    if (!this.config.terraform) this.config.terraform = {};
+    if (!this.config.terraform.required_providers) this.config.terraform.required_providers = {};
+    this.config.terraform.required_providers[name] = provider;
+    return this;
+  }
+  /**
+   * Set backend configuration
+   */
+  backend(backend2) {
+    if (!this.config.terraform) this.config.terraform = {};
+    this.config.terraform.backend = backend2;
+    return this;
+  }
+  /**
+   * Add a provider configuration
+   */
+  provider(provider, config = {}, alias) {
+    if (!this.config.providers) this.config.providers = [];
+    this.config.providers.push({ provider, config, alias });
+    return this;
+  }
+  /**
+   * Add a variable
+   */
+  variable(name, type, options = {}) {
+    if (!this.config.variables) this.config.variables = {};
+    this.config.variables[name] = {
+      type,
+      ...options
+    };
+    return this;
+  }
+  /**
+   * Add locals
+   */
+  locals(values) {
+    if (!this.config.locals) this.config.locals = {};
+    Object.assign(this.config.locals, values);
+    return this;
+  }
+  /**
+   * Add a resource
+   */
+  resource(type, name, config) {
+    if (!this.config.resources) this.config.resources = [];
+    this.config.resources.push({ type, name, config });
+    return this;
+  }
+  /**
+   * Add a data source
+   */
+  data(type, name, config) {
+    if (!this.config.dataSources) this.config.dataSources = [];
+    this.config.dataSources.push({ type, name, config });
+    return this;
+  }
+  /**
+   * Add a module
+   */
+  module(name, source, config = {}, version) {
+    if (!this.config.modules) this.config.modules = [];
+    this.config.modules.push({ name, source, config, version });
+    return this;
+  }
+  /**
+   * Add an output
+   */
+  output(name, value, options = {}) {
+    if (!this.config.outputs) this.config.outputs = {};
+    this.config.outputs[name] = { value, ...options };
+    return this;
+  }
+  /**
+   * Get the built configuration
+   */
+  build() {
+    return this.config;
+  }
+  /**
+   * Generate HCL string
+   */
+  toHcl(options) {
+    return generateTerraformConfig(this.config, options);
+  }
+};
+function terraform() {
+  return new TerraformConfigBuilder();
+}
+var backends = {
+  /**
+   * S3 backend configuration
+   */
+  s3: (config) => ({
+    type: "s3",
+    config: {
+      bucket: config.bucket,
+      key: config.key,
+      region: config.region,
+      encrypt: config.encrypt ?? true,
+      ...config.dynamodb_table ? { dynamodb_table: config.dynamodb_table } : {}
+    }
+  }),
+  /**
+   * GCS backend configuration
+   */
+  gcs: (config) => ({
+    type: "gcs",
+    config: {
+      bucket: config.bucket,
+      prefix: config.prefix
+    }
+  }),
+  /**
+   * Azure backend configuration
+   */
+  azurerm: (config) => ({
+    type: "azurerm",
+    config
+  }),
+  /**
+   * Local backend configuration
+   */
+  local: (path) => ({
+    type: "local",
+    config: path ? { path } : {}
+  }),
+  /**
+   * Terraform Cloud backend configuration
+   */
+  cloud: (config) => ({
+    type: "cloud",
+    config: {
+      organization: config.organization,
+      workspaces: { name: config.workspaces.name }
+    }
+  })
+};
+var providers = {
+  /**
+   * AWS provider
+   */
+  aws: (region, profile) => ({
+    provider: "aws",
+    config: {
+      region,
+      ...profile ? { profile } : {}
+    }
+  }),
+  /**
+   * Cloudflare provider
+   */
+  cloudflare: (apiToken) => ({
+    provider: "cloudflare",
+    config: apiToken ? { api_token: apiToken } : {}
+  }),
+  /**
+   * Google provider
+   */
+  google: (project, region) => ({
+    provider: "google",
+    config: { project, region }
+  }),
+  /**
+   * Azure provider
+   */
+  azurerm: (features = {}) => ({
+    provider: "azurerm",
+    config: { features }
+  })
+};
+
+// src/config/tfvars.ts
+function generateTfvars(config) {
+  const content = formatForTfvars(config.values);
+  if (config.header) {
+    return `${config.header}
+
+${content}`;
+  }
+  return content;
+}
+function generateEnvTfvars(environment, values, options = {}) {
+  const header = options.header !== false ? `# ${environment} environment configuration` : void 0;
+  return {
+    filename: `${environment}.tfvars`,
+    content: generateTfvars({ values, header })
+  };
+}
+var TfvarsBuilder = class {
+  constructor() {
+    this.values = {};
+  }
+  /**
+   * Set header comment
+   */
+  withHeader(header) {
+    this.header = header;
+    return this;
+  }
+  /**
+   * Set a string variable
+   */
+  string(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set a number variable
+   */
+  number(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set a boolean variable
+   */
+  bool(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set a list variable
+   */
+  list(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set a map variable
+   */
+  map(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set a variable of any type
+   */
+  set(name, value) {
+    this.values[name] = value;
+    return this;
+  }
+  /**
+   * Set multiple variables at once
+   */
+  setAll(values) {
+    Object.assign(this.values, values);
+    return this;
+  }
+  /**
+   * Build the tfvars content
+   */
+  build() {
+    return generateTfvars({ values: this.values, header: this.header });
+  }
+  /**
+   * Get the values as an object
+   */
+  toObject() {
+    return { ...this.values };
+  }
+};
+function tfvars() {
+  return new TfvarsBuilder();
+}
+function mergeTfvars(...sources) {
+  return Object.assign({}, ...sources);
+}
+function tfvarsFromEnv(mapping, env) {
+  const values = {};
+  for (const [tfvarName, envName] of Object.entries(mapping)) {
+    const value = env[envName];
+    if (value !== void 0) {
+      values[tfvarName] = value;
+    }
+  }
+  return values;
+}
+
+// src/config/backend.ts
+var BackendBuilder = class {
+  constructor(type) {
+    this.config = {};
+    this.type = type;
+  }
+  /**
+   * Set a configuration option
+   */
+  set(key, value) {
+    this.config[key] = value;
+    return this;
+  }
+  /**
+   * Set multiple configuration options
+   */
+  setAll(config) {
+    Object.assign(this.config, config);
+    return this;
+  }
+  /**
+   * Build the backend configuration
+   */
+  build() {
+    return {
+      type: this.type,
+      config: this.config
+    };
+  }
+};
+function backend(type) {
+  return new BackendBuilder(type);
+}
+function s3Backend(options) {
+  const config = {
+    bucket: options.bucket,
+    key: options.key,
+    region: options.region
+  };
+  if (options.encrypt !== void 0) config.encrypt = options.encrypt;
+  if (options.dynamodb_table) config.dynamodb_table = options.dynamodb_table;
+  if (options.workspace_key_prefix) config.workspace_key_prefix = options.workspace_key_prefix;
+  if (options.acl) config.acl = options.acl;
+  if (options.skip_credentials_validation !== void 0) {
+    config.skip_credentials_validation = options.skip_credentials_validation;
+  }
+  if (options.skip_metadata_api_check !== void 0) {
+    config.skip_metadata_api_check = options.skip_metadata_api_check;
+  }
+  if (options.skip_region_validation !== void 0) {
+    config.skip_region_validation = options.skip_region_validation;
+  }
+  if (options.profile) config.profile = options.profile;
+  if (options.role_arn) config.role_arn = options.role_arn;
+  return { type: "s3", config };
+}
+function gcsBackend(options) {
+  const config = {
+    bucket: options.bucket
+  };
+  if (options.prefix) config.prefix = options.prefix;
+  if (options.credentials) config.credentials = options.credentials;
+  if (options.encryption_key) config.encryption_key = options.encryption_key;
+  return { type: "gcs", config };
+}
+function azureBackend(options) {
+  const config = {
+    resource_group_name: options.resource_group_name,
+    storage_account_name: options.storage_account_name,
+    container_name: options.container_name,
+    key: options.key
+  };
+  if (options.access_key) config.access_key = options.access_key;
+  if (options.sas_token) config.sas_token = options.sas_token;
+  if (options.use_oidc !== void 0) config.use_oidc = options.use_oidc;
+  if (options.subscription_id) config.subscription_id = options.subscription_id;
+  if (options.tenant_id) config.tenant_id = options.tenant_id;
+  if (options.client_id) config.client_id = options.client_id;
+  return { type: "azurerm", config };
+}
+function terraformCloudBackend(options) {
+  const config = {
+    organization: options.organization,
+    workspaces: options.workspaces
+  };
+  if (options.hostname) config.hostname = options.hostname;
+  if (options.token) config.token = options.token;
+  return { type: "cloud", config };
+}
+function localBackend(path) {
+  return {
+    type: "local",
+    config: path ? { path } : {}
+  };
+}
+function consulBackend(options) {
+  const config = {
+    address: options.address,
+    path: options.path
+  };
+  if (options.scheme) config.scheme = options.scheme;
+  if (options.datacenter) config.datacenter = options.datacenter;
+  if (options.access_token) config.access_token = options.access_token;
+  if (options.gzip !== void 0) config.gzip = options.gzip;
+  if (options.lock !== void 0) config.lock = options.lock;
+  return { type: "consul", config };
+}
+
+// src/modules/types.ts
+function defineModule(source, version) {
+  return {
+    source,
+    version,
+    inputs: {},
+    outputs: {}
+  };
+}
+function useModule(definition, name, inputs) {
+  const config = {
+    name,
+    source: definition.source,
+    version: definition.version,
+    config: inputs
+  };
+  return {
+    name,
+    output(key) {
+      return expr(`module.${name}.${String(key)}`);
+    },
+    config
+  };
+}
+function moduleOutput(moduleName, outputName) {
+  return expr(`module.${moduleName}.${outputName}`);
+}
+function resourceRef(type, name, attribute) {
+  return expr(`${type}.${name}.${attribute}`);
+}
+function dataRef(type, name, attribute) {
+  return expr(`data.${type}.${name}.${attribute}`);
+}
+function varRef(name) {
+  return expr(`var.${name}`);
+}
+function localRef(name) {
+  return expr(`local.${name}`);
+}
+var tf = {
+  /** file() function */
+  file: (path) => expr(`file("${path}")`),
+  /** templatefile() function */
+  templatefile: (path, vars) => expr(`templatefile("${path}", ${vars})`),
+  /** jsonencode() function */
+  jsonencode: (value) => expr(`jsonencode(${value})`),
+  /** jsondecode() function */
+  jsondecode: (value) => expr(`jsondecode(${value})`),
+  /** lookup() function */
+  lookup: (map, key, defaultValue) => defaultValue !== void 0 ? expr(`lookup(${map}, "${key}", ${defaultValue})`) : expr(`lookup(${map}, "${key}")`),
+  /** element() function */
+  element: (list, index) => expr(`element(${list}, ${index})`),
+  /** length() function */
+  length: (value) => expr(`length(${value})`),
+  /** coalesce() function */
+  coalesce: (...values) => expr(`coalesce(${values.join(", ")})`),
+  /** join() function */
+  join: (separator, list) => expr(`join("${separator}", ${list})`),
+  /** split() function */
+  split: (separator, value) => expr(`split("${separator}", ${value})`),
+  /** format() function */
+  format: (formatStr, ...args) => expr(`format("${formatStr}", ${args.join(", ")})`),
+  /** each.key */
+  eachKey: expr("each.key"),
+  /** each.value */
+  eachValue: expr("each.value"),
+  /** count.index */
+  countIndex: expr("count.index"),
+  /** self reference */
+  self: (attribute) => expr(`self.${attribute}`),
+  /** path.module */
+  pathModule: expr("path.module"),
+  /** path.root */
+  pathRoot: expr("path.root"),
+  /** path.cwd */
+  pathCwd: expr("path.cwd"),
+  /** terraform.workspace */
+  workspace: expr("terraform.workspace")
+};
+
+// src/modules/cloudflare/worker.ts
+function cloudflareWorkerScript(config) {
+  const resourceConfig = {
+    account_id: config.accountId,
+    name: config.name,
+    content: config.content,
+    module: config.module ?? true
+  };
+  if (config.compatibilityDate) {
+    resourceConfig.compatibility_date = config.compatibilityDate;
+  }
+  if (config.compatibilityFlags?.length) {
+    resourceConfig.compatibility_flags = config.compatibilityFlags;
+  }
+  if (config.logpush !== void 0) {
+    resourceConfig.logpush = config.logpush;
+  }
+  const bindings = [];
+  if (config.kvNamespaces?.length) {
+    for (const kv of config.kvNamespaces) {
+      bindings.push({
+        type: "kv_namespace",
+        name: kv.name,
+        namespace_id: kv.namespaceId
+      });
+    }
+  }
+  if (config.d1Databases?.length) {
+    for (const d1 of config.d1Databases) {
+      bindings.push({
+        type: "d1_database",
+        name: d1.name,
+        database_id: d1.databaseId
+      });
+    }
+  }
+  if (config.r2Buckets?.length) {
+    for (const r2 of config.r2Buckets) {
+      bindings.push({
+        type: "r2_bucket",
+        name: r2.name,
+        bucket_name: r2.bucketName
+      });
+    }
+  }
+  if (config.plainTextBindings) {
+    for (const [name, value] of Object.entries(config.plainTextBindings)) {
+      bindings.push({
+        type: "plain_text",
+        name,
+        text: value
+      });
+    }
+  }
+  if (config.secretTextBindings) {
+    for (const [name, value] of Object.entries(config.secretTextBindings)) {
+      bindings.push({
+        type: "secret_text",
+        name,
+        text: value
+      });
+    }
+  }
+  if (config.serviceBindings?.length) {
+    for (const svc of config.serviceBindings) {
+      bindings.push({
+        type: "service",
+        name: svc.name,
+        service: svc.service,
+        ...svc.environment ? { environment: svc.environment } : {}
+      });
+    }
+  }
+  if (bindings.length > 0) {
+    resourceConfig.bindings = bindings;
+  }
+  return {
+    type: "cloudflare_workers_script",
+    name: config.name.replace(/-/g, "_"),
+    config: resourceConfig
+  };
+}
+function cloudflareWorkerRoute(config) {
+  const routeName = config.pattern.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return {
+    type: "cloudflare_workers_route",
+    name: routeName,
+    config: {
+      zone_id: config.zoneId,
+      pattern: config.pattern,
+      script_name: config.scriptName
+    }
+  };
+}
+function cloudflareWorkerDomain(config) {
+  const domainName = config.hostname.replace(/[^a-zA-Z0-9]/g, "_");
+  return {
+    type: "cloudflare_workers_domain",
+    name: domainName,
+    config: {
+      account_id: config.accountId,
+      zone_id: config.zoneId,
+      hostname: config.hostname,
+      service: config.service,
+      environment: config.environment ?? "production"
+    }
+  };
+}
+function workerScriptRef(name, attribute = "id") {
+  return expr(`cloudflare_workers_script.${name}.${attribute}`);
+}
+
+// src/modules/cloudflare/kv.ts
+function cloudflareKvNamespace(config) {
+  const resourceName = config.title.toLowerCase().replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return {
+    type: "cloudflare_workers_kv_namespace",
+    name: resourceName,
+    config: {
+      account_id: config.accountId,
+      title: config.title
+    }
+  };
+}
+function cloudflareKvPair(config) {
+  const resourceName = config.key.toLowerCase().replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return {
+    type: "cloudflare_workers_kv",
+    name: resourceName,
+    config: {
+      account_id: config.accountId,
+      namespace_id: config.namespaceId,
+      key: config.key,
+      value: config.value
+    }
+  };
+}
+function kvNamespaceRef(name, attribute = "id") {
+  return expr(`cloudflare_workers_kv_namespace.${name}.${attribute}`);
+}
+function cloudflareKvNamespaces(accountId, baseName, environments = ["production", "staging", "development"]) {
+  return environments.map((env) => ({
+    type: "cloudflare_workers_kv_namespace",
+    name: `${baseName.replace(/-/g, "_")}_${env}`,
+    config: {
+      account_id: accountId,
+      title: `${baseName}-${env}`
+    }
+  }));
+}
+function cloudflareKvBulk(config) {
+  const prefix = config.namePrefix ?? "kv";
+  return Object.entries(config.entries).map(([key, value], index) => ({
+    type: "cloudflare_workers_kv",
+    name: `${prefix}_${index}`,
+    config: {
+      account_id: config.accountId,
+      namespace_id: config.namespaceId,
+      key,
+      value
+    }
+  }));
+}
+
+// src/modules/cloudflare/d1.ts
+function cloudflareD1Database(config) {
+  const resourceName = config.name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return {
+    type: "cloudflare_d1_database",
+    name: resourceName,
+    config: {
+      account_id: config.accountId,
+      name: config.name
+    }
+  };
+}
+function d1DatabaseRef(name, attribute = "id") {
+  return expr(`cloudflare_d1_database.${name}.${attribute}`);
+}
+function cloudflareD1Databases(accountId, baseName, environments = ["production", "staging", "development"]) {
+  return environments.map((env) => ({
+    type: "cloudflare_d1_database",
+    name: `${baseName.replace(/-/g, "_")}_${env}`,
+    config: {
+      account_id: accountId,
+      name: `${baseName}-${env}`
+    }
+  }));
+}
+function d1DatabaseOutputs(config) {
+  const prefix = config.prefix ?? config.resourceName;
+  return {
+    [`${prefix}_id`]: {
+      value: d1DatabaseRef(config.resourceName, "id"),
+      description: `ID of the ${config.resourceName} D1 database`
+    },
+    [`${prefix}_name`]: {
+      value: d1DatabaseRef(config.resourceName, "name"),
+      description: `Name of the ${config.resourceName} D1 database`
+    }
+  };
+}
+
+// src/modules/cloudflare/r2.ts
+function cloudflareR2Bucket(config) {
+  const resourceName = config.name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  const resourceConfig = {
+    account_id: config.accountId,
+    name: config.name
+  };
+  if (config.location) {
+    resourceConfig.location = config.location;
+  }
+  return {
+    type: "cloudflare_r2_bucket",
+    name: resourceName,
+    config: resourceConfig
+  };
+}
+function r2BucketRef(name, attribute = "name") {
+  return expr(`cloudflare_r2_bucket.${name}.${attribute}`);
+}
+function cloudflareR2Buckets(accountId, buckets) {
+  return buckets.map((bucket) => cloudflareR2Bucket({
+    accountId,
+    name: bucket.name,
+    location: bucket.location
+  }));
+}
+function r2BucketOutputs(resourceName, prefix) {
+  const outputPrefix = prefix ?? resourceName;
+  return {
+    [`${outputPrefix}_name`]: {
+      value: r2BucketRef(resourceName, "name"),
+      description: `Name of the ${resourceName} R2 bucket`
+    },
+    [`${outputPrefix}_id`]: {
+      value: r2BucketRef(resourceName, "id"),
+      description: `ID of the ${resourceName} R2 bucket`
+    }
+  };
+}
+function cloudflareR2BucketsForEnvs(accountId, baseName, environments = ["production", "staging", "development"], location) {
+  return environments.map((env) => ({
+    type: "cloudflare_r2_bucket",
+    name: `${baseName.replace(/-/g, "_")}_${env}`,
+    config: {
+      account_id: accountId,
+      name: `${baseName}-${env}`,
+      ...location ? { location } : {}
+    }
+  }));
+}
+
+// src/modules/cloudflare/index.ts
+var cloudflareProvider = {
+  source: "cloudflare/cloudflare",
+  version: "~> 4.0"
+};
+var cloudflareVariables = {
+  account_id: {
+    type: "string",
+    description: "Cloudflare Account ID",
+    sensitive: true
+  },
+  api_token: {
+    type: "string",
+    description: "Cloudflare API Token",
+    sensitive: true
+  },
+  zone_id: {
+    type: "string",
+    description: "Cloudflare Zone ID"
+  }
+};
+var cfAccountId = expr("var.cloudflare_account_id");
+var cfZoneId = expr("var.cloudflare_zone_id");
+export {
+  BackendBuilder,
+  TerraformConfigBuilder,
+  TfvarsBuilder,
+  azureBackend,
+  backend,
+  backends,
+  cfAccountId,
+  cfZoneId,
+  cloudflareD1Database,
+  cloudflareD1Databases,
+  cloudflareKvBulk,
+  cloudflareKvNamespace,
+  cloudflareKvNamespaces,
+  cloudflareKvPair,
+  cloudflareProvider,
+  cloudflareR2Bucket,
+  cloudflareR2Buckets,
+  cloudflareR2BucketsForEnvs,
+  cloudflareVariables,
+  cloudflareWorkerDomain,
+  cloudflareWorkerRoute,
+  cloudflareWorkerScript,
+  consulBackend,
+  createFileWriter,
+  d1DatabaseOutputs,
+  d1DatabaseRef,
+  dataRef,
+  defineModule,
+  expr,
+  formatBlock,
+  formatForTfvars,
+  gcsBackend,
+  generateDataSource,
+  generateEnvTfvars,
+  generateLocals,
+  generateModule,
+  generateOutput,
+  generateProvider,
+  generateResource,
+  generateTerraformBlock,
+  generateTerraformConfig,
+  generateTerraformFile,
+  generateTerraformFiles,
+  generateTfvars,
+  generateVariable,
+  isHclExpression,
+  kvNamespaceRef,
+  localBackend,
+  localRef,
+  mergeTfvars,
+  moduleOutput,
+  providers,
+  r2BucketOutputs,
+  r2BucketRef,
+  resourceRef,
+  s3Backend,
+  terraform,
+  terraformCloudBackend,
+  tf,
+  tfvars,
+  tfvarsFromEnv,
+  toHcl,
+  useModule,
+  varRef,
+  workerScriptRef
+};