@gershy/lilac 0.0.1

package/cmp/mjs/main.js

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

package/cmp/mjs/package.json

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

package/cmp/mjs/petal/petal.d.ts

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

package/cmp/mjs/petal/petal.js

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

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

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

package/cmp/mjs/petal/terraform/terraform.js

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

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

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

package/cmp/mjs/util/aws.js

@@ -0,0 +1,54 @@
+import { isCls } from '@gershy/clearing';
+import capitalize from "./capitalize.js";
+export const capitalKeys = (v) => {
+    if (isCls(v, Array))
+        return v[map](v => capitalKeys(v));
+    if (isCls(v, Object))
+        return v[mapk]((val, key) => [capitalize(key), capitalKeys(val)]);
+    return v;
+};
+export const 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/mjs/util/awsTerraform.d.ts

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

package/cmp/mjs/util/awsTerraform.js

@@ -0,0 +1,5 @@
+export const provider = (defaultAwsRegion, targetAwsRegion) => {
+    return defaultAwsRegion !== targetAwsRegion
+        ? { $provider: `aws.${targetAwsRegion.split('-').join('_')}` }
+        : {};
+};

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

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

package/cmp/mjs/util/capitalize.js

@@ -0,0 +1,10 @@
+import { isCls } from '@gershy/clearing';
+const capitalize = (v) => {
+    // capitalize('hello')                       -> "Hello"
+    // capitalize('heLLo')                       -> "HeLLo"
+    // capitalize([ 'my', 'name', 'is', 'bOb' ]) -> "myNameIsBOb"
+    if (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('');
+};
+export default capitalize;

package/cmp/mjs/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/mjs/util/hash.js

@@ -0,0 +1,12 @@
+import { createHash } from 'node:crypto';
+import { isCls } from '@gershy/clearing';
+export default (str, targetBase = String[base62]) => {
+    // Consider moving this under the "node" directory - relies on "node:crypto'
+    if (isCls(str, String) || isCls(str, Buffer))
+        str = [str];
+    const hash = createHash('sha256');
+    for (const val of str)
+        hash.update(val);
+    return hash
+        .digest('base64url')[toNum](String[base64Url])[toStr](targetBase);
+};