apify-schema-tools 3.1.0 → 3.2.1

package/samples/package-json-config/.actor/input_schema.json

@@ -9,7 +9,15 @@
 			"title": "Start URLs",
 			"description": "List of URLs to scrape",
 			"default": [],
-			"editor": "requestListSources"
+			"editor": "requestListSources",
+			"items": {
+				"type": "object",
+				"properties": {
+					"url": {
+						"type": "string"
+					}
+				}
+			}
 		},
 		"searchTerm": {
 			"type": "string",
@@ -22,7 +30,21 @@
 			"type": "array",
 			"title": "Categories",
 			"description": "List of categories to filter results",
-			"default": []
+			"default": [],
+			"items": {
+				"type": "object",
+				"properties": {
+					"name": {
+						"type": "string",
+						"title": "Category name"
+					},
+					"id": {
+						"type": "string",
+						"title": "Category ID"
+					}
+				},
+				"additionalProperties": false
+			}
 		},
 		"maxPages": {
 			"type": "integer",
@@ -40,7 +62,14 @@
 			"description": "Proxy settings",
 			"default": {
 				"useApifyProxy": true
-			}
+			},
+			"properties": {
+				"useApifyProxy": {
+					"type": "boolean",
+					"default": true
+				}
+			},
+			"additionalProperties": true
 		},
 		"debugMode": {
 			"type": "boolean",

package/samples/package-json-config-merged/.actor/input_schema.json

@@ -9,7 +9,15 @@
 			"title": "Start URLs",
 			"description": "List of URLs to scrape",
 			"default": [],
-			"editor": "requestListSources"
+			"editor": "requestListSources",
+			"items": {
+				"type": "object",
+				"properties": {
+					"url": {
+						"type": "string"
+					}
+				}
+			}
 		},
 		"searchTerm": {
 			"type": "string",
@@ -22,7 +30,21 @@
 			"type": "array",
 			"title": "Categories",
 			"description": "List of categories to filter results",
-			"default": []
+			"default": [],
+			"items": {
+				"type": "object",
+				"properties": {
+					"name": {
+						"type": "string",
+						"title": "Category name"
+					},
+					"id": {
+						"type": "string",
+						"title": "Category ID"
+					}
+				},
+				"additionalProperties": false
+			}
 		},
 		"maxPages": {
 			"type": "integer",
@@ -40,7 +62,18 @@
 			"description": "Proxy settings",
 			"default": {
 				"useApifyProxy": true
-			}
+			},
+			"properties": {
+				"useApifyProxy": {
+					"type": "boolean",
+					"default": true
+				},
+				"proxyCountry": {
+					"type": "string",
+					"default": "US"
+				}
+			},
+			"additionalProperties": true
 		},
 		"debugMode": {
 			"type": "boolean",

package/src/apify.ts

@@ -1,6 +1,8 @@
 import { dirname, relative } from "node:path";
-import { filterValidSchemaProperties, type ObjectSchema, type OmissibleField } from "./json-schemas.js";
-import { jsonSchemaToTypeScriptInterface, serializeTypeScriptSchema, type TypeScriptInterface } from "./typescript.js";
+import { serializeMiddleSchemaToTypeScript } from "./middle-schema/generate-typescript.js";
+import { jsonSchemaToMiddleObject } from "./middle-schema/parse-json-schema.js";
+import type { MiddleObject } from "./middle-schema/schema-types.js";
+import { filterValidSchemaProperties, type ObjectSchema, type OmissibleField } from "./utils/json-schemas.js";
 
 export const ACTOR_CONFIG_PATH = ".actor/actor.json";
 
@@ -38,7 +40,18 @@ const VALID_INPUT_PROPERTY_KEYS_BY_TYPE: Record<string, string[]> = {
 	],
 	boolean: ["editor", "groupCaption", "groupDescription", "nullable"],
 	integer: ["editor", "maximum", "minimum", "unit", "nullable"],
-	object: ["editor", "patternKey", "patternValue", "maxProperties", "minProperties", "nullable"],
+	object: [
+		"editor",
+		"patternKey",
+		"patternValue",
+		"maxProperties",
+		"minProperties",
+		"nullable",
+		"isSecret",
+		"properties",
+		"additionalProperties",
+		"required",
+	],
 	array: [
 		"editor",
 		"placeholderKey",
@@ -49,6 +62,8 @@ const VALID_INPUT_PROPERTY_KEYS_BY_TYPE: Record<string, string[]> = {
 		"minItems",
 		"uniqueItems",
 		"nullable",
+		"items",
+		"isSecret",
 		"resourceType",
 	],
 };
@@ -76,9 +91,9 @@ export function generateInputDefaultsTsFileContent(inputSchema: ObjectSchema): s
 		}
 	}
 
-	const tsInterface = jsonSchemaToTypeScriptInterface(inputSchema);
+	const tsInterface = jsonSchemaToMiddleObject(inputSchema);
 
-	const defaultInterface: TypeScriptInterface = {
+	const defaultInterface: MiddleObject = {
 		isArray: false,
 		isRequired: true,
 		properties: {},
@@ -104,7 +119,7 @@ import type { Input } from "./input.js";
 ${
 	areThereDefaults
 		? `\
-interface DefaultInputs ${serializeTypeScriptSchema(defaultInterface)};
+interface DefaultInputs ${serializeMiddleSchemaToTypeScript(defaultInterface)};
 
 export type InputWithDefaults = Input & DefaultInputs;
 

package/src/cli/check.ts

@@ -0,0 +1,114 @@
+/** biome-ignore-all lint/style/useNamingConvention: the package `argparse` uses snake_case names */
+
+import { join } from "node:path";
+import { ArgumentDefaultsHelpFormatter, type SubParser } from "argparse";
+import { DATASET_SCHEMA_FIELD, DESCRIPTION_FIELDS, filterValidInputSchemaProperties } from "../apify.js";
+import { addCommonCliArgs, type CommonCliArgs, type Configuration } from "../configuration.js";
+import { compareMiddleObjects } from "../middle-schema/compare-schemas.js";
+import { jsonSchemaToMiddleObject } from "../middle-schema/parse-json-schema.js";
+import { parseTypeScriptInterface, removeTypeScriptHeader } from "../middle-schema/parse-typescript.js";
+import { readFile } from "../utils/filesystem.js";
+import { compareSchemas, mergeObjectSchemas, readJsonSchema, readJsonSchemaField } from "../utils/json-schemas.js";
+
+interface CheckArgs extends CommonCliArgs {
+	ignore_descriptions: boolean;
+}
+
+export function setupCheckParser(subparsers: SubParser, configuration: Configuration): void {
+	const checkParser = subparsers.add_parser("check", {
+		help: "Check the schemas for consistency and correctness. (WARNING: input utils will not be checked!)",
+		formatter_class: ArgumentDefaultsHelpFormatter,
+	});
+	addCommonCliArgs(checkParser, configuration);
+	checkParser.add_argument("--ignore-descriptions", {
+		help: "ignore the 'title' and 'description' fields during the comparison",
+		action: "store_true",
+		default: false,
+	});
+	checkParser.set_defaults({ func: check });
+}
+
+function check(args: CheckArgs): void {
+	if (args.input.includes("input")) {
+		checkInputSchemas(args);
+	}
+	if (args.input.includes("dataset")) {
+		checkDatasetSchemas(args);
+	}
+	console.log("Check passed.");
+}
+
+function checkInputSchemas(args: CheckArgs): void {
+	let sourceInputSchema = readJsonSchema(args.src_input);
+	if (args.add_input) {
+		sourceInputSchema = mergeObjectSchemas(sourceInputSchema, readJsonSchema(args.add_input), args.deep_merge);
+	}
+	const generatedInputSchema = filterValidInputSchemaProperties(sourceInputSchema);
+	if (args.output.includes("json-schemas")) {
+		const outputInputSchema = readJsonSchema(args.input_schema);
+		const isInputSchemaCoherent = compareSchemas(
+			generatedInputSchema,
+			outputInputSchema,
+			args.ignore_descriptions ? DESCRIPTION_FIELDS : undefined,
+		);
+		if (!isInputSchemaCoherent) {
+			console.error("Input schema validation failed: the input schema does not match the source schema.");
+			process.exit(1);
+		}
+	}
+	if (args.output.includes("ts-types")) {
+		const inputTsContent = readFile(join(args.output_ts_dir, "input.ts"));
+		const inputMiddleObject = parseTypeScriptInterface(removeTypeScriptHeader(inputTsContent));
+		const sourceInputMiddleObject = jsonSchemaToMiddleObject(sourceInputSchema);
+		const isTsInputCoherent = compareMiddleObjects(
+			sourceInputMiddleObject,
+			inputMiddleObject,
+			args.ignore_descriptions,
+		);
+		if (!isTsInputCoherent) {
+			console.error(
+				"Input TypeScript interface validation failed: the TypeScript interface does not match the source schema.",
+			);
+			process.exit(1);
+		}
+	}
+}
+
+function checkDatasetSchemas(args: CheckArgs): void {
+	let sourceDatasetSchema = readJsonSchema(args.src_dataset);
+	if (args.add_dataset) {
+		sourceDatasetSchema = mergeObjectSchemas(sourceDatasetSchema, readJsonSchema(args.add_dataset), args.deep_merge);
+	}
+	if (args.output.includes("json-schemas")) {
+		const outputDatasetSchema = readJsonSchemaField(args.dataset_schema, DATASET_SCHEMA_FIELD);
+		if (!outputDatasetSchema) {
+			console.error(`Dataset schema field "${DATASET_SCHEMA_FIELD}" not found in ${args.dataset_schema}.`);
+			process.exit(1);
+		}
+		const isDatasetSchemaCoherent = compareSchemas(
+			sourceDatasetSchema,
+			outputDatasetSchema,
+			args.ignore_descriptions ? DESCRIPTION_FIELDS : undefined,
+		);
+		if (!isDatasetSchemaCoherent) {
+			console.error("Dataset schema validation failed: the dataset schema does not match the source schema.");
+			process.exit(1);
+		}
+	}
+	if (args.output.includes("ts-types")) {
+		const datasetTsContent = readFile(join(args.output_ts_dir, "dataset.ts"));
+		const datasetMiddleObject = parseTypeScriptInterface(removeTypeScriptHeader(datasetTsContent));
+		const sourceDatasetMiddleObject = jsonSchemaToMiddleObject(sourceDatasetSchema);
+		const isTsDatasetCoherent = compareMiddleObjects(
+			sourceDatasetMiddleObject,
+			datasetMiddleObject,
+			args.ignore_descriptions,
+		);
+		if (!isTsDatasetCoherent) {
+			console.error(
+				"Dataset TypeScript interface validation failed: the TypeScript interface does not match the source schema.",
+			);
+			process.exit(1);
+		}
+	}
+}

package/src/cli/init.ts

@@ -0,0 +1,125 @@
+/** biome-ignore-all lint/style/useNamingConvention: the package `argparse` uses snake_case names */
+
+import { existsSync } from "node:fs";
+import { ArgumentDefaultsHelpFormatter, type SubParser } from "argparse";
+import { ACTOR_CONFIG_PATH, DATASET_SCHEMA_FIELD, getPathRelativeToActorConfig } from "../apify.js";
+import {
+	addCommonCliArgs,
+	type CommonCliArgs,
+	type Configuration,
+	writeConfigurationToPackageJson,
+} from "../configuration.js";
+import { readFile, writeFile } from "../utils/filesystem.js";
+import { readJsonSchema, readJsonSchemaField, writeJsonSchema } from "../utils/json-schemas.js";
+
+interface InitArgs extends CommonCliArgs {
+	no_config_file: boolean;
+	only_config_file: boolean;
+}
+
+export function setupInitParser(subparsers: SubParser, configuration: Configuration): void {
+	const initParser = subparsers.add_parser("init", {
+		help: "Initialize the Apify Schema Tools project with default settings.",
+		formatter_class: ArgumentDefaultsHelpFormatter,
+	});
+	addCommonCliArgs(initParser, configuration);
+	initParser.add_argument("--no-config-file", {
+		help: "do not create a configuration file in package.json",
+		action: "store_true",
+		default: false,
+	});
+	initParser.add_argument("--only-config-file", {
+		help: "create only the configuration file in package.json, without initializing schemas",
+		action: "store_true",
+		default: false,
+	});
+	initParser.set_defaults({ func: init });
+}
+
+function init(args: InitArgs): void {
+	if (args.only_config_file && args.no_config_file) {
+		throw new Error("The options --only-config-file and --no-config-file were defined together: doing nothing.");
+	}
+
+	console.log("Initializing Apify Schema Tools in the current project...");
+
+	if (!args.no_config_file) {
+		writeConfigurationToPackageJson(args);
+		console.log("Configuration written to package.json");
+	}
+
+	if (args.only_config_file) {
+		console.log("Only configuration file created, skipping schema initialization.");
+		return;
+	}
+
+	if (args.input.includes("input")) {
+		initializeInputSchema(args);
+	}
+
+	if (args.input.includes("dataset")) {
+		initializeDatasetSchema(args);
+	}
+}
+
+function initializeInputSchema(args: InitArgs): void {
+	if (existsSync(args.src_input)) {
+		console.log(`Input schema already exists at ${args.src_input}, skipping initialization.`);
+		return;
+	}
+	if (!existsSync(args.input_schema)) {
+		throw new Error("The current Actor does not have an input schema.");
+	}
+	const inputSchema = readJsonSchema(args.input_schema);
+	writeJsonSchema(args.src_input, inputSchema);
+	console.log(`Input schema initialized at ${args.src_input}`);
+	if (args.add_input) {
+		writeJsonSchema(args.add_input, { type: "object", properties: {} });
+		console.log(`Additional input schema initialized at ${args.add_input}`);
+	}
+}
+
+function initializeDatasetSchema(args: InitArgs): void {
+	if (!existsSync(ACTOR_CONFIG_PATH)) {
+		throw new Error(`The current Actor does not have an ${ACTOR_CONFIG_PATH} configuration file.`);
+	}
+	const actorConfig = JSON.parse(readFile(ACTOR_CONFIG_PATH));
+	const relativeDatasetPath = getPathRelativeToActorConfig(args.dataset_schema);
+	if (actorConfig.storages?.dataset !== relativeDatasetPath) {
+		writeFile(
+			ACTOR_CONFIG_PATH,
+			JSON.stringify(
+				{
+					...actorConfig,
+					storages: {
+						...actorConfig.storages,
+						dataset: relativeDatasetPath,
+					},
+				},
+				null,
+				4,
+			),
+		);
+		console.log(`Updated ${ACTOR_CONFIG_PATH} to use the dataset schema at ${args.dataset_schema}`);
+	}
+	if (!existsSync(args.dataset_schema)) {
+		writeFile(
+			args.dataset_schema,
+			JSON.stringify(
+				{
+					actorSpecification: 1,
+					[DATASET_SCHEMA_FIELD]: { type: "object", properties: {} },
+				},
+				null,
+				4,
+			),
+		);
+		console.log(`Dataset schema initialized at ${args.dataset_schema}`);
+	}
+	if (existsSync(args.src_dataset)) {
+		console.log(`Dataset schema already exists at ${args.src_dataset}, skipping initialization.`);
+		return;
+	}
+	const datasetItemSchema = readJsonSchemaField(args.dataset_schema, DATASET_SCHEMA_FIELD);
+	writeJsonSchema(args.src_dataset, datasetItemSchema);
+}

package/src/cli/sync.ts

@@ -0,0 +1,164 @@
+/** biome-ignore-all lint/style/useNamingConvention: the package `argparse` uses snake_case names */
+
+import { join } from "node:path";
+import { ArgumentDefaultsHelpFormatter, type SubParser } from "argparse";
+import {
+	DATASET_SCHEMA_FIELD,
+	DESCRIPTION_FIELDS,
+	filterValidInputSchemaProperties,
+	generateInputDefaultsTsFileContent,
+} from "../apify.js";
+import { addCommonCliArgs, type CommonCliArgs, type Configuration } from "../configuration.js";
+import { serializeMiddleObjectToTypeScript, writeTypeScriptFile } from "../middle-schema/generate-typescript.js";
+import { jsonSchemaToMiddleObject } from "../middle-schema/parse-json-schema.js";
+import {
+	mergeObjectSchemas,
+	type ObjectSchema,
+	readJsonSchema,
+	readJsonSchemaField,
+	writeJsonSchema,
+	writeSchemaToField,
+} from "../utils/json-schemas.js";
+import { type ConflictResolutionStrategy, checkConflicts } from "../utils/json-schemas-interactive-conflict.js";
+
+interface SyncArgs extends CommonCliArgs {
+	include_input_utils: string;
+	force: boolean;
+	fail_on_conflict: boolean;
+}
+
+export function setupSyncParser(subparsers: SubParser, configuration: Configuration): void {
+	const syncParser = subparsers.add_parser("sync", {
+		help: `Generate JSON schemas and TypeScript files from the source schemas. \
+    By default, if conflicts are detected, the user will be prompted to resolve them.`,
+		formatter_class: ArgumentDefaultsHelpFormatter,
+	});
+	addCommonCliArgs(syncParser, configuration);
+	syncParser.add_argument("--include-input-utils", {
+		help: "include input utilities in the generated TypeScript files: 'input' input and 'ts-types' output are required",
+		choices: ["true", "false"],
+		default: "true",
+	});
+	syncParser.add_argument("--force", {
+		help: "force the sync operation, even if conflicts are detected",
+		action: "store_true",
+		default: false,
+	});
+	syncParser.add_argument("--fail-on-conflict", {
+		help: "fail the sync operation if conflicts are detected",
+		action: "store_true",
+		default: false,
+	});
+	syncParser.set_defaults({ func: sync });
+}
+
+function sync(args: SyncArgs): void {
+	console.log("Syncing schemas...");
+
+	if (args.input.includes("input")) {
+		handleInputSync(args);
+	}
+
+	if (args.input.includes("dataset")) {
+		handleDatasetSync(args);
+	}
+}
+
+async function handleInputSync(args: SyncArgs): Promise<void> {
+	let inputSchemas = {
+		sourceSchema: readJsonSchema(args.src_input),
+		additionalSchema: args.add_input ? readJsonSchema(args.add_input) : undefined,
+	};
+	let resultingInputSchema: ObjectSchema | undefined;
+	if (args.output.includes("json-schemas")) {
+		const conflictResolutionStrategy = getConflictResolutionStrategy(args);
+		const existingInputSchema = readJsonSchema(args.input_schema);
+		inputSchemas = await checkConflicts(
+			inputSchemas.sourceSchema,
+			args.src_input,
+			inputSchemas.additionalSchema,
+			args.add_input,
+			existingInputSchema,
+			args.deep_merge,
+			DESCRIPTION_FIELDS,
+			conflictResolutionStrategy,
+		);
+		resultingInputSchema = inputSchemas.additionalSchema
+			? mergeObjectSchemas(inputSchemas.sourceSchema, inputSchemas.additionalSchema, args.deep_merge)
+			: inputSchemas.sourceSchema;
+		writeJsonSchema(args.input_schema, filterValidInputSchemaProperties(resultingInputSchema));
+	}
+	if (args.output.includes("ts-types")) {
+		resultingInputSchema ??= inputSchemas.additionalSchema
+			? mergeObjectSchemas(inputSchemas.sourceSchema, inputSchemas.additionalSchema, args.deep_merge)
+			: inputSchemas.sourceSchema;
+		writeTypeScriptFile(
+			join(args.output_ts_dir, "input.ts"),
+			serializeMiddleObjectToTypeScript("Input", jsonSchemaToMiddleObject(resultingInputSchema)),
+		);
+		if (args.include_input_utils === "true") {
+			writeTypeScriptFile(
+				join(args.output_ts_dir, "input-utils.ts"),
+				generateInputDefaultsTsFileContent(resultingInputSchema),
+			);
+		}
+	}
+	// Update the source schemas, which may have been modified by the conflict resolution
+	writeJsonSchema(args.src_input, inputSchemas.sourceSchema);
+	if (args.add_input && inputSchemas.additionalSchema) {
+		writeJsonSchema(args.add_input, inputSchemas.additionalSchema);
+	}
+}
+
+async function handleDatasetSync(args: SyncArgs): Promise<void> {
+	let datasetSchemas = {
+		sourceSchema: readJsonSchema(args.src_dataset),
+		additionalSchema: args.add_dataset ? readJsonSchema(args.add_dataset) : undefined,
+	};
+	let resultingDatasetSchema: ObjectSchema | undefined;
+	if (args.output.includes("json-schemas")) {
+		const conflictResolutionStrategy = getConflictResolutionStrategy(args);
+		const existingDatasetSchema = readJsonSchemaField(args.dataset_schema, DATASET_SCHEMA_FIELD);
+		datasetSchemas = await checkConflicts(
+			datasetSchemas.sourceSchema,
+			args.src_dataset,
+			datasetSchemas.additionalSchema,
+			args.add_dataset,
+			existingDatasetSchema,
+			args.deep_merge,
+			DESCRIPTION_FIELDS,
+			conflictResolutionStrategy,
+		);
+		resultingDatasetSchema = datasetSchemas.additionalSchema
+			? mergeObjectSchemas(datasetSchemas.sourceSchema, datasetSchemas.additionalSchema, args.deep_merge)
+			: datasetSchemas.sourceSchema;
+		writeSchemaToField(args.dataset_schema, resultingDatasetSchema, DATASET_SCHEMA_FIELD);
+	}
+	if (args.output.includes("ts-types")) {
+		resultingDatasetSchema ??= datasetSchemas.additionalSchema
+			? mergeObjectSchemas(datasetSchemas.sourceSchema, datasetSchemas.additionalSchema, args.deep_merge)
+			: datasetSchemas.sourceSchema;
+		writeTypeScriptFile(
+			join(args.output_ts_dir, "dataset.ts"),
+			serializeMiddleObjectToTypeScript("DatasetItem", jsonSchemaToMiddleObject(resultingDatasetSchema)),
+		);
+	}
+	// Update the source schemas, which may have been modified by the conflict resolution
+	writeJsonSchema(args.src_dataset, datasetSchemas.sourceSchema);
+	if (args.add_dataset && datasetSchemas.additionalSchema) {
+		writeJsonSchema(args.add_dataset, datasetSchemas.additionalSchema);
+	}
+}
+
+function getConflictResolutionStrategy(args: SyncArgs): ConflictResolutionStrategy {
+	if (args.fail_on_conflict && args.force) {
+		throw new Error("The options --force and --fail-on-conflict cannot be defined together.");
+	}
+	if (args.force) {
+		return "log";
+	}
+	if (args.fail_on_conflict) {
+		return "error";
+	}
+	return "interactive";
+}

package/src/configuration.ts

@@ -3,7 +3,7 @@
 import { existsSync } from "node:fs";
 import type { ArgumentParser } from "argparse";
 import { array, boolean, enum as enum_, object, string, type infer as zodInfer } from "zod/v4";
-import { readFile, writeFile } from "./filesystem.js";
+import { readFile, writeFile } from "./utils/filesystem.js";
 
 const zod = {
 	object,
@@ -19,6 +19,10 @@ const OUTPUTS = ["json-schemas", "ts-types"] as const;
 type Input = (typeof INPUTS)[number];
 type Output = (typeof OUTPUTS)[number];
 
+/**
+ * These CLI arguments are also available in the configuration file.
+ * They are in snake_case because `argparse` uses it for argument names.
+ */
 export interface CommonCliArgs {
 	input: Input[];
 	output: Output[];
@@ -32,7 +36,11 @@ export interface CommonCliArgs {
 	output_ts_dir: string;
 }
 
-export const Configuration = zod.object({
+/**
+ * Zod schema for the configuration file.
+ * Since the configuration is in JSON format, we use camelCase.
+ */
+export const CONFIGURATION_SCHEMA = zod.object({
 	input: zod.array(zod.enum(INPUTS)).default([...INPUTS]),
 	output: zod.array(zod.enum(OUTPUTS)).default([...OUTPUTS]),
 	srcInput: zod.string().default("src-schemas/input.json"),
@@ -45,10 +53,12 @@ export const Configuration = zod.object({
 	outputTSDir: zod.string().default("src/generated"),
 });
 
-export function parseConfigurationFromFileOrDefault(): zodInfer<typeof Configuration> {
+export type Configuration = zodInfer<typeof CONFIGURATION_SCHEMA>;
+
+export function parseConfigurationFromFileOrDefault(): Configuration {
 	const packageJsonContent = existsSync("package.json") ? readFile("package.json") : undefined;
 	const rawConfig = packageJsonContent ? (JSON.parse(packageJsonContent)["apify-schema-tools"] ?? {}) : {};
-	return Configuration.parse(rawConfig);
+	return CONFIGURATION_SCHEMA.parse(rawConfig);
 }
 
 export function writeConfigurationToPackageJson(args: CommonCliArgs): void {
@@ -73,10 +83,10 @@ export function writeConfigurationToPackageJson(args: CommonCliArgs): void {
 }
 
 /**
- * This function will set as default values the configuration from package.json, or the default one.
- * In this way, the CLI arguments can override the configuration.
+ * This function will set as default values the configuration file, or the default one.
+ * In this way, the CLI arguments can override the configuration file.
  */
-export function addCommonCliArgs(parser: ArgumentParser, configuration: zodInfer<typeof Configuration>): void {
+export function addCommonCliArgs(parser: ArgumentParser, configuration: zodInfer<typeof CONFIGURATION_SCHEMA>): void {
 	parser.add_argument("-i", "--input", {
 		help: "specify which sources to use for generation",
 		choices: [...INPUTS],

package/src/main.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/** biome-ignore-all lint/style/useNamingConvention: the package `argparse` uses snake_case names */
+
+import { ArgumentDefaultsHelpFormatter, ArgumentParser } from "argparse";
+import { setupCheckParser } from "./cli/check.js";
+import { setupInitParser } from "./cli/init.js";
+import { setupSyncParser } from "./cli/sync.js";
+import { parseConfigurationFromFileOrDefault } from "./configuration.js";
+
+const configuration = parseConfigurationFromFileOrDefault();
+
+const rootParser = new ArgumentParser({
+	description: "Apify Schema Tools - Generate JSON schemas and TypeScript files for Actor input and output dataset.",
+	formatter_class: ArgumentDefaultsHelpFormatter,
+});
+
+const subparsers = rootParser.add_subparsers();
+
+setupInitParser(subparsers, configuration);
+setupSyncParser(subparsers, configuration);
+setupCheckParser(subparsers, configuration);
+
+const parsedArgs = rootParser.parse_args();
+parsedArgs.func(parsedArgs);