Add in API for adding/deleting schemas and modifying their contents in memory"

gorkem · JPinkney · commit 8f0da51e8b7c · 2020-01-14T15:34:15.000-05:00
diff --git a/src/languageservice/apis/schemaModification.ts b/src/languageservice/apis/schemaModification.ts
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { JSONSchemaService } from '../services/jsonSchemaService';
+import { JSONSchema } from '../jsonSchema04';
+
+export enum MODIFICATION_ACTIONS {
+    'delete',
+    'add'
+}
+
+export interface SchemaAdditions {
+    schema: string,
+    action: MODIFICATION_ACTIONS.add,
+    path: string,
+    key: string,
+    // tslint:disable-next-line: no-any
+    content: any
+}
+
+export interface SchemaDeletions {
+    schema: string,
+    action: MODIFICATION_ACTIONS.delete,
+    path: string,
+    key: string
+}
+
+export class SchemaModification {
+
+    /**
+     * Add content to a specified schema at a specified path
+     */
+    public async addContent(schemaService: JSONSchemaService, additions: SchemaAdditions) {
+        const schema = await schemaService.getResolvedSchema(additions.schema);
+        if (schema) {
+            const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema.schema, additions.path);
+
+            if (typeof resolvedSchemaLocation === 'object') {
+                resolvedSchemaLocation[additions.key] = additions.content;
+            }
+            await schemaService.saveSchema(additions.schema, schema.schema);
+        }
+    }
+
+    /**
+     * Delete content in a specified schema at a specified path
+     */
+    public async deleteContent(schemaService: JSONSchemaService, deletions: SchemaDeletions) {
+        const schema = await schemaService.getResolvedSchema(deletions.schema);
+        if (schema) {
+            const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema.schema, deletions.path);
+
+            if (typeof resolvedSchemaLocation === 'object') {
+                delete resolvedSchemaLocation[deletions.key];
+            }
+            await schemaService.saveSchema(deletions.schema, schema.schema);
+        }
+    }
+
+    /**
+     * Take a JSON Schema and the path that you would like to get to
+     * @returns the JSON Schema resolved at that specific path
+     */
+    private resolveJSONSchemaToSection(schema: JSONSchema, paths: string): JSONSchema {
+        const splitPathway = paths.split('/');
+        let resolvedSchemaLocation = schema;
+        for (const path of splitPathway) {
+            if (path === '') {
+                continue;
+            }
+            this.resolveNext(resolvedSchemaLocation, path);
+            resolvedSchemaLocation = resolvedSchemaLocation[path];
+        }
+        return resolvedSchemaLocation;
+    }
+
+    /**
+     * Resolve the next Object if they have compatible types
+     * @param object a location in the JSON Schema
+     * @param token the next token that you want to search for
+     */
+    // tslint:disable-next-line: no-any
+    private resolveNext(object: any, token: any) {
+        // tslint:disable-next-line: no-any
+        if (Array.isArray(object) && isNaN(token)) {
+            throw new Error('Expected a number after the array object');
+        } else if (typeof object === 'object' && typeof token !== 'string') {
+            throw new Error('Expected a string after the object');
+        }
+    }
+}
diff --git a/src/languageservice/utils/kubernetesResolver.ts b/src/languageservice/utils/kubernetesResolver.ts
@@ -0,0 +1,12 @@
+export const KUBERNETES_SCHEMA_URL = 'https://raw.githubusercontent.com/garethr/kubernetes-json-schema/master/v1.14.0-standalone-strict/all.json';
+
+/**
+ * Resolve kubernetes to url
+ * @param url The URL that you want to resolve
+ */
+export function resolveURL(url: string) {
+    if (url.toLowerCase() === 'kubernetes') {
+        return KUBERNETES_SCHEMA_URL;
+    }
+    return url;
+}
diff --git a/src/languageservice/yamlLanguageService.ts b/src/languageservice/yamlLanguageService.ts
@@ -12,7 +12,8 @@ import { YAMLCompletion } from './services/yamlCompletion';
 import { YAMLHover } from './services/yamlHover';
 import { YAMLValidation } from './services/yamlValidation';
 import { YAMLFormatter } from './services/yamlFormatter';
-import { LanguageService as JSONLanguageService, getLanguageService as getJSONLanguageService, JSONWorkerContribution } from 'vscode-json-languageservice';
+import { getLanguageService as getJSONLanguageService, JSONWorkerContribution } from 'vscode-json-languageservice';
+import { SchemaModification, SchemaAdditions, SchemaDeletions } from './apis/schemaModification';
 
 export interface LanguageSettings {
   validate?: boolean; //Setting for whether we want to validate the schema
@@ -118,6 +119,10 @@ export interface LanguageService {
   doResolve(completionItem): Thenable<CompletionItem>;
   resetSchema(uri: string): boolean;
   doFormat(document: TextDocument, options: CustomFormatterOptions): TextEdit[];
+  addSchema(schemaID: string, schema: JSONSchema): void;
+  deleteSchema(schemaID: string): void;
+  modifySchemaContent(schemaAdditions: SchemaAdditions): void;
+  deleteSchemaContent(schemaDeletions: SchemaDeletions): void;
 }
 
 export function getLanguageService(schemaRequestService: SchemaRequestService,
@@ -132,6 +137,7 @@ export function getLanguageService(schemaRequestService: SchemaRequestService,
   const yamlDocumentSymbols = new YAMLDocumentSymbols(schemaService);
   const yamlValidation = new YAMLValidation(schemaService, promise);
   const formatter = new YAMLFormatter();
+  const schemaModifier = new SchemaModification();
 
   return {
         configure: settings => {
@@ -157,6 +163,10 @@ export function getLanguageService(schemaRequestService: SchemaRequestService,
       findDocumentSymbols: yamlDocumentSymbols.findDocumentSymbols.bind(yamlDocumentSymbols),
       findDocumentSymbols2: yamlDocumentSymbols.findHierarchicalDocumentSymbols.bind(yamlDocumentSymbols),
       resetSchema: (uri: string) => schemaService.onResourceChange(uri),
-      doFormat: formatter.format.bind(formatter)
+      doFormat: formatter.format.bind(formatter),
+      addSchema: (schemaID: string, schema: JSONSchema) => schemaService.saveSchema(schemaID, schema),
+      deleteSchema: (schemaID: string) => schemaService.deleteSchema(schemaID),
+      modifySchemaContent: (schemaAdditions: SchemaAdditions) => schemaModifier.addContent(schemaService, schemaAdditions),
+      deleteSchemaContent: (schemaDeletions: SchemaDeletions) => schemaModifier.deleteContent(schemaService, schemaDeletions)
   };
 }
diff --git a/src/server.ts b/src/server.ts
@@ -22,7 +22,7 @@ import { SchemaAssociationNotification, DynamicCustomSchemaRequestRegistration,
 import { schemaRequestHandler } from './languageservice/services/schemaRequestHandler';
 import { isRelativePath, relativeToAbsolutePath } from './languageservice/utils/paths';
 import { URI } from 'vscode-uri';
-
+import { resolveURL } from './languageservice/utils/kubernetesResolver';
 // tslint:disable-next-line: no-any
 nls.config(process.env['VSCODE_NLS_CONFIG'] as any);
 
@@ -236,8 +236,23 @@ function updateConfiguration() {
  * @param schema schema id
  * @param languageSettings current server settings
  */
-function configureSchemas(uri: string, fileMatch: string[], schema: any, languageSettings: LanguageSettings) {
-    uri = checkSchemaURI(uri);
+function configureSchemas(uri, fileMatch, schema, languageSettings){
+
+    uri = resolveURL(uri);
+
+    if (schema === null){
+        languageSettings.schemas.push({ uri, fileMatch: fileMatch });
+    }else {
+        languageSettings.schemas.push({ uri, fileMatch: fileMatch, schema: schema });
+    }
+
+    if (fileMatch.constructor === Array && uri === KUBERNETES_SCHEMA_URL){
+        fileMatch.forEach(url => {
+            specificValidatorPaths.push(url);
+        });
+    }else if (uri === KUBERNETES_SCHEMA_URL) {
+        specificValidatorPaths.push(fileMatch);
+    }
 
     if (schema === null) {
         languageSettings.schemas.push({ uri, fileMatch: fileMatch });
diff --git a/test/schema.test.ts b/test/schema.test.ts
@@ -6,6 +6,9 @@ import * as JsonSchema from '../src/languageservice/jsonSchema07';
 import fs = require('fs');
 import url = require('url');
 import path = require('path');
+import { SchemaModification, MODIFICATION_ACTIONS, SchemaDeletions } from '../src/languageservice/apis/schemaModification';
+import { KUBERNETES_SCHEMA_URL } from '../src/languageservice/utils/kubernetesResolver';
+import { XHRResponse, xhr } from 'request-light';
 
 const fixtureDocuments = {
     'http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json': 'deploymentTemplate.json',
@@ -41,6 +44,13 @@ const workspaceContext = {
         url.resolve(resource, relativePath)
 };
 
+const schemaRequestServiceForURL = (uri: string): Thenable<string> => {
+    const headers = { 'Accept-Encoding': 'gzip, deflate' };
+    return xhr({ url: uri, followRedirects: 5, headers }).then(response =>
+        response.responseText, (error: XHRResponse) =>
+        Promise.reject(error.responseText || error.toString()));
+};
+
 suite('JSON Schema', () => {
     test('Resolving $refs', function (testDone) {
         const service = new SchemaService.YAMLSchemaService(requestServiceMock, workspaceContext);
@@ -319,5 +329,158 @@ suite('JSON Schema', () => {
         assert.notEqual(schema, undefined);
         testDone();
        });
+    test('Modifying schema', async () => {
+        const service = new SchemaService.JSONSchemaService(requestServiceMock, workspaceContext);
+        service.setSchemaContributions({
+            schemas: {
+                'https://myschemastore/main/schema1.json': {
+                    type: 'object',
+                    properties: {
+                        apiVersion: {
+                            type: 'string',
+                            enum: [
+                                'v1'
+                            ]
+                        },
+                        kind: {
+                            type: 'string',
+                            enum: [
+                                'Pod'
+                            ]
+                        }
+                    }
+                }
+            }
+        });
+
+        const schemaModification = new SchemaModification();
+        await schemaModification.addContent(service, {
+            action: MODIFICATION_ACTIONS.add,
+            path: 'properties/apiVersion',
+            key: 'enum',
+            content: [
+                'v2',
+                'v3',
+            ],
+            schema: 'https://myschemastore/main/schema1.json'
+        });
+
+        const fs = await service.getResolvedSchema('https://myschemastore/main/schema1.json');
+        assert.deepEqual(fs.schema.properties['apiVersion'], {
+            type: 'string',
+            enum: ['v2', 'v3']
+        });
+        assert.deepEqual(fs.schema.properties['kind'], {
+            type: 'string',
+            enum: ['Pod']
+        });
+    });
+
+    test('Deleting schema', async () => {
+        const service = new SchemaService.JSONSchemaService(requestServiceMock, workspaceContext);
+        service.setSchemaContributions({
+            schemas: {
+                'https://myschemastore/main/schema1.json': {
+                    type: 'object',
+                    properties: {
+                        apiVersion: {
+                            type: 'string',
+                            enum: [
+                                'v1'
+                            ]
+                        },
+                        kind: {
+                            type: 'string',
+                            enum: [
+                                'Pod'
+                            ]
+                        }
+                    }
+                }
+            }
+        });
+
+        const schemaModification = new SchemaModification();
+        await schemaModification.deleteContent(service, {
+            action: MODIFICATION_ACTIONS.delete,
+            path: 'properties',
+            key: 'apiVersion',
+            schema: 'https://myschemastore/main/schema1.json'
+        } as SchemaDeletions);
+
+        const fs = await service.getResolvedSchema('https://myschemastore/main/schema1.json');
+        assert.notDeepEqual(fs.schema.properties['apiVersion'], {
+            type: 'string',
+            enum: ['v2', 'v3']
+        });
+        assert.equal(fs.schema.properties['apiVersion'], undefined);
+        assert.deepEqual(fs.schema.properties['kind'], {
+            type: 'string',
+            enum: ['Pod']
+        });
+    });
+
+    test('Modifying schema works with kubernetes resolution', async () => {
+        const service = new SchemaService.JSONSchemaService(schemaRequestServiceForURL, workspaceContext);
+        service.registerExternalSchema(KUBERNETES_SCHEMA_URL);
+
+        const schemaModification = new SchemaModification();
+        await schemaModification.addContent(service, {
+            action: MODIFICATION_ACTIONS.add,
+            path: 'oneOf/0/properties/kind',
+            key: 'enum',
+            content: [
+                'v2',
+                'v3',
+            ],
+            schema: KUBERNETES_SCHEMA_URL
+        });
+
+        const fs = await service.getResolvedSchema(KUBERNETES_SCHEMA_URL);
+        assert.deepEqual(fs.schema.oneOf[0].properties['kind']['enum'], ['v2', 'v3']);
+    });
+
+    test('Deleting schema works with Kubernetes resolution', async () => {
+        const service = new SchemaService.JSONSchemaService(schemaRequestServiceForURL, workspaceContext);
+        service.registerExternalSchema(KUBERNETES_SCHEMA_URL);
+
+        const schemaModification = new SchemaModification();
+        await schemaModification.deleteContent(service, {
+            action: MODIFICATION_ACTIONS.delete,
+            path: 'oneOf/0/properties/kind',
+            key: 'enum',
+            schema: KUBERNETES_SCHEMA_URL
+        });
+
+        const fs = await service.getResolvedSchema(KUBERNETES_SCHEMA_URL);
+        assert.equal(fs.schema.oneOf[0].properties['kind']['enum'], undefined);
+    });
+
+    test('Adding a brand new schema', async () => {
+        const service = new SchemaService.JSONSchemaService(schemaRequestServiceForURL, workspaceContext);
+        service.saveSchema('hello_world', {
+            enum: [
+                'test1',
+                'test2'
+            ]
+        });
+
+        const hello_world_schema = await service.getResolvedSchema('hello_world');
+        assert.deepEqual(hello_world_schema.schema.enum, ['test1', 'test2']);
+    });
+
+    test('Deleting an existing schema', async () => {
+        const service = new SchemaService.JSONSchemaService(schemaRequestServiceForURL, workspaceContext);
+        service.saveSchema('hello_world', {
+            enum: [
+                'test1',
+                'test2'
+            ]
+        });
+
+        await service.deleteSchema('hello_world');
+
+        const hello_world_schema = await service.getResolvedSchema('hello_world');
+        assert.equal(hello_world_schema, null);
     });
 });
