@gershy/lilac 0.0.1

package/cmp/cjs/main.d.ts

@@ -0,0 +1,75 @@
+import '../sideEffects.js';
+import { PetalTerraform } from './petal/terraform/terraform.ts';
+import Logger from './util/logger.ts';
+import { Fact } from '@gershy/disk';
+export type Context = {
+    name: string;
+    logger: Logger;
+    fact: Fact;
+    patioFact: Fact;
+    aws: {
+        accountId: string;
+        accessKey: {
+            id: string;
+            '!secret': string;
+        };
+        region: string;
+    };
+    maturity: string;
+    debug: boolean;
+    pfx: string;
+};
+export declare class Flower {
+    constructor();
+    getDependencies(): Generator<Flower>;
+    getPetals(ctx: Context): Iterable<PetalTerraform.Base> | AsyncIterable<PetalTerraform.Base>;
+}
+type RegistryFlowers<R extends Registry<any>, M extends 'real' | 'test'> = R extends Registry<infer Flowers> ? {
+    [K in keyof Flowers]: Flowers[K][M];
+} : never;
+export declare class Registry<Flowers extends Obj<{
+    real: typeof Flower;
+    test: typeof Flower;
+}> = Obj<never>> {
+    private flowers;
+    constructor(flowers: Flowers);
+    add<MoreFlowers extends Obj<{
+        real: typeof Flower;
+        test: typeof Flower;
+    }>>(flowers: MoreFlowers): Registry<Omit<Flowers, keyof MoreFlowers> & MoreFlowers>;
+    get<Mode extends 'real' | 'test'>(mode: Mode): RegistryFlowers<Registry<Flowers>, Mode>;
+}
+export declare class Garden<Reg extends Registry<any>> {
+    private ctx;
+    private registry;
+    private define;
+    constructor(args: {
+        name: string;
+        logger: Logger;
+        fact: Fact;
+        patioFact: Fact;
+        aws: {
+            accountId: string;
+            accessKey: {
+                id: string;
+                '!secret': string;
+            };
+            region: string;
+        };
+        maturity: string;
+        debug: boolean;
+        pfx: string;
+        registry: Reg;
+        define: Garden<Reg>['define'];
+    });
+    private getPetals;
+    prepare(): Promise<{
+        bootFact: Fact;
+        mainFact: Fact;
+    }>;
+    private terraformInit;
+    private terraformPlan;
+    private terraformApply;
+    grow(mode: 'real' | 'test'): Promise<void>;
+}
+export * from './petal/terraform/terraform.ts';

package/cmp/cjs/main.js

@@ -0,0 +1,299 @@
+"use strict";
+// TODO:
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Garden = exports.Registry = exports.Flower = void 0;
+// A more generic (beyond just tf) provider is very hard to support due to the multiplicity of
+// provider/petal combos - e.g. "api" flower would need to support ,api.getCloudformationPetals,
+// api.getTerraformPetals, etc... supporting just terraform for now
+// Watch out when working lilac into an npm dependency, need to allow the user a way to declare
+// their absolute repo path (so "<repo>/..." filenames work in any setup!)
+// Can region be dealt with any better??
+// Support test-mode (Flowers need to be able to do setup, share config, write to volumes, etc)
+const terraform_ts_1 = require("./petal/terraform/terraform.js");
+const aws_ts_1 = require("./util/aws.js");
+const clearing_1 = require("@gershy/clearing");
+const procTerraform_ts_1 = __importDefault(require("./util/procTerraform.js"));
+const { File, Provider, Terraform } = terraform_ts_1.PetalTerraform;
+class Flower {
+    constructor() { }
+    *getDependencies() {
+        yield this;
+    }
+    getPetals(ctx) {
+        throw Error('not implemented');
+    }
+}
+exports.Flower = Flower;
+;
+class Registry {
+    flowers;
+    constructor(flowers) {
+        this.flowers = {}[merge](flowers);
+    }
+    add(flowers) {
+        return new Registry({ ...this.flowers, ...flowers });
+    }
+    get(mode) {
+        return this.flowers[map]((v) => v[mode]);
+    }
+}
+exports.Registry = Registry;
+;
+class Garden {
+    // Note this class currently is coupled to terraform logic
+    ctx;
+    registry;
+    define;
+    constructor(args) {
+        const { define, registry, ...ctx } = args;
+        this.ctx = ctx;
+        this.registry = registry;
+        this.define = define;
+    }
+    async *getPetals(mode) {
+        const seenFlowers = new Set();
+        const seenPetals = new Set();
+        for await (const topLevelFlower of this.define(this.ctx, this.registry.get(mode))) {
+            for (const flower of topLevelFlower.getDependencies()) {
+                if (seenFlowers.has(flower))
+                    continue;
+                seenFlowers.add(flower);
+                for await (const petal of flower.getPetals(this.ctx)) {
+                    if (seenPetals.has(petal))
+                        continue;
+                    yield petal;
+                }
+            }
+        }
+    }
+    async prepare( /* Note this only pertains to "real" mode */) {
+        return this.ctx.logger.scope('garden.prepare', {}, async (logger) => {
+            const setupTfProj = async (args) => args.logger.scope('tf', { proj: this.ctx.name, tf: args.term }, async (logger) => {
+                // Allows a terraform project to be defined in terms of a function which writes to main.tf,
+                // and adds any arbitrary additional files to the terraform project
+                // Clean up previous terraform
+                await logger.scope('files.reset', {}, async (logger) => {
+                    // We only want to update iac - need to preserve terraform state management
+                    const tfFilesToPreserve = new Set([
+                        '.terraform',
+                        '.terraform.lock.hcl',
+                        'terraform.tfstate',
+                        'terraform.tfstate.backup'
+                    ]);
+                    const kids = await args.fact.getKids();
+                    await Promise.all(kids[toArr]((kid, k) => tfFilesToPreserve.has(k) ? clearing_1.skip : kid.rem()));
+                });
+                // Write new terraform
+                await logger.scope('files.generate', {}, async (logger) => {
+                    const stream = await args.fact.kid(['main.tf']).getDataHeadStream();
+                    await args.setup(args.fact, stream);
+                    await stream.end(); // TODO: @gershy/disk should allow `await headStream.end()`
+                });
+                return args.fact;
+            });
+            // We generate *two* terraform projects for every logical project - overall we want a
+            // terraform project which saves its state in the cloud; in order to do this we need to first
+            // provision the cloud storage engines to save the terraform state. The "boot" tf project
+            // takes care of this, and "main" uses the storage engine provisioned by "boot"!
+            return Promise[allObj]({
+                bootFact: setupTfProj({
+                    term: 'boot',
+                    logger,
+                    fact: this.ctx.fact.kid(['boot']),
+                    setup: async (fact, mainWritable) => {
+                        await mainWritable.write(String[baseline](`
+              | terraform {
+              |   required_providers {
+              |     aws = {
+              |       source  = "hashicorp/aws"
+              |       version = "~> 5.0"
+              |     }
+              |   }
+              | }
+              | provider "aws" {
+              |   shared_credentials_files = [ "creds.ini" ]
+              |   profile                  = "default"
+              |   region                   = "ca-central-1"
+              | }
+              | resource "aws_s3_bucket" "tf_state" {
+              |   bucket = "${this.ctx.pfx}-tf-state"
+              | }
+              | resource "aws_s3_bucket_ownership_controls" "tf_state" {
+              |   bucket = aws_s3_bucket.tf_state.bucket
+              |   rule {
+              |     object_ownership = "ObjectWriter"
+              |   }
+              | }
+              | resource "aws_s3_bucket_acl" "tf_state" {
+              |   bucket = aws_s3_bucket.tf_state.bucket
+              |   acl = "private"
+              |   depends_on = [ aws_s3_bucket_ownership_controls.tf_state ]
+              | }
+              | resource "aws_dynamodb_table" "tf_state" {
+              |   name         = "${this.ctx.pfx}-tf-state"
+              |   billing_mode = "PAY_PER_REQUEST"
+              |   hash_key     = "LockID"
+              |   attribute {
+              |     name = "LockID"
+              |     type = "S"
+              |   }
+              | }
+            `));
+                        await fact.kid(['creds.ini']).setData(String[baseline](`
+              | [default]
+              | aws_region            = ${this.ctx.aws.region}
+              | aws_access_key_id     = ${this.ctx.aws.accessKey.id}
+              | aws_secret_access_key = ${this.ctx.aws.accessKey['!secret']}
+            `));
+                    }
+                }),
+                mainFact: setupTfProj({
+                    term: 'main',
+                    logger,
+                    fact: this.ctx.fact.kid(['main']),
+                    setup: async (fact, mainWritable) => {
+                        const garden = this;
+                        const iteratePetals = async function* () {
+                            const tfAwsCredsFile = new File('creds.ini', String[baseline](`
+                | [default]
+                | aws_region            = ${garden.ctx.aws.region}
+                | aws_access_key_id     = ${garden.ctx.aws.accessKey.id}
+                | aws_secret_access_key = ${garden.ctx.aws.accessKey['!secret']}
+              `));
+                            yield tfAwsCredsFile;
+                            const terraform = new Terraform({
+                                $requiredProviders: {
+                                    aws: {
+                                        source: 'hashicorp/aws',
+                                        version: `~> 5.0` // Consider parameterizing??
+                                    }
+                                },
+                                '$backend.s3': {
+                                    region: garden.ctx.aws.region,
+                                    encrypt: true,
+                                    // Note references not allowed in terraform.backend!!
+                                    bucket: `${garden.ctx.pfx}-tf-state`,
+                                    key: `tf`,
+                                    dynamodbTable: `${garden.ctx.pfx}-tf-state`, // Dynamodb table is aws-account-wide
+                                    sharedCredentialsFiles: [tfAwsCredsFile.tfRef()],
+                                    profile: 'default', // References a section within the credentials file
+                                }
+                            });
+                            yield terraform;
+                            for (const { term } of aws_ts_1.regions)
+                                yield new Provider('aws', {
+                                    sharedCredentialsFiles: [tfAwsCredsFile.tfRef()],
+                                    profile: 'default', // References a section within the credentials file
+                                    region: term,
+                                    // Omit the alias for the default provider!
+                                    ...(term !== garden.ctx.aws.region && { alias: term.split('-').join('_') })
+                                });
+                            yield* garden.getPetals('real');
+                        };
+                        const patioTfHclFact = garden.ctx.patioFact.kid(['main', '.terraform.lock.hcl']);
+                        const tfHclData = await patioTfHclFact.getData('str');
+                        if (tfHclData)
+                            await fact.kid(['.terraform.lock.hcl']).setData(tfHclData);
+                        for await (const petal of iteratePetals()) {
+                            const result = await (async () => {
+                                const result = await petal.getResult();
+                                if (!(0, clearing_1.isCls)(result, Object))
+                                    return { tf: result, files: {} };
+                                return { files: {}, ...result };
+                            })();
+                            if (result.tf)
+                                await mainWritable.write(`${result.tf}\n`);
+                            await Promise.all(result.files[toArr]((data, kfp) => fact.kid(kfp.split('/')).setData(data)));
+                        }
+                    }
+                })
+            });
+        });
+    }
+    terraformInit(fact, args) {
+        return this.ctx.logger.scope('execTf.init', {}, async (logger) => {
+            // Consider if we ever want to pass "-reconfigure" and "-migrate-state" options; these are
+            // useful if we are moving backends (e.g. one aws account to another), and want to move our
+            // full iac definition too
+            // TODO: Some terraform commands fail when offline - can this be covered up?
+            const result = await (0, procTerraform_ts_1.default)(fact, `terraform init -input=false`);
+            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            return result;
+        });
+    }
+    terraformPlan(fact, args) {
+        return this.ctx.logger.scope('execTf.plan', {}, async (logger) => {
+            const result = await (0, procTerraform_ts_1.default)(fact, `terraform plan -input=false`);
+            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            return result;
+        });
+    }
+    terraformApply(fact, args) {
+        return this.ctx.logger.scope('execTf.apply', {}, async (logger) => {
+            const result = await (0, procTerraform_ts_1.default)(fact, `terraform apply -input=false -auto-approve`);
+            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            return result;
+        });
+    }
+    async grow(mode) {
+        // - Avoid tf preventing deletions on populated dbs - e.g. s3 tf needs "force_destroy = true"
+        // - Note `terraform init` generates a ".terraform.lock.hcl" file - this should be checked into
+        //   consumer's source control! May need consumers to provide an optional `repoFact`, and if
+        //   present after `terraform init` we can copy the ".terraform.lock.hcl" file
+        // Note that test mode does not involve any iac - it all runs locally
+        if (mode === 'test')
+            throw Error('test mode not implemented yet');
+        const { bootFact, mainFact } = await this.prepare();
+        const tryWithHealing = async (args) => {
+            const { fn, heal, canHeal } = args;
+            return fn().catch(async (err) => {
+                if (!canHeal(err))
+                    throw err;
+                await heal();
+                return fn();
+            });
+        };
+        const logicalApply = (args) => {
+            return tryWithHealing({
+                fn: () => this.terraformApply(args.mainFact),
+                canHeal: err => (err.output ?? '')[has]('please run "terraform init"'),
+                heal: () => tryWithHealing({
+                    fn: async () => {
+                        await this.terraformInit(args.mainFact);
+                        await this.ctx.patioFact.kid(['main', '.terraform.lock.hcl']).setData(await args.mainFact.kid(['.terraform.lock.hcl']).getData('str'));
+                    },
+                    canHeal: err => true,
+                    heal: () => tryWithHealing({
+                        fn: () => this.terraformApply(args.bootFact),
+                        canHeal: err => (err.output ?? '')[has]('please run "terraform init"'),
+                        heal: () => this.terraformInit(args.bootFact)
+                    })
+                })
+            });
+        };
+        // TODO: HEEERE do `logicalApply` instead!
+        await this.terraformInit(bootFact);
+        // const result = await logicalApply({ mainFact, bootFact });
+        //const result = await execTf.init(bootFact);
+    }
+}
+exports.Garden = Garden;
+;
+__exportStar(require("./petal/terraform/terraform.js"), exports);

package/cmp/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cmp/cjs/petal/petal.d.ts

@@ -0,0 +1,3 @@
+export default class Petal {
+    constructor();
+}

package/cmp/cjs/petal/petal.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Petal {
+    constructor() { }
+}
+exports.default = Petal;

package/cmp/cjs/petal/terraform/terraform.d.ts

@@ -0,0 +1,82 @@
+import Petal from '../petal.ts';
+export declare namespace PetalTerraform {
+    class Base extends Petal {
+        static terraformEncode: (val: Json) => string;
+        constructor();
+        getType(): string;
+        getHandle(): string;
+        getProps(): {
+            [key: string]: Json;
+        };
+        tfRef(props?: string | string[]): string;
+        tfRefp(props?: string | string[]): `| ${string}`;
+        getResultHeader(): Promise<string>;
+        getResult(): Promise<string | {
+            tf: string;
+            files?: Obj<string | Buffer>;
+        }>;
+    }
+    class Terraform extends Base {
+        private props;
+        constructor(props: {
+            [key: string]: Json;
+        });
+        getProps(): {
+            [key: string]: Json;
+        };
+        getResultHeader(): Promise<string>;
+    }
+    class Resource extends Base {
+        private type;
+        private handle;
+        private props;
+        constructor(type: string, handle: string, props: {
+            [key: string]: Json;
+        });
+        getType(): string;
+        getHandle(): string;
+        getProps(): {
+            [key: string]: Json;
+        };
+        getResultHeader(): Promise<string>;
+    }
+    class Provider extends Base {
+        private name;
+        private props;
+        constructor(name: string, props: {
+            [key: string]: Json;
+        });
+        getProps(): {
+            [key: string]: Json;
+        };
+        getResultHeader(): Promise<string>;
+    }
+    class Data extends Base {
+        private type;
+        private handle;
+        private props;
+        constructor(type: string, handle: string, props: {
+            [key: string]: Json;
+        });
+        getType(): string;
+        getHandle(): string;
+        getProps(): {
+            [key: string]: Json;
+        };
+        getResultHeader(): Promise<string>;
+        tfRef(props?: string | string[]): string;
+    }
+    class File extends Base {
+        private fp;
+        private content;
+        constructor(fp: string, content: string | Buffer);
+        getType(): string;
+        getResult(): Promise<{
+            tf: string;
+            files: {
+                [x: string]: string | Buffer<ArrayBufferLike>;
+            };
+        }>;
+        tfRef(props?: string | string[]): string;
+    }
+}

package/cmp/cjs/petal/terraform/terraform.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PetalTerraform = void 0;
+const clearing_1 = require("@gershy/clearing");
+const slashEscape_ts_1 = __importDefault(require("../../util/slashEscape.js"));
+const snakeCase_ts_1 = __importDefault(require("../../util/snakeCase.js"));
+const petal_ts_1 = __importDefault(require("../petal.js"));
+var PetalTerraform;
+(function (PetalTerraform) {
+    class Base extends petal_ts_1.default {
+        // Defines petals using terraform; subclasses generally map to terraform's different block types
+        static terraformEncode = (val) => {
+            if (val === null)
+                return 'null';
+            if ((0, clearing_1.isCls)(val, String))
+                return val[hasHead]('| ') ? val.slice('| '.length) : `"${(0, slashEscape_ts_1.default)(val, '"\n')}"`;
+            if ((0, clearing_1.isCls)(val, Number))
+                return `${val.toString(10)}`;
+            if ((0, clearing_1.isCls)(val, Boolean))
+                return val ? 'true' : 'false';
+            if ((0, clearing_1.isCls)(val, Array)) {
+                const vals = val[map](v => this.terraformEncode(v));
+                if (vals.some(v => (0, clearing_1.isCls)(v, String) && v[hasHead]('| ')))
+                    process.exit(0);
+                if (vals.length === 0)
+                    return '[]';
+                if (vals.length === 1)
+                    return `[ ${vals[0]} ]`;
+                return `[\n${vals.join(',\n')[indent]('  ')}\n]`;
+            }
+            if ((0, clearing_1.isCls)(val, Object)) {
+                // Strings use "| " to avoid any quoting (enabling complex/arbitrary tf)
+                // Objects use "$" as a key-prefix to define "nested blocks" instead of "inline maps"
+                const keys = Object.keys(val);
+                if (keys.length === 1 && keys[0][hasTail]('()')) {
+                    const vals = val[keys[0]][map](v => this.terraformEncode(v));
+                    return `${keys[0].slice(0, -'()'.length)}(${vals.join(', ')})`;
+                }
+                const entryItems = val[toArr]((v, k) => {
+                    // "special" indicates whether the first char was "$" - it causes objects to be assigned as
+                    // *nested blocks*
+                    const [special, pcs] = (() => {
+                        const ks = k[hasHead]('$');
+                        const kk = ks ? k.slice(1) : k;
+                        return [ks, kk.split('.')];
+                    })();
+                    const dedup = pcs.length > 1 && /^[0-9]+$/.test(pcs.at(-1));
+                    if (dedup)
+                        pcs.pop(); // Remove last item
+                    // Multi-component keys must pertain to objects
+                    if (pcs.length > 1 && !(0, clearing_1.isCls)(v, Object))
+                        throw Error('tf key of this form must correspond to object value')[mod]({ k, v });
+                    // Resolve to raw string?
+                    if (special && (0, clearing_1.isCls)(v, String))
+                        return [(0, snakeCase_ts_1.default)(pcs[0]), ' = ', this.terraformEncode(v[hasHead]('| ') ? v : `| ${v}`)];
+                    // Resolve to nested block?
+                    if (special && (0, clearing_1.isCls)(v, Object))
+                        return [[(0, snakeCase_ts_1.default)(pcs[0]), ...pcs.slice(1)[map](pc => (0, snakeCase_ts_1.default)(pc))].join(' '), ' ', this.terraformEncode(v)];
+                    // Resolve anything else to typical property - use the key exactly as provided (to support,
+                    // e.g., aws format for keys in policies, any other specific format, etc.)
+                    return [(0, snakeCase_ts_1.default)(pcs[0]), ' = ', this.terraformEncode(v)];
+                });
+                const len = entryItems.length;
+                if (len === 0)
+                    return '{}';
+                const entries = entryItems[map](([key, joiner, value]) => [key, joiner, value].join(''));
+                // Note single-line terraform definitions are illegal for non-linear values
+                // Determine whether the the value is linear based on its terminating character (janky)
+                if (len === 1 && !entries[0][has]('\n') && !'}]'[has](entries[0].at(-1)))
+                    return `{ ${entries[0]} }`;
+                return `{\n` + entries.join('\n')[indent]('  ') + '\n}';
+            }
+            throw Error('unexpected val')[mod]({ form: (0, clearing_1.getClsName)(val), val });
+        };
+        constructor() { super(); }
+        getType() { throw Error('not implemented'); }
+        getHandle() { throw Error('not implemented'); }
+        getProps() { throw Error('not implemented'); }
+        tfRef(props = []) {
+            if (!(0, clearing_1.isCls)(props, Array))
+                props = [props];
+            const base = `${(0, snakeCase_ts_1.default)(this.getType())}.${(0, snakeCase_ts_1.default)(this.getHandle())}`;
+            return props.length
+                ? `${base}.${props[map](v => (0, snakeCase_ts_1.default)(v)).join('.')}`
+                : base;
+        }
+        tfRefp(props = []) {
+            // "plain ref" - uses "| " to avoid being  quoted within terraform
+            return `| ${this.tfRef(props)}`;
+        }
+        async getResultHeader() { throw Error('not implemented'); }
+        async getResult() {
+            // Get header and props
+            const [header, props] = await Promise.all([
+                this.getResultHeader(),
+                Base.terraformEncode(this.getProps())
+            ]);
+            return `${header} ${props}`;
+        }
+    }
+    PetalTerraform.Base = Base;
+    ;
+    class Terraform extends Base {
+        props;
+        constructor(props) {
+            super();
+            this.props = props;
+        }
+        getProps() { return this.props; }
+        async getResultHeader() {
+            return `terraform`;
+        }
+    }
+    PetalTerraform.Terraform = Terraform;
+    ;
+    class Resource extends Base {
+        type;
+        handle;
+        props;
+        constructor(type, handle, props) {
+            super();
+            this.type = type;
+            this.handle = handle;
+            this.props = props;
+        }
+        getType() { return this.type; }
+        getHandle() { return this.handle; }
+        getProps() { return this.props; }
+        async getResultHeader() {
+            return `resource "${(0, snakeCase_ts_1.default)(this.type)}" "${(0, snakeCase_ts_1.default)(this.handle)}"`;
+        }
+    }
+    PetalTerraform.Resource = Resource;
+    ;
+    class Provider extends Base {
+        name;
+        props;
+        constructor(name, props) {
+            super();
+            this.name = name;
+            this.props = props;
+        }
+        getProps() { return this.props; }
+        async getResultHeader() {
+            return `provider "${(0, snakeCase_ts_1.default)(this.name)}"`;
+        }
+    }
+    PetalTerraform.Provider = Provider;
+    ;
+    class Data extends Base {
+        type;
+        handle;
+        props;
+        constructor(type, handle, props) {
+            super();
+            this.type = type;
+            this.handle = handle;
+            this.props = props;
+        }
+        getType() { return this.type; }
+        getHandle() { return this.handle; }
+        getProps() { return this.props; }
+        async getResultHeader() {
+            return `data "${(0, snakeCase_ts_1.default)(this.type)}" "${(0, snakeCase_ts_1.default)(this.handle)}"`;
+        }
+        tfRef(props = []) {
+            return `data.${super.tfRef(props)}`;
+        }
+    }
+    PetalTerraform.Data = Data;
+    ;
+    class File extends Base {
+        fp;
+        content;
+        constructor(fp, content) {
+            super();
+            this.fp = fp;
+            this.content = content;
+        }
+        getType() { return '_file'; }
+        async getResult() {
+            return { tf: '', files: { [this.fp]: this.content } };
+        }
+        tfRef(props) {
+            return this.fp; // `this.fp` should be quoted but not transformed to a tf handle
+        }
+    }
+    PetalTerraform.File = File;
+    ;
+})(PetalTerraform || (exports.PetalTerraform = PetalTerraform = {}));
+;

package/cmp/cjs/util/aws.d.ts

@@ -0,0 +1,5 @@
+export declare const capitalKeys: (v: any) => any;
+export declare const regions: {
+    term: string;
+    mini: string;
+}[];