@gershy/lilac 0.0.11 → 0.0.13

package/cmp/mjs/soil/soil.js

@@ -0,0 +1,285 @@
+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 http from '@gershy/util-http';
+import { regions as awsRegions } from "../util/aws.js";
+export var Soil;
+(function (Soil) {
+    class Base {
+        registry;
+        constructor(args) {
+            this.registry = args.registry;
+        }
+        async getTerraformPetals(ctx) {
+            throw Error('not implemented');
+        }
+    }
+    Soil.Base = Base;
+    ;
+    class LocalStack extends Base {
+        static localStackInternalPort = 4566;
+        aws;
+        localStackDocker;
+        procArgs;
+        constructor(args) {
+            super(args);
+            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:
+            // - s3 + ddb used for terraform state locking
+            // - sts is used for credential validation
+            // - iam is needed for role creation
+            const overheadAwsServices = ['s3', 'dynamodb', 'sts', 'iam'];
+            return new Set([...overheadAwsServices, ...this.registry.getAwsServices()]);
+        }
+        async getDockerContainers() {
+            const { containerName } = this.localStackDocker;
+            const dockerPs = await proc(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`, this.procArgs);
+            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 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 }));
+                    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 [containerInfo] = JSON.parse(inspectJson);
+                            console.log('DOCKER INSPECT', 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);
+                            const services = (containerEnv.SERVICES ?? '').split(',').sort().join(',');
+                            return true
+                                && containerImage === image
+                                && containerPort === port
+                                && containerEnv.DEFAULT_REGION === this.aws.region
+                                && services === awsServices[toArr](v => v).sort().join(',');
+                        })();
+                        if (isExistingContainerReusable) {
+                            if (state === 'paused')
+                                await proc(`docker unpause ${containerName}`, this.procArgs);
+                            if (state === 'exited')
+                                await proc(`docker start ${containerName}`, this.procArgs);
+                            logger.log({ $$: 'containerReused' });
+                            state = 'running';
+                        }
+                        else {
+                            await this.end({ containers });
+                            logger.log({ $$: 'previousLocalStackRemoved', containers });
+                            state = 'nonexistent';
+                        }
+                    }
+                    if (state === 'nonexistent') {
+                        const runCmd = String[baseline](`
+            | docker run
+            | --rm
+            | -d
+            | --privileged${'' /* TODO: consider removing? */}
+            | --name ${containerName}
+            | -p ${port}:${LocalStack.localStackInternalPort}
+            | -v /var/run/docker.sock:/var/run/docker.sock
+            | -e SERVICES=${awsServices[toArr](v => v).join(',')}
+            | -e DEFAULT_REGION=${this.aws.region}
+            | ${image}
+          `).split('\n')[map](ln => ln.trim() || skip).join(' ');
+                        await proc(runCmd, this.procArgs);
+                        state = 'running';
+                    }
+                    if (state !== 'running')
+                        throw Error('container state unexpected')[mod]({ state });
+                });
+                const readyEndpoint = {
+                    $req: null,
+                    $res: null,
+                    netProc: { proto: 'http', addr: 'localhost', port },
+                    path: ['_localstack', 'health'],
+                    method: 'get'
+                };
+                const { val: { services } } = await retry({
+                    // TODO: If the container already exists, it seems its "s3" and "sts" services become unavailable when we try to reinitialize Soil pointing at it??
+                    attempts: 20,
+                    delay: n => Math.min(500, 50 * n),
+                    fn: async () => {
+                        // Retry all failures and non-200s
+                        const res = await http(readyEndpoint, {}).catch(err => err[fire]({ retry: true }));
+                        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 : skip);
+                        if (missingServices.length)
+                            throw Error('services unavailable')[mod]({ missingServices })[mod]({ retry: true });
+                        return { services: ya };
+                    },
+                    retryable: err => !!err.retry,
+                }).catch(err => err[fire]({ numErrs: err.errs.length, errs: null }));
+                logger.log({ $$: 'localStackActive', services });
+                return {
+                    aws: { services: [...awsServices], region: this.aws.region, },
+                    netProc: { proto: 'http', addr: 'localhost', port },
+                    url: `http://localhost:${port}`
+                };
+            });
+        }
+        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 containers;
+        }
+        async getTerraformPetals(ctx) {
+            const { aws } = this;
+            const awsServices = [...this.getAwsServices()];
+            const netProc = { proto: 'http', addr: 'localhost', port: this.localStackDocker.port };
+            const localStackUrl = `${netProc.proto}://${netProc.addr}:${netProc.port}`;
+            return {
+                boot: () => [
+                    new PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0`
+                            }
+                        }
+                    }),
+                    new PetalTerraform.Provider('aws', {
+                        region: aws.region,
+                        skipCredentialsValidation: true,
+                        skipRequestingAccountId: true,
+                        s3UsePathStyle: true, // Otherwise requests can go to "bucket.s3.amazonaws.com", outside localStack
+                        // Note our localStack setup always includes s3 and ddb (required for tf state storage)
+                        $endpoints: awsServices[toObj](svc => [svc, localStackUrl])
+                    })
+                ],
+                main: function* (args) {
+                    yield new PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0` // Consider parameterizing??
+                            }
+                        },
+                        '$backend.s3': {
+                            region: aws.region,
+                            encrypt: true,
+                            bucket: args.s3Name,
+                            key: `tf`,
+                            dynamodbTable: args.ddbName,
+                            usePathStyle: true,
+                            // Point the S3 backend at LocalStack when testing
+                            endpoints: awsServices[toObj](svc => [svc, localStackUrl]),
+                        }
+                    });
+                    for (const { term } of awsRegions)
+                        yield new PetalTerraform.Provider('aws', {
+                            region: term,
+                            skipCredentialsValidation: true,
+                            skipRequestingAccountId: true,
+                            // Omit the alias for the default provider!
+                            ...(term !== aws.region && { alias: term.split('-').join('_') }),
+                            // Point providers at LocalStack when testing
+                            s3UsePathStyle: true,
+                            $endpoints: awsServices[toObj](svc => [svc, localStackUrl])
+                        });
+                }
+            };
+        }
+    }
+    Soil.LocalStack = LocalStack;
+    ;
+    class AwsCloud extends Base {
+        aws;
+        constructor(args) {
+            super(args);
+            this.aws = args.aws;
+        }
+        async getTerraformPetals(ctx) {
+            const { aws } = this;
+            return {
+                boot: function* () {
+                    const tfAwsCredsFile = new PetalTerraform.File('creds.ini', String[baseline](`
+            | [default]
+            | aws_region            = ${aws.region}
+            | aws_access_key_id     = ${aws.accessKey.id}
+            | aws_secret_access_key = ${aws.accessKey['!secret']}
+          `));
+                    yield tfAwsCredsFile;
+                    yield new PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0`
+                            }
+                        }
+                    });
+                    yield new PetalTerraform.Provider('aws', {
+                        sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                        profile: 'default', // References a section within the credentials file
+                        region: aws.region,
+                    });
+                },
+                main: function* (args) {
+                    const credFileProfile = 'default';
+                    const tfAwsCredsFile = new PetalTerraform.File('creds.ini', String[baseline](`
+            | [${credFileProfile}]
+            | aws_region            = ${aws.region}
+            | aws_access_key_id     = ${aws.accessKey.id}
+            | aws_secret_access_key = ${aws.accessKey['!secret']}
+          `));
+                    yield tfAwsCredsFile;
+                    yield new PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0` // Consider parameterizing??
+                            }
+                        },
+                        '$backend.s3': {
+                            sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                            profile: credFileProfile,
+                            region: aws.region,
+                            encrypt: true,
+                            bucket: args.s3Name,
+                            key: `tf`,
+                            dynamodbTable: args.ddbName
+                        }
+                    });
+                    for (const { term } of awsRegions)
+                        yield new PetalTerraform.Provider('aws', {
+                            sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                            profile: credFileProfile,
+                            region: term,
+                            // Omit the alias for the default provider!
+                            ...(term !== aws.region && { alias: term.split('-').join('_') }),
+                        });
+                }
+            };
+        }
+    }
+    Soil.AwsCloud = AwsCloud;
+    ;
+})(Soil || (Soil = {}));
+;

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

@@ -1,5 +1,19 @@
 export declare const capitalKeys: (v: any) => any;
-export declare const regions: {
-    term: string;
-    mini: string;
-}[];
+export declare const regions: readonly [{
+    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

@@ -50,5 +50,8 @@ export const regions = [
 ][map](region => {
     const [c, z, num] = region.split('-');
     const [dir0, dir1 = dir0] = z.match(/central|north|south|east|west/g);
-    return { term: region, mini: [c, dir0[0], dir1[0], num].join('') };
+    return {
+        term: region,
+        mini: [c, dir0[0], dir1[0], num].join('')
+    };
 });

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

@@ -1,8 +1,10 @@
-import { rootFact } from '@gershy/disk';
-import { ProcOpts } from '@gershy/util-nodejs-proc';
-type Fact = typeof rootFact;
-declare const _default: (fact: Fact, cmd: string, opts?: ProcOpts) => Promise<{
-    logDb: import("@gershy/disk").Fact;
+import { Fact } from '@gershy/disk';
+import { ProcOpts } from '@gershy/nodejs-proc';
+export type ProcTerraformArgs = ProcOpts & {};
+declare const _default: (fact: Fact, cmd: string, opts?: ProcTerraformArgs) => Promise<{
+    logDb: Fact;
     output: string;
-}>;
+}> & {
+    proc: import("child_process").ChildProcessWithoutNullStreams;
+};
 export default _default;

package/cmp/mjs/util/procTerraform.js

@@ -1,5 +1,5 @@
-import proc from '@gershy/util-nodejs-proc';
-export default (fact, cmd, opts) => {
+import proc from '@gershy/nodejs-proc';
+export default (fact, cmd, opts = {}) => {
     const numTailingTfLogLines = 20;
     const writeLog = async (result) => {
         const [yr, mo, dy, hr, mn, sc, ms] = new Date().toISOString().match(/([0-9]{4})[-]([0-9]{2})[-]([0-9]{2})[T]([0-9]{2})[:]([0-9]{2})[:]([0-9]{2})[.]([0-9]+)[Z]/).slice(1);
@@ -8,12 +8,13 @@ export default (fact, cmd, opts) => {
         await logDb.setData(result);
         return logDb;
     };
-    return proc(cmd, {
+    const prm = proc(cmd, {
         timeoutMs: 0,
         ...opts,
         cwd: fact,
         env: { TF_DATA_DIR: '' }
-    }).then(async (result) => {
+    });
+    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) => {
@@ -22,5 +23,5 @@ export default (fact, cmd, opts) => {
             logDb,
             ...(err.output ? { output: err.output.split('\n').slice(-numTailingTfLogLines).join('\n') } : { cause: err })
         });
-    });
+    }), { proc: prm.proc });
 };

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

@@ -0,0 +1 @@
+export type SuperIterable<T> = Iterable<T> | Promise<Iterable<T>> | AsyncIterable<T>;

package/cmp/mjs/util/superIterable.js

@@ -0,0 +1 @@
+export {};

package/cmp/mjs/util/terraform.js

@@ -1,3 +1,4 @@
+// TODO: Flower definers (Lilac consumers) will want to use these - make sure they're well-exposed
 export const embed = (v) => '${' + v + '}';
 export const json = (v) => [
     '| <<EOF',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gershy/lilac",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Luscious infrastructure Living as Code - an opinionated approach to IAC",
   "keywords": [
     "lilac",
@@ -22,16 +22,20 @@
     "@gershy/clearing": "^0.0.29"
   },
   "devDependencies": {
+    "@aws-sdk/client-api-gateway": "^3.1009.0",
+    "@gershy/util-hash": "^0.0.3",
     "@types/node": "^24.10.1",
+    "jszip": "^3.10.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@gershy/disk": "^0.0.10",
-    "@gershy/logger": "^0.0.3",
+    "@gershy/logger": "^0.0.4",
+    "@gershy/nodejs-proc": "^0.0.4",
     "@gershy/util-http": "^0.0.4",
-    "@gershy/util-nodejs-proc": "^0.0.10",
-    "@gershy/util-phrasing": "^0.0.4"
+    "@gershy/util-phrasing": "^0.0.4",
+    "@gershy/util-try-with-healing": "^0.0.2"
   },
   "type": "module",
   "files": [

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

@@ -1,13 +0,0 @@
-export type MockAwsArgs = {
-    port: number;
-    image: `localstack/localstack${':' | '@'}${string}`;
-};
-declare const _default: (args: MockAwsArgs) => Promise<{
-    netProc: {
-        proto: string;
-        addr: string;
-        port: number;
-    };
-    end: () => Promise<void>;
-}>;
-export default _default;

package/cmp/cjs/util/mockAws.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_nodejs_proc_1 = __importDefault(require("@gershy/util-nodejs-proc"));
-const disk_1 = require("@gershy/disk");
-const util_http_1 = __importDefault(require("@gershy/util-http"));
-const LOCALSTACK_IMAGE = 'localstack/localstack:latest';
-const LOCALSTACK_PORT = 4566;
-exports.default = async (args) => {
-    // Ensure docker is running
-    await (async () => {
-        const output = await (0, util_nodejs_proc_1.default)('docker ps', { cwd: disk_1.rootFact });
-        if (!output[has]('TODO'))
-            throw Error('docker unavailable');
-    })();
-    // Deploy localstack to docker
-    const { containerName } = await (async () => {
-        const containerName = `mockAws${Date.now()}`;
-        await (0, util_nodejs_proc_1.default)(`docker run --rm -d --name ${containerName} -p ${args.port}:${args.port} ${args.image}`, { cwd: disk_1.rootFact });
-        const readyEndpoint = {
-            $req: null,
-            $res: null,
-            netProc: { proto: 'http', addr: 'localhost', port: args.port },
-            path: ['health', 'ready'],
-            method: 'get'
-        };
-        const res = await (0, util_http_1.default)(readyEndpoint, { query: {}, body: {} });
-        console.log('localstack http health', { res });
-        return { containerName };
-    })();
-    return {
-        netProc: { proto: 'http', addr: 'localhost', port: args.port },
-        end: async () => {
-            await (0, util_nodejs_proc_1.default)(`docker rm -f ${containerName}`, { cwd: disk_1.rootFact });
-        }
-    };
-};

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

@@ -1,7 +0,0 @@
-export type TryWithHealingArgs<T> = {
-    fn: () => Promise<T>;
-    canHeal: (err: any) => boolean;
-    heal: () => Promise<any>;
-};
-declare const _default: <T>(args: TryWithHealingArgs<T>) => Promise<T>;
-export default _default;

package/cmp/cjs/util/tryWithHealing.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = async (args) => {
-    const { fn, heal, canHeal } = args;
-    return fn().catch(async (err) => {
-        if (!canHeal(err))
-            throw err;
-        await heal();
-        return fn();
-    });
-};

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

@@ -1,13 +0,0 @@
-export type MockAwsArgs = {
-    port: number;
-    image: `localstack/localstack${':' | '@'}${string}`;
-};
-declare const _default: (args: MockAwsArgs) => Promise<{
-    netProc: {
-        proto: string;
-        addr: string;
-        port: number;
-    };
-    end: () => Promise<void>;
-}>;
-export default _default;

package/cmp/mjs/util/mockAws.js

@@ -1,34 +0,0 @@
-import proc from '@gershy/util-nodejs-proc';
-import { rootFact } from '@gershy/disk';
-import http from '@gershy/util-http';
-const LOCALSTACK_IMAGE = 'localstack/localstack:latest';
-const LOCALSTACK_PORT = 4566;
-export default async (args) => {
-    // Ensure docker is running
-    await (async () => {
-        const output = await proc('docker ps', { cwd: rootFact });
-        if (!output[has]('TODO'))
-            throw Error('docker unavailable');
-    })();
-    // Deploy localstack to docker
-    const { containerName } = await (async () => {
-        const containerName = `mockAws${Date.now()}`;
-        await proc(`docker run --rm -d --name ${containerName} -p ${args.port}:${args.port} ${args.image}`, { cwd: rootFact });
-        const readyEndpoint = {
-            $req: null,
-            $res: null,
-            netProc: { proto: 'http', addr: 'localhost', port: args.port },
-            path: ['health', 'ready'],
-            method: 'get'
-        };
-        const res = await http(readyEndpoint, { query: {}, body: {} });
-        console.log('localstack http health', { res });
-        return { containerName };
-    })();
-    return {
-        netProc: { proto: 'http', addr: 'localhost', port: args.port },
-        end: async () => {
-            await proc(`docker rm -f ${containerName}`, { cwd: rootFact });
-        }
-    };
-};

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

@@ -1,7 +0,0 @@
-export type TryWithHealingArgs<T> = {
-    fn: () => Promise<T>;
-    canHeal: (err: any) => boolean;
-    heal: () => Promise<any>;
-};
-declare const _default: <T>(args: TryWithHealingArgs<T>) => Promise<T>;
-export default _default;

package/cmp/mjs/util/tryWithHealing.js

@@ -1,9 +0,0 @@
-export default async (args) => {
-    const { fn, heal, canHeal } = args;
-    return fn().catch(async (err) => {
-        if (!canHeal(err))
-            throw err;
-        await heal();
-        return fn();
-    });
-};