@atproto/lex-schema 0.1.0 → 0.1.2

package/src/core/result.ts

@@ -1,162 +1,15 @@
-export type ResultSuccess<V = any> = { success: true; value: V }
-
-/**
- * Represents a failed result containing an error reason.
- *
- * @typeParam E - The type of the error reason
- */
-export type ResultFailure<E = Error> = { success: false; reason: E }
-
-/**
- * A discriminated union type representing either a success or failure outcome.
- *
- * Check the `success` property to determine the outcome and access the
- * appropriate property (`value` for success, `reason` for failure).
- *
- * @typeParam V - The type of the success value
- * @typeParam E - The type of the error reason
- *
- * @example
- * ```typescript
- * function parseJson(text: string): Result<unknown, SyntaxError> {
- *   try {
- *     return success(JSON.parse(text))
- *   } catch (e) {
- *     return failure(e as SyntaxError)
- *   }
- * }
- * ```
- */
-export type Result<V = any, E = Error> = ResultSuccess<V> | ResultFailure<E>
-
-/**
- * Creates a successful result wrapping the given value.
- *
- * @typeParam V - The type of the value
- * @param value - The success value to wrap
- * @returns {ResultSuccess} A success result containing the value
- *
- * @example
- * ```typescript
- * const result = success(42)
- * console.log(result.success) // true
- * console.log(result.value)   // 42
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function success<V>(value: V): ResultSuccess<V> {
-  return { success: true, value }
+export type ResultSuccess<V = any> = {
+  success: true
+  value: V
+  reason?: undefined
 }
 
 /**
- * Creates a failed result wrapping the given error reason.
+ * Represents a failed result containing an error reason.
  *
  * @typeParam E - The type of the error reason
- * @param reason - The error reason to wrap
- * @returns {ResultFailure} A failure result containing the error
- *
- * @example
- * ```typescript
- * const result = failure(new Error('Something went wrong'))
- * console.log(result.success) // false
- * console.log(result.reason.message) // "Something went wrong"
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function failure<E>(reason: E): ResultFailure<E> {
-  return { success: false, reason }
-}
-
-/**
- * Extracts the error reason from a failure result.
- *
- * @typeParam T - The type of the error reason
- * @param result - A failure result
- * @returns {T} The error reason
- *
- * @example
- * ```typescript
- * const result = failure(new Error('oops'))
- * const error = failureReason(result)
- * console.log(error.message) // "oops"
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function failureReason<T>(result: ResultFailure<T>): T {
-  return result.reason
-}
-
-/**
- * Extracts the value from a success result.
- *
- * @typeParam T - The type of the success value
- * @param result - A success result
- * @returns {T} The success value
- *
- * @example
- * ```typescript
- * const result = success(42)
- * const value = successValue(result)
- * console.log(value) // 42
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function successValue<T>(result: ResultSuccess<T>): T {
-  return result.value
-}
-
-/**
- * Catches any error and wraps it in a {@link ResultFailure<Error>}.
- *
- * @param err - The error to catch.
- * @returns {ResultFailure} A failure result containing the error.
- * @example
- *
- * ```ts
- * declare function someFunction(): Promise<string>
- *
- * const result = await someFunction().then(success, catchall)
- * if (result.success) {
- *   console.log(result.value) // string
- * } else {
- *   console.error(result.reason instanceof Error) // true
- *   console.error(result.reason.message) // string
- * }
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function catchall(err: unknown): ResultFailure<Error> {
-  if (err instanceof Error) return failure(err)
-  return failure(new Error('Unknown error', { cause: err }))
-}
-
-/**
- * Creates a catcher function for the given constructor that wraps caught errors
- * in a {@link ResultFailure}.
- *
- * @example
- *
- * ```ts
- * class FooError extends Error {}
- * class BarError extends Error {}
- *
- * declare function someFunction(): Promise<string>
- *
- * const result = await someFunction()
- *   .then(success)
- *   .catch(createCatcher(FooError))
- *   .catch(createCatcher(BarError))
- *
- * if (result.success) {
- *   console.log(result.value) // string
- * } else {
- *   console.error(result.reason) // FooError | BarError
- * }
  */
-/*@__NO_SIDE_EFFECTS__*/
-export function createCatcher<T>(Ctor: new (...args: any[]) => T) {
-  return (err: unknown): ResultFailure<T> => {
-    if (err instanceof Ctor) return failure(err)
-    throw err
-  }
+export type ResultFailure<E = Error> = {
+  success: false
+  reason: E
 }

package/src/core/string-format.ts

@@ -1,5 +1,3 @@
-import isoDatestringValidator from 'iso-datestring-validator'
-const { isValidISODateString } = isoDatestringValidator
 import { validateCidString } from '@atproto/lex-data'
 import {
   AtIdentifierString,
@@ -14,6 +12,7 @@ import {
   isAtIdentifierString,
   isAtUriString,
   isDatetimeString,
+  isDatetimeStringLenient,
   isValidDid,
   isValidHandle,
   isValidLanguage,
@@ -50,28 +49,9 @@ export {
   assertDatetimeString,
   ifDatetimeString,
   isDatetimeString,
+  isDatetimeStringLenient,
 } from '@atproto/syntax'
 
-/**
- * Matches any ISO-ish datetime string. This is a more lenient check than
- * the strict {@link isDatetimeString} guard, which only allows datetimes that
- * fully conform to the AT Protocol specification (e.g. must include timezone).
- */
-export function isDatetimeStringLenient<I>(
-  input: I,
-): input is I & DatetimeString {
-  // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString
-  // type definition. A more accurate solution would be to use a branded type
-  // instead of a template literal for the "datetime" format
-  if (typeof input !== 'string') return false
-  try {
-    return isValidISODateString(input)
-  } catch {
-    // @NOTE isValidISODateString throws on some inputs
-    return false
-  }
-}
-
 // DatetimeString utilities
 export { currentDatetimeString, toDatetimeString } from '@atproto/syntax'
 

package/src/core/validation-error.ts

@@ -1,6 +1,6 @@
 import { LexError } from '@atproto/lex-data'
 import { arrayAgg } from '../util/array-agg.js'
-import { ResultFailure, failureReason } from './result.js'
+import { ResultFailure } from './result.js'
 import {
   Issue,
   IssueInvalidType,
@@ -82,38 +82,6 @@ export class LexValidationError
       issues: this.issues.map((issue) => issue.toJSON()),
     }
   }
-
-  /**
-   * Creates a validation error by combining multiple validation failures.
-   *
-   * This is useful when validating against multiple possible schemas (e.g., unions)
-   * and all branches fail. The resulting error contains issues from all failures.
-   *
-   * @param failures - The validation failures to combine
-   * @returns A single validation error containing all issues from the failures
-   *
-   * @example
-   * ```typescript
-   * const failures = schemas.map(s => s.safeValidate(data)).filter(r => !r.success)
-   * if (failures.length === schemas.length) {
-   *   throw LexValidationError.fromFailures(failures)
-   * }
-   * ```
-   */
-  static fromFailures(
-    failures: readonly ResultFailure<LexValidationError>[],
-  ): LexValidationError {
-    if (failures.length === 1) return failureReason(failures[0])
-    const issues = failures.flatMap(extractFailureIssues)
-    return new LexValidationError(issues, {
-      // Keep the original errors as the cause chain
-      cause: failures.map(failureReason),
-    })
-  }
-}
-
-function extractFailureIssues(result: ResultFailure<LexValidationError>) {
-  return result.reason.issues
 }
 
 function aggregateIssues(issues: Issue[]): Issue[] {

package/src/core/validator.ts

@@ -1,5 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { ResultFailure, ResultSuccess, success } from './result.js'
+import type * as Result from './result.js'
 import { LexValidationError } from './validation-error.js'
 import {
   Issue,
@@ -15,16 +14,16 @@ import {
 /**
  * Represents a successful validation result.
  *
- * @typeParam Value - The type of the validated value
+ * @typeParam TValue - The type of the validated value
+ * @extends Result.ResultSuccess<TValue>
  */
-export type ValidationSuccess<Value = unknown> = ResultSuccess<Value>
+export type ValidationSuccess<TValue = unknown> = Result.ResultSuccess<TValue>
 
 /**
  * Represents a failed validation result containing a {@link LexValidationError}.
  *
- * @extends ResultFailure<LexValidationError>
- * @see {@link ResultFailure}
  * @see {@link LexValidationError}
+ * @extends Result.ResultFailure<LexValidationError>
  */
 export type ValidationFailure = LexValidationError
 
@@ -429,24 +428,14 @@ export class ValidationContext {
   }
 
   /**
-   * Creates a successful validation result with the given value.
+   * Helper method to create a successful validation result.
    *
    * @typeParam V - The value type
    * @param value - The validated value
    * @returns A successful validation result
    */
-  success<V>(value: V): ValidationResult<V> {
-    return success(value)
-  }
-
-  /**
-   * Creates a failed validation result with the given error.
-   *
-   * @param reason - The validation error
-   * @returns A failed validation result
-   */
-  failure(reason: LexValidationError): ValidationFailure {
-    return reason
+  success<V>(value: V): ValidationSuccess<V> {
+    return { success: true, value }
   }
 
   /**
@@ -457,8 +446,8 @@ export class ValidationContext {
    * @param issue - The validation issue that caused the failure
    * @returns A failed validation result
    */
-  issue(issue: Issue) {
-    return this.failure(new LexValidationError([...this.issues, issue]))
+  issue(issue: Issue): ValidationFailure {
+    return new LexValidationError([...this.issues, issue])
   }
 
   /**

package/src/schema/token.ts

@@ -24,6 +24,10 @@ export class TokenSchema<
     super()
   }
 
+  get $token(): TValue {
+    return this.value
+  }
+
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (input === this.value) {
       return ctx.success(this.value)
@@ -31,7 +35,11 @@ export class TokenSchema<
 
     // @NOTE: allow using the token instance itself (but convert to the actual
     // token value)
-    if (input instanceof TokenSchema && input.value === this.value) {
+    if (
+      ctx.options.mode === 'parse' &&
+      input instanceof TokenSchema &&
+      input.value === this.value
+    ) {
       return ctx.success(this.value)
     }
 

package/src/schema/union.ts

@@ -1,10 +1,10 @@
 import {
   InferInput,
   InferOutput,
+  Issue,
   LexValidationError,
   Schema,
   ValidationContext,
-  ValidationFailure,
   Validator,
 } from '../core.js'
 
@@ -44,16 +44,16 @@ export class UnionSchema<
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
-    const failures: ValidationFailure[] = []
+    const issues: Issue[] = []
 
     for (const validator of this.validators) {
       const result = ctx.validate(input, validator)
       if (result.success) return result
 
-      failures.push(result)
+      issues.push(...result.issues)
     }
 
-    return ctx.failure(LexValidationError.fromFailures(failures))
+    return new LexValidationError(issues)
   }
 }