Apply some rudimentary workarounds for outstanding TS issues

src/@types/nodeError.d.ts

@@ -0,0 +1,6 @@
+declare interface Error {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: number | string;
+}

src/cmd/build/index.ts

@@ -21,6 +21,8 @@
 import {prepareMapFile} from '../../steps/processMapFile';
 import {copyFiles, logger} from '../../utils';
 import {upload as publishFilesToS3} from '../../commands/publish/upload';
+import {YfmArgv} from '../../models';
+import {Run} from '../../commands/publish';
 
 export const build = {
     command: ['build', '$0'],
@@ -174,13 +176,13 @@
         );
 }
 
-async function handler(args: Arguments<any>) {
+async function handler(args: Arguments<YfmArgv>) {
     const userOutputFolder = resolve(args.output);
     const tmpInputFolder = resolve(args.output, TMP_INPUT_FOLDER);
     const tmpOutputFolder = resolve(args.output, TMP_OUTPUT_FOLDER);
 
     if (typeof VERSION !== 'undefined') {
         console.log(`Using v${VERSION} version`);
     }
 
     try {
@@ -190,7 +192,7 @@
             input: tmpInputFolder,
             output: tmpOutputFolder,
         });
         Includers.init([OpenapiIncluder as any]);
 
         const {
             output: outputFolderPath,
@@ -231,7 +233,6 @@
                 outputFormat,
                 outputBundlePath,
                 tmpOutputFolder,
-                userOutputFolder,
             });
 
             await processChangelogs();
@@ -255,20 +256,25 @@
                     storageSecretKey: secretAccessKey,
                 } = ArgvService.getConfig();
 
-                await publishFilesToS3({
-                    input: userOutputFolder,
-                    region: storageRegion,
-                    ignore: [...ignore, TMP_INPUT_FOLDER, TMP_OUTPUT_FOLDER],
-                    endpoint,
-                    bucket,
-                    prefix,
-                    accessKeyId,
-                    secretAccessKey,
-                });
+                await publishFilesToS3(
+                    new Run({
+                        input: userOutputFolder,
+                        region: storageRegion,
+                        hidden: [...ignore, TMP_INPUT_FOLDER, TMP_OUTPUT_FOLDER],
+                        endpoint,
+                        bucket,
+                        prefix,
+                        accessKeyId,
+                        secretAccessKey,
+                        quiet: false,
+                    }),
+                );
             }
         }
     } catch (err) {
-        logger.error('', err.message);
+        const message = err instanceof Error ? err.message : String(err);
+
+        logger.error('', message);
     } finally {
         processLogs(tmpInputFolder);
 

src/commands/build/index.ts

@@ -1,10 +1,10 @@
-import type {IProgram} from '~/program';
+import type {IProgram, ProgramArgs} from '~/program';
 import yargs from 'yargs';
 import {hideBin} from 'yargs/helpers';
 import {Help} from 'commander';
 import log from '@diplodoc/transform/lib/log';
 
-import {BaseProgram} from '~/program/base';
+import {BaseHooks, BaseProgram} from '~/program/base';
 import {Command} from '~/config';
 import {build} from '~/cmd';
 
@@ -15,6 +15,10 @@
 export type BuildConfig = {};
 
 const parser = yargs
+    // FIXME: Since we're adding more arguments to the mix with
+    // `argvValidator` (see src/cmd/build/index.ts#L170), the type safety just completely breaks here
+    // (which makes sense, because stuff we do is absurdly unsound)
+    // @ts-expect-error
     .command(build)
     .option('config', {
         alias: 'c',
@@ -34,20 +38,21 @@
         type: 'boolean',
     })
     .group(['config', 'strict', 'quiet', 'help', 'version'], 'Common options:')
-    .version(typeof VERSION !== 'undefined' ? VERSION : '')
+    .version(typeof VERSION === 'undefined' ? '' : VERSION)
     .help();
 
 export class Build
     // eslint-disable-next-line new-cap
-    extends BaseProgram<BuildConfig, BuildArgs>(command, {
+    extends BaseProgram<BuildConfig, ProgramArgs>(command, {
         config: {
             // scope: 'build',
             defaults: () => ({}),
         },
         command: {
             isDefault: true,
         },
-        hooks: () => {},
+        // FIXME: This is a temporary workaround
+        hooks: (() => {}) as unknown as BaseHooks<BuildConfig, ProgramArgs>,
     })
     implements IProgram<BuildArgs>
 {
@@ -62,6 +67,9 @@
 
         this.command.createHelp = function () {
             const help = new Help();
+            // FIXME: This is not supposed to work, since `parser.getHelp` returns a Promise
+            // I'm not building a sync bridge for this right now
+            // @ts-expect-error
             help.formatHelp = () => parser.getHelp();
             return help;
         };
@@ -70,7 +78,7 @@
     async action() {
         await parser.parse(hideBin(process.argv), {}, (err, {strict}, output) => {
             if (err) {
                 console.error(err);
                 process.exit(1);
             }
 
@@ -80,7 +88,7 @@
                 process.exit(1);
             }
 
             console.log(output);
 
             process.exit(0);
         });

src/commands/publish/index.spec.ts

@@ -1,4 +1,5 @@
 import {describe, expect, it} from 'vitest';
+// @ts-expect-error FIXME
 import {runPublish as run, testConfig as test} from './__tests__';
 
 describe('Publish command', () => {

src/commands/translate/__tests__/index.ts

@@ -30,7 +30,7 @@
 }
 
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Record<any, any> ? DeepPartial<T[P]> : T[P];
 };
 
 export function testConfig<Config = TranslateConfig>(defaultArgs: string) {
@@ -48,7 +48,7 @@
         config: DeepPartial<Config>,
         result: Error | string,
     ): void;
     function _testConfig(name: string, args: string, config: any, result?: any): void {
         it(name, async () => {
             if (!result) {
                 result = config;
@@ -63,7 +63,7 @@
             });
 
             if (result instanceof Error || typeof result === 'string') {
-                const message = result.message || result;
+                const message = result instanceof Error ? result.message : result;
                 await expect(async () => runTranslate(defaultArgs + ' ' + args)).rejects.toThrow(
                     message,
                 );

src/config/index.ts

@@ -72,6 +72,8 @@ export function args(command: Command | null) {
     let args: string[] | undefined;
 
     while (command) {
+        // FIXME: This is probably broken
+        // @ts-expect-error
         args = command.rawArgs || args;
         command = command.parent;
     }

src/program/index.ts

@@ -42,13 +42,13 @@ export class Program
             }),
         },
     })
-    implements IProgram
+    implements IProgram<ProgramArgs>
 {
     readonly command: Command = new Command(NAME)
         .helpOption(true)
         .allowUnknownOption(false)
         .version(
-            typeof VERSION !== 'undefined' ? VERSION : '',
+            typeof VERSION === 'undefined' ? '' : VERSION,
             '--version',
             'Output the version number',
         )
@@ -75,7 +75,7 @@ export class Program
         .helpOption(false)
         .allowUnknownOption(true);
 
-    private readonly modules: ICallable[] = [this.build, this.publish, this.translate];
+    private readonly modules: ICallable<ProgramArgs>[] = [this.build, this.publish, this.translate];
 
     async init(argv: string[]) {
         const args = this.parser.parse(argv).opts() as ProgramArgs;

src/program/types.ts

@@ -5,8 +5,8 @@ import type {Logger} from '~/logger';
 // eslint-disable-next-line  @typescript-eslint/no-explicit-any
 type Hooks = Record<string, Hook<any, any> | HookMap<any>>;
 
-export interface ICallable {
-    apply(program?: IProgram): void;
+export interface ICallable<Args extends Hash = Hash> {
+    apply(program?: IProgram<Args>): void;
 }
 
 /**

src/resolvers/lintPage.ts

@@ -1,6 +1,6 @@
 import {dirname, relative, resolve} from 'path';
 import {load} from 'js-yaml';
-import log from '@diplodoc/transform/lib/log';
+import log, {LogLevels} from '@diplodoc/transform/lib/log';
 import {
     LintMarkdownFunctionOptions,
     PluginOptions,
@@ -76,15 +76,17 @@ function YamlFileLinter(content: string, lintOptions: FileTransformOptions): voi
         defaultLevel: log.LogLevels.ERROR,
     });
 
-    const contentLinks = findAllValuesByKeys(load(content), LINK_KEYS);
+    const contentLinks = findAllValuesByKeys(load(content) as object, LINK_KEYS);
     const localLinks = contentLinks.filter(
         (link) => getLinksWithExtension(link) && isLocalUrl(link),
     );
 
+    const loggerForLogLevel = logLevel === LogLevels.DISABLED ? () => undefined : log[logLevel];
+
     return localLinks.forEach(
         (link) =>
             checkPathExists(link, currentFilePath) ||
-            log[logLevel](`Link is unreachable: ${bold(link)} in ${bold(currentFilePath)}`),
+            loggerForLogLevel(`Link is unreachable: ${bold(link)} in ${bold(currentFilePath)}`),
     );
 }
 

src/resolvers/md2html.ts

@@ -114,10 +114,13 @@ export async function resolveMd2HTML(options: ResolverOptions): Promise<DocInner
     const {outputPath, inputPath, deep, deepBase} = options;
     const props = await getFileProps(options);
 
+    // FIXME: Whatever we're doing with app props in CLI is pretty unsound
+    // @ts-expect-error
     const outputFileContent = generateStaticMarkup(props, deepBase, deep);
     writeFileSync(outputPath, outputFileContent);
     logger.info(inputPath, PROCESSING_FINISHED);
 
+    // @ts-expect-error
     return props;
 }
 
@@ -170,11 +173,18 @@ function YamlFileTransformer(content: string, transformOptions: FileTransformOpt
             if (isString(link) && getLinksWithContentExtersion(link)) {
                 return link.replace(/.(md|yaml)$/gmu, '.html');
             }
+
+            return link;
         });
 
+        // FIXME: This is unsound, since `lang` does not exist on FileTransformOptions
+        // I'll leave this here for the sake of not breaking stuff
+        // @ts-expect-error
         const {path, lang} = transformOptions;
         const transformFn: Function = FileTransformer['.md'];
 
+        // FIXME: Whatever we're doing here with prop transformations, it seems quite unsound
+        // @ts-expect-error
         data = preprocess(data, {lang}, (lang, content) => {
             const {result} = transformFn(content, {path});
             return result?.html;
@@ -221,7 +231,7 @@ function MdFileTransformer(content: string, transformOptions: FileTransformOptio
 
     return transform(content, {
         ...options,
-        plugins: plugins as MarkdownItPluginCb<unknown>[],
+        plugins: plugins as MarkdownItPluginCb[],
         vars,
         root,
         path,

src/services/contributors.ts

@@ -71,7 +71,7 @@ async function getContributorsForNestedFiles(
             try {
                 contentIncludeFile = await readFile(relativeIncludeFilePath, 'utf8');
             } catch (err) {
-                if (err.code === 'ENOENT') {
+                if (err instanceof Error && err.code === 'ENOENT') {
                     continue;
                 }
                 throw err;
@@ -135,14 +135,18 @@ async function getFileIncludes(
     );
     for (const relativeIncludeFilePath of relativeIncludeFilePaths.values()) {
         const relativeFilePath = relativeIncludeFilePath.substring(inputFolderPathLength + 1);
-        if (results.has(relativeFilePath)) continue;
+
+        if (results.has(relativeFilePath)) {
+            continue;
+        }
+
         results.add(relativeFilePath);
 
         let contentIncludeFile: string;
         try {
             contentIncludeFile = await readFile(relativeIncludeFilePath, 'utf8');
         } catch (err) {
-            if (err.code === 'ENOENT') {
+            if (err instanceof Error && err.code === 'ENOENT') {
                 continue;
             }
             throw err;

src/services/includers/batteries/generic.ts

@@ -83,7 +83,9 @@ async function includerFunction(params: IncluderFunctionParams<Params>) {
 
         await writeFile(join(writePath, 'toc.yaml'), dump(toc));
     } catch (err) {
-        throw new GenericIncluderError(err.toString(), tocPath);
+        const message = err instanceof Error ? err.message : String(err);
+
+        throw new GenericIncluderError(message, tocPath);
     }
 }
 

src/services/includers/batteries/unarchive.ts

@@ -92,7 +92,9 @@ async function includerFunction(params: IncluderFunctionParams<Params>) {
     try {
         await pipeline(contentPath, writePath);
     } catch (err) {
-        throw new UnarchiveIncluderError(err.toString(), tocPath);
+        const message = err instanceof Error ? err.message : String(err);
+
+        throw new UnarchiveIncluderError(message, tocPath);
     }
 }