@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/permission.test.ts

@@ -1,145 +1,145 @@
 import { describe, expect, it } from 'vitest'
-import { Permission } from './permission.js'
+import { permission } from './permission.js'
 
 describe('Permission', () => {
   describe('basic construction', () => {
-    it('creates a permission with resource and empty options', () => {
-      const permission = new Permission('read', {})
-      expect(permission.resource).toBe('read')
-      expect(permission.options).toEqual({})
+    it('creates a perm with resource and empty options', () => {
+      const perm = permission('read', {})
+      expect(perm.resource).toBe('read')
+      expect(perm.options).toEqual({})
     })
 
-    it('creates a permission with resource and options', () => {
+    it('creates a perm with resource and options', () => {
       const options = { limit: 100 }
-      const permission = new Permission('read', options)
-      expect(permission.resource).toBe('read')
-      expect(permission.options).toEqual({ limit: 100 })
+      const perm = permission('read', options)
+      expect(perm.resource).toBe('read')
+      expect(perm.options).toEqual({ limit: 100 })
     })
 
     it('preserves the options object reference', () => {
       const options = { limit: 100 }
-      const permission = new Permission('read', options)
-      expect(permission.options).toBe(options)
+      const perm = permission('read', options)
+      expect(perm.options).toBe(options)
     })
 
     it('preserves resource as const literal type', () => {
-      const permission = new Permission('read' as const, {})
-      expect(permission.resource).toBe('read')
+      const perm = permission('read' as const, {})
+      expect(perm.resource).toBe('read')
     })
   })
 
   describe('resource strings', () => {
     it('handles simple resource names', () => {
-      const permission = new Permission('read', {})
-      expect(permission.resource).toBe('read')
+      const perm = permission('read', {})
+      expect(perm.resource).toBe('read')
     })
 
     it('handles namespaced resource names', () => {
-      const permission = new Permission('com.example.read', {})
-      expect(permission.resource).toBe('com.example.read')
+      const perm = permission('com.example.read', {})
+      expect(perm.resource).toBe('com.example.read')
     })
 
     it('handles resource names with dashes', () => {
-      const permission = new Permission('read-posts', {})
-      expect(permission.resource).toBe('read-posts')
+      const perm = permission('read-posts', {})
+      expect(perm.resource).toBe('read-posts')
     })
 
     it('handles resource names with underscores', () => {
-      const permission = new Permission('read_posts', {})
-      expect(permission.resource).toBe('read_posts')
+      const perm = permission('read_posts', {})
+      expect(perm.resource).toBe('read_posts')
     })
 
     it('handles resource names with colons', () => {
-      const permission = new Permission('posts:read', {})
-      expect(permission.resource).toBe('posts:read')
+      const perm = permission('posts:read', {})
+      expect(perm.resource).toBe('posts:read')
     })
 
     it('handles resource names with slashes', () => {
-      const permission = new Permission('posts/read', {})
-      expect(permission.resource).toBe('posts/read')
+      const perm = permission('posts/read', {})
+      expect(perm.resource).toBe('posts/read')
     })
 
     it('handles resource names with wildcards', () => {
-      const permission = new Permission('posts:*', {})
-      expect(permission.resource).toBe('posts:*')
+      const perm = permission('posts:*', {})
+      expect(perm.resource).toBe('posts:*')
     })
 
     it('handles empty resource string', () => {
-      const permission = new Permission('', {})
-      expect(permission.resource).toBe('')
+      const perm = permission('', {})
+      expect(perm.resource).toBe('')
     })
 
     it('handles very long resource strings', () => {
       const longResource = 'com.example.service.'.repeat(50) + 'read'
-      const permission = new Permission(longResource, {})
-      expect(permission.resource).toBe(longResource)
+      const perm = permission(longResource, {})
+      expect(perm.resource).toBe(longResource)
     })
 
     it('handles resource strings with unicode characters', () => {
-      const permission = new Permission('リソース', {})
-      expect(permission.resource).toBe('リソース')
+      const perm = permission('リソース', {})
+      expect(perm.resource).toBe('リソース')
     })
 
     it('handles resource strings with special characters', () => {
-      const permission = new Permission('resource@#$%', {})
-      expect(permission.resource).toBe('resource@#$%')
+      const perm = permission('resource@#$%', {})
+      expect(perm.resource).toBe('resource@#$%')
     })
   })
 
   describe('options with string parameters', () => {
     it('accepts empty options object', () => {
-      const permission = new Permission('read', {})
-      expect(permission.options).toEqual({})
+      const perm = permission('read', {})
+      expect(perm.options).toEqual({})
     })
 
     it('accepts options with string value', () => {
-      const permission = new Permission('read', { format: 'json' })
-      expect(permission.options).toEqual({ format: 'json' })
+      const perm = permission('read', { format: 'json' })
+      expect(perm.options).toEqual({ format: 'json' })
     })
 
     it('accepts options with multiple string values', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         format: 'json',
         encoding: 'utf-8',
       })
-      expect(permission.options).toEqual({ format: 'json', encoding: 'utf-8' })
+      expect(perm.options).toEqual({ format: 'json', encoding: 'utf-8' })
     })
 
     it('accepts options with empty string value', () => {
-      const permission = new Permission('read', { filter: '' })
-      expect(permission.options).toEqual({ filter: '' })
+      const perm = permission('read', { filter: '' })
+      expect(perm.options).toEqual({ filter: '' })
     })
 
     it('accepts options with very long string values', () => {
       const longString = 'value'.repeat(1000)
-      const permission = new Permission('read', { data: longString })
-      expect(permission.options.data).toBe(longString)
+      const perm = permission('read', { data: longString })
+      expect(perm.options.data).toBe(longString)
     })
   })
 
   describe('options with integer parameters', () => {
     it('accepts options with positive integer', () => {
-      const permission = new Permission('read', { limit: 100 })
-      expect(permission.options).toEqual({ limit: 100 })
+      const perm = permission('read', { limit: 100 })
+      expect(perm.options).toEqual({ limit: 100 })
     })
 
     it('accepts options with zero', () => {
-      const permission = new Permission('read', { offset: 0 })
-      expect(permission.options).toEqual({ offset: 0 })
+      const perm = permission('read', { offset: 0 })
+      expect(perm.options).toEqual({ offset: 0 })
     })
 
     it('accepts options with negative integer', () => {
-      const permission = new Permission('read', { delta: -50 })
-      expect(permission.options).toEqual({ delta: -50 })
+      const perm = permission('read', { delta: -50 })
+      expect(perm.options).toEqual({ delta: -50 })
     })
 
     it('accepts options with multiple integers', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         limit: 100,
         offset: 20,
         maxRetries: 3,
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         limit: 100,
         offset: 20,
         maxRetries: 3,
@@ -147,29 +147,29 @@ describe('Permission', () => {
     })
 
     it('accepts options with large integers', () => {
-      const permission = new Permission('read', { maxSize: 2147483647 })
-      expect(permission.options).toEqual({ maxSize: 2147483647 })
+      const perm = permission('read', { maxSize: 2147483647 })
+      expect(perm.options).toEqual({ maxSize: 2147483647 })
     })
   })
 
   describe('options with boolean parameters', () => {
     it('accepts options with true boolean', () => {
-      const permission = new Permission('read', { includeDeleted: true })
-      expect(permission.options).toEqual({ includeDeleted: true })
+      const perm = permission('read', { includeDeleted: true })
+      expect(perm.options).toEqual({ includeDeleted: true })
     })
 
     it('accepts options with false boolean', () => {
-      const permission = new Permission('read', { includeDeleted: false })
-      expect(permission.options).toEqual({ includeDeleted: false })
+      const perm = permission('read', { includeDeleted: false })
+      expect(perm.options).toEqual({ includeDeleted: false })
     })
 
     it('accepts options with multiple booleans', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         includeDeleted: true,
         includeDrafts: false,
         includeArchived: true,
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         includeDeleted: true,
         includeDrafts: false,
         includeArchived: true,
@@ -179,40 +179,40 @@ describe('Permission', () => {
 
   describe('options with array parameters', () => {
     it('accepts options with string array', () => {
-      const permission = new Permission('read', { fields: ['id', 'name'] })
-      expect(permission.options).toEqual({ fields: ['id', 'name'] })
+      const perm = permission('read', { fields: ['id', 'name'] })
+      expect(perm.options).toEqual({ fields: ['id', 'name'] })
     })
 
     it('accepts options with integer array', () => {
-      const permission = new Permission('read', { ids: [1, 2, 3] })
-      expect(permission.options).toEqual({ ids: [1, 2, 3] })
+      const perm = permission('read', { ids: [1, 2, 3] })
+      expect(perm.options).toEqual({ ids: [1, 2, 3] })
     })
 
     it('accepts options with boolean array', () => {
-      const permission = new Permission('read', { flags: [true, false, true] })
-      expect(permission.options).toEqual({ flags: [true, false, true] })
+      const perm = permission('read', { flags: [true, false, true] })
+      expect(perm.options).toEqual({ flags: [true, false, true] })
     })
 
     it('accepts options with empty array', () => {
-      const permission = new Permission('read', { fields: [] })
-      expect(permission.options).toEqual({ fields: [] })
+      const perm = permission('read', { fields: [] })
+      expect(perm.options).toEqual({ fields: [] })
     })
 
     it('preserves array reference in options', () => {
       const fields = ['id', 'name']
-      const permission = new Permission('read', { fields })
-      expect(permission.options.fields).toBe(fields)
+      const perm = permission('read', { fields })
+      expect(perm.options.fields).toBe(fields)
     })
   })
 
   describe('options with mixed parameter types', () => {
     it('accepts options with string, integer, and boolean', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         format: 'json',
         limit: 100,
         includeDeleted: true,
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         format: 'json',
         limit: 100,
         includeDeleted: true,
@@ -220,13 +220,13 @@ describe('Permission', () => {
     })
 
     it('accepts options with all parameter types', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         format: 'json',
         limit: 100,
         includeDeleted: true,
         fields: ['id', 'name'],
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         format: 'json',
         limit: 100,
         includeDeleted: true,
@@ -235,7 +235,7 @@ describe('Permission', () => {
     })
 
     it('accepts options with many parameters', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         param1: 'value1',
         param2: 'value2',
         param3: 'value3',
@@ -245,7 +245,7 @@ describe('Permission', () => {
         param7: false,
         param8: ['a', 'b'],
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         param1: 'value1',
         param2: 'value2',
         param3: 'value3',
@@ -260,18 +260,18 @@ describe('Permission', () => {
 
   describe('options with undefined values', () => {
     it('accepts options with undefined values', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         optionalParam: undefined,
       })
-      expect(permission.options).toEqual({ optionalParam: undefined })
+      expect(perm.options).toEqual({ optionalParam: undefined })
     })
 
     it('accepts options with mix of defined and undefined values', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         required: 'value',
         optional: undefined,
       })
-      expect(permission.options).toEqual({
+      expect(perm.options).toEqual({
         required: 'value',
         optional: undefined,
       })
@@ -279,84 +279,84 @@ describe('Permission', () => {
 
     it('preserves undefined in options object', () => {
       const options = { param: undefined }
-      const permission = new Permission('read', options)
-      expect('param' in permission.options).toBe(true)
-      expect(permission.options.param).toBeUndefined()
+      const perm = permission('read', options)
+      expect('param' in perm.options).toBe(true)
+      expect(perm.options.param).toBeUndefined()
     })
   })
 
-  describe('multiple permission instances', () => {
+  describe('multiple perm instances', () => {
     it('creates independent instances', () => {
-      const permission1 = new Permission('read', { limit: 100 })
-      const permission2 = new Permission('write', { format: 'json' })
+      const perm1 = permission('read', { limit: 100 })
+      const perm2 = permission('write', { format: 'json' })
 
-      expect(permission1.resource).toBe('read')
-      expect(permission2.resource).toBe('write')
-      expect(permission1.options).toEqual({ limit: 100 })
-      expect(permission2.options).toEqual({ format: 'json' })
+      expect(perm1.resource).toBe('read')
+      expect(perm2.resource).toBe('write')
+      expect(perm1.options).toEqual({ limit: 100 })
+      expect(perm2.options).toEqual({ format: 'json' })
     })
 
     it('instances with same values are not equal', () => {
-      const permission1 = new Permission('read', { limit: 100 })
-      const permission2 = new Permission('read', { limit: 100 })
+      const perm1 = permission('read', { limit: 100 })
+      const perm2 = permission('read', { limit: 100 })
 
-      expect(permission1).not.toBe(permission2)
-      expect(permission1.resource).toBe(permission2.resource)
-      expect(permission1.options).not.toBe(permission2.options)
-      expect(permission1.options).toEqual(permission2.options)
+      expect(perm1).not.toBe(perm2)
+      expect(perm1.resource).toBe(perm2.resource)
+      expect(perm1.options).not.toBe(perm2.options)
+      expect(perm1.options).toEqual(perm2.options)
     })
 
     it('instances sharing options object reference', () => {
       const options = { limit: 100 }
-      const permission1 = new Permission('read', options)
-      const permission2 = new Permission('write', options)
+      const perm1 = permission('read', options)
+      const perm2 = permission('write', options)
 
-      expect(permission1.options).toBe(permission2.options)
-      expect(permission1.options).toBe(options)
-      expect(permission2.options).toBe(options)
+      expect(perm1.options).toBe(perm2.options)
+      expect(perm1.options).toBe(options)
+      expect(perm2.options).toBe(options)
     })
   })
 
-  describe('common permission patterns', () => {
-    it('creates read permission', () => {
-      const permission = new Permission('read', {})
-      expect(permission.resource).toBe('read')
+  describe('common perm patterns', () => {
+    it('creates read perm', () => {
+      const perm = permission('read', {})
+      expect(perm.resource).toBe('read')
     })
 
-    it('creates write permission', () => {
-      const permission = new Permission('write', {})
-      expect(permission.resource).toBe('write')
+    it('creates write perm', () => {
+      const perm = permission('write', {})
+      expect(perm.resource).toBe('write')
     })
 
-    it('creates delete permission', () => {
-      const permission = new Permission('delete', {})
-      expect(permission.resource).toBe('delete')
+    it('creates delete perm', () => {
+      const perm = permission('delete', {})
+      expect(perm.resource).toBe('delete')
     })
 
-    it('creates admin permission', () => {
-      const permission = new Permission('admin', {})
-      expect(permission.resource).toBe('admin')
+    it('creates admin perm', () => {
+      const perm = permission('admin', {})
+      expect(perm.resource).toBe('admin')
     })
 
-    it('creates scoped resource permission', () => {
-      const permission = new Permission('posts:read', { limit: 50 })
-      expect(permission.resource).toBe('posts:read')
-      expect(permission.options).toEqual({ limit: 50 })
+    it('creates scoped resource perm', () => {
+      const perm = permission('posts:read', { limit: 50 })
+      expect(perm.resource).toBe('posts:read')
+      expect(perm.options).toEqual({ limit: 50 })
     })
 
-    it('creates namespaced permission', () => {
-      const permission = new Permission('com.example.posts.read', {
+    it('creates namespaced perm', () => {
+      const perm = permission('com.example.posts.read', {
         includeDeleted: false,
       })
-      expect(permission.resource).toBe('com.example.posts.read')
-      expect(permission.options).toEqual({ includeDeleted: false })
+      expect(perm.resource).toBe('com.example.posts.read')
+      expect(perm.options).toEqual({ includeDeleted: false })
     })
 
-    it('creates CRUD permissions', () => {
-      const create = new Permission('create', {})
-      const read = new Permission('read', {})
-      const update = new Permission('update', {})
-      const deleteP = new Permission('delete', {})
+    it('creates CRUD perms', () => {
+      const create = permission('create', {})
+      const read = permission('read', {})
+      const update = permission('update', {})
+      const deleteP = permission('delete', {})
 
       expect(create.resource).toBe('create')
       expect(read.resource).toBe('read')
@@ -364,14 +364,14 @@ describe('Permission', () => {
       expect(deleteP.resource).toBe('delete')
     })
 
-    it('creates permission with scope and filters', () => {
-      const permission = new Permission('posts:read', {
+    it('creates perm with scope and filters', () => {
+      const perm = permission('posts:read', {
         scope: 'public',
         limit: 100,
         includeDeleted: false,
       })
-      expect(permission.resource).toBe('posts:read')
-      expect(permission.options).toEqual({
+      expect(perm.resource).toBe('posts:read')
+      expect(perm.options).toEqual({
         scope: 'public',
         limit: 100,
         includeDeleted: false,
@@ -380,8 +380,8 @@ describe('Permission', () => {
   })
 
   describe('edge cases', () => {
-    it('handles permission with all parameter types in options', () => {
-      const permission = new Permission('complex', {
+    it('handles perm with all parameter types in options', () => {
+      const perm = permission('complex', {
         stringParam: 'value',
         intParam: 42,
         boolParam: true,
@@ -389,111 +389,111 @@ describe('Permission', () => {
         undefinedParam: undefined,
       })
 
-      expect(permission.options.stringParam).toBe('value')
-      expect(permission.options.intParam).toBe(42)
-      expect(permission.options.boolParam).toBe(true)
-      expect(permission.options.arrayParam).toEqual([1, 2, 3])
-      expect(permission.options.undefinedParam).toBeUndefined()
+      expect(perm.options.stringParam).toBe('value')
+      expect(perm.options.intParam).toBe(42)
+      expect(perm.options.boolParam).toBe(true)
+      expect(perm.options.arrayParam).toEqual([1, 2, 3])
+      expect(perm.options.undefinedParam).toBeUndefined()
     })
 
     it('handles resource with whitespace', () => {
-      const permission = new Permission('read posts', {})
-      expect(permission.resource).toBe('read posts')
+      const perm = permission('read posts', {})
+      expect(perm.resource).toBe('read posts')
     })
 
     it('handles resource with leading/trailing whitespace', () => {
-      const permission = new Permission('  read  ', {})
-      expect(permission.resource).toBe('  read  ')
+      const perm = permission('  read  ', {})
+      expect(perm.resource).toBe('  read  ')
     })
 
     it('handles options with numeric string keys', () => {
-      const permission = new Permission('read', { '123': 'value' })
-      expect(permission.options['123']).toBe('value')
+      const perm = permission('read', { '123': 'value' })
+      expect(perm.options['123']).toBe('value')
     })
 
     it('handles options with special character keys', () => {
-      const permission = new Permission('read', { 'key-name': 'value' })
-      expect(permission.options['key-name']).toBe('value')
+      const perm = permission('read', { 'key-name': 'value' })
+      expect(perm.options['key-name']).toBe('value')
     })
   })
 
   describe('type safety', () => {
     it('preserves resource type as literal', () => {
-      const permission = new Permission('read' as const, {})
+      const perm = permission('read' as const, {})
       // At compile time, TypeScript should infer the type as 'read'
-      expect(permission.resource).toBe('read')
+      expect(perm.resource).toBe('read')
     })
 
     it('preserves options type', () => {
       const options = { limit: 100 } as const
-      const permission = new Permission('read', options)
+      const perm = permission('read', options)
       // At compile time, TypeScript should infer the exact type
-      expect(permission.options.limit).toBe(100)
+      expect(perm.options.limit).toBe(100)
     })
 
     it('handles generic string resource type', () => {
       const resource: string = 'dynamic'
-      const permission = new Permission(resource, {})
-      expect(permission.resource).toBe('dynamic')
+      const perm = permission(resource, {})
+      expect(perm.resource).toBe('dynamic')
     })
 
     it('handles union resource types', () => {
       type ResourceType = 'read' | 'write' | 'delete'
       const resource: ResourceType = 'read'
-      const permission = new Permission(resource, {})
-      expect(permission.resource).toBe('read')
+      const perm = permission(resource, {})
+      expect(perm.resource).toBe('read')
     })
   })
 
   describe('constructor behavior', () => {
     it('requires both resource and options arguments', () => {
       // TypeScript enforces this at compile time
-      const permission = new Permission('read', {})
-      expect(permission.resource).toBeDefined()
-      expect(permission.options).toBeDefined()
+      const perm = permission('read', {})
+      expect(perm.resource).toBeDefined()
+      expect(perm.options).toBeDefined()
     })
 
     it('does not modify input options object', () => {
       const options = { limit: 100 }
       const originalOptions = { ...options }
-      new Permission('read', options)
+      permission('read', options)
       expect(options).toEqual(originalOptions)
     })
 
     it('accepts options as object literal', () => {
-      const permission = new Permission('read', { limit: 100 })
-      expect(permission.options).toEqual({ limit: 100 })
+      const perm = permission('read', { limit: 100 })
+      expect(perm.options).toEqual({ limit: 100 })
     })
 
     it('accepts options as variable', () => {
       const options = { limit: 100 }
-      const permission = new Permission('read', options)
-      expect(permission.options).toEqual({ limit: 100 })
+      const perm = permission('read', options)
+      expect(perm.options).toEqual({ limit: 100 })
     })
 
     it('accepts resource as string literal', () => {
-      const permission = new Permission('read', {})
-      expect(permission.resource).toBe('read')
+      const perm = permission('read', {})
+      expect(perm.resource).toBe('read')
     })
 
     it('accepts resource as variable', () => {
       const resource = 'read'
-      const permission = new Permission(resource, {})
-      expect(permission.resource).toBe('read')
+      const perm = permission(resource, {})
+      expect(perm.resource).toBe('read')
     })
   })
 
   describe('object enumeration', () => {
     it('enumerates all properties', () => {
-      const permission = new Permission('read', { limit: 100 })
-      const keys = Object.keys(permission)
+      const perm = permission('read', { limit: 100 })
+      const keys = Object.keys(perm)
       expect(keys).toContain('resource')
       expect(keys).toContain('options')
     })
 
     it('can be spread into object', () => {
-      const permission = new Permission('read', { limit: 100 })
-      const spread = { ...permission }
+      const perm = permission('read', { limit: 100 })
+      const spread = { ...perm }
       expect(spread.resource).toBe('read')
       expect(spread.options).toEqual({ limit: 100 })
     })
@@ -501,20 +501,20 @@ describe('Permission', () => {
 
   describe('JSON serialization', () => {
     it('can be JSON stringified', () => {
-      const permission = new Permission('read', { limit: 100 })
-      const json = JSON.stringify(permission)
+      const perm = permission('read', { limit: 100 })
+      const json = JSON.stringify(perm)
       const parsed = JSON.parse(json)
       expect(parsed.resource).toBe('read')
       expect(parsed.options).toEqual({ limit: 100 })
     })
 
     it('handles complex options in JSON', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         fields: ['id', 'name'],
         limit: 100,
         includeDeleted: false,
       })
-      const json = JSON.stringify(permission)
+      const json = JSON.stringify(perm)
       const parsed = JSON.parse(json)
       expect(parsed.options).toEqual({
         fields: ['id', 'name'],
@@ -524,12 +524,12 @@ describe('Permission', () => {
     })
 
     it('preserves undefined in JSON serialization', () => {
-      const permission = new Permission('read', {
+      const perm = permission('read', {
         defined: 'value',
         undefined: undefined,
       })
       // JSON.stringify removes undefined values by default
-      const json = JSON.stringify(permission)
+      const json = JSON.stringify(perm)
       const parsed = JSON.parse(json)
       expect('undefined' in parsed.options).toBe(false)
     })