feat: created hook to load spec file (#28)

Souvikns · web-flow · commit 127e9bee4b3a · 2021-07-19T15:24:29.000+02:00
* feat: created hook to load spec file * feat: auto loading spec path * feat: added file flag to load spec path * feat: changes suggested by @magicmatatjahu * feat: deleted duplicated code * test: trying to fix the test failing issue * test: fixed issue with file flag. * feat: updated parser to latest * feat: updated the package-lock
diff --git a/README.md b/README.md
@@ -25,6 +25,7 @@ Commands
    Options
      -c --context  context-name saved in the store
      -w --watch Enable watchMode (not implemented yet)
+     -f --file File path of the specification file
   
   context
     current show the current set context
@@ -35,7 +36,8 @@ Commands
 
 Examples
   $ asyncapi context add dummy ./asyncapi.yml
-	  $ asyncapi validate --context=dummy
+  $ asyncapi validate --context=dummy
+  $ asyncapi validate --file=./asyncapi.yml
 ```
 
 > For now --context flag is requried to run validate command
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -25,7 +25,7 @@
 		"dist"
 	],
 	"dependencies": {
-		"@asyncapi/parser": "^1.6.0",
+		"@asyncapi/parser": "^1.7.0",
 		"ink": "^3.0.8",
 		"meow": "^9.0.0",
 		"react": "^17.0.1",
diff --git a/src/CliModels.ts b/src/CliModels.ts
@@ -4,8 +4,9 @@ export type HelpMessage = string;
 export type Arguments = string[];
 
 export interface Options {
-  context: string,
-  watch: boolean
+  context?: string,
+  watch: boolean,
+  file?: string
 }
 
 export class CliInput {
@@ -34,8 +35,8 @@ export class CliInput {
 
   static createFromMeow(meowOutput: any): CliInput {
     const [command, ...args] = meowOutput.input;
-    const { context, watch } = meowOutput.flags;
-    return new CliInput(command || 'help', { context, watch }, args);
+    const { context, watch, file } = meowOutput.flags;
+    return new CliInput(command || 'help', { context, watch, file }, args);
   }
 
   static createSubCommand(cliInput: CliInput): CliInput {
diff --git a/src/cli.ts b/src/cli.ts
@@ -14,6 +14,7 @@ const cli = meow(`
 			Options
 				-c --context  context-name saved in the store
 				-w --watch Enable watchMode (not implemented yet)
+				-f --file File path of the specification file
 		context
 			current  show the current set context
 			list     show the list of all stored context
@@ -22,8 +23,9 @@ const cli = meow(`
 			add <context-name> <filepath> add/update new context
 
 	Examples
-	  $ asyncapi context add dummy ./asyncapi.yml
-	  $ asyncapi validate --context=dummy
+		$ asyncapi context add dummy ./asyncapi.yml
+		$ asyncapi validate --context=dummy
+		$ asyncapi validate --file=./asyncapi.yml
 `, {
 	flags: {
 		context: {
@@ -36,6 +38,11 @@ const cli = meow(`
 			type: 'boolean',
 			isRequired: false,
 			default: false
+		},
+		file: {
+			alias: 'f',
+			type: 'string',
+			isRequired: false
 		}
 	}
 });
diff --git a/src/components/Context/context.spec.tsx b/src/components/Context/context.spec.tsx
@@ -26,7 +26,8 @@ describe('rendering current context', () => {
 	test('showing error if now current context is found', () => {
 		testing.deleteDummyContextFile();
 		let { lastFrame } = render(<ShowCurrentContext />);
-		expect(lastFrame()).toMatch('No contexts saved yet.');
+		let message = lastFrame();
+		expect(message).toMatch('No contexts saved yet.');
 	})
 
 	test('showing current context ', () => {
diff --git a/src/components/Validate/Validate.tsx b/src/components/Validate/Validate.tsx
@@ -3,20 +3,24 @@ import { Newline, Text } from 'ink';
 import { Options } from "../../CliModels";
 import { SpecificationFile, useValidate } from "../../hooks/validation";
 import { UseValidateResponse } from "../../hooks/validation/models";
-import { useContextFile } from '../../hooks/context';
+import { useSpecfile } from '../../hooks/context';
 
 interface ValidateInput {
 	options: Options,
 }
 
 const Validate: FunctionComponent<ValidateInput> = ({ options }) => {
-	let { response, error } = useContextFile().getContext(options.context);
-	if (error || !response) {
-		if(error) return <Text color="red">{error.message}</Text>
+	let { specFile, error } = useSpecfile({ context: options.context, file: options.file });
+	if (error) {
+		return <Text color="red">{error.message}</Text>
+	}
+
+	if (!specFile) {
+		return <Text />
 	}
 
 	const validationInput = {
-		file: new SpecificationFile(response.getSpecificationName()),
+		file: new SpecificationFile(specFile.getSpecificationName()),
 		watchMode: options.watch,
 	};
 
diff --git a/src/constants.ts b/src/constants.ts
@@ -39,4 +39,12 @@ export class ContextTestingHelper {
 	getPath(key: string) {
 		return this._context.store[key];
 	}
+
+	createSpecFileAtWorkingDir() {
+		if (!fs.existsSync(path.resolve(process.cwd(), 'asyncapi.yml'))) fs.writeFileSync(path.resolve(process.cwd(), 'asyncapi.yml'), '');
+	}
+
+	deleteSpecFileAtWorkingDir() {
+		if (fs.existsSync(path.resolve(process.cwd(), 'asyncapi.yml'))) fs.unlinkSync(path.resolve(process.cwd(), 'asyncapi.yml'));
+	}
 }
diff --git a/src/hooks/context/contextService.spec.ts b/src/hooks/context/contextService.spec.ts
@@ -55,6 +55,7 @@ describe('ContextService.autoDetect', () => {
 	const contextService = new ContextService();
 
 	test("Should return undefined when does not detects anyfile", () => {
+		testing.deleteSpecFileAtWorkingDir();
 		expect(contextService.autoDetectSpecFile()).toBeUndefined();
 	});
 
diff --git a/src/hooks/context/hook.spec.ts b/src/hooks/context/hook.spec.ts
@@ -1,4 +1,4 @@
-import { useContextFile } from './hooks';
+import { useContextFile, useSpecfile } from './hooks';
 import { ContextFileNotFoundError, KeyNotFoundError, ContextNotFoundError } from './models';
 import { ContextTestingHelper } from '../../constants';
 import { SpecificationFile } from '../validation';
@@ -131,3 +131,30 @@ describe('useContextFile().getContext', () => {
 		expect(response instanceof SpecificationFile).toBeTruthy();
 	});
 })
+
+describe('useSpecFile should ', () => {
+	it('Load spec file from --file flag', () => {
+		const { specFile, error } = useSpecfile({ file: './test/specification.yml' });
+		expect(error).toBeUndefined();
+		expect(specFile instanceof SpecificationFile).toBeTruthy();
+	});
+	it('Load spec file from --context flag', () => {
+		testingVariables.createDummyContextFile();
+		const { specFile, error } = useSpecfile({ context: 'home' });
+		expect(error).toBeUndefined();
+		expect(specFile instanceof SpecificationFile).toBeTruthy();
+	});
+	it('Load spec file from current context', () => {
+		testingVariables.createDummyContextFile();
+		const { specFile, error } = useSpecfile({});
+		expect(error).toBeUndefined();
+		expect(specFile).toBeDefined();
+	});
+	
+	it('Throw error when nothing found', () => {
+		testingVariables.deleteDummyContextFile()
+		testingVariables.deleteDummyContextFile();
+		const { error } = useSpecfile({});
+		expect(error).toBeDefined();
+	});
+})
diff --git a/src/hooks/context/hooks.tsx b/src/hooks/context/hooks.tsx
@@ -15,60 +15,60 @@ export const useContextFile = () => {
 	return {
 		list: (): Result => {
 			try {
-				let ctx: Context = contextService.loadContextFile();
-				let response = Object.keys(ctx.store).map(c => ({ key: c, path: ctx.store[c] }));
+				const ctx: Context = contextService.loadContextFile();
+				const response = Object.keys(ctx.store).map(c => ({ key: c, path: ctx.store[c] }));
 				return { response };
 			} catch (error) {
 				return { error };
 			}
 		},
 		current: (): Result => {
 			try {
-				let ctx: Context = contextService.loadContextFile();
+				const ctx: Context = contextService.loadContextFile();
 				if (!ctx.current) throw new MissingCurrentContextError();
-				let response = { key: ctx.current, path: ctx.store[ctx.current] };
+				const response = { key: ctx.current, path: ctx.store[ctx.current] };
 				return { response };
 			} catch (error) {
 				return { error };
 			}
 		},
 		addContext: (key: string, specFile: SpecificationFile): Result => {
 			try {
-				let ctx = contextService.loadContextFile();
-				let updatedContext = contextService.addContext(ctx, key, specFile);
+				const ctx = contextService.loadContextFile();
+				const updatedContext = contextService.addContext(ctx, key, specFile);
 				contextService.save(updatedContext);
-				let response = "New context added";
+				const response = "New context added";
 				return { response };
 			} catch (error) {
 				if (error instanceof ContextFileNotFoundError) {
-					let context: Context = { current: '', store: {} };
-					let newContext = contextService.addContext(context, key, specFile);
+					const context: Context = { current: '', store: {} };
+					const newContext = contextService.addContext(context, key, specFile);
 					contextService.save(contextService.updateCurrent(newContext, key));
-					let response = "New context added";
+					const response = "New context added";
 					return { response };
 				}
 				return { error }
 			}
 		},
 		setCurrent: (key: string): Result => {
 			try {
-				let ctx = contextService.loadContextFile();
-				let updateCurrent = contextService.updateCurrent(ctx, key);
+				const ctx = contextService.loadContextFile();
+				const updateCurrent = contextService.updateCurrent(ctx, key);
 				contextService.save(updateCurrent);
-				let response = { key: updateCurrent.current, path: updateCurrent.store[updateCurrent.current] };
+				const response = { key: updateCurrent.current, path: updateCurrent.store[updateCurrent.current] };
 				return { response };
 			} catch (error) {
 				return { error };
 			}
 		},
 		deleteContext: (key: string): Result => {
 			try {
-				let ctx = contextService.loadContextFile();
+				const ctx = contextService.loadContextFile();
 				if (Object.keys(ctx.store).length === 1) {
 					contextService.deleteContextFile();
 					return { response: "context deleted successfully" };
 				}
-				let updatedContext = contextService.deleteContext(ctx, key);
+				const updatedContext = contextService.deleteContext(ctx, key);
 				contextService.save(updatedContext);
 				const response = "context deleted successfully";
 				return { response }
@@ -79,12 +79,12 @@ export const useContextFile = () => {
 		loadSpecFile: (): Result => {
 			try {
 				let response: SpecificationFile;
-				let autoDetectedSpecFile = contextService.autoDetectSpecFile();
+				const autoDetectedSpecFile = contextService.autoDetectSpecFile();
 				if (autoDetectedSpecFile) {
 					response = new SpecificationFile(autoDetectedSpecFile);
 					return { response };
 				}
-				let context = contextService.loadContextFile();
+				const context = contextService.loadContextFile();
 				//@ts-ignore
 				response = new SpecificationFile(context.store[context.current]);
 				return { response };
@@ -95,14 +95,65 @@ export const useContextFile = () => {
 		},
 		getContext: (key: string): Result => {
 			try {
-				let ctx = contextService.loadContextFile();
+				const ctx = contextService.loadContextFile();
 				if (!ctx.store[key]) throw new ContextNotFoundError();
 				//@ts-ignore
-				let response = new SpecificationFile(ctx.store[key]);
+				const response = new SpecificationFile(ctx.store[key]);
 				return { response }
 			} catch (error) {
 				return { error };
 			}
 		}
 	}
+}
+
+export interface useSpecFileInput {
+	file?: string,
+	context?: string
+}
+
+export interface useSpecFileOutput {
+	specFile?: SpecificationFile,
+	error?: Error
+}
+
+export const useSpecfile = (flags: useSpecFileInput): useSpecFileOutput => {
+	const contextService: ContextService = container.resolve(ContextService);
+
+	try {
+		if (flags.file) {
+			const specFile: SpecificationFile = new SpecificationFile(flags.file);
+			if (specFile.isNotValid()) throw new Error("Invalid spec path");
+			return { specFile };
+		}
+
+
+		let ctx: Context = contextService.loadContextFile();
+
+		if (flags.context) {
+			const ctxFile = ctx.store[flags.context];
+			if (!ctxFile) throw new ContextNotFoundError();
+			const specFile = new SpecificationFile(ctxFile);
+			return { specFile };
+		}
+
+		if (ctx.current) {
+			const currentFile = ctx.store[ctx.current];
+			if (!currentFile) throw new MissingCurrentContextError();
+			const specFile = new SpecificationFile(currentFile);
+			return { specFile };
+		}
+
+		const autoDetectedSpecPath = contextService.autoDetectSpecFile();
+
+		if (typeof autoDetectedSpecPath === 'undefined') throw new Error("No spec path found in your working directory, please use flags or store a context");
+
+		const specFile = new SpecificationFile(autoDetectedSpecPath);
+
+		return { specFile };
+
+	} catch (error) {
+		return { error };
+	}
+
 }

Original file line number	Diff line number	Diff line change
`@@ -39,4 +39,12 @@ export class ContextTestingHelper {`
`39`	`39`	`getPath(key: string) {`
`40`	`40`	`return this._context.store[key];`
`41`	`41`	`}`
	`42`	`+`
	`43`	`+ createSpecFileAtWorkingDir() {`
	`44`	`+ if (!fs.existsSync(path.resolve(process.cwd(), 'asyncapi.yml'))) fs.writeFileSync(path.resolve(process.cwd(), 'asyncapi.yml'), '');`
	`45`	`+ }`
	`46`	`+`
	`47`	`+ deleteSpecFileAtWorkingDir() {`
	`48`	`+ if (fs.existsSync(path.resolve(process.cwd(), 'asyncapi.yml'))) fs.unlinkSync(path.resolve(process.cwd(), 'asyncapi.yml'));`
	`49`	`+ }`
`42`	`50`	`}`