@czfabrics/front-ready 0.1.0-beta.1

package/.dist/main.mjs

@@ -0,0 +1,1337 @@
+#!/usr/bin/env node
+// src/config/schema.ts
+import z from "zod";
+var NUMERIC = /* @__PURE__ */ new Set([
+  "max-age",
+  "s-maxage",
+  "stale-while-revalidate",
+  "stale-if-error"
+]);
+var FLAGS = /* @__PURE__ */ new Set([
+  "no-cache",
+  "no-store",
+  "no-transform",
+  "must-revalidate",
+  "proxy-revalidate",
+  "must-understand",
+  "private",
+  "public",
+  "immutable"
+]);
+var CacheControlSchema = z.string().superRefine((header, ctx) => {
+  for (const part of header.split(",")) {
+    const t = part.trim();
+    if (!t) continue;
+    const i = t.indexOf("=");
+    const name = (i === -1 ? t : t.slice(0, i)).trim().toLowerCase();
+    const value = i === -1 ? void 0 : t.slice(i + 1).trim().replace(/^"(.*)"$/, "$1");
+    if (NUMERIC.has(name)) {
+      if (value === void 0 || !/^\d+$/.test(value)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Directive "${name}" requires a non-negative integer`
+        });
+      }
+    } else if (FLAGS.has(name)) {
+      if (value !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Directive "${name}" does not take a value`
+        });
+      }
+    } else {
+      ctx.addIssue({
+        code: "custom",
+        message: `Unknown directive "${name}"`
+      });
+    }
+  }
+});
+var ConfigSchema = z.object({
+  bucket: z.object({
+    namePrefix: z.string().nonempty().regex(/[a-z-]*/, "String should be kekab-case string"),
+    params: z.object({
+      region: z.string().nonempty(),
+      apiVersion: z.string().nonempty(),
+      endpoint: z.string().nonempty(),
+      forcePathStyle: z.union([z.stringbool(), z.boolean()]).optional(),
+      credentials: z.object({
+        accessKeyId: z.string().nonempty(),
+        secretAccessKey: z.string().nonempty()
+      })
+    }),
+    front: z.object({
+      cacheControlMapping: z.record(
+        z.templateLiteral([z.literal("^"), z.string(), z.literal("$")]),
+        CacheControlSchema
+      ).default({
+        "^index.html$": "max-age=60, stale-while-revalidate=600, stale-if-error=86400",
+        "^assets/.+$": "max-age=86400, stale-while-revalidate=600, stale-if-error=86400",
+        "^translate/.+$": "max-age=14400, stale-while-revalidate=600, stale-if-error=86400",
+        "^.+$": "max-age=31536000, stale-while-revalidate=600, stale-if-error=86400"
+      }),
+      indexDocumentSuffix: z.string().nonempty().default("index.html"),
+      errorDocumentKey: z.string().nonempty().default("index.html")
+    }).prefault({}),
+    upload: z.object({
+      concurrency: z.number().positive().default(50)
+    }).prefault({})
+  }),
+  front: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("angular"),
+      angular: z.object({
+        projectName: z.string().nonempty(),
+        angularJsonPath: z.string().nonempty(),
+        configurationName: z.string().nonempty().optional()
+      })
+    }),
+    z.object({
+      type: z.literal("custom"),
+      custom: z.object({
+        build: z.object({
+          command: z.string().nonempty(),
+          args: z.array(z.string().nonempty())
+        }),
+        environmentName: z.string().nonempty(),
+        buildOutputPath: z.string().nonempty()
+      })
+    })
+  ])
+});
+
+// src/errors/config_format.ts
+import { Data } from "effect";
+import z2 from "zod";
+var ConfigFormatError = class extends Data.TaggedError("ConfigFormatError") {
+  get message() {
+    return z2.prettifyError(this.cause);
+  }
+};
+
+// src/errors/interop/config_wrapper.ts
+import { Data as Data2 } from "effect";
+var ConfigWrapperError = class extends Data2.TaggedError("ConfigWrapperError") {
+};
+
+// src/helpers/effect.ts
+import { Effect } from "effect";
+var toEffectSync = function(fn, errorClass, additionalData) {
+  return toEffect(
+    new Promise((resolve) => {
+      resolve(fn());
+    }),
+    errorClass,
+    additionalData
+  );
+};
+var toEffect = function(promise, errorClass, additionalData) {
+  return Effect.mapError(
+    Effect.tryPromise(() => promise),
+    (error) => new errorClass({
+      message: error.message,
+      cause: error,
+      ...additionalData
+    })
+  );
+};
+var genFn = function(callback) {
+  return (...args) => {
+    return Effect.gen(() => callback(...args));
+  };
+};
+
+// src/config/loader.ts
+import { loadConfig as c12LoadConfig } from "c12";
+import { Effect as Effect2 } from "effect";
+var loadConfig = genFn(function* () {
+  const { config } = yield* toEffect(
+    c12LoadConfig({
+      name: "frontready",
+      configFileRequired: true
+    }),
+    ConfigWrapperError,
+    {}
+  );
+  const parsedConfig = ConfigSchema.safeParse(config);
+  if (parsedConfig.success) {
+    return parsedConfig.data;
+  }
+  return yield* Effect2.fail(
+    new ConfigFormatError({
+      cause: parsedConfig.error
+    })
+  );
+});
+
+// src/contexts/cli_command.ts
+import { Context } from "effect";
+var CliCommandContext = class extends Context.Tag("CliCommandContext")() {
+};
+
+// src/cli/cli_starter.ts
+import { intro, log } from "@clack/prompts";
+import { Effect as Effect3 } from "effect";
+
+// package.json
+var package_default = {
+  name: "@czfabrics/front-ready",
+  version: "0.1.0-beta.1",
+  author: {
+    name: "Dylan Valentin",
+    email: "dylan.valentin@ik.me",
+    url: "https://github.com/czyrok"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/czfabrics/front-ready.git"
+  },
+  dependencies: {
+    "@aws-sdk/client-s3": "^3.1061.0",
+    "@clack/prompts": "^1.5.1",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-node": "^0.107.0",
+    c12: "^4.0.0-beta.5",
+    "cmd-ts": "^0.15.0",
+    effect: "^3.21.2",
+    mrmime: "^2.0.1",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@appnest/readme": "^1.2.7",
+    "@types/pluralize": "^0.0.33",
+    "@typescript/analyze-trace": "^0.10.1",
+    esbuild: "^0.25.9",
+    prettier: "^3.6.2",
+    rimraf: "^6.0.1",
+    "tsc-alias": "^1.8.16",
+    tsx: "^4.21.0",
+    "type-fest": "^5.3.1",
+    typescript: "^5.9.2",
+    "vite-tsconfig-paths": "^6.1.0",
+    vitest: "^4.0.18",
+    "vscode-generate-index-standalone": "^1.7.1"
+  },
+  main: "./.dist/index.cjs",
+  module: "./.dist/index.mjs",
+  types: "./.dist/index.d.ts",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      types: "./.dist/index.d.ts",
+      import: "./.dist/index.mjs",
+      require: "./.dist/index.cjs"
+    }
+  },
+  bin: "./.dist/main.mjs",
+  bugs: {
+    url: "https://github.com/czfabrics/front-ready/issues"
+  },
+  description: "A framework-aware deployment tool for static frontends. It reads your project's build configuration (e.g. angular.json), runs the build with the configuration you choose, and pushes the compiled output to an S3 bucket \u2014 with correct content types and cache headers \u2014 so a single command takes you from source to a live, hosted site.",
+  files: [
+    "package.json",
+    "README.md",
+    "LICENSE",
+    ".dist/**/*"
+  ],
+  homepage: "https://github.com/czfabrics/front-ready#readme",
+  keywords: [
+    "cli",
+    "deploy",
+    "deployment",
+    "s3",
+    "aws",
+    "aws-s3",
+    "bucket",
+    "frontend",
+    "static-site",
+    "static-hosting",
+    "spa",
+    "build",
+    "angular",
+    "ci-cd",
+    "upload",
+    "typescript"
+  ],
+  license: "MIT",
+  scripts: {
+    "format:all": "prettier . --write",
+    typecheck: "tsc --project ./tsconfig.typecheck.json",
+    dev: "tsx main.ts",
+    test: "vitest",
+    "test:coverage": "vitest --coverage.enabled",
+    "check:type-perf": "rimraf .tsc_traces && tsc --project ./tsconfig.typecheck.json --generateTrace .tsc_traces && analyze-trace .tsc_traces",
+    "prepare:index": "vscode-generate-index-standalone index.ts",
+    "prepare:dist": "tsx build.ts",
+    "prepare:declaration": "tsc --project ./tsconfig.declaration.json",
+    "prepare:imports": "tsc-alias --project tsconfig.declaration.json --outDir .dist",
+    build: "rimraf .dist && bun run prepare:index && bun run prepare:dist && bun run prepare:declaration && bun run prepare:imports",
+    "generate:readme": "readme generate --config .blueprint.json",
+    prepublishOnly: "bun run generate:readme && bun run build"
+  }
+};
+
+// src/cli/cli_starter.ts
+var startCli = function() {
+  return Effect3.gen(function* () {
+    const context = yield* CliCommandContext;
+    intro(`${package_default.name}@${package_default.version} - ${context.commandName}`);
+    const config = yield* loadConfig();
+    log.info("Configuration loaded");
+    return { config };
+  });
+};
+
+// src/contexts/internal_config.ts
+import { Context as Context2 } from "effect";
+var InternalConfigContext = class extends Context2.Tag("InternalConfigContext")() {
+};
+
+// src/contexts/front_deployment.ts
+import { Context as Context3 } from "effect";
+var FrontDeploymentContext = class extends Context3.Tag("FrontDeploymentContext")() {
+};
+
+// src/errors/interop/tui_wrapper.ts
+import { Data as Data3 } from "effect";
+var TUiWrapperError = class extends Data3.TaggedError("TUiWrapperError") {
+};
+
+// src/factories/bucket_name.ts
+var makeDeploymentBucketName = function(config, bucketIdentifier) {
+  return `${config.bucket.namePrefix}-${bucketIdentifier}`;
+};
+
+// src/errors/angular.ts
+import { Data as Data4 } from "effect";
+import z3 from "zod";
+var AngularJsonFormatError = class extends Data4.TaggedError("AngularJsonFormatError") {
+  get message() {
+    return z3.prettifyError(this.cause);
+  }
+};
+var AngularJsonMissingDataError = class extends Data4.TaggedError(
+  "AngularJsonMissingDataError"
+) {
+  get message() {
+    return `Unable to resolve '${this.subject}' for '${this.projectName}'`;
+  }
+};
+
+// src/helpers/angular.ts
+import { FileSystem } from "@effect/platform";
+import { Effect as Effect4 } from "effect";
+import z4 from "zod";
+var OutputPathSchema = z4.union([
+  z4.string(),
+  z4.object({
+    base: z4.string(),
+    browser: z4.string().optional()
+  })
+]);
+var AngularTargetSchema = z4.object({
+  builder: z4.string().optional(),
+  options: z4.object({
+    outputPath: OutputPathSchema.optional()
+  }).optional(),
+  configurations: z4.record(z4.string(), z4.unknown()).optional()
+});
+var AngularProjectSchema = z4.object({
+  architect: z4.record(z4.string(), AngularTargetSchema).optional(),
+  targets: z4.record(z4.string(), AngularTargetSchema).optional()
+});
+var AngularJsonSchema = z4.object({
+  projects: z4.record(z4.string(), AngularProjectSchema).optional()
+});
+var getProjectTargets = (project) => {
+  return project.architect ?? project.targets ?? {};
+};
+var getAngularConfigurationNames = (angularJson) => {
+  const configurationNames = /* @__PURE__ */ new Set();
+  for (const project of Object.values(angularJson.projects ?? {})) {
+    for (const target of Object.values(getProjectTargets(project))) {
+      for (const name of Object.keys(target.configurations ?? {})) {
+        configurationNames.add(name);
+      }
+    }
+  }
+  return [...configurationNames];
+};
+var usesBrowserSubfolder = (builder) => builder?.endsWith(":application") ?? false;
+var getAngularOutputPath = (angularJson, projectName, targetName = "build") => {
+  const projects = angularJson.projects ?? {};
+  const project = projects[projectName];
+  if (!project) return void 0;
+  const target = getProjectTargets(project)[targetName];
+  const outputPath = target?.options?.outputPath;
+  if (outputPath === void 0) return void 0;
+  if (typeof outputPath === "object") {
+    const browser = outputPath.browser ?? "browser";
+    return browser ? `${outputPath.base}/${browser}` : outputPath.base;
+  }
+  return usesBrowserSubfolder(target?.builder) ? `${outputPath}/browser` : outputPath;
+};
+var resolveAngularConfigurations = function(angularJsonPath, projectName) {
+  return Effect4.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const content = yield* fs.readFileString(angularJsonPath);
+    const angularJson = yield* Effect4.try(() => JSON.parse(content));
+    const parsedJson = AngularJsonSchema.safeParse(angularJson);
+    if (!parsedJson.success) {
+      return yield* Effect4.fail(
+        new AngularJsonFormatError({
+          cause: parsedJson.error
+        })
+      );
+    }
+    const outputPath = getAngularOutputPath(parsedJson.data, projectName);
+    if (!outputPath) {
+      return yield* Effect4.fail(
+        new AngularJsonMissingDataError({
+          subject: "output path",
+          projectName
+        })
+      );
+    }
+    return {
+      configurations: getAngularConfigurationNames(parsedJson.data),
+      outputPath
+    };
+  });
+};
+
+// src/factories/front_deployment_context.ts
+import { log as log2, select } from "@clack/prompts";
+import { Command } from "@effect/platform";
+import { Effect as Effect5, Layer, Match } from "effect";
+var makeFrontDeploymentContextLayer = function(rootConfig) {
+  return Layer.effect(
+    FrontDeploymentContext,
+    Match.value(rootConfig.front).pipe(
+      Match.when(
+        { type: "angular" },
+        (config) => Effect5.gen(function* () {
+          const { configurations, outputPath } = yield* resolveAngularConfigurations(
+            config.angular.angularJsonPath,
+            config.angular.projectName
+          );
+          if (config.angular.configurationName) {
+            return {
+              command: Command.make("ng", "build", config.angular.configurationName),
+              bucketName: makeDeploymentBucketName(
+                rootConfig,
+                config.angular.configurationName
+              ),
+              buildOutputPath: outputPath
+            };
+          }
+          log2.warning("Angular configuration name not found in configuration");
+          log2.message(
+            `Reading '${config.angular.angularJsonPath}' file to get available configurations`
+          );
+          const options = configurations.map((name) => ({
+            value: name,
+            label: name
+          }));
+          const configurationName = yield* toEffect(
+            select({
+              message: "Pick an Angular configuration.",
+              options
+            }),
+            TUiWrapperError,
+            {
+              uiFunction: "select"
+            }
+          );
+          return {
+            command: Command.make("ng", "build", configurationName.toString()),
+            bucketName: makeDeploymentBucketName(
+              rootConfig,
+              configurationName.toString()
+            ),
+            buildOutputPath: outputPath
+          };
+        })
+      ),
+      Match.when(
+        { type: "custom" },
+        (config) => Effect5.gen(function* () {
+          return {
+            command: Command.make(
+              config.custom.build.command,
+              ...config.custom.build.args
+            ),
+            bucketName: makeDeploymentBucketName(
+              rootConfig,
+              config.custom.environmentName
+            ),
+            buildOutputPath: config.custom.buildOutputPath
+          };
+        })
+      ),
+      Match.exhaustive
+    )
+  );
+};
+
+// src/helpers/runtime.ts
+import { Effect as Effect6 } from "effect";
+import * as readline from "node:readline";
+var interruptOnCtrlC = function() {
+  return Effect6.async((resume) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    const onKeypress = (_, key) => {
+      if (key.ctrl && key.name === "c") {
+        resume(Effect6.interrupt);
+      }
+    };
+    process.stdin.on("keypress", onKeypress);
+    return Effect6.sync(() => {
+      process.stdin.off("keypress", onKeypress);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    });
+  });
+};
+var runAndInterruptOnCtrlC = function(effect) {
+  return Effect6.raceFirst(interruptOnCtrlC(), effect);
+};
+var overrideProcessExit = (override) => Effect6.acquireRelease(
+  Effect6.sync(() => {
+    const original = process.exit;
+    process.exit = override;
+    return original;
+  }),
+  (original) => Effect6.sync(() => {
+    process.exit = original;
+  })
+);
+var interceptProcessExit = function(effect, callback) {
+  return Effect6.scoped(
+    Effect6.gen(function* () {
+      yield* overrideProcessExit((exitCode) => {
+        callback(exitCode ?? 130);
+      });
+      return yield* effect;
+    })
+  );
+};
+
+// src/contexts/file_object_bucket.ts
+import { Context as Context4 } from "effect";
+var FileObjectBucketContext = class extends Context4.Tag("FileObjectBucketContext")() {
+};
+
+// src/contexts/file_repository.ts
+import { Context as Context5 } from "effect";
+var FileRepositoryContext = class extends Context5.Tag("FileRepositoryContext")() {
+};
+
+// src/errors/file.ts
+import { Data as Data5 } from "effect";
+var FileError = class extends Data5.TaggedError("FileError") {
+};
+var FileNotFoundError = class extends Data5.TaggedError("FileNotFoundError") {
+};
+
+// src/errors/interop/file_type_wrapper.ts
+import { Data as Data6 } from "effect";
+var FileTypeWrapperError = class extends Data6.TaggedError("FileTypeWrapperError") {
+};
+
+// src/file/types.ts
+import { Path } from "@effect/platform";
+import { FileSystem as FileSystem2 } from "@effect/platform/FileSystem";
+import { Effect as Effect7, Equal, Hash } from "effect";
+import { lookup } from "mrmime";
+var FileItem = {
+  new: function(data) {
+    return Effect7.gen(function* () {
+      const path = yield* Path.Path;
+      const fs = yield* FileSystem2;
+      const name = path.basename(data.relativePath);
+      const extension = path.extname(data.relativePath);
+      const absolutePath = path.resolve(data.cwd, data.relativePath);
+      const content = fs.readFile(absolutePath);
+      return {
+        name,
+        extension,
+        relativePath: data.relativePath,
+        absolutePath,
+        cwd: data.cwd,
+        content,
+        get contentType() {
+          return toEffectSync(
+            () => lookup(extension) ?? "application/octet-stream",
+            FileTypeWrapperError,
+            {
+              file: this
+            }
+          );
+        },
+        get length() {
+          return 1;
+        },
+        [Symbol.iterator]() {
+          let isFirst = true;
+          return {
+            next: () => {
+              if (isFirst) {
+                isFirst = false;
+                return { value: this, done: false };
+              }
+              return { value: void 0, done: true };
+            }
+          };
+        }
+      };
+    });
+  }
+};
+var FileTreeTypeId = Symbol.for("FileTree");
+var isFileTree = function(thing) {
+  return typeof thing === "object" && thing !== null && FileTreeTypeId in thing;
+};
+var FileTree = {
+  new: function(data) {
+    return Effect7.gen(function* () {
+      const path = yield* Path.Path;
+      return {
+        [FileTreeTypeId]: FileTreeTypeId,
+        name: path.basename(data.relativePath),
+        relativePath: data.relativePath,
+        absolutePath: path.resolve(data.cwd, data.relativePath),
+        cwd: data.cwd,
+        items: data.items,
+        get length() {
+          return this.items.length;
+        },
+        append: function(newItems) {
+          return FileTree.new({
+            ...this,
+            items: [...this.items, ...newItems]
+          });
+        },
+        [Symbol.iterator]() {
+          let currentIndex = 0;
+          return {
+            next: () => {
+              if (currentIndex < this.items.length) {
+                const currentItem = this.items[currentIndex];
+                currentIndex++;
+                return { value: currentItem, done: false };
+              }
+              return { value: void 0, done: true };
+            }
+          };
+        },
+        [Equal.symbol](that) {
+          return isFileTree(that) && this.absolutePath === that.absolutePath;
+        },
+        [Hash.symbol]() {
+          return Hash.string(this.absolutePath);
+        }
+      };
+    });
+  },
+  is: function(thing) {
+    return isFileTree(thing);
+  }
+};
+
+// src/file/repository.ts
+import { Path as Path2 } from "@effect/platform";
+import { FileSystem as FileSystem3 } from "@effect/platform/FileSystem";
+import { Effect as Effect8 } from "effect";
+var FileRepository = class extends Effect8.Service()("FileRepository", {
+  effect: Effect8.gen(function* () {
+    const fs = yield* FileSystem3;
+    const path = yield* Path2.Path;
+    const context = yield* FileRepositoryContext;
+    return {
+      listFiles: () => Effect8.gen(function* () {
+        const paths = yield* fs.readDirectory(context.cwd, {
+          recursive: true
+        });
+        const filePaths = yield* Effect8.filter(
+          paths,
+          (relativePath) => fs.stat(path.resolve(context.cwd, relativePath)).pipe(Effect8.map((info) => info.type === "File")),
+          { concurrency: "unbounded" }
+        );
+        return yield* Effect8.forEach(filePaths, (filePath) => {
+          return FileItem.new({
+            relativePath: filePath,
+            cwd: context.cwd
+          });
+        });
+      })
+    };
+  }),
+  dependencies: []
+}) {
+};
+
+// src/errors/interop/file_object_wrapper.ts
+import { Data as Data7 } from "effect";
+var FileObjectWrapperError = class extends Data7.TaggedError("FileObjectWrapperError") {
+};
+
+// src/file_object/api_instance.ts
+import { S3Client } from "@aws-sdk/client-s3";
+import { Context as Context6, Effect as Effect9, Layer as Layer2 } from "effect";
+var FileObjectApiInstance = class extends Context6.Tag("FileObjectApiInstance")() {
+};
+var FileObjectApiInstanceLive = Layer2.effect(
+  FileObjectApiInstance,
+  Effect9.gen(function* () {
+    const config = yield* InternalConfigContext;
+    return new S3Client({
+      region: config.bucket.params.region,
+      apiVersion: config.bucket.params.apiVersion,
+      endpoint: config.bucket.params.endpoint,
+      forcePathStyle: config.bucket.params.forcePathStyle,
+      credentials: {
+        accessKeyId: config.bucket.params.credentials.accessKeyId,
+        secretAccessKey: config.bucket.params.credentials.secretAccessKey
+      }
+    });
+  })
+);
+
+// src/file_object/repository.ts
+import {
+  CreateBucketCommand,
+  HeadBucketCommand,
+  PutBucketAclCommand,
+  PutBucketWebsiteCommand,
+  PutObjectCommand
+} from "@aws-sdk/client-s3";
+import { Effect as Effect10 } from "effect";
+var FileObjectRepository = class extends Effect10.Service()(
+  "FileObjectRepository",
+  {
+    effect: Effect10.gen(function* () {
+      const apiInstance = yield* FileObjectApiInstance;
+      const context = yield* FileObjectBucketContext;
+      return {
+        createBucket: genFn(function* () {
+          const command3 = new CreateBucketCommand({
+            Bucket: context.bucketName,
+            CreateBucketConfiguration: {
+              LocationConstraint: context.region
+            },
+            ObjectOwnership: "BucketOwnerEnforced"
+          });
+          yield* toEffect(apiInstance.send(command3), FileObjectWrapperError, {});
+        }),
+        doesBucketExist: genFn(function* () {
+          const command3 = new HeadBucketCommand({
+            Bucket: context.bucketName
+          });
+          const doesExist = yield* Effect10.matchEffect(
+            toEffect(apiInstance.send(command3), FileObjectWrapperError, {}),
+            {
+              onFailure: (error) => {
+                if (error.cause.name === "NotFound") {
+                  return Effect10.succeed(false);
+                }
+                return Effect10.fail(error);
+              },
+              onSuccess: () => Effect10.succeed(true)
+            }
+          );
+          return doesExist;
+        }),
+        setPublicReadAclOnBucket: genFn(function* () {
+          const command3 = new PutBucketAclCommand({
+            Bucket: context.bucketName,
+            ACL: "public-read"
+          });
+          yield* toEffect(apiInstance.send(command3), FileObjectWrapperError, {});
+        }),
+        setWebsiteConfigurationOnBucket: genFn(function* (indexFileKeySuffix, errorFileKey) {
+          const command3 = new PutBucketWebsiteCommand({
+            Bucket: context.bucketName,
+            WebsiteConfiguration: {
+              IndexDocument: {
+                Suffix: indexFileKeySuffix
+              },
+              ErrorDocument: {
+                Key: errorFileKey
+              }
+            }
+          });
+          yield* toEffect(apiInstance.send(command3), FileObjectWrapperError, {});
+        }),
+        putObject: genFn(function* (file) {
+          const command3 = new PutObjectCommand({
+            ACL: "public-read",
+            Bucket: context.bucketName,
+            Key: file.key,
+            Body: file.content,
+            ContentEncoding: "binary",
+            ContentType: file.contentType,
+            CacheControl: file.cacheControlValue
+          });
+          yield* toEffect(apiInstance.send(command3), FileObjectWrapperError, {});
+        })
+      };
+    }),
+    dependencies: [FileObjectApiInstanceLive]
+  }
+) {
+};
+
+// src/helpers/file.ts
+import { Path as Path3 } from "@effect/platform";
+import { Array as Array2, Effect as Effect11, Option } from "effect";
+var fileIntoObject = function(file) {
+  return Effect11.gen(function* () {
+    const content = yield* file.content;
+    const contentType = yield* file.contentType;
+    return {
+      key: file.relativePath,
+      content,
+      contentType,
+      cacheControlValue: void 0
+    };
+  });
+};
+var detectAndFillCacheControl = function(object, cacheControlMapping) {
+  for (const [keyRawRegExp, cacheControlValue] of Object.entries(cacheControlMapping)) {
+    const isCorrectCacheControl = new RegExp(keyRawRegExp).test(object.key);
+    if (isCorrectCacheControl) {
+      return {
+        ...object,
+        cacheControlValue
+      };
+    }
+  }
+  return object;
+};
+var extractFirstFolderFromPath = function(relativePath) {
+  return Effect11.gen(function* () {
+    const path = yield* Path3.Path;
+    const segments = path.normalize(relativePath).replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+    if (segments.length <= 1) {
+      return Option.none();
+    }
+    return Array2.head(segments);
+  });
+};
+var extractRootFileTree = genFn(function* (file, cwd) {
+  const firstFolder = yield* extractFirstFolderFromPath(file.relativePath);
+  if (Option.isNone(firstFolder)) {
+    return Option.none();
+  }
+  return Option.some(
+    yield* FileTree.new({ relativePath: firstFolder.value, cwd, items: [file] })
+  );
+});
+var hasMinOneFile = function(components) {
+  for (const component of components) {
+    if (component.length > 0) {
+      return true;
+    }
+  }
+  return false;
+};
+var excludeRootFile = function(components, filenameToExclude) {
+  return Effect11.sync(function* () {
+    for (const component of components) {
+      if (!FileTree.is(component) && component.name === filenameToExclude) {
+        continue;
+      }
+      yield component;
+    }
+  });
+};
+var extractRootFile = genFn(function* (components, filenameToPick) {
+  for (const component of components) {
+    if (!FileTree.is(component) && component.name === filenameToPick) {
+      return component;
+    }
+  }
+  return yield* Effect11.fail(
+    new FileNotFoundError({ message: `File not found`, file: { name: filenameToPick } })
+  );
+});
+var pickIndexHtml = genFn(function* (components) {
+  const alteredComponents = yield* excludeRootFile(components, "index.html");
+  const indexHtml = yield* extractRootFile(components, "index.html");
+  return {
+    components: alteredComponents,
+    indexHtml
+  };
+});
+
+// src/front/service.ts
+import { Effect as Effect12, HashMap, Layer as Layer3, Option as Option2 } from "effect";
+var FileRepositoryContextLive = Layer3.effect(
+  FileRepositoryContext,
+  Effect12.gen(function* () {
+    const front = yield* FrontDeploymentContext;
+    return { cwd: front.buildOutputPath };
+  })
+);
+var FileObjectBucketContextLive = Layer3.effect(
+  FileObjectBucketContext,
+  Effect12.gen(function* () {
+    const front = yield* FrontDeploymentContext;
+    const config = yield* InternalConfigContext;
+    return {
+      bucketName: front.bucketName,
+      region: config.bucket.params.region
+    };
+  })
+);
+var FrontFileObjectService = class extends Effect12.Service()(
+  "FrontFileObjectService",
+  {
+    effect: Effect12.gen(function* () {
+      const configContext = yield* InternalConfigContext;
+      const fileRepository = yield* FileRepository;
+      const fileObjectRepository = yield* FileObjectRepository;
+      const frontContext = yield* FrontDeploymentContext;
+      return {
+        doesFrontBucketExist: () => {
+          return fileObjectRepository.doesBucketExist();
+        },
+        listFrontBuildFiles: () => {
+          return fileRepository.listFiles();
+        },
+        listFrontBuildFileByRootComponents: genFn(function* () {
+          const files = yield* fileRepository.listFiles();
+          let map = HashMap.empty();
+          for (const file of files) {
+            const resolvedFileTree = yield* extractRootFileTree(
+              file,
+              frontContext.buildOutputPath
+            );
+            if (Option2.isNone(resolvedFileTree)) {
+              map = HashMap.set(map, file.absolutePath, file);
+              continue;
+            }
+            const existingFileTree = HashMap.get(map, resolvedFileTree.value.absolutePath);
+            if (Option2.isNone(existingFileTree)) {
+              map = HashMap.set(
+                map,
+                resolvedFileTree.value.absolutePath,
+                resolvedFileTree.value
+              );
+              continue;
+            }
+            if (!FileTree.is(existingFileTree.value)) {
+              return yield* Effect12.fail(
+                new FileError({
+                  message: `The same path was resolved both file item & file tree`,
+                  file: existingFileTree.value
+                })
+              );
+            }
+            const updatedFileTree = yield* existingFileTree.value.append([file]);
+            map = HashMap.set(map, existingFileTree.value.absolutePath, updatedFileTree);
+          }
+          return HashMap.values(map);
+        }),
+        createFrontBucket: genFn(function* () {
+          yield* fileObjectRepository.createBucket();
+          yield* fileObjectRepository.setPublicReadAclOnBucket();
+          yield* fileObjectRepository.setWebsiteConfigurationOnBucket(
+            configContext.bucket.front.indexDocumentSuffix,
+            configContext.bucket.front.errorDocumentKey
+          );
+        }),
+        uploadFrontFileToBucket: genFn(function* (file) {
+          const object = detectAndFillCacheControl(
+            yield* fileIntoObject(file),
+            configContext.bucket.front.cacheControlMapping
+          );
+          yield* fileObjectRepository.putObject(object);
+        })
+      };
+    }),
+    dependencies: [
+      FileRepository.Default.pipe(Layer3.provide(FileRepositoryContextLive)),
+      FileObjectRepository.Default.pipe(Layer3.provide(FileObjectBucketContextLive))
+    ]
+  }
+) {
+};
+
+// src/ui/confirm.ts
+import { confirm } from "@clack/prompts";
+var genConfirmUi = function({
+  question,
+  initialValue
+}) {
+  return toEffect(
+    confirm({
+      message: question,
+      initialValue
+    }),
+    TUiWrapperError,
+    {
+      uiFunction: "confirm"
+    }
+  );
+};
+
+// src/ui/loader.ts
+import { spinner } from "@clack/prompts";
+import { Effect as Effect13 } from "effect";
+var genLoaderUi = function({
+  process: process2,
+  message
+}) {
+  return Effect13.gen(function* () {
+    const spin = spinner({
+      indicator: "timer",
+      frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+      delay: 80,
+      styleFrame: (frame) => `\x1B[35m${frame}\x1B[0m`
+    });
+    return yield* interceptProcessExit(
+      Effect13.gen(function* () {
+        spin.start(message.resolveStart());
+        const [duration, result] = yield* Effect13.timed(
+          process2(spin.message).pipe(
+            Effect13.catchAll(
+              (error) => Effect13.gen(function* () {
+                spin.error(message.resolveError(error));
+                return yield* Effect13.fail(error);
+              })
+            )
+          )
+        );
+        spin.stop(message.resolveEnd(duration));
+        return result;
+      }),
+      (exitCode) => spin.cancel(message.resolveCancel(exitCode))
+    );
+  });
+};
+
+// src/use_cases/create_front_bucket.ts
+import { log as log3 } from "@clack/prompts";
+import { Duration as Duration2, Effect as Effect14 } from "effect";
+var CreateFrontBucketUseCase = class extends Effect14.Service()(
+  "CreateFrontBucketUseCase",
+  {
+    effect: Effect14.gen(function* () {
+      const deploymentContext = yield* FrontDeploymentContext;
+      const frontService = yield* FrontFileObjectService;
+      return {
+        run: genFn(function* () {
+          const doesBucketExist = yield* frontService.doesFrontBucketExist();
+          if (doesBucketExist) {
+            log3.info(`The bucket '${deploymentContext.bucketName}' already exist`);
+            return yield* Effect14.interrupt;
+          }
+          const shouldContinue = yield* genConfirmUi({
+            question: `Do you want to create the bucket '${deploymentContext.bucketName}'?`,
+            initialValue: true
+          });
+          if (!shouldContinue) {
+            return yield* Effect14.interrupt;
+          }
+          yield* genLoaderUi({
+            process: frontService.createFrontBucket,
+            message: {
+              resolveStart: () => "Creating front bucket",
+              resolveError: (error) => `Creation failed: ${error.message}`,
+              resolveCancel: () => "Creation canceled",
+              resolveEnd: (duration) => `Creation finished in ${Duration2.toMillis(duration)}ms`
+            }
+          });
+        })
+      };
+    }),
+    dependencies: [FrontFileObjectService.Default]
+  }
+) {
+};
+
+// src/cli/create_front_bucket_command.ts
+import { cancel, log as log4, outro } from "@clack/prompts";
+import { command } from "cmd-ts";
+import { Effect as Effect15, Inspectable, Layer as Layer4 } from "effect";
+var createFrontBucketCommand = command({
+  name: "create",
+  description: "TODO",
+  args: {},
+  handler: function() {
+    const CommandContextLayer = Layer4.succeed(CliCommandContext, {
+      commandName: this.name
+    });
+    return Effect15.gen(function* () {
+      const { config } = yield* startCli();
+      const ConfigContextLayer = Layer4.succeed(InternalConfigContext, config);
+      const DeploymentContextLayer = makeFrontDeploymentContextLayer(config);
+      yield* Effect15.gen(function* () {
+        const useCase = yield* CreateFrontBucketUseCase;
+        yield* runAndInterruptOnCtrlC(useCase.run());
+        outro(`Creation finished`);
+      }).pipe(
+        Effect15.provide(CreateFrontBucketUseCase.Default),
+        Effect15.provide(ConfigContextLayer),
+        Effect15.provide(DeploymentContextLayer),
+        Effect15.onInterrupt(() => Effect15.sync(() => cancel(`Creation canceled`))),
+        Effect15.catchAll(
+          (error) => Effect15.gen(function* () {
+            log4.error(error.message);
+            log4.message(Inspectable.toStringUnknown(error));
+            outro(`Creation aborted`);
+          })
+        )
+      );
+    }).pipe(Effect15.provide(CommandContextLayer));
+  }
+});
+
+// src/errors/front.ts
+import { Data as Data8 } from "effect";
+var FrontError = class extends Data8.TaggedError("FrontError") {
+};
+
+// src/errors/command.ts
+import { Data as Data9 } from "effect";
+var CommandError = class extends Data9.TaggedError("CommandError") {
+};
+
+// src/helpers/command.ts
+import { Command as Command2 } from "@effect/platform";
+import { Effect as Effect16, pipe, Stream } from "effect";
+var runCommand = function(command3, logMessage) {
+  return Effect16.scoped(
+    pipe(
+      Command2.start(command3.pipe(Command2.runInShell(true))),
+      Effect16.flatMap(
+        (process2) => Effect16.all(
+          [
+            process2.exitCode,
+            process2.stdout.pipe(
+              Stream.decodeText(),
+              Stream.runForEach((chunk) => Effect16.sync(() => logMessage(chunk)))
+            ),
+            process2.stderr.pipe(
+              Stream.decodeText(),
+              Stream.runForEach((chunk) => Effect16.sync(() => logMessage(chunk)))
+            )
+          ],
+          { concurrency: 3 }
+        )
+      ),
+      Effect16.map((result) => result[0])
+    )
+  );
+};
+
+// src/ui/command.ts
+import { Effect as Effect17 } from "effect";
+var genCommandUi = function({
+  command: command3,
+  message
+}) {
+  return genLoaderUi({
+    process: (logMessage) => Effect17.gen(function* () {
+      const exitCode = yield* runCommand(command3, logMessage);
+      if (exitCode !== 0) {
+        return yield* Effect17.fail(
+          new CommandError({
+            message: `Command exited with code '${exitCode}'`,
+            code: exitCode
+          })
+        );
+      }
+      return exitCode;
+    }),
+    message
+  });
+};
+
+// src/ui/tasks.ts
+import { taskLog } from "@clack/prompts";
+import { Effect as Effect18 } from "effect";
+var genTaskLogsUi = ({
+  title,
+  itemGroups,
+  processItem,
+  message,
+  subTaskConcurrency
+}) => {
+  return Effect18.gen(function* () {
+    const log7 = taskLog({
+      title,
+      retainLog: false
+    });
+    const tasks = Array.from(itemGroups).map((group) => {
+      return Effect18.gen(function* () {
+        const groupLog = log7.group(message.resolveGroupTitle(group));
+        const [duration2] = yield* Effect18.timed(
+          Effect18.gen(function* () {
+            const itemProcesses = Array.from(group).map(
+              (item) => Effect18.gen(function* () {
+                yield* processItem(item);
+                groupLog.message(message.resolveItem(item));
+              })
+            );
+            yield* Effect18.all(itemProcesses, {
+              concurrency: subTaskConcurrency
+            });
+          }).pipe(
+            Effect18.catchAll(
+              (error) => Effect18.gen(function* () {
+                groupLog.error(message.resolveGroupError(group, error));
+                return yield* Effect18.fail(error);
+              })
+            )
+          )
+        );
+        groupLog.success(message.resolveGroupSuccess(group, duration2));
+      });
+    });
+    const [duration] = yield* Effect18.timed(
+      Effect18.all(tasks, {
+        concurrency: "unbounded"
+      })
+    );
+    log7.success(message.resolveSuccess(duration));
+  });
+};
+
+// src/use_cases/deploy_on_bucket.ts
+import { log as log5 } from "@clack/prompts";
+import { Duration as Duration5, Effect as Effect19 } from "effect";
+var DeployOnBucketUseCase = class extends Effect19.Service()(
+  "DeployOnBucketUseCase",
+  {
+    effect: Effect19.gen(function* () {
+      const frontService = yield* FrontFileObjectService;
+      const deploymentContext = yield* FrontDeploymentContext;
+      return {
+        run: genFn(function* () {
+          const shouldContinue = yield* genConfirmUi({
+            question: `Do you want to build and upload '${deploymentContext.buildOutputPath}' to bucket '${deploymentContext.bucketName}'?`,
+            initialValue: false
+          });
+          if (!shouldContinue) {
+            return yield* Effect19.interrupt;
+          }
+          const doesBucketExist = yield* frontService.doesFrontBucketExist();
+          if (!doesBucketExist) {
+            log5.error(`Bucket '${deploymentContext.bucketName}' should exist`);
+            return yield* Effect19.interrupt;
+          }
+          yield* genCommandUi({
+            command: deploymentContext.command,
+            message: {
+              resolveStart: () => "Building front",
+              resolveError: (error) => `Build failed: ${error.message}`,
+              resolveCancel: () => "Build canceled",
+              resolveEnd: (duration) => `Build finished in ${Duration5.toMillis(duration)}ms`
+            }
+          });
+          const configContext = yield* InternalConfigContext;
+          const frontBuildFileComponents = yield* frontService.listFrontBuildFileByRootComponents();
+          const hasOneFile = hasMinOneFile(frontBuildFileComponents);
+          if (!hasOneFile) {
+            log5.error("Front files should contain minimum one file");
+            return yield* Effect19.interrupt;
+          }
+          const { components: frontBuildFileComponentRests, indexHtml } = yield* pickIndexHtml(frontBuildFileComponents).pipe(
+            Effect19.catchTag(
+              "FileNotFoundError",
+              () => new FrontError({
+                message: "'index.html' file should exist in the front build folder",
+                config: configContext.front
+              })
+            )
+          );
+          yield* genTaskLogsUi({
+            title: "Uploading common files",
+            itemGroups: Array.from(frontBuildFileComponentRests),
+            processItem: frontService.uploadFrontFileToBucket,
+            message: {
+              resolveGroupTitle: (fileComponent) => `Uploading ${fileComponent.name}`,
+              resolveGroupSuccess: (fileComponent, duration) => `${fileComponent.name}: ${fileComponent.length} files uploaded in ${Duration5.toMillis(duration)}ms`,
+              resolveGroupError: (fileComponent, error) => `Upload ${fileComponent.name} failed: ${error.message}`,
+              resolveItem: (fileItem) => `File ${fileItem.relativePath} uploaded`,
+              resolveSuccess: (duration) => `Common files uploaded in ${Duration5.toMillis(duration)}ms`
+            },
+            subTaskConcurrency: configContext.bucket.upload.concurrency
+          });
+          yield* genLoaderUi({
+            process: () => frontService.uploadFrontFileToBucket(indexHtml),
+            message: {
+              resolveStart: () => "Uploading index.html",
+              resolveError: (error) => `Upload index.html failed: ${error.message}`,
+              resolveCancel: () => "Upload index.html canceled",
+              resolveEnd: (duration) => `Upload index.html finished in ${Duration5.toMillis(duration)}ms`
+            }
+          });
+        })
+      };
+    }),
+    dependencies: [FrontFileObjectService.Default]
+  }
+) {
+};
+
+// src/cli/deploy_on_bucket_command.ts
+import { cancel as cancel2, log as log6, outro as outro2 } from "@clack/prompts";
+import { command as command2 } from "cmd-ts";
+import { Effect as Effect20, Inspectable as Inspectable2, Layer as Layer5 } from "effect";
+var deployOnBucketCommand = command2({
+  name: "deploy",
+  description: "TODO",
+  args: {},
+  handler: function() {
+    const CommandContextLayer = Layer5.succeed(CliCommandContext, {
+      commandName: this.name
+    });
+    return Effect20.gen(function* () {
+      const { config } = yield* startCli();
+      const ConfigContextLayer = Layer5.succeed(InternalConfigContext, config);
+      const DeploymentContextLayer = makeFrontDeploymentContextLayer(config);
+      yield* Effect20.gen(function* () {
+        const useCase = yield* DeployOnBucketUseCase;
+        yield* runAndInterruptOnCtrlC(useCase.run());
+        outro2(`Deployment finished`);
+      }).pipe(
+        Effect20.provide(DeployOnBucketUseCase.Default),
+        Effect20.provide(ConfigContextLayer),
+        Effect20.provide(DeploymentContextLayer),
+        Effect20.onInterrupt(() => Effect20.sync(() => cancel2(`Deployment canceled`))),
+        Effect20.catchAll(
+          (error) => Effect20.gen(function* () {
+            log6.error(error.message);
+            log6.message(Inspectable2.toStringUnknown(error));
+            outro2(`Deployment aborted`);
+          })
+        )
+      );
+    }).pipe(Effect20.provide(CommandContextLayer));
+  }
+});
+
+// src/cli/cli.ts
+import { subcommands } from "cmd-ts";
+var cli = subcommands({
+  name: package_default.name,
+  cmds: { deploy: deployOnBucketCommand, create: createFrontBucketCommand }
+});
+
+// src/errors/internal.ts
+import { Data as Data10 } from "effect";
+var InternalError = class extends Data10.TaggedError("InternalError") {
+};
+
+// main.ts
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { run } from "cmd-ts";
+import { Effect as Effect21 } from "effect";
+var runCli = toEffect(run(cli, process.argv.slice(2)), InternalError, {}).pipe(
+  Effect21.flatMap(({ value }) => value)
+);
+NodeRuntime.runMain(runCli.pipe(Effect21.provide(NodeContext.layer)));