@atproto/lex-schema 0.0.9 → 0.0.10

package/src/schema/permission.ts

@@ -1,13 +1,21 @@
-import { Params } from './_parameters.js'
+import { Params } from './params.js'
 
 export type PermissionOptions = Params
 
 export class Permission<
-  const Resource extends string = any,
-  const Options extends PermissionOptions = any,
+  const TResource extends string = any,
+  const TOptions extends PermissionOptions = any,
 > {
   constructor(
-    readonly resource: Resource,
-    readonly options: Options,
+    readonly resource: TResource,
+    readonly options: TOptions,
   ) {}
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function permission<
+  const R extends string,
+  const O extends PermissionOptions,
+>(resource: R, options: PermissionOptions & O = {} as O) {
+  return new Permission<R, O>(resource, options)
+}

package/src/schema/procedure.test.ts

@@ -1,315 +1,259 @@
 import { describe, expect, it } from 'vitest'
-import { ObjectSchema } from './object.js'
-import { ParamsSchema } from './params.js'
-import { Payload } from './payload.js'
-import { Procedure } from './procedure.js'
-import { StringSchema } from './string.js'
+import { object } from './object.js'
+import { params } from './params.js'
+import { payload } from './payload.js'
+import { procedure } from './procedure.js'
+import { string } from './string.js'
 
 describe('Procedure', () => {
   describe('basic construction', () => {
     it('creates a procedure with all parameters', () => {
-      const nsid = 'com.example.createPost'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
       const errors = ['InvalidRequest', 'Unauthorized'] as const
 
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const createPost = procedure(
+        'com.example.createPost',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
+        errors,
+      )
 
-      expect(procedure.nsid).toBe(nsid)
-      expect(procedure.parameters).toBe(parameters)
-      expect(procedure.input).toBe(input)
-      expect(procedure.output).toBe(output)
-      expect(procedure.errors).toBe(errors)
+      expect(createPost.nsid).toBe('com.example.createPost')
+      expect(createPost.parameters).toEqual(params())
+      expect(createPost.input).toEqual(payload('application/json', undefined))
+      expect(createPost.output).toEqual(payload('application/json', undefined))
+      expect(createPost.errors).toBe(errors)
     })
 
     it('creates a procedure without errors', () => {
-      const nsid = 'com.example.doSomething'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const doSomething = procedure(
+        'com.example.doSomething',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.nsid).toBe(nsid)
-      expect(procedure.parameters).toBe(parameters)
-      expect(procedure.input).toBe(input)
-      expect(procedure.output).toBe(output)
-      expect(procedure.errors).toBeUndefined()
+      expect(doSomething.nsid).toBe('com.example.doSomething')
+      expect(doSomething.parameters).toEqual(params())
+      expect(doSomething.input).toEqual(payload('application/json', undefined))
+      expect(doSomething.output).toEqual(payload('application/json', undefined))
+      expect(doSomething.errors).toBeUndefined()
     })
 
     it('creates a procedure with empty errors array', () => {
-      const nsid = 'com.example.action'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
-      const errors = [] as const
-
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const performAction = procedure(
+        'com.example.performAction',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
+        [] as const,
+      )
 
-      expect(procedure.errors).toEqual([])
+      expect(performAction.errors).toEqual([])
     })
   })
 
   describe('with parameters schema', () => {
     it('creates a procedure with query parameters', () => {
-      const nsid = 'com.example.listPosts'
-      const parameters = new ParamsSchema({
-        limit: new StringSchema({}),
-        cursor: new StringSchema({}),
-      })
-      const input = new Payload(undefined, undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const listPosts = procedure(
+        'com.example.listPosts',
+        params({
+          limit: string(),
+          cursor: string(),
+        }),
+        payload(undefined, undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.parameters).toBe(parameters)
-      expect(procedure.parameters.validators).toHaveProperty('limit')
-      expect(procedure.parameters.validators).toHaveProperty('cursor')
+      expect(listPosts.parameters.shape).toHaveProperty('limit')
+      expect(listPosts.parameters.shape).toHaveProperty('cursor')
     })
 
     it('creates a procedure with empty parameters', () => {
-      const nsid = 'com.example.action'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.action',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.parameters).toBe(parameters)
-      expect(Object.keys(procedure.parameters.validators)).toHaveLength(0)
+      expect(Object.keys(myProcedure.parameters.shape)).toHaveLength(0)
     })
   })
 
   describe('with input payload', () => {
     it('creates a procedure with JSON input', () => {
-      const nsid = 'com.example.createPost'
-      const parameters = new ParamsSchema({})
-      const inputSchema = new ObjectSchema({
-        text: new StringSchema({}),
+      const inputSchema = object({
+        text: string(),
       })
-      const input = new Payload('application/json', inputSchema)
-      const output = new Payload('application/json', undefined)
 
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.createPost',
+        params(),
+        payload('application/json', inputSchema),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.input.encoding).toBe('application/json')
-      expect(procedure.input.schema).toBe(inputSchema)
+      expect(myProcedure.input.encoding).toBe('application/json')
+      expect(myProcedure.input.schema).toBe(inputSchema)
     })
 
     it('creates a procedure with text input', () => {
-      const nsid = 'com.example.uploadText'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('text/plain', undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.uploadText',
+        params(),
+        payload('text/plain', undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.input.encoding).toBe('text/plain')
-      expect(procedure.input.schema).toBeUndefined()
+      expect(myProcedure.input.encoding).toBe('text/plain')
+      expect(myProcedure.input.schema).toBeUndefined()
     })
 
     it('creates a procedure with binary input', () => {
-      const nsid = 'com.example.uploadBlob'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/octet-stream', undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.uploadBlob',
+        params(),
+        payload('application/octet-stream', undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.input.encoding).toBe('application/octet-stream')
+      expect(myProcedure.input.encoding).toBe('application/octet-stream')
     })
 
     it('creates a procedure with no input', () => {
-      const nsid = 'com.example.action'
-      const parameters = new ParamsSchema({})
-      const input = new Payload(undefined, undefined)
-      const output = new Payload('application/json', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.action',
+        params(),
+        payload(undefined, undefined),
+        payload('application/json', undefined),
         undefined,
       )
 
-      expect(procedure.input.encoding).toBeUndefined()
-      expect(procedure.input.schema).toBeUndefined()
+      expect(myProcedure.input.encoding).toBeUndefined()
+      expect(myProcedure.input.schema).toBeUndefined()
     })
   })
 
   describe('with output payload', () => {
     it('creates a procedure with JSON output', () => {
-      const nsid = 'com.example.getPost'
-      const parameters = new ParamsSchema({})
-      const input = new Payload(undefined, undefined)
-      const outputSchema = new ObjectSchema({
-        uri: new StringSchema({}),
-        cid: new StringSchema({}),
+      const outputSchema = object({
+        uri: string(),
+        cid: string(),
       })
-      const output = new Payload('application/json', outputSchema)
 
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.getPost',
+        params(),
+        payload(undefined, undefined),
+        payload('application/json', outputSchema),
         undefined,
       )
 
-      expect(procedure.output.encoding).toBe('application/json')
-      expect(procedure.output.schema).toBe(outputSchema)
+      expect(myProcedure.output.encoding).toBe('application/json')
+      expect(myProcedure.output.schema).toBe(outputSchema)
     })
 
     it('creates a procedure with text output', () => {
-      const nsid = 'com.example.export'
-      const parameters = new ParamsSchema({})
-      const input = new Payload(undefined, undefined)
-      const output = new Payload('text/plain', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.export',
+        params(),
+        payload(undefined, undefined),
+        payload('text/plain', undefined),
         undefined,
       )
 
-      expect(procedure.output.encoding).toBe('text/plain')
+      expect(myProcedure.output.encoding).toBe('text/plain')
     })
 
     it('creates a procedure with binary output', () => {
-      const nsid = 'com.example.download'
-      const parameters = new ParamsSchema({})
-      const input = new Payload(undefined, undefined)
-      const output = new Payload('application/octet-stream', undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.download',
+        params(),
+        payload(undefined, undefined),
+        payload('application/octet-stream', undefined),
         undefined,
       )
 
-      expect(procedure.output.encoding).toBe('application/octet-stream')
+      expect(myProcedure.output.encoding).toBe('application/octet-stream')
     })
 
     it('creates a procedure with no output', () => {
-      const nsid = 'com.example.deletePost'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload(undefined, undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.deletePost',
+        params(),
+        payload('application/json', undefined),
+        payload(undefined, undefined),
         undefined,
       )
 
-      expect(procedure.output.encoding).toBeUndefined()
-      expect(procedure.output.schema).toBeUndefined()
+      expect(myProcedure.output.encoding).toBeUndefined()
+      expect(myProcedure.output.schema).toBeUndefined()
     })
   })
 
   describe('with error definitions', () => {
     it('creates a procedure with single error', () => {
-      const nsid = 'com.example.action'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
-      const errors = ['InvalidRequest'] as const
-
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const myProcedure = procedure(
+        'com.example.action',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
+        ['InvalidRequest'] as const,
+      )
 
-      expect(procedure.errors).toEqual(['InvalidRequest'])
+      expect(myProcedure.errors).toEqual(['InvalidRequest'])
     })
 
     it('creates a procedure with multiple errors', () => {
-      const nsid = 'com.example.createPost'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
-      const errors = [
-        'InvalidRequest',
-        'Unauthorized',
-        'RateLimitExceeded',
-      ] as const
-
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const myProcedure = procedure(
+        'com.example.createPost',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
+        ['InvalidRequest', 'Unauthorized', 'RateLimitExceeded'] as const,
+      )
 
-      expect(procedure.errors).toHaveLength(3)
-      expect(procedure.errors).toContain('InvalidRequest')
-      expect(procedure.errors).toContain('Unauthorized')
-      expect(procedure.errors).toContain('RateLimitExceeded')
+      expect(myProcedure.errors).toHaveLength(3)
+      expect(myProcedure.errors).toContain('InvalidRequest')
+      expect(myProcedure.errors).toContain('Unauthorized')
+      expect(myProcedure.errors).toContain('RateLimitExceeded')
     })
   })
 
   describe('property access', () => {
     it('provides access to all properties', () => {
-      const nsid = 'com.example.test'
-      const parameters = new ParamsSchema({})
-      const input = new Payload('application/json', undefined)
-      const output = new Payload('application/json', undefined)
       const errors = ['Error1', 'Error2'] as const
 
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const myProcedure = procedure(
+        'com.example.test',
+        params(),
+        payload('application/json', undefined),
+        payload('application/json', undefined),
+        errors,
+      )
 
-      // Verify all properties are accessible
-      expect(procedure.nsid).toBe(nsid)
-      expect(procedure.parameters).toBe(parameters)
-      expect(procedure.input).toBe(input)
-      expect(procedure.output).toBe(output)
-      expect(procedure.errors).toBe(errors)
+      expect(myProcedure.nsid).toBe('com.example.test')
+      expect(myProcedure.parameters).toEqual(params())
+      expect(myProcedure.input).toEqual(payload('application/json', undefined))
+      expect(myProcedure.output).toEqual(payload('application/json', undefined))
+      expect(myProcedure.errors).toBe(errors)
     })
 
     it('maintains reference equality for complex properties', () => {
-      const parameters = new ParamsSchema({ test: new StringSchema({}) })
-      const inputSchema = new ObjectSchema({ field: new StringSchema({}) })
-      const outputSchema = new ObjectSchema({ result: new StringSchema({}) })
-      const input = new Payload('application/json', inputSchema)
-      const output = new Payload('application/json', outputSchema)
+      const parameters = params({ test: string() })
+      const inputSchema = object({ field: string() })
+      const outputSchema = object({ result: string() })
+      const input = payload('application/json', inputSchema)
+      const output = payload('application/json', outputSchema)
 
-      const procedure = new Procedure(
+      const myProcedure = procedure(
         'com.example.test',
         parameters,
         input,
@@ -318,66 +262,63 @@ describe('Procedure', () => {
       )
 
       // Verify references are maintained
-      expect(procedure.parameters).toBe(parameters)
-      expect(procedure.input).toBe(input)
-      expect(procedure.output).toBe(output)
-      expect(procedure.input.schema).toBe(inputSchema)
-      expect(procedure.output.schema).toBe(outputSchema)
+      expect(myProcedure.parameters).toBe(parameters)
+      expect(myProcedure.input).toBe(input)
+      expect(myProcedure.output).toBe(output)
+      expect(myProcedure.input.schema).toBe(inputSchema)
+      expect(myProcedure.output.schema).toBe(outputSchema)
     })
   })
 
   describe('complex scenarios', () => {
     it('creates a fully-featured procedure', () => {
-      const nsid = 'com.example.chat.sendMessage'
-      const parameters = new ParamsSchema({
-        conversationId: new StringSchema({}),
-      })
-      const inputSchema = new ObjectSchema({
-        text: new StringSchema({}),
-        mentions: new StringSchema({}),
+      const inputSchema = object({
+        text: string(),
+        mentions: string(),
       })
-      const outputSchema = new ObjectSchema({
-        messageId: new StringSchema({}),
-        timestamp: new StringSchema({}),
+      const outputSchema = object({
+        messageId: string(),
+        timestamp: string(),
       })
-      const input = new Payload('application/json', inputSchema)
-      const output = new Payload('application/json', outputSchema)
       const errors = [
         'ConversationNotFound',
         'MessageTooLong',
         'RateLimitExceeded',
       ] as const
 
-      const procedure = new Procedure(nsid, parameters, input, output, errors)
+      const myProcedure = procedure(
+        'com.example.chat.sendMessage',
+        params({
+          conversationId: string(),
+        }),
+        payload('application/json', inputSchema),
+        payload('application/json', outputSchema),
+        errors,
+      )
 
-      expect(procedure.nsid).toBe(nsid)
-      expect(procedure.parameters.validators).toHaveProperty('conversationId')
-      expect(procedure.input.encoding).toBe('application/json')
-      expect(procedure.input.schema).toBe(inputSchema)
-      expect(procedure.output.encoding).toBe('application/json')
-      expect(procedure.output.schema).toBe(outputSchema)
-      expect(procedure.errors).toEqual(errors)
+      expect(myProcedure.nsid).toBe('com.example.chat.sendMessage')
+      expect(myProcedure.parameters.shape).toHaveProperty('conversationId')
+      expect(myProcedure.input.encoding).toBe('application/json')
+      expect(myProcedure.input.schema).toBe(inputSchema)
+      expect(myProcedure.output.encoding).toBe('application/json')
+      expect(myProcedure.output.schema).toBe(outputSchema)
+      expect(myProcedure.errors).toEqual(errors)
     })
 
     it('creates a minimal procedure', () => {
-      const nsid = 'com.example.ping'
-      const parameters = new ParamsSchema({})
-      const input = new Payload(undefined, undefined)
-      const output = new Payload(undefined, undefined)
-
-      const procedure = new Procedure(
-        nsid,
-        parameters,
-        input,
-        output,
+      const myProcedure = procedure(
+        'com.example.ping',
+        params(),
+        payload(undefined, undefined),
+        payload(undefined, undefined),
         undefined,
       )
 
-      expect(procedure.nsid).toBe(nsid)
-      expect(Object.keys(procedure.parameters.validators)).toHaveLength(0)
-      expect(procedure.input.encoding).toBeUndefined()
-      expect(procedure.output.encoding).toBeUndefined()
-      expect(procedure.errors).toBeUndefined()
+      expect(myProcedure.nsid).toBe('com.example.ping')
+      expect(Object.keys(myProcedure.parameters.shape)).toHaveLength(0)
+      expect(myProcedure.input.encoding).toBeUndefined()
+      expect(myProcedure.output.encoding).toBeUndefined()
+      expect(myProcedure.errors).toBeUndefined()
     })
   })
 })

package/src/schema/procedure.ts

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