@atproto/lex-schema 0.0.14 → 0.0.16

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/custom.ts

@@ -1,10 +1,4 @@
-import {
-  Issue,
-  IssueCustom,
-  PropertyKey,
-  Schema,
-  ValidationContext,
-} from '../core.js'
+import { Issue, IssueCustom, Schema, ValidationContext } from '../core.js'
 
 /**
  * Context object provided to custom assertion functions.

package/src/schema/params.test.ts

@@ -419,7 +419,7 @@ describe('ParamsSchema', () => {
           ['name', 'Alice'],
           ['bools', 'notabool'],
         ]),
-      ).toThrow('Expected boolean value type at $.bools (got string)')
+      ).toThrow('Expected boolean value type (got string) at $.bools')
 
       expect(() =>
         schema.fromURLSearchParams(
@@ -431,7 +431,7 @@ describe('ParamsSchema', () => {
             path: ['foo', 'bar'],
           },
         ),
-      ).toThrow('Expected boolean value type at $.foo.bar.bools (got string)')
+      ).toThrow('Expected boolean value type (got string) at $.foo.bar.bools')
     })
 
     it('ignores empty string values', () => {

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/ref.ts

@@ -32,11 +32,7 @@ export type RefSchemaGetter<out TValidator extends Validator> = () => TValidator
  * ```
  */
 export class RefSchema<const TValidator extends Validator>
-  extends Schema<
-    InferInput<TValidator>,
-    InferOutput<TValidator>,
-    TValidator['__lex']
-  >
+  extends Schema<InferInput<TValidator>, InferOutput<TValidator>>
   implements WrappedValidator<TValidator>
 {
   readonly type = 'ref' as const

package/src/schema/refine.ts

@@ -1,7 +1,6 @@
 import {
   InferInput,
   IssueCustom,
-  PropertyKey,
   ValidationContext,
   ValidationResult,
   Validator,

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)
     }
 

package/dist/core/property-key.d.ts

@@ -1,2 +0,0 @@
-export type PropertyKey = string | number;
-//# sourceMappingURL=property-key.d.ts.map

package/dist/core/property-key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"property-key.d.ts","sourceRoot":"","sources":["../../src/core/property-key.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAA"}

package/dist/core/property-key.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=property-key.js.map

package/dist/core/property-key.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"property-key.js","sourceRoot":"","sources":["../../src/core/property-key.ts"],"names":[],"mappings":"","sourcesContent":["export type PropertyKey = string | number\n"]}

package/src/core/property-key.ts

@@ -1 +0,0 @@
-export type PropertyKey = string | number