@atcute/lex-cli 2.8.2 → 3.0.0

package/src/lexicon-metadata.ts

@@ -1,6 +1,6 @@
-import { isNsid } from '@atcute/lexicons/syntax';
+import * as v from 'valibot';
 
-import * as v from '@badrap/valita';
+import { isValidLexiconPattern } from './utils/nsid-pattern.ts';
 
 export type LexiconMappingEntryType = 'namespace' | 'named';
 export type LexiconMappingPath = '.' | `./${string}`;
@@ -19,56 +19,39 @@ export interface PackageJsonWithLexicons {
 	[key: string]: unknown;
 }
 
-/**
- * Validates if a string is a valid NSID pattern (exact or wildcard)
- * - Exact: "com.atproto.repo.getRecord"
- * - Wildcard: "com.atproto.*"
- */
-const isValidLexiconPattern = (pattern: string): boolean => {
-	if (pattern.endsWith('.*')) {
-		// For wildcards, remove the .* and validate the prefix as an NSID segment
-		const prefix = pattern.slice(0, -2);
-		// Add a dummy segment to make it a valid NSID for validation
-		return isNsid(prefix + '.x');
-	}
-	return isNsid(pattern);
-};
-
 /**
  * Schema for a single lexicon mapping entry
  */
-const lexiconMappingEntry: v.Type<LexiconMappingEntry> = v.object({
-	type: v.union(v.literal('namespace'), v.literal('named')),
-	path: v.string().assert((input): input is LexiconMappingPath => input === '.' || input.startsWith('./'), {
-		message: `path must be "." or start with "./"`,
-	}),
+const lexiconMappingEntry: v.GenericSchema<unknown, LexiconMappingEntry> = v.looseObject({
+	type: v.picklist(['namespace', 'named']),
+	path: v.custom<LexiconMappingPath>(
+		(input) => typeof input === 'string' && (input === '.' || input.startsWith('./')),
+		`path must be "." or start with "./"`,
+	),
 });
 
 /**
  * Schema for the atcute:lexicons field in package.json
  */
-const mappingsSchema: v.Type<Record<string, LexiconMappingEntry>> = v
-	.record(lexiconMappingEntry)
-	.chain((input) => {
+const mappingsSchema: v.GenericSchema<unknown, Record<string, LexiconMappingEntry>> = v.pipe(
+	v.record(v.string(), lexiconMappingEntry),
+	v.check((input) => {
 		for (const key in input) {
 			if (!isValidLexiconPattern(key)) {
-				return v.err({
-					message: `invalid NSID pattern (must be valid NSID or end with .*)`,
-					path: [key],
-				});
+				return false;
 			}
 		}
+		return true;
+	}, `invalid NSID pattern (must be valid NSID or end with .*)`),
+);
 
-		return v.ok(input);
-	});
-
-const atcuteLexiconsField: v.Type<AtcuteLexiconsField> = v.object({
-	mappings: mappingsSchema.optional(),
+const atcuteLexiconsField: v.GenericSchema<unknown, AtcuteLexiconsField> = v.looseObject({
+	mappings: v.optional(mappingsSchema),
 });
 
 /**
  * Schema for package.json with atcute:lexicons field
  */
-export const packageJsonSchema: v.Type<PackageJsonWithLexicons> = v.object({
-	'atcute:lexicons': atcuteLexiconsField.optional(),
+export const packageJsonSchema: v.GenericSchema<unknown, PackageJsonWithLexicons> = v.looseObject({
+	'atcute:lexicons': v.optional(atcuteLexiconsField),
 });

package/src/pull-sources/atproto.ts

@@ -71,12 +71,13 @@ const discoverLexiconsForAuthority = async (
 
 		// extract NSIDs from record keys (the rkey in at://did/collection/rkey)
 		for (const record of data.records) {
-			const r = parseCanonicalResourceUri(record.uri);
-			if (!r.ok) {
+			let nsid: string;
+			try {
+				nsid = parseCanonicalResourceUri(record.uri).rkey;
+			} catch {
 				continue;
 			}
 
-			const nsid = r.value.rkey;
 			if (!isNsid(nsid)) {
 				continue;
 			}

package/src/utils/issues.ts

@@ -0,0 +1,9 @@
+import * as v from 'valibot';
+
+/** prints a list of valibot issues to stderr in the lex-cli's standard format. */
+export const printValibotIssues = (issues: readonly v.BaseIssue<unknown>[]): void => {
+	for (const issue of issues) {
+		const dotPath = v.getDotPath(issue) ?? '';
+		console.log(`- ${issue.type} at .${dotPath}: ${issue.message}`);
+	}
+};

package/src/utils/nsid-pattern.ts

@@ -0,0 +1,12 @@
+import { isNsid } from '@atcute/lexicons/syntax';
+
+/**
+ * checks whether a string is either a valid NSID or a wildcard pattern that
+ * ends with `.*` whose prefix is a valid NSID segment.
+ */
+export const isValidLexiconPattern = (pattern: string): boolean => {
+	if (pattern.endsWith('.*')) {
+		return isNsid(`${pattern.slice(0, -2)}.x`);
+	}
+	return isNsid(pattern);
+};