@atproto/lex-schema 0.0.9 → 0.0.11

package/src/schema/query.test.ts

@@ -1,225 +1,221 @@
 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 { Payload } from './payload.js'
-import { Query } from './query.js'
-import { StringSchema } from './string.js'
+import { integer } from './integer.js'
+import { ObjectSchema, object } from './object.js'
+import { optional } from './optional.js'
+import { ParamsSchema, params } from './params.js'
+import { Payload, payload } from './payload.js'
+import { Query, query } from './query.js'
+import { string } from './string.js'
+import { withDefault } from './with-default.js'
 
 describe('Query', () => {
   describe('constructor', () => {
     it('creates a Query instance with all parameters', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({
-        feed: new StringSchema({ format: 'at-uri' }),
-        limit: new OptionalSchema(
-          new IntegerSchema({ minimum: 1, maximum: 100 }),
-        ),
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params({
+        feed: string({ format: 'at-uri' }),
+        limit: optional(integer({ minimum: 1, maximum: 100 })),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          feed: new StringSchema({ format: 'at-uri' }),
+        object({
+          feed: string({ format: 'at-uri' }),
         }),
       )
       const errors = ['NotFound', 'RateLimitExceeded'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.nsid).toBe(nsid)
-      expect(query.parameters).toBe(parameters)
-      expect(query.output).toBe(output)
-      expect(query.errors).toBe(errors)
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.nsid).toBe(nsid)
+      expect(myQuery.parameters).toBe(parameters)
+      expect(myQuery.output).toBe(output)
+      expect(myQuery.errors).toBe(errors)
     })
 
     it('creates a Query instance without errors', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({
-        feed: new StringSchema({ format: 'at-uri' }),
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params({
+        feed: string({ format: 'at-uri' }),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          feed: new StringSchema({ format: 'at-uri' }),
+        object({
+          feed: string({ format: 'at-uri' }),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.nsid).toBe(nsid)
-      expect(query.parameters).toBe(parameters)
-      expect(query.output).toBe(output)
-      expect(query.errors).toBeUndefined()
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.nsid).toBe(nsid)
+      expect(myQuery.parameters).toBe(parameters)
+      expect(myQuery.output).toBe(output)
+      expect(myQuery.errors).toBeUndefined()
     })
 
     it('creates a Query instance with empty parameters', () => {
-      const nsid = asNsidString('app.bsky.actor.getProfile')
-      const parameters = new ParamsSchema({})
-      const output = new Payload(
+      const nsid = 'app.bsky.actor.getProfile'
+      const parameters = params()
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          did: new StringSchema({ format: 'did' }),
+        object({
+          did: string({ format: 'did' }),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.parameters).toBe(parameters)
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.parameters).toBe(parameters)
     })
   })
 
   describe('properties', () => {
     it('has nsid property', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params()
+      const output = payload('application/json', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.nsid).toBe(nsid)
-      expect(query.nsid).toBe('app.bsky.feed.getFeedSkeleton')
+      expect(myQuery.nsid).toBe(nsid)
+      expect(myQuery.nsid).toBe('app.bsky.feed.getFeedSkeleton')
     })
 
     it('has parameters property', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({
-        feed: new StringSchema({ format: 'at-uri' }),
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params({
+        feed: string({ format: 'at-uri' }),
       })
-      const output = new Payload('application/json', undefined)
+      const output = payload('application/json', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.parameters).toBe(parameters)
-      expect(query.parameters).toBeInstanceOf(ParamsSchema)
+      expect(myQuery.parameters).toBe(parameters)
+      expect(myQuery.parameters).toBeInstanceOf(ParamsSchema)
     })
 
     it('has output property', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params()
+      const output = payload('application/json', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.output).toBe(output)
-      expect(query.output).toBeInstanceOf(Payload)
+      expect(myQuery.output).toBe(output)
+      expect(myQuery.output).toBeInstanceOf(Payload)
     })
 
     it('has errors property', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params()
+      const output = payload('application/json', undefined)
       const errors = ['NotFound', 'RateLimitExceeded'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query.errors).toBe(errors)
-      expect(query.errors).toEqual(['NotFound', 'RateLimitExceeded'])
+      expect(myQuery.errors).toBe(errors)
+      expect(myQuery.errors).toEqual(['NotFound', 'RateLimitExceeded'])
     })
   })
 
   describe('with complex parameters', () => {
     it('creates a Query with multiple parameter types', () => {
-      const nsid = asNsidString('app.bsky.feed.searchPosts')
-      const parameters = new ParamsSchema({
-        q: new StringSchema({ minLength: 1 }),
-        limit: new OptionalSchema(
-          new IntegerSchema({ minimum: 1, maximum: 100 }),
-        ),
-        cursor: new OptionalSchema(new StringSchema({})),
-        author: new OptionalSchema(new StringSchema({ format: 'did' })),
+      const nsid = 'app.bsky.feed.searchPosts'
+      const parameters = params({
+        q: string({ minLength: 1 }),
+        limit: optional(integer({ minimum: 1, maximum: 100 })),
+        cursor: optional(string()),
+        author: optional(string({ format: 'did' })),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          cursor: new OptionalSchema(new StringSchema({})),
-          posts: new ObjectSchema({}),
+        object({
+          cursor: optional(string()),
+          posts: object({}),
         }),
       )
       const errors = ['BadRequest', 'RateLimitExceeded'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.parameters).toBe(parameters)
-      expect(query.errors).toEqual(['BadRequest', 'RateLimitExceeded'])
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.parameters).toBe(parameters)
+      expect(myQuery.errors).toEqual(['BadRequest', 'RateLimitExceeded'])
     })
   })
 
   describe('with various output payloads', () => {
     it('creates a Query with undefined output payload', () => {
-      const nsid = asNsidString('app.bsky.actor.getProfile')
-      const parameters = new ParamsSchema({
-        actor: new StringSchema({ format: 'at-identifier' }),
+      const nsid = 'app.bsky.actor.getProfile'
+      const parameters = params({
+        actor: string({ format: 'at-identifier' }),
       })
-      const output = new Payload(undefined, undefined)
+      const output = payload(undefined, undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.output.encoding).toBeUndefined()
-      expect(query.output.schema).toBeUndefined()
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.output.encoding).toBeUndefined()
+      expect(myQuery.output.schema).toBeUndefined()
     })
 
     it('creates a Query with JSON payload', () => {
-      const nsid = asNsidString('app.bsky.actor.getProfile')
-      const parameters = new ParamsSchema({
-        actor: new StringSchema({ format: 'at-identifier' }),
+      const nsid = 'app.bsky.actor.getProfile'
+      const parameters = params({
+        actor: string({ format: 'at-identifier' }),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          did: new StringSchema({ format: 'did' }),
-          handle: new StringSchema({ format: 'handle' }),
+        object({
+          did: string({ format: 'did' }),
+          handle: string({ format: 'handle' }),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.output.encoding).toBe('application/json')
-      expect(query.output.schema).toBeInstanceOf(ObjectSchema)
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.output.encoding).toBe('application/json')
+      expect(myQuery.output.schema).toBeInstanceOf(ObjectSchema)
     })
 
     it('creates a Query with text payload', () => {
-      const nsid = asNsidString('app.bsky.feed.getPost')
-      const parameters = new ParamsSchema({
-        uri: new StringSchema({ format: 'at-uri' }),
+      const nsid = 'app.bsky.feed.getPost'
+      const parameters = params({
+        uri: string({ format: 'at-uri' }),
       })
-      const output = new Payload('text/plain', undefined)
+      const output = payload('text/plain', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query).toBeInstanceOf(Query)
-      expect(query.output.encoding).toBe('text/plain')
+      expect(myQuery).toBeInstanceOf(Query)
+      expect(myQuery.output.encoding).toBe('text/plain')
     })
   })
 
   describe('with different error configurations', () => {
     it('creates a Query with a single error', () => {
-      const nsid = asNsidString('app.bsky.feed.getPost')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getPost'
+      const parameters = params()
+      const output = payload('application/json', undefined)
       const errors = ['NotFound'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query.errors).toEqual(['NotFound'])
+      expect(myQuery.errors).toEqual(['NotFound'])
     })
 
     it('creates a Query with multiple errors', () => {
-      const nsid = asNsidString('app.bsky.feed.getPost')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getPost'
+      const parameters = params()
+      const output = payload('application/json', undefined)
       const errors = ['NotFound', 'Unauthorized', 'RateLimitExceeded'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query.errors).toEqual([
+      expect(myQuery.errors).toEqual([
         'NotFound',
         'Unauthorized',
         'RateLimitExceeded',
@@ -227,136 +223,126 @@ describe('Query', () => {
     })
 
     it('creates a Query with empty errors array', () => {
-      const nsid = asNsidString('app.bsky.feed.getPost')
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'app.bsky.feed.getPost'
+      const parameters = params()
+      const output = payload('application/json', undefined)
       const errors = [] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query.errors).toEqual([])
+      expect(myQuery.errors).toEqual([])
     })
   })
 
   describe('edge cases', () => {
     it('handles very long NSID', () => {
-      const nsid = asNsidString(
-        'com.example.very.long.namespace.identifier.method.name',
-      )
-      const parameters = new ParamsSchema({})
-      const output = new Payload('application/json', undefined)
+      const nsid = 'com.example.very.long.namespace.identifier.method.name'
+      const parameters = params()
+      const output = payload('application/json', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.nsid).toBe(nsid)
+      expect(myQuery.nsid).toBe(nsid)
     })
 
-    it('handles query with all optional parameters', () => {
-      const nsid = asNsidString('app.bsky.feed.search')
-      const parameters = new ParamsSchema({
-        q: new OptionalSchema(new StringSchema({})),
-        limit: new OptionalSchema(new IntegerSchema({})),
-        cursor: new OptionalSchema(new StringSchema({})),
+    it('handles myQuery with all optional parameters', () => {
+      const nsid = 'app.bsky.feed.search'
+      const parameters = params({
+        q: optional(string()),
+        limit: optional(integer()),
+        cursor: optional(string()),
       })
-      const output = new Payload('application/json', undefined)
+      const output = payload('application/json', undefined)
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.parameters).toBe(parameters)
+      expect(myQuery.parameters).toBe(parameters)
     })
 
-    it('handles query with complex nested output schema', () => {
-      const nsid = asNsidString('app.bsky.feed.getTimeline')
-      const parameters = new ParamsSchema({})
-      const output = new Payload(
+    it('handles myQuery with complex nested output schema', () => {
+      const nsid = 'app.bsky.feed.getTimeline'
+      const parameters = params()
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          cursor: new OptionalSchema(new StringSchema({})),
-          feed: new ObjectSchema({
-            post: new ObjectSchema({
-              uri: new StringSchema({ format: 'at-uri' }),
-              cid: new StringSchema({ format: 'cid' }),
+        object({
+          cursor: optional(string()),
+          feed: object({
+            post: object({
+              uri: string({ format: 'at-uri' }),
+              cid: string({ format: 'cid' }),
             }),
           }),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.output.schema).toBeInstanceOf(ObjectSchema)
+      expect(myQuery.output.schema).toBeInstanceOf(ObjectSchema)
     })
   })
 
-  describe('real-world query examples', () => {
-    it('creates a getFeedSkeleton query', () => {
-      const nsid = asNsidString('app.bsky.feed.getFeedSkeleton')
-      const parameters = new ParamsSchema({
-        feed: new StringSchema({ format: 'at-uri' }),
-        limit: new OptionalSchema(
-          new IntegerSchema({ minimum: 1, maximum: 100, default: 50 }),
-        ),
-        cursor: new OptionalSchema(new StringSchema({})),
+  describe('real-world myQuery examples', () => {
+    it('creates a getFeedSkeleton myQuery', () => {
+      const nsid = 'app.bsky.feed.getFeedSkeleton'
+      const parameters = params({
+        feed: string({ format: 'at-uri' }),
+        limit: optional(withDefault(integer({ minimum: 1, maximum: 100 }), 50)),
+        cursor: optional(string()),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          cursor: new OptionalSchema(new StringSchema({})),
-          feed: new ObjectSchema({}),
+        object({
+          cursor: optional(string()),
+          feed: object({}),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.nsid).toBe('app.bsky.feed.getFeedSkeleton')
+      expect(myQuery.nsid).toBe('app.bsky.feed.getFeedSkeleton')
     })
 
-    it('creates a searchPosts query', () => {
-      const nsid = asNsidString('app.bsky.feed.searchPosts')
-      const parameters = new ParamsSchema({
-        q: new StringSchema({ minLength: 1, maxLength: 300 }),
-        limit: new OptionalSchema(
-          new IntegerSchema({ minimum: 1, maximum: 100, default: 25 }),
-        ),
-        cursor: new OptionalSchema(new StringSchema({})),
+    it('creates a searchPosts myQuery', () => {
+      const nsid = 'app.bsky.feed.searchPosts'
+      const parameters = params({
+        q: string({ minLength: 1, maxLength: 300 }),
+        limit: optional(withDefault(integer({ minimum: 1, maximum: 100 }), 25)),
+        cursor: optional(string()),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          cursor: new OptionalSchema(new StringSchema({})),
-          hitsTotal: new OptionalSchema(new IntegerSchema({})),
-          posts: new ObjectSchema({}),
+        object({
+          cursor: optional(string()),
+          hitsTotal: optional(integer()),
+          posts: object({}),
         }),
       )
       const errors = ['BadRequest'] as const
 
-      const query = new Query(nsid, parameters, output, errors)
+      const myQuery = query(nsid, parameters, output, errors)
 
-      expect(query.nsid).toBe('app.bsky.feed.searchPosts')
-      expect(query.errors).toEqual(['BadRequest'])
+      expect(myQuery.nsid).toBe('app.bsky.feed.searchPosts')
+      expect(myQuery.errors).toEqual(['BadRequest'])
     })
 
-    it('creates a getProfile query', () => {
-      const nsid = asNsidString('app.bsky.actor.getProfile')
-      const parameters = new ParamsSchema({
-        actor: new StringSchema({ format: 'at-identifier' }),
+    it('creates a getProfile myQuery', () => {
+      const nsid = 'app.bsky.actor.getProfile'
+      const parameters = params({
+        actor: string({ format: 'at-identifier' }),
       })
-      const output = new Payload(
+      const output = payload(
         'application/json',
-        new ObjectSchema({
-          did: new StringSchema({ format: 'did' }),
-          handle: new StringSchema({ format: 'handle' }),
-          displayName: new OptionalSchema(
-            new StringSchema({ maxGraphemes: 64 }),
-          ),
-          description: new OptionalSchema(
-            new StringSchema({ maxGraphemes: 256 }),
-          ),
+        object({
+          did: string({ format: 'did' }),
+          handle: string({ format: 'handle' }),
+          displayName: optional(string({ maxGraphemes: 64 })),
+          description: optional(string({ maxGraphemes: 256 })),
         }),
       )
 
-      const query = new Query(nsid, parameters, output, undefined)
+      const myQuery = query(nsid, parameters, output, undefined)
 
-      expect(query.nsid).toBe('app.bsky.actor.getProfile')
+      expect(myQuery.nsid).toBe('app.bsky.actor.getProfile')
     })
   })
 })

package/src/schema/query.ts

@@ -3,10 +3,12 @@ import { ParamsSchema } from './params.js'
 import { Payload } from './payload.js'
 
 export class Query<
-  TNsid extends NsidString = NsidString,
-  TParameters extends ParamsSchema = ParamsSchema,
-  TOutputPayload extends Payload = Payload,
-  TErrors extends undefined | readonly string[] = undefined | readonly string[],
+  const TNsid extends NsidString = NsidString,
+  const TParameters extends ParamsSchema = ParamsSchema,
+  const TOutputPayload extends Payload = Payload,
+  const TErrors extends undefined | readonly string[] =
+    | undefined
+    | readonly string[],
 > {
   readonly type = 'query' as const
 
@@ -17,3 +19,13 @@ export class Query<
     readonly errors: TErrors,
   ) {}
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function query<
+  const N extends NsidString,
+  const P extends ParamsSchema,
+  const O extends Payload,
+  const E extends undefined | readonly string[] = undefined,
+>(nsid: N, parameters: P, output: O, errors: E = undefined as E) {
+  return new Query<N, P, O, E>(nsid, parameters, output, errors)
+}