@zap-studio/permit 0.3.1 → 0.3.3

package/dist/index.d.mts

@@ -1,256 +1,261 @@
 import { Actions, ConditionFn, Context, PermitConfig, Policy, PolicyFn, Resources, Role, RoleHierarchy } from "./types.mjs";
-
 //#region src/index.d.ts
 /**
-* Returns a policy function that always allows the action.
-*
-* @example
-* ```ts
-* const policy = createPolicy({
-*   resources,
-*   actions,
-*   rules: {
-*     post: {
-*       read: allow(), // Always allow reading posts
-*     },
-*   },
-* });
-* ```
-*/
-declare function allow<TContext extends Context, TAction extends string = string, TResource = unknown>(): PolicyFn<TContext, TAction, TResource>;
+ * Returns a policy function that always allows the action.
+ *
+ * @example
+ * ```ts
+ * const policy = createPolicy({
+ *   resources,
+ *   actions,
+ *   rules: {
+ *     post: {
+ *       read: allow(), // Always allow reading posts
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare const allow: <TContext extends Context, TAction extends string = string, TResource = unknown>() => PolicyFn<TContext, TAction, TResource>;
 /**
-* Returns a policy function that always denies the action.
-*
-* @example
-* ```ts
-* const policy = createPolicy({
-*   resources,
-*   actions,
-*   rules: {
-*     post: {
-*       delete: deny(), // Never allow deleting posts
-*     },
-*   },
-* });
-* ```
-*/
-declare function deny<TContext extends Context, TAction extends string = string, TResource = unknown>(): PolicyFn<TContext, TAction, TResource>;
+ * Returns a policy function that always denies the action.
+ *
+ * @example
+ * ```ts
+ * const policy = createPolicy({
+ *   resources,
+ *   actions,
+ *   rules: {
+ *     post: {
+ *       delete: deny(), // Never allow deleting posts
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare const deny: <TContext extends Context, TAction extends string = string, TResource = unknown>() => PolicyFn<TContext, TAction, TResource>;
 /**
-* Returns a policy function that allows or denies based on a condition.
-*
-* @example
-* ```ts
-* const policy = createPolicy({
-*   resources,
-*   actions,
-*   rules: {
-*     post: {
-*       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
-*     },
-*   },
-* });
-* ```
-*/
-declare function when<TContext extends Context, TAction extends string = string, TResource = unknown>(condition: ConditionFn<TContext, TAction, TResource>): PolicyFn<TContext, TAction, TResource>;
+ * Returns a policy function that allows or denies based on a condition.
+ *
+ * @example
+ * ```ts
+ * const policy = createPolicy({
+ *   resources,
+ *   actions,
+ *   rules: {
+ *     post: {
+ *       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare const when: <TContext extends Context, TAction extends string = string, TResource = unknown>(condition: ConditionFn<TContext, TAction, TResource>) => PolicyFn<TContext, TAction, TResource>;
 /**
-* Returns a condition function that returns `true` if all conditions are met.
-*
-* @example
-* ```ts
-* const isOwnerAndPublished = and(
-*   (ctx, action, resource) => ctx.user.id === resource.authorId,
-*   (ctx, action, resource) => resource.status === "published"
-* );
-*
-* rules: {
-*   post: {
-*     delete: when(isOwnerAndPublished),
-*   },
-* }
-* ```
-*/
-declare function and<TContext extends Context, TAction extends string = string, TResource = unknown>(...conditions: ConditionFn<TContext, TAction, TResource>[]): ConditionFn<TContext, TAction, TResource>;
+ * Returns a condition function that returns `true` if all conditions are met.
+ *
+ * @example
+ * ```ts
+ * const isOwnerAndPublished = and(
+ *   (ctx, action, resource) => ctx.user.id === resource.authorId,
+ *   (ctx, action, resource) => resource.status === "published"
+ * );
+ *
+ * rules: {
+ *   post: {
+ *     delete: when(isOwnerAndPublished),
+ *   },
+ * }
+ * ```
+ */
+declare const and: <TContext extends Context, TAction extends string = string, TResource = unknown>(...conditions: ConditionFn<TContext, TAction, TResource>[]) => ConditionFn<TContext, TAction, TResource>;
 /**
-* Returns a condition function that returns `true` if any condition is met.
-*
-* @example
-* ```ts
-* const isOwnerOrAdmin = or(
-*   (ctx, action, resource) => ctx.user.id === resource.authorId,
-*   (ctx, action, resource) => ctx.user.role === "admin"
-* );
-*
-* rules: {
-*   post: {
-*     write: when(isOwnerOrAdmin),
-*   },
-* }
-* ```
-*/
-declare function or<TContext extends Context, TAction extends string = string, TResource = unknown>(...conditions: ConditionFn<TContext, TAction, TResource>[]): ConditionFn<TContext, TAction, TResource>;
+ * Returns a condition function that returns `true` if any condition is met.
+ *
+ * @example
+ * ```ts
+ * const isOwnerOrAdmin = or(
+ *   (ctx, action, resource) => ctx.user.id === resource.authorId,
+ *   (ctx, action, resource) => ctx.user.role === "admin"
+ * );
+ *
+ * rules: {
+ *   post: {
+ *     write: when(isOwnerOrAdmin),
+ *   },
+ * }
+ * ```
+ */
+declare const or: <TContext extends Context, TAction extends string = string, TResource = unknown>(...conditions: ConditionFn<TContext, TAction, TResource>[]) => ConditionFn<TContext, TAction, TResource>;
 /**
-* Returns a condition function that negates another condition.
-*
-* @example
-* ```ts
-* const isNotOwner = not((ctx, action, resource) => ctx.user.id === resource.authorId);
-*
-* rules: {
-*   post: {
-*     like: when(isNotOwner), // Can only like posts you don't own
-*   },
-* }
-* ```
-*/
-declare function not<TContext extends Context, TAction extends string = string, TResource = unknown>(condition: ConditionFn<TContext, TAction, TResource>): ConditionFn<TContext, TAction, TResource>;
+ * Returns a condition function that negates another condition.
+ *
+ * @example
+ * ```ts
+ * const isNotOwner = not((ctx, action, resource) => ctx.user.id === resource.authorId);
+ *
+ * rules: {
+ *   post: {
+ *     like: when(isNotOwner), // Can only like posts you don't own
+ *   },
+ * }
+ * ```
+ */
+declare const not: <TContext extends Context, TAction extends string = string, TResource = unknown>(condition: ConditionFn<TContext, TAction, TResource>) => ConditionFn<TContext, TAction, TResource>;
 /**
-* Returns a condition function that checks if a context property equals a value.
-*
-* @example
-* ```ts
-* rules: {
-*   post: {
-*     write: when(has("role", "admin")), // Only admins can write
-*   },
-* }
-* ```
-*/
-declare function has<TContext extends Context, K extends keyof TContext>(key: K, value: TContext[K]): ConditionFn<TContext>;
+ * Returns a condition function that checks if a context property equals a value.
+ *
+ * @example
+ * ```ts
+ * rules: {
+ *   post: {
+ *     write: when(has("role", "admin")), // Only admins can write
+ *   },
+ * }
+ * ```
+ */
+declare const has: <TContext extends Context, K extends keyof TContext>(key: K, value: TContext[K]) => ConditionFn<TContext>;
 /**
-* Collects all roles including inherited ones from a role hierarchy.
-*
-* @example
-* ```ts
-* type Role = "guest" | "user" | "admin";
-*
-* const hierarchy: RoleHierarchy<Role> = {
-*   guest: [],
-*   user: ["guest"],
-*   admin: ["user"],
-* };
-*
-* collectInheritedRoles(["admin"], hierarchy);
-* // Returns: Set { "admin", "user", "guest" }
-* ```
-*/
-declare function collectInheritedRoles<TRole extends Role = Role>(roles: TRole[], hierarchy: RoleHierarchy<TRole>): Set<TRole>;
+ * Collects all roles including inherited ones from a role hierarchy.
+ *
+ * @example
+ * ```ts
+ * type Role = "guest" | "user" | "admin";
+ *
+ * const hierarchy: RoleHierarchy<Role> = {
+ *   guest: [],
+ *   user: ["guest"],
+ *   admin: ["user"],
+ * };
+ *
+ * collectInheritedRoles(["admin"], hierarchy);
+ * // Returns: Set { "admin", "user", "guest" }
+ * ```
+ */
+declare const collectInheritedRoles: <TRole extends Role = Role>(roles: TRole[], hierarchy: RoleHierarchy<TRole>) => Set<TRole>;
 /**
-* Returns a condition function that checks if the user has a specific role.
-* Supports role hierarchy for inherited permissions.
-*
-* @example
-* ```ts
-* // Without hierarchy
-* rules: {
-*   post: {
-*     delete: when(hasRole("admin")),
-*   },
-* }
-*
-* // With hierarchy
-* const hierarchy = {
-*   guest: [],
-*   user: ["guest"],
-*   admin: ["user"],
-* };
-*
-* rules: {
-*   post: {
-*     read: when(hasRole("guest", hierarchy)), // Admins and users can also read
-*   },
-* }
-* ```
-*/
-declare function hasRole<TContext extends {
-  role: Role | Role[];
-}, TAction extends string = string, TResource = unknown>(role: Role): ConditionFn<TContext, TAction, TResource>;
-declare function hasRole<TContext extends {
-  role: TRole | TRole[];
-}, TAction extends string = string, TResource = unknown, TRole extends Role = Role>(role: TRole, hierarchy: RoleHierarchy<TRole>): ConditionFn<TContext, TAction, TResource>;
+ * Call signatures for {@link hasRole}, preserving the with/without hierarchy overloads.
+ */
+interface HasRoleFn {
+  <TContext extends {
+    role: Role | Role[];
+  }, TAction extends string = string, TResource = unknown>(role: Role): ConditionFn<TContext, TAction, TResource>;
+  <TContext extends {
+    role: TRole | TRole[];
+  }, TAction extends string = string, TResource = unknown, TRole extends Role = Role>(role: TRole, hierarchy: RoleHierarchy<TRole>): ConditionFn<TContext, TAction, TResource>;
+}
 /**
-* Creates a type-safe policy from resource schemas, actions, and rules.
-*
-* @example
-* ```ts
-* import { z } from "zod";
-* import { createPolicy, allow, deny, when } from "@zap-studio/permit";
-* import type { Resources, Actions } from "@zap-studio/permit/types";
-*
-* // Define resource schemas
-* const resources = {
-*   post: z.object({
-*     id: z.string(),
-*     authorId: z.string(),
-*     visibility: z.enum(["public", "private"]),
-*   }),
-*   comment: z.object({
-*     id: z.string(),
-*     postId: z.string(),
-*     authorId: z.string(),
-*   }),
-* } satisfies Resources;
-*
-* // Define actions per resource
-* const actions = {
-*   post: ["read", "write", "delete"],
-*   comment: ["read", "write"],
-* } as const satisfies Actions<typeof resources>;
-*
-* // Define context type
-* type AppContext = { user: { id: string; role: string } };
-*
-* // Create the policy
-* const policy = createPolicy<AppContext>({
-*   resources,
-*   actions,
-*   rules: {
-*     post: {
-*       read: when((ctx, action, resource) => resource.visibility === "public"),
-*       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
-*       delete: deny(),
-*     },
-*     comment: {
-*       read: allow(),
-*       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
-*     },
-*   },
-* });
-*
-* // Check permissions
-* const post = { id: "1", authorId: "user-1", visibility: "public" as const };
-* await policy.can(ctx, "post:read", post); // true
-* await policy.can(ctx, "post:write", post); // depends on ctx.user.id
-* ```
-*/
-declare function createPolicy<TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(config: PermitConfig<TContext, TResources, TActions>): Policy<TContext, TResources, TActions>;
+ * Returns a condition function that checks if the user has a specific role.
+ * Supports role hierarchy for inherited permissions.
+ *
+ * @example
+ * ```ts
+ * // Without hierarchy
+ * rules: {
+ *   post: {
+ *     delete: when(hasRole("admin")),
+ *   },
+ * }
+ *
+ * // With hierarchy
+ * const hierarchy = {
+ *   guest: [],
+ *   user: ["guest"],
+ *   admin: ["user"],
+ * };
+ *
+ * rules: {
+ *   post: {
+ *     read: when(hasRole("guest", hierarchy)), // Admins and users can also read
+ *   },
+ * }
+ * ```
+ */
+declare const hasRole: HasRoleFn;
 /**
-* Merges multiple policies into one using "deny-overrides" strategy.
-* If any policy denies, the merged policy denies. All must allow for the result to allow.
-*
-* @example
-* ```ts
-* const basePolicy = createPolicy({ ... });
-* const adminPolicy = createPolicy({ ... });
-*
-* const merged = mergePolicies(basePolicy, adminPolicy);
-* // Both policies must allow for the action to be permitted
-* ```
-*/
-declare function mergePolicies<TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(...policies: Policy<TContext, TResources, TActions>[]): Policy<TContext, TResources, TActions>;
+ * Creates a type-safe policy from resource schemas, actions, and rules.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { createPolicy, allow, deny, when } from "@zap-studio/permit";
+ * import type { Resources, Actions } from "@zap-studio/permit/types";
+ *
+ * // Define resource schemas
+ * const resources = {
+ *   post: z.object({
+ *     id: z.string(),
+ *     authorId: z.string(),
+ *     visibility: z.enum(["public", "private"]),
+ *   }),
+ *   comment: z.object({
+ *     id: z.string(),
+ *     postId: z.string(),
+ *     authorId: z.string(),
+ *   }),
+ * } satisfies Resources;
+ *
+ * // Define actions per resource
+ * const actions = {
+ *   post: ["read", "write", "delete"],
+ *   comment: ["read", "write"],
+ * } as const satisfies Actions<typeof resources>;
+ *
+ * // Define context type
+ * type AppContext = { user: { id: string; role: string } };
+ *
+ * // Create the policy
+ * const policy = createPolicy<AppContext>({
+ *   resources,
+ *   actions,
+ *   rules: {
+ *     post: {
+ *       read: when((ctx, action, resource) => resource.visibility === "public"),
+ *       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
+ *       delete: deny(),
+ *     },
+ *     comment: {
+ *       read: allow(),
+ *       write: when((ctx, action, resource) => ctx.user.id === resource.authorId),
+ *     },
+ *   },
+ * });
+ *
+ * // Check permissions
+ * const post = { id: "1", authorId: "user-1", visibility: "public" as const };
+ * await policy.can(ctx, "post:read", post); // true
+ * await policy.can(ctx, "post:write", post); // depends on ctx.user.id
+ * ```
+ */
+declare const createPolicy: <TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(config: PermitConfig<TContext, TResources, TActions>) => Policy<TContext, TResources, TActions>;
 /**
-* Merges multiple policies into one using "allow-overrides" strategy.
-* If any policy allows, the merged policy allows. All must deny for the result to deny.
-*
-* @example
-* ```ts
-* const guestPolicy = createPolicy({ ... });
-* const memberPolicy = createPolicy({ ... });
-*
-* const merged = mergePoliciesAny(guestPolicy, memberPolicy);
-* // If either policy allows, the action is permitted
-* ```
-*/
-declare function mergePoliciesAny<TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(...policies: Policy<TContext, TResources, TActions>[]): Policy<TContext, TResources, TActions>;
+ * Merges multiple policies into one using "deny-overrides" strategy.
+ * If any policy denies, the merged policy denies. All must allow for the result to allow.
+ *
+ * @example
+ * ```ts
+ * const basePolicy = createPolicy({ ... });
+ * const adminPolicy = createPolicy({ ... });
+ *
+ * const merged = mergePolicies(basePolicy, adminPolicy);
+ * // Both policies must allow for the action to be permitted
+ * ```
+ */
+declare const mergePolicies: <TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(...policies: Policy<TContext, TResources, TActions>[]) => Policy<TContext, TResources, TActions>;
+/**
+ * Merges multiple policies into one using "allow-overrides" strategy.
+ * If any policy allows, the merged policy allows. All must deny for the result to deny.
+ *
+ * @example
+ * ```ts
+ * const guestPolicy = createPolicy({ ... });
+ * const memberPolicy = createPolicy({ ... });
+ *
+ * const merged = mergePoliciesAny(guestPolicy, memberPolicy);
+ * // If either policy allows, the action is permitted
+ * ```
+ */
+declare const mergePoliciesAny: <TContext extends Context, TResources extends Resources = Resources, TActions extends Actions<TResources> = Actions<TResources>>(...policies: Policy<TContext, TResources, TActions>[]) => Policy<TContext, TResources, TActions>;
 //#endregion
 export { allow, and, collectInheritedRoles, createPolicy, deny, has, hasRole, mergePolicies, mergePoliciesAny, not, or, when };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAwCa,QAET,iBAAiB,SACjB,iCACA,0BACG,SAAS,UAAU,SAAS;;;;;;;;;;;;;;;;;cAoBtB,OAET,iBAAiB,SACjB,iCACA,0BACG,SAAS,UAAU,SAAS;;;;;;;;;;;;;;;;;cAoBtB,OAET,iBAAiB,SACjB,iCACA,qBAEA,WAAW,YAAY,UAAU,SAAS,eACzC,SAAS,UAAU,SAAS;;;;;;;;;;;;;;;;;;cAqBpB,MAET,iBAAiB,SACjB,iCACA,wBAEG,YAAY,YAAY,UAAU,SAAS,iBAC7C,YAAY,UAAU,SAAS;;;;;;;;;;;;;;;;;;cAqBvB,KAET,iBAAiB,SACjB,iCACA,wBAEG,YAAY,YAAY,UAAU,SAAS,iBAC7C,YAAY,UAAU,SAAS;;;;;;;;;;;;;;;cAkBvB,MAET,iBAAiB,SACjB,iCACA,qBAEA,WAAW,YAAY,UAAU,SAAS,eACzC,YAAY,UAAU,SAAS;;;;;;;;;;;;;cAgBvB,MACV,iBAAiB,SAAS,gBAAgB,UACzC,KAAK,GACL,OAAO,SAAS,OACf,YAAY;;;;;;;;;;;;;;;;;;cAqBJ,wBAAyB,cAAc,OAAO,MACzD,OAAO,SACP,WAAW,cAAc,WACxB,IAAI;;;;UAwBG;GAEN;IAAmB,MAAM,OAAO;KAChC,iCACA,qBAEA,MAAM,OACL,YAAY,UAAU,SAAS;GAEhC;IAAmB,MAAM,QAAQ;KACjC,iCACA,qBACA,cAAc,OAAO,MAErB,MAAM,OACN,WAAW,cAAc,SACxB,YAAY,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BvB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsGT,eACX,iBAAiB,SACjB,mBAAmB,YAAY,WAC/B,iBAAiB,QAAQ,cAAc,QAAQ,aAE/C,QAAQ,aAAa,UAAU,YAAY,cAC1C,OAAO,UAAU,YAAY;;;;;;;;;;;;;;cA2InB,gBACX,iBAAiB,SACjB,mBAAmB,YAAY,WAC/B,iBAAiB,QAAQ,cAAc,QAAQ,gBAE5C,UAAU,OAAO,UAAU,YAAY,gBACzC,OAAO,UAAU,YAAY;;;;;;;;;;;;;;cAgBnB,mBACX,iBAAiB,SACjB,mBAAmB,YAAY,WAC/B,iBAAiB,QAAQ,cAAc,QAAQ,gBAE5C,UAAU,OAAO,UAAU,YAAY,gBACzC,OAAO,UAAU,YAAY"}