kuby-core 0.17.0 → 0.18.0

data/lib/kuby/docker/spec.rb

@@ -3,201 +3,221 @@
 module Kuby
   module Docker
     class Spec
-      extend T::Sig
+      # extend T::Sig
 
       DEFAULT_DISTRO = :debian
+      DEFAULT_APP_ROOT_PATH = '.'.freeze
 
-      sig { returns(Environment) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Environment) }
       attr_reader :environment
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :image_url_str
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :registry_index_url_str
 
-      sig { params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
+      attr_reader :app_root_path
+
+      # T::Sig::WithoutRuntime.sig { returns T.nilable(Kuby::Docker::AppImage) }
+      attr_reader :image
+
+      # T::Sig::WithoutRuntime.sig { params(environment: Kuby::Environment).void }
       def initialize(environment)
         @environment = environment
 
-        @credentials = T.let(@credentials, T.nilable(Credentials))
-        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
-        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
-        @bundler_phase = T.let(@bundler_phase, T.nilable(BundlerPhase))
-        @yarn_phase = T.let(@yarn_phase, T.nilable(YarnPhase))
-        @copy_phase = T.let(@copy_phase, T.nilable(CopyPhase))
-        @assets_phase = T.let(@assets_phase, T.nilable(AssetsPhase))
-        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverPhase))
+        # @credentials = T.let(@credentials, T.nilable(Credentials))
+        # @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
+        # @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
+        # @bundler_phase = T.let(@bundler_phase, T.nilable(BundlerPhase))
+        # @yarn_phase = T.let(@yarn_phase, T.nilable(YarnPhase))
+        # @copy_phase = T.let(@copy_phase, T.nilable(CopyPhase))
+        # @app_phase = T.let(@app_phase, T.nilable(AppPhase))
+        # @assets_phase = T.let(@assets_phase, T.nilable(AssetsPhase))
+        # @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverPhase))
 
-        @distro_name = T.let(@distro_name, T.nilable(Symbol))
-        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
-        @layer_stack = T.let(@layer_stack, T.nilable(Kuby::Docker::LayerStack))
+        # @distro_name = T.let(@distro_name, T.nilable(Symbol))
+        # @distro_spec = T.let(@distro_spec, T.nilable(Distro))
+        # @layer_stack = T.let(@layer_stack, T.nilable(Kuby::Docker::LayerStack))
 
-        @image_url_str = T.let(@image_url_str, T.nilable(String))
-        @registry_index_url_str = T.let(@registry_index_url_str, T.nilable(String))
-        @image = T.let(@image, T.nilable(Docker::AppImage))
+        # @image_url_str = T.let(@image_url_str, T.nilable(String))
+        # @registry_index_url_str = T.let(@registry_index_url_str, T.nilable(String))
+        # @image = T.let(@image, T.nilable(Docker::AppImage))
+
+        @app_root_path = DEFAULT_APP_ROOT_PATH
       end
 
-      sig { returns(Symbol) }
+      # T::Sig::WithoutRuntime.sig { returns(Symbol) }
       def distro_name
         @distro_name || DEFAULT_DISTRO
       end
 
-      sig { params(image_url: String).void }
+      # T::Sig::WithoutRuntime.sig { params(image_url: String).void }
       def base_image(image_url)
         setup_phase.base_image = image_url
       end
 
-      sig { params(dir: String).void }
+      # T::Sig::WithoutRuntime.sig { params(dir: String).void }
       def working_dir(dir)
         setup_phase.working_dir = dir
       end
 
-      sig { params(env: String).void }
+      # T::Sig::WithoutRuntime.sig { params(env: String).void }
       def rails_env(env)
         setup_phase.rails_env = env
       end
 
-      sig { params(version: String).void }
+      # T::Sig::WithoutRuntime.sig { params(version: String).void }
       def bundler_version(version)
         bundler_phase.version = version
       end
 
-      sig { params(path: String).void }
+      # T::Sig::WithoutRuntime.sig { params(path: String).void }
       def gemfile(path)
         bundler_phase.gemfile = path
       end
 
-      sig {
-        params(
-          package_name: Symbol,
-          version: T.nilable(String)
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig { params(path: String).void }
+      def app_root(path)
+        @app_root_path = path
+      end
+
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     package_name: Symbol,
+      #     version: T.nilable(String)
+      #   )
+      #   .void
+      # }
       def package(package_name, version = nil)
         package_phase.add(package_name, version)
       end
 
-      sig { params(distro_name: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(distro_name: Symbol).void }
       def distro(distro_name)
         @distro_name = distro_name
         @distro_spec = nil
       end
 
-      sig { params(path: String).void }
+      # T::Sig::WithoutRuntime.sig { params(path: String).void }
       def files(path)
         copy_phase << path
       end
 
-      sig { params(port: Integer).void }
+      # T::Sig::WithoutRuntime.sig { params(port: Integer).void }
       def port(port)
         webserver_phase.port = port
       end
 
-      sig { params(url: String).void }
+      # T::Sig::WithoutRuntime.sig { params(url: String).void }
       def image_url(url)
         @image_url_str = url
       end
 
-      sig { params(url: String).void }
+      # T::Sig::WithoutRuntime.sig { params(url: String).void }
       def registry_index_url(url)
         @registry_index_url_str = url
       end
 
-      sig {
-        params(
-          name: Symbol,
-          layer: T.nilable(Layer),
-          block: T.nilable(T.proc.params(df: Dockerfile).void)
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     name: Symbol,
+      #     layer: T.nilable(Layer),
+      #     block: T.nilable(T.proc.params(df: Kuby::Docker::Dockerfile).void)
+      #   )
+      #   .void
+      # }
       def use(name, layer = nil, &block)
         layer_stack.use(name, layer, &block)
       end
 
-      sig {
-        params(
-          name: Symbol,
-          layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
-          options: T::Hash[Symbol, T.untyped],
-          block: T.nilable(T.proc.params(df: Dockerfile).void)
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     name: Symbol,
+      #     layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
+      #     options: T::Hash[Symbol, T.untyped],
+      #     block: T.nilable(T.proc.params(df: Dockerfile).void)
+      #   )
+      #   .void
+      # }
       def insert(name, layer = nil, options = {}, &block)
         layer_stack.insert(name, layer, options, &block)
       end
 
-      sig { params(name: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol).void }
       def delete(name)
         layer_stack.delete(name)
       end
 
-      sig { params(name: Symbol).returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol).returns(T::Boolean) }
       def exists?(name)
         layer_stack.includes?(name)
       end
 
-      sig {
-        params(block: T.nilable(T.proc.void)).returns(Credentials)
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(block: T.nilable(T.proc.void)).returns(Kuby::Docker::Credentials)
+      # }
       def credentials(&block)
         @credentials ||= Credentials.new
         @credentials.instance_eval(&block) if block
         @credentials
       end
 
-      sig { returns(Docker::AppImage) }
-      def image
-        @image ||= begin
+      # T::Sig::WithoutRuntime.sig { void }
+      def after_configuration
+        @image = begin
           dockerfile = Dockerfile.new.tap do |df|
             layer_stack.each { |layer| layer.apply_to(df) }
           end
 
           Docker::AppImage.new(
-            dockerfile, T.must(image_url_str), credentials, registry_index_url_str
+            dockerfile, image_url_str, credentials, registry_index_url_str
           )
         end
       end
 
-      sig { returns(SetupPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::SetupPhase) }
       def setup_phase
         @setup_phase ||= SetupPhase.new(environment, self)
       end
 
-      sig { returns(PackagePhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::PackagePhase) }
       def package_phase
         @package_phase ||= PackagePhase.new(environment)
       end
 
-      sig { returns(BundlerPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::BundlerPhase) }
       def bundler_phase
         @bundler_phase ||= BundlerPhase.new(environment)
       end
 
-      sig { returns(YarnPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::YarnPhase) }
       def yarn_phase
         @yarn_phase ||= YarnPhase.new(environment)
       end
 
-      sig { returns(CopyPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::CopyPhase) }
       def copy_phase
         @copy_phase ||= CopyPhase.new(environment)
       end
 
-      sig { returns(AssetsPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::AppPhase) }
+      def app_phase
+        @app_phase ||= AppPhase.new(environment)
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::AssetsPhase) }
       def assets_phase
         @assets_phase ||= AssetsPhase.new(environment)
       end
 
-      sig { returns(WebserverPhase) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::WebserverPhase) }
       def webserver_phase
         @webserver_phase ||= WebserverPhase.new(environment)
       end
 
-      sig { returns(Distro) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Distro) }
       def distro_spec
         @distro_spec ||= if distro_klass = Kuby.distros[distro_name]
           distro_klass.new(self)
@@ -208,7 +228,7 @@ module Kuby
 
       private
 
-      sig { returns(Kuby::Docker::LayerStack) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::LayerStack) }
       def layer_stack
         @layer_stack ||= Kuby::Docker::LayerStack.new.tap do |stack|
           stack.use(:setup_phase, setup_phase)
@@ -216,6 +236,7 @@ module Kuby
           stack.use(:bundler_phase, bundler_phase)
           stack.use(:yarn_phase, yarn_phase)
           stack.use(:copy_phase, copy_phase)
+          stack.use(:app_phase, app_phase)
           stack.use(:assets_phase, assets_phase)
           stack.use(:webserver_phase, webserver_phase)
         end

data/lib/kuby/docker/timestamp_tag.rb

@@ -5,11 +5,11 @@ require 'time'
 module Kuby
   module Docker
     class TimestampTag
-      extend T::Sig
+      # extend T::Sig
 
-      FORMAT = T.let('%Y%m%d%H%M%S'.freeze, String)
+      FORMAT = '%Y%m%d%H%M%S'.freeze
 
-      sig { params(str: T.nilable(String)).returns(T.nilable(TimestampTag)) }
+      # T::Sig::WithoutRuntime.sig { params(str: T.nilable(String)).returns(T.nilable(Kuby::Docker::TimestampTag)) }
       def self.try_parse(str)
         return nil unless str
 
@@ -27,35 +27,40 @@ module Kuby
         new(time)
       end
 
-      sig { returns(Time) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::TimestampTag) }
+      def self.now
+        new(Time.now.utc)
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Time) }
       attr_reader :time
 
-      sig { params(time: Time).void }
+      # T::Sig::WithoutRuntime.sig { params(time: Time).void }
       def initialize(time)
-        @time = T.let(time, Time)
+        @time = time
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def to_s
         time.strftime(FORMAT)
       end
 
-      sig { params(other: TimestampTag).returns(T.nilable(Integer)) }
+      # T::Sig::WithoutRuntime.sig { params(other: Kuby::Docker::TimestampTag).returns(T.nilable(Integer)) }
       def <=>(other)
         time <=> other.time
       end
 
-      sig { params(other: TimestampTag).returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { params(other: Kuby::Docker::TimestampTag).returns(T::Boolean) }
       def ==(other)
         time == other.time
       end
 
-      sig { returns(Integer) }
+      # T::Sig::WithoutRuntime.sig { returns(Integer) }
       def hash
         time.hash
       end
 
-      sig { params(other: TimestampTag).returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { params(other: Kuby::Docker::TimestampTag).returns(T::Boolean) }
       def eql?(other)
         time == other.time
       end

data/lib/kuby/docker/timestamped_image.rb

@@ -5,54 +5,56 @@ require 'docker/remote'
 module Kuby
   module Docker
     class TimestampedImage < Image
-      extend T::Sig
-
-      sig {
-        params(
-          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
-          image_url: String,
-          credentials: Credentials,
-          registry_index_url_str: T.nilable(String),
-          main_tag: T.nilable(String),
-          alias_tags: T::Array[String]
-        ).void
-      }
+      # extend T::Sig
+
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     dockerfile: T.any(Dockerfile, T.proc.returns(Kuby::Docker::Dockerfile)),
+      #     image_url: String,
+      #     credentials: Kuby::Docker::Credentials,
+      #     registry_index_url_str: T.nilable(String),
+      #     main_tag: T.nilable(String),
+      #     alias_tags: T::Array[String]
+      #   ).void
+      # }
       def initialize(dockerfile, image_url, credentials, registry_index_url_str = nil, main_tag = nil, alias_tags = [])
-        @new_version = T.let(@new_version, T.nilable(Image))
-        @current_version = T.let(@current_version, T.nilable(Image))
-        @previous_version = T.let(@previous_version, T.nilable(Image))
+        # @new_version = T.let(@new_version, T.nilable(Image))
+        # @current_version = T.let(@current_version, T.nilable(Image))
+        # @previous_version = T.let(@previous_version, T.nilable(Image))
 
-        @remote_client = T.let(@remote_client, T.nilable(::Docker::Remote::Client))
-        @local = T.let(@local, T.nilable(LocalTags))
-        @remote = T.let(@remote, T.nilable(RemoteTags))
+        # @remote_client = T.let(@remote_client, T.nilable(::Docker::Remote::Client))
+        # @local = T.let(@local, T.nilable(LocalTags))
+        # @remote = T.let(@remote, T.nilable(RemoteTags))
 
         super
       end
 
-      sig { returns(Image) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def new_version
-        @new_version ||= create_new_version
+        @new_version ||= duplicate_with_tags(
+          TimestampTag.now.to_s, [Kuby::Docker::LATEST_TAG]
+        )
       end
 
-      sig { returns(Image) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def current_version
         @current_version ||= begin
           duplicate_with_tags(
             latest_timestamp_tag.to_s, [Kuby::Docker::LATEST_TAG]
           )
         rescue MissingTagError
-          create_new_version
+          new_version
         end
       end
 
-      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Kuby::Docker::Image) }
       def previous_version(current_tag = nil)
         @previous_version ||= duplicate_with_tags(
           previous_timestamp_tag(current_tag).to_s, []
         )
       end
 
-      sig { params(current_tag: T.nilable(String)).returns(TimestampTag) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Kuby::Docker::TimestampTag) }
       def previous_timestamp_tag(current_tag = nil)
         current_tag = TimestampTag.try_parse(current_tag || latest_timestamp_tag.to_s)
         raise MissingTagError, 'could not find current timestamp tag' unless current_tag
@@ -66,53 +68,70 @@ module Kuby
         idx ||= 0
         raise MissingTagError, 'could not find previous timestamp tag' unless idx > 0
 
-        T.must(all_tags[idx - 1])
+        all_tags[idx - 1]
       end
 
-      sig { returns(TimestampTag) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::TimestampTag) }
       def latest_timestamp_tag
         tag = timestamp_tags.sort.last
         raise MissingTagError, 'could not find latest timestamp tag' unless tag
         tag
       end
 
-      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String], context: T.nilable(String)).void }
-      def build(build_args = {}, docker_args = [], context: nil)
-        docker_cli.build(new_version, build_args: build_args, docker_args: docker_args, context: context)
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     build_args: T::Hash[String, String],
+      #     docker_args: T::Array[String],
+      #     context: T.nilable(String),
+      #     cache_from: T.nilable(String)
+      #   ).void
+      # }
+      def build(build_args = {}, docker_args = [], context: nil, cache_from: nil)
+        docker_cli.build(
+          self,
+          build_args: build_args,
+          docker_args: docker_args,
+          context: context,
+          cache_from: cache_from
+        )
       end
 
-      sig { params(tag: String).void }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
       def push(tag)
         docker_cli.push(image_url, tag)
       end
 
-      private
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
+      def pull(tag)
+        docker_cli.pull(image_url, tag)
+      end
 
-      sig { returns(Image) }
-      def create_new_version
-        duplicate_with_tags(
-          TimestampTag.new(Time.now).to_s, [Kuby::Docker::LATEST_TAG]
-        )
+      # T::Sig::WithoutRuntime.sig { returns(T::Boolean) }
+      def exists?
+        return false unless main_tag
+        timestamp_tags.include?(TimestampTag.try_parse(main_tag))
       end
 
-      sig { returns(::Docker::Remote::Client) }
+      private
+
+      # T::Sig::WithoutRuntime.sig { returns(::Docker::Remote::Client) }
       def remote_client
         @remote_client ||= ::Docker::Remote::Client.new(
           registry_index_host, image_repo, credentials.username, credentials.password,
         )
       end
 
-      sig { returns(T::Array[TimestampTag]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Kuby::Docker::TimestampTag]) }
       def timestamp_tags
         (local.timestamp_tags + remote.timestamp_tags).uniq
       end
 
-      sig { returns(LocalTags) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::LocalTags) }
       def local
         @local ||= LocalTags.new(docker_cli, image_url)
       end
 
-      sig { returns(RemoteTags) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::RemoteTags) }
       def remote
         @remote ||= RemoteTags.new(remote_client, registry_index_host)
       end

data/lib/kuby/docker/webserver_phase.rb

@@ -3,28 +3,28 @@
 module Kuby
   module Docker
     class WebserverPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
       class Webserver
-        extend T::Sig
-        extend T::Helpers
+        # extend T::Sig
+        # extend T::Helpers
 
-        abstract!
+        # abstract!
 
-        sig { returns(WebserverPhase) }
+        # T::Sig::WithoutRuntime.sig { returns(WebserverPhase) }
         attr_reader :phase
 
-        sig { params(phase: WebserverPhase).void }
+        # T::Sig::WithoutRuntime.sig { params(phase: WebserverPhase).void }
         def initialize(phase)
           @phase = phase
         end
 
-        sig { abstract.params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { abstract.params(dockerfile: Dockerfile).void }
         def apply_to(dockerfile); end
       end
 
       class Puma < Webserver
-        sig { override.params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
         def apply_to(dockerfile)
           dockerfile.cmd(
             'puma',
@@ -39,43 +39,43 @@ module Kuby
         end
       end
 
-      DEFAULT_PORT = T.let(8080, Integer)
-      WEBSERVER_MAP = T.let({ puma: Puma }.freeze, T::Hash[Symbol, T.class_of(Webserver)])
+      DEFAULT_PORT = 8080
+      WEBSERVER_MAP = { puma: Puma }.freeze
 
-      sig { params(port: Integer).void }
+      # T::Sig::WithoutRuntime.sig { params(port: Integer).returns(Integer) }
       attr_writer :port
 
-      sig { returns(T.nilable(Symbol)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(Symbol)) }
       attr_reader :webserver
 
-      sig { params(webserver: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(webserver: Symbol).returns(Symbol) }
       attr_writer :webserver
 
-      sig { override.params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { override.params(environment: Environment).void }
       def initialize(environment)
         super
 
-        @port = T.let(@port, T.nilable(Integer))
-        @webserver = T.let(@webserver, T.nilable(Symbol))
+        # @port = T.let(@port, T.nilable(Integer))
+        # @webserver = T.let(@webserver, T.nilable(Symbol))
       end
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         ws = webserver || default_webserver
-        ws_class = WEBSERVER_MAP[T.must(ws)]
+        ws_class = WEBSERVER_MAP[ws]
         raise "No webserver named #{ws}" unless ws_class
 
         ws_class.new(self).apply_to(dockerfile)
       end
 
-      sig { returns(Integer) }
+      # T::Sig::WithoutRuntime.sig { returns(Integer) }
       def port
         @port || DEFAULT_PORT
       end
 
       private
 
-      sig { returns(T.nilable(Symbol)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(Symbol)) }
       def default_webserver
         if Gem.loaded_specs.include?('puma')
           :puma

data/lib/kuby/docker/yarn_phase.rb

@@ -3,13 +3,37 @@
 module Kuby
   module Docker
     class YarnPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      sig { params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
-        # use character classes as a hack to only copy the files if they exist
-        dockerfile.copy('package.json yarn.loc[k] .npmr[c] .yarnr[c]', './')
-        dockerfile.run('yarn', 'install')
+        host_path = environment.docker.app_root_path
+
+        # if more than one file is passed to the COPY directive, the destination must be
+        # a directory and must end with a slash
+        container_path = ensure_trailing_delimiter(
+          File.join(
+            dockerfile.current_workdir,
+            environment.docker.app_root_path
+          )
+        )
+
+        if File.exist?(File.join(host_path, 'package.json'))
+          # use brackets as a hack to only copy the files if they exist
+          dockerfile.copy(
+            "#{host_path}/package.json #{host_path}/yarn.loc[k] #{host_path}/.npmr[c] #{host_path}/.yarnr[c]",
+            container_path
+          )
+
+          dockerfile.run('yarn', 'install', '--cwd', container_path)
+        end
+      end
+
+      private
+
+      # T::Sig::WithoutRuntime.sig { params(path: String).returns(String) }
+      def ensure_trailing_delimiter(path)
+        path.end_with?(File::SEPARATOR) ? path : File.join(path, '')
       end
     end
   end