@pyreon/permissions 0.11.4 → 0.11.6

package/src/tests/predicates.test.ts

@@ -1,64 +1,64 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { createPermissions } from "../index"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { createPermissions } from '../index'
 
-describe("createPermissions — predicate permissions", () => {
-  describe("basic predicate evaluation", () => {
-    it("evaluates predicate with context argument", () => {
+describe('createPermissions — predicate permissions', () => {
+  describe('basic predicate evaluation', () => {
+    it('evaluates predicate with context argument', () => {
       const can = createPermissions({
-        "posts.update": (post: any) => post?.authorId === "user-1",
+        'posts.update': (post: any) => post?.authorId === 'user-1',
       })
-      expect(can("posts.update", { authorId: "user-1" })).toBe(true)
-      expect(can("posts.update", { authorId: "user-2" })).toBe(false)
+      expect(can('posts.update', { authorId: 'user-1' })).toBe(true)
+      expect(can('posts.update', { authorId: 'user-2' })).toBe(false)
     })
 
-    it("predicate called without context receives undefined", () => {
+    it('predicate called without context receives undefined', () => {
       const can = createPermissions({
-        "posts.update": (post?: any) => post?.authorId === "user-1",
+        'posts.update': (post?: any) => post?.authorId === 'user-1',
       })
       // No context — post is undefined
-      expect(can("posts.update")).toBe(false)
+      expect(can('posts.update')).toBe(false)
     })
 
-    it("predicate that ignores context (always true)", () => {
+    it('predicate that ignores context (always true)', () => {
       const can = createPermissions({
-        "posts.create": () => true,
+        'posts.create': () => true,
       })
-      expect(can("posts.create")).toBe(true)
-      expect(can("posts.create", { anything: true })).toBe(true)
+      expect(can('posts.create')).toBe(true)
+      expect(can('posts.create', { anything: true })).toBe(true)
     })
 
-    it("predicate that ignores context (always false)", () => {
+    it('predicate that ignores context (always false)', () => {
       const can = createPermissions({
-        "posts.create": () => false,
+        'posts.create': () => false,
       })
-      expect(can("posts.create")).toBe(false)
+      expect(can('posts.create')).toBe(false)
     })
   })
 
-  describe("complex predicate logic", () => {
-    it("ownership check", () => {
-      const currentUserId = "user-42"
+  describe('complex predicate logic', () => {
+    it('ownership check', () => {
+      const currentUserId = 'user-42'
       const can = createPermissions({
-        "posts.update": (post: any) => post?.authorId === currentUserId,
-        "posts.delete": (post: any) => post?.authorId === currentUserId && post?.status === "draft",
+        'posts.update': (post: any) => post?.authorId === currentUserId,
+        'posts.delete': (post: any) => post?.authorId === currentUserId && post?.status === 'draft',
       })
 
-      const myDraft = { authorId: "user-42", status: "draft" }
-      const myPublished = { authorId: "user-42", status: "published" }
-      const otherPost = { authorId: "user-99", status: "draft" }
+      const myDraft = { authorId: 'user-42', status: 'draft' }
+      const myPublished = { authorId: 'user-42', status: 'published' }
+      const otherPost = { authorId: 'user-99', status: 'draft' }
 
-      expect(can("posts.update", myDraft)).toBe(true)
-      expect(can("posts.update", myPublished)).toBe(true)
-      expect(can("posts.update", otherPost)).toBe(false)
-      expect(can("posts.delete", myDraft)).toBe(true)
-      expect(can("posts.delete", myPublished)).toBe(false)
-      expect(can("posts.delete", otherPost)).toBe(false)
+      expect(can('posts.update', myDraft)).toBe(true)
+      expect(can('posts.update', myPublished)).toBe(true)
+      expect(can('posts.update', otherPost)).toBe(false)
+      expect(can('posts.delete', myDraft)).toBe(true)
+      expect(can('posts.delete', myPublished)).toBe(false)
+      expect(can('posts.delete', otherPost)).toBe(false)
     })
 
-    it("predicate with multiple conditions", () => {
+    it('predicate with multiple conditions', () => {
       const can = createPermissions({
-        "orders.refund": (order: any) => {
+        'orders.refund': (order: any) => {
           if (!order) return false
           const isRecent = Date.now() - order.createdAt < 86400000
           const isSmall = order.amount < 100
@@ -70,80 +70,80 @@ describe("createPermissions — predicate permissions", () => {
       const recentLarge = { createdAt: Date.now() - 1000, amount: 200 }
       const oldSmall = { createdAt: Date.now() - 100_000_000, amount: 50 }
 
-      expect(can("orders.refund", recentSmall)).toBe(true)
-      expect(can("orders.refund", recentLarge)).toBe(false)
-      expect(can("orders.refund", oldSmall)).toBe(false)
+      expect(can('orders.refund', recentSmall)).toBe(true)
+      expect(can('orders.refund', recentLarge)).toBe(false)
+      expect(can('orders.refund', oldSmall)).toBe(false)
     })
 
-    it("predicate referencing reactive signal", () => {
-      const role = signal("admin")
+    it('predicate referencing reactive signal', () => {
+      const role = signal('admin')
       const can = createPermissions({
-        "users.manage": () => role.peek() === "admin",
+        'users.manage': () => role.peek() === 'admin',
       })
 
-      expect(can("users.manage")).toBe(true)
+      expect(can('users.manage')).toBe(true)
 
-      role.set("viewer")
+      role.set('viewer')
       // Need to trigger version update for reactive tracking,
       // but predicate re-evaluation on read still reflects signal state
-      can.patch({ "users.manage": () => role.peek() === "admin" })
-      expect(can("users.manage")).toBe(false)
+      can.patch({ 'users.manage': () => role.peek() === 'admin' })
+      expect(can('users.manage')).toBe(false)
     })
   })
 
-  describe("predicate error handling", () => {
-    it("returns false when predicate throws", () => {
+  describe('predicate error handling', () => {
+    it('returns false when predicate throws', () => {
       const can = createPermissions({
-        "posts.update": () => {
-          throw new Error("boom")
+        'posts.update': () => {
+          throw new Error('boom')
         },
       })
-      expect(can("posts.update")).toBe(false)
+      expect(can('posts.update')).toBe(false)
     })
 
-    it("returns false when predicate throws with context", () => {
+    it('returns false when predicate throws with context', () => {
       const can = createPermissions({
-        "posts.update": (_post: any) => {
-          throw new TypeError("property access failed")
+        'posts.update': (_post: any) => {
+          throw new TypeError('property access failed')
         },
       })
-      expect(can("posts.update", { id: 1 })).toBe(false)
+      expect(can('posts.update', { id: 1 })).toBe(false)
     })
 
-    it("can.not returns true when predicate throws", () => {
+    it('can.not returns true when predicate throws', () => {
       const can = createPermissions({
-        "posts.update": () => {
-          throw new Error("error")
+        'posts.update': () => {
+          throw new Error('error')
         },
       })
-      expect(can.not("posts.update")).toBe(true)
+      expect(can.not('posts.update')).toBe(true)
     })
 
-    it("other permissions unaffected when one predicate throws", () => {
+    it('other permissions unaffected when one predicate throws', () => {
       const can = createPermissions({
-        "posts.read": true,
-        "posts.update": () => {
-          throw new Error("boom")
+        'posts.read': true,
+        'posts.update': () => {
+          throw new Error('boom')
         },
-        "posts.create": () => true,
+        'posts.create': () => true,
       })
-      expect(can("posts.read")).toBe(true)
-      expect(can("posts.update")).toBe(false)
-      expect(can("posts.create")).toBe(true)
+      expect(can('posts.read')).toBe(true)
+      expect(can('posts.update')).toBe(false)
+      expect(can('posts.create')).toBe(true)
     })
   })
 
-  describe("predicates in granted()", () => {
-    it("predicates count as capabilities in granted()", () => {
+  describe('predicates in granted()', () => {
+    it('predicates count as capabilities in granted()', () => {
       const can = createPermissions({
-        "posts.read": true,
-        "posts.update": (post: any) => post?.authorId === "me",
-        "posts.delete": false,
+        'posts.read': true,
+        'posts.update': (post: any) => post?.authorId === 'me',
+        'posts.delete': false,
       })
       const granted = can.granted()
-      expect(granted).toContain("posts.read")
-      expect(granted).toContain("posts.update") // predicate = capability exists
-      expect(granted).not.toContain("posts.delete")
+      expect(granted).toContain('posts.read')
+      expect(granted).toContain('posts.update') // predicate = capability exists
+      expect(granted).not.toContain('posts.delete')
     })
   })
 })

package/src/tests/wildcards.test.ts

@@ -1,141 +1,141 @@
-import { effect } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { createPermissions } from "../index"
-
-describe("createPermissions — wildcard matching", () => {
-  describe("prefix wildcard (posts.*)", () => {
-    it("matches any sub-key under the prefix", () => {
-      const can = createPermissions({ "posts.*": true })
-      expect(can("posts.read")).toBe(true)
-      expect(can("posts.create")).toBe(true)
-      expect(can("posts.update")).toBe(true)
-      expect(can("posts.delete")).toBe(true)
+import { effect } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { createPermissions } from '../index'
+
+describe('createPermissions — wildcard matching', () => {
+  describe('prefix wildcard (posts.*)', () => {
+    it('matches any sub-key under the prefix', () => {
+      const can = createPermissions({ 'posts.*': true })
+      expect(can('posts.read')).toBe(true)
+      expect(can('posts.create')).toBe(true)
+      expect(can('posts.update')).toBe(true)
+      expect(can('posts.delete')).toBe(true)
     })
 
-    it("does not match keys without a dot", () => {
-      const can = createPermissions({ "posts.*": true })
-      expect(can("posts")).toBe(false) // no dot, no wildcard match
+    it('does not match keys without a dot', () => {
+      const can = createPermissions({ 'posts.*': true })
+      expect(can('posts')).toBe(false) // no dot, no wildcard match
     })
 
-    it("does not match different prefix", () => {
-      const can = createPermissions({ "posts.*": true })
-      expect(can("users.read")).toBe(false)
-      expect(can("comments.read")).toBe(false)
+    it('does not match different prefix', () => {
+      const can = createPermissions({ 'posts.*': true })
+      expect(can('users.read')).toBe(false)
+      expect(can('comments.read')).toBe(false)
     })
 
-    it("does not match partial prefix overlap", () => {
-      const can = createPermissions({ "post.*": true })
-      expect(can("posts.read")).toBe(false) // 'posts' !== 'post'
+    it('does not match partial prefix overlap', () => {
+      const can = createPermissions({ 'post.*': true })
+      expect(can('posts.read')).toBe(false) // 'posts' !== 'post'
     })
 
-    it("exact match takes precedence over wildcard", () => {
+    it('exact match takes precedence over wildcard', () => {
       const can = createPermissions({
-        "posts.*": true,
-        "posts.delete": false,
+        'posts.*': true,
+        'posts.delete': false,
       })
-      expect(can("posts.read")).toBe(true)
-      expect(can("posts.create")).toBe(true)
-      expect(can("posts.delete")).toBe(false) // exact overrides wildcard
+      expect(can('posts.read')).toBe(true)
+      expect(can('posts.create')).toBe(true)
+      expect(can('posts.delete')).toBe(false) // exact overrides wildcard
     })
 
-    it("wildcard with predicate function", () => {
+    it('wildcard with predicate function', () => {
       const can = createPermissions({
-        "posts.*": (post: any) => post?.status !== "archived",
+        'posts.*': (post: any) => post?.status !== 'archived',
       })
-      expect(can("posts.read", { status: "published" })).toBe(true)
-      expect(can("posts.update", { status: "archived" })).toBe(false)
-      expect(can("posts.delete", { status: "draft" })).toBe(true)
+      expect(can('posts.read', { status: 'published' })).toBe(true)
+      expect(can('posts.update', { status: 'archived' })).toBe(false)
+      expect(can('posts.delete', { status: 'draft' })).toBe(true)
     })
 
-    it("multiple prefix wildcards for different namespaces", () => {
+    it('multiple prefix wildcards for different namespaces', () => {
       const can = createPermissions({
-        "posts.*": true,
-        "users.*": false,
+        'posts.*': true,
+        'users.*': false,
       })
-      expect(can("posts.read")).toBe(true)
-      expect(can("users.read")).toBe(false)
+      expect(can('posts.read')).toBe(true)
+      expect(can('users.read')).toBe(false)
     })
   })
 
-  describe("global wildcard (*)", () => {
-    it("matches any key", () => {
-      const can = createPermissions({ "*": true })
-      expect(can("posts.read")).toBe(true)
-      expect(can("users.manage")).toBe(true)
-      expect(can("anything.at.all")).toBe(true)
-      expect(can("simple-key")).toBe(true)
+  describe('global wildcard (*)', () => {
+    it('matches any key', () => {
+      const can = createPermissions({ '*': true })
+      expect(can('posts.read')).toBe(true)
+      expect(can('users.manage')).toBe(true)
+      expect(can('anything.at.all')).toBe(true)
+      expect(can('simple-key')).toBe(true)
     })
 
-    it("exact match takes precedence over global wildcard", () => {
+    it('exact match takes precedence over global wildcard', () => {
       const can = createPermissions({
-        "*": true,
-        "billing.export": false,
+        '*': true,
+        'billing.export': false,
       })
-      expect(can("posts.read")).toBe(true)
-      expect(can("billing.export")).toBe(false)
+      expect(can('posts.read')).toBe(true)
+      expect(can('billing.export')).toBe(false)
     })
 
-    it("prefix wildcard takes precedence over global wildcard", () => {
+    it('prefix wildcard takes precedence over global wildcard', () => {
       const can = createPermissions({
-        "*": false,
-        "posts.*": true,
+        '*': false,
+        'posts.*': true,
       })
-      expect(can("posts.read")).toBe(true)
-      expect(can("posts.create")).toBe(true)
-      expect(can("users.manage")).toBe(false) // falls to global *
+      expect(can('posts.read')).toBe(true)
+      expect(can('posts.create')).toBe(true)
+      expect(can('users.manage')).toBe(false) // falls to global *
     })
 
-    it("resolution order: exact > prefix wildcard > global wildcard", () => {
+    it('resolution order: exact > prefix wildcard > global wildcard', () => {
       const can = createPermissions({
-        "*": false,
-        "posts.*": true,
-        "posts.delete": false,
+        '*': false,
+        'posts.*': true,
+        'posts.delete': false,
       })
-      expect(can("posts.read")).toBe(true) // matched by posts.*
-      expect(can("posts.delete")).toBe(false) // exact match
-      expect(can("users.manage")).toBe(false) // matched by *
+      expect(can('posts.read')).toBe(true) // matched by posts.*
+      expect(can('posts.delete')).toBe(false) // exact match
+      expect(can('users.manage')).toBe(false) // matched by *
     })
 
-    it("global wildcard with predicate", () => {
+    it('global wildcard with predicate', () => {
       const can = createPermissions({
-        "*": (ctx: any) => ctx?.role === "admin",
+        '*': (ctx: any) => ctx?.role === 'admin',
       })
-      expect(can("posts.read", { role: "admin" })).toBe(true)
-      expect(can("posts.read", { role: "viewer" })).toBe(false)
+      expect(can('posts.read', { role: 'admin' })).toBe(true)
+      expect(can('posts.read', { role: 'viewer' })).toBe(false)
     })
   })
 
-  describe("wildcard reactivity", () => {
-    it("wildcards are reactive after set()", () => {
-      const can = createPermissions({ "posts.*": false })
+  describe('wildcard reactivity', () => {
+    it('wildcards are reactive after set()', () => {
+      const can = createPermissions({ 'posts.*': false })
       const results: boolean[] = []
 
       effect(() => {
-        results.push(can("posts.read"))
+        results.push(can('posts.read'))
       })
 
-      can.set({ "posts.*": true })
+      can.set({ 'posts.*': true })
       expect(results).toEqual([false, true])
     })
 
-    it("wildcards are reactive after patch()", () => {
-      const can = createPermissions({ "posts.*": true })
+    it('wildcards are reactive after patch()', () => {
+      const can = createPermissions({ 'posts.*': true })
       const results: boolean[] = []
 
       effect(() => {
-        results.push(can("posts.read"))
+        results.push(can('posts.read'))
       })
 
-      can.patch({ "posts.read": false }) // exact override
+      can.patch({ 'posts.read': false }) // exact override
       expect(results).toEqual([true, false])
     })
 
-    it("removing wildcard via set() removes its effect", () => {
-      const can = createPermissions({ "posts.*": true })
-      expect(can("posts.read")).toBe(true)
+    it('removing wildcard via set() removes its effect', () => {
+      const can = createPermissions({ 'posts.*': true })
+      expect(can('posts.read')).toBe(true)
 
       can.set({}) // remove all permissions
-      expect(can("posts.read")).toBe(false)
+      expect(can('posts.read')).toBe(false)
     })
   })
 })

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Computed } from "@pyreon/reactivity"
+import type { Computed } from '@pyreon/reactivity'
 
 // ─── Permission values ───────────────────────────────────────────────────────