@gershy/lilac 0.0.13 → 0.0.15

package/cmp/cjs/util/procTerraform.js

@@ -17,14 +17,19 @@ exports.default = (fact, cmd, opts = {}) => {
         timeoutMs: 0,
         ...opts,
         cwd: fact,
-        env: { TF_DATA_DIR: '' }
+        env: {
+            ...process.env,
+            TF_DATA_DIR: '',
+            TF_CLI_CONFIG_FILE: '',
+            ...opts.env
+        }
     });
     return Object.assign(prm.then(async (result) => {
         const logDb = await writeLog(result.output);
         return { logDb, output: result.output.split('\n').slice(-numTailingTfLogLines).join('\n') };
     }, async (err) => {
-        const logDb = await writeLog(err.output ?? err[limn]());
-        throw Error(`terraform failed (${err.message})`)[mod]({
+        const logDb = await writeLog(err.output ?? err[cl.limn]());
+        throw Error(`terraform failed (${err.message})`)[cl.mod]({
             logDb,
             ...(err.output ? { output: err.output.split('\n').slice(-numTailingTfLogLines).join('\n') } : { cause: err })
         });

package/cmp/cjs/util/slashEscape.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = (str, escapeChars) => {
-    if (!escapeChars[has]('\\'))
+    if (!escapeChars[cl.has]('\\'))
         escapeChars += '\\';
     // The regex to construct must have "\" and "]" escaped:
     const escChars = escapeChars.replace(/([\\\]])/g, '\\$1');

package/cmp/cjs/util/terraform.js

@@ -6,7 +6,7 @@ const embed = (v) => '${' + v + '}';
 exports.embed = embed;
 const json = (v) => [
     '| <<EOF',
-    JSON.stringify(v, null, 2)[indent](2),
+    JSON.stringify(v, null, 2)[cl.indent](2),
     'EOF'
 ].join('\n');
 exports.json = json;

package/cmp/mjs/main.d.ts

@@ -1,7 +1,8 @@
 import '../sideEffects.js';
 import { PetalTerraform } from './petal/terraform/terraform.ts';
-import Logger from '@gershy/logger';
-import { Fact } from '@gershy/disk';
+import type Logger from '@gershy/logger';
+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;
@@ -39,6 +41,7 @@ export declare class Garden<Reg extends Registry<any>> {
     private ctx;
     private reg;
     private def;
+    private tfProcArgs;
     constructor(args: {
         context: Context;
         registry: Reg;

package/cmp/mjs/main.js

@@ -2,15 +2,23 @@
 // 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)
 import { PetalTerraform } from "./petal/terraform/terraform.js";
-import { isCls, skip } from '@gershy/clearing';
-import procTerraform from "./util/procTerraform.js";
+import { tempFact } from '@gershy/disk';
+import '@gershy/clearing';
 import tryWithHealing from '@gershy/util-try-with-healing';
 import phrasing from '@gershy/util-phrasing';
+import proc from '@gershy/nodejs-proc';
+const { isCls, skip } = cl;
+const toArr = cl.toArr;
+const allObj = cl.allObj;
+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;
 export 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
@@ -40,7 +48,7 @@ export 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);
@@ -58,11 +66,21 @@ export 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
@@ -115,7 +133,7 @@ export class Garden {
                         await Promise.all(files[toArr]((data, kfp) => args.fact.kid(kfp.split('/')).setData(data)));
                         return petal;
                     });
-                    await stream.end(); // TODO: @gershy/disk should allow `await headStream.end()`
+                    await stream.end();
                 });
                 return args.fact;
             });
@@ -154,7 +172,7 @@ export class Garden {
                         // Create ddb tf state locking table
                         await writePetalTfAndFiles(new PetalTerraform.Resource('awsDynamodbTable', 'tfState', {
                             name: ddbName,
-                            billingMode: phrasing('payPerRequest', 'camel', 'snake')[upper](),
+                            billingMode: phrasing('camel->snake', 'payPerRequest')[upper](),
                             hashKey: 'LockID',
                             $attribute: { name: 'LockID', type: 'S' }
                         }));
@@ -181,31 +199,55 @@ export 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 procTerraform(fact, `terraform init -input=false`, {
-                onData: async (mode, data) => logger.log({ $$: 'notice', mode, data }) ?? null
+            const { output: result } = await tryWithHealing({
+                fn: () => logger.scope('attempt', {}, async (logger) => {
+                    const configFact = tempFact.kid([`${Math.random().toString(36).slice(2)}.terraform.rc`]);
+                    await configFact.setData(String[baseline](`
+            | provider_installation {
+            |   filesystem_mirror {
+            |     path = "${mirrorFact.fsp().replaceAll('\\', '/')}"
+            |   }
+            | }
+          `));
+                    return proc(`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 proc(`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 procTerraform(fact, `terraform plan -input=false`);
-            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            const { output: result } = await proc(`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 procTerraform(fact, `terraform apply -input=false -auto-approve`);
-            logger.log({ $$: 'result', logFp: result.logDb.toString(), msg: result.output });
+            const { output: result } = await proc(`terraform apply -input=false -auto-approve`, {}[merge](this.tfProcArgs)[merge]({
+                cwd: fact
+            }));
+            logger.log({ $$: 'result', result });
             return result;
         });
     }

package/cmp/mjs/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/mjs/petal/terraform/terraform.js

@@ -1,7 +1,15 @@
-import { getClsName, isCls } from '@gershy/clearing';
+import '@gershy/clearing';
 import slashEscape from "../../util/slashEscape.js";
 import Petal from "../petal.js";
 import ph from '@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;
 export var PetalTerraform;
 (function (PetalTerraform) {
     class Base extends Petal {
@@ -49,13 +57,13 @@ export var PetalTerraform;
                         throw Error('tf key of this form must correspond to object value')[mod]({ k, v });
                     // Resolve to raw string?
                     if (special && isCls(v, String))
-                        return [ph(pcs[0], 'camel', 'snake'), ' = ', this.terraformEncode(v[hasHead]('| ') ? v : `| ${v}`)];
+                        return [ph('camel->snake', pcs[0]), ' = ', this.terraformEncode(v[hasHead]('| ') ? v : `| ${v}`)];
                     // Resolve to nested block?
                     if (special && isCls(v, Object))
-                        return [[ph(pcs[0], 'camel', 'snake'), ...pcs.slice(1)[map](pc => ph(pc, 'camel', 'snake'))].join(' '), ' ', this.terraformEncode(v)];
+                        return [[ph('camel->snake', pcs[0]), ...pcs.slice(1)[map](pc => ph('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 [ph(pcs[0], 'camel', 'snake'), ' = ', this.terraformEncode(v)];
+                    return [ph('camel->snake', pcs[0]), ' = ', this.terraformEncode(v)];
                 });
                 const len = entryItems.length;
                 if (len === 0)
@@ -76,9 +84,9 @@ export var PetalTerraform;
         refStr(props = []) {
             if (!isCls(props, Array))
                 props = [props];
-            const base = `${ph(this.getType(), 'camel', 'snake')}.${ph(this.getHandle(), 'camel', 'snake')}`;
+            const base = `${ph('camel->snake', this.getType())}.${ph('camel->snake', this.getHandle())}`;
             return props.length
-                ? `${base}.${props[map](v => ph(v, 'camel', 'snake')).join('.')}`
+                ? `${base}.${props[map](v => ph('camel->snake', v)).join('.')}`
                 : base;
         }
         ref(props = []) {
@@ -124,7 +132,7 @@ export var PetalTerraform;
         getHandle() { return this.handle; }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `resource "${ph(this.type, 'camel', 'snake')}" "${ph(this.handle, 'camel', 'snake')}"`;
+            return `resource "${ph('camel->snake', this.type)}" "${ph('camel->snake', this.handle)}"`;
         }
     }
     PetalTerraform.Resource = Resource;
@@ -139,7 +147,7 @@ export var PetalTerraform;
         }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `provider "${ph(this.name, 'camel', 'snake')}"`;
+            return `provider "${ph('camel->snake', this.name)}"`;
         }
     }
     PetalTerraform.Provider = Provider;
@@ -158,7 +166,7 @@ export var PetalTerraform;
         getHandle() { return this.handle; }
         getProps() { return this.props; }
         async getResultHeader() {
-            return `data "${ph(this.type, 'camel', 'snake')}" "${ph(this.handle, 'camel', 'snake')}"`;
+            return `data "${ph('camel->snake', this.type)}" "${ph('camel->snake', this.handle)}"`;
         }
         refStr(props = []) {
             return `data.${super.refStr(props)}`;

package/cmp/mjs/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 Logger from '@gershy/logger';
+import type Logger from '@gershy/logger';
+import { RestApi } from '@aws-sdk/client-api-gateway';
 export declare namespace Soil {
     type PetalProjArgs = {
         s3Name: string;
@@ -13,9 +15,11 @@ 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);
         getTerraformPetals(ctx: Context): Promise<PetalProjResult>;
@@ -34,19 +38,21 @@ export declare namespace Soil {
         private static localStackInternalPort;
         private aws;
         private localStackDocker;
-        private procArgs;
         constructor(args: LocalStackArgs);
         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']>>;

package/cmp/mjs/soil/soil.js

@@ -1,15 +1,31 @@
-import { rootFact } from '@gershy/disk';
 import proc from '@gershy/nodejs-proc';
 import { PetalTerraform } from "../main.js";
 import retry from '@gershy/util-retry';
-import { skip } from '@gershy/clearing';
+import '@gershy/clearing';
 import http from '@gershy/util-http';
 import { regions as awsRegions } from "../util/aws.js";
+import { APIGatewayClient, GetRestApisCommand } from '@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)
 export var Soil;
 (function (Soil) {
     class Base {
+        logger;
         registry;
         constructor(args) {
+            this.logger = args.logger;
             this.registry = args.registry;
         }
         async getTerraformPetals(ctx) {
@@ -22,16 +38,14 @@ export 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 = { cwd: rootFact, env: process.env };
         }
         getAwsServices() {
             // Note that "overhead" services are essential for initializing localstack:
@@ -43,29 +57,29 @@ export var Soil;
         }
         async getDockerContainers() {
             const { containerName } = this.localStackDocker;
-            const dockerPs = await proc(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`, this.procArgs);
+            const dockerPs = await proc(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`);
             return dockerPs
                 .output
                 .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 : 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 proc('docker info', this.procArgs).catch(({ output }) => Error('docker unavailable')[fire]({ output }));
+                    await proc('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 proc(`docker inspect ${containerName}`, this.procArgs);
+                            const { output: inspectJson } = await proc(`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);
@@ -78,9 +92,9 @@ export var Soil;
                         })();
                         if (isExistingContainerReusable) {
                             if (state === 'paused')
-                                await proc(`docker unpause ${containerName}`, this.procArgs);
+                                await proc(`docker unpause ${containerName}`);
                             if (state === 'exited')
-                                await proc(`docker start ${containerName}`, this.procArgs);
+                                await proc(`docker start ${containerName}`);
                             logger.log({ $$: 'containerReused' });
                             state = 'running';
                         }
@@ -103,7 +117,7 @@ export var Soil;
             | -e DEFAULT_REGION=${this.aws.region}
             | ${image}
           `).split('\n')[map](ln => ln.trim() || skip).join(' ');
-                        await proc(runCmd, this.procArgs);
+                        await proc(runCmd);
                         state = 'running';
                     }
                     if (state !== 'running')
@@ -129,26 +143,33 @@ export var Soil;
                         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 APIGatewayClient({ region: this.aws.region, endpoint: `${netProc.proto}://${netProc.addr}:${netProc.port}` });
+                        const apiRes = await client.send(new GetRestApisCommand({}));
+                        const apis = (apiRes.items ?? []);
+                        return apis[toObj](api => [api.name, api]);
+                    }
                 };
             });
         }
         async end(args) {
-            const containers = args?.containers ?? await this.getDockerContainers();
-            await proc(`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 proc(`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;

package/cmp/mjs/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'];

package/cmp/mjs/util/aws.js

@@ -1,10 +1,10 @@
-import { isCls } from '@gershy/clearing';
+import '@gershy/clearing';
 import ph from '@gershy/util-phrasing';
 export const capitalKeys = (v) => {
-    if (isCls(v, Array))
-        return v[map](v => capitalKeys(v));
-    if (isCls(v, Object))
-        return v[mapk]((val, key) => [ph(key, 'camel', 'kamel'), capitalKeys(val)]);
+    if (cl.isCls(v, Array))
+        return v[cl.map](v => capitalKeys(v));
+    if (cl.isCls(v, Object))
+        return v[cl.mapk]((val, key) => [ph('camel->kamel', key), capitalKeys(val)]);
     return v;
 };
 export const regions = [
@@ -47,7 +47,7 @@ export const regions = [
     // Ignoring these for now...
     // 'us-gov-east-1',
     // 'us-gov-west-1',
-][map](region => {
+][cl.map](region => {
     const [c, z, num] = region.split('-');
     const [dir0, dir1 = dir0] = z.match(/central|north|south|east|west/g);
     return {

package/cmp/mjs/util/normalize.d.ts

@@ -1,2 +1,3 @@
+import '@gershy/clearing';
 declare const normalize: (val: any, seen?: Set<any>) => any;
 export default normalize;

package/cmp/mjs/util/normalize.js

@@ -1,4 +1,5 @@
-import { isCls, getClsName } from '@gershy/clearing';
+import '@gershy/clearing';
+const { isCls, getClsName } = clearing;
 const normalize = (val, seen = new Set()) => {
     // Derives a json-stringifiable value from *any* value
     // E.g. to hash *anything*: hash(JSON.stringify(normalized(anything)));
@@ -15,7 +16,7 @@ const normalize = (val, seen = new Set()) => {
         return '<<!circ!>>';
     seen.add(val);
     if (isCls(val, Array))
-        return val[map](v => normalize(v, seen));
+        return val[cl.map](v => normalize(v, seen));
     if (isCls(val, Object))
         return normalize(Object.entries(val).sort((e0, e1) => e0[0] < e1[0] ? -1 : 1), seen);
     return normalize({ $form: getClsName(val), ...val }, seen);

package/cmp/mjs/util/procTerraform.d.ts

@@ -1,6 +1,8 @@
-import { Fact } from '@gershy/disk';
+import type { Fact } from '@gershy/disk';
 import { ProcOpts } from '@gershy/nodejs-proc';
-export type ProcTerraformArgs = ProcOpts & {};
+export type ProcTerraformArgs = ProcOpts & {
+    config?: string;
+};
 declare const _default: (fact: Fact, cmd: string, opts?: ProcTerraformArgs) => Promise<{
     logDb: Fact;
     output: string;

package/cmp/mjs/util/procTerraform.js

@@ -12,14 +12,19 @@ export default (fact, cmd, opts = {}) => {
         timeoutMs: 0,
         ...opts,
         cwd: fact,
-        env: { TF_DATA_DIR: '' }
+        env: {
+            ...process.env,
+            TF_DATA_DIR: '',
+            TF_CLI_CONFIG_FILE: '',
+            ...opts.env
+        }
     });
     return Object.assign(prm.then(async (result) => {
         const logDb = await writeLog(result.output);
         return { logDb, output: result.output.split('\n').slice(-numTailingTfLogLines).join('\n') };
     }, async (err) => {
-        const logDb = await writeLog(err.output ?? err[limn]());
-        throw Error(`terraform failed (${err.message})`)[mod]({
+        const logDb = await writeLog(err.output ?? err[cl.limn]());
+        throw Error(`terraform failed (${err.message})`)[cl.mod]({
             logDb,
             ...(err.output ? { output: err.output.split('\n').slice(-numTailingTfLogLines).join('\n') } : { cause: err })
         });

package/cmp/mjs/util/slashEscape.js

@@ -1,5 +1,5 @@
 export default (str, escapeChars) => {
-    if (!escapeChars[has]('\\'))
+    if (!escapeChars[cl.has]('\\'))
         escapeChars += '\\';
     // The regex to construct must have "\" and "]" escaped:
     const escChars = escapeChars.replace(/([\\\]])/g, '\\$1');

package/cmp/mjs/util/terraform.js

@@ -2,6 +2,6 @@
 export const embed = (v) => '${' + v + '}';
 export const json = (v) => [
     '| <<EOF',
-    JSON.stringify(v, null, 2)[indent](2),
+    JSON.stringify(v, null, 2)[cl.indent](2),
     'EOF'
 ].join('\n');