@vertile-ai/iac 0.0.1

package/src/core/manifest.mjs

@@ -0,0 +1,110 @@
+import fs from 'node:fs'
+
+function asObject(value, fallback = {}) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : fallback
+}
+
+function normalizeProject(project) {
+  if (typeof project === 'string') return { name: project }
+  const normalized = asObject(project)
+  return {
+    name: normalized.name || normalized.key || 'project',
+    ...normalized,
+  }
+}
+
+function normalizeApp(app) {
+  const normalized = asObject(app)
+  if (!normalized.key) {
+    throw new Error('Each iac.json app must include a key.')
+  }
+
+  return {
+    name: normalized.name || normalized.key,
+    ...normalized,
+  }
+}
+
+function normalizeKeyedList(manifest, field) {
+  if (!Array.isArray(manifest[field])) return []
+
+  return manifest[field].map((item) => {
+    const normalized = asObject(item)
+    if (!normalized.key) {
+      throw new Error(`Each iac.json ${field} item must include a key.`)
+    }
+    return normalized
+  })
+}
+
+function assertStringArray(value, field) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.trim() === '')) {
+    throw new Error(`iac.json ${field} must be an array of non-empty strings.`)
+  }
+}
+
+function validateProviderResources(providers) {
+  for (const [provider, config] of Object.entries(providers)) {
+    const resources = config && Array.isArray(config.resources) ? config.resources : []
+    for (const resource of resources) {
+      if (!resource.type || !resource.name) {
+        throw new Error(
+          `iac.json providers.${provider}.resources items must include type and name.`,
+        )
+      }
+    }
+  }
+}
+
+export function validateManifest(manifest) {
+  if (manifest.version !== 1) {
+    throw new Error(`Unsupported iac.json version "${manifest.version}". Expected version 1.`)
+  }
+  if (!manifest.project.name || typeof manifest.project.name !== 'string') {
+    throw new Error('iac.json project.name must be a non-empty string.')
+  }
+  assertStringArray(manifest.environments, 'environments')
+  validateProviderResources(manifest.providers)
+}
+
+export function normalizeManifest(rawManifest) {
+  const manifest = asObject(rawManifest)
+  const environments = Array.isArray(manifest.environments)
+    ? manifest.environments
+    : ['development', 'preview', 'production']
+
+  const normalized = {
+    version: manifest.version || 1,
+    project: normalizeProject(manifest.project),
+    environments,
+    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'),
+    sandboxes: normalizeKeyedList(manifest, 'sandboxes'),
+    clusters: normalizeKeyedList(manifest, 'clusters'),
+    env: asObject(manifest.env),
+  }
+
+  validateManifest(normalized)
+  return normalized
+}
+
+export function readManifest(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Missing required iac manifest: ${filePath}`)
+  }
+
+  return normalizeManifest(JSON.parse(fs.readFileSync(filePath, 'utf8')))
+}
+
+export function assertEnvironment(manifest, environment) {
+  if (!manifest.environments.includes(environment)) {
+    throw new Error(
+      `Unknown environment "${environment}". Use one of: ${manifest.environments.join(', ')}`,
+    )
+  }
+}

package/src/core/render.mjs

@@ -0,0 +1,38 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { targetWorkspace } from './context.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'
+
+const renderers = {
+  aws: renderAws,
+  digitalocean: renderDigitalOcean,
+  vercel: renderVercel,
+}
+
+export function renderTarget({ manifest, environment, target }) {
+  const render = renderers[target]
+  if (!render) throw new Error(`No renderer registered for target "${target}".`)
+  return render({ manifest, environment })
+}
+
+export async function writeTarget({ context, manifest, environment, target }) {
+  const workspace = targetWorkspace(context, target)
+  const files = renderTarget({ manifest, environment, target })
+  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 }
+}
+
+export async function writeTargets({ context, manifest, environment, targets }) {
+  const rendered = []
+  for (const target of targets) {
+    rendered.push(await writeTarget({ context, manifest, environment, target }))
+  }
+  return rendered
+}

package/src/core/terraform.mjs

@@ -0,0 +1,42 @@
+import { spawnSync } from 'node:child_process'
+
+function runTerraform({ terraformBin, workspace, args }) {
+  const result = spawnSync(terraformBin, args, {
+    cwd: workspace,
+    stdio: 'inherit',
+  })
+
+  if (result.error) {
+    throw new Error(`Failed to run ${terraformBin}: ${result.error.message}`)
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`${terraformBin} ${args.join(' ')} failed with exit code ${result.status}`)
+  }
+}
+
+export function terraformPlan({ terraformBin, workspace }) {
+  runTerraform({
+    terraformBin,
+    workspace,
+    args: ['init', '-input=false'],
+  })
+  runTerraform({
+    terraformBin,
+    workspace,
+    args: ['plan', '-input=false'],
+  })
+}
+
+export function terraformApply({ terraformBin, workspace, autoApprove = false }) {
+  runTerraform({
+    terraformBin,
+    workspace,
+    args: ['init', '-input=false'],
+  })
+  runTerraform({
+    terraformBin,
+    workspace,
+    args: ['apply', '-input=false', ...(autoApprove ? ['-auto-approve'] : [])],
+  })
+}

package/src/core/vercel-manifests.mjs

@@ -0,0 +1,179 @@
+import fs from 'node:fs'
+import { readManifest } from './manifest.mjs'
+
+const projectSettingKeys = [
+  'rootDirectory',
+  'nodeVersion',
+  'enableAffectedProjectsDeployments',
+]
+
+function readJSON(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Missing required file: ${filePath}`)
+  }
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+}
+
+function readUnifiedManifest(context, fallbackPath) {
+  if (!fs.existsSync(context.iacManifestPath)) {
+    throw new Error(`Missing required file: ${fallbackPath} or ${context.iacManifestPath}`)
+  }
+  return readManifest(context.iacManifestPath)
+}
+
+function readLegacyOrUnified({
+  legacyPath,
+  explicitLegacyPath,
+  context,
+  derive,
+}) {
+  if (fs.existsSync(legacyPath) || explicitLegacyPath) {
+    return readJSON(legacyPath)
+  }
+
+  return derive(readUnifiedManifest(context, legacyPath))
+}
+
+function vercelConfig(manifest) {
+  return manifest.providers.vercel || {}
+}
+
+function appVercelValues(app) {
+  return {
+    ...app,
+    ...((app.providers && app.providers.vercel) || {}),
+  }
+}
+
+function teamSlugFromManifest(manifest) {
+  const config = vercelConfig(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)
+    return {
+      key: app.key,
+      id: values.id || values.projectId || '',
+      name: values.name || app.name || app.key,
+    }
+  })
+}
+
+function compactObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== undefined),
+  )
+}
+
+function projectSettings(manifest) {
+  return manifest.apps.map((app) => {
+    const values = appVercelValues(app)
+    const entry = { key: app.key }
+    for (const key of projectSettingKeys) {
+      if (values[key] !== undefined) entry[key] = values[key]
+    }
+    return entry
+  })
+}
+
+function domainTarget(domain, fallback) {
+  if (fallback) return fallback
+  if (!domain || typeof domain !== 'object') return ''
+  return domain.app || domain.project || domain.key || ''
+}
+
+function domainConfig(domain) {
+  if (typeof domain === 'string') return domain
+  if (!domain || typeof domain !== 'object') return null
+
+  return compactObject({
+    name: domain.name,
+    gitBranch: domain.gitBranch,
+    verified: domain.verified,
+  })
+}
+
+function projectDomains(manifest) {
+  const domainsByProject = new Map(manifest.apps.map((app) => [app.key, []]))
+
+  for (const app of manifest.apps) {
+    const values = appVercelValues(app)
+    const domains = Array.isArray(values.domains) ? values.domains : []
+    for (const domain of domains) {
+      const config = domainConfig(domain)
+      if (config) domainsByProject.get(app.key).push(config)
+    }
+  }
+
+  for (const domain of manifest.domains) {
+    const target = domainTarget(domain)
+    if (!target) continue
+    const config = domainConfig(domain)
+    if (!config) continue
+    if (!domainsByProject.has(target)) domainsByProject.set(target, [])
+    domainsByProject.get(target).push(config)
+  }
+
+  return [...domainsByProject.entries()].map(([key, domains]) => ({ key, domains }))
+}
+
+export function vercelEnvManifestFromIac(manifest, context = {}) {
+  return {
+    teamSlug: teamSlugFromManifest(manifest),
+    infraDir: context.infraDir || envSourceDir(manifest),
+    projects: configuredProjects(manifest),
+  }
+}
+
+export function vercelProjectSettingsFromIac(manifest) {
+  const config = vercelConfig(manifest)
+  return compactObject({
+    defaults: config.projectDefaults || config.projectSettingsDefaults,
+    projects: projectSettings(manifest),
+  })
+}
+
+export function vercelProjectDomainsFromIac(manifest) {
+  return {
+    projects: projectDomains(manifest),
+  }
+}
+
+export function readVercelEnvManifest(context) {
+  return readLegacyOrUnified({
+    legacyPath: context.manifestPath,
+    explicitLegacyPath: context.explicitManifestPath,
+    context,
+    derive: (manifest) => vercelEnvManifestFromIac(manifest, context),
+  })
+}
+
+export function readVercelProjectSettingsManifest(context) {
+  return readLegacyOrUnified({
+    legacyPath: context.projectSettingsPath,
+    explicitLegacyPath: context.explicitProjectSettingsPath,
+    context,
+    derive: vercelProjectSettingsFromIac,
+  })
+}
+
+export function readVercelProjectDomainsManifest(context) {
+  return readLegacyOrUnified({
+    legacyPath: context.projectDomainsPath,
+    explicitLegacyPath: context.explicitProjectDomainsPath,
+    context,
+    derive: vercelProjectDomainsFromIac,
+  })
+}

package/src/plan.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+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 { writeTargets } from './core/render.mjs'
+import { terraformPlan } from './core/terraform.mjs'
+
+async function main() {
+  const argv = process.argv.slice(2)
+  const context = resolvePlatformContext(argv)
+  const manifest = readManifest(context.manifestPath)
+  const environment = readOption(argv, '--env') || 'production'
+  const targets = parseTargetOption(argv)
+
+  assertEnvironment(manifest, environment)
+
+  const rendered = await writeTargets({ context, manifest, environment, targets })
+  for (const item of rendered) {
+    console.log(`Planning ${item.workspace}`)
+    terraformPlan({
+      terraformBin: context.terraformBin,
+      workspace: item.workspace,
+    })
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message)
+  process.exit(1)
+})

package/src/providers/aws/index.mjs

@@ -0,0 +1,153 @@
+import {
+  block,
+  nestedBlock,
+  raw,
+  renderGenericResources,
+  renderLocals,
+  renderOutput,
+  renderRequiredProvider,
+  renderVariable,
+} from '../../core/hcl.mjs'
+import {
+  compactBody,
+  providerResourceName,
+  providerValues,
+  resourceName,
+  terraformVariableName,
+} from '../../core/concepts.mjs'
+
+function providerBlock(manifest, environment) {
+  const config = manifest.providers.aws || {}
+  const body = {
+    region: config.region,
+  }
+  const tags = {
+    Project: manifest.project.name,
+    Environment: environment,
+    ...(config.defaultTags || {}),
+  }
+
+  const provider = block('provider', ['aws'], body)
+  if (Object.keys(tags).length === 0) return provider
+
+  return `${provider.slice(0, -1)}\n  ${nestedBlock('default_tags', { tags }).replace(/\n/g, '\n  ')}\n}`
+}
+
+function objectStorageBlocks(manifest, environment) {
+  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),
+      force_destroy: values.forceDestroy,
+    }))
+  })
+}
+
+function queueBlocks(manifest, environment) {
+  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)
+    return block('resource', ['aws_sqs_queue', resourceName('queue', item.key)], compactBody({
+      name: fifo && !baseName.endsWith('.fifo') ? `${baseName}.fifo` : baseName,
+      fifo_queue: fifo || undefined,
+      visibility_timeout_seconds: values.visibilityTimeoutSeconds,
+      message_retention_seconds: values.messageRetentionSeconds,
+    }))
+  })
+}
+
+function databaseBlocks(manifest, environment) {
+  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),
+      engine: values.engine || item.engine || 'postgres',
+      engine_version: values.engineVersion,
+      instance_class: values.instanceClass || 'db.t4g.micro',
+      allocated_storage: values.allocatedStorage || 20,
+      db_name: values.databaseName || resourceName(item.key),
+      username: values.username || 'app',
+      password: raw(`var.${variable}`),
+      publicly_accessible: values.publiclyAccessible || false,
+      skip_final_snapshot: values.skipFinalSnapshot ?? true,
+    }))
+  })
+}
+
+function databaseVariables(manifest) {
+  return manifest.databases.map((item) => renderVariable(
+    terraformVariableName('database', item.key, 'password'),
+    {
+      type: raw('string'),
+      sensitive: true,
+      description: `Password for the ${item.key} database.`,
+    },
+  ))
+}
+
+function amazonLinuxDataSource() {
+  return [
+    'data "aws_ami" "amazon_linux" {',
+    '  most_recent = true',
+    '  owners      = ["amazon"]',
+    '',
+    '  filter {',
+    '    name   = "name"',
+    '    values = ["al2023-ami-*-x86_64"]',
+    '  }',
+    '}',
+  ].join('\n')
+}
+
+function computeBlocks(manifest, environment, field, prefix) {
+  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),
+        Project: manifest.project.name,
+        Environment: environment,
+        Kind: prefix,
+      },
+    }))
+  })
+}
+
+function outputBlocks(manifest) {
+  return manifest.objectStorage.map((item) => renderOutput(
+    resourceName('aws_object_storage', item.key, 'bucket_name'),
+    {
+      value: raw(`aws_s3_bucket.${resourceName('object_storage', item.key)}.bucket`),
+    },
+  ))
+}
+
+export function renderTerraform({ manifest, environment }) {
+  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),
+    needsAmazonLinux ? amazonLinuxDataSource() : '',
+    ...objectStorageBlocks(manifest, environment),
+    ...queueBlocks(manifest, environment),
+    ...databaseBlocks(manifest, environment),
+    ...computeBlocks(manifest, environment, 'sandboxes', 'sandbox'),
+    ...computeBlocks(manifest, environment, 'clusters', 'cluster'),
+    resources,
+  ].filter(Boolean)
+  const variableBlocks = databaseVariables(manifest)
+
+  return {
+    'versions.tf': `${renderRequiredProvider('aws', 'hashicorp/aws', '>= 5.0.0')}\n`,
+    'main.tf': `${mainBlocks.join('\n\n')}\n`,
+    ...(variableBlocks.length > 0 ? { 'variables.tf': `${variableBlocks.join('\n\n')}\n` } : {}),
+    ...(outputBlocks(manifest).length > 0 ? { 'outputs.tf': `${outputBlocks(manifest).join('\n\n')}\n` } : {}),
+  }
+}

package/src/providers/digitalocean/index.mjs

@@ -0,0 +1,85 @@
+import {
+  block,
+  renderGenericResources,
+  renderLocals,
+  renderOutput,
+  renderRequiredProvider,
+} from '../../core/hcl.mjs'
+import {
+  compactBody,
+  providerResourceName,
+  providerValues,
+  resourceName,
+} from '../../core/concepts.mjs'
+
+function region(config, values) {
+  return values.region || config.region || 'nyc3'
+}
+
+function objectStorageBlocks(manifest, environment, config) {
+  return manifest.objectStorage.map((item) => {
+    const values = providerValues(item, 'digitalocean')
+    return block('resource', ['digitalocean_spaces_bucket', resourceName('object_storage', item.key)], compactBody({
+      name: values.name || providerResourceName(manifest, environment, item),
+      region: region(config, values),
+      acl: values.acl || 'private',
+    }))
+  })
+}
+
+function databaseBlocks(manifest, environment, config) {
+  return manifest.databases.map((item) => {
+    const values = providerValues(item, 'digitalocean')
+    return block('resource', ['digitalocean_database_cluster', resourceName('database', item.key)], compactBody({
+      name: values.name || providerResourceName(manifest, environment, item),
+      engine: values.engine || item.engine || 'pg',
+      version: values.version || '15',
+      size: values.size || 'db-s-1vcpu-1gb',
+      region: region(config, values),
+      node_count: values.nodeCount || 1,
+    }))
+  })
+}
+
+function dropletBlocks(manifest, environment, config, field, prefix) {
+  return manifest[field].map((item) => {
+    const values = providerValues(item, 'digitalocean')
+    return block('resource', ['digitalocean_droplet', resourceName(prefix, item.key)], compactBody({
+      name: values.name || providerResourceName(manifest, environment, item),
+      image: values.image || 'ubuntu-24-04-x64',
+      region: region(config, values),
+      size: values.sizeSlug || values.size || 's-1vcpu-1gb',
+      count: field === 'clusters' ? values.nodes || item.nodes || item.size || 1 : undefined,
+      tags: [manifest.project.name, environment, prefix],
+    }))
+  })
+}
+
+function outputBlocks(manifest) {
+  return manifest.objectStorage.map((item) => renderOutput(
+    resourceName('digitalocean_object_storage', item.key, 'bucket_name'),
+    {
+      value: `\${digitalocean_spaces_bucket.${resourceName('object_storage', item.key)}.name}`,
+    },
+  ))
+}
+
+export function renderTerraform({ manifest, environment }) {
+  const config = manifest.providers.digitalocean || {}
+  const resources = renderGenericResources(config.resources)
+  const mainBlocks = [
+    renderLocals(manifest, environment),
+    block('provider', ['digitalocean'], {}),
+    ...objectStorageBlocks(manifest, environment, config),
+    ...databaseBlocks(manifest, environment, config),
+    ...dropletBlocks(manifest, environment, config, 'sandboxes', 'sandbox'),
+    ...dropletBlocks(manifest, environment, config, 'clusters', 'cluster'),
+    resources,
+  ].filter(Boolean)
+
+  return {
+    'versions.tf': `${renderRequiredProvider('digitalocean', 'digitalocean/digitalocean', config.version || '>= 2.0.0')}\n`,
+    'main.tf': `${mainBlocks.join('\n\n')}\n`,
+    ...(outputBlocks(manifest).length > 0 ? { 'outputs.tf': `${outputBlocks(manifest).join('\n\n')}\n` } : {}),
+  }
+}

package/src/providers/vercel/index.mjs

@@ -0,0 +1,60 @@
+import {
+  block,
+  raw,
+  renderGenericResources,
+  renderLocals,
+  renderRequiredProvider,
+  sanitizeName,
+} from '../../core/hcl.mjs'
+
+function providerBody(config) {
+  return {
+    team: config.team || config.teamId || config.teamSlug,
+  }
+}
+
+function appProject(app) {
+  return block('resource', ['vercel_project', sanitizeName(app.key)], {
+    name: app.name,
+    framework: app.framework,
+    root_directory: app.rootDirectory,
+  })
+}
+
+function appDomains(app) {
+  const domains = Array.isArray(app.domains) ? app.domains : []
+  return domains.map((domain) => domainResource(domain, app.key))
+}
+
+function domainResource(domain, appKey) {
+  const name = typeof domain === 'string' ? domain : domain.name
+  const targetApp = appKey || domain.app || domain.project
+  if (!name || !targetApp) return ''
+
+  const resourceName = sanitizeName(`${targetApp}_${name}`)
+  return block('resource', ['vercel_project_domain', resourceName], {
+    project_id: raw(`vercel_project.${sanitizeName(targetApp)}.id`),
+    domain: name,
+  })
+}
+
+export function renderTerraform({ manifest, environment }) {
+  const config = manifest.providers.vercel || {}
+  const appBlocks = manifest.apps.map(appProject)
+  const appDomainBlocks = manifest.apps.flatMap(appDomains)
+  const topLevelDomainBlocks = manifest.domains.map((domain) => domainResource(domain))
+  const genericResources = renderGenericResources(config.resources)
+  const mainBlocks = [
+    renderLocals(manifest, environment),
+    block('provider', ['vercel'], providerBody(config)),
+    ...appBlocks,
+    ...appDomainBlocks,
+    ...topLevelDomainBlocks,
+    genericResources,
+  ].filter(Boolean)
+
+  return {
+    'versions.tf': `${renderRequiredProvider('vercel', 'vercel/vercel', '>= 1.0.0')}\n`,
+    'main.tf': `${mainBlocks.join('\n\n')}\n`,
+  }
+}