terrafaker 0.0.0 → 0.0.1

package/dist/utilities/generators/azure-generator.js

@@ -0,0 +1,46 @@
+import { AWS_INSTANCE_TYPES } from "../../constants/aws.js";
+import { AZURE_LAMBDA_RUNTIMES, AZURE_REGIONS } from "../../constants/azure.js";
+import { randomEnvironmentTag, randomItem, randomMemorableSlug, randomMemorySize, randomServiceTag, } from "./generator-utils.js";
+import { ProviderGenerator } from "./provider-generator.js";
+const AzureResourceType = {
+    ComputeInstance: "azurerm_linux_virtual_machine",
+    LambdaFunction: "azurerm_linux_function_app",
+};
+class AzureGenerator extends ProviderGenerator {
+    addProvider() {
+        const region = randomItem(AZURE_REGIONS);
+        this.tfg.provider("azurerm", { region });
+    }
+    addComputeInstance() {
+        const name = randomMemorableSlug();
+        const environment = randomEnvironmentTag();
+        const service = randomServiceTag();
+        const instanceType = randomItem(AWS_INSTANCE_TYPES);
+        this.tfg.resource(AzureResourceType.ComputeInstance, name, {
+            size: instanceType,
+            tags: { name, environment, service },
+        });
+        return this;
+    }
+    addLambdaFunction() {
+        const name = randomMemorableSlug();
+        const environment = randomEnvironmentTag();
+        const service = randomServiceTag();
+        const runtime = randomItem(AZURE_LAMBDA_RUNTIMES);
+        // There's a lot of different configurations listed, so just guessing here.
+        // https://learn.microsoft.com/en-us/azure/azure-functions/functions-scale
+        const instanceMemoryInMb = randomMemorySize({
+            min: 128,
+            max: 4 * 1024,
+            step: 128,
+        });
+        this.tfg.resource(AzureResourceType.LambdaFunction, name, {
+            ...runtime,
+            name,
+            instance_memory_in_mb: instanceMemoryInMb,
+            labels: { name, environment, service },
+        });
+        return this;
+    }
+}
+export { AzureGenerator };

package/dist/utilities/generators/file-generator.d.ts

@@ -0,0 +1,12 @@
+import { type Provider } from "../../enums/providers.js";
+interface GenerateOptions {
+    provider?: Provider;
+    directory?: string;
+    fileName?: string;
+    format?: boolean;
+    resourceCount?: number;
+}
+declare class FileGenerator {
+    static generate(options: GenerateOptions): void;
+}
+export { FileGenerator };

package/dist/utilities/generators/file-generator.js

@@ -0,0 +1,13 @@
+import { randomProvider } from "./generator-utils.js";
+import { ProviderGeneratorFactory } from "./provider-generator-factory.js";
+class FileGenerator {
+    static generate(options) {
+        const { provider = randomProvider(), resourceCount = 3, fileName, directory, format, } = options;
+        const generator = ProviderGeneratorFactory.get(provider);
+        for (let i = 0; i < resourceCount; i++) {
+            generator.addRandomResource();
+        }
+        generator.writeToFile({ fileName, directory, format });
+    }
+}
+export { FileGenerator };

package/dist/utilities/generators/gcp-generator.d.ts

@@ -0,0 +1,7 @@
+import { ProviderGenerator } from "./provider-generator.js";
+declare class GcpGenerator extends ProviderGenerator {
+    addProvider(): void;
+    addComputeInstance(): this;
+    addLambdaFunction(): this;
+}
+export { GcpGenerator };

package/dist/utilities/generators/gcp-generator.js

@@ -0,0 +1,53 @@
+import { GCP_GPU_MACHINE_TYPES, GCP_INSTANCE_TYPES, GCP_LAMBDA_RUNTIMES, GCP_REGIONS, } from "../../constants/gcp.js";
+import { maybe, randomEnvironmentTag, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomServiceTag, } from "./generator-utils.js";
+import { ProviderGenerator } from "./provider-generator.js";
+const GcpResourceType = {
+    ComputeInstance: "google_compute_instance",
+    LambdaFunction: "google_cloudfunctions_function",
+};
+class GcpGenerator extends ProviderGenerator {
+    addProvider() {
+        const region = randomItem(GCP_REGIONS);
+        this.tfg.provider("google", { region });
+    }
+    addComputeInstance() {
+        const name = randomMemorableSlug();
+        const environment = randomEnvironmentTag();
+        const service = randomServiceTag();
+        const machineType = randomItem(GCP_INSTANCE_TYPES);
+        const guestAccelerator = maybe(0.5)
+            ? {
+                guest_accelerator: {
+                    type: randomItem(GCP_GPU_MACHINE_TYPES),
+                    count: randomInt({ min: 1, max: 4 }),
+                },
+            }
+            : {};
+        this.tfg.resource(GcpResourceType.ComputeInstance, name, {
+            machine_type: machineType,
+            ...guestAccelerator,
+            labels: { name, environment, service },
+        });
+        return this;
+    }
+    addLambdaFunction() {
+        const name = randomMemorableSlug();
+        const environment = randomEnvironmentTag();
+        const service = randomServiceTag();
+        const runtime = randomItem(GCP_LAMBDA_RUNTIMES);
+        // @see https://docs.cloud.google.com/run/docs/configuring/services/memory-limits
+        const availableMemoryMb = randomMemorySize({
+            min: 128,
+            max: 32 * 1024,
+            step: 128,
+        });
+        this.tfg.resource(GcpResourceType.LambdaFunction, name, {
+            runtime,
+            name,
+            available_memory_mb: availableMemoryMb,
+            labels: { name, environment, service },
+        });
+        return this;
+    }
+}
+export { GcpGenerator };

package/dist/utilities/generators/generator-utils.d.ts

@@ -1,22 +1,11 @@
-import type { TerraformGenerator } from "terraform-generator";
-import type { Provider } from "../../enums/providers.js";
 type StringGenerator = () => string;
-interface ResourceGeneratorOptions {
-    tfg: TerraformGenerator;
-    environment?: string;
-    service?: string;
-}
-interface FileGeneratorOptions {
-    resourceCount?: number;
-    environment?: string;
-}
 /**
  * Wraps a generator function to ensure the values it returns are not reused within the program runtime
  */
 declare function unique(generator: StringGenerator): StringGenerator;
 declare const randomMemorableSlug: StringGenerator;
 declare const randomItem: <T>(values: T[]) => T;
-declare const randomProvider: () => "aws" | "gcp";
+declare const randomProvider: () => "aws" | "gcp" | "azure";
 declare const randomId: StringGenerator;
 declare const randomEnvironmentTag: () => string;
 declare const randomServiceTag: () => string;
@@ -33,48 +22,4 @@ declare const randomInt: (options: RandomIntOptions) => number;
  * Returns true/false depending on the provided probability (0 to 1)
  */
 declare const maybe: (probability: number) => boolean;
-interface GenerateFileByProviderOptions extends FileGeneratorOptions {
-    provider: Provider;
-}
-declare const generateFileByProvider: (options: GenerateFileByProviderOptions) => TerraformGenerator;
-interface GenerateRepoOptions {
-    /**
-     * Provider to generate a terraform file for.
-     */
-    provider: Provider;
-    /**
-     * Environment to use for tags, etc.
-     */
-    environment?: string;
-    /**
-     * Whether the terraform files should be formatted. Requires `terraform` to be installed.
-     */
-    format: boolean;
-    /**
-     * Prefix for the repo
-     */
-    prefix: string;
-    /**
-     * Directory to generate the repo in
-     */
-    directory: string;
-    /**
-     * Number of files to generate
-     */
-    fileCount: number;
-    /**
-     * Number of resources per file to generate
-     */
-    resourceCount: number;
-    /**
-     * Whether output from the commands should be silenced
-     */
-    quiet?: boolean;
-}
-interface GenerateRepoResult {
-    name: string;
-    path: string;
-}
-declare const generateRepo: (options: GenerateRepoOptions) => Promise<GenerateRepoResult>;
-export type { FileGeneratorOptions, ResourceGeneratorOptions, StringGenerator };
-export { generateFileByProvider, generateRepo, maybe, randomEnvironmentTag, randomId, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomProvider, randomServiceTag, unique, };
+export { maybe, randomEnvironmentTag, randomId, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomProvider, randomServiceTag, unique, };

package/dist/utilities/generators/generator-utils.js

@@ -1,11 +1,6 @@
 import { faker } from "@faker-js/faker";
 import { snakeSlugify } from "../string-utils.js";
 import { ENVIRONMENT_TAGS, SERVICE_TAGS } from "../../constants/tags.js";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import { generateAwsFile } from "./aws-generators.js";
-import { $ } from "zx";
-import { generateGcpFile } from "./gcp-generators.js";
 import { Providers } from "../../enums/providers.js";
 import { range } from "lodash-es";
 /**
@@ -43,30 +38,4 @@ const randomInt = (options) => {
  * Returns true/false depending on the provided probability (0 to 1)
  */
 const maybe = (probability) => Math.random() < probability;
-const generateFileByProvider = (options) => {
-    const { provider, ...rest } = options;
-    switch (provider) {
-        case Providers.GCP:
-            return generateGcpFile(rest);
-        default:
-        case Providers.AWS:
-            return generateAwsFile(rest);
-    }
-};
-const generateRepo = async (options) => {
-    const { provider, format, prefix, fileCount, resourceCount, quiet } = options;
-    const directory = path.resolve(process.cwd(), options.directory);
-    const repoName = `${prefix}${randomMemorableSlug()}`;
-    const repoPath = path.join(directory, repoName);
-    const sh = $({ cwd: repoPath, stdio: quiet ? "ignore" : "inherit" });
-    await mkdir(repoPath);
-    await sh `git init`;
-    for (let i = 0; i < fileCount; i++) {
-        const tfFilename = `${randomMemorableSlug()}.tf`;
-        const tfg = generateFileByProvider({ provider, resourceCount });
-        tfg.write({ format, dir: repoPath, tfFilename });
-    }
-    await sh `git add . && git commit -m "initial commit"`;
-    return { name: repoName, path: repoPath };
-};
-export { generateFileByProvider, generateRepo, maybe, randomEnvironmentTag, randomId, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomProvider, randomServiceTag, unique, };
+export { maybe, randomEnvironmentTag, randomId, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomProvider, randomServiceTag, unique, };

package/dist/utilities/generators/provider-generator-factory.d.ts

@@ -0,0 +1,8 @@
+import type { Provider } from "../../enums/providers.js";
+import { AwsGenerator } from "./aws-generator.js";
+import { AzureGenerator } from "./azure-generator.js";
+import { GcpGenerator } from "./gcp-generator.js";
+declare class ProviderGeneratorFactory {
+    static get(provider: Provider): AwsGenerator | AzureGenerator | GcpGenerator;
+}
+export { ProviderGeneratorFactory };

package/dist/utilities/generators/provider-generator-factory.js

@@ -0,0 +1,18 @@
+import { Providers } from "../../enums/providers.js";
+import { AwsGenerator } from "./aws-generator.js";
+import { AzureGenerator } from "./azure-generator.js";
+import { GcpGenerator } from "./gcp-generator.js";
+class ProviderGeneratorFactory {
+    static get(provider) {
+        switch (provider) {
+            case Providers.Azure:
+                return new AzureGenerator();
+            case Providers.GCP:
+                return new GcpGenerator();
+            default:
+            case Providers.AWS:
+                return new AwsGenerator();
+        }
+    }
+}
+export { ProviderGeneratorFactory };

package/dist/utilities/generators/provider-generator.d.ts

@@ -0,0 +1,22 @@
+import { TerraformGenerator } from "terraform-generator";
+import type { ResourceType } from "../../enums/resource-types.js";
+interface WriteToFileOptions {
+    directory?: string;
+    fileName?: string;
+    format?: boolean;
+}
+declare abstract class ProviderGenerator {
+    readonly tfg: TerraformGenerator;
+    constructor();
+    /**
+     * Adds a block for the provider, and typically the region to be used.
+     * This is called automatically by the constructor, so it shouldn't need to be called manually.
+     */
+    abstract addProvider(): void;
+    abstract addComputeInstance(): this;
+    abstract addLambdaFunction(): this;
+    addResourceByType(type: ResourceType): this;
+    addRandomResource(): this;
+    writeToFile(options?: WriteToFileOptions): void;
+}
+export { ProviderGenerator };

package/dist/utilities/generators/provider-generator.js

@@ -0,0 +1,31 @@
+import { TerraformGenerator } from "terraform-generator";
+import { ResourceTypes } from "../../enums/resource-types.js";
+import { randomItem, randomMemorableSlug } from "./generator-utils.js";
+import { formatTfFileName } from "../string-utils.js";
+class ProviderGenerator {
+    tfg;
+    constructor() {
+        this.tfg = new TerraformGenerator();
+        this.addProvider();
+    }
+    addResourceByType(type) {
+        switch (type) {
+            case ResourceTypes.LambdaFunction:
+                return this.addLambdaFunction();
+            default:
+            case ResourceTypes.ComputeInstance: {
+                return this.addComputeInstance();
+            }
+        }
+    }
+    addRandomResource() {
+        const type = randomItem(Object.values(ResourceTypes));
+        return this.addResourceByType(type);
+    }
+    writeToFile(options) {
+        const { directory, format = true } = options ?? {};
+        const fileName = formatTfFileName(options?.fileName ?? randomMemorableSlug());
+        this.tfg.write({ format, dir: directory, tfFilename: fileName });
+    }
+}
+export { ProviderGenerator };

package/dist/utilities/generators/repo-generator.d.ts

@@ -0,0 +1,39 @@
+import type { Provider } from "../../enums/providers.js";
+interface GenerateOptions {
+    /**
+     * Provider to generate a terraform file for. If not provided, random providers will be used.
+     */
+    provider?: Provider;
+    /**
+     * Whether the terraform files should be formatted. Requires `terraform` to be installed.
+     */
+    format?: boolean;
+    /**
+     * Prefix for the repo
+     */
+    prefix?: string;
+    /**
+     * Directory to generate the repo in
+     */
+    directory?: string;
+    /**
+     * Number of files to generate
+     */
+    fileCount?: number;
+    /**
+     * Number of resources per file to generate
+     */
+    resourceCount?: number;
+    /**
+     * Whether output from the commands should be silenced
+     */
+    quiet?: boolean;
+}
+interface GenerateResult {
+    name: string;
+    path: string;
+}
+declare class RepoGenerator {
+    static generate(options: GenerateOptions): Promise<GenerateResult>;
+}
+export { RepoGenerator };

package/dist/utilities/generators/repo-generator.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { FileGenerator } from "./file-generator.js";
+import { randomMemorableSlug } from "./generator-utils.js";
+import { $ } from "zx";
+import { mkdir } from "node:fs/promises";
+import { success } from "../string-utils.js";
+class RepoGenerator {
+    static async generate(options) {
+        const { provider, prefix = "tf_", format, fileCount = 3, resourceCount, quiet, } = options;
+        const directory = path.resolve(process.cwd(), options.directory ?? ".");
+        const repoName = `${prefix}${randomMemorableSlug()}`;
+        const repoPath = path.join(directory, repoName);
+        const sh = $({ cwd: repoPath, stdio: quiet ? "ignore" : "inherit" });
+        await mkdir(repoPath);
+        await sh `git init`;
+        for (let i = 0; i < fileCount; i++) {
+            FileGenerator.generate({
+                directory: repoPath,
+                provider,
+                resourceCount,
+                format,
+            });
+        }
+        await sh `git add . && git commit -m "initial commit"`;
+        if (!quiet) {
+            console.log(success(`Successfully generated '${repoPath}'`));
+        }
+        return { name: repoName, path: repoPath };
+    }
+}
+export { RepoGenerator };

package/dist/utilities/string-utils.d.ts

@@ -2,4 +2,5 @@ declare const slugify: (value: string) => string;
 declare const snakeSlugify: (value: string) => string;
 declare const success: (message: string) => string;
 declare const stringifySingleLineArray: (values: string[]) => string;
-export { slugify, snakeSlugify, stringifySingleLineArray, success };
+declare const formatTfFileName: (fileName: string) => string;
+export { formatTfFileName, slugify, snakeSlugify, stringifySingleLineArray, success, };

package/dist/utilities/string-utils.js

@@ -4,4 +4,5 @@ const slugify = (value) => faker.helpers.slugify(value).toLowerCase();
 const snakeSlugify = (value) => slugify(value).replaceAll("-", "_");
 const success = (message) => `${ux.colorize("green", "✓")} ${message}`;
 const stringifySingleLineArray = (values) => `[${values.map((value) => `"${value}"`).join(", ")}]`;
-export { slugify, snakeSlugify, stringifySingleLineArray, success };
+const formatTfFileName = (fileName) => fileName.endsWith(".tf") ? fileName : `${fileName}.tf`;
+export { formatTfFileName, slugify, snakeSlugify, stringifySingleLineArray, success, };

package/oclif.manifest.json

@@ -19,7 +19,8 @@
           "multiple": false,
           "options": [
             "aws",
-            "gcp"
+            "gcp",
+            "azure"
           ],
           "type": "option"
         },
@@ -134,7 +135,8 @@
           "multiple": false,
           "options": [
             "aws",
-            "gcp"
+            "gcp",
+            "azure"
           ],
           "type": "option"
         },
@@ -354,5 +356,5 @@
       ]
     }
   },
-  "version": "0.0.0"
+  "version": "0.0.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "author": "Brandon Scott",
     "bin": {
-        "terrafaker": "./bin/run.js"
+        "terrafaker": "bin/run.js"
     },
     "bugs": "https://github.com/brandongregoryscott/terrafaker/issues",
     "dependencies": {
@@ -58,7 +58,10 @@
         ],
         "topicSeparator": " "
     },
-    "repository": "brandongregoryscott/terrafaker",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/brandongregoryscott/terrafaker.git"
+    },
     "scripts": {
         "build": "npm run clean && tsc -b",
         "build:watch": "npm run clean && tsc --watch",
@@ -78,5 +81,5 @@
     },
     "type": "module",
     "types": "dist/index.d.ts",
-    "version": "0.0.0"
+    "version": "0.0.1"
 }

package/dist/utilities/generators/aws-generators.d.ts

@@ -1,4 +0,0 @@
-import { TerraformGenerator } from "terraform-generator";
-import type { FileGeneratorOptions } from "./generator-utils.js";
-declare const generateAwsFile: (options?: FileGeneratorOptions) => TerraformGenerator;
-export { generateAwsFile };

package/dist/utilities/generators/aws-generators.js

@@ -1,80 +0,0 @@
-import { TerraformGenerator } from "terraform-generator";
-import { maybe, randomEnvironmentTag, randomId, randomItem, randomMemorableSlug, randomMemorySize, randomServiceTag, unique, } from "./generator-utils.js";
-import { AWS_EBS_VOLUME_TYPES, AWS_INSTANCE_TYPES, AWS_LAMBDA_RUNTIMES, AWS_REGIONS, } from "../../constants/aws.js";
-const AwsResourceType = {
-    Instance: "aws_instance",
-    LambdaFunction: "aws_lambda_function",
-};
-const randomRegion = () => randomItem(AWS_REGIONS);
-const randomAmi = unique(() => `ami-${randomId()}`);
-const randomRole = unique(() => `arn:aws:iam::${randomId()}:mfa/${randomMemorableSlug()}`);
-const randomResourceType = () => randomItem(Object.values(AwsResourceType));
-const generateAwsInstance = (options) => {
-    const { tfg, environment = randomEnvironmentTag(), service = randomServiceTag(), } = options;
-    const ami = randomAmi();
-    const instanceType = randomItem(AWS_INSTANCE_TYPES);
-    const name = randomMemorableSlug();
-    const rootBlockDevice = maybe(0.5)
-        ? {
-            root_block_device: {
-                volume_size: randomMemorySize({
-                    min: 1024,
-                    max: 64 * 1024 * 1024,
-                    step: 1024,
-                }),
-                volume_type: randomItem(AWS_EBS_VOLUME_TYPES),
-            },
-        }
-        : {};
-    tfg.resource(AwsResourceType.Instance, name, {
-        ami,
-        instance_type: instanceType,
-        ...rootBlockDevice,
-        tags: { name, environment, service },
-    });
-};
-const generateAwsLambdaFunction = (options) => {
-    const { tfg, environment = randomEnvironmentTag(), service = randomServiceTag(), } = options;
-    const ami = randomAmi();
-    const name = randomMemorableSlug();
-    const runtime = randomItem(AWS_LAMBDA_RUNTIMES);
-    const functionName = randomItem(["run", "test", "handler"]);
-    const handler = `${randomItem(["exports", "index"])}.${functionName}`;
-    /** @see https://docs.aws.amazon.com/lambda/latest/dg/configuration-memory.html */
-    const memorySize = randomMemorySize({ min: 128, max: 10240, step: 128 });
-    const role = randomRole();
-    tfg.resource(AwsResourceType.LambdaFunction, name, {
-        ami,
-        runtime,
-        handler,
-        function_name: functionName,
-        memory_size: memorySize,
-        role,
-        tags: { name, environment, service },
-    });
-};
-const generateResourceByType = (options) => {
-    const { type, ...rest } = options;
-    switch (type) {
-        case AwsResourceType.LambdaFunction:
-            return generateAwsLambdaFunction(rest);
-        default:
-        case AwsResourceType.Instance: {
-            return generateAwsInstance(rest);
-        }
-    }
-};
-const generateAwsFile = (options) => {
-    const { resourceCount = 3, environment = randomEnvironmentTag() } = options ?? {};
-    const tfg = new TerraformGenerator();
-    const region = randomRegion();
-    tfg.provider("aws", {
-        region,
-    });
-    for (let i = 0; i < resourceCount; i++) {
-        const type = randomResourceType();
-        generateResourceByType({ type, tfg, environment });
-    }
-    return tfg;
-};
-export { generateAwsFile };

package/dist/utilities/generators/gcp-generators.d.ts

@@ -1,4 +0,0 @@
-import { TerraformGenerator } from "terraform-generator";
-import type { FileGeneratorOptions } from "./generator-utils.js";
-declare const generateGcpFile: (options?: FileGeneratorOptions) => TerraformGenerator;
-export { generateGcpFile };

package/dist/utilities/generators/gcp-generators.js

@@ -1,69 +0,0 @@
-import { TerraformGenerator } from "terraform-generator";
-import { GCP_GPU_MACHINE_TYPES, GCP_INSTANCE_TYPES, GCP_LAMBDA_RUNTIMES, GCP_REGIONS, } from "../../constants/gcp.js";
-import { maybe, randomEnvironmentTag, randomInt, randomItem, randomMemorableSlug, randomMemorySize, randomServiceTag, } from "./generator-utils.js";
-const GcpResourceType = {
-    Instance: "google_compute_instance",
-    LambdaFunction: "google_cloudfunctions_function",
-};
-const randomRegion = () => randomItem(GCP_REGIONS);
-const randomResourceType = () => randomItem(Object.values(GcpResourceType));
-const generateGcpInstance = (options) => {
-    const { tfg, environment = randomEnvironmentTag(), service = randomServiceTag(), } = options;
-    const machineType = randomItem(GCP_INSTANCE_TYPES);
-    const name = randomMemorableSlug();
-    const guestAccelerator = maybe(0.5)
-        ? {
-            guest_accelerator: {
-                type: randomItem(GCP_GPU_MACHINE_TYPES),
-                count: randomInt({ min: 1, max: 4 }),
-            },
-        }
-        : {};
-    tfg.resource(GcpResourceType.Instance, name, {
-        machine_type: machineType,
-        ...guestAccelerator,
-        labels: { name, environment, service },
-    });
-};
-const generateGcpLambdaFunction = (options) => {
-    const { tfg, environment = randomEnvironmentTag(), service = randomServiceTag(), } = options;
-    const runtime = randomItem(GCP_LAMBDA_RUNTIMES);
-    const name = randomMemorableSlug();
-    /** @see https://docs.cloud.google.com/run/docs/configuring/services/memory-limits */
-    const availableMemoryMb = randomMemorySize({
-        min: 128,
-        max: 32 * 1024,
-        step: 128,
-    });
-    tfg.resource(GcpResourceType.LambdaFunction, name, {
-        runtime,
-        name,
-        available_memory_mb: availableMemoryMb,
-        labels: { name, environment, service },
-    });
-};
-const generateResourceByType = (options) => {
-    const { type, ...rest } = options;
-    switch (type) {
-        case GcpResourceType.LambdaFunction:
-            return generateGcpLambdaFunction(rest);
-        default:
-        case GcpResourceType.Instance: {
-            return generateGcpInstance(rest);
-        }
-    }
-};
-const generateGcpFile = (options) => {
-    const { resourceCount = 3, environment = randomEnvironmentTag() } = options ?? {};
-    const tfg = new TerraformGenerator();
-    const region = randomRegion();
-    tfg.provider("google", {
-        region,
-    });
-    for (let i = 0; i < resourceCount; i++) {
-        const type = randomResourceType();
-        generateResourceByType({ type, tfg, environment });
-    }
-    return tfg;
-};
-export { generateGcpFile };