@auth-gate/rbac 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -39,6 +39,8 @@ interface RoleConfig {
     description?: string;
     inherits?: readonly string[];
     grants: Record<string, Record<string, GrantValue>>;
+    /** Mark this role as the default for new org members. Only one role may be default. */
+    isDefault?: boolean;
     /** Previous config key if this role was renamed. */
     renamedFrom?: string;
 }
@@ -80,6 +82,63 @@ type InferScopes<T, Resource extends string> = T extends {
 type InferConditionKeys<T> = T extends {
     conditions: infer C;
 } ? keyof C & string : never;
+/** Extract role keys that have `isDefault: true`. */
+type DefaultRoleKeys<Roles> = {
+    [K in keyof Roles]: Roles[K] extends {
+        isDefault: true;
+    } ? K : never;
+}[keyof Roles];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+/**
+ * Compile-time constraint: if more than one role has `isDefault: true`,
+ * intersect those roles' `isDefault` with an error string so TypeScript
+ * produces a descriptive message.
+ *
+ * Error reads: Type 'true' is not assignable to type '"ERROR: ..."'.
+ */
+type ValidateSingleDefault<T> = T extends {
+    roles: infer Roles;
+} ? IsUnion<DefaultRoleKeys<Roles>> extends true ? {
+    roles: {
+        [K in DefaultRoleKeys<Roles> & keyof Roles]: {
+            isDefault: "ERROR: Only one role may have isDefault: true";
+        };
+    };
+} : {} : {};
+/** Extract valid action string literals from a resource config. */
+type ValidActions<R> = R extends {
+    actions: readonly (infer U)[];
+} ? U & string : never;
+/**
+ * Compile-time constraint: validates grant resource/action keys against
+ * declared resources at the type level.
+ *
+ * - **Invalid resource key** → descriptive error naming the resource.
+ * - **Invalid action key** → descriptive error listing valid actions.
+ * - **Valid grants** → passes through original types transparently.
+ *
+ * Used as `T & ValidateConfig<T>` in the `defineRbac()` parameter type.
+ *
+ * @note Extra properties on role objects (e.g. `isFakeProp`) are caught
+ * by the runtime `validateRbacConfig()` which runs by default.
+ */
+type ValidateConfig<T> = T extends {
+    resources: infer R extends Record<string, ResourceConfig>;
+    roles: infer Roles;
+} ? {
+    roles: {
+        [RK in keyof Roles]: Roles[RK] extends {
+            grants: infer G;
+        } ? {
+            grants: {
+                [ResK in keyof G]: ResK extends keyof R ? keyof G[ResK] extends ValidActions<R[ResK & keyof R]> ? {
+                    [ActK in keyof G[ResK]]: G[ResK][ActK];
+                } : `ERROR: invalid action(s) in "${ResK & string}" grants. Valid actions: ${ValidActions<R[ResK & keyof R]>}` : `ERROR: resource "${ResK & string}" is not declared in resources`;
+            };
+        } : Roles[RK];
+    };
+} : {};
 /** A structured resource with a `key` constant and an `actions` map of `"resource:action"` strings. */
 type StructuredResource<T, K extends string> = {
     readonly key: K;
@@ -91,7 +150,7 @@ type StructuredResource<T, K extends string> = {
 type StructuredResources<T> = {
     readonly [K in InferResourceKeys<T>]: StructuredResource<T, K>;
 };
-/** A structured role with `key`, `name`, and `grants` from the config. */
+/** A structured role with `key`, `name`, `grants`, and optional `isDefault` from the config. */
 type StructuredRole<T, K extends string> = {
     readonly key: K;
     readonly name: T extends {
@@ -104,6 +163,11 @@ type StructuredRole<T, K extends string> = {
     } ? K extends keyof R ? R[K] extends {
         grants: infer G;
     } ? Readonly<G> : {} : {} : {};
+    readonly isDefault: T extends {
+        roles: infer R;
+    } ? K extends keyof R ? R[K] extends {
+        isDefault: infer D;
+    } ? D : false : false : false;
 };
 /** Map of all roles as structured objects: `roles.admin.key` -> `"admin"`. */
 type StructuredRoles<T> = {
@@ -121,7 +185,7 @@ type StructuredPermissions<T> = {
  * Carries phantom types that downstream factories use to constrain
  * permission/role string parameters -- enabling full IDE autocomplete.
  */
-interface TypedRbac<T extends RbacConfig> {
+interface TypedRbac<T> {
     /** The raw RBAC config. Access resources, roles, etc. via `rbac._config`. */
     readonly _config: T;
     /**
@@ -172,6 +236,7 @@ interface ServerRole {
     grants: Record<string, Record<string, GrantValue>> | null;
     inherits: string[];
     resolvedPermissions: string[];
+    isDefault: boolean;
     isActive: boolean;
     managedBy: string;
     version: number;
@@ -245,7 +310,7 @@ interface DiffResult {
     conditionOps: ConditionOp[];
     hasDestructive: boolean;
 }
-/** Simple hash of a condition function's source code for change detection. */
+/** Hash of a condition function's source code for change detection. */
 declare function hashConditionSource(fn: Function): string;
 declare function computeRbacDiff(config: RbacConfig, server: ServerState, memberCounts: Record<string, number>): DiffResult;
 
@@ -272,12 +337,61 @@ declare class RbacSyncClient {
 
 declare function formatRbacDiff(diff: DiffResult, dryRun: boolean): string;
 
+interface RoleManagementConfig {
+    baseUrl: string;
+    apiKey: string;
+}
+interface Role {
+    id: string;
+    projectId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    isDefault: boolean;
+    permissions: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateRoleInput {
+    key: string;
+    name: string;
+    description?: string;
+    isDefault?: boolean;
+    permissions?: string[];
+}
+interface UpdateRoleInput {
+    name?: string;
+    description?: string | null;
+    permissions?: string[];
+    isDefault?: boolean;
+}
+interface RoleManagementClient {
+    listRoles(): Promise<Role[]>;
+    createRole(input: CreateRoleInput): Promise<Role>;
+    updateRole(roleId: string, input: UpdateRoleInput): Promise<Role>;
+    deleteRole(roleId: string): Promise<void>;
+    setDefaultRole(roleId: string): Promise<Role>;
+}
+declare function createRoleManagement(config: RoleManagementConfig): RoleManagementClient;
+
+/** Base config shape used as the generic constraint for `defineRbac()`. */
+type DefineRbacConfig = {
+    resources: Record<string, ResourceConfig>;
+    conditions?: Record<string, ConditionFn>;
+    roles: Record<string, {
+        name: string;
+        description?: string;
+        inherits?: readonly string[];
+        isDefault?: boolean;
+        renamedFrom?: string;
+        grants: Record<string, Record<string, GrantValue>>;
+    }>;
+};
 /**
  * Define your RBAC config. Use this in your `authgate.rbac.ts` config file.
  *
- * Returns a `TypedRbac<T>` object with structured resource, role, and permission
- * objects -- enabling full IDE autocomplete via dot-notation across hooks, helpers,
- * and server-side checks.
+ * Grants are validated at compile-time: if a role references an undeclared
+ * resource or action, TypeScript flags it as a type error.
  *
  * @example
  * ```ts
@@ -310,6 +424,8 @@ declare function formatRbacDiff(diff: DiffResult, dryRun: boolean): string;
  * rbac.permissions.documents.write       // "documents:write"
  * ```
  */
-declare function defineRbac<const T extends RbacConfig>(config: T): TypedRbac<T>;
+declare function defineRbac<const T extends DefineRbacConfig>(config: T & ValidateConfig<T> & ValidateSingleDefault<T>, opts?: {
+    validate?: boolean;
+}): TypedRbac<T>;
 
-export { type ApplyResult, type ConditionContext, type ConditionFn, type ConditionOp, type DiffResult, type GrantValue, type InferActions, type InferConditionKeys, type InferPermissions, type InferResourceKeys, type InferRoleKeys, type InferScopes, type Permission, type RbacConfig, RbacSyncClient, type RbacSyncClientConfig, type ResourceConfig, type ResourceKey, type ResourceOp, type RoleConfig, type RoleKey, type RoleOp, type ServerCondition, type ServerResource, type ServerRole, type ServerState, type TypedRbac, computeRbacDiff, defineRbac, formatRbacDiff, hashConditionSource, loadRbacConfig, validateRbacConfig };
+export { type ApplyResult, type ConditionContext, type ConditionFn, type ConditionOp, type CreateRoleInput, type DiffResult, type GrantValue, type InferActions, type InferConditionKeys, type InferPermissions, type InferResourceKeys, type InferRoleKeys, type InferScopes, type Permission, type RbacConfig, RbacSyncClient, type RbacSyncClientConfig, type ResourceConfig, type ResourceKey, type ResourceOp, type Role, type RoleConfig, type RoleKey, type RoleManagementClient, type RoleManagementConfig, type RoleOp, type ServerCondition, type ServerResource, type ServerRole, type ServerState, type TypedRbac, type UpdateRoleInput, computeRbacDiff, createRoleManagement, defineRbac, formatRbacDiff, hashConditionSource, loadRbacConfig, validateRbacConfig };

package/dist/index.mjs

@@ -5,10 +5,100 @@ import {
   hashConditionSource,
   loadRbacConfig,
   validateRbacConfig
-} from "./chunk-HE57TIQI.mjs";
+} from "./chunk-ZFKXT2MP.mjs";
+
+// src/role-management.ts
+function createRoleManagement(config) {
+  const baseUrl = config.baseUrl.replace(/\/$/, "");
+  const apiKey = config.apiKey;
+  async function request(method, path, body) {
+    var _a, _b;
+    const url = `${baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      let message;
+      try {
+        const json = JSON.parse(text);
+        message = (_b = (_a = json.error) != null ? _a : json.message) != null ? _b : "Unknown error";
+      } catch (e) {
+        message = text.length > 500 ? text.slice(0, 500) + "..." : text;
+      }
+      if (apiKey) {
+        message = message.replaceAll(apiKey, "[REDACTED]");
+      }
+      throw new Error(`API error (${res.status}): ${message}`);
+    }
+    return res.json();
+  }
+  return {
+    async listRoles() {
+      const result = await request("GET", "/api/v1/roles");
+      return result.data.map(toRole);
+    },
+    async createRole(input) {
+      var _a, _b;
+      const result = await request("POST", "/api/v1/roles", {
+        key: input.key,
+        name: input.name,
+        description: input.description,
+        is_default: (_a = input.isDefault) != null ? _a : false,
+        permissions: (_b = input.permissions) != null ? _b : []
+      });
+      return toRole(result.role);
+    },
+    async updateRole(roleId, input) {
+      const body = {};
+      if (input.name !== void 0) body.name = input.name;
+      if (input.description !== void 0) body.description = input.description;
+      if (input.permissions !== void 0) body.permissions = input.permissions;
+      if (input.isDefault !== void 0) body.is_default = input.isDefault;
+      const result = await request(
+        "PATCH",
+        `/api/v1/roles/${encodeURIComponent(roleId)}`,
+        body
+      );
+      return toRole(result.role);
+    },
+    async deleteRole(roleId) {
+      await request(
+        "DELETE",
+        `/api/v1/roles/${encodeURIComponent(roleId)}`
+      );
+    },
+    async setDefaultRole(roleId) {
+      return this.updateRole(roleId, { isDefault: true });
+    }
+  };
+}
+function toRole(raw) {
+  return {
+    id: raw.id,
+    projectId: raw.project_id,
+    key: raw.key,
+    name: raw.name,
+    description: raw.description,
+    isDefault: raw.is_default,
+    permissions: raw.permissions,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
 
 // src/index.ts
-function defineRbac(config) {
+function defineRbac(config, opts) {
+  var _a;
+  if ((opts == null ? void 0 : opts.validate) !== false) {
+    validateRbacConfig(config);
+  }
   const resources = {};
   for (const [key, resource] of Object.entries(config.resources)) {
     const actions = {};
@@ -19,7 +109,7 @@ function defineRbac(config) {
   }
   const roles = {};
   for (const [key, role] of Object.entries(config.roles)) {
-    roles[key] = { key, name: role.name, grants: role.grants };
+    roles[key] = { key, name: role.name, grants: role.grants, isDefault: (_a = role.isDefault) != null ? _a : false };
   }
   const permissions = {};
   for (const [key, resource] of Object.entries(config.resources)) {
@@ -41,6 +131,7 @@ function defineRbac(config) {
 export {
   RbacSyncClient,
   computeRbacDiff,
+  createRoleManagement,
   defineRbac,
   formatRbacDiff,
   hashConditionSource,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth-gate/rbac",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "exports": {
     ".": {