);
    }

    private AfterExecutionResult executeWithCache(UnitOfWork work, C context, BuildCacheKey cacheKey) {
        CacheableWork cacheableWork = new CacheableWork(context.getIdentity().getUniqueId(), context.getWorkspace(), work);
        return Try.ofFailable(() -> work.isAllowedToLoadFromCache()
                ? tryLoadingFromCache(cacheKey, cacheableWork)

                        HashCode cacheKey = ((BuildCacheKeyInternal) key).getHashCodeInternal();
                        OriginWriter originWriter = originMetadataFactory.createWriter(entity.getIdentity(), entity.getType(), cacheKey, executionTime);
                        BuildCacheEntryPacker.PackResult packResult = packer.pack(entity, snapshots, fileOutputStream, originWriter);

            this.transform = transform;
            this.componentIdentifier = componentIdentifier;
        }

        @Override
        public String getIdentity() {
            return transformWorkspaceIdentity.getUniqueId();
        }

        @Override
        public Map<String, String> getFromAttributes() {

    @Override
    public WorkspaceResult execute(UnitOfWork work, C context) {
        ImmutableWorkspaceProvider workspaceProvider = ((ImmutableUnitOfWork) work).getWorkspaceProvider();
        String uniqueId = context.getIdentity().getUniqueId();
        ImmutableWorkspace workspace = workspaceProvider.getWorkspace(uniqueId);

        return loadImmutableWorkspaceIfExists(work, workspace)

    //                                                                        Assist Logic
    //                                                                        ============
    private static OptionalEntity<Role> getEntity(final CreateForm form) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new Role()).map(entity -> {

    //                                                                        Assist Logic
    //                                                                        ============
    public static OptionalEntity<WebAuthentication> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new WebAuthentication()).map(entity -> {

    //                                                                        Assist Logic
    //                                                                        ============

    private static OptionalEntity<AccessToken> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new AccessToken()).map(entity -> {

    //                                                                        Assist Logic
    //                                                                        ============

    public static OptionalEntity<LabelType> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new LabelType()).map(entity -> {

    //                                                                       Assist Logic
    //                                                                       ============
    private static OptionalEntity<User> getEntity(final CreateForm form) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new User()).map(entity -> {

    //                                                                        ============

    private static OptionalEntity<BoostDocumentRule> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new BoostDocumentRule()).map(entity -> {