@gershy/lilac 0.0.14 → 0.0.16

package/cmp/cjs/main.d.ts

@@ -1,7 +1,8 @@
 import '../sideEffects.js';
 import { PetalTerraform } from './petal/terraform/terraform.ts';
 import type Logger from '@gershy/logger';
-import type { Fact } from '@gershy/disk';
+import { type Fact } from '@gershy/disk';
+import '@gershy/clearing';
 import { Soil } from './soil/soil.ts';
 import { SuperIterable } from './util/superIterable.ts';
 export type Context = {
@@ -9,6 +10,7 @@ export type Context = {
     logger: Logger;
     fact: Fact;
     patioFact: Fact;
+    shedFact: Fact;
     maturity: string;
     debug: boolean;
     pfx: string;
@@ -18,6 +20,7 @@ export declare class Flower {
     constructor();
     getDependencies(): Generator<Flower>;
     getPetals(ctx: Context): SuperIterable<PetalTerraform.Base>;
+    cultivate(): Promise<void>;
 }
 type RegistryFlowers<R extends Registry<any>, M extends 'real' | 'test'> = R extends Registry<infer Flowers> ? {
     [K in keyof Flowers]: Flowers[K][M];
@@ -39,13 +42,14 @@ export declare class Garden<Reg extends Registry<any>> {
     private ctx;
     private reg;
     private def;
+    private tfProcArgs;
     constructor(args: {
         context: Context;
         registry: Reg;
         define: Garden<Reg>['def'];
     });
     private getPetals;
-    genTerraform(deployTarget: Soil.Base): Promise<Obj<Fact>>;
+    genTerraform(soil: Soil.Base): Promise<Obj<Fact>>;
     private terraformInit;
     private terraformPlan;
     private terraformApply;

package/cmp/cjs/main.js

@@ -22,15 +22,24 @@ 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 clearing_1 = require("@gershy/clearing");
-const procTerraform_ts_1 = __importDefault(require("./util/procTerraform.js"));
+const disk_1 = require("@gershy/disk");
+require("@gershy/clearing");
 const util_try_with_healing_1 = __importDefault(require("@gershy/util-try-with-healing"));
 const util_phrasing_1 = __importDefault(require("@gershy/util-phrasing"));
+const nodejs_proc_1 = __importDefault(require("@gershy/nodejs-proc"));
+const { isCls, skip } = cl;
+const toArr = cl.toArr;
+const allObj = cl.allObj;
+const allArr = cl.allArr;
+const has = cl.has;
+const map = cl.map;
+const mod = cl.mod;
+const walk = cl.walk;
+const merge = cl.merge;
+const upper = cl.upper;
+const baseline = cl.baseline;
 class Flower {
     // TODO: The downside of having this static is that different instances may use different
     // services - e.g. api gateway instance may have "useEdge: true", in which case we'd like to
@@ -47,6 +56,11 @@ class Flower {
     getPetals(ctx) {
         throw Error('not implemented');
     }
+    async cultivate() {
+        // This function is called once all Flowers for a given Garden have been constructed. The main
+        // purpose of this phase is to allow Flowers which reference each other via functions to run
+        // such functions without running into uninitialized values.
+    }
 }
 exports.Flower = Flower;
 ;
@@ -61,7 +75,7 @@ class Registry {
     }
     getAwsServices() {
         const services = new Set();
-        for (const [k, { real }] of this.flowers)
+        for (const [k, { real }] of this.flowers[walk]())
             for (const awsService of real.getAwsServices())
                 services.add(awsService);
         return services[toArr](v => v);
@@ -80,11 +94,21 @@ class Garden {
     ctx;
     reg;
     def;
+    tfProcArgs;
     constructor(args) {
         const { define, registry, context } = args;
         this.ctx = context;
         this.reg = registry;
         this.def = define;
+        this.tfProcArgs = {
+            timeoutMs: 0,
+            env: {
+                ...process.env,
+                TF_LOG: 'DEBUG',
+                TF_DATA_DIR: '',
+                TF_CLI_CONFIG_FILE: ''
+            }
+        };
     }
     async *getPetals() {
         // TODO: We always use the "real" flowers from the registry - this is part of the shift to
@@ -94,21 +118,22 @@ class Garden {
         // conditionally calling `this.registry.get('fake')`...
         const seenFlowers = new Set();
         const seenPetals = new Set();
-        for await (const topLevelFlower of await this.def(this.ctx, this.reg.get('real'))) {
-            for (const flower of topLevelFlower.getDependencies()) {
-                if (seenFlowers.has(flower))
-                    continue;
+        for await (const topLevelFlower of await this.def(this.ctx, this.reg.get('real')))
+            for (const flower of topLevelFlower.getDependencies())
                 seenFlowers.add(flower);
-                for await (const petal of await flower.getPetals(this.ctx)) {
-                    if (seenPetals.has(petal))
-                        continue;
-                    yield petal;
-                }
+        // Now we've exhaustively referenced all Flowers - we can cultivate them
+        await Promise.all(seenFlowers[toArr](f => f.cultivate()));
+        for (const flower of seenFlowers) {
+            for await (const petal of await flower.getPetals(this.ctx)) {
+                if (seenPetals.has(petal))
+                    continue;
+                seenPetals.add(petal);
+                yield petal;
             }
         }
     }
-    async genTerraform(deployTarget) {
-        const soilTfPetalsPrm = deployTarget.getTerraformPetals(this.ctx);
+    async genTerraform(soil) {
+        const soilTfPetalsPrm = soil.getTerraformPetals(this.ctx);
         return this.ctx.logger.scope('garden.genTerraform', {}, 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,
@@ -123,15 +148,14 @@ class Garden {
                         'terraform.tfstate.backup'
                     ]);
                     const kids = await args.fact.getKids();
-                    await Promise.all(kids[toArr]((kid, k) => tfFilesToPreserve.has(k) ? clearing_1.skip : kid.rem()));
+                    await Promise.all(kids[toArr]((kid, k) => tfFilesToPreserve.has(k) ? 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, async (petal) => {
                         // Include a utility function the caller can use to easily write petals
-                        const { tf, files = {} } = await petal.getResult()
-                            .then(tf => (0, clearing_1.isCls)(tf, String) ? { tf } : tf);
+                        const { tf, files = {} } = await petal.getResult().then(tf => isCls(tf, String) ? { tf } : tf);
                         if (tf)
                             await stream.write(`${tf}\n`);
                         await Promise.all(files[toArr]((data, kfp) => args.fact.kid(kfp.split('/')).setData(data)));
@@ -176,7 +200,7 @@ class Garden {
                         // Create ddb tf state locking table
                         await writePetalTfAndFiles(new terraform_ts_1.PetalTerraform.Resource('awsDynamodbTable', 'tfState', {
                             name: ddbName,
-                            billingMode: (0, util_phrasing_1.default)('payPerRequest', 'camel', 'snake')[upper](),
+                            billingMode: (0, util_phrasing_1.default)('camel->snake', 'payPerRequest')[upper](),
                             hashKey: 'LockID',
                             $attribute: { name: 'LockID', type: 'S' }
                         }));
@@ -203,31 +227,55 @@ class Garden {
             });
         });
     }
-    terraformInit(fact, args) {
+    // TODO: Write terraform output to logs??
+    async terraformInit(fact) {
+        // 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
+        // Ensure the mirror directory exists in the shed
+        const mirrorFact = this.ctx.shedFact.kid(['lilacTerraformMirror']);
+        await mirrorFact.kid(['note.txt']).setData(`Root of terraform mirror for @gershy/lilac`);
         return this.ctx.logger.scope('execTf.init', { fact: fact.fsp() }, 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? Possibly by
-            // checking terraform binaries into the repo? (Cross-platform nightmare though...)
-            const result = await (0, procTerraform_ts_1.default)(fact, `terraform init -input=false`, {
-                onData: async (mode, data) => logger.log({ $$: 'notice', mode, data }) ?? null
+            const { output: result } = await (0, util_try_with_healing_1.default)({
+                fn: () => logger.scope('attempt', {}, async (logger) => {
+                    const configFact = disk_1.tempFact.kid([`${Math.random().toString(36).slice(2)}.terraform.rc`]);
+                    await configFact.setData(String[baseline](`
+            | provider_installation {
+            |   filesystem_mirror {
+            |     path = "${mirrorFact.fsp().replaceAll('\\', '/')}"
+            |   }
+            | }
+          `));
+                    return (0, nodejs_proc_1.default)(`terraform init -input=false`, {}[merge](this.tfProcArgs)[merge]({
+                        cwd: fact,
+                        env: { TF_CLI_CONFIG_FILE: configFact.fsp() }
+                    })).finally(() => configFact.rem());
+                }),
+                canHeal: err => (err?.output ?? '')[has]('Could not retrieve the list of available versions for provider'),
+                heal: () => logger.scope('mirror', { fsp: mirrorFact.fsp() }, async (logger) => {
+                    const { output: result } = await (0, nodejs_proc_1.default)(`terraform providers mirror "${mirrorFact.fsp().replaceAll('\\', '/')}"`, { cwd: fact, timeoutMs: 0 });
+                    logger.log({ $$: 'result', result });
+                })
             });
-            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            logger.log({ $$: 'result', result });
             return result;
         });
     }
     terraformPlan(fact, args) {
         return this.ctx.logger.scope('execTf.plan', { fact: fact.fsp() }, 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 });
+            const { output: result } = await (0, nodejs_proc_1.default)(`terraform plan -input=false`, {}[merge](this.tfProcArgs)[merge]({
+                cwd: fact,
+            }));
+            logger.log({ $$: 'result', result });
             return result;
         });
     }
     terraformApply(fact, args) {
         return this.ctx.logger.scope('execTf.apply', { fact: fact.fsp() }, 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 });
+            const { output: result } = await (0, nodejs_proc_1.default)(`terraform apply -input=false -auto-approve`, {}[merge](this.tfProcArgs)[merge]({
+                cwd: fact
+            }));
+            logger.log({ $$: 'result', result });
             return result;
         });
     }

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

@@ -1,3 +1,4 @@
+import '@gershy/clearing';
 import Petal from '../petal.ts';
 export declare namespace PetalTerraform {
     class Base extends Petal {

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

@@ -4,10 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PetalTerraform = void 0;
-const clearing_1 = require("@gershy/clearing");
+require("@gershy/clearing");
 const slashEscape_ts_1 = __importDefault(require("../../util/slashEscape.js"));
 const petal_ts_1 = __importDefault(require("../petal.js"));
 const util_phrasing_1 = __importDefault(require("@gershy/util-phrasing"));
+const { getClsName, isCls } = cl;
+const hasHead = cl.hasHead;
+const map = cl.map;
+const hasTail = cl.hasTail;
+const indent = cl.indent;
+const mod = cl.mod;
+const toArr = cl.toArr;
+const has = cl.has;
 var PetalTerraform;
 (function (PetalTerraform) {
     class Base extends petal_ts_1.default {
@@ -15,15 +23,15 @@ var PetalTerraform;
         static terraformEncode = (val) => {
             if (val === null)
                 return 'null';
-            if ((0, clearing_1.isCls)(val, String))
+            if (isCls(val, String))
                 return val[hasHead]('| ') ? val.slice('| '.length) : `"${(0, slashEscape_ts_1.default)(val, '"\n')}"`;
-            if ((0, clearing_1.isCls)(val, Number))
+            if (isCls(val, Number))
                 return `${val.toString(10)}`;
-            if ((0, clearing_1.isCls)(val, Boolean))
+            if (isCls(val, Boolean))
                 return val ? 'true' : 'false';
-            if ((0, clearing_1.isCls)(val, Array)) {
+            if (isCls(val, Array)) {
                 const vals = val[map](v => this.terraformEncode(v));
-                if (vals.some(v => (0, clearing_1.isCls)(v, String) && v[hasHead]('| ')))
+                if (vals.some(v => isCls(v, String) && v[hasHead]('| ')))
                     process.exit(0);
                 if (vals.length === 0)
                     return '[]';
@@ -31,7 +39,7 @@ var PetalTerraform;
                     return `[ ${vals[0]} ]`;
                 return `[\n${vals.join(',\n')[indent]('  ')}\n]`;
             }
-            if ((0, clearing_1.isCls)(val, Object)) {
+            if (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);
@@ -51,17 +59,17 @@ var PetalTerraform;
                     if (dedup)
                         pcs.pop(); // Remove last item
                     // Multi-component keys must pertain to objects
-                    if (pcs.length > 1 && !(0, clearing_1.isCls)(v, Object))
+                    if (pcs.length > 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, util_phrasing_1.default)(pcs[0], 'camel', 'snake'), ' = ', this.terraformEncode(v[hasHead]('| ') ? v : `| ${v}`)];
+                    if (special && isCls(v, String))
+                        return [(0, util_phrasing_1.default)('camel->snake', pcs[0]), ' = ', this.terraformEncode(v[hasHead]('| ') ? v : `| ${v}`)];
                     // Resolve to nested block?
-                    if (special && (0, clearing_1.isCls)(v, Object))
-                        return [[(0, util_phrasing_1.default)(pcs[0], 'camel', 'snake'), ...pcs.slice(1)[map](pc => (0, util_phrasing_1.default)(pc, 'camel', 'snake'))].join(' '), ' ', this.terraformEncode(v)];
+                    if (special && isCls(v, Object))
+                        return [[(0, util_phrasing_1.default)('camel->snake', pcs[0]), ...pcs.slice(1)[map](pc => (0, util_phrasing_1.default)('camel->snake', 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, util_phrasing_1.default)(pcs[0], 'camel', 'snake'), ' = ', this.terraformEncode(v)];
+                    return [(0, util_phrasing_1.default)('camel->snake', pcs[0]), ' = ', this.terraformEncode(v)];
                 });
                 const len = entryItems.length;
                 if (len === 0)
@@ -73,18 +81,18 @@ var PetalTerraform;
                     return `{ ${entries[0]} }`;
                 return `{\n` + entries.join('\n')[indent]('  ') + '\n}';
             }
-            throw Error('unexpected val')[mod]({ form: (0, clearing_1.getClsName)(val), val });
+            throw Error('unexpected val')[mod]({ form: getClsName(val), val });
         };
         constructor() { super(); }
         getType() { throw Error('not implemented'); }
         getHandle() { throw Error('not implemented'); }
         getProps() { throw Error('not implemented'); }
         refStr(props = []) {
-            if (!(0, clearing_1.isCls)(props, Array))
+            if (!isCls(props, Array))
                 props = [props];
-            const base = `${(0, util_phrasing_1.default)(this.getType(), 'camel', 'snake')}.${(0, util_phrasing_1.default)(this.getHandle(), 'camel', 'snake')}`;
+            const base = `${(0, util_phrasing_1.default)('camel->snake', this.getType())}.${(0, util_phrasing_1.default)('camel->snake', this.getHandle())}`;
             return props.length
-                ? `${base}.${props[map](v => (0, util_phrasing_1.default)(v, 'camel', 'snake')).join('.')}`
+                ? `${base}.${props[map](v => (0, util_phrasing_1.default)('camel->snake', v)).join('.')}`
                 : base;
         }
         ref(props = []) {
@@ -130,7 +138,7 @@ var PetalTerraform;
         getHandle() { return this.handle; }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `resource "${(0, util_phrasing_1.default)(this.type, 'camel', 'snake')}" "${(0, util_phrasing_1.default)(this.handle, 'camel', 'snake')}"`;
+            return `resource "${(0, util_phrasing_1.default)('camel->snake', this.type)}" "${(0, util_phrasing_1.default)('camel->snake', this.handle)}"`;
         }
     }
     PetalTerraform.Resource = Resource;
@@ -145,7 +153,7 @@ var PetalTerraform;
         }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `provider "${(0, util_phrasing_1.default)(this.name, 'camel', 'snake')}"`;
+            return `provider "${(0, util_phrasing_1.default)('camel->snake', this.name)}"`;
         }
     }
     PetalTerraform.Provider = Provider;
@@ -164,7 +172,7 @@ var PetalTerraform;
         getHandle() { return this.handle; }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `data "${(0, util_phrasing_1.default)(this.type, 'camel', 'snake')}" "${(0, util_phrasing_1.default)(this.handle, 'camel', 'snake')}"`;
+            return `data "${(0, util_phrasing_1.default)('camel->snake', this.type)}" "${(0, util_phrasing_1.default)('camel->snake', this.handle)}"`;
         }
         refStr(props = []) {
             return `data.${super.refStr(props)}`;

package/cmp/cjs/soil/soil.d.ts

@@ -1,8 +1,10 @@
 import { Context, PetalTerraform, Registry } from '../main.ts';
 import { RegionTerm } from '../util/aws.ts';
+import '@gershy/clearing';
 import { NetProc } from '@gershy/util-http';
 import { SuperIterable } from '../util/superIterable.ts';
 import type Logger from '@gershy/logger';
+import { RestApi } from '@aws-sdk/client-api-gateway';
 export declare namespace Soil {
     type PetalProjArgs = {
         s3Name: string;
@@ -13,11 +15,14 @@ export declare namespace Soil {
     };
     type LocalStackAwsService = never | 'acm' | 'apigateway' | 'cloudformation' | 'cloudwatch' | 'config' | 'dynamodb' | 'dynamodbstreams' | 'ec2' | 'es' | 'events' | 'firehose' | 'iam' | 'kinesis' | 'kms' | 'lambda' | 'logs' | 'opensearch' | 'redshift' | 'resource' | 'resourcegroupstaggingapi' | 'route53' | 'route53resolver' | 's3' | 's3control' | 'scheduler' | 'secretsmanager' | 'ses' | 'sns' | 'sqs' | 'ssm' | 'stepfunctions' | 'sts' | 'support' | 'swf' | 'transcribe';
     type BaseArgs = {
+        logger: Logger;
         registry: Registry<any>;
     };
     class Base {
+        protected logger: Logger;
         protected registry: Registry<any>;
         constructor(args: BaseArgs);
+        getRegion(): string;
         getTerraformPetals(ctx: Context): Promise<PetalProjResult>;
     }
     type LocalStackArgs = BaseArgs & {
@@ -34,19 +39,22 @@ export declare namespace Soil {
         private static localStackInternalPort;
         private aws;
         private localStackDocker;
-        private procArgs;
         constructor(args: LocalStackArgs);
+        getRegion(): "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
         private getAwsServices;
         private getDockerContainers;
-        run(args: {
-            logger: Logger;
-        }): Promise<{
+        run(): Promise<{
             aws: {
                 services: LocalStackAwsService[];
                 region: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
             };
             netProc: NetProc;
-            url: string;
+            getApis: () => Promise<{
+                [x: string]: RestApi & {
+                    id: string;
+                    name: string;
+                };
+            }>;
         }>;
         end(args?: {
             containers?: Awaited<ReturnType<Soil.LocalStack['getDockerContainers']>>;
@@ -71,6 +79,7 @@ export declare namespace Soil {
     class AwsCloud extends Base {
         private aws;
         constructor(args: AwsCloudArgs);
+        getRegion(): "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
         getTerraformPetals(ctx: Context): Promise<{
             boot: () => Generator<PetalTerraform.Terraform | PetalTerraform.Provider | PetalTerraform.File, void, unknown>;
             main: (args: any) => Generator<PetalTerraform.Terraform | PetalTerraform.Provider | PetalTerraform.File, void, unknown>;

package/cmp/cjs/soil/soil.js

@@ -7,18 +7,38 @@ exports.Soil = void 0;
 const nodejs_proc_1 = __importDefault(require("@gershy/nodejs-proc"));
 const main_ts_1 = require("../main.js");
 const util_retry_1 = __importDefault(require("@gershy/util-retry"));
-const clearing_1 = require("@gershy/clearing");
+require("@gershy/clearing");
 const util_http_1 = __importDefault(require("@gershy/util-http"));
 const aws_ts_1 = require("../util/aws.js");
+const client_api_gateway_1 = require("@aws-sdk/client-api-gateway");
+const { skip } = clearing;
+const merge = cl.merge;
+const map = cl.map;
+const cut = cl.cut;
+const fire = cl.fire;
+const hasHead = cl.hasHead;
+const has = cl.has;
+const toObj = cl.toObj;
+const toArr = cl.toArr;
+const baseline = cl.baseline;
+const mod = cl.mod;
+const group = cl.group;
+// TODO: Consider splitting each Soil implementation into its own unit
+// (Soil.LocalStack unit can, e.g., isolate the `@aws-sdk/client-api-gateway` dependency)
 var Soil;
 (function (Soil) {
     class Base {
+        logger;
         registry;
         constructor(args) {
+            this.logger = args.logger;
             this.registry = args.registry;
         }
+        getRegion() {
+            throw Error('method definition missing');
+        }
         async getTerraformPetals(ctx) {
-            throw Error('not implemented');
+            throw Error('method definition missing');
         }
     }
     Soil.Base = Base;
@@ -27,17 +47,16 @@ var Soil;
         static localStackInternalPort = 4566;
         aws;
         localStackDocker;
-        procArgs;
         constructor(args) {
-            super(args);
+            super({ ...args, logger: args.logger.kid('localStack') });
             this.aws = args.aws;
             this.localStackDocker = {
                 image: 'localstack/localstack:latest',
                 port: LocalStack.localStackInternalPort,
                 containerName: 'gershyLilacLocalStack'
             }[merge](args.localStackDocker ?? {});
-            this.procArgs = { env: process.env };
         }
+        getRegion() { return this.aws.region; }
         getAwsServices() {
             // Note that "overhead" services are essential for initializing localstack:
             // - s3 + ddb used for terraform state locking
@@ -48,29 +67,29 @@ var Soil;
         }
         async getDockerContainers() {
             const { containerName } = this.localStackDocker;
-            const dockerPs = await (0, nodejs_proc_1.default)(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`, this.procArgs);
+            const dockerPs = await (0, nodejs_proc_1.default)(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`);
             return dockerPs
                 .output
-                .split('\n')[map](v => v.trim() || clearing_1.skip)[map](v => v[cut](',', 1))[map](([name, state]) => ({ name, state }))
+                .split('\n')[map](v => v.trim() || skip)[map](v => v[cut](',', 1))[map](([name, state]) => ({ name, state }))
             // Exclude containers which match the `docker ps` filter but don't have the prefix
-            [map](v => (v.name === containerName || v.name[hasHead](`${containerName}-`)) ? v : clearing_1.skip);
+            [map](v => (v.name === containerName || v.name[hasHead](`${containerName}-`)) ? v : skip);
         }
-        run(args) {
-            return args.logger.scope('localStack', {}, async (logger) => {
+        run() {
+            return this.logger.scope('run', {}, async (logger) => {
                 // Run a localStack container in docker, enabling `terraform apply` on an aws-like target
                 const { image, port, containerName } = this.localStackDocker;
                 const awsServices = this.getAwsServices();
                 await logger.scope('dockerDeploy', { image, containerName, port }, async (logger) => {
-                    await (0, nodejs_proc_1.default)('docker info', this.procArgs).catch(({ output }) => Error('docker unavailable')[fire]({ output }));
+                    await (0, nodejs_proc_1.default)('docker info').catch(({ output }) => Error('docker unavailable')[fire]({ output }));
                     logger.log({ $$: 'dockerActive' });
                     const containers = await this.getDockerContainers();
                     let state = containers.find(c => c.name === containerName)?.state ?? 'nonexistent';
                     // First if a container already exists ensure it's compatible with our given config
                     if (['running', 'paused', 'exited'][has](state)) {
                         const isExistingContainerReusable = await (async () => {
-                            const { output: inspectJson } = await (0, nodejs_proc_1.default)(`docker inspect ${containerName}`, this.procArgs);
+                            const { output: inspectJson } = await (0, nodejs_proc_1.default)(`docker inspect ${containerName}`);
                             const [containerInfo] = JSON.parse(inspectJson);
-                            console.log('DOCKER INSPECT', containerInfo);
+                            logger.log({ $$: 'reusableCheck', containerInfo });
                             const containerImage = containerInfo.Config.Image;
                             const containerEnv = containerInfo.Config.Env[toObj](v => v[cut]('=', 1));
                             const containerPort = Number(containerInfo.HostConfig.PortBindings[`${LocalStack.localStackInternalPort}/tcp`]?.[0]?.HostPort ?? 0);
@@ -83,9 +102,9 @@ var Soil;
                         })();
                         if (isExistingContainerReusable) {
                             if (state === 'paused')
-                                await (0, nodejs_proc_1.default)(`docker unpause ${containerName}`, this.procArgs);
+                                await (0, nodejs_proc_1.default)(`docker unpause ${containerName}`);
                             if (state === 'exited')
-                                await (0, nodejs_proc_1.default)(`docker start ${containerName}`, this.procArgs);
+                                await (0, nodejs_proc_1.default)(`docker start ${containerName}`);
                             logger.log({ $$: 'containerReused' });
                             state = 'running';
                         }
@@ -107,8 +126,8 @@ var Soil;
             | -e SERVICES=${awsServices[toArr](v => v).join(',')}
             | -e DEFAULT_REGION=${this.aws.region}
             | ${image}
-          `).split('\n')[map](ln => ln.trim() || clearing_1.skip).join(' ');
-                        await (0, nodejs_proc_1.default)(runCmd, this.procArgs);
+          `).split('\n')[map](ln => ln.trim() || skip).join(' ');
+                        await (0, nodejs_proc_1.default)(runCmd);
                         state = 'running';
                     }
                     if (state !== 'running')
@@ -131,29 +150,36 @@ var Soil;
                         if (res.code !== 200)
                             throw Error('unhealthy')[mod]({ retry: true });
                         const { ya = [], no = [] } = res.body.services[group](v => v === 'available' ? 'ya' : 'no')[map](group => group[toArr]((v, k) => k));
-                        const missingServices = no[map](svc => awsServices.has(svc) ? svc : clearing_1.skip);
+                        const missingServices = no[map](svc => awsServices.has(svc) ? svc : skip);
                         if (missingServices.length)
                             throw Error('services unavailable')[mod]({ missingServices })[mod]({ retry: true });
-                        return { services: ya };
+                        return { res, services: ya };
                     },
                     retryable: err => !!err.retry,
                 }).catch(err => err[fire]({ numErrs: err.errs.length, errs: null }));
-                logger.log({ $$: 'localStackActive', services });
+                logger.log({ $$: 'result', services });
+                const netProc = { proto: 'http', addr: 'localhost', port };
                 return {
-                    aws: { services: [...awsServices], region: this.aws.region, },
-                    netProc: { proto: 'http', addr: 'localhost', port },
-                    url: `http://localhost:${port}`
+                    aws: { services: [...awsServices], region: this.aws.region },
+                    netProc,
+                    getApis: async () => {
+                        const client = new client_api_gateway_1.APIGatewayClient({ region: this.aws.region, endpoint: `${netProc.proto}://${netProc.addr}:${netProc.port}` });
+                        const apiRes = await client.send(new client_api_gateway_1.GetRestApisCommand({}));
+                        const apis = (apiRes.items ?? []);
+                        return apis[toObj](api => [api.name, api]);
+                    }
                 };
             });
         }
         async end(args) {
-            const containers = args?.containers ?? await this.getDockerContainers();
-            await (0, nodejs_proc_1.default)(`docker rm -f ${containers.map(c => c.name).join(' ')}`, this.procArgs)
-                .catch(err => {
-                console.log('ERROR ENDING LOCALSTACK DOCKER CONTAINER:\n', err.output);
-                return;
+            return this.logger.scope('end', {}, async (logger) => {
+                const containers = args?.containers ?? await this.getDockerContainers();
+                await (0, nodejs_proc_1.default)(`docker rm -f ${containers.map(c => c.name).join(' ')}`).catch(err => {
+                    logger.log({ $$: 'glitch', cmdOutput: err.output });
+                    return;
+                });
+                return containers;
             });
-            return containers;
         }
         async getTerraformPetals(ctx) {
             const { aws } = this;
@@ -221,6 +247,7 @@ var Soil;
             super(args);
             this.aws = args.aws;
         }
+        getRegion() { return this.aws.region; }
         async getTerraformPetals(ctx) {
             const { aws } = this;
             return {

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

@@ -1,19 +1,8 @@
+import '@gershy/clearing';
 export declare const capitalKeys: (v: any) => any;
-export declare const regions: readonly [{
+export declare const regions: {
     term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
     mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
-}, {
-    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
-    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
-}, {
-    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
-    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
-}, {
-    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
-    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
-}, {
-    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
-    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
-}];
+}[];
 export type RegionTerm = (typeof regions)[number]['term'];
 export type RegionMini = (typeof regions)[number]['mini'];