@atproto/lex-schema 0.0.4 → 0.0.5

package/src/schema/subscription.ts

@@ -1,33 +1,20 @@
 import { NsidString } from '../core.js'
-import { Infer } from '../validation.js'
-import { ObjectSchema } from './object.js'
+import { Infer, Schema } from '../validation.js'
 import { ParamsSchema } from './params.js'
-import { RefSchema } from './ref.js'
-import { TypedUnionSchema } from './typed-union.js'
 
-export type InferSubscriptionParameters<S extends Subscription> =
-  S extends Subscription<any, infer P extends ParamsSchema, any>
-    ? Infer<P>
-    : never
+export type InferSubscriptionParameters<S extends Subscription> = Infer<
+  S['parameters']
+>
 
-export type InferSubscriptionMessage<S extends Subscription> =
-  S extends Subscription<
-    any,
-    any,
-    infer M extends RefSchema | TypedUnionSchema | ObjectSchema
-  >
-    ? Infer<M>
-    : unknown
+export type InferSubscriptionMessage<S extends Subscription> = Infer<
+  S['message']
+>
 
 export class Subscription<
-  TNsid extends NsidString = any,
-  TParameters extends ParamsSchema = any,
-  TMessage extends
-    | undefined
-    | RefSchema
-    | TypedUnionSchema
-    | ObjectSchema = any,
-  TErrors extends undefined | readonly string[] = any,
+  TNsid extends NsidString = NsidString,
+  TParameters extends ParamsSchema = ParamsSchema,
+  TMessage extends Schema = Schema,
+  TErrors extends undefined | readonly string[] = undefined | readonly string[],
 > {
   readonly type = 'subscription' as const
 

package/src/schema/typed-object.ts

@@ -7,15 +7,16 @@ import {
   Validator,
   ValidatorContext,
 } from '../validation.js'
+import { TypedObject } from './typed-union.js'
 
 export type TypedObjectSchemaOutput<
   T extends $Type,
-  S extends Validator<{ [_ in string]?: unknown }>,
+  S extends Validator<{ [k: string]: unknown }>,
 > = Simplify<Infer<S> & { $type?: T }>
 
 export class TypedObjectSchema<
   const T extends $Type = any,
-  const S extends Validator<{ [_ in string]?: unknown }> = any,
+  const S extends Validator<{ [k: string]: unknown }> = any,
 > extends Schema<TypedObjectSchemaOutput<T, S>> {
   constructor(
     readonly $type: T,
@@ -26,7 +27,10 @@ export class TypedObjectSchema<
 
   isTypeOf<X extends Record<string, unknown>>(
     value: X,
-  ): value is X extends { $type?: T } ? X : X & { $type?: T } {
+  ): value is Exclude<
+    X extends { $type?: T } ? X : X & { $type?: T },
+    TypedObject
+  > {
     return value.$type === undefined || value.$type === this.$type
   }
 

package/src/schema/union.ts

@@ -33,9 +33,6 @@ export class UnionSchema<V extends UnionSchemaValidators = any> extends Schema<
       }
     }
 
-    return {
-      success: false,
-      error: ValidationError.fromFailures(failures),
-    }
+    return ctx.failure(ValidationError.fromFailures(failures))
   }
 }

package/src/util/assertion-util.ts

@@ -0,0 +1,40 @@
+export type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T
+export type CastFn<T> = <I extends string>(input: I) => I & T
+export type CheckFn<T> = <I extends string>(input: I) => input is I & T
+
+export function createAssertFunction<T extends string>(
+  checkFn: (input: string) => input is T,
+  errorMessage?: string,
+): AssertFn<T>
+export function createAssertFunction<T extends string>(
+  checkFn: (input: string) => boolean,
+  errorMessage?: string,
+): AssertFn<T>
+export function createAssertFunction<T extends string>(
+  checkFn: (input: string) => boolean,
+  errorMessage = 'Invalid format',
+): AssertFn<T> {
+  return (input: string) => {
+    if (!checkFn(input)) throw new Error(errorMessage)
+  }
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function createCastFunction<T>(assertFn: AssertFn<T>): CastFn<T> {
+  return <I extends string>(input: I) => {
+    assertFn(input)
+    return input as I & T
+  }
+}
+
+/*@__NO_SIDE_EFFECTS__ */
+export function createCheckFunction<T>(assertFn: AssertFn<T>): CheckFn<T> {
+  return <I extends string>(input: I): input is I & T => {
+    try {
+      assertFn(input)
+      return true
+    } catch {
+      return false
+    }
+  }
+}

package/src/validation/schema.ts

@@ -5,17 +5,42 @@ import {
   ValidatorContext,
 } from './validator.js'
 
-export abstract class Schema<Output> implements Validator<Output> {
-  declare readonly ['_lex']: { output: Output }
+export abstract class Schema<Output = any> implements Validator<Output> {
+  declare readonly ['__lex']: { output: Output }
 
   abstract validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<Output>
 
+  /**
+   * @note use {@link check}() instead of {@link assert}() if you encounter a
+   * `ts(2775)` error and you are not able to fully type the validator. This
+   * will typically arise in generic contexts, where the narrowed type is not
+   * needed.
+   */
   assert(input: unknown): asserts input is Output {
     const result = this.safeParse(input, { allowTransform: false })
-    if (!result.success) throw result.error
+    if (!result.success) throw result.reason
+  }
+
+  /**
+   * Alias for {@link assert}(). Most useful in generic contexts where the
+   * validator is not exactly typed, allowing to avoid "_Assertions require
+   * every name in the call target to be declared with an explicit type
+   * annotation. ts(2775)_" errors.
+   */
+  check(input: unknown): void {
+    this.assert(input)
+  }
+
+  /**
+   * Casts the input (by validating it) to the output type if it matches the
+   * schema, otherwise throws. This is the same as calling {@link parse}() with
+   * `allowTransform: false`.
+   */
+  cast<I>(input: I): I & Output {
+    return this.parse(input, { allowTransform: false })
   }
 
   matches(input: unknown): input is Output {
@@ -34,7 +59,7 @@ export abstract class Schema<Output> implements Validator<Output> {
   parse(input: unknown, options?: ValidationOptions): Output
   parse(input: unknown, options?: ValidationOptions): Output {
     const result = this.safeParse(input, options)
-    if (!result.success) throw result.error
+    if (!result.success) throw result.reason
     return result.value
   }
 

package/src/validation/validation-error.ts

@@ -1,4 +1,4 @@
-import { ResultFailure, failureError } from '../core.js'
+import { ResultFailure, failureReason } from '../core.js'
 import { arrayAgg } from '../util/array-agg.js'
 import {
   Issue,
@@ -20,17 +20,17 @@ export class ValidationError extends Error {
   static fromFailures(
     failures: ResultFailure<ValidationError>[],
   ): ValidationError {
-    if (failures.length === 1) return failures[0].error
+    if (failures.length === 1) return failureReason(failures[0])
     const issues = failures.flatMap(extractFailureIssues)
     return new ValidationError(issues, {
       // Keep the original errors as the cause chain
-      cause: failures.map(failureError),
+      cause: failures.map(failureReason),
     })
   }
 }
 
 function extractFailureIssues(result: ResultFailure<ValidationError>) {
-  return result.error.issues
+  return result.reason.issues
 }
 
 function aggregateIssues(issues: Issue[]): Issue[] {

package/src/validation/validation-issue.ts

@@ -184,8 +184,18 @@ function stringifyType(value: unknown): string {
       if (value instanceof Set) return 'set'
       return 'object'
     case 'number':
-      if (Number.isInteger(value)) return 'integer'
-      if (Number.isNaN(value)) return 'NaN'
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return 'integer'
+      }
+      if (Number.isNaN(value)) {
+        return 'NaN'
+      }
+      if (value === Infinity) {
+        return 'Infinity'
+      }
+      if (value === -Infinity) {
+        return '-Infinity'
+      }
       return 'float'
     default:
       return typeof value

package/src/validation/validator.ts

@@ -25,7 +25,7 @@ export type ValidationOptions = {
   allowTransform?: boolean
 }
 
-export type Infer<T extends Validator> = T['_lex']['output']
+export type Infer<T extends Validator> = T['__lex']['output']
 
 export interface Validator<Output = any> {
   /**
@@ -34,7 +34,7 @@ export interface Validator<Output = any> {
    *
    * @deprecated **INTERNAL API, DO NOT USE**.
    */
-  readonly ['_lex']: { output: Output }
+  readonly ['__lex']: { output: Output }
 
   /**
    * @internal **INTERNAL API**: use {@link ValidatorContext.validate} instead
@@ -162,24 +162,28 @@ export class ValidatorContext {
     return success(value)
   }
 
-  failure(issue: Issue): ValidationFailure {
-    return failure(new ValidationError([...this.issues, issue]))
+  failure(reason: ValidationError): ValidationFailure {
+    return failure(reason)
+  }
+
+  issue(issue: Issue) {
+    return this.failure(new ValidationError([...this.issues, issue]))
   }
 
   issueInvalidValue(input: unknown, values: readonly unknown[]) {
-    return this.failure(new IssueInvalidValue(this.path, input, values))
+    return this.issue(new IssueInvalidValue(this.path, input, values))
   }
 
   issueInvalidType(input: unknown, expected: string) {
-    return this.failure(new IssueInvalidType(this.path, input, [expected]))
+    return this.issue(new IssueInvalidType(this.path, input, [expected]))
   }
 
   issueRequiredKey(input: object, key: PropertyKey) {
-    return this.failure(new IssueRequiredKey(this.path, input, key))
+    return this.issue(new IssueRequiredKey(this.path, input, key))
   }
 
   issueInvalidFormat(input: unknown, format: string, msg?: string) {
-    return this.failure(new IssueInvalidFormat(this.path, input, format, msg))
+    return this.issue(new IssueInvalidFormat(this.path, input, format, msg))
   }
 
   issueTooBig(
@@ -188,7 +192,7 @@ export class ValidatorContext {
     max: number,
     actual: number,
   ) {
-    return this.failure(new IssueTooBig(this.path, input, max, type, actual))
+    return this.issue(new IssueTooBig(this.path, input, max, type, actual))
   }
 
   issueTooSmall(
@@ -197,7 +201,7 @@ export class ValidatorContext {
     min: number,
     actual: number,
   ) {
-    return this.failure(new IssueTooSmall(this.path, input, min, type, actual))
+    return this.issue(new IssueTooSmall(this.path, input, min, type, actual))
   }
 
   issueInvalidPropertyValue<I>(
@@ -207,7 +211,7 @@ export class ValidatorContext {
   ) {
     const value = input[property]
     const path = this.concatPath(property)
-    return this.failure(new IssueInvalidValue(path, value, values))
+    return this.issue(new IssueInvalidValue(path, value, values))
   }
 
   issueInvalidPropertyType<I>(
@@ -217,6 +221,6 @@ export class ValidatorContext {
   ) {
     const value = input[property]
     const path = this.concatPath(property)
-    return this.failure(new IssueInvalidType(path, value, [expected]))
+    return this.issue(new IssueInvalidType(path, value, [expected]))
   }
 }

package/tsconfig.tests.json

@@ -1,6 +1,6 @@
 {
   "extends": "../../../tsconfig/tests.json",
-  "include": ["./tests", "./src/**.test.ts"],
+  "include": ["./tests", "./src/**/*.test.ts"],
   "compilerOptions": {
     "noImplicitAny": true,
     "rootDir": "./",