From 3b9ef222b768f5ce0a89e35acb39dfd924110f2e Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Mon, 28 Oct 2019 22:58:42 +0100
Subject: [PATCH 01/21] Add lifecycle buttons

---
 src/main/frontend/package-lock.json             |  6 +++---
 src/main/frontend/package.json                  |  2 +-
 src/main/frontend/src/components/Properties.vue | 16 +++++++++++++++-
 3 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/main/frontend/package-lock.json b/src/main/frontend/package-lock.json
index fa834d75..2ea75d7e 100644
--- a/src/main/frontend/package-lock.json
+++ b/src/main/frontend/package-lock.json
@@ -951,9 +951,9 @@
       }
     },
     "@mdi/js": {
-      "version": "4.4.95",
-      "resolved": "https://registry.npmjs.org/@mdi/js/-/js-4.4.95.tgz",
-      "integrity": "sha512-wCrur/ICoHP7/NcNboBCdqR64gQnoUKxSRla4uOsGC61jMUnUeDMNfU7PrA/I0IzvotWc0ws2cCNVL7JsOPh2Q==",
+      "version": "4.5.95",
+      "resolved": "https://registry.npmjs.org/@mdi/js/-/js-4.5.95.tgz",
+      "integrity": "sha512-zQ6LqK/B61/ASwoR26AauCLfNc6u/SyTwsnWF0WLcSIh+oe+A7rQbioYT3eSsQch1gC+1Ejk8YDfD7gDk0FUXg==",
       "dev": true
     },
     "@mrmlnc/readdir-enhanced": {
diff --git a/src/main/frontend/package.json b/src/main/frontend/package.json
index f5e59c0b..4d6b573f 100644
--- a/src/main/frontend/package.json
+++ b/src/main/frontend/package.json
@@ -23,7 +23,7 @@
   "devDependencies": {
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.4.4",
     "@babel/plugin-proposal-optional-chaining": "^7.6.0",
-    "@mdi/js": "^4.4.95",
+    "@mdi/js": "^4.5.95",
     "@vue/cli-plugin-babel": "^3.4.0",
     "@vue/cli-plugin-eslint": "^3.4.0",
     "@vue/cli-service": "^3.8.0",
diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index dab6bc6a..9db5ab83 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -17,7 +17,11 @@
                 </v-tab-item>
             </v-tabs>
         </v-card-text>
-
+        <v-card-actions>
+            <v-btn outlined color="primary"><v-icon>{{icons.publish}}</v-icon>Publish</v-btn>
+            <v-btn outlined color="warning"><v-icon>{{icons.deprecate}}</v-icon>Deprecate</v-btn>
+            <v-btn outlined color="error"><v-icon>{{icons.delete}}</v-icon>Remove</v-btn>
+        </v-card-actions>
     </v-card>
 
 
@@ -25,9 +29,19 @@
 
 <script>
     import {mapFields} from 'vuex-map-fields';
+    import {mdiDelete, mdiLabel, mdiLabelOff} from '@mdi/js'
     import marked from 'marked'
 
     export default {
+        data: function () {
+            return {
+                icons: {
+                    publish: mdiLabel,
+                    delete: mdiDelete,
+                    deprecate: mdiLabelOff
+                }
+            }
+        },
         computed: {
             ...mapFields([
                 'schema',

From c60e27a95479a1e7a0acc5249571c85c353f15b9 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Mon, 28 Oct 2019 23:36:25 +0100
Subject: [PATCH 02/21] Add version state transition buttons

---
 .../frontend/src/api/SchemataRepository.js    | 19 ++++++-
 .../frontend/src/components/Properties.vue    | 55 ++++++++++++++++++-
 src/main/frontend/src/components/Versions.vue |  8 ++-
 src/main/frontend/src/store.js                | 11 ++--
 4 files changed, 82 insertions(+), 11 deletions(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 58916e36..174e3e35 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -8,7 +8,8 @@ const resources = {
     categories: () => '/schema/categories',
     scopes: () => '/schema/scopes',
     schemata: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}/schemas`,
-    versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`
+    versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`,
+    versionStatus: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/status`
 }
 
 function ensure(response, status) {
@@ -128,4 +129,20 @@ export default {
             .then(ensureCreated)
             .then(response => response.data)
     },
+    setSchemaVersionStatus(
+        organization, unit, context, schema, version, status) {
+        let config = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'text'
+        };
+        return Repository.patch(
+            resources.versionStatus(organization, unit, context, schema, version),
+            status,
+            config
+        )
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 }
\ No newline at end of file
diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index 9db5ab83..ac4a349d 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -18,9 +18,21 @@
             </v-tabs>
         </v-card-text>
         <v-card-actions>
-            <v-btn outlined color="primary"><v-icon>{{icons.publish}}</v-icon>Publish</v-btn>
-            <v-btn outlined color="warning"><v-icon>{{icons.deprecate}}</v-icon>Deprecate</v-btn>
-            <v-btn outlined color="error"><v-icon>{{icons.delete}}</v-icon>Remove</v-btn>
+            <v-btn outlined color="primary" @click="publish"
+                   :disabled="status !== 'Draft'">
+                <v-icon>{{icons.publish}}</v-icon>
+                Publish
+            </v-btn>
+            <v-btn outlined color="warning" @click="deprecate"
+                   :disabled="status !== 'Published' && status !== 'Draft'">
+                <v-icon>{{icons.deprecate}}</v-icon>
+                Deprecate
+            </v-btn>
+            <v-btn outlined color="error" @click="remove"
+                   :disabled="status !== 'Deprecated' && status !== 'Draft'">
+                <v-icon>{{icons.delete}}</v-icon>
+                Remove
+            </v-btn>
         </v-card-actions>
     </v-card>
 
@@ -31,6 +43,8 @@
     import {mapFields} from 'vuex-map-fields';
     import {mdiDelete, mdiLabel, mdiLabelOff} from '@mdi/js'
     import marked from 'marked'
+    import Repository from '@/api/SchemataRepository'
+
 
     export default {
         data: function () {
@@ -61,6 +75,41 @@
         methods: {
             compiledDescription: function () {
                 return marked(this.description)
+            },
+
+            publish() {
+                this._setStatus('Published')
+            },
+            deprecate() {
+                this._setStatus('Deprecated')
+            },
+            remove() {
+                this._setStatus('Removed')
+            },
+
+            _setStatus(status) {
+                let vm = this
+                Repository.setSchemaVersionStatus(
+                    this.version.organizationId,
+                    this.version.unitId,
+                    this.version.contextId,
+                    this.version.schemaId,
+                    this.version.schemaVersionId,
+                    status
+                )
+                    .then((response) => {
+
+                            vm.$store.commit('raiseNotification', {
+                                message: `Status for ${vm.schema.name} v${vm.version.currentVersion} set to ${status}.`,
+                                type: 'success'
+                            })
+                            vm.$store.commit('selectSchemaVersion', response.data)
+                        }
+                    )
+                    .catch(function (err) {
+                        let response = err.response ? err.response.data + ' - ' : ''
+                        vm.$store.commit('raiseError', {message: response + err})
+                    })
             }
         }
     }
diff --git a/src/main/frontend/src/components/Versions.vue b/src/main/frontend/src/components/Versions.vue
index 2f70c54a..cb787dea 100644
--- a/src/main/frontend/src/components/Versions.vue
+++ b/src/main/frontend/src/components/Versions.vue
@@ -26,7 +26,7 @@
 </template>
 
 <script>
-    import {mdiDelete, mdiPencil, mdiTag} from '@mdi/js'
+    import {mdiDelete, mdiLabel, mdiLabelOff, mdiPencil} from '@mdi/js'
     import Repository from '@/api/SchemataRepository'
     import {mapFields} from 'vuex-map-fields';
 
@@ -76,13 +76,15 @@
                 if (!version) return '';
                 switch (version.status) {
                     case 'Published':
-                        return mdiTag
+                        return mdiLabel
                     case 'Draft':
                         return mdiPencil
+                    case 'Deprecated':
+                        return mdiLabelOff
                     case 'Removed':
                         return mdiDelete
                     default:
-                        return 'insert_drive_file'
+                        return ''
                 }
             }
         }
diff --git a/src/main/frontend/src/store.js b/src/main/frontend/src/store.js
index 567667d6..a995962b 100644
--- a/src/main/frontend/src/store.js
+++ b/src/main/frontend/src/store.js
@@ -1,6 +1,6 @@
 import Vue from 'vue'
 import Vuex from 'vuex'
-import { getField, updateField } from 'vuex-map-fields';
+import {getField, updateField} from 'vuex-map-fields';
 
 Vue.use(Vuex)
 
@@ -37,12 +37,15 @@ export default new Vuex.Store({
       state.notification = undefined
     },
 
-    selectSchema (state, selected) {
-      state.schema = selected
-    },
     selectOrganization (state, selected) {
       state.organization = selected
     },
+    selectSchema(state, selected) {
+      state.schema = selected
+    },
+    selectSchemaVersion (state, selected) {
+      state.version = selected
+    },
 
   },
   actions: {

From af23a16ea2355877f30e3eda0c3620eb1a553d38 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 14:34:38 +0100
Subject: [PATCH 03/21] Update test to use ObjectStore API w/ StateSources

---
 .../persistence/SchemataObjectStoreTest.java  | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java b/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
index 93b70490..c950981c 100644
--- a/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
+++ b/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
@@ -23,6 +23,7 @@
 import io.vlingo.symbio.store.object.MapQueryExpression;
 import io.vlingo.symbio.store.object.ObjectStore;
 import io.vlingo.symbio.store.object.ObjectStoreReader.QueryMode;
+import io.vlingo.symbio.store.object.StateSources;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -57,7 +58,7 @@ public void testThatObjectStoreInsertsOrganizationStateAndQuerys() {
                 .from(orgId)
                 .defineWith(orgName, "Organization Vlingo");
 
-        objectStore.persist(organizationState, persistInterest);
+        objectStore.persist(StateSources.of(organizationState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -89,7 +90,7 @@ public void testThatObjectStoreInsertsOrganizationStateAndQuerys() {
         final OrganizationState updatedOrganizationState =
                 insertedOrganizationState.withDescription("Organization Vlingo V2");
 
-        objectStore.persist(updatedOrganizationState, persistInterest);
+        objectStore.persist(StateSources.of(updatedOrganizationState), persistInterest);
         querySelect(queryInterest, OrganizationState.class, "TBL_ORGANIZATIONS", "organizationId", orgId.value);
 
 
@@ -112,7 +113,7 @@ public void testThatObjectStoreInsertsUnitStateAndQuerys() {
                 .from(unitId)
                 .defineWith("Vlingo", "Unit Vlingo");
 
-        objectStore.persist(unitState, persistInterest);
+        objectStore.persist(StateSources.of(unitState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -130,7 +131,7 @@ public void testThatObjectStoreInsertsUnitStateAndQuerys() {
         final UnitState updatedUnitState =
                 insertedUnitState.defineWith("VlingoV2", "Unit Vlingo V2");
 
-        objectStore.persist(updatedUnitState, persistInterest);
+        objectStore.persist(StateSources.of(updatedUnitState), persistInterest);
         querySelect(queryInterest, UnitState.class, "TBL_UNITS", "unitId", unitId.value);
 
         queryInterest.until.completes();
@@ -152,7 +153,7 @@ public void testThatObjectStoreInsertsContextStateAndQuerys() {
                 .from(contextId)
                 .defineWith("io.vlingo", "Context Vlingo");
 
-        objectStore.persist(contextState, persistInterest);
+        objectStore.persist(StateSources.of(contextState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -170,7 +171,7 @@ public void testThatObjectStoreInsertsContextStateAndQuerys() {
         final ContextState updatedContextState =
                 insertedContextState.defineWith("io.vlingoV2", "Context Vlingo V2");
 
-        objectStore.persist(updatedContextState, persistInterest);
+        objectStore.persist(StateSources.of(updatedContextState), persistInterest);
         querySelect(queryInterest, ContextState.class, "TBL_CONTEXTS", "contextId", contextId.value);
 
         queryInterest.until.completes();
@@ -195,7 +196,7 @@ public void testThatObjectStoreInsertsSchemaStateAndQuerys() {
         final SchemaState schemaState = SchemaState.from(schemaId)
                 .defineWith(Category.Event, Scope.Public, "Vlingo", "Schema Vlingo");
 
-        objectStore.persist(schemaState, persistInterest);
+        objectStore.persist(StateSources.of(schemaState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -219,7 +220,7 @@ public void testThatObjectStoreInsertsSchemaStateAndQuerys() {
         final SchemaState updatedSchemaState =
                 insertedSchemaState.defineWith(Category.Document, Scope.Public, "VlingoV2", "Schema Vlingo V2");
 
-        objectStore.persist(updatedSchemaState, persistInterest);
+        objectStore.persist(StateSources.of(updatedSchemaState), persistInterest);
         querySelect(queryInterest, SchemaState.class, "TBL_SCHEMAS", "schemaId", schemaId.value);
 
         queryInterest.until.completes();
@@ -246,7 +247,7 @@ public void testThatObjectStoreInsertsSchemaVersionStateAndQuerys() {
                         Version.of("0.0.0"),
                         Version.of("1.0.0"));
 
-        objectStore.persist(schemaVersionState, persistInterest);
+        objectStore.persist(StateSources.of(schemaVersionState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -264,7 +265,7 @@ public void testThatObjectStoreInsertsSchemaVersionStateAndQuerys() {
         final SchemaVersionState updatedSchemaVersionState =
                 insertedSchemaVersionState.defineWith("Schema Version Vlingo V2", Specification.of("SpecV2"), Version.of("1.0.0"), Version.of("2.0.0"));
 
-        objectStore.persist(updatedSchemaVersionState, persistInterest);
+        objectStore.persist(StateSources.of(updatedSchemaVersionState), persistInterest);
         querySelect(queryInterest, SchemaVersionState.class, "TBL_SCHEMAVERSIONS", "schemaVersionId", schemaVersionId.value);
 
         queryInterest.until.completes();

From b5f12edde1fed6501c5beadcddab71d31f752d85 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 14:37:40 +0100
Subject: [PATCH 04/21] Call status update with correct view model value

---
 src/main/frontend/src/components/Properties.vue | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index 3bb2e9e4..a344f76d 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -121,8 +121,7 @@
                     this.version.contextId,
                     this.version.schemaId,
                     this.version.schemaVersionId,
-                    this.currentSpecification
-                )
+                    status)
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,

From 9f4d3dbf561f31f6ef0844ff08a1a77270c3b311 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 18:44:43 +0100
Subject: [PATCH 05/21] Return 409 if version status cannot be updated

---
 .../resource/SchemaVersionResource.java       | 289 ++++++-------
 .../resource/SchemaVersionResourceTest.java   | 407 ++++++++++--------
 2 files changed, 359 insertions(+), 337 deletions(-)

diff --git a/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java b/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
index 60bf32b4..81d7a4d4 100644
--- a/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
+++ b/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
@@ -7,22 +7,6 @@
 
 package io.vlingo.schemata.resource;
 
-import static io.vlingo.common.serialization.JsonSerialization.serialized;
-import static io.vlingo.http.Response.Status.BadRequest;
-import static io.vlingo.http.Response.Status.Conflict;
-import static io.vlingo.http.Response.Status.Created;
-import static io.vlingo.http.Response.Status.Ok;
-import static io.vlingo.http.ResponseHeader.ContentType;
-import static io.vlingo.http.ResponseHeader.Location;
-import static io.vlingo.http.ResponseHeader.of;
-import static io.vlingo.http.resource.ResourceBuilder.get;
-import static io.vlingo.http.resource.ResourceBuilder.patch;
-import static io.vlingo.http.resource.ResourceBuilder.post;
-import static io.vlingo.http.resource.ResourceBuilder.resource;
-import static io.vlingo.schemata.Schemata.NoId;
-import static io.vlingo.schemata.Schemata.SchemaVersionsPath;
-import static io.vlingo.schemata.Schemata.StageName;
-
 import io.vlingo.actors.Stage;
 import io.vlingo.actors.World;
 import io.vlingo.common.Completes;
@@ -40,142 +24,155 @@
 import io.vlingo.schemata.query.Queries;
 import io.vlingo.schemata.resource.data.SchemaVersionData;
 
+import static io.vlingo.common.serialization.JsonSerialization.serialized;
+import static io.vlingo.http.Response.Status.*;
+import static io.vlingo.http.ResponseHeader.*;
+import static io.vlingo.http.resource.ResourceBuilder.*;
+import static io.vlingo.schemata.Schemata.*;
+
 public class SchemaVersionResource extends ResourceHandler {
-  private final SchemaVersionCommands commands;
-  private final Stage stage;
-
-  public SchemaVersionResource(final World world) {
-    this.stage = world.stageNamed(StageName);
-    this.commands = new SchemaVersionCommands(this.stage, 10);
-  }
-
-  public Completes<Response> defineWith(
-          final String organizationId,
-          final String unitId,
-          final String contextId,
-          final String schemaId,
-          final SchemaVersionData data) {
-
-    if (!data.hasSpecification()) {
-      return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+    private final SchemaVersionCommands commands;
+    private final Stage stage;
+
+    public SchemaVersionResource(final World world) {
+        this.stage = world.stageNamed(StageName);
+        this.commands = new SchemaVersionCommands(this.stage, 10);
+    }
+
+    public Completes<Response> defineWith(
+            final String organizationId,
+            final String unitId,
+            final String contextId,
+            final String schemaId,
+            final SchemaVersionData data) {
+
+        if (!data.hasSpecification()) {
+            return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+        }
+        if (!data.validVersions()) {
+            return Completes.withSuccess(Response.of(BadRequest, "Conflicting versions"));
+        }
+
+        return SchemaVersion.with(stage, SchemaId.existing(organizationId, unitId, contextId, schemaId), Specification.of(data.specification), data.description, Version.of(data.previousVersion), Version.of(data.currentVersion))
+                .andThenTo(3000, state -> {
+                    final String location = schemaVersionLocation(state.schemaVersionId);
+                    final Headers<ResponseHeader> headers = Headers.of(
+                            of(Location, location),
+                            of(ContentType, "application/json; charset=UTF-8")
+                    );
+                    final String serialized = serialized(SchemaVersionData.from(state));
+
+                    return Completes.withSuccess(Response.of(Created, headers, serialized));
+                })
+                .otherwise(response -> Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, NoId, data.specification, data.description, "Draft", data.previousVersion, data.currentVersion))));
+    }
+
+    public Completes<Response> describeAs(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String description) {
+        return commands
+                .describeAs(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), description).answer()
+                .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
+    }
+
+    public Completes<Response> specifyWith(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String specification) {
+        if (!SchemaVersionData.hasSpecification(specification)) {
+            return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+        }
+
+        return commands
+                .specifyWith(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), Specification.of(specification)).answer()
+                .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
     }
-    if (!data.validVersions()) {
-      return Completes.withSuccess(Response.of(BadRequest, "Conflicting versions"));
+
+    public Completes<Response> statusOf(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String status) {
+        final SchemaVersionId id = SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId);
+        final Completes<SchemaVersionState> answer;
+
+        switch (status.toLowerCase()) {
+            case "published":
+                answer = commands.publish(id).answer();
+                break;
+            case "deprecated":
+                answer = commands.deprecate(id).answer();
+                break;
+            case "removed":
+                answer = commands.remove(id).answer();
+                break;
+            default:
+                return Completes.withSuccess(Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, schemaVersionId, "", "", status, "", ""))));
+        }
+
+        return answer.andThenTo(state -> {
+            if (status.toLowerCase().equals(state.status.value.toLowerCase()))
+                return Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state))));
+            else
+                return Completes.withSuccess(Response.of(
+                        Conflict,
+                        "Status '" + status + "' cannot be reached from current status '" + state.status.value + "'"));
+        });
+    }
+
+    public Completes<Response> querySchemaVersions(final String organizationId, final String unitId, final String contextId, final String schemaId) {
+        return Queries.forSchemaVersions()
+                .schemaVersions(organizationId, unitId, contextId, schemaId)
+                .andThenTo(schemaVersions -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersions))));
     }
 
-    return SchemaVersion.with(stage, SchemaId.existing(organizationId, unitId, contextId, schemaId), Specification.of(data.specification), data.description, Version.of(data.previousVersion), Version.of(data.currentVersion))
-            .andThenTo(3000, state -> {
-                final String location = schemaVersionLocation(state.schemaVersionId);
-                final Headers<ResponseHeader> headers = Headers.of(
-                        of(Location, location),
-                        of(ContentType, "application/json; charset=UTF-8")
-                );
-                final String serialized = serialized(SchemaVersionData.from(state));
-
-                return Completes.withSuccess(Response.of(Created, headers, serialized));
-              })
-            .otherwise(response -> Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, NoId, data.specification, data.description, "Draft", data.previousVersion, data.currentVersion))));
-  }
-
-  public Completes<Response> describeAs(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String description) {
-    return commands
-              .describeAs(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), description).answer()
-              .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> specifyWith(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String specification) {
-    if (!SchemaVersionData.hasSpecification(specification)) {
-      return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+    public Completes<Response> querySchemaVersion(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId) {
+        return Queries.forSchemaVersions()
+                .schemaVersion(organizationId, unitId, contextId, schemaId, schemaVersionId)
+                .andThenTo(schemaVersion -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersion))));
     }
 
-    return commands
-            .specifyWith(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), Specification.of(specification)).answer()
-            .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> statusOf(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String status) {
-    final SchemaVersionId id = SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId);
-    final Completes<SchemaVersionState> answer;
-
-    switch (status.toLowerCase()) {
-    case "published":
-      answer = commands.publish(id).answer();
-      break;
-    case "deprecated":
-      answer = commands.deprecate(id).answer();
-      break;
-    case "removed":
-      answer = commands.remove(id).answer();
-      break;
-    default:
-      return Completes.withSuccess(Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, schemaVersionId, "", "", status, "", ""))));
+    @Override
+    public Resource<?> routes() {
+        return resource("SchemaVersion Resource", 1,
+                post("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(SchemaVersionData.class)
+                        .handle(this::defineWith),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/description")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::describeAs),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/specification")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::specifyWith),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/status")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::statusOf),
+                get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .handle(this::querySchemaVersions),
+                get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .handle(this::querySchemaVersion));
     }
 
-    return answer.andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> querySchemaVersions(final String organizationId, final String unitId, final String contextId, final String schemaId) {
-    return Queries.forSchemaVersions()
-            .schemaVersions(organizationId, unitId, contextId, schemaId)
-            .andThenTo(schemaVersions -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersions))));
-  }
-
-  public Completes<Response> querySchemaVersion(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId) {
-    return Queries.forSchemaVersions()
-            .schemaVersion(organizationId, unitId, contextId, schemaId, schemaVersionId)
-            .andThenTo(schemaVersion -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersion))));
-  }
-
-  @Override
-  public Resource<?> routes() {
-    return resource("SchemaVersion Resource", 1,
-      post("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(SchemaVersionData.class)
-        .handle(this::defineWith),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/description")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::describeAs),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/specification")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::specifyWith),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/status")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::statusOf),
-      get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .handle(this::querySchemaVersions),
-      get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .handle(this::querySchemaVersion));
-  }
-
-  private String schemaVersionLocation(final SchemaVersionId schemaVersionId) {
-    return String.format(SchemaVersionsPath, schemaVersionId.organizationId().value, schemaVersionId.unitId().value, schemaVersionId.contextId().value, schemaVersionId.schemaId.value, schemaVersionId.value);
-  }
+    private String schemaVersionLocation(final SchemaVersionId schemaVersionId) {
+        return String.format(SchemaVersionsPath, schemaVersionId.organizationId().value, schemaVersionId.unitId().value, schemaVersionId.contextId().value, schemaVersionId.schemaId.value, schemaVersionId.value);
+    }
 }
diff --git a/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java b/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
index 6ea3d0c7..83d76079 100644
--- a/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
+++ b/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
@@ -7,201 +7,226 @@
 
 package io.vlingo.schemata.resource;
 
-import static io.vlingo.http.Response.Status.BadRequest;
-import static io.vlingo.http.Response.Status.Created;
-import static io.vlingo.http.ResponseHeader.Location;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
 import io.vlingo.common.serialization.JsonSerialization;
 import io.vlingo.http.Response;
+import io.vlingo.schemata.model.Id;
 import io.vlingo.schemata.model.SchemaVersion.Status;
 import io.vlingo.schemata.resource.data.SchemaVersionData;
+import org.junit.Test;
+
+import static io.vlingo.http.Response.Status.BadRequest;
+import static io.vlingo.http.Response.Status.Created;
+import static io.vlingo.http.ResponseHeader.Location;
+import static org.junit.Assert.*;
 
 public class SchemaVersionResourceTest extends ResourceTest {
-  private static final String OrgId = "O123";
-  private static final String UnitId = "U456";
-  private static final String ContextId = "C789";
-  private static final String SchemaId = "S135";
-  private static final String SchemaVersionDescription = "Test context.";
-  private static final String SchemaVersionSpecification = "{ spec = \"spec\" ";
-  private static final String SchemaVersionStatus = "Draft";
-  private static final String SchemaVersionVersion000 = "0.0.0";
-  private static final String SchemaVersionVersion100 = "1.0.0";
-  private static final String SchemaVersionVersion101 = "1.0.1";
-  private static final String SchemaVersionVersion300 = "3.0.0";
-
-  @Test
-  public void testThatSchemaVersionIsDefined() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    assertNotNull(response1.headers.headerOf(Location));
-    final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    assertEquals(SchemaVersionStatus, data.status);
-    assertEquals(SchemaVersionSpecification, data.specification);
-    assertEquals(SchemaVersionDescription, data.description);
-    assertEquals(SchemaVersionVersion100, data.currentVersion);
-  }
-
-  @Test
-  public void testThatSchemaVersionMinorUpgradeIsDefined() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion101);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    assertNotNull(response1.headers.headerOf(Location));
-    final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    assertEquals(SchemaVersionStatus, data.status);
-    assertEquals(SchemaVersionSpecification, data.specification);
-    assertEquals(SchemaVersionDescription, data.description);
-    assertEquals(SchemaVersionVersion101, data.currentVersion);
-  }
-
-  @Test
-  public void testSchemaVersionDescribedAs() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.describeAs(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, SchemaVersionDescription + 1).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.description, data2.description);
-    assertEquals((SchemaVersionDescription + 1), data2.description);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsPublished() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Published.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsDeprecated() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Deprecated.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsNotDeprecated() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    assertEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertEquals(data1.status, data2.status);
-    assertNotEquals(Status.Deprecated.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsRemoved() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Removed.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsNotRemoved() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(Status.Removed.name(), data2.status);
-  }
-
-  @Test
-  public void testFailDefineWithNullSpecification() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(null, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("missing"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithEmptySpecification() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just("", SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("missing"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithZeroVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion000);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithHighLowVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion000);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithGappedVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion300);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
+    private static final String OrgId = "O123";
+    private static final String UnitId = "U456";
+    private static final String ContextId = "C789";
+    private static final String SchemaId = "S135";
+    private static final String SchemaVersionDescription = "Test context.";
+    private static final String SchemaVersionSpecification = "{ spec = \"spec\" ";
+    private static final String SchemaVersionStatus = "Draft";
+    private static final String SchemaVersionVersion000 = "0.0.0";
+    private static final String SchemaVersionVersion100 = "1.0.0";
+    private static final String SchemaVersionVersion101 = "1.0.1";
+    private static final String SchemaVersionVersion300 = "3.0.0";
+
+    @Test
+    public void testThatSchemaVersionIsDefined() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        assertNotNull(response1.headers.headerOf(Location));
+        final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        assertEquals(SchemaVersionStatus, data.status);
+        assertEquals(SchemaVersionSpecification, data.specification);
+        assertEquals(SchemaVersionDescription, data.description);
+        assertEquals(SchemaVersionVersion100, data.currentVersion);
+    }
+
+    @Test
+    public void testThatSchemaVersionMinorUpgradeIsDefined() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion101);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        assertNotNull(response1.headers.headerOf(Location));
+        final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        assertEquals(SchemaVersionStatus, data.status);
+        assertEquals(SchemaVersionSpecification, data.specification);
+        assertEquals(SchemaVersionDescription, data.description);
+        assertEquals(SchemaVersionVersion101, data.currentVersion);
+    }
+
+    @Test
+    public void testSchemaVersionDescribedAs() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        final Response response2 = resource.describeAs(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, SchemaVersionDescription + 1).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.description, data2.description);
+        assertEquals((SchemaVersionDescription + 1), data2.description);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsPublished() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Published.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsDeprecated() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Deprecated.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsNotDeprecated() {
+        Id.OrganizationId orgId = Id.OrganizationId.unique();
+        Id.UnitId unitId = Id.UnitId.uniqueFor(orgId);
+        Id.ContextId contextId = Id.ContextId.uniqueFor(unitId);
+        Id.SchemaId schemaId = Id.SchemaId.uniqueFor(contextId);
+
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(
+                orgId.value, unitId.value, contextId.value, schemaId.value, defineData)
+                .await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        assertEquals(Response.Status.Conflict, response2.status);
+        assertTrue(response2.entity.content().contains("Status 'Deprecated' cannot be reached from current status"));
+
+        Response responseAfterTriedUpdate =
+                resource.querySchemaVersion(orgId.value, unitId.value, contextId.value, schemaId.value, data1.schemaVersionId)
+                .await();
+
+        final SchemaVersionData data2 =
+                JsonSerialization.deserialized(responseAfterTriedUpdate.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertEquals(data1.status, data2.status);
+        assertNotEquals(Status.Deprecated.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsRemoved() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Removed.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsNotRemoved() {
+        Id.OrganizationId orgId = Id.OrganizationId.unique();
+        Id.UnitId unitId = Id.UnitId.uniqueFor(orgId);
+        Id.ContextId contextId = Id.ContextId.uniqueFor(unitId);
+        Id.SchemaId schemaId = Id.SchemaId.uniqueFor(contextId);
+
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 =
+                resource.defineWith(orgId.value, unitId.value, contextId.value, schemaId.value, defineData)
+                        .await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
+        assertEquals(Response.Status.Conflict, response2.status);
+
+        Response responseAfterTriedUpdate =
+                resource.querySchemaVersion(orgId.value, unitId.value, contextId.value, schemaId.value, data1.schemaVersionId)
+                        .await();
+
+        final SchemaVersionData data2 =
+                JsonSerialization.deserialized(responseAfterTriedUpdate.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(Status.Removed.name(), data2.status);
+    }
+
+    @Test
+    public void testFailDefineWithNullSpecification() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(null, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("missing"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithEmptySpecification() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just("", SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("missing"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithZeroVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion000);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithHighLowVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion000);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithGappedVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion300);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
 }

From 45392ff8e8d348301ea05dec0e95adff3858f2ef Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 19:03:07 +0100
Subject: [PATCH 06/21] Make parent indices non-unique, otherwise an entity
 could not have more than one children e.g. a unit could have only one context

---
 .../infra/persistence/HSQLDBSchemataObjectStore.java      | 8 ++++----
 .../infra/persistence/PostgresSchemataObjectStore.java    | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java b/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
index a79718cc..746a7d84 100644
--- a/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
+++ b/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
@@ -38,7 +38,7 @@ protected void createUnitStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_ALL_INDEX ON TBL_UNITS (organizationId, unitId)");
       jdbi.handle().execute("ALTER TABLE TBL_UNITS ADD CONSTRAINT IF NOT EXISTS UNIT_ALL_UNIQUE UNIQUE (organizationId, name)");
   }
@@ -56,7 +56,7 @@ protected void createContextStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_ALL_INDEX ON TBL_CONTEXTS (organizationId, unitId, contextId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_CONTEXTS ADD CONSTRAINT IF NOT EXISTS CONTEXT_ALL_UNIQUE UNIQUE (organizationId, unitId, namespace)");
@@ -78,7 +78,7 @@ protected void createSchemaStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_ALL_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAS ADD CONSTRAINT IF NOT EXISTS SCHEMA_ALL_UNIQUE UNIQUE (organizationId, unitId, contextId, category, name)");
   }
@@ -117,7 +117,7 @@ protected void createSchemaVersionStateTable() {
 //              "UNIQUE (schemaId, currentVersion) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_ALL_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId, schemaVersionId)");
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAVERSIONS ADD CONSTRAINT IF NOT EXISTS SCHEMAVERSIION_ALL_UNIQUE UNIQUE (organizationId, unitId, contextId, schemaId, currentVersion)");
   }
diff --git a/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java b/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
index 6a83d623..948729ba 100644
--- a/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
+++ b/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
@@ -46,7 +46,7 @@ protected void createUnitStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_ALL_INDEX ON TBL_UNITS (organizationId, unitId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_UNITS DROP CONSTRAINT IF EXISTS UNIT_ALL_UNIQUE");
@@ -67,7 +67,7 @@ protected void createContextStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_ALL_INDEX ON TBL_CONTEXTS (organizationId, unitId, contextId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_CONTEXTS DROP CONSTRAINT IF EXISTS CONTEXT_ALL_UNIQUE");
@@ -91,7 +91,7 @@ protected void createSchemaStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_ALL_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId, schemaId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAS DROP CONSTRAINT IF EXISTS SCHEMA_ALL_UNIQUE");
@@ -132,7 +132,7 @@ protected void createSchemaVersionStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_ALL_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId, schemaVersionId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAVERSIONS DROP CONSTRAINT IF EXISTS SCHEMAVERSIION_ALL_UNIQUE");

From 486c3e32aa4e6a72071ef848fd6e1f97e840c1a8 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 19:27:18 +0100
Subject: [PATCH 07/21] Remove status from schema version creation, since all
 new versions are created as drafts

---
 src/main/frontend/src/api/SchemataRepository.js  |  3 +--
 .../frontend/src/components/SchemaVersion.vue    | 16 ++--------------
 .../cypress/integration/entity-creation.spec.ts  |  1 -
 3 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 36e4b45a..7aff2d1a 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -116,12 +116,11 @@ export default {
     },
     createSchemaVersion(
         organization, unit, context, schema,
-        specification, description, status, previousVersion, currentVersion) {
+        specification, description, previousVersion, currentVersion) {
         return Repository.post(resources.versions(organization, unit, context, schema),
             {
                 schemaVersionId: '',
                 specification: specification,
-                status: status,
                 previousVersion: previousVersion,
                 currentVersion: currentVersion,
                 description: description
diff --git a/src/main/frontend/src/components/SchemaVersion.vue b/src/main/frontend/src/components/SchemaVersion.vue
index e568002f..7462e297 100644
--- a/src/main/frontend/src/components/SchemaVersion.vue
+++ b/src/main/frontend/src/components/SchemaVersion.vue
@@ -66,7 +66,7 @@
                     </v-col>
 
 
-                    <v-col class="d-flex" cols="4">
+                    <v-col class="d-flex" cols="6">
                         <v-text-field
                                 v-model="previousVersion"
                                 :rules="[rules.notEmpty,rules.versionNumber]"
@@ -75,7 +75,7 @@
                         ></v-text-field>
                     </v-col>
 
-                    <v-col class="d-flex" cols="4">
+                    <v-col class="d-flex" cols="6">
                         <v-text-field
                                 v-model="currentVersion"
                                 :rules="[rules.notEmpty,rules.versionNumber]"
@@ -84,15 +84,6 @@
                         ></v-text-field>
                     </v-col>
 
-                    <v-col class="d-flex" cols="4">
-                        <v-autocomplete
-                                :items="statuses"
-                                :rules="[rules.notEmpty]"
-                                label="Status"
-                                v-model="status"
-                        ></v-autocomplete>
-                    </v-col>
-
                     <v-col cols="12">
                         <label class="v-label theme--light"
                                :class="{'primary--text':descriptionEditorActive}">Description</label>
@@ -149,10 +140,8 @@
                 schemaVersionId: '',
                 description: '',
                 specification: '',
-                status: 'Draft',
                 previousVersion: '',
                 currentVersion: '',
-                statuses: ['Draft', 'Published', 'Deprecated', 'Removed'],
 
                 descriptionEditorActive: false,
                 specificationEditorActive: false,
@@ -173,7 +162,6 @@
                     this.schema.schemaId,
                     this.specification,
                     this.description,
-                    this.status,
                     this.previousVersion,
                     this.currentVersion)
                     .then((created) => {
diff --git a/src/test/e2e/cypress/integration/entity-creation.spec.ts b/src/test/e2e/cypress/integration/entity-creation.spec.ts
index 7c7414fd..5378f92b 100644
--- a/src/test/e2e/cypress/integration/entity-creation.spec.ts
+++ b/src/test/e2e/cypress/integration/entity-creation.spec.ts
@@ -133,7 +133,6 @@ describe('Entity Creation Tests', function () {
         cy.fieldContent('SchemaVersionID').should('be.empty')
         cy.fillField('Previous Version', prevVersion)
         cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
         cy.fillEditor('#description-editor', faker.lorem.sentence())
         cy.fillEditor('#specification-editor', 'event SalutationHappened {\n' +
             '    type eventType')

From 6e892718d87209c2b623c904efffa5794e7c1ce1 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 19:29:55 +0100
Subject: [PATCH 08/21] Remove schema version status from e2e tests which
 create schema versions

---
 src/test/e2e/cypress/integration/browse-schemata.spec.ts | 1 -
 src/test/e2e/cypress/integration/validation.spec.ts      | 2 --
 2 files changed, 3 deletions(-)

diff --git a/src/test/e2e/cypress/integration/browse-schemata.spec.ts b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
index 9f653ca6..887f69d7 100644
--- a/src/test/e2e/cypress/integration/browse-schemata.spec.ts
+++ b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
@@ -65,7 +65,6 @@ describe('Schemata View Tests', function () {
         cy.selectOption('Schema', schema)
         cy.fillField('Previous Version', prevVersion)
         cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
         cy.fillEditor('#description-editor', desc)
         cy.fillEditor('#specification-editor', spec)
         cy.contains('button', 'Create').click()
diff --git a/src/test/e2e/cypress/integration/validation.spec.ts b/src/test/e2e/cypress/integration/validation.spec.ts
index d60835ce..eeed617b 100644
--- a/src/test/e2e/cypress/integration/validation.spec.ts
+++ b/src/test/e2e/cypress/integration/validation.spec.ts
@@ -72,8 +72,6 @@ describe('Form Validation Tests', function () {
         cy.contains('button', 'Create').should('be.disabled')
         cy.fillField('Current Version', currentVersion).get('.v-messages__message')
         cy.contains('button', 'Create').should('be.disabled')
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
-        cy.contains('button', 'Create').should('be.disabled')
         cy.fillEditor('#description-editor', faker.lorem.sentence())
         cy.contains('button', 'Create').should('be.disabled')
         cy.fillEditor('#specification-editor', 'event SalutationHappened {\n' +

From 497043d1012fb5ed60187e0382794b3b144639b2 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Tue, 29 Oct 2019 20:41:36 +0100
Subject: [PATCH 09/21] Move version selection and version list loading to vuex

---
 .../frontend/src/components/Properties.vue    |   5 +-
 src/main/frontend/src/components/Schemata.vue |   3 +-
 src/main/frontend/src/components/Versions.vue |  25 +---
 src/main/frontend/src/store.js                | 116 +++++++++++-------
 4 files changed, 79 insertions(+), 70 deletions(-)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index a344f76d..2195a132 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -48,7 +48,6 @@
         </v-card-actions>
     </v-card>
 
-
 </template>
 
 <script>
@@ -122,9 +121,10 @@
                     this.version.schemaId,
                     this.version.schemaVersionId,
                     status)
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response.data))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
-                                message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,
+                                message: `Status for ${vm.schema.name} updated.`,
                                 type: 'success'
                             })
                         }
@@ -145,6 +145,7 @@
                     this.version.schemaVersionId,
                     this.currentSpecification
                 )
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response.data))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,
diff --git a/src/main/frontend/src/components/Schemata.vue b/src/main/frontend/src/components/Schemata.vue
index fec6cbae..dc2bb279 100644
--- a/src/main/frontend/src/components/Schemata.vue
+++ b/src/main/frontend/src/components/Schemata.vue
@@ -80,7 +80,7 @@
                     return [this.$store.schema]
                 },
                 set(value) {
-                    this.$store.commit('selectSchema', value[0])
+                    this.$store.dispatch('selectSchema', value[0])
                 }
             },
 
@@ -100,6 +100,7 @@
                             vm.items.push(organization)
                         }
                     })
+                    .catch((err) => vm.$store.commit('raiseError', {message: err}))
             },
 
             async loadChildren(item) {
diff --git a/src/main/frontend/src/components/Versions.vue b/src/main/frontend/src/components/Versions.vue
index cb787dea..10983081 100644
--- a/src/main/frontend/src/components/Versions.vue
+++ b/src/main/frontend/src/components/Versions.vue
@@ -3,7 +3,7 @@
     <v-card height="45vh" id="schemata-versions">
         <v-list dense>
             <v-list-item-group v-model="selected" color="primary">
-                <v-list-item v-for="v in versions" :key="v.id" ripple>
+                <v-list-item v-for="v in schemaVersions" :key="v.id" ripple>
                     <v-list-item-action>
                         <v-tooltip right>
                             <template v-slot:activator="{ on }">
@@ -27,7 +27,6 @@
 
 <script>
     import {mdiDelete, mdiLabel, mdiLabelOff, mdiPencil} from '@mdi/js'
-    import Repository from '@/api/SchemataRepository'
     import {mapFields} from 'vuex-map-fields';
 
     export default {
@@ -44,33 +43,17 @@
                 if (value === undefined) {
                     this.version = undefined
                 } else {
-                    this.version = this.versions[value]
+                    this.version = this.schemaVersions[value]
                 }
             }
         },
         computed: {
             ...mapFields([
                 'schema',
-                'version'
+                'schemaVersions',
+                'version',
             ]),
         },
-        asyncComputed: {
-            async versions() {
-                if (!(this.schema)) {
-                    return
-                }
-
-                let vm = this
-                return await Repository.getVersions(
-                    this.schema.organizationId,
-                    this.schema.unitId,
-                    this.schema.contextId,
-                    this.schema.schemaId)
-                    .catch(function (err) {
-                        vm.$emit('vs-error', {status: 0, message: err})
-                    });
-            }
-        },
         methods: {
             icon(version) {
                 if (!version) return '';
diff --git a/src/main/frontend/src/store.js b/src/main/frontend/src/store.js
index a995962b..5f61716b 100644
--- a/src/main/frontend/src/store.js
+++ b/src/main/frontend/src/store.js
@@ -1,61 +1,85 @@
 import Vue from 'vue'
 import Vuex from 'vuex'
 import {getField, updateField} from 'vuex-map-fields';
+import Repository from "@/api/SchemataRepository";
 
 Vue.use(Vuex)
 
 export default new Vuex.Store({
-  strict: true,
-  state: {
-    error: undefined,
-    notification: undefined,
-    schemaVersion: undefined,
-    selected: undefined,
-    organization: undefined,
-    unit: undefined,
-    context: undefined,
-    category: undefined,
-    schema: undefined,
-    version: undefined
-  },
-  mutations: {
-    updateField,
-    raiseError (state, error) {
-      state.error = error
+    strict: true,
+    state: {
+        error: undefined,
+        notification: undefined,
+        schemaVersion: undefined,
+        selected: undefined,
+        organization: undefined,
+        unit: undefined,
+        context: undefined,
+        category: undefined,
+        schema: undefined,
+        schemaVersions: undefined,
+        version: undefined
     },
+    mutations: {
+        updateField,
+        raiseError(state, error) {
+            state.error = error
+        },
 
-    dismissError (state) {
-      state.error = undefined
-    },
+        dismissError(state) {
+            state.error = undefined
+        },
 
-    raiseNotification (state, notification) {
-      notification.type = notification.type || 'info'
-      state.notification = notification
-    },
+        raiseNotification(state, notification) {
+            notification.type = notification.type || 'info'
+            state.notification = notification
+        },
 
-    dismissNotification (state) {
-      state.notification = undefined
-    },
+        dismissNotification(state) {
+            state.notification = undefined
+        },
+
+        selectOrganization(state, selected) {
+            state.organization = selected
+        },
+        updateSchema(state, selected) {
+            state.schema = selected
+        },
+        updateSchemaVersion(state, selected) {
+            state.version = selected
+        },
+        updateSchemaVersions(state, versions) {
+            state.schemaVersions = versions
+        }
 
-    selectOrganization (state, selected) {
-      state.organization = selected
-    },
-    selectSchema(state, selected) {
-      state.schema = selected
-    },
-    selectSchemaVersion (state, selected) {
-      state.version = selected
     },
+    actions: {
+        selectSchema(context, selected) {
+            this.commit('updateSchema', selected)
+            this.dispatch('loadVersions')
+        },
+        selectSchemaVersion(context, selected) {
+            this.commit('updateSchemaVersion', selected)
+        },
+        loadVersions(context) {
+            if (!(context.state.schema)) {
+                return
+            }
 
-  },
-  actions: {
-
-  },
-  getters: {
-    getField,
-    organizationId: state => state.selected?.organizationId ?? undefined,
-    unitId: state => state.selected?.unitId ?? undefined,
-    contextId: state => state.selected?.contextId ?? undefined,
-    schemaId: state => state.selected?.schemaId ?? undefined,
-  }
+            Repository.getVersions(
+                context.state.schema.organizationId,
+                context.state.schema.unitId,
+                context.state.schema.contextId,
+                context.state.schema.schemaId)
+                .then(response => context.commit('updateSchemaVersions', response))
+                .catch(err => context.commit('raiseError', {status: 0, message: err}));
+        }
+    },
+    getters: {
+        getField,
+        organizationId: state => state.selected?.organizationId ?? undefined,
+        unitId: state => state.selected?.unitId ?? undefined,
+        contextId: state => state.selected?.contextId ?? undefined,
+        schemaId: state => state.selected?.schemaId ?? undefined,
+    }
 })

From 7248a00a56965db31d6b59420f81ac939447e257 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 09:47:37 +0100
Subject: [PATCH 10/21] Improve button & warning layout

---
 .../frontend/src/components/Properties.vue    | 69 ++++++++++---------
 1 file changed, 38 insertions(+), 31 deletions(-)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index 2195a132..c7e7e5fe 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -1,14 +1,17 @@
 <template>
     <v-card height="45vh" id="schemata-properties">
-        <v-card-text>
-            <v-alert v-if="status && status !== 'Published'" :value="true" type="warning" dense outlined>
-                Status <b>{{status}}</b>. Do not use in production.
-            </v-alert>
-            <v-tabs>
-                <v-tab>Specification</v-tab>
-                <v-tab>Description</v-tab>
 
-                <v-tab-item>
+        <v-tabs>
+            <v-tab>Specification</v-tab>
+            <v-tab>Description</v-tab>
+            <v-spacer></v-spacer>
+            <v-chip label color="warning" v-if="status && status !== 'Published'" class="mt-3 mr-3">
+                Status&nbsp;<b>{{status}}</b>. Do not use in production.
+            </v-chip>
+
+
+            <v-tab-item>
+                <v-card-text>
                     <editor
                             id="specification-editor"
                             v-model="currentSpecification"
@@ -17,35 +20,38 @@
                             height="200"
                             :options="editorOptions"
                     ></editor>
-                    <br>
+                </v-card-text>
+                <v-card-actions>
+                    <v-btn outlined color="primary" @click="publish"
+                           :disabled="status !== 'Draft'">
+                        <v-icon>{{icons.publish}}</v-icon>
+                        Publish
+                    </v-btn>
+                    <v-btn outlined color="warning" @click="deprecate"
+                           :disabled="status !== 'Published' && status !== 'Draft'">
+                        <v-icon>{{icons.deprecate}}</v-icon>
+                        Deprecate
+                    </v-btn>
+                    <v-btn outlined color="error" @click="remove"
+                           :disabled="status !== 'Deprecated' && status !== 'Draft'">
+                        <v-icon>{{icons.delete}}</v-icon>
+                        Remove
+                    </v-btn>
+                    <v-spacer></v-spacer>
                     <v-btn color="info"
                            :disabled="status !== 'Draft'"
                            @click="saveSpecification">Save
                     </v-btn>
-                </v-tab-item>
+                </v-card-actions>
+            </v-tab-item>
 
-                <v-tab-item>
+            <v-tab-item>
+                <v-card-text>
                     <div v-html="compiledDescription()"></div>
-                </v-tab-item>
-            </v-tabs>
-        </v-card-text>
-        <v-card-actions>
-            <v-btn outlined color="primary" @click="publish"
-                   :disabled="status !== 'Draft'">
-                <v-icon>{{icons.publish}}</v-icon>
-                Publish
-            </v-btn>
-            <v-btn outlined color="warning" @click="deprecate"
-                   :disabled="status !== 'Published' && status !== 'Draft'">
-                <v-icon>{{icons.deprecate}}</v-icon>
-                Deprecate
-            </v-btn>
-            <v-btn outlined color="error" @click="remove"
-                   :disabled="status !== 'Deprecated' && status !== 'Draft'">
-                <v-icon>{{icons.delete}}</v-icon>
-                Remove
-            </v-btn>
-        </v-card-actions>
+                </v-card-text>
+            </v-tab-item>
+        </v-tabs>
+
     </v-card>
 
 </template>
@@ -163,4 +169,5 @@
 </script>
 
 <style>
+
 </style>

From ea8d217aea37e8b029159fbfd23aceb1e051f4ad Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 09:58:38 +0100
Subject: [PATCH 11/21] Make selected schema version and version list reactive
 to display changes right away

---
 src/main/frontend/src/components/Properties.vue    | 5 +++--
 src/main/frontend/src/components/SchemaVersion.vue | 1 +
 src/main/frontend/src/store.js                     | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index c7e7e5fe..cac7e5e9 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -127,7 +127,8 @@
                     this.version.schemaId,
                     this.version.schemaVersionId,
                     status)
-                    .then(response => vm.$store.dispatch('selectSchemaVersion', response.data))
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response))
+                    .then(() => vm.$store.dispatch('loadVersions'))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Status for ${vm.schema.name} updated.`,
@@ -151,7 +152,7 @@
                     this.version.schemaVersionId,
                     this.currentSpecification
                 )
-                    .then(response => vm.$store.dispatch('selectSchemaVersion', response.data))
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,
diff --git a/src/main/frontend/src/components/SchemaVersion.vue b/src/main/frontend/src/components/SchemaVersion.vue
index 7462e297..3834a2cb 100644
--- a/src/main/frontend/src/components/SchemaVersion.vue
+++ b/src/main/frontend/src/components/SchemaVersion.vue
@@ -177,6 +177,7 @@
                                 message: `Schema v${vm.currentVersion} created.`,
                                 type: 'success'
                             })
+                            vm.$store.dispatch('loadVersions')
                         }
                     )
                     .catch(function (err) {
diff --git a/src/main/frontend/src/store.js b/src/main/frontend/src/store.js
index 5f61716b..d636d850 100644
--- a/src/main/frontend/src/store.js
+++ b/src/main/frontend/src/store.js
@@ -59,7 +59,7 @@ export default new Vuex.Store({
             this.dispatch('loadVersions')
         },
         selectSchemaVersion(context, selected) {
-            this.commit('updateSchemaVersion', selected)
+            context.commit('updateSchemaVersion', selected)
         },
         loadVersions(context) {
             if (!(context.state.schema)) {

From c4f83da6b0617375065d2e5317ba95a6a41cd0b9 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 10:12:08 +0100
Subject: [PATCH 12/21] Add E2E test for vstate transitions

---
 .../integration/browse-schemata.spec.ts       |  89 --------
 .../schema-version-maintenance.spec.ts        | 199 ++++++++++++++++++
 2 files changed, 199 insertions(+), 89 deletions(-)
 create mode 100644 src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts

diff --git a/src/test/e2e/cypress/integration/browse-schemata.spec.ts b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
index 887f69d7..a6a5c586 100644
--- a/src/test/e2e/cypress/integration/browse-schemata.spec.ts
+++ b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
@@ -92,93 +92,4 @@ describe('Schemata View Tests', function () {
         cy.contains('.v-window-item--active',desc)
 
     });
-
-    it('can update schema version specification', function () {
-        // Setup
-        let orgName = faker.company.companyName()
-        let unitName = faker.lorem.word()
-        let namespace = faker.internet.domainName()
-        let schema = faker.company.catchPhraseNoun()
-        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
-        let patchVersion = faker.random.number(9)
-        let prevVersion = majorMinorVersion + '.' + patchVersion
-        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
-        let spec = 'event SalutationHappened {\n' +
-            '    type eventType'
-        let desc = faker.lorem.sentence()
-
-        // Create Entities
-        cy.visit('/#/organization')
-        cy.fillField('Name', orgName)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Unit').click()
-
-        cy.selectOption('Organization', orgName)
-        cy.fillField('Name', unitName)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Context').click()
-
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.fillField('Namespace', namespace)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Schema').click()
-
-        cy.fieldContent('SchemaID').should('be.empty')
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.selectOption('Context', namespace)
-        cy.fillField('Name', schema)
-        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
-        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
-        cy.fillField('Description', faker.lorem.sentence())
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Schema Version').click()
-
-        cy.fieldContent('SchemaVersionID').should('be.empty')
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.selectOption('Context', namespace)
-        cy.selectOption('Schema', schema)
-        cy.fillField('Previous Version', prevVersion)
-        cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', 'Draft')
-        cy.fillEditor('#description-editor', desc)
-        cy.fillEditor('#specification-editor', spec)
-        cy.contains('button', 'Create').click()
-
-        // Assert visibility in treeview
-        // Filter for Org
-        cy.visit("/#/schemata")
-            .fillField('Search', orgName)
-
-        // Expand Tree
-        cy.contains('.v-treeview-node__label', orgName).click()
-        cy.contains('.v-treeview-node__label', unitName).click()
-        cy.contains('.v-treeview-node__label', namespace).click()
-        cy.contains('.v-treeview-node__label', schema).click()
-
-        // Select version
-        cy.contains('.v-list-item__title', currentVersion).click()
-
-        // Change spec
-        cy.fillEditor('#specification-editor', 'foo bar baz')
-        cy.contains('button', 'Save').click()
-
-        // Reload and navigate to schema version
-        cy.reload()
-        cy.visit("/#/schemata")
-            .fillField('Search', orgName)
-        cy.contains('.v-treeview-node__label', orgName).click()
-        cy.contains('.v-treeview-node__label', unitName).click()
-        cy.contains('.v-treeview-node__label', namespace).click()
-        cy.contains('.v-treeview-node__label', schema).click()
-        cy.contains('.v-list-item__title', currentVersion).click()
-
-        cy.editorContent('#specification-editor').should('contain','foo bar baz')
-    });
-
 });
\ No newline at end of file
diff --git a/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
new file mode 100644
index 00000000..05001ec0
--- /dev/null
+++ b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
@@ -0,0 +1,199 @@
+import * as faker from 'faker';
+
+describe('Schemata View Tests', function () {
+    before(() => {
+    });
+
+    after(() => {
+
+    });
+
+    beforeEach(() => {
+        cy.viewport(1280, 960)
+    });
+
+    it('can update schema version state', function () {
+        // Setup
+        let orgName = faker.company.companyName()
+        let unitName = faker.lorem.word()
+        let namespace = faker.internet.domainName()
+        let schema = faker.company.catchPhraseNoun()
+        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
+        let patchVersion = faker.random.number(9)
+        let prevVersion = majorMinorVersion + '.' + patchVersion
+        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
+        let spec = 'event SalutationHappened {\n' +
+            '    type eventType'
+        let desc = faker.lorem.sentence()
+
+        // Create Entities
+        cy.visit('/#/organization')
+        cy.fillField('Name', orgName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Unit').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.fillField('Name', unitName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Context').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.fillField('Namespace', namespace)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema').click()
+
+        cy.fieldContent('SchemaID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.fillField('Name', schema)
+        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
+        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
+        cy.fillField('Description', faker.lorem.sentence())
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema Version').click()
+
+        cy.fieldContent('SchemaVersionID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.selectOption('Schema', schema)
+        cy.fillField('Previous Version', prevVersion)
+        cy.fillField('Current Version', currentVersion)
+        cy.fillEditor('#description-editor', desc)
+        cy.fillEditor('#specification-editor', spec)
+        cy.contains('button', 'Create').click()
+
+        // Assert visibility in treeview
+        // Filter for Org
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+
+        // Expand Tree
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+
+        // Select version
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        // Assert all states reachable
+        cy.contains('button', 'Publish').should('be.enabled')
+        cy.contains('button', 'Deprecate').should('be.enabled')
+        cy.contains('button', 'Remove').should('be.enabled')
+        cy.get('.v-chip.warning')
+
+        //Publish
+        cy.contains('button', 'Publish').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.enabled')
+        cy.contains('button', 'Remove').should('be.disabled')
+
+        //Deprecate
+        cy.contains('button', 'Deprecate').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.disabled')
+        cy.contains('button', 'Remove').should('be.enabled')
+        cy.get('.v-chip.warning')
+
+        //Remove
+        cy.contains('button', 'Remove').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.disabled')
+        cy.contains('button', 'Remove').should('be.disabled')
+        cy.get('.v-chip.warning')
+
+    });
+
+    it('can update schema version specification', function () {
+        // Setup
+        let orgName = faker.company.companyName()
+        let unitName = faker.lorem.word()
+        let namespace = faker.internet.domainName()
+        let schema = faker.company.catchPhraseNoun()
+        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
+        let patchVersion = faker.random.number(9)
+        let prevVersion = majorMinorVersion + '.' + patchVersion
+        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
+        let spec = 'event SalutationHappened {\n' +
+            '    type eventType'
+        let desc = faker.lorem.sentence()
+
+        // Create Entities
+        cy.visit('/#/organization')
+        cy.fillField('Name', orgName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Unit').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.fillField('Name', unitName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Context').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.fillField('Namespace', namespace)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema').click()
+
+        cy.fieldContent('SchemaID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.fillField('Name', schema)
+        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
+        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
+        cy.fillField('Description', faker.lorem.sentence())
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema Version').click()
+
+        cy.fieldContent('SchemaVersionID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.selectOption('Schema', schema)
+        cy.fillField('Previous Version', prevVersion)
+        cy.fillField('Current Version', currentVersion)
+        cy.fillEditor('#description-editor', desc)
+        cy.fillEditor('#specification-editor', spec)
+        cy.contains('button', 'Create').click()
+
+        // Assert visibility in treeview
+        // Filter for Org
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+
+        // Expand Tree
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+
+        // Select version
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        // Change spec
+        cy.fillEditor('#specification-editor', 'foo bar baz')
+        cy.contains('button', 'Save').click()
+
+        // Reload and navigate to schema version
+        cy.reload()
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        cy.editorContent('#specification-editor').should('contain','foo bar baz')
+    });
+});
\ No newline at end of file

From d0ba2addb8470cad576cb9386adbc923706d21a0 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 10:25:20 +0100
Subject: [PATCH 13/21] Add assertion for enablement of save button based on
 state

---
 .../cypress/integration/schema-version-maintenance.spec.ts   | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
index 05001ec0..2eb44928 100644
--- a/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
+++ b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
@@ -87,12 +87,14 @@ describe('Schemata View Tests', function () {
         cy.contains('button', 'Deprecate').should('be.enabled')
         cy.contains('button', 'Remove').should('be.enabled')
         cy.get('.v-chip.warning')
+        cy.contains('button', 'Save').should('be.enabled')
 
         //Publish
         cy.contains('button', 'Publish').click()
         cy.contains('button', 'Publish').should('be.disabled')
         cy.contains('button', 'Deprecate').should('be.enabled')
         cy.contains('button', 'Remove').should('be.disabled')
+        cy.contains('button', 'Save').should('be.disabled')
 
         //Deprecate
         cy.contains('button', 'Deprecate').click()
@@ -100,6 +102,7 @@ describe('Schemata View Tests', function () {
         cy.contains('button', 'Deprecate').should('be.disabled')
         cy.contains('button', 'Remove').should('be.enabled')
         cy.get('.v-chip.warning')
+        cy.contains('button', 'Save').should('be.disabled')
 
         //Remove
         cy.contains('button', 'Remove').click()
@@ -107,7 +110,7 @@ describe('Schemata View Tests', function () {
         cy.contains('button', 'Deprecate').should('be.disabled')
         cy.contains('button', 'Remove').should('be.disabled')
         cy.get('.v-chip.warning')
-
+        cy.contains('button', 'Save').should('be.disabled')
     });
 
     it('can update schema version specification', function () {

From a86401007a2aa73c24ba72c1270038fc32005d29 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 10:28:39 +0100
Subject: [PATCH 14/21] Refresh versions after updating selected version

---
 src/main/frontend/src/components/Properties.vue | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index cac7e5e9..e3f5efc8 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -153,6 +153,7 @@
                     this.currentSpecification
                 )
                     .then(response => vm.$store.dispatch('selectSchemaVersion', response))
+                    .then(() => vm.$store.dispatch('loadVersions'))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,

From 36e42aa137f16e46d7c23f91ca0a48e7db25c45c Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 10:42:34 +0100
Subject: [PATCH 15/21] Merge SchemaRepo

---
 .../frontend/src/api/SchemataRepository.js    | 38 ++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 57c9c0d4..6b60ebf9 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -9,7 +9,9 @@ const resources = {
     scopes: () => '/schema/scopes',
     schemata: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}/schemas`,
     versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`,
-    schemaSpecification: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/specification`
+    versionStatus: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/status`,
+    schemaSpecification: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/specification`,
+    sources: (o, u, c, s, v, lang) => `/code/${o}:${u}:${c}:${s}:${v}/${lang}`,
 }
 
 function ensure(response, status) {
@@ -145,4 +147,38 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+
+    setSchemaVersionStatus(
+        organization, unit, context, schema, version, status) {
+
+        let config = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'text'
+        };
+        return Repository.patch(
+            resources.versionStatus(organization, unit, context, schema, version),
+            status,
+            config
+        )
+            .then(ensureOk)
+            .then(response => response.data)
+    },
+
+    loadSourceJava(
+        organization, unit, context, schema, version, language) {
+
+        let config = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'text'
+        };
+        return Repository.get(
+            resources.sources(organization, unit, context, schema, "java"),
+        )
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 }
\ No newline at end of file

From b7c724ac43e3e5a6772c9e4c05041fd7ab46829a Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 11:33:18 +0100
Subject: [PATCH 16/21] Add query methods for entities

---
 .../frontend/src/api/SchemataRepository.js    | 33 ++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 99e40925..ba27ae7c 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -3,12 +3,17 @@ import Repository from '@/api/Repository'
 
 const resources = {
     organizations: () => '/organizations',
+    organization: (o) => `/organizations/${o}/units`,
     units: (o) => `/organizations/${o}/units`,
+    unit: (o, u) => `/organizations/${o}/units/${u}`,
     contexts: (o, u) => `/organizations/${o}/units/${u}/contexts`,
+    context: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}`,
     categories: () => '/schema/categories',
     scopes: () => '/schema/scopes',
     schemata: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}/schemas`,
+    schema: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}`,
     versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`,
+    version: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}`,
     versionStatus: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/status`,
     schemaSpecification: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/specification`,
     sources: (o, u, c, s, v, lang) => `/code/${o}:${u}:${c}:${s}:${v}/${lang}`,
@@ -35,18 +40,34 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+    getOrganization(organization) {
+        return Repository.get(resources.organization(organization))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getUnits(organization) {
         return Repository.get(resources.units(organization))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getUnit(organization, unit) {
+        return Repository.get(resources.unit(organization, unit))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getContexts(organization, unit) {
         return Repository.get(resources.contexts(organization, unit))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getContext(organization, unit, context) {
+        return Repository.get(resources.context(organization, unit, context))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
+
     getCategories() {
         return Repository.get(resources.categories())
             .then(ensureOk)
@@ -62,12 +83,22 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+    getSchema(organization, unit, context, schema) {
+        return Repository.get(resources.schema(organization, unit, context, schema))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getVersions(organization, unit, context, schema) {
         return Repository.get(resources.versions(organization, unit, context, schema))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getVersion(organization, unit, context, schema, version) {
+        return Repository.get(resources.version(organization, unit, context, schema, version))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     createOrganization(name, description) {
         return Repository.post(resources.organizations(),
@@ -172,7 +203,7 @@ export default {
             responseType: 'text'
         };
         return Repository.get(
-            resources.sources(organization, unit, context, schema, "java"),
+            resources.sources(organization, unit, context, schema, version, "java"),
         )
             .then(ensureOk)
             .then(response => response.data)

From bb09110a415b2e9b065de8b1b1be3c2502a9e6f5 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 11:46:45 +0100
Subject: [PATCH 17/21] Factor out duplicated resource URLs

---
 .../frontend/src/api/SchemataRepository.js    | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index ba27ae7c..06fa4cc2 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -3,19 +3,19 @@ import Repository from '@/api/Repository'
 
 const resources = {
     organizations: () => '/organizations',
-    organization: (o) => `/organizations/${o}/units`,
-    units: (o) => `/organizations/${o}/units`,
-    unit: (o, u) => `/organizations/${o}/units/${u}`,
-    contexts: (o, u) => `/organizations/${o}/units/${u}/contexts`,
-    context: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}`,
+    organization: (o) => `${resources.organizations()}/${o}`,
+    units: (o) => `${resources.organization(o)}/units`,
+    unit: (o, u) => `${resources.units(o)}/${u}`,
+    contexts: (o, u) => `${resources.unit(o, u)}/contexts`,
+    context: (o, u, c) => `${resources.contexts(o, u)}/${c}`,
     categories: () => '/schema/categories',
     scopes: () => '/schema/scopes',
-    schemata: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}/schemas`,
-    schema: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}`,
-    versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`,
-    version: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}`,
-    versionStatus: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/status`,
-    schemaSpecification: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/specification`,
+    schemata: (o, u, c) => `${resources.context(o, u, c)}/schemas`,
+    schema: (o, u, c, s) => `${resources.schemata(o, u, c)}/${s}`,
+    versions: (o, u, c, s) => `${resources.schema(o, u, c, s)}/versions`,
+    version: (o, u, c, s, v) => `${resources.versions(o, u, c, s)}/${v}`,
+    versionStatus: (o, u, c, s, v) => `${resources.version(o, u, c, s, v)}/status`,
+    schemaSpecification: (o, u, c, s, v) => `${resources.version(o, u, c, s, v)}/specification`,
     sources: (o, u, c, s, v, lang) => `/code/${o}:${u}:${c}:${s}:${v}/${lang}`,
 }
 
@@ -194,7 +194,7 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
-    loadSourceJava(
+    loadSource(
         organization, unit, context, schema, version, language) {
         let config = {
             headers: {
@@ -203,7 +203,7 @@ export default {
             responseType: 'text'
         };
         return Repository.get(
-            resources.sources(organization, unit, context, schema, version, "java"),
+            resources.sources(organization, unit, context, schema, version, language),
         )
             .then(ensureOk)
             .then(response => response.data)

From 1d4fb0e31fa1d841d8d9e6813ca2ac2941b6c331 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 12:14:09 +0100
Subject: [PATCH 18/21] Disable source button if no version is selected

---
 .../frontend/src/components/Properties.vue    | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index e3f5efc8..6dfa47af 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -42,6 +42,12 @@
                            :disabled="status !== 'Draft'"
                            @click="saveSpecification">Save
                     </v-btn>
+                    <v-btn color="info"
+                           :disabled="!version"
+                           @click="loadSources">
+                        <v-icon>{{icons.source}}</v-icon>
+                        Source
+                    </v-btn>
                 </v-card-actions>
             </v-tab-item>
 
@@ -58,7 +64,7 @@
 
 <script>
     import {mapFields} from 'vuex-map-fields';
-    import {mdiDelete, mdiLabel, mdiLabelOff} from '@mdi/js'
+    import {mdiDelete, mdiLabel, mdiLabelOff,mdiSourcePull} from '@mdi/js'
     import marked from 'marked'
     import Repository from '@/api/SchemataRepository'
     import editor from 'monaco-editor-vue';
@@ -71,7 +77,8 @@
                 icons: {
                     publish: mdiLabel,
                     delete: mdiDelete,
-                    deprecate: mdiLabelOff
+                    deprecate: mdiLabelOff,
+                    source: mdiSourcePull
                 }
             }
         },
@@ -165,6 +172,16 @@
                         let response = err.response ? err.response.data + ' - ' : ''
                         vm.$store.commit('raiseError', {message: response + err})
                     })
+            },
+            loadSources() {
+                Repository.loadSources(
+                    this.version.organizationId,
+                    this.version.unitId,
+                    this.version.contextId,
+                    this.version.schemaId,
+                    this.version.schemaVersionId,
+                    "java"
+                )
             }
         }
     }

From 1cbac0c656b1cc762bc5ec496ae3e2c4ed2911be Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 12:14:29 +0100
Subject: [PATCH 19/21] Retrieve source code from properties view

---
 .../frontend/src/api/SchemataRepository.js    | 26 ++++++++++++++++---
 src/main/frontend/vue.config.js               |  3 +++
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 06fa4cc2..c2e16e42 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -194,7 +194,7 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
-    loadSource(
+    loadSources(
         organization, unit, context, schema, version, language) {
         let config = {
             headers: {
@@ -202,9 +202,27 @@ export default {
             },
             responseType: 'text'
         };
-        return Repository.get(
-            resources.sources(organization, unit, context, schema, version, language),
-        )
+        Promise.all([
+            this.getOrganization(organization),
+            this.getUnit(organization, unit),
+            this.getContext(organization, unit, context),
+            this.getSchema(organization, unit, context, schema),
+            this.getVersion(organization, unit, context, schema, version),
+        ]).then(([org, unit, context, schema, version]) => {
+            console.log(org);
+            console.log(unit);
+            console.log(context);
+            console.log(schema);
+            console.log(version);
+            Repository.get(
+                resources.sources(
+                    org.name,
+                    unit.name,
+                    context.namespace,
+                    schema.name,
+                    version.currentVersion,
+                    language))
+        })
             .then(ensureOk)
             .then(response => response.data)
     },
diff --git a/src/main/frontend/vue.config.js b/src/main/frontend/vue.config.js
index d4db71be..10fdb462 100644
--- a/src/main/frontend/vue.config.js
+++ b/src/main/frontend/vue.config.js
@@ -12,6 +12,9 @@ module.exports = {
             },
             '/categories': {
                 target: 'http://localhost:9019/'
+            },
+            '/code': {
+                target: 'http://localhost:9019/'
             }
         },
     },

From e064f6b0cd536de19430d2a48f3fe125cfde9bff Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 12:36:24 +0100
Subject: [PATCH 20/21] Include source highlighting for java

---
 src/main/frontend/vue.config.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/frontend/vue.config.js b/src/main/frontend/vue.config.js
index 10fdb462..3fa66b54 100644
--- a/src/main/frontend/vue.config.js
+++ b/src/main/frontend/vue.config.js
@@ -21,7 +21,7 @@ module.exports = {
     chainWebpack: config => {
         config.plugin('monaco-editor').use(MonacoWebpackPlugin, [
             {
-                languages: ['javascript', 'markdown']
+                languages: ['javascript', 'markdown','java']
             }
         ])
     }

From 543b2ba76b4a82d2a96f9cc12e9d81c8099bbcc0 Mon Sep 17 00:00:00 2001
From: Wolfgang Werner <mail@wolfgang-werner.net>
Date: Wed, 30 Oct 2019 12:36:50 +0100
Subject: [PATCH 21/21] Show generated sources in dialog

---
 .../frontend/src/api/SchemataRepository.js    | 11 ++----
 .../frontend/src/components/Properties.vue    | 37 ++++++++++++++++---
 2 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index c2e16e42..943d487f 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -202,26 +202,21 @@ export default {
             },
             responseType: 'text'
         };
-        Promise.all([
+        return Promise.all([
             this.getOrganization(organization),
             this.getUnit(organization, unit),
             this.getContext(organization, unit, context),
             this.getSchema(organization, unit, context, schema),
             this.getVersion(organization, unit, context, schema, version),
         ]).then(([org, unit, context, schema, version]) => {
-            console.log(org);
-            console.log(unit);
-            console.log(context);
-            console.log(schema);
-            console.log(version);
-            Repository.get(
+            return Repository.get(
                 resources.sources(
                     org.name,
                     unit.name,
                     context.namespace,
                     schema.name,
                     version.currentVersion,
-                    language))
+                    language), config)
         })
             .then(ensureOk)
             .then(response => response.data)
diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index 6dfa47af..069de937 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -38,17 +38,29 @@
                         Remove
                     </v-btn>
                     <v-spacer></v-spacer>
-                    <v-btn color="info"
-                           :disabled="status !== 'Draft'"
-                           @click="saveSpecification">Save
-                    </v-btn>
-                    <v-btn color="info"
+                    <v-btn outlined color="info"
                            :disabled="!version"
                            @click="loadSources">
                         <v-icon>{{icons.source}}</v-icon>
                         Source
                     </v-btn>
+                    <v-btn color="info"
+                           :disabled="status !== 'Draft'"
+                           @click="saveSpecification">Save
+                    </v-btn>
                 </v-card-actions>
+                <v-dialog v-model="sourceDialog">
+                    <v-card>
+                        <editor
+                                id="source-editor"
+                                v-model="sources.java"
+                                theme="vs-dark"
+                                language="java"
+                                height="400"
+                                :options="{ readOnly: true, automaticLayout: true }"
+                        ></editor>
+                    </v-card>
+                </v-dialog>
             </v-tab-item>
 
             <v-tab-item>
@@ -64,7 +76,7 @@
 
 <script>
     import {mapFields} from 'vuex-map-fields';
-    import {mdiDelete, mdiLabel, mdiLabelOff,mdiSourcePull} from '@mdi/js'
+    import {mdiDelete, mdiLabel, mdiLabelOff, mdiSourcePull} from '@mdi/js'
     import marked from 'marked'
     import Repository from '@/api/SchemataRepository'
     import editor from 'monaco-editor-vue';
@@ -79,6 +91,10 @@
                     delete: mdiDelete,
                     deprecate: mdiLabelOff,
                     source: mdiSourcePull
+                },
+                sourceDialog: false,
+                sources: {
+                    java: undefined,
                 }
             }
         },
@@ -174,6 +190,7 @@
                     })
             },
             loadSources() {
+                let vm = this
                 Repository.loadSources(
                     this.version.organizationId,
                     this.version.unitId,
@@ -182,6 +199,14 @@
                     this.version.schemaVersionId,
                     "java"
                 )
+                    .then(response => {
+                        vm.sources.java = response
+                        vm.sourceDialog = true
+                    })
+                    .catch(function (err) {
+                        let response = err.response ? err.response.data + ' - ' : ''
+                        vm.$store.commit('raiseError', {message: response + err})
+                    })
             }
         }
     }