@stackframe/stack-shared 2.4.27 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @stackframe/stack-shared
 
+## 2.5.0
+
+### Minor Changes
+
+- Client teams and many bugfixes
+
+### Patch Changes
+
+- @stackframe/stack-sc@2.5.0
+
+## 2.4.28
+
+### Patch Changes
+
+- Bugfixes
+  - @stackframe/stack-sc@2.4.28
+
 ## 2.4.27
 
 ### Patch Changes

package/dist/interface/adminInterface.d.ts

@@ -31,6 +31,8 @@ export type ProjectUpdateOptions = {
         allowLocalhost?: boolean;
         createTeamOnSignUp?: boolean;
         emailConfig?: EmailConfigJson;
+        teamCreatorDefaultPermissionIds?: string[];
+        teamMemberDefaultPermissionIds?: string[];
     };
 };
 export type ApiKeySetBaseJson = {

package/dist/interface/clientInterface.d.ts

@@ -68,6 +68,8 @@ export type ProjectJson = {
         emailConfig?: EmailConfigJson;
         domains: DomainConfigJson[];
         createTeamOnSignUp: boolean;
+        teamCreatorDefaultPermissions: PermissionDefinitionJson[];
+        teamMemberDefaultPermissions: PermissionDefinitionJson[];
     };
 };
 export type OAuthProviderConfigJson = {
@@ -106,6 +108,8 @@ export type OrglikeJson = {
 };
 export type TeamJson = OrglikeJson;
 export type OrganizationJson = OrglikeJson;
+export type OrglikeCustomizableJson = Pick<OrglikeJson, "displayName">;
+export type TeamCustomizableJson = OrglikeCustomizableJson;
 export type TeamMemberJson = {
     userId: string;
     teamId: string;
@@ -219,6 +223,7 @@ export declare class StackClientInterface {
     getAccessToken(provider: string, scope: string, session: InternalSession): Promise<{
         accessToken: string;
     }>;
+    createTeamForCurrentUser(data: TeamCustomizableJson, session: InternalSession): Promise<TeamJson>;
 }
 export declare function getProductionModeErrors(project: ProjectJson): ProductionModeError[];
 export {};

package/dist/interface/clientInterface.js

@@ -549,6 +549,16 @@ export class StackClientInterface {
             accessToken: json.accessToken,
         };
     }
+    async createTeamForCurrentUser(data, session) {
+        const response = await this.sendClientRequest("/current-user/teams?server=false", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, session);
+        return await response.json();
+    }
 }
 export function getProductionModeErrors(project) {
     const errors = [];

package/dist/interface/crud/current-user.d.ts

@@ -2,9 +2,9 @@ import { CrudTypeOf } from "../../crud";
 import * as yup from "yup";
 export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions<{
     clientReadSchema: yup.ObjectSchema<{
+        projectId: string;
         displayName: string | null;
         id: string;
-        projectId: string;
         clientMetadata: {} | null;
         primaryEmail: string | null;
         primaryEmailVerified: NonNullable<boolean | undefined>;

package/dist/interface/serverInterface.d.ts

@@ -56,31 +56,32 @@ export declare class StackServerInterface extends StackClientInterface {
     createPermissionDefinition(data: ServerPermissionDefinitionCustomizableJson): Promise<ServerPermissionDefinitionJson>;
     updatePermissionDefinition(permissionId: string, data: Partial<ServerPermissionDefinitionCustomizableJson>): Promise<void>;
     deletePermissionDefinition(permissionId: string): Promise<void>;
-    listUsers(): Promise<ServerUserJson[]>;
-    listTeams(): Promise<ServerTeamJson[]>;
-    listTeamMembers(teamId: string): Promise<ServerTeamMemberJson[]>;
-    createTeam(data: ServerTeamCustomizableJson): Promise<ServerTeamJson>;
-    updateTeam(teamId: string, data: Partial<ServerTeamCustomizableJson>): Promise<void>;
-    deleteTeam(teamId: string): Promise<void>;
-    addUserToTeam(options: {
+    listServerUsers(): Promise<ServerUserJson[]>;
+    listServerTeams(): Promise<ServerTeamJson[]>;
+    listServerTeamMembers(teamId: string): Promise<ServerTeamMemberJson[]>;
+    createServerTeam(data: ServerTeamCustomizableJson): Promise<ServerTeamJson>;
+    updateServerTeam(teamId: string, data: Partial<ServerTeamCustomizableJson>): Promise<void>;
+    deleteServerTeam(teamId: string): Promise<void>;
+    addServerUserToTeam(options: {
         userId: string;
         teamId: string;
     }): Promise<void>;
-    removeUserFromTeam(options: {
+    removeServerUserFromTeam(options: {
         userId: string;
         teamId: string;
     }): Promise<void>;
     setServerUserCustomizableData(userId: string, update: ServerUserUpdateJson): Promise<void>;
-    listTeamMemberPermissions(options: {
+    listServerTeamMemberPermissions(options: {
         teamId: string;
         userId: string;
         type: 'global' | 'team';
         direct: boolean;
     }): Promise<ServerPermissionDefinitionJson[]>;
-    grantTeamUserPermission(teamId: string, userId: string, permissionId: string, type: 'global' | 'team'): Promise<void>;
-    revokeTeamUserPermission(teamId: string, userId: string, permissionId: string, type: 'global' | 'team'): Promise<void>;
-    deleteServerUser(userId: string): Promise<void>;
+    grantServerTeamUserPermission(teamId: string, userId: string, permissionId: string, type: 'global' | 'team'): Promise<void>;
+    revokeServerTeamUserPermission(teamId: string, userId: string, permissionId: string, type: 'global' | 'team'): Promise<void>;
+    deleteServerServerUser(userId: string): Promise<void>;
     listEmailTemplates(): Promise<ListEmailTemplatesCrud['Server']['Read']>;
     updateEmailTemplate(type: EmailTemplateType, data: EmailTemplateCrud['Server']['Update']): Promise<void>;
     resetEmailTemplate(type: EmailTemplateType): Promise<void>;
+    createServerTeamForUser(userId: string, data: ServerTeamCustomizableJson, session: InternalSession): Promise<ServerTeamJson>;
 }

package/dist/interface/serverInterface.js

@@ -71,20 +71,20 @@ export class StackServerInterface extends StackClientInterface {
     async deletePermissionDefinition(permissionId) {
         await this.sendServerRequest(`/permission-definitions/${permissionId}?server=true`, { method: "DELETE" }, null);
     }
-    async listUsers() {
+    async listServerUsers() {
         const response = await this.sendServerRequest("/users?server=true", {}, null);
         return await response.json();
     }
-    async listTeams() {
+    async listServerTeams() {
         const response = await this.sendServerRequest("/teams?server=true", {}, null);
         const json = await response.json();
         return json;
     }
-    async listTeamMembers(teamId) {
+    async listServerTeamMembers(teamId) {
         const response = await this.sendServerRequest(`/teams/${teamId}/users?server=true`, {}, null);
         return await response.json();
     }
-    async createTeam(data) {
+    async createServerTeam(data) {
         const response = await this.sendServerRequest("/teams?server=true", {
             method: "POST",
             headers: {
@@ -94,7 +94,7 @@ export class StackServerInterface extends StackClientInterface {
         }, null);
         return await response.json();
     }
-    async updateTeam(teamId, data) {
+    async updateServerTeam(teamId, data) {
         await this.sendServerRequest(`/teams/${teamId}?server=true`, {
             method: "PUT",
             headers: {
@@ -103,10 +103,10 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify(data),
         }, null);
     }
-    async deleteTeam(teamId) {
+    async deleteServerTeam(teamId) {
         await this.sendServerRequest(`/teams/${teamId}?server=true`, { method: "DELETE" }, null);
     }
-    async addUserToTeam(options) {
+    async addServerUserToTeam(options) {
         await this.sendServerRequest(`/teams/${options.teamId}/users/${options.userId}?server=true`, {
             method: "POST",
             headers: {
@@ -115,7 +115,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({}),
         }, null);
     }
-    async removeUserFromTeam(options) {
+    async removeServerUserFromTeam(options) {
         await this.sendServerRequest(`/teams/${options.teamId}/users/${options.userId}?server=true`, {
             method: "DELETE",
             headers: {
@@ -133,11 +133,11 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify(update),
         }, null);
     }
-    async listTeamMemberPermissions(options) {
+    async listServerTeamMemberPermissions(options) {
         const response = await this.sendServerRequest(`/teams/${options.teamId}/users/${options.userId}/permissions?server=true&type=${options.type}&direct=${options.direct}`, {}, null);
         return await response.json();
     }
-    async grantTeamUserPermission(teamId, userId, permissionId, type) {
+    async grantServerTeamUserPermission(teamId, userId, permissionId, type) {
         await this.sendServerRequest(`/teams/${teamId}/users/${userId}/permissions/${permissionId}?server=true`, {
             method: "POST",
             headers: {
@@ -146,7 +146,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({ type }),
         }, null);
     }
-    async revokeTeamUserPermission(teamId, userId, permissionId, type) {
+    async revokeServerTeamUserPermission(teamId, userId, permissionId, type) {
         await this.sendServerRequest(`/teams/${teamId}/users/${userId}/permissions/${permissionId}?server=true`, {
             method: "DELETE",
             headers: {
@@ -155,7 +155,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({ type }),
         }, null);
     }
-    async deleteServerUser(userId) {
+    async deleteServerServerUser(userId) {
         await this.sendServerRequest(`/users/${userId}?server=true`, {
             method: "DELETE",
             headers: {
@@ -180,4 +180,14 @@ export class StackServerInterface extends StackClientInterface {
     async resetEmailTemplate(type) {
         await this.sendServerRequest(`/email-templates/${type}?server=true`, { method: "DELETE" }, null);
     }
+    async createServerTeamForUser(userId, data, session) {
+        const response = await this.sendClientRequest(`/users/${userId}/teams?server=true`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, session);
+        return await response.json();
+    }
 }

package/dist/known-errors.d.ts

@@ -71,13 +71,13 @@ export declare const KnownErrors: {
     RequestTypeWithoutProjectId: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"REQUEST_TYPE_WITHOUT_PROJECT_ID">, [requestType: "client" | "server" | "admin"]> & {
         errorCode: "REQUEST_TYPE_WITHOUT_PROJECT_ID";
     };
-    InvalidPublishableClientKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_PUBLISHABLE_CLIENT_KEY">, []> & {
+    InvalidPublishableClientKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_PUBLISHABLE_CLIENT_KEY">, [projectId: string]> & {
         errorCode: "INVALID_PUBLISHABLE_CLIENT_KEY";
     };
-    InvalidSecretServerKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SECRET_SERVER_KEY">, []> & {
+    InvalidSecretServerKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SECRET_SERVER_KEY">, [projectId: string]> & {
         errorCode: "INVALID_SECRET_SERVER_KEY";
     };
-    InvalidSuperSecretAdminKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SUPER_SECRET_ADMIN_KEY">, []> & {
+    InvalidSuperSecretAdminKey: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_SUPER_SECRET_ADMIN_KEY">, [projectId: string]> & {
         errorCode: "INVALID_SUPER_SECRET_ADMIN_KEY";
     };
     InvalidAdminAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
@@ -236,9 +236,6 @@ export declare const KnownErrors: {
     PermissionScopeMismatch: KnownErrorConstructor<KnownError & KnownErrorBrand<"PERMISSION_SCOPE_MISMATCH">, [permissionId: string, permissionScope: PermissionDefinitionScopeJson, testScope: PermissionDefinitionScopeJson]> & {
         errorCode: "PERMISSION_SCOPE_MISMATCH";
     };
-    UserNotInTeam: KnownErrorConstructor<KnownError & KnownErrorBrand<"USER_NOT_IN_TEAM">, [userId: string, teamId: string]> & {
-        errorCode: "USER_NOT_IN_TEAM";
-    };
     TeamNotFound: KnownErrorConstructor<KnownError & KnownErrorBrand<"TEAM_NOT_FOUND">, [teamId: string]> & {
         errorCode: "TEAM_NOT_FOUND";
     };

package/dist/known-errors.js

@@ -17,6 +17,7 @@ export class KnownError extends StatusError {
             code: this.errorCode,
             message: this.humanReadableMessage,
             details: this.details,
+            error: true,
         }, undefined, 2));
     }
     getHeaders() {
@@ -117,18 +118,27 @@ const RequestTypeWithoutProjectId = createKnownErrorConstructor(InvalidProjectAu
         requestType,
     },
 ], (json) => [json.requestType]);
-const InvalidPublishableClientKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_PUBLISHABLE_CLIENT_KEY", () => [
+const InvalidPublishableClientKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_PUBLISHABLE_CLIENT_KEY", (projectId) => [
     401,
-    "The publishable key is not valid for the given project. Does the project and/or the key exist?",
-], () => []);
-const InvalidSecretServerKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SECRET_SERVER_KEY", () => [
+    `The publishable key is not valid for the project ${JSON.stringify(projectId)}. Does the project and/or the key exist?`,
+    {
+        projectId,
+    },
+], (json) => [json.projectId]);
+const InvalidSecretServerKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SECRET_SERVER_KEY", (projectId) => [
     401,
-    "The secret server key is not valid for the given project. Does the project and/or the key exist?",
-], () => []);
-const InvalidSuperSecretAdminKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SUPER_SECRET_ADMIN_KEY", () => [
+    `The secret server key is not valid for the project ${JSON.stringify(projectId)}. Does the project and/or the key exist?`,
+    {
+        projectId,
+    },
+], (json) => [json.projectId]);
+const InvalidSuperSecretAdminKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_SUPER_SECRET_ADMIN_KEY", (projectId) => [
     401,
-    "The super secret admin key is not valid for the given project. Does the project and/or the key exist?",
-], () => []);
+    `The super secret admin key is not valid for the project ${JSON.stringify(projectId)}. Does the project and/or the key exist?`,
+    {
+        projectId,
+    },
+], (json) => [json.projectId]);
 const InvalidAdminAccessToken = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_ADMIN_ACCESS_TOKEN", "inherit", "inherit");
 const UnparsableAdminAccessToken = createKnownErrorConstructor(InvalidAdminAccessToken, "UNPARSABLE_ADMIN_ACCESS_TOKEN", () => [
     401,
@@ -322,14 +332,6 @@ const PermissionScopeMismatch = createKnownErrorConstructor(KnownError, "PERMISS
         },
     ];
 }, (json) => [json.details.permissionId, json.details.permissionScope, json.details.testScope]);
-const UserNotInTeam = createKnownErrorConstructor(KnownError, "USER_NOT_IN_TEAM", (userId, teamId) => [
-    400,
-    `User ${userId} is not in team ${teamId}.`,
-    {
-        userId,
-        teamId,
-    },
-], (json) => [json.details.userId, json.details.teamId]);
 const TeamNotFound = createKnownErrorConstructor(KnownError, "TEAM_NOT_FOUND", (teamId) => [
     404,
     `Team ${teamId} not found.`,
@@ -434,7 +436,6 @@ export const KnownErrors = {
     EmailAlreadyVerified,
     PermissionNotFound,
     PermissionScopeMismatch,
-    UserNotInTeam,
     TeamNotFound,
     EmailTemplateAlreadyExists,
     OAuthConnectionNotConnectedToUser,

package/dist/utils/jwt.js

@@ -1,16 +1,16 @@
 import * as jose from "jose";
 import { getEnvVariable } from "./env";
-const SERVER_SECRET = jose.base64url.decode(getEnvVariable("SERVER_SECRET"));
+const STACK_SERVER_SECRET = jose.base64url.decode(getEnvVariable("STACK_SERVER_SECRET"));
 export async function encryptJWT(payload, expirationTime = "5m") {
     return await new jose.EncryptJWT(payload)
         .setProtectedHeader({ alg: "dir", enc: "A128CBC-HS256" })
         .setIssuedAt()
         .setExpirationTime(expirationTime)
-        .encrypt(SERVER_SECRET);
+        .encrypt(STACK_SERVER_SECRET);
 }
 export async function decryptJWT(jwt) {
     if (!jwt) {
         throw new Error("Provided JWT is empty");
     }
-    return (await jose.jwtDecrypt(jwt, SERVER_SECRET)).payload;
+    return (await jose.jwtDecrypt(jwt, STACK_SERVER_SECRET)).payload;
 }

package/dist/utils/strings.d.ts

@@ -41,6 +41,23 @@ export declare function deindent(code: string): string;
 export declare function deindent(strings: TemplateStringsArray | readonly string[], ...values: any[]): string;
 export declare function extractScopes(scope: string, removeDuplicates?: boolean): string[];
 export declare function mergeScopeStrings(...scopes: string[]): string;
-export declare function nicify(value: unknown, { depth }?: {
-    depth?: number | undefined;
-}): string;
+export type Nicifiable = {
+    getNicifiableKeys?(): PropertyKey[];
+    getNicifiedObjectExtraLines?(): string[];
+};
+export type NicifyOptions = {
+    maxDepth: number;
+    currentIndent: string;
+    lineIndent: string;
+    multiline: boolean;
+    refs: Map<unknown, string>;
+    path: string;
+    parent: null | {
+        options: NicifyOptions;
+        value: unknown;
+    };
+    keyInParent: PropertyKey | null;
+    overrides: (...args: Parameters<typeof nicify>) => ["result", string] | ["replace", unknown] | null;
+};
+export declare function nicify(value: unknown, options?: Partial<NicifyOptions>): string;
+export declare function replaceAll(input: string, searchValue: string, replaceValue: string): string;

package/dist/utils/strings.js

@@ -1,3 +1,5 @@
+import { StackAssertionError } from "./errors";
+import { filterUndefined } from "./objects";
 export function typedToLowercase(s) {
     return s.toLowerCase();
 }
@@ -102,7 +104,58 @@ export function mergeScopeStrings(...scopes) {
     const allScope = scopes.map((s) => extractScopes(s)).flat().join(" ");
     return extractScopes(allScope).join(" ");
 }
-export function nicify(value, { depth = 5 } = {}) {
+/**
+ * Some classes have different constructor names in different environments (eg. `Headers` is sometimes called `_Headers`,
+ * so we create an object of overrides to handle these cases.
+ */
+const nicifiableClassNameOverrides = new Map(Object.entries({
+    Headers,
+}).map(([k, v]) => [v, k]));
+export function nicify(value, options = {}) {
+    const fullOptions = {
+        maxDepth: 5,
+        currentIndent: "",
+        lineIndent: "  ",
+        multiline: true,
+        refs: new Map(),
+        path: "value",
+        parent: null,
+        overrides: () => null,
+        keyInParent: null,
+        ...filterUndefined(options),
+    };
+    const { maxDepth, currentIndent, lineIndent, multiline, refs, path, overrides, } = fullOptions;
+    const nl = `\n${currentIndent}`;
+    if (["function", "object", "symbol"].includes(typeof value)) {
+        if (refs.has(value)) {
+            return `Ref<${refs.get(value)}>`;
+        }
+        refs.set(value, path);
+    }
+    const overrideResult = overrides(value, options);
+    if (overrideResult?.[0] === "result")
+        return overrideResult[1];
+    else if (overrideResult?.[0] === "replace")
+        return nicify(overrideResult[1], options);
+    const newOptions = {
+        maxDepth: maxDepth - 1,
+        currentIndent,
+        lineIndent,
+        multiline,
+        refs,
+        path: path + "->[unknown property]",
+        overrides,
+        parent: { value, options: fullOptions },
+        keyInParent: null,
+    };
+    const nestedNicify = (newValue, newPath, indent, keyInParent) => {
+        return nicify(newValue, {
+            ...newOptions,
+            path: newPath,
+            currentIndent: currentIndent + (indent ? lineIndent : ""),
+            keyInParent,
+        });
+    };
     switch (typeof value) {
         case "string":
         case "boolean":
@@ -127,24 +180,81 @@ export function nicify(value, { depth = 5 } = {}) {
             if (value === null)
                 return "null";
             if (Array.isArray(value)) {
-                if (depth <= 0 && value.length !== 0)
+                const extraLines = getNicifiedObjectExtraLines(value);
+                const resValueLength = value.length + extraLines.length;
+                if (maxDepth <= 0 && resValueLength === 0)
                     return "[...]";
-                return `[${value.map((v) => nicify(v, { depth: depth - 1 })).join(", ")}]`;
+                const shouldIndent = multiline && resValueLength > 1;
+                const resValues = value.map((v, i) => nestedNicify(v, `${path}[${i}]`, shouldIndent, i));
+                resValues.push(...extraLines);
+                if (resValues.length !== resValueLength)
+                    throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });
+                if (shouldIndent) {
+                    return `[${nl}${resValues.map(x => `${lineIndent}${x},${nl}`).join("")}]`;
+                }
+                else {
+                    return `[${resValues.join(", ")}]`;
+                }
+            }
+            const constructorName = [null, Object].includes(Object.getPrototypeOf(value)) ? null : (nicifiableClassNameOverrides.get(value.constructor) ?? value.constructor.name);
+            const constructorString = constructorName ? `${nicifyPropertyString(constructorName)} ` : "";
+            const entries = getNicifiableEntries(value);
+            const extraLines = getNicifiedObjectExtraLines(value);
+            const resValueLength = entries.length + extraLines.length;
+            if (resValueLength === 0)
+                return `${constructorString}{}`;
+            if (maxDepth <= 0)
+                return `${constructorString}{ ... }`;
+            const shouldIndent = multiline && resValueLength > 1;
+            const resValues = entries.map(([k, v], keyIndex) => {
+                const keyNicified = nestedNicify(k, `Object.keys(${path})[${keyIndex}]`, shouldIndent, null);
+                const keyInObjectLiteral = typeof k === "string" ? JSON.stringify(k) : `[${keyNicified}]`;
+                if (typeof v === "function" && v.name === k) {
+                    return `${keyInObjectLiteral}(...): { ... }`;
+                }
+                else {
+                    return `${keyInObjectLiteral}: ${nestedNicify(v, `${path}[${keyNicified}]`, shouldIndent, k)}`;
+                }
+            });
+            resValues.push(...extraLines);
+            if (resValues.length !== resValueLength)
+                throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });
+            if (resValues.length === 0)
+                return `${constructorString}{}`;
+            if (shouldIndent) {
+                return `${constructorString}{${nl}${resValues.map(x => `${lineIndent}${x},${nl}`).join("")}}`;
+            }
+            else {
+                return `${constructorString}{ ${resValues.join(", ")} }`;
             }
-            const entries = Object.entries(value);
-            if (entries.length === 0)
-                return "{}";
-            if (depth <= 0)
-                return "{...}";
-            return `{ ${Object.entries(value).map(([k, v]) => {
-                if (typeof v === "function" && v.name === k)
-                    return `${k}(...): { ... }`;
-                else
-                    return `${k}: ${nicify(v, { depth: depth - 1 })}`;
-            }).join(", ")} }`;
         }
         default: {
             return `${typeof value}<${value}>`;
         }
     }
 }
+export function replaceAll(input, searchValue, replaceValue) {
+    return input.split(searchValue).join(replaceValue);
+}
+function nicifyPropertyString(str) {
+    if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(str))
+        return str;
+    return JSON.stringify(str);
+}
+function getNicifiableKeys(value) {
+    return ("getNicifiableKeys" in value ? value.getNicifiableKeys : null)?.() ?? Object.keys(value).sort();
+}
+function getNicifiableEntries(value) {
+    const recordLikes = [Headers];
+    function isRecordLike(value) {
+        return recordLikes.some(x => value instanceof x);
+    }
+    if (isRecordLike(value)) {
+        return [...value.entries()].sort(([a], [b]) => String(a).localeCompare(String(b)));
+    }
+    const keys = getNicifiableKeys(value);
+    return keys.map((k) => [k, value[k]]);
+}
+function getNicifiedObjectExtraLines(value) {
+    return ("getNicifiedObjectExtraLines" in value ? value.getNicifiedObjectExtraLines : null)?.() ?? [];
+}

package/dist/utils/yup.d.ts

@@ -1,2 +1,3 @@
 import * as yup from "yup";
 export declare const yupJson: yup.MixedSchema<{} | null, yup.AnyObject, undefined, "">;
+export declare const yupJsonValidator: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

package/dist/utils/yup.js

@@ -1,2 +1,13 @@
 import * as yup from "yup";
 export const yupJson = yup.mixed().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value)));
+export const yupJsonValidator = yup.string().test("json", "Invalid JSON format", (value) => {
+    if (!value)
+        return true;
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.4.27",
+  "version": "2.5.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -36,7 +36,7 @@
     "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.4.27"
+    "@stackframe/stack-sc": "2.5.0"
   },
   "devDependencies": {
     "rimraf": "^5.0.5",

package/dist/hooks/use-trigger.d.ts

@@ -1 +0,0 @@
-export declare function useTrigger(callback: () => void): () => void;

package/dist/hooks/use-trigger.js

@@ -1,10 +0,0 @@
-import * as React from "react";
-export function useTrigger(callback) {
-    const [hasTriggered, setHasTriggered] = React.useState(false);
-    React.useEffect(() => {
-        if (hasTriggered) {
-            callback();
-        }
-    }, [hasTriggered]);
-    return () => setHasTriggered(true);
-}