@atproto/lex-schema 0.0.15 → 0.0.16

package/src/schema/blob.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { assert, describe, expect, it } from 'vitest'
 import { parseCid } from '@atproto/lex-data'
 import { blob } from './blob.js'
 
@@ -214,37 +214,62 @@ describe('BlobSchema', () => {
   })
 
   describe('strict validation', () => {
-    const strictSchema = blob({ strict: true })
+    const schema = blob()
 
     it('accepts valid raw CID in strict mode', () => {
-      const result = strictSchema.safeParse({
-        $type: 'blob',
-        ref: blobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-      })
+      const result = schema.safeParse(
+        {
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: true },
+      )
       expect(result.success).toBe(true)
     })
 
     it('rejects non-raw CID in strict mode', () => {
-      const result = strictSchema.safeParse({
-        $type: 'blob',
-        ref: lexCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-      })
+      const result = schema.safeParse(
+        {
+          $type: 'blob',
+          ref: lexCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: true },
+      )
       expect(result.success).toBe(false)
     })
 
     it('accepts non-raw CID in non-strict mode', () => {
-      const nonStrictSchema = blob({ strict: false })
-      const result = nonStrictSchema.safeParse({
+      const result = schema.safeParse(
+        {
+          $type: 'blob',
+          ref: lexCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: false },
+      )
+      expect(result.success).toBe(true)
+    })
+
+    it('coerces legacy blob format in non-strict parse mode', () => {
+      const result = schema.safeParse(
+        {
+          cid: lexCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(result.success)
+      expect(result.value).toEqual({
         $type: 'blob',
         ref: lexCid,
         mimeType: 'image/jpeg',
-        size: 10000,
+        size: -1,
       })
-      expect(result.success).toBe(true)
     })
   })
 
@@ -455,51 +480,294 @@ describe('BlobSchema', () => {
     })
   })
 
-  describe('combined options', () => {
-    it('validates with strict and allowLegacy both true', () => {
-      const schema = blob({ strict: true, allowLegacy: true })
+  describe('legacy blob format with strict mode combinations', () => {
+    describe('allowLegacy: false (default)', () => {
+      const schema = blob()
+
+      describe('strict: true (default)', () => {
+        it('rejects legacy blob format', () => {
+          const result = schema.safeParse({
+            cid: blobCid.toString(),
+            mimeType: 'image/jpeg',
+          })
+          expect(result.success).toBe(false)
+        })
+
+        it('accepts standard BlobRef', () => {
+          const result = schema.safeParse({
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'image/jpeg',
+            size: 10000,
+          })
+          expect(result.success).toBe(true)
+        })
+      })
+
+      describe('strict: false', () => {
+        it('coerces legacy blob format into BlobRef', () => {
+          const result = schema.safeParse(
+            {
+              cid: blobCid.toString(),
+              mimeType: 'image/jpeg',
+            },
+            { strict: false },
+          )
+          assert(result.success)
+          expect(result.value).toEqual({
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'image/jpeg',
+            size: -1,
+          })
+        })
+
+        it('coerces legacy blob format with lexCid', () => {
+          const result = schema.safeParse(
+            {
+              cid: lexCid.toString(),
+              mimeType: 'image/png',
+            },
+            { strict: false },
+          )
+          assert(result.success)
+          expect(result.value).toEqual({
+            $type: 'blob',
+            ref: lexCid,
+            mimeType: 'image/png',
+            size: -1,
+          })
+        })
+
+        it('rejects legacy blob format with invalid cid', () => {
+          const result = schema.safeParse(
+            {
+              cid: 'invalid-cid',
+              mimeType: 'image/jpeg',
+            },
+            { strict: false },
+          )
+          expect(result.success).toBe(false)
+        })
+
+        it('accepts standard BlobRef with non-raw CID', () => {
+          const result = schema.safeParse(
+            {
+              $type: 'blob',
+              ref: lexCid,
+              mimeType: 'image/jpeg',
+              size: 10000,
+            },
+            { strict: false },
+          )
+          expect(result.success).toBe(true)
+        })
+      })
+    })
+
+    describe('allowLegacy: true', () => {
+      const schema = blob({ allowLegacy: true })
 
-      // Should accept strict BlobRef
-      const blobRefResult = schema.safeParse({
-        $type: 'blob',
-        ref: blobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
+      describe('strict: true (default)', () => {
+        it('accepts legacy blob format as LegacyBlobRef', () => {
+          const result = schema.safeParse({
+            cid: blobCid.toString(),
+            mimeType: 'image/jpeg',
+          })
+          assert(result.success)
+          expect('cid' in result.value && result.value.cid).toBe(
+            blobCid.toString(),
+          )
+        })
+
+        it('accepts standard BlobRef', () => {
+          const result = schema.safeParse({
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'image/jpeg',
+            size: 10000,
+          })
+          expect(result.success).toBe(true)
+        })
+
+        it('rejects non-raw CID in BlobRef format (strict)', () => {
+          const result = schema.safeParse({
+            $type: 'blob',
+            ref: lexCid,
+            mimeType: 'image/jpeg',
+            size: 10000,
+          })
+          expect(result.success).toBe(false)
+        })
+      })
+
+      describe('strict: false', () => {
+        it('accepts legacy blob format as LegacyBlobRef', () => {
+          const result = schema.safeParse(
+            {
+              cid: blobCid.toString(),
+              mimeType: 'image/jpeg',
+            },
+            { strict: false },
+          )
+          assert(result.success)
+          expect('cid' in result.value && result.value.cid).toBe(
+            blobCid.toString(),
+          )
+        })
+
+        it('accepts standard BlobRef with non-raw CID (non-strict)', () => {
+          const result = schema.safeParse(
+            {
+              $type: 'blob',
+              ref: lexCid,
+              mimeType: 'image/jpeg',
+              size: 10000,
+            },
+            { strict: false },
+          )
+          expect(result.success).toBe(true)
+        })
+
+        it('accepts standard BlobRef with raw CID', () => {
+          const result = schema.safeParse(
+            {
+              $type: 'blob',
+              ref: blobCid,
+              mimeType: 'image/jpeg',
+              size: 10000,
+            },
+            { strict: false },
+          )
+          expect(result.success).toBe(true)
+        })
       })
-      expect(blobRefResult.success).toBe(true)
+    })
+  })
 
-      // Should accept LegacyBlobRef
-      const legacyResult = schema.safeParse({
-        cid: blobCid.toString(),
-        mimeType: 'image/jpeg',
+  describe('mime and size checks depend on strict mode', () => {
+    describe('accept constraint', () => {
+      const schema = blob({ accept: ['image/jpeg', 'image/png'] })
+
+      it('rejects non-matching mime type in strict mode (default)', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/gif',
+          size: 10000,
+        })
+        expect(result.success).toBe(false)
+      })
+
+      it('accepts non-matching mime type in non-strict mode', () => {
+        const result = schema.safeParse(
+          {
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'image/gif',
+            size: 10000,
+          },
+          { strict: false },
+        )
+        expect(result.success).toBe(true)
       })
-      expect(legacyResult.success).toBe(true)
 
-      // Should reject non-raw CID in BlobRef format
-      const nonRawResult = schema.safeParse({
-        $type: 'blob',
-        ref: lexCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
+      it('accepts matching mime type in strict mode', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        })
+        expect(result.success).toBe(true)
       })
-      expect(nonRawResult.success).toBe(false)
     })
 
-    it('validates with all options combined', () => {
+    describe('maxSize constraint', () => {
+      const schema = blob({ maxSize: 1000 })
+
+      it('rejects oversized blob in strict mode (default)', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 5000,
+        })
+        expect(result.success).toBe(false)
+      })
+
+      it('accepts oversized blob in non-strict mode', () => {
+        const result = schema.safeParse(
+          {
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'image/jpeg',
+            size: 5000,
+          },
+          { strict: false },
+        )
+        expect(result.success).toBe(true)
+      })
+
+      it('accepts correctly sized blob in strict mode', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 500,
+        })
+        expect(result.success).toBe(true)
+      })
+    })
+
+    describe('combined accept and maxSize constraints', () => {
       const schema = blob({
-        strict: true,
-        allowLegacy: true,
         accept: ['image/jpeg'],
         maxSize: 20000,
       })
 
-      const result = schema.safeParse({
-        $type: 'blob',
-        ref: blobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
+      it('accepts valid blob in strict mode', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        })
+        expect(result.success).toBe(true)
+      })
+
+      it('rejects wrong mime in strict mode', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/png',
+          size: 10000,
+        })
+        expect(result.success).toBe(false)
+      })
+
+      it('rejects oversized in strict mode', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 30000,
+        })
+        expect(result.success).toBe(false)
+      })
+
+      it('accepts wrong mime and oversized in non-strict mode', () => {
+        const result = schema.safeParse(
+          {
+            $type: 'blob',
+            ref: blobCid,
+            mimeType: 'video/mp4',
+            size: 99999,
+          },
+          { strict: false },
+        )
+        expect(result.success).toBe(true)
       })
-      expect(result.success).toBe(true)
     })
   })
 })

package/src/schema/blob.ts

@@ -1,32 +1,36 @@
 import {
   BlobRef,
-  BlobRefCheckOptions,
   LegacyBlobRef,
   isBlobRef,
   isLegacyBlobRef,
+  parseCidSafe,
 } from '@atproto/lex-data'
 import { Schema, ValidationContext } from '../core.js'
 import { memoizedOptions } from '../util/memoize.js'
 
 /**
  * Configuration options for blob schema validation.
- *
- * @property allowLegacy - Whether to allow legacy blob references format
- * @property accept - List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
- * @property maxSize - Maximum blob size in bytes
  */
-export type BlobSchemaOptions = BlobRefCheckOptions & {
+export type BlobSchemaOptions = {
   /**
    * Whether to allow legacy blob references format
+   *
+   * @default false
    * @see {@link LegacyBlobRef}
    */
   allowLegacy?: boolean
+
   /**
-   * List of accepted mime types
+   * List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
+   *
+   * @default undefined // accepts all MIME types
    */
   accept?: string[]
+
   /**
-   * Maximum size in bytes
+   * Maximum blob size in bytes
+   *
+   * @default undefined // no size limit
    */
   maxSize?: number
 }
@@ -61,27 +65,24 @@ export class BlobSchema<
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
-    const blob: null | BlobRef | LegacyBlobRef =
-      (input as any)?.$type !== undefined
-        ? isBlobRef(input, this.options)
-          ? input
-          : null
-        : this.options?.allowLegacy === true && isLegacyBlobRef(input)
-          ? input
-          : null
+    const blob = parseValue.call(ctx, input, this.options)
 
     if (!blob) {
       return ctx.issueUnexpectedType(input, 'blob')
     }
 
-    const accept = this.options?.accept
-    if (accept && !matchesMime(blob.mimeType, accept)) {
-      return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
-    }
+    // In non-strict mode, we allow blob refs to pass through without MIME
+    // type or size checks.
+    if (ctx.options.strict) {
+      const accept = this.options?.accept
+      if (accept && !matchesMime(blob.mimeType, accept)) {
+        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
+      }
 
-    const maxSize = this.options?.maxSize
-    if (maxSize != null && 'size' in blob && blob.size > maxSize) {
-      return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)
+      const maxSize = this.options?.maxSize
+      if (maxSize != null && 'size' in blob && blob.size > maxSize) {
+        return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)
+      }
     }
 
     return ctx.success(blob)
@@ -94,6 +95,38 @@ export class BlobSchema<
   }
 }
 
+function parseValue(
+  this: ValidationContext,
+  input: unknown,
+  options?: BlobSchemaOptions,
+): BlobRef | LegacyBlobRef | null {
+  // If there is a $type property, we treat if as a potential BlobRef and
+  // validate accordingly.
+  if ((input as any)?.$type !== undefined) {
+    // Use the context's option for the "strict" check
+    return isBlobRef(input, this.options) ? input : null
+  }
+
+  // If there is no $type property, we may be dealing with a legacy blob ref. If
+  // legacy refs are allowed, validate against the legacy format. If not
+  // allowed, but we are in non-strict "parse" mode, coerce legacy refs into
+  // standard BlobRef format for backward compatibility. Otherwise, reject the
+  // value.
+  if (options?.allowLegacy) {
+    if (isLegacyBlobRef(input)) {
+      return input
+    }
+  } else if (!this.options.strict && this.options.mode === 'parse') {
+    if (isLegacyBlobRef(input)) {
+      const { cid, mimeType } = input
+      const ref = parseCidSafe(cid)
+      if (ref) return { $type: 'blob', ref, mimeType, size: -1 }
+    }
+  }
+
+  return null
+}
+
 function matchesMime(mime: string, accepted: string[]): boolean {
   if (accepted.includes('*/*')) return true
   if (accepted.includes(mime)) return true

package/src/schema/payload.ts

@@ -1,5 +1,5 @@
 import { LexValue } from '@atproto/lex-data'
-import { Infer, Schema, Validator } from '../core.js'
+import { InferInput, Schema, Validator } from '../core.js'
 import { ObjectSchema, object } from './object.js'
 
 export type { LexValue }
@@ -15,7 +15,7 @@ type ToBodyType<
   TSchema,
   TBinary,
 > = TSchema extends Schema
-  ? Infer<TSchema>
+  ? InferInput<TSchema>
   : TEncoding extends `application/json`
     ? LexValue
     : TBinary

package/src/schema/string.test.ts

@@ -265,6 +265,69 @@ describe('StringSchema', () => {
       const result = schema.safeParse('12/25/2023')
       expect(result.success).toBe(false)
     })
+
+    it('rejects datetime without timezone', () => {
+      const result = schema.safeParse('2023-12-25T12:00:00')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects date-only strings', () => {
+      // Date-only is not a valid datetime in either strict or loose mode
+      const result = schema.safeParse('2023-12-25')
+      expect(result.success).toBe(false)
+    })
+
+    describe('loose validation', () => {
+      it('accepts datetime without timezone', () => {
+        const result = schema.safeParse('2023-12-25T12:00:00', {
+          strict: false,
+        })
+        expect(result.success).toBe(true)
+      })
+
+      it('accepts datetime without separator', () => {
+        const result = schema.safeParse('20231225T120000', { strict: false })
+        expect(result.success).toBe(true)
+      })
+
+      it('rejects datetime with "-00:00" timezone offset', () => {
+        const result = schema.safeParse('2023-12-25T12:00:00-00:00', {
+          strict: false,
+        })
+        expect(result.success).toBe(false)
+      })
+
+      it('rejects date-only strings', () => {
+        const result = schema.safeParse('2023-12-25', { strict: false })
+        expect(result.success).toBe(false)
+      })
+
+      it('accepts datetime with timezone offset', () => {
+        const result = schema.safeParse('2023-12-25T12:00:00+05:30', {
+          strict: false,
+        })
+        expect(result.success).toBe(true)
+      })
+
+      it('still rejects completely invalid strings', () => {
+        expect(schema.safeParse('not a date', { strict: false }).success).toBe(
+          false,
+        )
+        expect(schema.safeParse('12/25/2023', { strict: false }).success).toBe(
+          false,
+        )
+        expect(schema.safeParse('', { strict: false }).success).toBe(false)
+      })
+
+      it('uses strict mode by default', () => {
+        // Datetime without timezone is not AT Protocol compliant
+        expect(schema.safeParse('2023-12-25T12:00:00').success).toBe(false)
+        // Date-only is not AT Protocol compliant
+        expect(schema.safeParse('2023-12-25').success).toBe(false)
+        // With timezone offset (AT Protocol compliant)
+        expect(schema.safeParse('2023-12-25T12:00:00+05:30').success).toBe(true)
+      })
+    })
   })
 
   describe('format: uri', () => {

package/src/schema/string.ts

@@ -119,7 +119,7 @@ export class StringSchema<
     }
 
     const format = this.options.format
-    if (format != null && !isStringFormat(str, format)) {
+    if (format != null && !isStringFormat(str, format, ctx.options)) {
       return ctx.issueInvalidFormat(str, format)
     }