@atcute/lex-cli 2.8.2 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atcute/lex-cli",
-  "version": "2.8.2",
+  "version": "3.0.0",
   "description": "cli tool to generate type definitions for atcute",
   "license": "0BSD",
   "repository": {
@@ -23,16 +23,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@badrap/valita": "^0.4.6",
     "@optique/core": "^1.0.2",
     "@optique/run": "^1.0.2",
     "picocolors": "^1.1.1",
     "prettier": "^3.8.3",
-    "@atcute/lexicon-doc": "^2.2.1",
-    "@atcute/identity-resolver": "^1.2.3",
-    "@atcute/identity": "^1.1.5",
-    "@atcute/lexicons": "^1.3.1",
-    "@atcute/lexicon-resolver": "^0.1.7"
+    "valibot": "^1.4.0",
+    "@atcute/identity": "^2.0.0",
+    "@atcute/lexicon-doc": "^3.0.0",
+    "@atcute/identity-resolver": "^2.0.0",
+    "@atcute/lexicon-resolver": "^1.0.0",
+    "@atcute/lexicons": "^2.0.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/src/commands/generate.ts

@@ -3,6 +3,7 @@ import * as module from 'node:module';
 import * as path from 'node:path';
 
 import pc from 'picocolors';
+import * as v from 'valibot';
 
 import type { GenerateCommand } from '../cli.ts';
 import { generateLexiconApi, type ImportMapping } from '../codegen.ts';
@@ -10,6 +11,7 @@ import { loadConfig, type GenerateConfig, type NormalizedConfig } from '../confi
 import { createFormatter } from '../formatter.ts';
 import { loadLexicons } from '../lexicon-loader.ts';
 import { packageJsonSchema } from '../lexicon-metadata.ts';
+import { printValibotIssues } from '../utils/issues.ts';
 
 /**
  * resolves package imports to ImportMapping[]
@@ -64,19 +66,14 @@ const resolveImportsToMappings = async (
 			process.exit(1);
 		}
 
-		const result = packageJsonSchema.try(packageJson, { mode: 'passthrough' });
-		if (!result.ok) {
+		const result = v.safeParse(packageJsonSchema, packageJson);
+		if (!result.success) {
 			console.error(pc.bold(pc.red(`invalid atcute:lexicons in "${packageName}":`)));
-			console.error(result.message);
-
-			for (const issue of result.issues) {
-				console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-			}
-
+			printValibotIssues(result.issues);
 			process.exit(1);
 		}
 
-		const lexicons = result.value['atcute:lexicons'];
+		const lexicons = result.output['atcute:lexicons'];
 		if (!lexicons?.mappings) {
 			continue;
 		}

package/src/commands/pull.ts

@@ -4,6 +4,7 @@ import * as path from 'node:path';
 import { lexiconDoc, refineLexiconDoc, type LexiconDoc } from '@atcute/lexicon-doc';
 
 import pc from 'picocolors';
+import * as v from 'valibot';
 
 import type { PullCommand } from '../cli.ts';
 import { loadConfig, type NormalizedConfig, type PullConfig, type SourceConfig } from '../config.ts';
@@ -11,6 +12,7 @@ import { createFormatter, type Formatter } from '../formatter.ts';
 import { pullAtprotoSource } from '../pull-sources/atproto.ts';
 import { pullGitSource } from '../pull-sources/git.ts';
 import type { PullResult, PulledLexicon, SourceLocation } from '../pull-sources/types.ts';
+import { printValibotIssues } from '../utils/issues.ts';
 
 interface SourceRevision {
 	source: SourceConfig;
@@ -52,24 +54,19 @@ const parseLexiconFile = async (loc: SourceLocation): Promise<LexiconDoc> => {
 		process.exit(1);
 	}
 
-	const result = lexiconDoc.try(json, { mode: 'passthrough' });
-	if (!result.ok) {
+	const result = v.safeParse(lexiconDoc, json);
+	if (!result.success) {
 		console.error(
 			pc.bold(
 				pc.red(`schema validation failed for ${loc.relativePath} when pulling ${loc.sourceDescription}`),
 			),
 		);
 		console.error(`found in ${loc.absolutePath}`);
-		console.error(result.message);
-
-		for (const issue of result.issues) {
-			console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-		}
-
+		printValibotIssues(result.issues);
 		process.exit(1);
 	}
 
-	const issues = refineLexiconDoc(result.value, true);
+	const issues = refineLexiconDoc(result.output, true);
 	if (issues.length > 0) {
 		console.error(
 			pc.bold(pc.red(`lint validation failed for ${loc.relativePath} when pulling ${loc.sourceDescription}`)),
@@ -83,7 +80,27 @@ const parseLexiconFile = async (loc: SourceLocation): Promise<LexiconDoc> => {
 		process.exit(1);
 	}
 
-	return result.value;
+	return result.output;
+};
+
+// valibot rebuilds objects in schema key order; reorder back into dag-cbor
+// canonical order (shorter keys first, then lexicographic) so writes are
+// deterministic regardless of schema field declaration order
+const canonicalize = (value: unknown): unknown => {
+	if (Array.isArray(value)) {
+		return value.map(canonicalize);
+	}
+	if (value !== null && typeof value === 'object') {
+		const obj = value as Record<string, unknown>;
+		const keys = Object.keys(obj).toSorted((a, b) => a.length - b.length || (a < b ? -1 : 1));
+		const result: Record<string, unknown> = {};
+		for (const key of keys) {
+			result[key] = canonicalize(obj[key]);
+		}
+
+		return result;
+	}
+	return value;
 };
 
 const writeLexicon = async (
@@ -96,7 +113,7 @@ const writeLexicon = async (
 	const target = path.join(outdir, `${nsidPath}.json`);
 	const dirname = path.dirname(target);
 
-	const code = await formatter.format(JSON.stringify(doc, null, 2), target);
+	const code = await formatter.format(JSON.stringify(canonicalize(doc), null, 2), target);
 
 	await fs.mkdir(dirname, { recursive: true });
 	await fs.writeFile(target, code);

package/src/config.ts

@@ -3,187 +3,209 @@ import * as path from 'node:path';
 import * as url from 'node:url';
 
 import { isAtprotoDid } from '@atcute/identity';
-import { isHandle, isNsid } from '@atcute/lexicons/syntax';
+import { isHandle, isNsid, type Nsid } from '@atcute/lexicons/syntax';
 
-import * as v from '@badrap/valita';
 import pc from 'picocolors';
+import * as v from 'valibot';
 
 import type { ImportMapping } from './codegen.ts';
+import { printValibotIssues } from './utils/issues.ts';
+import { isValidLexiconPattern } from './utils/nsid-pattern.ts';
+
+// `lexiconConfigSchema` is wide and deep enough that valibot's inferred output bottoms out at
+// `{}` for its nested fields. annotating it against an explicit interface forces tsgo to use the
+// declared shape; inner schemas infer cleanly without help. the interfaces also strip the
+// `{ [key: string]: unknown }` index signature that `looseObject` would otherwise expose.
+
+export interface GitSourceConfig {
+	type: 'git';
+	remote: string;
+	ref?: string;
+	pattern: string[];
+}
+
+export interface AtprotoNsidsSourceConfig {
+	type: 'atproto';
+	mode: 'nsids';
+	nsids: Nsid[];
+}
+
+export interface AtprotoAuthoritySourceConfig {
+	type: 'atproto';
+	mode: 'authority';
+	authority: string;
+	pattern?: string[];
+}
+
+export type AtprotoSourceConfig = AtprotoNsidsSourceConfig | AtprotoAuthoritySourceConfig;
+
+export type SourceConfig = GitSourceConfig | AtprotoSourceConfig;
+
+export interface PullConfig {
+	outdir: string;
+	clean?: boolean;
+	sources: SourceConfig[];
+}
+
+export interface ExportConfig {
+	outdir: string;
+	files?: string[];
+	clean?: boolean;
+}
+
+export type FormatterConfig =
+	| { type: 'prettier' }
+	| { type: 'command'; command: string; concurrency: number }
+	| { type: 'lsp'; command: string };
+
+export interface ModulesConfig {
+	importSuffix?: string;
+}
+
+export interface GenerateConfig {
+	outdir?: string;
+	files?: string[];
+	imports?: string[];
+	mappings?: ImportMapping[];
+	modules?: ModulesConfig;
+	clean?: boolean;
+}
+
+export interface LexiconConfig {
+	formatter?: FormatterConfig;
+	generate?: GenerateConfig;
+	pull?: PullConfig;
+	export?: ExportConfig;
+}
+
+export type NormalizedConfig = LexiconConfig & {
+	formatter: FormatterConfig;
+	root: string;
+};
+
+const nonEmptyString = v.pipe(v.string(), v.nonEmpty(`must not be empty`));
 
-const gitSourceConfigSchema = v.object({
+const gitSourceConfigSchema = v.looseObject({
 	type: v.literal('git'),
-	remote: v.string().assert((value) => value.length > 0, `must not be empty`),
-	ref: v
-		.string()
-		.assert((value) => value.length > 0, `must not be empty`)
-		.optional(),
-	pattern: v
-		.array(v.string().assert((value) => value.length > 0, `must not be empty`))
-		.assert((value) => value.length > 0, `must include at least one glob pattern`),
+	remote: nonEmptyString,
+	ref: v.optional(nonEmptyString),
+	pattern: v.pipe(v.array(nonEmptyString), v.minLength(1, `must include at least one glob pattern`)),
 });
 
-const atprotoNsidsSourceConfigSchema = v.object({
+const atprotoNsidsSourceConfigSchema = v.looseObject({
 	type: v.literal('atproto'),
 	mode: v.literal('nsids'),
-	nsids: v
-		.array(v.string().assert((value) => isNsid(value), `must be valid nsid`))
-		.assert((value) => value.length > 0, `must include at least one nsid`),
+	nsids: v.pipe(
+		v.array(v.custom<Nsid>(isNsid, `must be valid nsid`)),
+		v.minLength(1, `must include at least one nsid`),
+	),
 });
 
-const atprotoAuthoritySourceConfigSchema = v.object({
+const atprotoAuthoritySourceConfigSchema = v.looseObject({
 	type: v.literal('atproto'),
 	mode: v.literal('authority'),
-	authority: v
-		.string()
-		.assert((value) => isHandle(value) || isAtprotoDid(value), `must a valid at-identifier`),
-	pattern: v
-		.array(
-			v
-				.string()
-				.assert((value) => isValidLexiconPattern(value), `must be valid nsid or pattern ending with .*`),
-		)
-		.optional(),
+	authority: v.pipe(
+		v.string(),
+		v.check((value) => isHandle(value) || isAtprotoDid(value), `must be a valid at-identifier`),
+	),
+	pattern: v.optional(
+		v.array(
+			v.pipe(v.string(), v.check(isValidLexiconPattern, `must be valid nsid or pattern ending with .*`)),
+		),
+	),
 });
 
-const atprotoSourceConfigSchema = v.union(atprotoNsidsSourceConfigSchema, atprotoAuthoritySourceConfigSchema);
+const atprotoSourceConfigSchema = v.union([
+	atprotoNsidsSourceConfigSchema,
+	atprotoAuthoritySourceConfigSchema,
+]);
 
-const sourceConfigSchema = v.union(gitSourceConfigSchema, atprotoSourceConfigSchema);
+const sourceConfigSchema = v.union([gitSourceConfigSchema, atprotoSourceConfigSchema]);
 
-const pullConfigSchema = v.object({
-	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
-	clean: v.boolean().optional(),
-	sources: v
-		.array(sourceConfigSchema)
-		.assert((value) => value.length > 0, `must include at least one source`),
+const pullConfigSchema = v.looseObject({
+	outdir: nonEmptyString,
+	clean: v.optional(v.boolean()),
+	sources: v.pipe(v.array(sourceConfigSchema), v.minLength(1, `must include at least one source`)),
 });
 
-const exportConfigSchema = v.object({
-	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
-	files: v.array(v.string().assert((value) => value.length > 0, `must not be empty`)).optional(),
-	clean: v.boolean().optional(),
+const exportConfigSchema = v.looseObject({
+	outdir: nonEmptyString,
+	files: v.optional(v.array(nonEmptyString)),
+	clean: v.optional(v.boolean()),
 });
 
-const formatterConfigSchema = v.union(
-	v.object({ type: v.literal('prettier') }),
-	v.object({
+const formatterConfigSchema = v.union([
+	v.looseObject({ type: v.literal('prettier') }),
+	v.looseObject({
 		type: v.literal('command'),
-		command: v.string().assert((value) => value.length > 0, `must not be empty`),
-		concurrency: v
-			.number()
-			.assert((value) => Number.isInteger(value) && value > 0, `must be a positive integer`)
-			.optional(() => 1),
+		command: nonEmptyString,
+		concurrency: v.optional(
+			v.pipe(
+				v.number(),
+				v.check((value) => Number.isInteger(value) && value > 0, `must be a positive integer`),
+			),
+			() => 1,
+		),
 	}),
-	v.object({
+	v.looseObject({
 		type: v.literal('lsp'),
-		command: v.string().assert((value) => value.length > 0, `must not be empty`),
+		command: nonEmptyString,
 	}),
-);
-
-const isValidLexiconPattern = (pattern: string): boolean => {
-	if (pattern.endsWith('.*')) {
-		return isNsid(`${pattern.slice(0, -2)}.x`);
-	}
-
-	return isNsid(pattern);
-};
-
-const mappingImports: v.Type<ImportMapping['imports']> = v.unknown().chain((value) => {
-	if (typeof value === 'string') {
-		if (value.length === 0) {
-			return v.err('imports must not be empty');
+]);
+
+const mappingImports = v.pipe(
+	v.unknown(),
+	v.rawTransform<unknown, ImportMapping['imports']>(({ dataset, addIssue, NEVER }) => {
+		const value = dataset.value;
+		if (typeof value === 'string') {
+			if (value.length === 0) {
+				addIssue({ message: 'imports must not be empty' });
+				return NEVER;
+			}
+			return value;
 		}
+		if (typeof value === 'function') {
+			return value as ImportMapping['imports'];
+		}
+		addIssue({ message: 'imports must be a string or function' });
+		return NEVER;
+	}),
+);
 
-		return v.ok(value);
-	}
-
-	if (typeof value === 'function') {
-		return v.ok(value as ImportMapping['imports']);
-	}
-
-	return v.err('imports must be a string or function');
-});
-
-const importMappingSchema: v.Type<ImportMapping> = v.object({
-	nsid: v
-		.array(
-			v.string().chain((value) => {
-				if (!isValidLexiconPattern(value)) {
-					return v.err(`invalid NSID pattern (must be valid NSID or end with .*)`);
-				}
-
-				return v.ok(value);
-			}),
-		)
-		.assert((patterns) => patterns.length > 0, `nsid requires at least one pattern`),
+const importMappingSchema = v.looseObject({
+	nsid: v.pipe(
+		v.array(
+			v.pipe(
+				v.string(),
+				v.check(isValidLexiconPattern, `invalid NSID pattern (must be valid NSID or end with .*)`),
+			),
+		),
+		v.minLength(1, `nsid requires at least one pattern`),
+	),
 	imports: mappingImports,
 });
 
-const modulesConfigSchema = v
-	.object({
-		importSuffix: v
-			.string()
-			.assert((value) => value.length > 0, `must not be empty`)
-			.optional(),
-	})
-	.partial();
-
-const generateConfigSchema = v.object({
-	outdir: v
-		.string()
-		.assert((value) => value.length > 0, `must not be empty`)
-		.optional(),
-	files: v
-		.array(v.string().assert((value) => value.length > 0, `must not be empty`))
-		.assert((value) => value.length > 0, `must include at least one glob pattern`)
-		.optional(),
-	imports: v.array(v.string().assert((value) => value.length > 0, `must not be empty`)).optional(),
-	mappings: v.array(importMappingSchema).optional(),
-	modules: modulesConfigSchema.optional(),
-	clean: v.boolean().optional(),
+const modulesConfigSchema = v.looseObject({
+	importSuffix: v.optional(nonEmptyString),
 });
 
-export type GitSourceConfig = v.Infer<typeof gitSourceConfigSchema>;
-export type AtprotoNsidsSourceConfig = v.Infer<typeof atprotoNsidsSourceConfigSchema>;
-export type AtprotoAuthoritySourceConfig = v.Infer<typeof atprotoAuthoritySourceConfigSchema>;
-export type AtprotoSourceConfig = v.Infer<typeof atprotoSourceConfigSchema>;
-export type SourceConfig = v.Infer<typeof sourceConfigSchema>;
-export type PullConfig = v.Infer<typeof pullConfigSchema>;
-export type ExportConfig = v.Infer<typeof exportConfigSchema>;
-export type FormatterConfig = v.Infer<typeof formatterConfigSchema>;
-export type GenerateConfig = v.Infer<typeof generateConfigSchema>;
-
-export const lexiconConfigSchema = v.object({
-	/** @deprecated moved to `generate.outdir` */
-	outdir: v
-		.string()
-		.assert((value) => value.length > 0, `must not be empty`)
-		.optional(),
-	/** @deprecated moved to `generate.files` */
-	files: v
-		.array(v.string().assert((value) => value.length > 0, `must not be empty`))
-		.assert((value) => value.length > 0, `must include at least one glob pattern`)
-		.optional(),
-	/** @deprecated moved to `generate.imports` */
-	imports: v.array(v.string().assert((value) => value.length > 0, `must not be empty`)).optional(),
-	/** @deprecated moved to `generate.mappings` */
-	mappings: v.array(importMappingSchema).optional(),
-	/** @deprecated moved to `generate.modules` */
-	modules: modulesConfigSchema.optional(),
-	formatter: formatterConfigSchema.optional(),
-	generate: generateConfigSchema.optional(),
-	pull: pullConfigSchema.optional(),
-	export: exportConfigSchema.optional(),
+const generateConfigSchema = v.looseObject({
+	outdir: v.optional(nonEmptyString),
+	files: v.optional(
+		v.pipe(v.array(nonEmptyString), v.minLength(1, `must include at least one glob pattern`)),
+	),
+	imports: v.optional(v.array(nonEmptyString)),
+	mappings: v.optional(v.array(importMappingSchema)),
+	modules: v.optional(modulesConfigSchema),
+	clean: v.optional(v.boolean()),
 });
 
-export type LexiconConfig = v.Infer<typeof lexiconConfigSchema>;
-
-export type NormalizedConfig = Omit<
-	LexiconConfig,
-	'formatter' | 'outdir' | 'files' | 'imports' | 'mappings' | 'modules'
-> & {
-	formatter: FormatterConfig;
-	root: string;
-};
+export const lexiconConfigSchema: v.GenericSchema<unknown, Omit<NormalizedConfig, 'root'>> = v.looseObject({
+	formatter: v.optional(formatterConfigSchema, (): FormatterConfig => ({ type: 'prettier' })),
+	generate: v.optional(generateConfigSchema),
+	pull: v.optional(pullConfigSchema),
+	export: v.optional(exportConfigSchema),
+});
 
 export const loadConfig = async (configPath?: string): Promise<NormalizedConfig> => {
 	let configFilename: string | undefined;
@@ -191,7 +213,6 @@ export const loadConfig = async (configPath?: string): Promise<NormalizedConfig>
 	if (configPath) {
 		configFilename = path.resolve(configPath);
 	} else {
-		// try to find lex.config.js or lex.config.ts in the current directory
 		const candidates = ['lex.config.js', 'lex.config.ts'];
 
 		for (const candidate of candidates) {
@@ -226,50 +247,12 @@ export const loadConfig = async (configPath?: string): Promise<NormalizedConfig>
 		process.exit(1);
 	}
 
-	const configResult = lexiconConfigSchema.try(rawConfig, { mode: 'passthrough' });
-	if (!configResult.ok) {
+	const configResult = v.safeParse(lexiconConfigSchema, rawConfig);
+	if (!configResult.success) {
 		console.error(pc.bold(pc.red(`invalid config:`)));
-		console.error(configResult.message);
-
-		for (const issue of configResult.issues) {
-			console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-		}
-
+		printValibotIssues(configResult.issues);
 		process.exit(1);
 	}
 
-	const {
-		formatter = { type: 'prettier' },
-		outdir,
-		files,
-		imports,
-		mappings,
-		modules,
-		generate,
-		...rest
-	} = configResult.value;
-
-	// back-compat: top-level generate options were moved into `generate.*`. merge the legacy
-	// top-level values into `generate`, with nested `generate.*` winning on conflicts. the result
-	// is only present if at least one generate-related option was provided anywhere.
-	const hasLegacyTopLevel =
-		outdir !== undefined ||
-		files !== undefined ||
-		imports !== undefined ||
-		mappings !== undefined ||
-		modules !== undefined;
-
-	let normalizedGenerate: GenerateConfig | undefined;
-	if (generate || hasLegacyTopLevel) {
-		normalizedGenerate = {
-			outdir: generate?.outdir ?? outdir,
-			files: generate?.files ?? files,
-			imports: generate?.imports ?? imports,
-			mappings: generate?.mappings ?? mappings,
-			modules: generate?.modules ?? modules,
-			clean: generate?.clean,
-		};
-	}
-
-	return { ...rest, formatter, generate: normalizedGenerate, root: configDirname };
+	return { ...configResult.output, root: configDirname };
 };

package/src/index.ts

@@ -1,7 +1,9 @@
+import * as v from 'valibot';
+
 import { lexiconConfigSchema, type LexiconConfig } from './config.ts';
 
 export type { LexiconConfig };
 
 export const defineLexiconConfig = (config: LexiconConfig): LexiconConfig => {
-	return lexiconConfigSchema.parse(config);
+	return v.parse(lexiconConfigSchema, config);
 };

package/src/lexicon-loader.ts

@@ -6,6 +6,9 @@ import { lexiconDoc, refineLexiconDoc, type LexiconDoc } from '@atcute/lexicon-d
 import { build, type LexDocumentBuilder } from '@atcute/lexicon-doc/builder';
 
 import pc from 'picocolors';
+import * as v from 'valibot';
+
+import { printValibotIssues } from './utils/issues.ts';
 
 /** file extensions recognized as module files */
 const MODULE_EXTENSIONS = new Set(['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts']);
@@ -70,19 +73,14 @@ const loadJsonFile = async (absolutePath: string, relativePath: string): Promise
 		process.exit(1);
 	}
 
-	const result = lexiconDoc.try(json, { mode: 'strip' });
-	if (!result.ok) {
+	const result = v.safeParse(lexiconDoc, json);
+	if (!result.success) {
 		console.error(pc.bold(pc.red(`schema validation failed for "${relativePath}"`)));
-		console.error(result.message);
-
-		for (const issue of result.issues) {
-			console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-		}
-
+		printValibotIssues(result.issues);
 		process.exit(1);
 	}
 
-	const issues = refineLexiconDoc(result.value, true);
+	const issues = refineLexiconDoc(result.output, true);
 	if (issues.length > 0) {
 		console.error(pc.bold(pc.red(`lint validation failed for "${relativePath}"`)));
 
@@ -93,7 +91,7 @@ const loadJsonFile = async (absolutePath: string, relativePath: string): Promise
 		process.exit(1);
 	}
 
-	return result.value;
+	return result.output;
 };
 
 /**