fix(cli): streamline cli based on tests

package.json

@@ -10,7 +10,7 @@
   ],
   "main": "dist/index.js",
   "bin": "bin/sass-build.js",
-  "types": "lib/types/index.d.ts",
+  "types": "types/index.d.ts",
   "files": [
     "bin/",
     "dist/",

src/build/build-files.ts

@@ -1,6 +1,6 @@
 import { wrapCompiler } from '../compiler';
 
-export function sassBuildFiles( file: string | string[], output: OutputOptions = <OutputOptions>{}, options?: CliBuildOptions ) : void {
+export function sassBuildFiles( file: string | string[], output: OutputOptions = <OutputOptions> {}, options?: SassCompilerOptions ) : void {
     const compiler = wrapCompiler( options );
 
     compiler.buildFiles( file, output, options?.sassOptions );

src/build/build-string.ts

@@ -1,6 +1,6 @@
 import { wrapCompiler } from '../compiler';
 
-export function sassBuildString( source: string, outFile: string, options?: CliBuildOptions ) : void {
+export function sassBuildString( source: string, outFile: string, options?: SassCompilerOptions ) : void {
     const compiler = wrapCompiler( options );
 
     compiler.buildString( source, outFile, options?.sassOptions );

src/build/build.ts

@@ -1,6 +1,6 @@
 import { wrapCompiler } from '../compiler';
 
-export function sassBuild( file: string, outFile: string, options?: CliBuildOptions ) : void {
+export function sassBuild( file: string, outFile: string, options?: SassCompilerOptions ) : void {
     const compiler = wrapCompiler( options );
 
     compiler.build( file, outFile, options?.sassOptions );

src/cli/commands/build/validate-params.ts

@@ -22,22 +22,27 @@ export function validateParams( params ) {
         }
     }
 
+    if ( source !== undefined ) {
+        if ( typeof source !== 'string' ) {
+            throw new Error( '--source must be string.' );
+        }
+        if (outFile === undefined) {
+            throw new Error( 'Supply --outFile.' );
+        }
+    }
+
     if ( glob !== undefined ) {
         if (typeof glob !== 'string' && !Array.isArray(glob)) {
             throw new Error( '--glob must be either string or array.' );
         }
         if (glob === '' || (Array.isArray( glob ) && glob.length === 0 ) ) {
             throw new Error( '--glob must not be empty.' );
         }
-        if (Array.isArray(glob) && outFile) {
+        if (outFile) {
             throw new Error( 'Supply --outDir instead of --outFile.' );
         }
     }
 
-    if ( source !== undefined && typeof source !== 'string' ) {
-        throw new Error( '--source must be string.' );
-    }
-
     if ( outFile !== undefined && typeof outFile !== 'string' ) {
         throw new Error( '--outFile must be string.' );
     }

src/cli/commands/compile/validate-params.ts

@@ -5,25 +5,23 @@ import { logger } from "../../../utils";
 export function validateParams( params ) {
     logger.silly('cli > compile', 'Validating params...');
 
-    const { file, source, glob, outFile, outDir } = params;
+    const { file, source, outFile, outDir } = params;
 
-    if (file && source) {
-        throw new Error('Supply either --file or --source, but not both.');
-    }
-    if ((!file && !source)) {
+    if ( file === undefined && source === undefined ) {
         throw new Error('Supply either --file or --source.');
     }
 
-    if (glob || outFile || outDir) {
-        throw new Error('Do not supply --glob, --outFile or --outDir.');
-    }
-
-    if (file && typeof file !== 'string') {
+    if ( file && typeof file !== 'string' ) {
         throw new Error('--file must be string.');
     }
-    if (source && typeof source !== 'string') {
+
+    if ( source && typeof source !== 'string' ) {
         throw new Error('--source must be string.');
     }
 
+    if ( outFile !== undefined || outDir !== undefined ) {
+        throw new Error('Do not supply --outFile or --outDir.');
+    }
+
     logger.silly('cli > compile', 'Params validated.');
 }

src/cli/commands/info/validate-params.ts

@@ -2,7 +2,12 @@
 export function validateParams( params ) {
     const { file, source, glob, outFile, outDir } = params;
 
-    if ( file || source || glob || outFile || outDir ) {
+    if ( file !== undefined
+        || source !== undefined
+        || glob !== undefined
+        || outFile !== undefined
+        || outDir !== undefined
+    ) {
         throw new Error( 'Command "info" does not accept additional parameters.' );
     }
 

src/cli/index.ts

@@ -1,3 +1,5 @@
+/// <reference path="../../types/index.d.ts" />
+
 import fs from 'fs';
 import path from 'path';
 import argsParser from 'yargs-parser';
@@ -30,6 +32,24 @@ export function cli() {
 
     const argv = argsParser( process.argv.slice(2), ARGS_PARSER_OPTIONS );
 
+    const { command, params, config } = parseArgs( argv );
+
+    if ( typeof command === 'function' ) {
+        command( params );
+        exitSuccess();
+    }
+
+    if ( config !== undefined ) {
+        processConfigFile( config );
+        exitSuccess();
+    }
+
+    process.stdout.write( 'No command passed and no default config found!\n' );
+    process.exit(0);
+}
+
+function parseArgs( argv : argsParser.Arguments ) : { command?: Function, params?: any, config?: string } {
+
     try {
         validateParams( argv, ARGS_PARSER_OPTIONS );
     } catch ( err ) {
@@ -53,37 +73,38 @@ export function cli() {
     if ( debug ) {
         logger.level = 'debug';
         logger.silly( 'cli', 'Starting in debug mode.' );
-        logger.silly( 'cli', 'Arguments parsed.' );
     }
 
     if ( commandName ) {
-        logger.silly( 'cli', 'Command passed' );
         logger.silly( 'cli', 'Command is: %s', commandName );
 
-        command( params );
-        exitSuccess();
+        return { command, params };
     }
     logger.silly( 'cli', 'No command passed.' );
 
     if ( config ) {
-        logger.silly( 'cli', 'Config passed' );
+        logger.silly( 'cli', 'Config passed: %s', config );
 
-        processConfigFile( config );
-        exitSuccess();
+        return { config };
     }
-
     logger.silly( 'cli', 'No config passed.' );
 
-    if ( Object.keys(params).length > 0 ) {
-        logger.silly( 'cli', 'Parameters passed.' );
-        logger.silly( 'cli', 'Falling back to build command' );
+    const hasParams = Object.values(params).filter( item => item !== undefined).length > 0;
+    const hasConfig = fs.existsSync( 'sass.config.js' );
 
-        commands.get( 'build' )( params );
-        exitSuccess();
+    if ( hasParams ) {
+        logger.silly( 'cli', 'Attempting build command with cli parameters' );
+
+        return { command: commands.get( 'build' ), params };
+    }
+
+    if ( hasConfig ) {
+        logger.silly( 'cli', 'Attempting to process default config' );
+
+        return { config: null };
     }
 
-    processConfigFile( null );
-    exitSuccess();
+    return {};
 }
 
 function exitSuccess() {

src/cli/validate-params.ts

@@ -26,16 +26,22 @@ export function validateParams( argv: argsParser.Arguments, argsParserOpts: args
         throw new Error( 'Unknown parameters passed.' );
     }
 
-    // Throw error for extra parameters for version command
-    if ( version
+    // Throw error for command with --version parameter
+    if ( version && commandName !== undefined ) {
+        throw new Error( '--version parameter cannot be passed to commands.' );
+    }
+
+    // Throw error for --version parameter with other parameters
+    if (
+        version
         && (
-            commandName
+            params.length > 0
             || restParams.length > 0
             || config
             || debug
         )
     ) {
-        throw new Error( 'Version parameter cannot be passed with other parameters.' );
+        throw new Error( '--version parameter cannot be used with other parameters.' );
     }
 
     // Throw error for empty command name
@@ -45,37 +51,37 @@ export function validateParams( argv: argsParser.Arguments, argsParserOpts: args
 
     // Throw error for unknown command
     if ( commandName !== undefined && typeof command !== 'function' ) {
-        throw new Error( `Command not found: ${commandName}` );
-    }
-
-    // Throw error for command and config passed together
-    if ( commandName !== undefined && config !== undefined) {
-        throw new Error( `Command ${commandName} and config param cannot be passed together.` );
+        throw new Error( `Command not found: ${commandName}.` );
     }
 
     // Throw error for debug parameter for info
     if ( commandName === 'info' && debug ) {
-        throw new Error( 'Debug parameter cannot be passed with info command.' );
+        throw new Error( '--debug parameter cannot be passed to "info" command.' );
+    }
+
+    // Throw error for command with config parameter
+    if ( commandName !== undefined && config !== undefined) {
+        throw new Error( '--config parameter cannot be passed to commands.' );
     }
 
     // Throw error for extra parameters for config
     if ( config !== undefined && params.length > 0 ) {
-        throw new Error( 'Config parameter cannot be passed with other parameters.' );
+        throw new Error( '--config parameter cannot be used with other parameters.' );
     }
 
     if ( file !== undefined && source !== undefined ) {
-        throw new Error( 'File and source parameters cannot be passed together.' );
+        throw new Error( '--file and --source parameters cannot be used together.' );
     }
 
     if ( file !== undefined && glob !== undefined ) {
-        throw new Error( 'File and glob parameters cannot be passed together.' );
+        throw new Error( '--file and --glob parameters cannot be used together.' );
     }
 
     if ( source !== undefined && glob !== undefined ) {
-        throw new Error( 'Source and glob parameters cannot be passed together.' );
+        throw new Error( '--source and --glob parameters cannot be used together.' );
     }
 
     if ( outFile !== undefined && outDir !== undefined ) {
-        throw new Error( 'Out file and out dir parameters cannot be passed together.' );
+        throw new Error( '--outFile and --outDir parameters cannot be used together.' );
     }
 }

src/compile/compile-string.ts

@@ -1,6 +1,6 @@
 import { wrapCompiler } from '../compiler';
 
-export function sassCompileString( source: string, options?: CliBuildOptions ) : string {
+export function sassCompileString( source: string, options?: SassCompilerOptions ) : string {
     const compiler = wrapCompiler( options );
 
     return compiler.compileString( source, options?.sassOptions );

src/compile/compile.ts

@@ -1,6 +1,6 @@
 import { wrapCompiler } from '../compiler';
 
-export function sassCompile( file: string, options?: CliBuildOptions ) : string {
+export function sassCompile( file: string, options?: SassCompilerOptions ) : string {
     const compiler = wrapCompiler( options );
 
     return compiler.compile( file, options?.sassOptions );

src/compiler/base-sass-compiler.ts

@@ -15,9 +15,9 @@ import {
 export abstract class BaseSassCompiler implements SassCompiler {
     protected compiler: NativeSassCompiler;
     protected postcss: PostcssProcessor;
-    protected options: CliBuildOptions;
+    protected options: SassCompilerOptions;
 
-    constructor(options: CliBuildOptions) {
+    constructor(options: SassCompilerOptions) {
         this.options = options;
         this.compiler = <NativeSassCompiler> this.options.compiler;
         this.postcss = <PostcssProcessor> this.options.postcss;

src/compiler/index.ts

@@ -10,11 +10,11 @@ import { ModernSassCompiler } from './modern-sass-compiler';
 import { LegacySassCompiler } from './legacy-sass-compiler';
 
 
-export function wrapCompiler( options?: CliBuildOptions ) : SassCompiler {
-    const defaults = <Partial<CliBuildOptions>>{
+export function wrapCompiler( options?: SassCompilerOptions ) : SassCompiler {
+    const defaults = <Partial<SassCompilerOptions>> {
         cwd: CWD
     };
-    const opts = _.defaultsDeep( {}, options, defaults );
+    const opts = <SassCompilerOptions> _.defaultsDeep( {}, options, defaults );
 
     opts.compiler = getSassCompiler( opts.compiler );
     opts.postcss = getPostcss( opts.postcss );

types/build/index.d.ts

@@ -0,0 +1 @@
+/// <reference path="build-options.d.ts" />

types/cli/cli-options.d.ts

@@ -1,16 +1,9 @@
-declare type ApiType = 'modern' | 'legacy';
-
 declare type CommonCliOptions = {
     cwd: string;
 }
 
 
-declare type CliBuildOptions = CommonCliOptions & {
-    compiler: string | NativeSassCompiler;
-    api: ApiType;
-    postcss: false | 'auto' | [] | PostcssProcessor;
-    sassOptions: SassOptions;
-}
+declare type CliBuildOptions = CommonCliOptions & SassCompilerOptions;
 declare type CliBuilder = string | Function | {
     buildFile: Function;
     buildGlob: Function;

types/compile/index.d.ts

@@ -0,0 +1 @@
+/// <reference path="compile-options.d.ts" />

types/compiler/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="sass-compile-result.d.ts" />
+/// <reference path="sass-compiler.d.ts" />
+/// <reference path="sass-options.d.ts" />

types/compiler/sass-compiler.d.ts

@@ -0,0 +1,34 @@
+declare type ApiType = 'legacy' | 'modern';
+
+declare type SassCompilerOptions = {
+    compiler: string | NativeSassCompiler;
+    api: ApiType;
+    postcss: false | 'auto' | [] | PostcssProcessor;
+    sassOptions: SassOptions;
+    cwd: string;
+};
+
+declare type SassCompiler = {
+    build(file: string, outFile: string, sassOptions?: SassOptions) : void;
+    buildFiles(files: string | string[], output: OutputOptions, sassOptions?: SassOptions) : void;
+    buildString(source: string, outFile: string, sassOptions?: SassOptions) : void;
+    compile(file: string, sassOptions?: SassOptions) : string;
+    compileString(source: string, sassOptions?: SassOptions) : string;
+    info: string;
+}
+
+declare type LegacySassImplementation = {
+    renderSync(options: LegacySassOptions): LegacyCompileResult;
+    renderSync(options: Omit<LegacySassOptions, 'data'>): LegacyCompileResult;
+    logger: SassLogger;
+    info: string;
+}
+
+declare type ModernSassImplementation = {
+    compile(file: string, options: ModernSassOptions) : ModernCompileResult;
+    compileString(source: string, options: ModernSassOptions): ModernCompileResult;
+    logger: SassLogger;
+    info: string;
+}
+
+declare type NativeSassCompiler = LegacySassImplementation | ModernSassImplementation;