screwdriver-api 6.0.14 → 6.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "6.0.14",
+  "version": "6.0.16",
   "description": "API server for the Screwdriver.cd service",
   "main": "index.js",
   "scripts": {

package/plugins/templates/README.md

@@ -117,6 +117,20 @@ Deleting a template will delete a template and all of its associated tags and ve
 
 * `name` - Name of the template
 
+##### Delete a version
+
+Delete the template version and all of its associated tags.
+If the deleted version was the last published, the API would set the `latest` attribute of the previous version to `true`.
+
+`DELETE /templates/{name}/versions/{version}`
+
+###### Arguments
+
+'name', 'version'
+
+* `name` - Name of the template
+* `version` - Version of the template
+
 #### Template Tag
 Template tag allows fetching on template version by tag. For example, tag `mytemplate@1.1.0` as `stable`.
 

package/plugins/templates/index.js

@@ -10,6 +10,7 @@ const listVersionsRoute = require('./listVersions');
 const listVersionsWithMetricsRouter = require('./listVersionsWithMetric');
 const removeRoute = require('./remove');
 const removeTagRoute = require('./removeTag');
+const removeVersionRoute = require('./removeVersion');
 const updateTrustedRoute = require('./updateTrusted');
 const getTemplateByIdRoute = require('./getTemplateById');
 
@@ -84,6 +85,7 @@ const templatesPlugin = {
             listVersionsWithMetricsRouter(),
             removeRoute(),
             removeTagRoute(),
+            removeVersionRoute(),
             updateTrustedRoute(),
             getTemplateByIdRoute()
         ]);

package/plugins/templates/removeVersion.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const nameSchema = schema.models.template.base.extract('name');
+const exactVersionSchema = schema.config.template.exactVersion;
+
+module.exports = () => ({
+    method: 'DELETE',
+    path: '/templates/{name}/versions/{version}',
+    options: {
+        description: 'Delete the specified version of template and the tags associated with it',
+        notes: 'Returns null if successful',
+        tags: ['api', 'templates'],
+        auth: {
+            strategies: ['token'],
+            scope: ['build', 'user', '!guest']
+        },
+
+        handler: async (request, h) => {
+            const { name, version } = request.params;
+            const { credentials } = request.auth;
+            const { templateFactory, templateTagFactory } = request.server.app;
+            const { canRemove } = request.server.plugins.templates;
+            let shouldUpdateLatest = false;
+
+            return Promise.all([
+                templateFactory.get({ name, version }),
+                templateTagFactory.list({ params: { name, version } })
+            ])
+                .then(([template, tags]) => {
+                    if (!template) {
+                        throw boom.notFound(`Template ${name} with version ${version} does not exist`);
+                    }
+
+                    return canRemove(credentials, template, 'admin', request.server.app)
+                        .then(() => {
+                            shouldUpdateLatest = template.latest;
+                            const removeTemplatePromise = template.remove();
+                            const removeTagPromises = tags.map(tag => tag.remove());
+
+                            return Promise.all([removeTemplatePromise, ...removeTagPromises]).then(() => {
+                                if (shouldUpdateLatest) {
+                                    return templateFactory
+                                        .list({
+                                            params: { name },
+                                            sort: 'descending',
+                                            sortBy: 'createTime',
+                                            paginate: { count: 1 }
+                                        })
+                                        .then(templates => {
+                                            if (templates.length > 0) {
+                                                const newLatestTemplate = templates[0];
+
+                                                newLatestTemplate.latest = true;
+
+                                                return newLatestTemplate.update();
+                                            }
+
+                                            return Promise.resolve();
+                                        });
+                                }
+
+                                return Promise.resolve();
+                            });
+                        })
+                        .then(() => h.response().code(204));
+                })
+                .catch(err => {
+                    throw err;
+                });
+        },
+        validate: {
+            params: joi.object({
+                name: nameSchema,
+                version: exactVersionSchema
+            })
+        }
+    }
+});