chore: tests

Author: vladfrangu

features/test-implementations/0.world.ts

@@ -49,7 +49,7 @@ export interface TestWorld<Parameters = unknown[]> extends IWorld<Parameters> {
  */
 export const ProjectRoot = new URL('../../', import.meta.url);
 
-export const DevRunFile = new URL('./bin/dev.js', ProjectRoot);
+export const DevRunFile = new URL('./src/entrypoints/apify.ts', ProjectRoot);
 
 export const TestTmpRoot = new URL('./test/tmp/', ProjectRoot);
 

src/entrypoints/_shared.ts

@@ -13,14 +13,9 @@ yargonaut //
 
 export const cli = yargs()
 	.scriptName('apify')
-	.version(version)
-	// This needs to be manually handled, as setting it here will override any `-v` flags used in commands (e.g: `apify runs info -v`)
-	// .alias('v', 'version')
-	// TODO: we can override the help message by disabling the built in help flag, then implementing it on the commands
-	// .help()
-	// TODO: if we set `h` here, no commands can use `h` as a char for a flag, unless we manually handle help messages ourselves
-	.alias('h', 'help')
-	.wrap(Math.max(80, process.stdout.columns || 80))
+	.version(false)
+	.help(false)
+	// .wrap(Math.max(80, process.stdout.columns || 80))
 	.parserConfiguration({
 		// Disables the automatic conversion of `--foo-bar` to `fooBar` (we handle it manually)
 		'camel-case-expansion': false,
@@ -29,10 +24,6 @@ export const cli = yargs()
 		// We parse numbers manually
 		'parse-numbers': false,
 		'parse-positional-numbers': false,
-	})
-	.strictCommands()
-	.updateStrings({
-		'Positionals:': 'Arguments:',
 	});
 
 // @ts-expect-error @types/yargs is outdated -.-

src/entrypoints/apify.ts

@@ -39,7 +39,7 @@ for (const CommandClass of apifyCommands) {
 const parsed = await cli.parse(process.argv.slice(2));
 
 if (parsed._.length === 0) {
-	if (parsed.v === true) {
+	if (parsed.v === true || parsed.version === true) {
 		printCLIVersionAndExit();
 	}
 

src/lib/apify-oclif-help.ts

@@ -25,19 +25,50 @@ type InferArgTypeFromArg<Builder extends TaggedArgBuilder<ArgTag, unknown>> = Bu
 	: unknown;
 
 type If<T, Y, N> = T extends true ? Y : N;
-
-type InferFlagTypeFromFlag<Builder extends TaggedFlagBuilder<FlagTag, unknown, unknown>> =
-	// Handle special case where there can be no choices
-	Builder extends TaggedFlagBuilder<infer ReturnedType, never, infer Required>
-		? If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
-		: // Might have choices, in which case we branch based on that
-			Builder extends TaggedFlagBuilder<infer ReturnedType, infer ChoiceType, infer Required>
-			? // If choices is a valid array
-				ChoiceType extends unknown[] | readonly unknown[]
-				? // Then assert on required status
+type IfNotUnknown<T, Y, N> = T extends unknown ? Y : N;
+
+type InferFlagTypeFromFlag<
+	Builder extends TaggedFlagBuilder<FlagTag, unknown, unknown, unknown>,
+	OptionalIfHasDefault = false,
+> = Builder extends TaggedFlagBuilder<infer ReturnedType, never, infer Required, infer HasDefault> // Handle special case where there can be no choices
+	? If<
+			// If we want to mark flags as optional if they have a default
+			OptionalIfHasDefault,
+			// If the flag actually has a default value, assert on that
+			IfNotUnknown<
+				HasDefault,
+				FlagTagToTSType[ReturnedType] | undefined,
+				// Otherwise fall back to required status
+				If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
+			>,
+			// fallback to required status
+			If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
+		>
+	: // Might have choices, in which case we branch based on that
+		Builder extends TaggedFlagBuilder<infer ReturnedType, infer ChoiceType, infer Required, infer HasDefault>
+		? // If choices is a valid array
+			ChoiceType extends unknown[] | readonly unknown[]
+			? // If we want optional flags to stay as optional
+				If<
+					OptionalIfHasDefault,
+					ChoiceType[number] | undefined,
+					// fallback to required status
 					If<Required, ChoiceType[number], ChoiceType[number] | undefined>
-				: If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
-			: unknown;
+				>
+			: If<
+					// If we want to mark flags as optional if they have a default
+					OptionalIfHasDefault,
+					// If the flag actually has a default value, assert on that
+					IfNotUnknown<
+						HasDefault,
+						FlagTagToTSType[ReturnedType] | undefined,
+						// Fallback to required status
+						If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
+					>,
+					// fallback to required status
+					If<Required, FlagTagToTSType[ReturnedType], FlagTagToTSType[ReturnedType] | undefined>
+				>
+		: unknown;
 
 // Adapted from https://gist.github.com/kuroski/9a7ae8e5e5c9e22985364d1ddbf3389d to support kebab-case and "string a"
 type CamelCase<S extends string> = S extends
@@ -51,16 +82,23 @@ type _InferArgsFromCommand<O extends Record<string, TaggedArgBuilder<ArgTag, unk
 	[K in keyof O as CamelCase<string & K>]: InferArgTypeFromArg<O[K]>;
 };
 
-type _InferFlagsFromCommand<O extends Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown>>> = {
-	[K in keyof O as CamelCase<string & K>]: InferFlagTypeFromFlag<O[K]>;
+type _InferFlagsFromCommand<
+	O extends Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown, unknown>>,
+	OptionalIfHasDefault = false,
+> = {
+	[K in keyof O as CamelCase<string & K>]: InferFlagTypeFromFlag<O[K], OptionalIfHasDefault>;
 };
 
 type InferArgsFromCommand<O extends Record<string, TaggedArgBuilder<ArgTag, unknown>> | undefined> = O extends undefined
 	? Record<string, unknown>
 	: _InferArgsFromCommand<Exclude<O, undefined>>;
 
-type InferFlagsFromCommand<O extends Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown>> | undefined> =
-	(O extends undefined ? Record<string, unknown> : _InferFlagsFromCommand<Exclude<O, undefined>>) & { json: boolean };
+type InferFlagsFromCommand<
+	O extends Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown, unknown>> | undefined,
+	OptionalIfHasDefault = false,
+> = (O extends undefined
+	? Record<string, unknown>
+	: _InferFlagsFromCommand<Exclude<O, undefined>, OptionalIfHasDefault>) & { json: boolean };
 
 function camelCaseString(str: string): string {
 	return str.replace(/[-_\s](.)/g, (_, group1) => group1.toUpperCase());
@@ -74,16 +112,12 @@ function camelCaseToKebabCase(str: string): string {
 	return str.replace(/([A-Z])/g, '-$1').toLowerCase();
 }
 
-function kebabCaseToSnakeCase(str: string): string {
-	return str.replaceAll('-', '_').toLowerCase();
-}
-
 export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof BuiltApifyCommand> {
 	static args?: Record<string, TaggedArgBuilder<ArgTag, unknown>> & {
 		json?: 'Do not use json as the key of an argument, as it will prevent the --json flag from working';
 	};
 
-	static flags?: Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown>> & {
+	static flags?: Record<string, TaggedFlagBuilder<FlagTag, unknown, unknown, unknown>> & {
 		json?: 'Do not use json as the key of a flag, override the enableJsonFlag static property instead';
 	};
 
@@ -101,7 +135,7 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 
 	static hiddenAliases?: string[];
 
-	protected telemetryData!: Record<string, unknown>;
+	protected telemetryData: Record<string, unknown> = {};
 
 	protected flags!: InferFlagsFromCommand<T['flags']>;
 	protected args!: InferArgsFromCommand<T['args']>;
@@ -116,6 +150,10 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 		return amount === 1 ? singular : plural;
 	}
 
+	protected printHelp() {
+		console.log(`TODO!!! Command ${this.ctor.name} wants to print help manually`);
+	}
+
 	private async _run(rawArgs: ArgumentsCamelCase) {
 		// Cheating a bit here with the types, but its fine
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any -- makes parsing easier
@@ -193,11 +231,15 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 			}
 		}
 
+		// TODO: remove me
+		// console.log({ rawInput: rawArgs, args: this.args, flags: this.flags });
+
 		try {
 			await this.run();
-		} catch (err) {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		} catch (err: any) {
 			// TODO: handle errors gracefully with a logger
-			console.error(err);
+			console.error(err.message);
 		}
 	}
 
@@ -256,10 +298,8 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 					}
 
 					const flagKey = kebabCaseString(camelCaseToKebabCase(key)).toLowerCase();
-					const camelCaseKey = camelCaseString(key);
-					const snakeCaseKey = kebabCaseToSnakeCase(flagKey);
 
-					finalYargs = internalBuilderData.builder(finalYargs, flagKey, [camelCaseKey, snakeCaseKey]);
+					finalYargs = internalBuilderData.builder(finalYargs, flagKey);
 				}
 			}
 
@@ -315,6 +355,96 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 	}
 }
 
+// Utility type to extract only the keys that are optional
+type ExtractOptionalFlagKeys<Cmd extends typeof BuiltApifyCommand> = {
+	[K in keyof InferFlagsFromCommand<Cmd['flags'], true>]: [undefined] extends [
+		InferFlagsFromCommand<Cmd['flags'], true>[K],
+	]
+		? K
+		: never;
+}[keyof InferFlagsFromCommand<Cmd['flags'], true>];
+
+type ExtractOptionalArgKeys<Cmd extends typeof BuiltApifyCommand> = {
+	[K in keyof InferArgsFromCommand<Cmd['args']>]: [undefined] extends [InferArgsFromCommand<Cmd['args']>[K]]
+		? K
+		: never;
+}[keyof InferArgsFromCommand<Cmd['args']>];
+
+// Messy type...
+type StaticArgsFlagsInput<Cmd extends typeof BuiltApifyCommand> = Omit<
+	{
+		// This ensures we only get the required args
+		[K in Exclude<
+			keyof InferArgsFromCommand<Cmd['args']>,
+			ExtractOptionalArgKeys<Cmd>
+		> as `args_${string & K}`]: InferArgsFromCommand<Cmd['args']>[K];
+	},
+	// Omit args_json as it is used only to throw an error if the user provides it
+	'args_json'
+> &
+	Omit<
+		{
+			// Fill in the rest of the args, this will not override what the code above does
+			[K in keyof InferArgsFromCommand<Cmd['args']> as `args_${string & K}`]?: InferArgsFromCommand<
+				Cmd['args']
+			>[K];
+		},
+		'args_json'
+	> &
+	Omit<
+		{
+			// This ensures we only ever get the required flags into this object, as `key?: type` and `key: type | undefined` are not the same (one is optionally present, the other is mandatory)
+			[K in Exclude<
+				keyof InferFlagsFromCommand<Cmd['flags'], true>,
+				ExtractOptionalFlagKeys<Cmd>
+			> as `flags_${string & K}`]: InferFlagsFromCommand<Cmd['flags'], true>[K];
+		},
+		// Omit flags_json as it is used only to throw an error if the user provides it
+		'flags_json'
+	> &
+	Omit<
+		{
+			// Fill in the rest of the flags, this will not override what the code above does
+			[K in keyof InferFlagsFromCommand<Cmd['flags'], true> as `flags_${string & K}`]?: InferFlagsFromCommand<
+				Cmd['flags'],
+				true
+			>[K];
+		},
+		// Omit flags_json as it is used only to throw an error if the user provides it
+		'flags_json'
+	> & {
+		// Define it at the end exactly like it is
+		flags_json?: boolean;
+	};
+
+export async function runCommand<Cmd extends typeof BuiltApifyCommand>(
+	command: Cmd,
+	argsFlags: StaticArgsFlagsInput<Cmd>,
+) {
+	// This is very much yolo'd in, but its purpose is for testing only
+	const rawObject: ArgumentsCamelCase = {
+		_: [],
+		$0: 'apify',
+	};
+
+	for (const [key, value] of Object.entries(argsFlags)) {
+		const [type, rawKey] = key.split('_');
+
+		if (type === 'args') {
+			rawObject[rawKey] = value;
+		} else {
+			const yargsFlagName = kebabCaseString(camelCaseToKebabCase(rawKey)).toLowerCase();
+
+			rawObject[yargsFlagName] = value;
+		}
+	}
+
+	const instance = new (command as typeof BuiltApifyCommand)();
+
+	// eslint-disable-next-line dot-notation
+	await instance['_run'](rawObject);
+}
+
 export declare class BuiltApifyCommand extends ApifyCommand {
-	override run(): void;
+	override run(): Awaitable<void>;
 }