@firestartr/cli 0.1.0

package/build/provisioner/dist-cdktf/src/resources/github_feature/preprocessor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+async function create(resource) {
+    // it has files?
+    for (const file of resource.get("main_artifact").spec.files) {
+        await onFileCreation(resource, file);
+    }
+}
+exports.create = create;
+function onFileCreation(resource, file) {
+    if (file.userManaged) {
+        // d
+        // status
+        //  FAILED
+        //  reason:
+    }
+}

package/build/provisioner/dist-cdktf/src/resources/github_group/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from "../resource";
+export declare class FirestartrGithubGroup extends Resource {
+    static kind(): string;
+    preprocess(): Promise<void>;
+}

package/build/provisioner/dist-cdktf/src/resources/github_group/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestartrGithubGroup = void 0;
+const resource_1 = require("../resource");
+const debug_1 = __importDefault(require("debug"));
+const log = (0, debug_1.default)('firestartr:provisioner:github_group');
+class FirestartrGithubGroup extends resource_1.Resource {
+    static kind() {
+        return 'FirestartrGithubGroup';
+    }
+    async preprocess() {
+        switch (this.get('operation')) {
+            case "CREATE":
+                log("CREATE");
+                break;
+            case "UPDATE":
+                log("UPDATED");
+                break;
+            case "DELETE":
+                log("DELETED");
+                break;
+            case "IMPORT":
+                log("IMPORT");
+                break;
+            case "IMPORT_SKIP_PLAN":
+                log("IMPORT_SKIP_PLAN");
+                break;
+            default:
+                log("UNKNOWN");
+        }
+    }
+}
+exports.FirestartrGithubGroup = FirestartrGithubGroup;

package/build/provisioner/dist-cdktf/src/resources/github_membership/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from "../resource";
+export declare class FirestartrGithubMembership extends Resource {
+    static kind(): string;
+    preprocess(): Promise<void>;
+}

package/build/provisioner/dist-cdktf/src/resources/github_membership/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestartrGithubMembership = void 0;
+const resource_1 = require("../resource");
+const debug_1 = __importDefault(require("debug"));
+const log = (0, debug_1.default)('firestartr:provisioner:github_membership');
+class FirestartrGithubMembership extends resource_1.Resource {
+    static kind() {
+        return 'FirestartrGithubMembership';
+    }
+    async preprocess() {
+        switch (this.get('operation')) {
+            case "CREATE":
+                log("CREATE");
+                break;
+            case "UPDATE":
+                log("UPDATED");
+                break;
+            case "DELETE":
+                log("DELETED");
+                break;
+            case "IMPORT":
+                log("IMPORT");
+                break;
+            case "IMPORT_SKIP_PLAN":
+                log("IMPORT_SKIP_PLAN");
+                break;
+            default:
+                log("UNKNOWN");
+        }
+    }
+}
+exports.FirestartrGithubMembership = FirestartrGithubMembership;

package/build/provisioner/dist-cdktf/src/resources/github_repository/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from "../resource";
+export declare class FirestartrGithubRepository extends Resource {
+    static kind(): string;
+    preprocess(): Promise<void>;
+}

package/build/provisioner/dist-cdktf/src/resources/github_repository/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestartrGithubRepository = void 0;
+const resource_1 = require("../resource");
+const debug_1 = __importDefault(require("debug"));
+const log = (0, debug_1.default)('firestartr:provisioner:github_repository');
+class FirestartrGithubRepository extends resource_1.Resource {
+    static kind() {
+        return 'FirestartrGithubRepository';
+    }
+    async preprocess() {
+        switch (this.get('operation')) {
+            case "CREATE":
+                log("CREATE");
+                break;
+            case "UPDATE":
+                log("UPDATED");
+                break;
+            case "DELETE":
+                log("DELETED");
+                break;
+            case "IMPORT":
+                log("IMPORT");
+                break;
+            case "IMPORT_SKIP_PLAN":
+                log("IMPORT_SKIP_PLAN");
+                break;
+            default:
+                log("UNKNOWN");
+        }
+    }
+}
+exports.FirestartrGithubRepository = FirestartrGithubRepository;

package/build/provisioner/dist-cdktf/src/resources/index.d.ts

@@ -0,0 +1,13 @@
+import { FirestartrGithubRepositoryFeature } from './github_feature';
+import { FirestartrGithubRepository } from './github_repository';
+import { FirestartrGithubMembership } from './github_membership';
+import { FirestartrGithubGroup } from './github_group';
+import { FirestartrTerraformModule } from './terraform_module';
+declare const _default: {
+    FirestartrGithubRepositoryFeature: typeof FirestartrGithubRepositoryFeature;
+    FirestartrGithubRepository: typeof FirestartrGithubRepository;
+    FirestartrGithubMembership: typeof FirestartrGithubMembership;
+    FirestartrGithubGroup: typeof FirestartrGithubGroup;
+    FirestartrTerraformModule: typeof FirestartrTerraformModule;
+};
+export default _default;

package/build/provisioner/dist-cdktf/src/resources/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const github_feature_1 = require("./github_feature");
+const github_repository_1 = require("./github_repository");
+const github_membership_1 = require("./github_membership");
+const github_group_1 = require("./github_group");
+const terraform_module_1 = require("./terraform_module");
+exports.default = {
+    FirestartrGithubRepositoryFeature: github_feature_1.FirestartrGithubRepositoryFeature,
+    FirestartrGithubRepository: github_repository_1.FirestartrGithubRepository,
+    FirestartrGithubMembership: github_membership_1.FirestartrGithubMembership,
+    FirestartrGithubGroup: github_group_1.FirestartrGithubGroup,
+    FirestartrTerraformModule: terraform_module_1.FirestartrTerraformModule,
+};

package/build/provisioner/dist-cdktf/src/resources/resource.d.ts

@@ -0,0 +1,17 @@
+export declare class Resource {
+    data: any;
+    output: string;
+    logFn: Function;
+    setLogger(fn: Function): void;
+    constructor(mainCR: any, operation: string, deps?: any[]);
+    run(): Promise<void>;
+    artifact(): any;
+    synth(): Promise<void>;
+    log(msg: string): void;
+    runTerraform(): Promise<void>;
+    preprocess(): Promise<void>;
+    crs(): void;
+    env(): void;
+    set(k: string, v: any): void;
+    get(k: string): any;
+}

package/build/provisioner/dist-cdktf/src/resources/resource.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = void 0;
+const cdktf_1 = require("../cdktf");
+const terraform_1 = require("../terraform");
+class Resource {
+    data = {};
+    output = '';
+    logFn = (msg) => console.log(msg);
+    setLogger(fn) {
+        this.logFn = fn;
+    }
+    constructor(mainCR, operation, deps = []) {
+        this.set('main_artifact', mainCR);
+        this.set('operation', operation);
+        this.set('deps', deps);
+    }
+    async run() {
+        try {
+            await this.preprocess();
+            await this.synth();
+            await this.runTerraform();
+        }
+        catch (err) {
+            throw `error: ${JSON.stringify(err, null, 4)}`;
+        }
+    }
+    artifact() {
+        return this.get('main_artifact');
+    }
+    async synth() {
+        const isImport = this.get('operation') === 'IMPORT' || this.get('operation') === 'IMPORT_SKIP_PLAN';
+        await (0, cdktf_1.runCDKTF)(this.get('main_artifact'), "synth", this.get('deps'), isImport);
+    }
+    log(msg) {
+        this.logFn(msg);
+    }
+    async runTerraform() {
+        let output = '';
+        output += await (0, terraform_1.terraformInit)(this.get('main_artifact'));
+        output += await (0, terraform_1.terraformPlan)(this.get('main_artifact'));
+        if (this.get('operation') === 'CREATE' || this.get('operation') === 'UPDATE') {
+            output += await (0, terraform_1.terraformApply)(this.get('main_artifact'), false, true);
+        }
+        else if (this.get('operation') === 'DELETE') {
+            output += await (0, terraform_1.terraformDestroy)(this.get('main_artifact'));
+        }
+        else if (this.get('operation') === 'IMPORT') {
+            output += await (0, terraform_1.terraformApply)(this.get('main_artifact'), true, false);
+        }
+        else if (this.get('operation') === 'IMPORT_SKIP_PLAN') {
+            output += await (0, terraform_1.terraformApply)(this.get('main_artifact'), true, true);
+        }
+        else {
+            throw new Error(`unknown operation: ${this.get('operation')}`);
+        }
+        this.set('output', output);
+    }
+    async preprocess() { }
+    crs() { }
+    env() { }
+    set(k, v) {
+        this.data[k] = v;
+    }
+    get(k) {
+        return this.data[k];
+    }
+}
+exports.Resource = Resource;

package/build/provisioner/dist-cdktf/src/resources/terraform_module/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from "../resource";
+export declare class FirestartrTerraformModule extends Resource {
+    static kind(): string;
+    preprocess(): Promise<void>;
+}

package/build/provisioner/dist-cdktf/src/resources/terraform_module/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestartrTerraformModule = void 0;
+const resource_1 = require("../resource");
+const debug_1 = __importDefault(require("debug"));
+const log = (0, debug_1.default)('firestartr:provisioner:terraform_module');
+class FirestartrTerraformModule extends resource_1.Resource {
+    static kind() {
+        return 'FirestartrTerraformModule';
+    }
+    async preprocess() {
+        const operation = this.get('operation');
+        log(operation);
+        switch (operation) {
+            case "CREATE":
+                break;
+            case "UPDATE":
+                break;
+            case "DELETE":
+                break;
+            case "IMPORT":
+                break;
+            case "IMPORT_SKIP_PLAN":
+                break;
+            default:
+                break;
+        }
+    }
+}
+exports.FirestartrTerraformModule = FirestartrTerraformModule;

package/build/provisioner/dist-cdktf/src/stacks/GithubStack.d.ts

@@ -0,0 +1,6 @@
+import { TerraformProvider } from 'cdktf';
+import { BaseStack } from './base';
+export declare class GithubStack extends BaseStack {
+    provisionEntity(isImport: boolean, entity: any, deps: any, tfStatePath: string, orgConfig: any): Promise<void>;
+    initProviders(scope: any, tfStatePath: string, backendConfig: any, providerConfig: any, deps: any): TerraformProvider;
+}

package/build/provisioner/dist-cdktf/src/stacks/GithubStack.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubStack = void 0;
+const provider_1 = require("@cdktf/provider-github/lib/provider");
+const entities_1 = require("../entities");
+const debug_1 = __importDefault(require("debug"));
+const base_1 = require("./base");
+const catalog_common_1 = __importDefault(require("catalog_common"));
+const providers_1 = require("../providers");
+const messageLog = (0, debug_1.default)('firestartr:provisioner:stacks:githubstack');
+class GithubStack extends base_1.BaseStack {
+    async provisionEntity(isImport, entity, deps, tfStatePath, orgConfig) {
+        try {
+            const { backendConfig, providerConfig } = this.getRefContextConfigs(entity, deps);
+            this.initProviders(this, tfStatePath, backendConfig, providerConfig, deps);
+            const instance = (0, entities_1.getEntityInstance)(entity, deps);
+            await instance.provision({ scope: this });
+            if (isImport) {
+                instance.importResources();
+            }
+        }
+        catch (err) {
+            messageLog("Error: provisionEntity: %s", err);
+            throw err;
+        }
+    }
+    initProviders(scope, tfStatePath, backendConfig, providerConfig, deps) {
+        if (providerConfig.spec.type != providers_1.FirestartrTerraformProvider.GITHUB)
+            throw `Provider type ${providerConfig.spec.type} is not supported`;
+        const backendSecrets = this.getRefContextFromCr(backendConfig, deps);
+        const providerSecrets = this.getRefContextFromCr(providerConfig, deps);
+        const backendConfigData = this.replaceConfigSecrets(JSON.parse(backendConfig.spec.config), backendSecrets);
+        const providerConfigData = this.replaceConfigSecrets(JSON.parse(providerConfig.spec.config), providerSecrets);
+        (0, providers_1.createBackend)(scope, backendConfig.spec.type, tfStatePath, backendConfigData);
+        return new provider_1.GithubProvider(scope, tfStatePath, catalog_common_1.default.generic.transformKeysToCamelCase(providerConfigData));
+    }
+}
+exports.GithubStack = GithubStack;

package/build/provisioner/dist-cdktf/src/stacks/TerraformModuleStack.d.ts

@@ -0,0 +1,7 @@
+import { FirestartrTerraformModuleEntity } from "../entities/firestartrterraformmodule/FirestartrTerraformModule";
+import { BaseStack } from "./base";
+import { TerraformProvider } from "cdktf";
+export declare class TerraformModuleStack extends BaseStack {
+    provisionEntity(isImport: boolean, entity: FirestartrTerraformModuleEntity, deps: any, tfStatePath: string, orgConfig: any): Promise<void>;
+    initProviders(scope: BaseStack, name: string, tfStatePath: string, backendConfig: any, providerConfig: any, deps: any): TerraformProvider;
+}

package/build/provisioner/dist-cdktf/src/stacks/TerraformModuleStack.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformModuleStack = void 0;
+const debug_1 = __importDefault(require("debug"));
+const FirestartrTerraformModule_1 = require("../entities/firestartrterraformmodule/FirestartrTerraformModule");
+const base_1 = require("./base");
+const providers_1 = require("../providers");
+const messageLog = (0, debug_1.default)("firestartr:provisioner:stacks:terraformmodulestack");
+class TerraformModuleStack extends base_1.BaseStack {
+    async provisionEntity(isImport, entity, deps, tfStatePath, orgConfig) {
+        try {
+            const { backendConfig, providerConfig } = this.getRefContextConfigs(entity, deps);
+            const provider = this.initProviders(this, entity.metadata.name, tfStatePath, backendConfig, providerConfig, deps);
+            const instance = new FirestartrTerraformModule_1.FirestartrTerraformModuleEntity(entity, provider, deps);
+            await instance.provision({ scope: this });
+            if (isImport) {
+                instance.importResources();
+            }
+        }
+        catch (err) {
+            messageLog("Error: provisionEntity: %s", err);
+            throw err;
+        }
+    }
+    initProviders(scope, name, tfStatePath, backendConfig, providerConfig, deps) {
+        const backendSecrets = this.getRefContextFromCr(backendConfig, deps);
+        const providerSecrets = this.getRefContextFromCr(providerConfig, deps);
+        const backendConfigData = this.replaceConfigSecrets(JSON.parse(backendConfig.spec.config), backendSecrets);
+        const providerConfigData = this.replaceConfigSecrets(JSON.parse(providerConfig.spec.config), providerSecrets);
+        (0, providers_1.createBackend)(scope, backendConfig.spec.type, tfStatePath, backendConfigData);
+        return (0, providers_1.createProvider)(scope, providerConfig.spec.type, name, providerConfigData);
+    }
+}
+exports.TerraformModuleStack = TerraformModuleStack;

package/build/provisioner/dist-cdktf/src/stacks/base.d.ts

@@ -0,0 +1,17 @@
+import { TerraformProvider, TerraformStack } from "cdktf";
+export declare class SecretNotFound extends Error {
+    constructor(secretName: string);
+}
+export declare class SecretKeyNotFound extends Error {
+    constructor(secretName: string, keyName: string);
+}
+export declare abstract class BaseStack extends TerraformStack {
+    abstract provisionEntity(isImport: boolean, entity: any, deps: any, tfStatePath: string, orgConfig: any): Promise<void>;
+    abstract initProviders(scope: any, name: string, tfStatePath: string, backend: any, provider: any, deps: any): TerraformProvider;
+    protected getRefContextConfigs(entity: any, deps: any): {
+        backendConfig: any;
+        providerConfig: any;
+    };
+    protected getRefContextFromCr(cr: any, deps: any): any;
+    protected replaceConfigSecrets(config: any, secrets: any): any;
+}

package/build/provisioner/dist-cdktf/src/stacks/base.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStack = exports.SecretKeyNotFound = exports.SecretNotFound = void 0;
+const cdktf_1 = require("cdktf");
+class SecretNotFound extends Error {
+    constructor(secretName) {
+        super(`Secret ${secretName} not found`);
+        this.name = "SecretNotFound";
+    }
+}
+exports.SecretNotFound = SecretNotFound;
+class SecretKeyNotFound extends Error {
+    constructor(secretName, keyName) {
+        super(`Secret ${secretName} does not have key ${keyName}`);
+        this.name = "SecretKeyNotFound";
+    }
+}
+exports.SecretKeyNotFound = SecretKeyNotFound;
+class BaseStack extends cdktf_1.TerraformStack {
+    getRefContextConfigs(entity, deps) {
+        const backendRef = entity.spec.context.backend.ref;
+        if (deps[`${backendRef.kind}-${backendRef.name}`] === undefined)
+            console.error(`Could not find backend ${backendRef.kind}-${backendRef.name}`);
+        const backendConfig = deps[`${backendRef.kind}-${backendRef.name}`].cr;
+        const providerRef = entity.spec.context.provider.ref;
+        if (deps[`${providerRef.kind}-${providerRef.name}`] === undefined)
+            console.error(`Could not find provider ${providerRef.kind}-${providerRef.name}`);
+        const providerConfig = deps[`${providerRef.kind}-${providerRef.name}`].cr;
+        return {
+            backendConfig,
+            providerConfig
+        };
+    }
+    getRefContextFromCr(cr, deps) {
+        const secrets = {};
+        // check first there are any secrets to resolve
+        if (cr.spec.secrets === undefined)
+            return secrets;
+        for (const i of Object.entries(cr.spec.secrets)) {
+            const [objectKey, value] = i;
+            const { key, name } = value.secretRef;
+            const secretDepKeyName = `Secret-${name}`;
+            const secret = deps[secretDepKeyName];
+            if (secret.cr.data[key] === undefined)
+                throw new SecretKeyNotFound(name, key);
+            secrets[objectKey] = Buffer.from(secret.cr.data[key], 'base64');
+        }
+        return secrets;
+    }
+    replaceConfigSecrets(config, secrets) {
+        for (let key in config) {
+            if (typeof config[key] === 'object' && config[key] !== null) {
+                // If the property is an object, call this function recursively
+                this.replaceConfigSecrets(config[key], secrets);
+            }
+            else if (typeof config[key] === 'string') {
+                // If the property is a string and its value is equal to secrets.something,
+                // replace the value with the value of the 'something' key in the secrets object
+                config[key] = config[key].replace(/\$\{\{ secrets\.(.*?) \}\}/g, function (_, group1) {
+                    if (!secrets[group1]) {
+                        throw new SecretNotFound(group1);
+                    }
+                    return secrets[group1];
+                });
+            }
+        }
+        return config;
+    }
+}
+exports.BaseStack = BaseStack;

package/build/provisioner/dist-cdktf/src/stacks/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseStack } from "./base";
+import { Construct } from "constructs";
+export declare class StackNotFoundError extends Error {
+    constructor(kind: string);
+}
+export declare function getStackByEntity(entity: any): new (app: Construct, tfStatePath: string) => BaseStack;

package/build/provisioner/dist-cdktf/src/stacks/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackByEntity = exports.StackNotFoundError = void 0;
+const GithubStack_1 = require("./GithubStack");
+const TerraformModuleStack_1 = require("./TerraformModuleStack");
+class StackNotFoundError extends Error {
+    constructor(kind) {
+        super(`Stack not found for kind ${kind}`);
+        this.name = 'StackNotFoundError';
+    }
+}
+exports.StackNotFoundError = StackNotFoundError;
+function getStackByEntity(entity) {
+    switch (entity.kind) {
+        case 'FirestartrGithubRepository':
+        case 'FirestartrGithubGroup':
+        case 'FirestartrGithubMembership':
+        case 'FirestartrGithubRepositoryFeature':
+            return GithubStack_1.GithubStack;
+        case 'FirestartrTerraformModule':
+            return TerraformModuleStack_1.TerraformModuleStack;
+        default:
+            throw new StackNotFoundError(entity.kind);
+    }
+}
+exports.getStackByEntity = getStackByEntity;

package/build/provisioner/dist-cdktf/src/terraform.d.ts

@@ -0,0 +1,5 @@
+export declare function runTerraform(entity: any, command: Array<string>): Promise<unknown>;
+export declare function terraformInit(entity: any): Promise<unknown>;
+export declare function terraformPlan(entity: any): Promise<unknown>;
+export declare function terraformApply(entity: any, isImport?: boolean, skipPlan?: boolean): Promise<unknown>;
+export declare function terraformDestroy(entity: any): Promise<unknown>;