@gershy/lilac 0.0.1

package/cmp/cjs/util/aws.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regions = exports.capitalKeys = void 0;
+const clearing_1 = require("@gershy/clearing");
+const capitalize_ts_1 = __importDefault(require("./capitalize.js"));
+const capitalKeys = (v) => {
+    if ((0, clearing_1.isCls)(v, Array))
+        return v[map](v => (0, exports.capitalKeys)(v));
+    if ((0, clearing_1.isCls)(v, Object))
+        return v[mapk]((val, key) => [(0, capitalize_ts_1.default)(key), (0, exports.capitalKeys)(val)]);
+    return v;
+};
+exports.capitalKeys = capitalKeys;
+exports.regions = [
+    'ca-central-1',
+    'us-east-1',
+    'us-east-2',
+    'us-west-1',
+    'us-west-2',
+    // TODO: What's the exact purpose of this definition? Exhaustive list of regions??
+    // 'af-south-1',
+    // 'ap-east-1',
+    // 'ap-east-2',
+    // 'ap-northeast-1',
+    // 'ap-northeast-2',
+    // 'ap-northeast-3',
+    // 'ap-south-1',
+    // 'ap-south-2',
+    // 'ap-southeast-1',
+    // 'ap-southeast-2',
+    // 'ap-southeast-3',
+    // 'ap-southeast-4',
+    // 'ap-southeast-5',
+    // 'ap-southeast-7',
+    // 'ca-west-1',
+    // 'cn-north-1',
+    // 'cn-northwest-1',
+    // 'eu-central-1',
+    // 'eu-central-2',
+    // 'eu-north-1',
+    // 'eu-south-1',
+    // 'eu-south-2',
+    // 'eu-west-1',
+    // 'eu-west-2',
+    // 'eu-west-3',
+    // 'il-central-1',
+    // 'me-central-1',
+    // 'me-south-1',
+    // 'mx-central-1',
+    // 'sa-east-1',
+    // Ignoring these for now...
+    // 'us-gov-east-1',
+    // 'us-gov-west-1',
+][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('') };
+});

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

@@ -0,0 +1,3 @@
+export declare const provider: (defaultAwsRegion: string, targetAwsRegion: string) => {
+    $provider: string;
+};

package/cmp/cjs/util/awsTerraform.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provider = void 0;
+const provider = (defaultAwsRegion, targetAwsRegion) => {
+    return defaultAwsRegion !== targetAwsRegion
+        ? { $provider: `aws.${targetAwsRegion.split('-').join('_')}` }
+        : {};
+};
+exports.provider = provider;

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

@@ -0,0 +1,2 @@
+declare const capitalize: (v: string | string[]) => string;
+export default capitalize;

package/cmp/cjs/util/capitalize.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clearing_1 = require("@gershy/clearing");
+const capitalize = (v) => {
+    // capitalize('hello')                       -> "Hello"
+    // capitalize('heLLo')                       -> "HeLLo"
+    // capitalize([ 'my', 'name', 'is', 'bOb' ]) -> "myNameIsBOb"
+    if ((0, clearing_1.isCls)(v, String))
+        return v[0][upper]() + v.slice(1);
+    return [v[0], ...v.slice(1)[map](v => v[0][upper]() + v.slice(1))].join('');
+};
+exports.default = capitalize;

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

@@ -0,0 +1,2 @@
+declare const _default: (str: string | Buffer | Iterable<string | Buffer>, targetBase?: string) => string;
+export default _default;

package/cmp/cjs/util/hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const clearing_1 = require("@gershy/clearing");
+exports.default = (str, targetBase = String[base62]) => {
+    // Consider moving this under the "node" directory - relies on "node:crypto'
+    if ((0, clearing_1.isCls)(str, String) || (0, clearing_1.isCls)(str, Buffer))
+        str = [str];
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    for (const val of str)
+        hash.update(val);
+    return hash
+        .digest('base64url')[toNum](String[base64Url])[toStr](targetBase);
+};

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

@@ -0,0 +1,20 @@
+type LoggerData = null | boolean | number | string | {
+    [limn]: (...args: any) => LoggerData;
+} | LoggerData[] | {
+    [k: string]: LoggerData;
+};
+export default class Logger {
+    static dummy: Logger;
+    private format;
+    private domain;
+    private ctx;
+    private write;
+    private opts;
+    constructor(domain: string, ctx?: Obj<any>, opts?: typeof this.opts, write?: typeof this.write);
+    getDomain(): string;
+    getTraceId(term: string): string;
+    log(data: LoggerData): void;
+    kid(domain: string): Logger;
+    scope<Fn extends (logger: Logger) => any>(domain: string, ctx: Obj<any>, fn: Fn): ReturnType<Fn>;
+}
+export {};

package/cmp/cjs/util/logger.js

@@ -0,0 +1,150 @@
+"use strict";
+// TODO: @gershy/logger (or @gershy/watcher?)
+Object.defineProperty(exports, "__esModule", { value: true });
+const clearing_1 = require("@gershy/clearing");
+const scrubbed = (val, opts = {}) => {
+    const { isScrub = (k, _v) => k[0] === '!', doScrub = ((v) => `$scrub(${(0, clearing_1.getClsName)(v)})`), seen = new Map() } = opts ?? {};
+    if (val === null)
+        return val;
+    if ((0, clearing_1.isCls)(val, Boolean))
+        return val;
+    if ((0, clearing_1.isCls)(val, Number))
+        return val;
+    if ((0, clearing_1.isCls)(val, String))
+        return val;
+    if (seen.has(val))
+        return seen.get(val) ?? null;
+    if ((0, clearing_1.isCls)(val, Array)) {
+        const result = [];
+        seen.set(val, result);
+        for (const item of val)
+            result.push(scrubbed(item, { isScrub, doScrub, seen }));
+        return result;
+    }
+    else if ((0, clearing_1.isCls)(val, Object)) {
+        // Consider using hashes to display scrubbed values? (Makes them correlatable!)
+        const result = {};
+        seen.set(val, result);
+        for (const [k, v] of val)
+            result[k] = isScrub(k, v) ? doScrub(v) : scrubbed(v, { isScrub, doScrub, seen });
+        return result;
+    }
+    else if ((0, clearing_1.inCls)(val[limn], Function)) {
+        return scrubbed(val[limn](), { isScrub, doScrub, seen });
+    }
+    else {
+        // Consider processing for other types (sets, maps?)
+        return val;
+    }
+};
+class Logger {
+    static dummy = {
+        getTraceId() { return ''; },
+        log() { },
+        kid() { return Logger.dummy; },
+        scope(...args) { return args.at(-1)(Logger.dummy); }
+    };
+    format(v /* should not have cycles */, seen = new Map()) {
+        // Formats any value into json (so that it can be logged)
+        if (v == null)
+            return null;
+        if ((0, clearing_1.isCls)(v, Boolean))
+            return v;
+        if ((0, clearing_1.isCls)(v, Number))
+            return v;
+        if ((0, clearing_1.isCls)(v, String))
+            return v.length > this.opts.maxStrLen ? v.slice(0, this.opts.maxStrLen - 1) + '\u2026' : v;
+        if (seen.has(v))
+            return `<cyc> ${(0, clearing_1.getClsName)(v)}(...)`;
+        if ((0, clearing_1.inCls)(v[limn], Function)) {
+            const formatted = {};
+            seen.set(v, formatted);
+            Object.assign(formatted, this.format(v[limn](), seen));
+            return formatted;
+        }
+        if ((0, clearing_1.isCls)(v, Array)) {
+            const arr = [];
+            seen.set(v, arr);
+            for (const vv of v)
+                arr.push(this.format(vv, seen));
+            return arr;
+        }
+        if ((0, clearing_1.isCls)(v, Object)) {
+            const obj = {};
+            seen.set(v, obj);
+            for (const k in v)
+                obj[k] = this.format(v[k], seen);
+            return obj;
+        }
+        return `${(0, clearing_1.getClsName)(v)}(...)`;
+    }
+    ;
+    domain;
+    ctx;
+    write;
+    opts;
+    constructor(domain, ctx = {}, opts, write) {
+        this.domain = domain;
+        this.ctx = {
+            ...ctx,
+            $: this.domain,
+            [this.domain.split('.').at(-1)]: Math.random().toString(36).slice(2, 12)[padTail](10, '0'),
+        };
+        this.opts = opts ?? { maxStrLen: 250 };
+        // Note this default `this.write` function produces truncated values (sloppy outputting) in the
+        // cli, but works perfectly for lambdas with json-style logging configured!
+        this.write = write ?? ((val) => console.log(val));
+    }
+    getDomain() { return this.domain; }
+    getTraceId(term) {
+        const traceId = this.ctx[term];
+        if (!traceId)
+            throw Error('trace term invalid')[mod]({ term, ctx: this.ctx });
+        return traceId;
+    }
+    log(data) {
+        // Use-cases:
+        // 1. logger.log('a basic string')
+        //    - The logged payload is converted to `{ msg: 'a basic string' }`
+        // 2. logger.log({ msg: 'a basic string' })
+        //    - Logged as-is; equivalent to #1
+        // 3. logger.log({ $$: 'note', msg: 'a basic string' })
+        //    - Same as #1 and #2, but logger domain has "note" appended to it
+        // 4. logger.log({ $$: 'noteOnly' })
+        //    - Logged payload will be `{}`; only info is the tag - useful for infinitesimal moments in
+        //      the flamegraph!
+        // 5. logger.log({ $$: 'context.noteOnly' })
+        //    - Valid way to extend domain with more than 1 component at once!
+        let dmn = null;
+        if (data && (0, clearing_1.isCls)(data?.$$, String))
+            ({ $$: dmn, ...data } = data);
+        const domain = dmn ? [this.domain, dmn].join('.') : this.domain;
+        if (!(0, clearing_1.isCls)(data, Object))
+            data = { msg: data };
+        this.write({}[merge]({ $: this.ctx })[merge](scrubbed(this.format(data)))[merge]({ $: { $: domain } }));
+    }
+    kid(domain) {
+        const d = [this.domain, domain].filter(Boolean).join('.');
+        const logger = new Logger(d, this.ctx, this.opts, this.write);
+        return logger;
+    }
+    scope(domain, ctx, fn) {
+        const ms = Date.now();
+        const logger = this.kid(domain);
+        logger.log({ $$: 'launch', ...ctx });
+        const accept = val => { logger.log({ $$: 'accept', ms: Date.now() - ms }); return val; };
+        const glitch = err => { logger.log({ $$: err.log?.term ?? 'glitch', ms: Date.now() - ms, err }); throw err; }; // Always throws an error! Note allowing the consumer to override the logged term/domain offers a lot of flexibility!
+        let v;
+        try {
+            v = fn(logger);
+        }
+        catch (err) {
+            glitch(err);
+        }
+        return (0, clearing_1.isCls)(v, Promise)
+            ? v.then(accept, glitch)
+            : accept(v);
+    }
+}
+exports.default = Logger;
+;

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

@@ -0,0 +1,2 @@
+declare const normalize: (val: any, seen?: Set<any>) => any;
+export default normalize;

package/cmp/cjs/util/normalize.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clearing_1 = require("@gershy/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)));
+    // Handles terminations
+    if ((0, clearing_1.isCls)(val, String))
+        return val;
+    if ((0, clearing_1.isCls)(val, Number))
+        return val;
+    if (val === null)
+        return null;
+    if (val === undefined)
+        return null;
+    if (seen.has(val))
+        return '<<!circ!>>';
+    seen.add(val);
+    if ((0, clearing_1.isCls)(val, Array))
+        return val[map](v => normalize(v, seen));
+    if ((0, clearing_1.isCls)(val, Object))
+        return normalize(Object.entries(val).sort((e0, e1) => e0[0] < e1[0] ? -1 : 1), seen);
+    return normalize({ $form: (0, clearing_1.getClsName)(val), ...val }, seen);
+};
+exports.default = normalize;

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

@@ -0,0 +1,8 @@
+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;
+    output: string;
+}>;
+export default _default;

package/cmp/cjs/util/procTerraform.js

@@ -0,0 +1,31 @@
+"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"));
+exports.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);
+        const term = `${cmd.split(' ')[1]}-${yr}${mo}${dy}-${hr}${mn}${sc}`;
+        const logDb = fact.kid(['.terraform.log', `${term}.txt`]);
+        await logDb.setData(result);
+        return logDb;
+    };
+    return (0, util_nodejs_proc_1.default)(cmd, {
+        timeoutMs: 0,
+        ...opts,
+        cwd: fact,
+        env: { TF_DATA_DIR: '' }
+    }).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]({
+            logDb,
+            ...(err.output ? { output: err.output.split('\n').slice(-numTailingTfLogLines).join('\n') } : { cause: err })
+        });
+    });
+};

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

@@ -0,0 +1,2 @@
+declare const _default: (str: string, escapeChars: string) => string;
+export default _default;

package/cmp/cjs/util/slashEscape.js

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

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

@@ -0,0 +1,2 @@
+declare const _default: (val: string) => Lowercase<string>;
+export default _default;

package/cmp/cjs/util/snakeCase.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (val) => val.replace(/([A-Z])/g, '_$1')[lower]();

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

@@ -0,0 +1,2 @@
+export declare const embed: (v: string) => string;
+export declare const json: (v: Json) => string;

package/cmp/cjs/util/terraform.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = exports.embed = void 0;
+const embed = (v) => '${' + v + '}';
+exports.embed = embed;
+const json = (v) => [
+    '| <<EOF',
+    JSON.stringify(v, null, 2)[indent](2),
+    'EOF'
+].join('\n');
+exports.json = json;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,11 @@
+"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/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';