@vertile-ai/iac 0.0.1 → 0.1.0

package/src/core/context.mjs

@@ -34,6 +34,8 @@ export function resolvePlatformContext(argv) {
   }
 }
 
-export function targetWorkspace(context, target) {
-  return path.join(context.generatedRoot, target)
+export function targetWorkspace(context, target, deploymentName = '') {
+  return deploymentName
+    ? path.join(context.generatedRoot, target, deploymentName)
+    : path.join(context.generatedRoot, target)
 }

package/src/core/deployments.mjs

@@ -0,0 +1,39 @@
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+}
+
+export function providerDeployments(manifest, target) {
+  return asObject(asObject(manifest.providers[target]).deployments)
+}
+
+export function resolveDeployment({ manifest, target, environment, deploymentName = '' }) {
+  const deployments = providerDeployments(manifest, target)
+  const name = deploymentName || (deployments[environment] ? environment : '')
+
+  if (!name) {
+    return {
+      name: '',
+      environment,
+      values: {},
+    }
+  }
+
+  if (!deployments[name] && Object.keys(deployments).length === 0) {
+    return {
+      name: '',
+      environment,
+      values: {},
+    }
+  }
+
+  if (!deployments[name]) {
+    throw new Error(`Unknown ${target} deployment "${name}". Use one of: ${Object.keys(deployments).join(', ')}`)
+  }
+
+  const values = asObject(deployments[name])
+  return {
+    name,
+    environment: values.environment || environment,
+    values,
+  }
+}

package/src/core/env-files.mjs

@@ -0,0 +1,38 @@
+const defaultEnvironmentFiles = {
+  development: ['.env.development'],
+  local: ['.env.local'],
+  preview: ['.env.staging'],
+  production: ['.env.production'],
+  staging: ['.env.staging'],
+  test: ['.env.test'],
+}
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+}
+
+function asFiles(value) {
+  if (Array.isArray(value)) return value
+  if (typeof value === 'string' && value.trim()) return [value]
+  return []
+}
+
+export function environmentConfig(manifest, environment) {
+  const configured = asObject(asObject(manifest.env).environments)[environment]
+  if (typeof configured === 'string' || Array.isArray(configured)) {
+    return { files: asFiles(configured) }
+  }
+  return asObject(configured)
+}
+
+export function environmentFiles(manifest, environment) {
+  const config = environmentConfig(manifest, environment)
+  const files = asFiles(config.files || config.sources || config.file)
+  if (files.length > 0) return files
+  return defaultEnvironmentFiles[environment] || [`.env.${environment}`]
+}
+
+export function environmentOutputFile(manifest, environment) {
+  const config = environmentConfig(manifest, environment)
+  return config.output || config.outputFile || defaultEnvironmentFiles[environment]?.[0] || `.env.${environment}`
+}

package/src/core/env-source.mjs

@@ -0,0 +1,5 @@
+export const defaultEnvSourceDir = '.vertile-iac/env'
+
+export function envSourceDir(manifest) {
+  return manifest.env.sourceDir || defaultEnvSourceDir
+}

package/src/core/hcl.mjs

@@ -81,10 +81,11 @@ export function renderGenericResources(resources = []) {
     .join('\n\n')
 }
 
-export function renderLocals(manifest, environment) {
+export function renderLocals(manifest, environment, deployment = {}) {
   return block('locals', [], {
     project_name: manifest.project.name,
     environment,
+    deployment: deployment.name || undefined,
   })
 }
 

package/src/core/manifest.mjs

@@ -56,6 +56,20 @@ function validateProviderResources(providers) {
   }
 }
 
+function validateProviderDeployments(manifest) {
+  for (const [provider, config] of Object.entries(manifest.providers)) {
+    const deployments = asObject(config.deployments)
+    for (const [name, deployment] of Object.entries(deployments)) {
+      const environment = asObject(deployment).environment
+      if (environment && !manifest.environments.includes(environment)) {
+        throw new Error(
+          `iac.json providers.${provider}.deployments.${name}.environment must be one of: ${manifest.environments.join(', ')}`,
+        )
+      }
+    }
+  }
+}
+
 export function validateManifest(manifest) {
   if (manifest.version !== 1) {
     throw new Error(`Unsupported iac.json version "${manifest.version}". Expected version 1.`)
@@ -65,6 +79,7 @@ export function validateManifest(manifest) {
   }
   assertStringArray(manifest.environments, 'environments')
   validateProviderResources(manifest.providers)
+  validateProviderDeployments(manifest)
 }
 
 export function normalizeManifest(rawManifest) {
@@ -80,7 +95,6 @@ export function normalizeManifest(rawManifest) {
     providers: asObject(manifest.providers),
     apps: Array.isArray(manifest.apps) ? manifest.apps.map(normalizeApp) : [],
     domains: Array.isArray(manifest.domains) ? manifest.domains : [],
-    infraDir: manifest.infraDir,
     objectStorage: normalizeKeyedList(manifest, 'objectStorage'),
     databases: normalizeKeyedList(manifest, 'databases'),
     queues: normalizeKeyedList(manifest, 'queues'),

package/src/core/render.mjs

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { targetWorkspace } from './context.mjs'
+import { resolveDeployment } from './deployments.mjs'
+import { assertEnvironment } from './manifest.mjs'
 import { renderTerraform as renderAws } from '../providers/aws/index.mjs'
 import { renderTerraform as renderDigitalOcean } from '../providers/digitalocean/index.mjs'
 import { renderTerraform as renderVercel } from '../providers/vercel/index.mjs'
@@ -11,28 +13,37 @@ const renderers = {
   vercel: renderVercel,
 }
 
-export function renderTarget({ manifest, environment, target }) {
+export function renderTarget({ manifest, environment, target, deploymentName = '' }) {
   const render = renderers[target]
   if (!render) throw new Error(`No renderer registered for target "${target}".`)
-  return render({ manifest, environment })
+  const deployment = resolveDeployment({ manifest, target, environment, deploymentName })
+  assertEnvironment(manifest, deployment.environment)
+  return render({ manifest, environment: deployment.environment, deployment })
 }
 
-export async function writeTarget({ context, manifest, environment, target }) {
-  const workspace = targetWorkspace(context, target)
-  const files = renderTarget({ manifest, environment, target })
+export async function writeTarget({ context, manifest, environment, target, deploymentName = '' }) {
+  const deployment = resolveDeployment({ manifest, target, environment, deploymentName })
+  assertEnvironment(manifest, deployment.environment)
+  const workspace = targetWorkspace(context, target, deployment.name)
+  const files = renderTarget({
+    manifest,
+    environment: deployment.environment,
+    target,
+    deploymentName: deployment.name,
+  })
   await fs.mkdir(workspace, { recursive: true })
 
   for (const [name, contents] of Object.entries(files)) {
     await fs.writeFile(path.join(workspace, name), contents)
   }
 
-  return { workspace, files }
+  return { workspace, files, deployment }
 }
 
-export async function writeTargets({ context, manifest, environment, targets }) {
+export async function writeTargets({ context, manifest, environment, targets, deploymentName = '' }) {
   const rendered = []
   for (const target of targets) {
-    rendered.push(await writeTarget({ context, manifest, environment, target }))
+    rendered.push(await writeTarget({ context, manifest, environment, target, deploymentName }))
   }
   return rendered
 }

package/src/core/vercel-manifests.mjs

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import { envSourceDir } from './env-source.mjs'
 import { readManifest } from './manifest.mjs'
 
 const projectSettingKeys = [
@@ -50,16 +51,6 @@ function teamSlugFromManifest(manifest) {
   return config.teamSlug || config.team || ''
 }
 
-function envSourceDir(manifest) {
-  return (
-    manifest.env.sourceDir ||
-    manifest.env.dir ||
-    manifest.env.infraDir ||
-    manifest.infraDir ||
-    'infrastructure'
-  )
-}
-
 function configuredProjects(manifest) {
   return manifest.apps.map((app) => {
     const values = appVercelValues(app)
@@ -130,9 +121,12 @@ function projectDomains(manifest) {
 }
 
 export function vercelEnvManifestFromIac(manifest, context = {}) {
+  const config = vercelConfig(manifest)
   return {
     teamSlug: teamSlugFromManifest(manifest),
-    infraDir: context.infraDir || envSourceDir(manifest),
+    sourceDir: envSourceDir(manifest),
+    environmentFiles: manifest.env?.environments || {},
+    targets: config.env?.targets || {},
     projects: configuredProjects(manifest),
   }
 }

package/src/plan.mjs

@@ -3,7 +3,7 @@
 import process from 'node:process'
 import { parseTargetOption, readOption } from './core/args.mjs'
 import { resolvePlatformContext } from './core/context.mjs'
-import { assertEnvironment, readManifest } from './core/manifest.mjs'
+import { readManifest } from './core/manifest.mjs'
 import { writeTargets } from './core/render.mjs'
 import { terraformPlan } from './core/terraform.mjs'
 
@@ -12,11 +12,10 @@ async function main() {
   const context = resolvePlatformContext(argv)
   const manifest = readManifest(context.manifestPath)
   const environment = readOption(argv, '--env') || 'production'
+  const deploymentName = readOption(argv, '--deployment') || ''
   const targets = parseTargetOption(argv)
 
-  assertEnvironment(manifest, environment)
-
-  const rendered = await writeTargets({ context, manifest, environment, targets })
+  const rendered = await writeTargets({ context, manifest, environment, targets, deploymentName })
   for (const item of rendered) {
     console.log(`Planning ${item.workspace}`)
     terraformPlan({

package/src/providers/aws/index.mjs

@@ -16,38 +16,54 @@ import {
   terraformVariableName,
 } from '../../core/concepts.mjs'
 
-function providerBlock(manifest, environment) {
+function deploymentLabel(environment, deployment = {}) {
+  return deployment.name || environment
+}
+
+function providerBlock(manifest, environment, deployment = {}) {
   const config = manifest.providers.aws || {}
+  const deploymentValues = deployment.values || {}
   const body = {
-    region: config.region,
+    region: deploymentValues.region || config.region,
+    profile: deploymentValues.profile || config.profile,
   }
-  const tags = {
+  const tags = compactBody({
     Project: manifest.project.name,
     Environment: environment,
+    Deployment: deployment.name || undefined,
     ...(config.defaultTags || {}),
-  }
+    ...(deploymentValues.tags || {}),
+  })
 
   const provider = block('provider', ['aws'], body)
-  if (Object.keys(tags).length === 0) return provider
+  const assumeRole = deploymentValues.assumeRole || deploymentValues.assume_role || config.assumeRole || config.assume_role
+  const assumeRoleBlock = assumeRole
+    ? `\n  ${nestedBlock('assume_role', assumeRole).replace(/\n/g, '\n  ')}`
+    : ''
+  const defaultTagsBlock = Object.keys(tags).length > 0
+    ? `\n  ${nestedBlock('default_tags', { tags }).replace(/\n/g, '\n  ')}`
+    : ''
 
-  return `${provider.slice(0, -1)}\n  ${nestedBlock('default_tags', { tags }).replace(/\n/g, '\n  ')}\n}`
+  return `${provider.slice(0, -1)}${assumeRoleBlock}${defaultTagsBlock}\n}`
 }
 
-function objectStorageBlocks(manifest, environment) {
+function objectStorageBlocks(manifest, environment, deployment = {}) {
+  const nameEnvironment = deploymentLabel(environment, deployment)
   return manifest.objectStorage.map((item) => {
     const values = providerValues(item, 'aws')
     return block('resource', ['aws_s3_bucket', resourceName('object_storage', item.key)], compactBody({
-      bucket: values.bucket || providerResourceName(manifest, environment, item),
+      bucket: values.bucket || providerResourceName(manifest, nameEnvironment, item),
       force_destroy: values.forceDestroy,
     }))
   })
 }
 
-function queueBlocks(manifest, environment) {
+function queueBlocks(manifest, environment, deployment = {}) {
+  const nameEnvironment = deploymentLabel(environment, deployment)
   return manifest.queues.map((item) => {
     const values = providerValues(item, 'aws')
     const fifo = values.fifo || item.kind === 'fifo'
-    const baseName = values.name || providerResourceName(manifest, environment, item)
+    const baseName = values.name || providerResourceName(manifest, nameEnvironment, item)
     return block('resource', ['aws_sqs_queue', resourceName('queue', item.key)], compactBody({
       name: fifo && !baseName.endsWith('.fifo') ? `${baseName}.fifo` : baseName,
       fifo_queue: fifo || undefined,
@@ -57,12 +73,13 @@ function queueBlocks(manifest, environment) {
   })
 }
 
-function databaseBlocks(manifest, environment) {
+function databaseBlocks(manifest, environment, deployment = {}) {
+  const nameEnvironment = deploymentLabel(environment, deployment)
   return manifest.databases.map((item) => {
     const values = providerValues(item, 'aws')
     const variable = terraformVariableName('database', item.key, 'password')
     return block('resource', ['aws_db_instance', resourceName('database', item.key)], compactBody({
-      identifier: values.identifier || providerResourceName(manifest, environment, item),
+      identifier: values.identifier || providerResourceName(manifest, nameEnvironment, item),
       engine: values.engine || item.engine || 'postgres',
       engine_version: values.engineVersion,
       instance_class: values.instanceClass || 'db.t4g.micro',
@@ -101,19 +118,21 @@ function amazonLinuxDataSource() {
   ].join('\n')
 }
 
-function computeBlocks(manifest, environment, field, prefix) {
+function computeBlocks(manifest, environment, deployment, field, prefix) {
+  const nameEnvironment = deploymentLabel(environment, deployment)
   return manifest[field].map((item) => {
     const values = providerValues(item, 'aws')
     return block('resource', ['aws_instance', resourceName(prefix, item.key)], compactBody({
       ami: values.ami ? values.ami : raw('data.aws_ami.amazon_linux.id'),
       instance_type: values.instanceType || 't3.micro',
       count: field === 'clusters' ? values.size || item.size || 1 : undefined,
-      tags: {
-        Name: values.name || providerResourceName(manifest, environment, item),
+      tags: compactBody({
+        Name: values.name || providerResourceName(manifest, nameEnvironment, item),
         Project: manifest.project.name,
         Environment: environment,
+        Deployment: deployment.name || undefined,
         Kind: prefix,
-      },
+      }),
     }))
   })
 }
@@ -127,19 +146,19 @@ function outputBlocks(manifest) {
   ))
 }
 
-export function renderTerraform({ manifest, environment }) {
+export function renderTerraform({ manifest, environment, deployment = {} }) {
   const config = manifest.providers.aws || {}
   const resources = renderGenericResources(config.resources)
   const needsAmazonLinux = manifest.sandboxes.length > 0 || manifest.clusters.length > 0
   const mainBlocks = [
-    renderLocals(manifest, environment),
-    providerBlock(manifest, environment),
+    renderLocals(manifest, environment, deployment),
+    providerBlock(manifest, environment, deployment),
     needsAmazonLinux ? amazonLinuxDataSource() : '',
-    ...objectStorageBlocks(manifest, environment),
-    ...queueBlocks(manifest, environment),
-    ...databaseBlocks(manifest, environment),
-    ...computeBlocks(manifest, environment, 'sandboxes', 'sandbox'),
-    ...computeBlocks(manifest, environment, 'clusters', 'cluster'),
+    ...objectStorageBlocks(manifest, environment, deployment),
+    ...queueBlocks(manifest, environment, deployment),
+    ...databaseBlocks(manifest, environment, deployment),
+    ...computeBlocks(manifest, environment, deployment, 'sandboxes', 'sandbox'),
+    ...computeBlocks(manifest, environment, deployment, 'clusters', 'cluster'),
     resources,
   ].filter(Boolean)
   const variableBlocks = databaseVariables(manifest)

package/src/provision-env.mjs

@@ -3,6 +3,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
+import { environmentFiles } from './core/env-files.mjs'
 import { readVercelEnvManifest } from './core/vercel-manifests.mjs'
 import { resolveIacContext } from './shared.mjs'
 
@@ -140,6 +141,20 @@ function parseEnvFile(filePath) {
   return entries
 }
 
+function mergeEntries(layers) {
+  const order = []
+  const values = new Map()
+
+  for (const layer of layers) {
+    for (const { key, value } of layer) {
+      if (!values.has(key)) order.push(key)
+      values.set(key, value)
+    }
+  }
+
+  return order.map((key) => ({ key, value: values.get(key) }))
+}
+
 function readTokenFromFile(filePath) {
   if (!fs.existsSync(filePath)) return ''
 
@@ -162,24 +177,50 @@ function readTokenFromFile(filePath) {
   return ''
 }
 
-// Maps a Vercel target name to the .env filename used in infrastructure folders.
-const targetToEnvFile = {
-  development: '.env.development',
-  staging: '.env.staging',
-  production: '.env.production',
+function targetEnvironment(manifest, target) {
+  const configured = manifest.targets?.[target]
+  if (typeof configured === 'string') return configured
+  if (configured && typeof configured === 'object' && configured.environment) {
+    return configured.environment
+  }
+  return target === 'preview' ? 'staging' : target
 }
 
-function readInfraScopedEntries(infraDir, target, projects) {
-  const envFile = targetToEnvFile[target]
+function targetEnvFiles(manifest, environment) {
+  return environmentFiles({ env: { environments: manifest.environmentFiles || {} } }, environment)
+}
 
-  const teamEntries = parseEnvFile(path.join(rootDir, infraDir, 'shared', envFile))
+function readEnvFiles(baseDir, files, { requireFiles = false } = {}) {
+  const filePaths = files.map((file) => path.join(baseDir, file))
+  const missing = filePaths.filter((filePath) => !fs.existsSync(filePath))
 
-  const projectEntries = Object.fromEntries(
-    projects.map((project) => [
-      project.key,
-      parseEnvFile(path.join(rootDir, infraDir, project.key, envFile)),
-    ]),
-  )
+  if (requireFiles && missing.length > 0) {
+    throw new Error(
+      `Missing required env source file(s) for --reconcile-delete: ${missing.map((filePath) => path.relative(rootDir, filePath)).join(', ')}`,
+    )
+  }
+
+  return mergeEntries(filePaths.map(parseEnvFile))
+}
+
+function readSourceScopedEntries(sourceDir, environment, projects, files, options = {}) {
+  const {
+    readTeam = true,
+    readProjects = true,
+    ...readOptions
+  } = options
+  const teamEntries = readTeam
+    ? readEnvFiles(path.join(rootDir, sourceDir, 'shared'), files, readOptions)
+    : []
+
+  const projectEntries = readProjects
+    ? Object.fromEntries(
+        projects.map((project) => [
+          project.key,
+          readEnvFiles(path.join(rootDir, sourceDir, project.key), files, readOptions),
+        ]),
+      )
+    : {}
 
   return { teamEntries, projectEntries }
 }
@@ -631,13 +672,13 @@ async function main() {
   const teamSlug = manifest.teamSlug
   const projects = Array.isArray(manifest.projects) ? manifest.projects : []
   const configuredProjects = [...projects]
-  const infraDir = iacContext.infraDir || manifest.infraDir
+  const sourceDir = manifest.sourceDir
 
   if (!teamSlug) {
     throw new Error('Missing "teamSlug" in env manifest')
   }
-  if (!infraDir) {
-    throw new Error('Missing "infraDir" in env manifest')
+  if (!sourceDir) {
+    throw new Error('Missing "sourceDir" in env manifest')
   }
 
   let teamId = ''
@@ -746,12 +787,16 @@ async function main() {
     `${c.bold('Mode:')} ${dryRun ? c.yellow('dry-run') : c.green('apply')} ${c.gray('|')} scope=${c.cyan(args.scope)} ${c.gray('|')} targets=${c.cyan(args.targets.join(','))} ${c.gray('|')} reconcile-delete=${c.cyan(args.reconcileDelete ? 'on' : 'off')}`,
   )
 
-  // preview deployments read from the staging env files
-  const resolvedTarget = (target) => (target === 'preview' ? 'staging' : target)
-
   if (args.scope === 'team' || args.scope === 'all') {
     for (const target of args.targets) {
-      const parsed = readInfraScopedEntries(infraDir, resolvedTarget(target), projects)
+      const environment = targetEnvironment(manifest, target)
+      const parsed = readSourceScopedEntries(
+        sourceDir,
+        environment,
+        [],
+        targetEnvFiles(manifest, environment),
+        { requireFiles: args.reconcileDelete, readProjects: false },
+      )
       await upsertTeamShared({
         token,
         dryRun,
@@ -767,10 +812,13 @@ async function main() {
   if (args.scope === 'projects' || args.scope === 'all') {
     const parsedByTarget = {}
     for (const target of args.targets) {
-      parsedByTarget[target] = readInfraScopedEntries(
-        infraDir,
-        resolvedTarget(target),
+      const environment = targetEnvironment(manifest, target)
+      parsedByTarget[target] = readSourceScopedEntries(
+        sourceDir,
+        environment,
         selectedProjects,
+        targetEnvFiles(manifest, environment),
+        { requireFiles: args.reconcileDelete, readTeam: false },
       )
     }
 

package/src/render.mjs

@@ -3,7 +3,7 @@
 import process from 'node:process'
 import { parseTargetOption, readOption } from './core/args.mjs'
 import { resolvePlatformContext } from './core/context.mjs'
-import { assertEnvironment, readManifest } from './core/manifest.mjs'
+import { readManifest } from './core/manifest.mjs'
 import { writeTargets } from './core/render.mjs'
 
 async function main() {
@@ -11,11 +11,10 @@ async function main() {
   const context = resolvePlatformContext(argv)
   const manifest = readManifest(context.manifestPath)
   const environment = readOption(argv, '--env') || 'production'
+  const deploymentName = readOption(argv, '--deployment') || ''
   const targets = parseTargetOption(argv)
 
-  assertEnvironment(manifest, environment)
-
-  const rendered = await writeTargets({ context, manifest, environment, targets })
+  const rendered = await writeTargets({ context, manifest, environment, targets, deploymentName })
   for (const item of rendered) {
     console.log(`Rendered ${item.workspace}`)
   }

package/src/shared.mjs

@@ -55,8 +55,6 @@ export function resolveIacContext(argv, defaults = {}) {
   const projectSettingsArg = readOption(argv, '--project-settings')
   const projectDomainsArg = readOption(argv, '--project-domains')
   const iacManifestArg = readOption(argv, '--iac-manifest')
-  const infraDir =
-    readOption(argv, '--infra-dir') || defaults.infraDir || ''
 
   const autoCreateKeys = new Set([
     ...splitList(defaults.autoCreateKeys || ''),
@@ -70,7 +68,6 @@ export function resolveIacContext(argv, defaults = {}) {
   return {
     repoRoot,
     iacDir,
-    infraDir,
     manifestPath: resolveFrom(
       repoRoot,
       manifestArg || path.relative(repoRoot, path.join(iacDir, 'env-manifest.json')),
@@ -109,7 +106,6 @@ export function sharedOptionsHelp() {
   --project-settings <path>       Project settings manifest path.
   --project-domains <path>        Project domains manifest path.
   --iac-manifest <path>           Unified IaC manifest path. Defaults to <iac-dir>/iac.json.
-  --infra-dir <path>              Override manifest infraDir.
   --token-file <path>             Token file. Defaults to <repo-root>/.vercel.token.
   --auto-create-keys <a,b>        Project keys allowed to be created in apply mode.
   --auto-create-prefixes <a,b>    Project key prefixes allowed to be created in apply mode.`