@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/subscription.test.ts

@@ -1,274 +1,230 @@
-import { describe, expect, it } from 'vitest'
-import { asNsidString } from '../core.js'
-import { IntegerSchema } from './integer.js'
-import { ObjectSchema } from './object.js'
-import { OptionalSchema } from './optional.js'
-import { ParamsSchema } from './params.js'
-import { RefSchema } from './ref.js'
-import { StringSchema } from './string.js'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { integer } from './integer.js'
+import { ObjectSchema, object } from './object.js'
+import { optional } from './optional.js'
+import { ParamsSchema, params } from './params.js'
+import { RefSchema, ref } from './ref.js'
+import { string } from './string.js'
 import {
   InferSubscriptionMessage,
   InferSubscriptionParameters,
   Subscription,
+  subscription,
 } from './subscription.js'
 
 describe('Subscription', () => {
   describe('constructor', () => {
     it('creates a Subscription instance with all parameters', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({})),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params({
+        cursor: optional(integer()),
       })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        data: new StringSchema({}),
+      const message = object({
+        seq: integer(),
+        data: string(),
       })
       const errors = ['ConsumerTooSlow', 'FutureCursor'] as const
 
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      const mySub = subscription(nsid, parameters, message, errors)
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.nsid).toBe(nsid)
-      expect(subscription.parameters).toBe(parameters)
-      expect(subscription.message).toBe(message)
-      expect(subscription.errors).toBe(errors)
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.nsid).toBe(nsid)
+      expect(mySub.parameters).toBe(parameters)
+      expect(mySub.message).toBe(message)
+      expect(mySub.errors).toBe(errors)
     })
 
     it('creates a Subscription instance without errors', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({})),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params({
+        cursor: optional(integer()),
       })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.nsid).toBe(nsid)
-      expect(subscription.parameters).toBe(parameters)
-      expect(subscription.message).toBe(message)
-      expect(subscription.errors).toBeUndefined()
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.nsid).toBe(nsid)
+      expect(mySub.parameters).toBe(parameters)
+      expect(mySub.message).toBe(message)
+      expect(mySub.errors).toBeUndefined()
     })
 
     it('creates a Subscription instance with empty parameters', () => {
-      const nsid = asNsidString('app.bsky.notification.subscribe')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        type: new StringSchema({}),
+      const nsid = 'app.bsky.notification.subscribe'
+      const parameters = params()
+      const message = object({
+        type: string(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.parameters).toBe(parameters)
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.parameters).toBe(parameters)
     })
   })
 
   describe('type property', () => {
     it('has type set to "subscription"', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.type).toBe('subscription')
+      expect(mySub.type).toBe('subscription')
     })
 
     it('type is a constant value', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.type).toBe('subscription')
+      expect(mySub.type).toBe('subscription')
       // TypeScript enforces readonly at compile time
-      expect(typeof subscription.type).toBe('string')
+      expect(typeof mySub.type).toBe('string')
     })
   })
 
   describe('properties', () => {
     it('has nsid property', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.nsid).toBe(nsid)
-      expect(typeof subscription.nsid).toBe('string')
+      expect(mySub.nsid).toBe(nsid)
+      expect(typeof mySub.nsid).toBe('string')
     })
 
     it('has parameters property', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.parameters).toBe(parameters)
-      expect(subscription.parameters).toBeInstanceOf(ParamsSchema)
+      expect(mySub.parameters).toBe(parameters)
+      expect(mySub.parameters).toBeInstanceOf(ParamsSchema)
     })
 
     it('has message property', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.message).toBe(message)
-      expect(subscription.message).toBeInstanceOf(ObjectSchema)
+      expect(mySub.message).toBe(message)
+      expect(mySub.message).toBeInstanceOf(ObjectSchema)
     })
 
     it('has errors property', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
       })
       const errors = ['ConsumerTooSlow'] as const
 
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      const mySub = subscription(nsid, parameters, message, errors)
 
-      expect(subscription.errors).toBe(errors)
-      expect(Array.isArray(subscription.errors)).toBe(true)
+      expect(mySub.errors).toBe(errors)
+      expect(Array.isArray(mySub.errors)).toBe(true)
     })
   })
 
   describe('with complex parameters', () => {
     it('creates a Subscription with multiple parameter types', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({ minimum: 0 })),
-        includeDeletes: new OptionalSchema(
-          new IntegerSchema({ minimum: 0, maximum: 1 }),
-        ),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params({
+        cursor: optional(integer({ minimum: 0 })),
+        includeDeletes: optional(integer({ minimum: 0, maximum: 1 })),
       })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        data: new StringSchema({}),
+      const message = object({
+        seq: integer(),
+        data: string(),
       })
       const errors = ['ConsumerTooSlow', 'FutureCursor'] as const
 
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      const mySub = subscription(nsid, parameters, message, errors)
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.parameters).toBe(parameters)
-      expect(subscription.errors).toEqual(['ConsumerTooSlow', 'FutureCursor'])
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.parameters).toBe(parameters)
+      expect(mySub.errors).toEqual(['ConsumerTooSlow', 'FutureCursor'])
     })
   })
 
   describe('with various message types', () => {
     it('creates a Subscription with ObjectSchema message', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        data: new StringSchema({}),
-      })
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
+      const mySub = subscription(
+        'com.atproto.sync.subscribeRepos',
+        params(),
+        object({
+          seq: integer(),
+          data: string(),
+        }),
         undefined,
       )
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.message).toBeInstanceOf(ObjectSchema)
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.message).toBeInstanceOf(ObjectSchema)
     })
 
     it('creates a Subscription with RefSchema message', () => {
-      const nsid = asNsidString('app.bsky.feed.subscribe')
-      const parameters = new ParamsSchema({})
-      const message = new RefSchema(() => new StringSchema({}))
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
+      const message = string()
+      const mySub = subscription(
+        'app.bsky.feed.subscribe',
+        params(),
+        ref(() => message),
         undefined,
       )
 
-      expect(subscription).toBeInstanceOf(Subscription)
-      expect(subscription.message).toBeInstanceOf(RefSchema)
+      expect(mySub).toBeInstanceOf(Subscription)
+      expect(mySub.message).toBeInstanceOf(RefSchema)
     })
   })
 
   describe('with different error configurations', () => {
     it('creates a Subscription with a single error', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
-      const errors = ['ConsumerTooSlow'] as const
-
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      const mySub = subscription(
+        'com.atproto.sync.subscribeRepos',
+        params(),
+        object({}),
+        ['ConsumerTooSlow'],
+      )
 
-      expect(subscription.errors).toEqual(['ConsumerTooSlow'])
+      expect(mySub.errors).toEqual(['ConsumerTooSlow'])
     })
 
     it('creates a Subscription with multiple errors', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
-      const errors = [
-        'ConsumerTooSlow',
-        'FutureCursor',
-        'InvalidCursor',
-      ] as const
+      const mySub = subscription(
+        'com.atproto.sync.subscribeRepos',
+        params(),
+        object({}),
+        ['ConsumerTooSlow', 'FutureCursor', 'InvalidCursor'],
+      )
 
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      expectTypeOf<
+        readonly ['ConsumerTooSlow', 'FutureCursor', 'InvalidCursor']
+      >(mySub.errors)
 
-      expect(subscription.errors).toEqual([
+      expect(mySub.errors).toEqual([
         'ConsumerTooSlow',
         'FutureCursor',
         'InvalidCursor',
@@ -276,167 +232,129 @@ describe('Subscription', () => {
     })
 
     it('creates a Subscription with empty errors array', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
-      const errors = [] as const
-
-      const subscription = new Subscription(nsid, parameters, message, errors)
+      const mySub = subscription(
+        'com.atproto.sync.subscribeRepos',
+        params(),
+        object({}),
+        [],
+      )
 
-      expect(subscription.errors).toEqual([])
+      expect(mySub.errors).toEqual([])
     })
   })
 
   describe('type inference', () => {
     it('InferSubscriptionParameters correctly infers parameter types', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({})),
-      })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-      })
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
+      const mySub = subscription(
+        'com.atproto.sync.subscribeRepos',
+        params({
+          cursor: optional(integer()),
+        }),
+        object({
+          seq: integer(),
+        }),
       )
 
-      type Params = InferSubscriptionParameters<typeof subscription>
+      type Params = InferSubscriptionParameters<typeof mySub>
 
-      // Type-level test - this should compile without errors
-      const params: Params = {
+      expectTypeOf<Params>({
         cursor: 12345,
-      }
-
-      expect(params.cursor).toBeDefined()
+      })
     })
 
     it('InferSubscriptionMessage correctly infers message type', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        data: new StringSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
+        data: string(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      type Message = InferSubscriptionMessage<typeof subscription>
+      type Message = InferSubscriptionMessage<typeof mySub>
 
-      // Type-level test - this should compile without errors
-      const msg: Message = {
+      expectTypeOf<Message>({
         seq: 12345,
         data: 'test data',
-      }
-
-      expect(msg.seq).toBeDefined()
-      expect(msg.data).toBeDefined()
+      })
     })
   })
 
   describe('edge cases', () => {
     it('handles very long NSID', () => {
-      const nsid = asNsidString(
-        'com.example.very.long.namespace.identifier.subscription.name',
-      )
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
+      const nsid =
+        'com.example.very.long.namespace.identifier.subscription.name'
+      const parameters = params()
+      const message = object({})
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.nsid).toBe(nsid)
+      expect(mySub.nsid).toBe(nsid)
     })
 
     it('handles subscription with all optional parameters', () => {
-      const nsid = asNsidString('app.bsky.feed.subscribe')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({})),
-        includeDeletes: new OptionalSchema(new IntegerSchema({})),
-        includeEdits: new OptionalSchema(new IntegerSchema({})),
+      const nsid = 'app.bsky.feed.subscribe'
+      const parameters = params({
+        cursor: optional(integer()),
+        includeDeletes: optional(integer()),
+        includeEdits: optional(integer()),
       })
-      const message = new ObjectSchema({})
+      const message = object({})
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.parameters).toBe(parameters)
+      expect(mySub.parameters).toBe(parameters)
     })
 
     it('handles subscription with complex nested message schema', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        blocks: new ObjectSchema({
-          cid: new StringSchema({ format: 'cid' }),
-          data: new ObjectSchema({
-            uri: new StringSchema({ format: 'at-uri' }),
-            content: new StringSchema({}),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer(),
+        blocks: object({
+          cid: string({ format: 'cid' }),
+          data: object({
+            uri: string({ format: 'at-uri' }),
+            content: string(),
           }),
         }),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.message).toBeInstanceOf(ObjectSchema)
+      expect(mySub.message).toBeInstanceOf(ObjectSchema)
     })
   })
 
   describe('real-world subscription examples', () => {
     it('creates a subscribeLabels subscription', () => {
-      const nsid = asNsidString('com.atproto.label.subscribeLabels')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({ minimum: 0 })),
+      const nsid = 'com.atproto.label.subscribeLabels'
+      const parameters = params({
+        cursor: optional(integer({ minimum: 0 })),
       })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        labels: new ObjectSchema({
-          uri: new StringSchema({ format: 'uri' }),
-          val: new StringSchema({}),
+      const message = object({
+        seq: integer(),
+        labels: object({
+          uri: string({ format: 'uri' }),
+          val: string(),
         }),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.type).toBe('subscription')
-      expect(subscription.nsid).toBe('com.atproto.label.subscribeLabels')
-      expect(subscription.parameters.matches({ cursor: 10 })).toBe(true)
-      expect(subscription.parameters.matches({ cursor: -10 })).toBe(false)
+      expect(mySub.type).toBe('subscription')
+      expect(mySub.nsid).toBe('com.atproto.label.subscribeLabels')
+      expect(mySub.parameters.matches({ cursor: 10 })).toBe(true)
+      expect(mySub.parameters.matches({ cursor: -10 })).toBe(false)
       expect(
-        subscription.message.matches({
+        mySub.message.matches({
           seq: 1,
           labels: { uri: 'http://foo.com', val: 'test' },
         }),
       ).toBe(true)
       expect(
-        subscription.message.matches({
+        mySub.message.matches({
           seq: 1,
           labels: { uri: 'http://foo.com', val: 3 },
         }),
@@ -444,110 +362,84 @@ describe('Subscription', () => {
     })
 
     it('creates a notification subscription', () => {
-      const nsid = asNsidString('app.bsky.notification.subscribe')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new StringSchema({})),
+      const nsid = 'app.bsky.notification.subscribe'
+      const parameters = params({
+        cursor: optional(string()),
       })
-      const message = new ObjectSchema({
-        type: new StringSchema({}),
-        uri: new StringSchema({ format: 'at-uri' }),
-        cid: new StringSchema({ format: 'cid' }),
+      const message = object({
+        type: string(),
+        uri: string({ format: 'at-uri' }),
+        cid: string({ format: 'cid' }),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.type).toBe('subscription')
-      expect(subscription.nsid).toBe('app.bsky.notification.subscribe')
+      expect(mySub.type).toBe('subscription')
+      expect(mySub.nsid).toBe('app.bsky.notification.subscribe')
     })
   })
 
   describe('with mixed parameter and message types', () => {
     it('handles required and optional parameters with complex message', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new OptionalSchema(new IntegerSchema({ minimum: 0 })),
-        includeDeletes: new OptionalSchema(
-          new IntegerSchema({ minimum: 0, maximum: 1 }),
-        ),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params({
+        cursor: optional(integer({ minimum: 0 })),
+        includeDeletes: optional(integer({ minimum: 0, maximum: 1 })),
       })
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({}),
-        rebase: new OptionalSchema(
-          new IntegerSchema({ minimum: 0, maximum: 1 }),
-        ),
-        tooBig: new OptionalSchema(
-          new IntegerSchema({ minimum: 0, maximum: 1 }),
-        ),
-        repo: new StringSchema({ format: 'did' }),
-        commit: new StringSchema({ format: 'cid' }),
-        blocks: new StringSchema({}),
-        ops: new ObjectSchema({}),
+      const message = object({
+        seq: integer(),
+        rebase: optional(integer({ minimum: 0, maximum: 1 })),
+        tooBig: optional(integer({ minimum: 0, maximum: 1 })),
+        repo: string({ format: 'did' }),
+        commit: string({ format: 'cid' }),
+        blocks: string(),
+        ops: object({}),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.type).toBe('subscription')
-      expect(subscription.parameters).toBe(parameters)
-      expect(subscription.message).toBe(message)
+      expect(mySub.type).toBe('subscription')
+      expect(mySub.parameters).toBe(parameters)
+      expect(mySub.message).toBe(message)
     })
   })
 
   describe('validation through nested schemas', () => {
     it('parameters can validate input through ParamsSchema', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({
-        cursor: new IntegerSchema({ minimum: 0 }),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params({
+        cursor: integer({ minimum: 0 }),
       })
-      const message = new ObjectSchema({})
+      const message = object({})
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
       // Test that the parameters schema can validate
-      const validResult = subscription.parameters.safeParse({ cursor: 100 })
+      const validResult = mySub.parameters.safeParse({ cursor: 100 })
       expect(validResult.success).toBe(true)
 
-      const invalidResult = subscription.parameters.safeParse({ cursor: -1 })
+      const invalidResult = mySub.parameters.safeParse({ cursor: -1 })
       expect(invalidResult.success).toBe(false)
     })
 
     it('message can validate input through ObjectSchema', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        seq: new IntegerSchema({ minimum: 0 }),
-        data: new StringSchema({ minLength: 1 }),
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({
+        seq: integer({ minimum: 0 }),
+        data: string({ minLength: 1 }),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
       // Test that the message schema can validate
-      const validResult = subscription.message.safeParse({
+      const validResult = mySub.message.safeParse({
         seq: 100,
         data: 'test',
       })
       expect(validResult.success).toBe(true)
 
-      const invalidResult = subscription.message.safeParse({
+      const invalidResult = mySub.message.safeParse({
         seq: -1,
         data: '',
       })
@@ -557,71 +449,51 @@ describe('Subscription', () => {
 
   describe('property access', () => {
     it('can access nsid after construction', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({})
+
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.nsid).toBe(nsid)
-      expect(subscription.nsid).toBe('com.atproto.sync.subscribeRepos')
+      expect(mySub.nsid).toBe(nsid)
+      expect(mySub.nsid).toBe('com.atproto.sync.subscribeRepos')
     })
 
     it('can access type after construction', () => {
-      const nsid = asNsidString('com.atproto.sync.subscribeRepos')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({})
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const nsid = 'com.atproto.sync.subscribeRepos'
+      const parameters = params()
+      const message = object({})
 
-      expect(subscription.type).toBe('subscription')
-      expect(typeof subscription.type).toBe('string')
+      const mySub = subscription(nsid, parameters, message, undefined)
+
+      expect(mySub.type).toBe('subscription')
+      expect(typeof mySub.type).toBe('string')
     })
   })
 
   describe('different message schema types', () => {
     it('constructs with ObjectSchema message', () => {
-      const nsid = asNsidString('app.bsky.test')
-      const parameters = new ParamsSchema({})
-      const message = new ObjectSchema({
-        field: new StringSchema({}),
+      const nsid = 'app.bsky.test'
+      const parameters = params()
+      const message = object({
+        field: string(),
       })
 
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.message).toBeInstanceOf(ObjectSchema)
-      expect(subscription.message).toBe(message)
+      expect(mySub.message).toBeInstanceOf(ObjectSchema)
+      expect(mySub.message).toBe(message)
     })
 
     it('constructs with RefSchema message', () => {
-      const nsid = asNsidString('app.bsky.test')
-      const parameters = new ParamsSchema({})
-      const message = new RefSchema(() => new ObjectSchema({}))
-
-      const subscription = new Subscription(
-        nsid,
-        parameters,
-        message,
-        undefined,
-      )
+      const nsid = 'app.bsky.test'
+      const parameters = params()
+      const message = ref(() => object({}))
+
+      const mySub = subscription(nsid, parameters, message, undefined)
 
-      expect(subscription.message).toBeInstanceOf(RefSchema)
-      expect(subscription.message).toBe(message)
+      expect(mySub.message).toBeInstanceOf(RefSchema)
+      expect(mySub.message).toBe(message)
     })
   })
 })