@stackframe/stack-shared 2.7.30 → 2.8.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @stackframe/stack-shared
 
+## 2.8.2
+
+### Patch Changes
+
+- Various changes
+
+## 2.8.1
+
+## 2.8.0
+
+### Minor Changes
+
+- Various changes
+
 ## 2.7.30
 
 ### Patch Changes

package/dist/interface/adminInterface.d.ts

@@ -2,6 +2,7 @@ import { InternalSession } from "../sessions";
 import { ApiKeysCrud } from "./crud/api-keys";
 import { EmailTemplateCrud, EmailTemplateType } from "./crud/email-templates";
 import { InternalEmailsCrud } from "./crud/emails";
+import { ProjectPermissionDefinitionsCrud } from "./crud/project-permissions";
 import { ProjectsCrud } from "./crud/projects";
 import { SvixTokenCrud } from "./crud/svix-token";
 import { TeamPermissionDefinitionsCrud } from "./crud/team-permissions";
@@ -41,10 +42,14 @@ export declare class StackAdminInterface extends StackServerInterface {
     listEmailTemplates(): Promise<EmailTemplateCrud['Admin']['Read'][]>;
     updateEmailTemplate(type: EmailTemplateType, data: EmailTemplateCrud['Admin']['Update']): Promise<EmailTemplateCrud['Admin']['Read']>;
     resetEmailTemplate(type: EmailTemplateType): Promise<void>;
-    listPermissionDefinitions(): Promise<TeamPermissionDefinitionsCrud['Admin']['Read'][]>;
-    createPermissionDefinition(data: TeamPermissionDefinitionsCrud['Admin']['Create']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
-    updatePermissionDefinition(permissionId: string, data: TeamPermissionDefinitionsCrud['Admin']['Update']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
-    deletePermissionDefinition(permissionId: string): Promise<void>;
+    listTeamPermissionDefinitions(): Promise<TeamPermissionDefinitionsCrud['Admin']['Read'][]>;
+    createTeamPermissionDefinition(data: TeamPermissionDefinitionsCrud['Admin']['Create']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
+    updateTeamPermissionDefinition(permissionId: string, data: TeamPermissionDefinitionsCrud['Admin']['Update']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
+    deleteTeamPermissionDefinition(permissionId: string): Promise<void>;
+    listProjectPermissionDefinitions(): Promise<ProjectPermissionDefinitionsCrud['Admin']['Read'][]>;
+    createProjectPermissionDefinition(data: ProjectPermissionDefinitionsCrud['Admin']['Create']): Promise<ProjectPermissionDefinitionsCrud['Admin']['Read']>;
+    updateProjectPermissionDefinition(permissionId: string, data: ProjectPermissionDefinitionsCrud['Admin']['Update']): Promise<ProjectPermissionDefinitionsCrud['Admin']['Read']>;
+    deleteProjectPermissionDefinition(permissionId: string): Promise<void>;
     getSvixToken(): Promise<SvixTokenCrud["Admin"]["Read"]>;
     deleteProject(): Promise<void>;
     getMetrics(): Promise<any>;

package/dist/interface/adminInterface.js

@@ -77,12 +77,13 @@ export class StackAdminInterface extends StackServerInterface {
     async resetEmailTemplate(type) {
         await this.sendAdminRequest(`/email-templates/${type}`, { method: "DELETE" }, null);
     }
-    async listPermissionDefinitions() {
+    // Team permission definitions methods
+    async listTeamPermissionDefinitions() {
         const response = await this.sendAdminRequest(`/team-permission-definitions`, {}, null);
         const result = await response.json();
         return result.items;
     }
-    async createPermissionDefinition(data) {
+    async createTeamPermissionDefinition(data) {
         const response = await this.sendAdminRequest("/team-permission-definitions", {
             method: "POST",
             headers: {
@@ -92,7 +93,7 @@ export class StackAdminInterface extends StackServerInterface {
         }, null);
         return await response.json();
     }
-    async updatePermissionDefinition(permissionId, data) {
+    async updateTeamPermissionDefinition(permissionId, data) {
         const response = await this.sendAdminRequest(`/team-permission-definitions/${permissionId}`, {
             method: "PATCH",
             headers: {
@@ -102,9 +103,37 @@ export class StackAdminInterface extends StackServerInterface {
         }, null);
         return await response.json();
     }
-    async deletePermissionDefinition(permissionId) {
+    async deleteTeamPermissionDefinition(permissionId) {
         await this.sendAdminRequest(`/team-permission-definitions/${permissionId}`, { method: "DELETE" }, null);
     }
+    async listProjectPermissionDefinitions() {
+        const response = await this.sendAdminRequest(`/project-permission-definitions`, {}, null);
+        const result = await response.json();
+        return result.items;
+    }
+    async createProjectPermissionDefinition(data) {
+        const response = await this.sendAdminRequest("/project-permission-definitions", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
+        return await response.json();
+    }
+    async updateProjectPermissionDefinition(permissionId, data) {
+        const response = await this.sendAdminRequest(`/project-permission-definitions/${permissionId}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
+        return await response.json();
+    }
+    async deleteProjectPermissionDefinition(permissionId) {
+        await this.sendAdminRequest(`/project-permission-definitions/${permissionId}`, { method: "DELETE" }, null);
+    }
     async getSvixToken() {
         const response = await this.sendAdminRequest("/webhooks/svix-token", {
             method: "POST",

package/dist/interface/clientInterface.d.ts

@@ -6,6 +6,7 @@ import { Result } from "../utils/results";
 import { ContactChannelsCrud } from './crud/contact-channels';
 import { CurrentUserCrud } from './crud/current-user';
 import { ConnectedAccountAccessTokenCrud } from './crud/oauth';
+import { ProjectPermissionsCrud } from './crud/project-permissions';
 import { InternalProjectsCrud, ProjectsCrud } from './crud/projects';
 import { SessionsCrud } from './crud/sessions';
 import { TeamInvitationCrud } from './crud/team-invitation';
@@ -187,6 +188,9 @@ export declare class StackClientInterface {
         teamId: string;
         recursive: boolean;
     }, session: InternalSession): Promise<TeamPermissionsCrud['Client']['Read'][]>;
+    listCurrentUserProjectPermissions(options: {
+        recursive: boolean;
+    }, session: InternalSession): Promise<ProjectPermissionsCrud['Client']['Read'][]>;
     listCurrentUserTeams(session: InternalSession): Promise<TeamsCrud["Client"]["Read"][]>;
     getClientProject(): Promise<Result<ProjectsCrud['Client']['Read'], KnownErrors["ProjectNotFound"]>>;
     updateClientUser(update: CurrentUserCrud["Client"]["Update"], session: InternalSession): Promise<void>;

package/dist/interface/clientInterface.js

@@ -85,7 +85,7 @@ export class StackClientInterface {
         // try to diagnose the error for the user
         if (retriedResult.status === "error") {
             if (globalVar.navigator && !globalVar.navigator.onLine) {
-                throw new Error("Failed to send Stack network request. It seems like you are offline. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
+                throw new Error("Failed to send Stack network request. It seems like you are offline, please check your internet connection and try again. This is not an error with Stack Auth. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
             }
             throw await this._createNetworkError(retriedResult.error, session, requestType);
         }
@@ -790,6 +790,11 @@ export class StackClientInterface {
         const result = await response.json();
         return result.items;
     }
+    async listCurrentUserProjectPermissions(options, session) {
+        const response = await this.sendClientRequest(`/project-permissions?user_id=me&recursive=${options.recursive}`, {}, session);
+        const result = await response.json();
+        return result.items;
+    }
     async listCurrentUserTeams(session) {
         const response = await this.sendClientRequest("/teams?user_id=me", {}, session);
         const result = await response.json();

package/dist/interface/crud/project-permissions.d.ts

@@ -0,0 +1,155 @@
+import { CrudTypeOf } from "../../crud";
+export declare const projectPermissionsCrudClientReadSchema: import("yup").ObjectSchema<{
+    id: string;
+    user_id: string;
+}, import("yup").AnyObject, {
+    id: undefined;
+    user_id: undefined;
+}, "">;
+export declare const projectPermissionsCrudServerCreateSchema: import("yup").ObjectSchema<{}, import("yup").AnyObject, {}, "">;
+export declare const projectPermissionsCrudServerDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const projectPermissionsCrud: import("../../crud").CrudSchemaFromOptions<{
+    clientReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+    }, "">;
+    serverCreateSchema: import("yup").ObjectSchema<{}, import("yup").AnyObject, {}, "">;
+    serverDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        clientList: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        serverList: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        serverCreate: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        serverDelete: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+    };
+}>;
+export type ProjectPermissionsCrud = CrudTypeOf<typeof projectPermissionsCrud>;
+export declare const projectPermissionCreatedWebhookEvent: {
+    type: string;
+    schema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+};
+export declare const projectPermissionDeletedWebhookEvent: {
+    type: string;
+    schema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+};
+export declare const projectPermissionDefinitionsCrudAdminReadSchema: import("yup").ObjectSchema<{
+    id: string;
+    description: string | undefined;
+    contained_permission_ids: string[];
+}, import("yup").AnyObject, {
+    id: undefined;
+    description: undefined;
+    contained_permission_ids: undefined;
+}, "">;
+export declare const projectPermissionDefinitionsCrudAdminCreateSchema: import("yup").ObjectSchema<{
+    id: string;
+    description: string | undefined;
+    contained_permission_ids: string[] | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    description: undefined;
+    contained_permission_ids: undefined;
+}, "">;
+export declare const projectPermissionDefinitionsCrudAdminUpdateSchema: import("yup").ObjectSchema<{
+    id: string | undefined;
+    description: string | undefined;
+    contained_permission_ids: string[] | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    description: undefined;
+    contained_permission_ids: undefined;
+}, "">;
+export declare const projectPermissionDefinitionsCrudAdminDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const projectPermissionDefinitionsCrud: import("../../crud").CrudSchemaFromOptions<{
+    adminReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        description: string | undefined;
+        contained_permission_ids: string[];
+    }, import("yup").AnyObject, {
+        id: undefined;
+        description: undefined;
+        contained_permission_ids: undefined;
+    }, "">;
+    adminCreateSchema: import("yup").ObjectSchema<{
+        id: string;
+        description: string | undefined;
+        contained_permission_ids: string[] | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        description: undefined;
+        contained_permission_ids: undefined;
+    }, "">;
+    adminUpdateSchema: import("yup").ObjectSchema<{
+        id: string | undefined;
+        description: string | undefined;
+        contained_permission_ids: string[] | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        description: undefined;
+        contained_permission_ids: undefined;
+    }, "">;
+    adminDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        adminList: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        adminCreate: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        adminUpdate: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        adminDelete: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+    };
+}>;
+export type ProjectPermissionDefinitionsCrud = CrudTypeOf<typeof projectPermissionDefinitionsCrud>;

package/dist/interface/crud/project-permissions.js

@@ -0,0 +1,100 @@
+import { createCrud } from "../../crud";
+import * as schemaFields from "../../schema-fields";
+import { yupMixed, yupObject } from "../../schema-fields";
+// =============== Project permissions =================
+export const projectPermissionsCrudClientReadSchema = yupObject({
+    id: schemaFields.permissionDefinitionIdSchema.defined(),
+    user_id: schemaFields.userIdSchema.defined(),
+}).defined();
+export const projectPermissionsCrudServerCreateSchema = yupObject({}).defined();
+export const projectPermissionsCrudServerDeleteSchema = yupMixed();
+export const projectPermissionsCrud = createCrud({
+    clientReadSchema: projectPermissionsCrudClientReadSchema,
+    serverCreateSchema: projectPermissionsCrudServerCreateSchema,
+    serverDeleteSchema: projectPermissionsCrudServerDeleteSchema,
+    docs: {
+        clientList: {
+            summary: "List project permissions",
+            description: "List global permissions of the current user. `user_id=me` must be set for client requests. `(user_id, permission_id)` together uniquely identify a permission.",
+            tags: ["Permissions"],
+        },
+        serverList: {
+            summary: "List project permissions",
+            description: "Query and filter the permission with `user_id` and `permission_id`. `(user_id, permission_id)` together uniquely identify a permission.",
+            tags: ["Permissions"],
+        },
+        serverCreate: {
+            summary: "Grant a global permission to a user",
+            description: "Grant a global permission to a user (the permission must be created first on the Stack dashboard)",
+            tags: ["Permissions"],
+        },
+        serverDelete: {
+            summary: "Revoke a global permission from a user",
+            description: "Revoke a global permission from a user",
+            tags: ["Permissions"],
+        },
+    },
+});
+export const projectPermissionCreatedWebhookEvent = {
+    type: "project_permission.created",
+    schema: projectPermissionsCrud.server.readSchema,
+    metadata: {
+        summary: "Project Permission Created",
+        description: "This event is triggered when a project permission is created.",
+        tags: ["Users"],
+    },
+};
+export const projectPermissionDeletedWebhookEvent = {
+    type: "project_permission.deleted",
+    schema: projectPermissionsCrud.server.readSchema,
+    metadata: {
+        summary: "Project Permission Deleted",
+        description: "This event is triggered when a project permission is deleted.",
+        tags: ["Users"],
+    },
+};
+// =============== Project permission definitions =================
+export const projectPermissionDefinitionsCrudAdminReadSchema = yupObject({
+    id: schemaFields.permissionDefinitionIdSchema.defined(),
+    description: schemaFields.teamPermissionDescriptionSchema.optional(),
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.defined(),
+}).defined();
+export const projectPermissionDefinitionsCrudAdminCreateSchema = yupObject({
+    id: schemaFields.customPermissionDefinitionIdSchema.defined(),
+    description: schemaFields.teamPermissionDescriptionSchema.optional(),
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
+}).defined();
+export const projectPermissionDefinitionsCrudAdminUpdateSchema = yupObject({
+    id: schemaFields.customPermissionDefinitionIdSchema.optional(),
+    description: schemaFields.teamPermissionDescriptionSchema.optional(),
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
+}).defined();
+export const projectPermissionDefinitionsCrudAdminDeleteSchema = yupMixed();
+export const projectPermissionDefinitionsCrud = createCrud({
+    adminReadSchema: projectPermissionDefinitionsCrudAdminReadSchema,
+    adminCreateSchema: projectPermissionDefinitionsCrudAdminCreateSchema,
+    adminUpdateSchema: projectPermissionDefinitionsCrudAdminUpdateSchema,
+    adminDeleteSchema: projectPermissionDefinitionsCrudAdminDeleteSchema,
+    docs: {
+        adminList: {
+            summary: "List project permission definitions",
+            description: "Query and filter project permission definitions (the equivalent of listing permissions on the Stack dashboard)",
+            tags: ["Permissions"],
+        },
+        adminCreate: {
+            summary: "Create a new project permission definition",
+            description: "Create a new project permission definition (the equivalent of creating a new permission on the Stack dashboard)",
+            tags: ["Permissions"],
+        },
+        adminUpdate: {
+            summary: "Update a project permission definition",
+            description: "Update a project permission definition (the equivalent of updating a permission on the Stack dashboard)",
+            tags: ["Permissions"],
+        },
+        adminDelete: {
+            summary: "Delete a project permission definition",
+            description: "Delete a project permission definition (the equivalent of deleting a permission on the Stack dashboard)",
+            tags: ["Permissions"],
+        },
+    },
+});

package/dist/interface/crud/projects.d.ts

@@ -80,6 +80,9 @@ export declare const projectsCrudAdminReadSchema: import("yup").ObjectSchema<{
         team_member_default_permissions: {
             id: string;
         }[];
+        user_default_permissions: {
+            id: string;
+        }[];
         oauth_account_merge_strategy: "link_method" | "raise_error" | "allow_duplicates";
     };
 }, import("yup").AnyObject, {
@@ -113,6 +116,7 @@ export declare const projectsCrudAdminReadSchema: import("yup").ObjectSchema<{
         create_team_on_sign_up: undefined;
         team_creator_default_permissions: undefined;
         team_member_default_permissions: undefined;
+        user_default_permissions: undefined;
         oauth_account_merge_strategy: undefined;
     };
 }, "">;
@@ -184,6 +188,9 @@ export declare const projectsCrudAdminUpdateSchema: import("yup").ObjectSchema<{
         team_member_default_permissions?: {
             id: string;
         }[] | undefined;
+        user_default_permissions?: {
+            id: string;
+        }[] | undefined;
         oauth_account_merge_strategy?: "link_method" | "raise_error" | "allow_duplicates" | undefined;
     } | undefined;
 }, import("yup").AnyObject, {
@@ -233,6 +240,9 @@ export declare const projectsCrudAdminCreateSchema: import("yup").ObjectSchema<{
         team_member_default_permissions?: {
             id: string;
         }[] | undefined;
+        user_default_permissions?: {
+            id: string;
+        }[] | undefined;
         oauth_account_merge_strategy?: "link_method" | "raise_error" | "allow_duplicates" | undefined;
     } | undefined;
 } & {
@@ -320,6 +330,9 @@ export declare const projectsCrud: import("../../crud").CrudSchemaFromOptions<{
             team_member_default_permissions: {
                 id: string;
             }[];
+            user_default_permissions: {
+                id: string;
+            }[];
             oauth_account_merge_strategy: "link_method" | "raise_error" | "allow_duplicates";
         };
     }, import("yup").AnyObject, {
@@ -353,6 +366,7 @@ export declare const projectsCrud: import("../../crud").CrudSchemaFromOptions<{
             create_team_on_sign_up: undefined;
             team_creator_default_permissions: undefined;
             team_member_default_permissions: undefined;
+            user_default_permissions: undefined;
             oauth_account_merge_strategy: undefined;
         };
     }, "">;
@@ -397,6 +411,9 @@ export declare const projectsCrud: import("../../crud").CrudSchemaFromOptions<{
             team_member_default_permissions?: {
                 id: string;
             }[] | undefined;
+            user_default_permissions?: {
+                id: string;
+            }[] | undefined;
             oauth_account_merge_strategy?: "link_method" | "raise_error" | "allow_duplicates" | undefined;
         } | undefined;
     }, import("yup").AnyObject, {
@@ -479,6 +496,9 @@ export declare const internalProjectsCrud: import("../../crud").CrudSchemaFromOp
             team_member_default_permissions: {
                 id: string;
             }[];
+            user_default_permissions: {
+                id: string;
+            }[];
             oauth_account_merge_strategy: "link_method" | "raise_error" | "allow_duplicates";
         };
     }, import("yup").AnyObject, {
@@ -512,6 +532,7 @@ export declare const internalProjectsCrud: import("../../crud").CrudSchemaFromOp
             create_team_on_sign_up: undefined;
             team_creator_default_permissions: undefined;
             team_member_default_permissions: undefined;
+            user_default_permissions: undefined;
             oauth_account_merge_strategy: undefined;
         };
     }, "">;
@@ -556,6 +577,9 @@ export declare const internalProjectsCrud: import("../../crud").CrudSchemaFromOp
             team_member_default_permissions?: {
                 id: string;
             }[] | undefined;
+            user_default_permissions?: {
+                id: string;
+            }[] | undefined;
             oauth_account_merge_strategy?: "link_method" | "raise_error" | "allow_duplicates" | undefined;
         } | undefined;
     } & {

package/dist/interface/crud/projects.js

@@ -75,6 +75,7 @@ export const projectsCrudAdminReadSchema = yupObject({
         create_team_on_sign_up: schemaFields.projectCreateTeamOnSignUpSchema.defined(),
         team_creator_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
         team_member_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
+        user_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
         oauth_account_merge_strategy: schemaFields.oauthAccountMergeStrategySchema.defined(),
     }).defined(),
 }).defined();
@@ -109,6 +110,7 @@ export const projectsCrudAdminUpdateSchema = yupObject({
         create_team_on_sign_up: schemaFields.projectCreateTeamOnSignUpSchema.optional(),
         team_creator_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
         team_member_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
+        user_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
         oauth_account_merge_strategy: schemaFields.oauthAccountMergeStrategySchema.optional(),
     }).optional().default(undefined),
 }).defined();

package/dist/interface/crud/team-permissions.js

@@ -3,7 +3,7 @@ import * as schemaFields from "../../schema-fields";
 import { yupMixed, yupObject } from "../../schema-fields";
 // =============== Team permissions =================
 export const teamPermissionsCrudClientReadSchema = yupObject({
-    id: schemaFields.teamPermissionDefinitionIdSchema.defined(),
+    id: schemaFields.permissionDefinitionIdSchema.defined(),
     user_id: schemaFields.userIdSchema.defined(),
     team_id: schemaFields.teamIdSchema.defined(),
 }).defined();
@@ -56,19 +56,19 @@ export const teamPermissionDeletedWebhookEvent = {
 };
 // =============== Team permission definitions =================
 export const teamPermissionDefinitionsCrudAdminReadSchema = yupObject({
-    id: schemaFields.teamPermissionDefinitionIdSchema.defined(),
+    id: schemaFields.permissionDefinitionIdSchema.defined(),
     description: schemaFields.teamPermissionDescriptionSchema.optional(),
-    contained_permission_ids: schemaFields.containedPermissionIdsSchema.defined()
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.defined(),
 }).defined();
 export const teamPermissionDefinitionsCrudAdminCreateSchema = yupObject({
-    id: schemaFields.customTeamPermissionDefinitionIdSchema.defined(),
+    id: schemaFields.customPermissionDefinitionIdSchema.defined(),
     description: schemaFields.teamPermissionDescriptionSchema.optional(),
-    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional()
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
 }).defined();
 export const teamPermissionDefinitionsCrudAdminUpdateSchema = yupObject({
-    id: schemaFields.customTeamPermissionDefinitionIdSchema.optional(),
+    id: schemaFields.customPermissionDefinitionIdSchema.optional(),
     description: schemaFields.teamPermissionDescriptionSchema.optional(),
-    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional()
+    contained_permission_ids: schemaFields.containedPermissionIdsSchema.optional(),
 }).defined();
 export const teamPermissionDefinitionsCrudAdminDeleteSchema = yupMixed();
 export const teamPermissionDefinitionsCrud = createCrud({

package/dist/interface/serverInterface.d.ts

@@ -9,6 +9,7 @@ import { SessionsCrud } from "./crud/sessions";
 import { TeamInvitationCrud } from "./crud/team-invitation";
 import { TeamMemberProfilesCrud } from "./crud/team-member-profiles";
 import { TeamMembershipsCrud } from "./crud/team-memberships";
+import { ProjectPermissionsCrud } from "./crud/project-permissions";
 import { TeamPermissionsCrud } from "./crud/team-permissions";
 import { TeamsCrud } from "./crud/teams";
 import { UsersCrud } from "./crud/users";
@@ -51,6 +52,10 @@ export declare class StackServerInterface extends StackClientInterface {
         teamId?: string;
         recursive: boolean;
     }, session: InternalSession | null): Promise<TeamPermissionsCrud['Server']['Read'][]>;
+    listServerProjectPermissions(options: {
+        userId?: string;
+        recursive: boolean;
+    }, session: InternalSession | null): Promise<ProjectPermissionsCrud['Server']['Read'][]>;
     listServerUsers(options: {
         cursor?: string;
         limit?: number;

package/dist/interface/serverInterface.js

@@ -91,6 +91,14 @@ export class StackServerInterface extends StackClientInterface {
         const result = await response.json();
         return result.items;
     }
+    async listServerProjectPermissions(options, session) {
+        const response = await this.sendServerRequest(`/project-permissions?${new URLSearchParams(filterUndefined({
+            user_id: options.userId,
+            recursive: options.recursive.toString(),
+        }))}`, {}, session);
+        const result = await response.json();
+        return result.items;
+    }
     async listServerUsers(options) {
         const searchParams = new URLSearchParams(filterUndefined({
             cursor: options.cursor,

package/dist/interface/webhooks.d.ts

@@ -254,4 +254,36 @@ export declare const webhookEvents: readonly [{
         description: string;
         tags: string[];
     };
+}, {
+    type: string;
+    schema: yup.ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, yup.AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+}, {
+    type: string;
+    schema: yup.ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, yup.AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
 }];

package/dist/interface/webhooks.js

@@ -1,4 +1,5 @@
 import { teamMembershipCreatedWebhookEvent, teamMembershipDeletedWebhookEvent } from "./crud/team-memberships";
+import { teamPermissionCreatedWebhookEvent, teamPermissionDeletedWebhookEvent } from "./crud/team-permissions";
 import { teamCreatedWebhookEvent, teamDeletedWebhookEvent, teamUpdatedWebhookEvent } from "./crud/teams";
 import { userCreatedWebhookEvent, userDeletedWebhookEvent, userUpdatedWebhookEvent } from "./crud/users";
 export const webhookEvents = [
@@ -10,4 +11,6 @@ export const webhookEvents = [
     teamDeletedWebhookEvent,
     teamMembershipCreatedWebhookEvent,
     teamMembershipDeletedWebhookEvent,
+    teamPermissionCreatedWebhookEvent,
+    teamPermissionDeletedWebhookEvent,
 ];

package/dist/known-errors.d.ts

@@ -66,6 +66,9 @@ export declare const KnownErrors: {
     ProjectAuthenticationError: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "PROJECT_AUTHENTICATION_ERROR";
     };
+    PermissionIdAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"PERMISSION_ID_ALREADY_EXISTS">, [permissionId: string]> & {
+        errorCode: "PERMISSION_ID_ALREADY_EXISTS";
+    };
     InvalidProjectAuthentication: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
@@ -373,6 +376,9 @@ export declare const KnownErrors: {
     TeamMembershipAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"TEAM_MEMBERSHIP_ALREADY_EXISTS">, []> & {
         errorCode: "TEAM_MEMBERSHIP_ALREADY_EXISTS";
     };
+    ProjectPermissionRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_PERMISSION_REQUIRED">, [any, any]> & {
+        errorCode: "PROJECT_PERMISSION_REQUIRED";
+    };
     TeamPermissionRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"TEAM_PERMISSION_REQUIRED">, [any, any, any]> & {
         errorCode: "TEAM_PERMISSION_REQUIRED";
     };

package/dist/known-errors.js

@@ -510,6 +510,14 @@ const TeamMembershipAlreadyExists = createKnownErrorConstructor(KnownError, "TEA
     409,
     "Team membership already exists.",
 ], () => []);
+const ProjectPermissionRequired = createKnownErrorConstructor(KnownError, "PROJECT_PERMISSION_REQUIRED", (userId, permissionId) => [
+    401,
+    `User ${userId} does not have permission ${permissionId}.`,
+    {
+        user_id: userId,
+        permission_id: permissionId,
+    },
+], (json) => [json.user_id, json.permission_id]);
 const TeamPermissionRequired = createKnownErrorConstructor(KnownError, "TEAM_PERMISSION_REQUIRED", (teamId, userId, permissionId) => [
     401,
     `User ${userId} does not have permission ${permissionId} in team ${teamId}.`,
@@ -562,6 +570,13 @@ const InvalidPollingCodeError = createKnownErrorConstructor(KnownError, "INVALID
     "The polling code is invalid or does not exist.",
     details,
 ], (json) => [json]);
+const PermissionIdAlreadyExists = createKnownErrorConstructor(KnownError, "PERMISSION_ID_ALREADY_EXISTS", (permissionId) => [
+    400,
+    `Permission with ID "${permissionId}" already exists. Choose a different ID.`,
+    {
+        permission_id: permissionId,
+    },
+], (json) => [json.permission_id]);
 export const KnownErrors = {
     CannotDeleteCurrentSession,
     UnsupportedError,
@@ -569,6 +584,7 @@ export const KnownErrors = {
     SchemaError,
     AllOverloadsFailed,
     ProjectAuthenticationError,
+    PermissionIdAlreadyExists,
     InvalidProjectAuthentication,
     ProjectKeyWithoutAccessType,
     InvalidAccessType,
@@ -648,6 +664,7 @@ export const KnownErrors = {
     InvalidTotpCode,
     UserAuthenticationRequired,
     TeamMembershipAlreadyExists,
+    ProjectPermissionRequired,
     TeamPermissionRequired,
     InvalidSharedOAuthProviderId,
     InvalidStandardOAuthProviderId,

package/dist/schema-fields.d.ts

@@ -131,8 +131,8 @@ export declare const signInResponseSchema: yup.ObjectSchema<{
     user_id: undefined;
 }, "">;
 export declare const teamSystemPermissions: readonly ["$update_team", "$delete_team", "$read_members", "$remove_members", "$invite_members"];
-export declare const teamPermissionDefinitionIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
-export declare const customTeamPermissionDefinitionIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const permissionDefinitionIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const customPermissionDefinitionIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const teamPermissionDescriptionSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const containedPermissionIdsSchema: yup.ArraySchema<string[] | undefined, yup.AnyObject, undefined, "">;
 export declare const teamIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

package/dist/schema-fields.js

@@ -327,7 +327,7 @@ export const teamSystemPermissions = [
     '$remove_members',
     '$invite_members',
 ];
-export const teamPermissionDefinitionIdSchema = yupString()
+export const permissionDefinitionIdSchema = yupString()
     .matches(/^\$?[a-z0-9_:]+$/, 'Only lowercase letters, numbers, ":", "_" and optional "$" at the beginning are allowed')
     .test('is-system-permission', 'System permissions must start with a dollar sign', (value, ctx) => {
     if (!value)
@@ -338,11 +338,11 @@ export const teamPermissionDefinitionIdSchema = yupString()
     return true;
 })
     .meta({ openapiField: { description: `The permission ID used to uniquely identify a permission. Can either be a custom permission with lowercase letters, numbers, \`:\`, and \`_\` characters, or one of the system permissions: ${teamSystemPermissions.map(x => `\`${x}\``).join(', ')}`, exampleValue: 'read_secret_info' } });
-export const customTeamPermissionDefinitionIdSchema = yupString()
+export const customPermissionDefinitionIdSchema = yupString()
     .matches(/^[a-z0-9_:]+$/, 'Only lowercase letters, numbers, ":", "_" are allowed')
     .meta({ openapiField: { description: 'The permission ID used to uniquely identify a permission. Can only contain lowercase letters, numbers, ":", and "_" characters', exampleValue: 'read_secret_info' } });
 export const teamPermissionDescriptionSchema = yupString().meta({ openapiField: { description: 'A human-readable description of the permission', exampleValue: 'Read secret information' } });
-export const containedPermissionIdsSchema = yupArray(teamPermissionDefinitionIdSchema.defined()).meta({ openapiField: { description: 'The IDs of the permissions that are contained in this permission', exampleValue: ['read_public_info'] } });
+export const containedPermissionIdsSchema = yupArray(permissionDefinitionIdSchema.defined()).meta({ openapiField: { description: 'The IDs of the permissions that are contained in this permission', exampleValue: ['read_public_info'] } });
 // Teams
 export const teamIdSchema = yupString().uuid().meta({ openapiField: { description: _idDescription('team'), exampleValue: 'ad962777-8244-496a-b6a2-e0c6a449c79e' } });
 export const teamDisplayNameSchema = yupString().meta({ openapiField: { description: _displayNameDescription('team'), exampleValue: 'My Team' } });

package/dist/utils/errors.js

@@ -68,11 +68,7 @@ StackAssertionError.prototype.name = "StackAssertionError";
 export function errorToNiceString(error) {
     if (!(error instanceof Error))
         return `${typeof error}<${nicify(error)}>`;
-    let stack = error.stack ?? "";
-    const toString = error.toString();
-    if (!stack.startsWith(toString))
-        stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
-    return `${stack} ${nicify(Object.fromEntries(Object.entries(error)), { maxDepth: 8 })}`;
+    return nicify(error, { maxDepth: 8 });
 }
 const errorSinks = new Set();
 export function registerErrorSink(sink) {

package/dist/utils/results.js

@@ -1,5 +1,5 @@
 import { wait } from "./promises";
-import { deindent } from "./strings";
+import { deindent, nicify } from "./strings";
 export const Result = {
     fromThrowing,
     fromThrowingAsync,
@@ -255,17 +255,17 @@ import.meta.vitest?.test("mapResult", ({ expect }) => {
 });
 class RetryError extends AggregateError {
     constructor(errors) {
-        const strings = errors.map(e => String(e));
+        const strings = errors.map(e => nicify(e));
         const isAllSame = strings.length > 1 && strings.every(s => s === strings[0]);
         super(errors, deindent `
       Error after ${errors.length} attempts.
       
       ${isAllSame ? deindent `
         Attempts 1-${errors.length}:
-          ${errors[0]}
-      ` : errors.map((e, i) => deindent `
+          ${strings[0]}
+      ` : strings.map((s, i) => deindent `
           Attempt ${i + 1}:
-            ${e}
+            ${s}
         `).join("\n\n")}
       `, { cause: errors[errors.length - 1] });
         this.errors = errors;

package/dist/utils/strings.d.ts

@@ -43,6 +43,7 @@ export declare function trimLines(s: string): string;
 export declare function templateIdentity(strings: TemplateStringsArray | readonly string[], ...values: string[]): string;
 export declare function deindent(code: string): string;
 export declare function deindent(strings: TemplateStringsArray | readonly string[], ...values: any[]): string;
+export declare function deindentTemplate(strings: TemplateStringsArray | readonly string[], ...values: any[]): [string[], ...string[]];
 export declare function extractScopes(scope: string, removeDuplicates?: boolean): string[];
 export declare function mergeScopeStrings(...scopes: string[]): string;
 export declare function escapeTemplateLiteral(s: string): string;

package/dist/utils/strings.js

@@ -207,8 +207,9 @@ Line2`).toBe("Line1\nLine2");
 export function deindent(strings, ...values) {
     if (typeof strings === "string")
         return deindent([strings]);
-    if (strings.length === 0)
-        return "";
+    return templateIdentity(...deindentTemplate(strings, ...values));
+}
+export function deindentTemplate(strings, ...values) {
     if (values.length !== strings.length - 1)
         throw new StackAssertionError("Invalid number of values; must be one less than strings", { strings, values });
     const trimmedStrings = [...strings];
@@ -231,7 +232,7 @@ export function deindent(strings, ...values) {
         const firstLineIndentation = getWhitespacePrefix(deindentedStrings[i].split("\n").at(-1));
         return `${value}`.replaceAll("\n", `\n${firstLineIndentation}`);
     });
-    return templateIdentity(deindentedStrings, ...indentedValues);
+    return [deindentedStrings, ...indentedValues];
 }
 import.meta.vitest?.test("deindent", ({ expect }) => {
     // Test with string input
@@ -241,7 +242,6 @@ import.meta.vitest?.test("deindent", ({ expect }) => {
     expect(deindent("\n  hello\n  world\n")).toBe("hello\nworld");
     // Test with empty input
     expect(deindent("")).toBe("");
-    expect(deindent([])).toBe("");
     // Test with template literal
     expect(deindent `
     hello
@@ -414,12 +414,13 @@ export function nicify(value, options = {}) {
         keyInParent: null,
         hideFields: [],
     };
-    const nestedNicify = (newValue, newPath, keyInParent) => {
+    const nestedNicify = (newValue, newPath, keyInParent, options = {}) => {
         return nicify(newValue, {
             ...newOptions,
             path: newPath,
             currentIndent: currentIndent + lineIndent,
             keyInParent,
+            ...options,
         });
     };
     switch (typeof value) {
@@ -431,7 +432,7 @@ export function nicify(value, options = {}) {
             const isDeindentable = (v) => deindent(v) === v && v.includes("\n");
             const wrapInDeindent = (v) => deindent `
         deindent\`
-        ${currentIndent + lineIndent}${escapeTemplateLiteral(value).replaceAll("\n", nl + lineIndent)}
+        ${currentIndent + lineIndent}${escapeTemplateLiteral(v).replaceAll("\n", nl + lineIndent)}
         ${currentIndent}\`
       `;
             if (isDeindentable(value)) {
@@ -470,7 +471,7 @@ export function nicify(value, options = {}) {
                 resValues.push(...extraLines);
                 if (resValues.length !== resValueLength)
                     throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });
-                const shouldIndent = resValues.length > 1 || resValues.some(x => x.includes("\n"));
+                const shouldIndent = resValues.length > 4 || resValues.some(x => (resValues.length > 1 && x.length > 4) || x.includes("\n"));
                 if (shouldIndent) {
                     return `[${nl}${resValues.map(x => `${lineIndent}${x},${nl}`).join("")}]`;
                 }
@@ -479,13 +480,30 @@ export function nicify(value, options = {}) {
                 }
             }
             if (value instanceof URL) {
-                return `URL(${nicify(value.toString())})`;
+                return `URL(${nestedNicify(value.toString(), `${path}.toString()`, null)})`;
             }
             if (ArrayBuffer.isView(value)) {
                 return `${value.constructor.name}([${value.toString()}])`;
             }
+            if (value instanceof Error) {
+                let stack = value.stack ?? "";
+                const toString = value.toString();
+                if (!stack.startsWith(toString))
+                    stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
+                stack = stack.trimEnd();
+                stack = stack.replace(/\n\s+/g, `\n${lineIndent}${lineIndent}`);
+                stack = stack.replace("\n", `\n${lineIndent}Stack:\n`);
+                if (Object.keys(value).length > 0) {
+                    stack += `\n${lineIndent}Extra properties: ${nestedNicify(Object.fromEntries(Object.entries(value)), path, null)}`;
+                }
+                if (value.cause) {
+                    stack += `\n${lineIndent}Cause:\n${lineIndent}${lineIndent}${nestedNicify(value.cause, path, null, { currentIndent: currentIndent + lineIndent + lineIndent })}`;
+                }
+                stack = stack.replaceAll("\n", `\n${currentIndent}`);
+                return stack;
+            }
             const constructorName = [null, Object.prototype].includes(Object.getPrototypeOf(value)) ? null : (nicifiableClassNameOverrides.get(value.constructor) ?? value.constructor.name);
-            const constructorString = constructorName ? `${nicifyPropertyString(constructorName)} ` : "";
+            const constructorString = constructorName ? `${constructorName} ` : "";
             const entries = getNicifiableEntries(value).filter(([k]) => !hideFields.includes(k));
             const extraLines = [
                 ...getNicifiedObjectExtraLines(value),
@@ -498,7 +516,7 @@ export function nicify(value, options = {}) {
                 return `${constructorString}{ ... }`;
             const resValues = entries.map(([k, v], keyIndex) => {
                 const keyNicified = nestedNicify(k, `Object.keys(${path})[${keyIndex}]`, null);
-                const keyInObjectLiteral = typeof k === "string" ? JSON.stringify(k) : `[${keyNicified}]`;
+                const keyInObjectLiteral = typeof k === "string" ? nicifyPropertyString(k) : `[${keyNicified}]`;
                 if (typeof v === "function" && v.name === k) {
                     return `${keyInObjectLiteral}(...): { ... }`;
                 }
@@ -525,25 +543,63 @@ export function nicify(value, options = {}) {
     }
 }
 export function replaceAll(input, searchValue, replaceValue) {
+    if (searchValue === "")
+        throw new StackAssertionError("replaceAll: searchValue is empty");
     return input.split(searchValue).join(replaceValue);
 }
+import.meta.vitest?.test("replaceAll", ({ expect }) => {
+    expect(replaceAll("hello world", "o", "x")).toBe("hellx wxrld");
+    expect(replaceAll("aaa", "a", "b")).toBe("bbb");
+    expect(replaceAll("", "a", "b")).toBe("");
+    expect(replaceAll("abc", "b", "")).toBe("ac");
+    expect(replaceAll("test.test.test", ".", "_")).toBe("test_test_test");
+    expect(replaceAll("a.b*c", ".", "x")).toBe("axb*c");
+    expect(replaceAll("a*b*c", "*", "x")).toBe("axbxc");
+    expect(replaceAll("hello hello", "hello", "hi")).toBe("hi hi");
+});
 function nicifyPropertyString(str) {
-    if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(str))
-        return str;
     return JSON.stringify(str);
 }
+import.meta.vitest?.test("nicifyPropertyString", ({ expect }) => {
+    // Test valid identifiers
+    expect(nicifyPropertyString("validName")).toBe('"validName"');
+    expect(nicifyPropertyString("_validName")).toBe('"_validName"');
+    expect(nicifyPropertyString("valid123Name")).toBe('"valid123Name"');
+    // Test invalid identifiers
+    expect(nicifyPropertyString("123invalid")).toBe('"123invalid"');
+    expect(nicifyPropertyString("invalid-name")).toBe('"invalid-name"');
+    expect(nicifyPropertyString("invalid space")).toBe('"invalid space"');
+    expect(nicifyPropertyString("$invalid")).toBe('"$invalid"');
+    expect(nicifyPropertyString("")).toBe('""');
+    // Test with special characters
+    expect(nicifyPropertyString("property!")).toBe('"property!"');
+    expect(nicifyPropertyString("property.name")).toBe('"property.name"');
+    // Test with escaped characters
+    expect(nicifyPropertyString("\\")).toBe('"\\\\"');
+    expect(nicifyPropertyString('"')).toBe('"\\""');
+});
 function getNicifiableKeys(value) {
     const overridden = ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.();
     if (overridden != null)
         return overridden;
     const keys = Object.keys(value).sort();
-    if (value instanceof Error) {
-        if (value.cause)
-            keys.unshift("cause");
-        keys.unshift("message", "stack");
-    }
     return unique(keys);
 }
+import.meta.vitest?.test("getNicifiableKeys", ({ expect }) => {
+    // Test regular object
+    expect(getNicifiableKeys({ b: 1, a: 2, c: 3 })).toEqual(["a", "b", "c"]);
+    // Test empty object
+    expect(getNicifiableKeys({})).toEqual([]);
+    // Test object with custom getNicifiableKeys
+    const customObject = {
+        a: 1,
+        b: 2,
+        getNicifiableKeys() {
+            return ["customKey1", "customKey2"];
+        }
+    };
+    expect(getNicifiableKeys(customObject)).toEqual(["customKey1", "customKey2"]);
+});
 function getNicifiableEntries(value) {
     const recordLikes = [Headers];
     function isRecordLike(value) {

package/dist/utils/strings.nicify.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "vitest";
+import { deindent, nicify } from "./strings";
+describe("nicify", () => {
+    describe("primitive values", () => {
+        test("numbers", () => {
+            expect(nicify(123)).toBe("123");
+            expect(nicify(123n)).toBe("123n");
+        });
+        test("strings", () => {
+            expect(nicify("hello")).toBe('"hello"');
+        });
+        test("booleans", () => {
+            expect(nicify(true)).toBe("true");
+            expect(nicify(false)).toBe("false");
+        });
+        test("null and undefined", () => {
+            expect(nicify(null)).toBe("null");
+            expect(nicify(undefined)).toBe("undefined");
+        });
+        test("symbols", () => {
+            expect(nicify(Symbol("test"))).toBe("Symbol(test)");
+        });
+    });
+    describe("arrays", () => {
+        test("empty array", () => {
+            expect(nicify([])).toBe("[]");
+        });
+        test("single-element array", () => {
+            expect(nicify([1])).toBe("[1]");
+        });
+        test("single-element array with long content", () => {
+            expect(nicify(["123123123123123"])).toBe('["123123123123123"]');
+        });
+        test("flat array", () => {
+            expect(nicify([1, 2, 3])).toBe("[1, 2, 3]");
+        });
+        test("longer array", () => {
+            expect(nicify([10000, 2, 3])).toBe(deindent `
+        [
+          10000,
+          2,
+          3,
+        ]
+      `);
+        });
+        test("nested array", () => {
+            expect(nicify([1, [2, 3]])).toBe(deindent `
+        [
+          1,
+          [2, 3],
+        ]
+      `);
+        });
+    });
+    describe("objects", () => {
+        test("empty object", () => {
+            expect(nicify({})).toBe("{}");
+        });
+        test("simple object", () => {
+            expect(nicify({ a: 1 })).toBe('{ "a": 1 }');
+        });
+        test("multiline object", () => {
+            expect(nicify({ a: 1, b: 2 })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+        }
+      `);
+        });
+    });
+    describe("custom classes", () => {
+        test("class instance", () => {
+            class TestClass {
+                constructor(value) {
+                    this.value = value;
+                }
+            }
+            expect(nicify(new TestClass(42))).toBe('TestClass { "value": 42 }');
+        });
+    });
+    describe("built-in objects", () => {
+        test("URL", () => {
+            expect(nicify(new URL("https://example.com"))).toBe('URL("https://example.com/")');
+        });
+        test("TypedArrays", () => {
+            expect(nicify(new Uint8Array([1, 2, 3]))).toBe("Uint8Array([1,2,3])");
+            expect(nicify(new Int32Array([1, 2, 3]))).toBe("Int32Array([1,2,3])");
+        });
+        test("Error objects", () => {
+            const error = new Error("test error");
+            const nicifiedError = nicify({ error });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^\{
+          "error": Error: test error
+            Stack:
+              at (.|\\n)*
+        \}$
+      `));
+        });
+        test("Error objects with cause and an extra property", () => {
+            const error = new Error("test error", { cause: new Error("cause") });
+            error.extra = "something";
+            const nicifiedError = nicify(error, { lineIndent: "--" });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^Error: test error
+        --Stack:
+        ----at (.|\\n)+
+        --Extra properties: \{ "extra": "something" \}
+        --Cause:
+        ----Error: cause
+        ------Stack:
+        --------at (.|\\n)+$
+      `));
+        });
+        test("Headers", () => {
+            const headers = new Headers();
+            headers.append("Content-Type", "application/json");
+            headers.append("Accept", "text/plain");
+            expect(nicify(headers)).toBe(deindent `
+        Headers {
+          "accept": "text/plain",
+          "content-type": "application/json",
+        }`);
+        });
+    });
+    describe("multiline strings", () => {
+        test("basic multiline", () => {
+            expect(nicify("line1\nline2")).toBe('deindent`\n  line1\n  line2\n`');
+        });
+        test("multiline with trailing newline", () => {
+            expect(nicify("line1\nline2\n")).toBe('deindent`\n  line1\n  line2\n` + "\\n"');
+        });
+    });
+    describe("circular references", () => {
+        test("object with self reference", () => {
+            const circular = { a: 1 };
+            circular.self = circular;
+            expect(nicify(circular)).toBe(deindent `
+        {
+          "a": 1,
+          "self": Ref<value>,
+        }`);
+        });
+    });
+    describe("configuration options", () => {
+        test("maxDepth", () => {
+            const deep = { a: { b: { c: { d: { e: 1 } } } } };
+            expect(nicify(deep, { maxDepth: 2 })).toBe('{ "a": { "b": { ... } } }');
+        });
+        test("lineIndent", () => {
+            expect(nicify({ a: 1, b: 2 }, { lineIndent: "    " })).toBe(deindent `
+        {
+            "a": 1,
+            "b": 2,
+        }
+      `);
+        });
+        test("hideFields", () => {
+            expect(nicify({ a: 1, b: 2, secret: "hidden" }, { hideFields: ["secret"] })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+          <some fields may have been hidden>,
+        }
+      `);
+        });
+    });
+    describe("custom overrides", () => {
+        test("override with custom type", () => {
+            expect(nicify({ type: "special" }, {
+                overrides: ((value) => {
+                    if (typeof value === "object" && value && "type" in value && value.type === "special") {
+                        return "SPECIAL";
+                    }
+                    return null;
+                })
+            })).toBe("SPECIAL");
+        });
+    });
+    describe("functions", () => {
+        test("named function", () => {
+            expect(nicify(function namedFunction() { })).toBe("function namedFunction(...) { ... }");
+        });
+        test("arrow function", () => {
+            expect(nicify(() => { })).toBe("(...) => { ... }");
+        });
+    });
+    describe("Nicifiable interface", () => {
+        test("object implementing Nicifiable", () => {
+            const nicifiable = {
+                value: 42,
+                getNicifiableKeys() {
+                    return ["value"];
+                },
+                getNicifiedObjectExtraLines() {
+                    return ["// custom comment"];
+                }
+            };
+            expect(nicify(nicifiable)).toBe(deindent `
+        {
+          "value": 42,
+          // custom comment,
+        }
+      `);
+        });
+    });
+    describe("unknown types", () => {
+        test("object without prototype", () => {
+            const unknownType = Object.create(null);
+            unknownType.value = "test";
+            expect(nicify(unknownType)).toBe('{ "value": "test" }');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.7.30",
+  "version": "2.8.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",

package/dist/utils/strings.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { templateIdentity } from "./strings";
-describe("templateIdentity", () => {
-    it("should be equivalent to a regular template string", () => {
-        const adjective = "scientific";
-        const noun = "railgun";
-        expect(templateIdentity `a certain scientific railgun`).toBe("a certain scientific railgun");
-        expect(templateIdentity `a certain ${adjective} railgun`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `a certain ${adjective} ${noun}`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `${adjective}${noun}`).toBe(`scientificrailgun`);
-    });
-    it("should work with empty strings", () => {
-        expect(templateIdentity ``).toBe("");
-        expect(templateIdentity `${""}`).toBe("");
-        expect(templateIdentity `${""}${""}`).toBe("");
-    });
-    it("should work with normal arrays", () => {
-        expect(templateIdentity(["a ", " scientific ", "gun"], "certain", "rail")).toBe("a certain scientific railgun");
-        expect(templateIdentity(["a"])).toBe("a");
-    });
-    it("should throw an error with wrong number of value arguments", () => {
-        expect(() => templateIdentity([])).toThrow();
-        expect(() => templateIdentity(["a", "b"])).toThrow();
-        expect(() => templateIdentity(["a", "b", "c"], "a", "b", "c")).toThrow();
-    });
-});