feat(supported-version): validate custom_versions

Previously, @danslo reported that he tried to use `custom_versions` without
setting the kind. This isn't the correct behavior.
I've added a validator to alert him of this.

Author: damienwebdev

Diff for: supported-version/dist/index.js

@@ -1,15 +1,15 @@
 import * as core from '@actions/core';
-import { validateOrError } from './kind/compute-kind';
+import { validateKind } from './kind/validate-kinds';
 import { getMatrixForKind } from './matrix/get-matrix-for-kind';
 
 
 export async function run(): Promise<void> {
   try { 
     const kind = core.getInput("kind");
-    validateOrError(kind);
-
     const customVersions = core.getInput("custom_versions");
 
+    validateKind(<any>kind, customVersions.split(','));
+
     core.setOutput('matrix', getMatrixForKind(kind, customVersions));
   } 
   catch (error) {

Diff for: supported-version/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Acceptable arguments for version `kind`
+ */
+export const KNOWN_KINDS = {
+    'currently-supported': true,
+    'latest': true,
+    'custom': true,
+    'nightly': true,
+    'all': true,
+}
+
+export type Kind = keyof typeof KNOWN_KINDS;

Diff for: supported-version/src/kind/compute-kind.spec.ts

@@ -0,0 +1,15 @@
+import { validateKind } from "./validate-kinds";
+
+describe('validateKind', () => {
+    it('returns `true` if its a valid kind', () => {
+        expect(validateKind("latest")).toBe(true);
+    });
+
+    it('throws a helpful exception if its an invalid kind', () => {
+        expect(() => validateKind(<any>"taco")).toThrowError();
+    })
+
+    it('throws a helpful exception if custom versions are provided with the wrong kind', () => {
+        expect(() => validateKind(<any>"latest", [])).toThrowError();
+    })
+})

Diff for: supported-version/src/kind/compute-kind.ts

@@ -0,0 +1,12 @@
+import { customVersionsValidator } from "./validations/custom-versions-validator";
+import { isKnownKind } from "./validations/is-known-kind";
+import { KindValidator } from "./validator";
+
+export const validateKind: KindValidator = (kind, custom_versions = null): boolean => {
+    return validators.reduce((acc, el) => el(kind, custom_versions), true);
+}
+
+export const validators: KindValidator[] = [
+    isKnownKind,
+    customVersionsValidator,
+];

Diff for: supported-version/src/kind/kinds.ts

@@ -0,0 +1,8 @@
+import { KindValidator } from "../validator";
+
+export const customVersionsValidator: KindValidator = (kind, customVersions) => {
+    if(customVersions && kind !== 'custom') {
+        throw new Error('`custom_versions` can only be used with kind `custom`'); 
+    }
+    return true;
+}

Diff for: supported-version/src/kind/validate-kinds.spec.ts

@@ -0,0 +1,11 @@
+import { KNOWN_KINDS, Kind } from "../kinds";
+
+export const isKnownKind = (kind: Kind): boolean => {
+    if(!(kind in KNOWN_KINDS)) {
+        throw new Error(
+            `Invalid kind provided, supported kinds are: ${Object.keys(KNOWN_KINDS).join(', ')}`
+        );
+    }
+    
+    return true;
+};

Diff for: supported-version/src/kind/validate-kinds.ts

@@ -0,0 +1,3 @@
+import { Kind } from "./kinds";
+
+export type KindValidator = (kind: Kind, custom_versions?: string[]) => boolean;