@atproto/lex-schema 0.0.13 → 0.0.14

package/src/core/validator.ts

@@ -1,6 +1,6 @@
 import { PropertyKey } from './property-key.js'
 import { ResultFailure, ResultSuccess, failure, success } from './result.js'
-import { ValidationError } from './validation-error.js'
+import { LexValidationError } from './validation-error.js'
 import {
   Issue,
   IssueInvalidFormat,
@@ -20,16 +20,16 @@ import {
 export type ValidationSuccess<Value = unknown> = ResultSuccess<Value>
 
 /**
- * Represents a failed validation result containing a {@link ValidationError}.
+ * Represents a failed validation result containing a {@link LexValidationError}.
  */
-export type ValidationFailure = ResultFailure<ValidationError>
+export type ValidationFailure = ResultFailure<LexValidationError>
 
 /**
  * Discriminated union representing the outcome of a validation operation.
  *
  * Check the `success` property to determine if validation passed or failed:
  * - If `success` is `true`, the `value` property contains the validated data
- * - If `success` is `false`, the `reason` property contains the {@link ValidationError}
+ * - If `success` is `false`, the `reason` property contains the {@link LexValidationError}
  *
  * @typeParam Value - The type of the validated value on success
  *
@@ -39,7 +39,7 @@ export type ValidationFailure = ResultFailure<ValidationError>
  * if (result.success) {
  *   // result.value is string
  * } else {
- *   // result.reason is ValidationError
+ *   // result.reason is LexValidationError
  * }
  * ```
  */
@@ -326,7 +326,7 @@ export class ValidationContext {
       if (this.issues.length > 0) {
         // Validator returned a success but issues were added via the context.
         // This means the overall validation failed.
-        return failure(new ValidationError(Array.from(this.issues)))
+        return failure(new LexValidationError(Array.from(this.issues)))
       }
 
       if (this.options.mode !== 'parse' && !Object.is(result.value, input)) {
@@ -341,7 +341,7 @@ export class ValidationContext {
         // another.
 
         // This if block comes before the next one because 'this.issues' will
-        // end-up being appended to the returned ValidationError (see the
+        // end-up being appended to the returned LexValidationError (see the
         // "failure" method below), resulting in a more complete error report.
         return this.issueInvalidValue(input, [result.value])
       }
@@ -425,7 +425,7 @@ export class ValidationContext {
    * @param reason - The validation error
    * @returns A failed validation result
    */
-  failure(reason: ValidationError): ValidationFailure {
+  failure(reason: LexValidationError): ValidationFailure {
     return failure(reason)
   }
 
@@ -438,7 +438,7 @@ export class ValidationContext {
    * @returns A failed validation result
    */
   issue(issue: Issue) {
-    return this.failure(new ValidationError([...this.issues, issue]))
+    return this.failure(new LexValidationError([...this.issues, issue]))
   }
 
   /**

package/src/schema/params.test.ts

@@ -433,6 +433,22 @@ describe('ParamsSchema', () => {
         ),
       ).toThrow('Expected boolean value type at $.foo.bar.bools (got string)')
     })
+
+    it('ignores empty string values', () => {
+      const result = schema.fromURLSearchParams([
+        ['name', 'Alice'],
+        ['extra', ''],
+      ])
+      expect(result).toEqual({ name: 'Alice' })
+    })
+
+    it('ignores empty string values for known parameters', () => {
+      const result = schema.fromURLSearchParams([
+        ['name', 'Alice'],
+        ['age', ''],
+      ])
+      expect(result).toEqual({ name: 'Alice' })
+    })
   })
 
   describe('toURLSearchParams', () => {

package/src/schema/params.ts

@@ -6,10 +6,10 @@ import {
   Issue,
   IssueInvalidType,
   IssueInvalidValue,
+  LexValidationError,
   ParseOptions,
   Schema,
   ValidationContext,
-  ValidationError,
   Validator,
   WithOptionalProperties,
 } from '../core.js'
@@ -209,6 +209,9 @@ export class ParamsSchema<
       iterable instanceof URLSearchParams ? iterable.entries() : iterable
 
     for (const [name, value] of entries) {
+      // Ignore empty strings
+      if (!value) continue
+
       const validator = this.shapeValidators.get(name)
       const innerValidator = validator ? unwrapSchema(validator) : undefined
       const expectsArray = innerValidator instanceof ArraySchema
@@ -302,7 +305,7 @@ function coerceParam(
   // the index of the param in case of array params (e.g. "tags[1]"), which
   // could be helpful for debugging. The cost overhead is not worth it though
   // (IMO).
-  throw new ValidationError([issue])
+  throw new LexValidationError([issue])
 }
 
 function paramPath(key: string, options?: ParseOptions) {

package/src/schema/record.ts

@@ -11,6 +11,7 @@ import {
   ValidationContext,
   Validator,
 } from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 import { literal } from './literal.js'
 import { string } from './string.js'
 
@@ -70,10 +71,18 @@ export class RecordSchema<
     this.keySchema = recordKey(key)
   }
 
-  isTypeOf<TValue extends { $type?: unknown }>(
-    value: TValue,
-  ): value is TypedRecord<TType, TValue> {
-    return value.$type === this.$type
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    const result = ctx.validate(input, this.schema)
+
+    if (!result.success) {
+      return result
+    }
+
+    if (result.value.$type !== this.$type) {
+      return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])
+    }
+
+    return result
   }
 
   build(
@@ -82,30 +91,26 @@ export class RecordSchema<
     return this.parse($typed(input, this.$type))
   }
 
-  $isTypeOf<TValue extends { $type?: unknown }>(
+  isTypeOf<TValue extends { $type?: unknown }>(
     value: TValue,
   ): value is TypedRecord<TType, TValue> {
-    return this.isTypeOf<TValue>(value)
+    return value.$type === this.$type
   }
 
-  $build(
-    input: Omit<InferInput<this>, '$type'>,
-  ): $Typed<InferOutput<this>, TType> {
-    return this.build(input)
+  /**
+   * Bound alias for {@link build} for compatibility with generated utilities.
+   * @see {@link build}
+   */
+  get $build(): typeof this.build {
+    return lazyProperty(this, '$build', this.build.bind(this))
   }
 
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    const result = ctx.validate(input, this.schema)
-
-    if (!result.success) {
-      return result
-    }
-
-    if (result.value.$type !== this.$type) {
-      return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])
-    }
-
-    return result
+  /**
+   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.
+   * @see {@link isTypeOf}
+   */
+  get $isTypeOf(): typeof this.isTypeOf {
+    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))
   }
 }
 

package/src/schema/typed-object.test.ts

@@ -332,6 +332,44 @@ describe('TypedObjectSchema', () => {
     })
   })
 
+  describe('bound $ methods', () => {
+    it('$build can be used as a detached function', () => {
+      const { $build } = schema
+      const result = $build({ text: 'Hello' })
+      expect(result).toEqual({
+        text: 'Hello',
+        $type: 'app.bsky.feed.post',
+      })
+    })
+
+    it('$isTypeOf can be used as a detached function', () => {
+      const { $isTypeOf } = schema
+      expect($isTypeOf({ text: 'Hello' })).toBe(true)
+      expect($isTypeOf({ $type: 'app.bsky.feed.post', text: 'Hello' })).toBe(
+        true,
+      )
+      expect($isTypeOf({ $type: 'other.type', text: 'Hello' })).toBe(false)
+    })
+
+    it('$parse can be used as a detached function', () => {
+      const { $parse } = schema
+      const result = $parse({ text: 'Hello' })
+      expect(result).toEqual({ text: 'Hello' })
+    })
+
+    it('$matches can be used as a detached function', () => {
+      const { $matches } = schema
+      expect($matches({ text: 'Hello' })).toBe(true)
+      expect($matches(42)).toBe(false)
+    })
+
+    it('lazy property returns the same function on repeated access', () => {
+      const fn1 = schema.$build
+      const fn2 = schema.$build
+      expect(fn1).toBe(fn2)
+    })
+  })
+
   describe('with complex nested schemas', () => {
     const complexSchema = typedObject(
       'app.bsky.actor.profile',

package/src/schema/typed-object.ts

@@ -14,6 +14,7 @@ import {
   ValidationContext,
   Validator,
 } from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 
 export type MaybeTypedObject<
   TType extends $Type,
@@ -56,10 +57,20 @@ export class TypedObjectSchema<
     super()
   }
 
-  isTypeOf<TValue extends Record<string, unknown>>(
-    value: TValue,
-  ): value is MaybeTypedObject<TType, TValue> {
-    return value.$type === undefined || value.$type === this.$type
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    if (!isPlainObject(input)) {
+      return ctx.issueUnexpectedType(input, 'object')
+    }
+
+    if (
+      '$type' in input &&
+      input.$type !== undefined &&
+      input.$type !== this.$type
+    ) {
+      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])
+    }
+
+    return ctx.validate(input, this.schema)
   }
 
   build(
@@ -71,32 +82,26 @@ export class TypedObjectSchema<
     >
   }
 
-  $isTypeOf<TValue extends Record<string, unknown>>(
+  isTypeOf<TValue extends Record<string, unknown>>(
     value: TValue,
   ): value is MaybeTypedObject<TType, TValue> {
-    return this.isTypeOf(value)
+    return value.$type === undefined || value.$type === this.$type
   }
 
-  $build(
-    input: Omit<InferInput<this>, '$type'>,
-  ): $Typed<InferOutput<this>, TType> {
-    return this.build(input)
+  /**
+   * Bound alias for {@link build} for compatibility with generated utilities.
+   * @see {@link build}
+   */
+  get $build(): typeof this.build {
+    return lazyProperty(this, '$build', this.build.bind(this))
   }
 
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!isPlainObject(input)) {
-      return ctx.issueUnexpectedType(input, 'object')
-    }
-
-    if (
-      '$type' in input &&
-      input.$type !== undefined &&
-      input.$type !== this.$type
-    ) {
-      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])
-    }
-
-    return ctx.validate(input, this.schema)
+  /**
+   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.
+   * @see {@link isTypeOf}
+   */
+  get $isTypeOf(): typeof this.isTypeOf {
+    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))
   }
 }
 

package/src/schema/union.ts

@@ -1,9 +1,9 @@
 import {
   InferInput,
   InferOutput,
+  LexValidationError,
   Schema,
   ValidationContext,
-  ValidationError,
   ValidationFailure,
   Validator,
 } from '../core.js'
@@ -53,7 +53,7 @@ export class UnionSchema<
       failures.push(result)
     }
 
-    return ctx.failure(ValidationError.fromFailures(failures))
+    return ctx.failure(LexValidationError.fromFailures(failures))
   }
 }