@stackframe/stack-shared 2.3.6 → 2.4.0

package/dist/interface/adminInterface.d.ts

@@ -62,7 +62,7 @@ export type ApiKeySetCreateOptions = {
 export declare class StackAdminInterface extends StackServerInterface {
     readonly options: AdminAuthApplicationOptions;
     constructor(options: AdminAuthApplicationOptions);
-    protected sendAdminRequest(path: string, options: RequestInit, tokenStore: TokenStore | null): Promise<Response & {
+    protected sendAdminRequest(path: string, options: RequestInit, tokenStore: TokenStore | null, requestType?: "admin"): Promise<Response & {
         usedTokens: Readonly<{
             refreshToken: string | null;
             accessToken: string | null;

package/dist/interface/adminInterface.js

@@ -5,14 +5,14 @@ export class StackAdminInterface extends StackServerInterface {
         super(options);
         this.options = options;
     }
-    async sendAdminRequest(path, options, tokenStore) {
+    async sendAdminRequest(path, options, tokenStore, requestType = "admin") {
         return await this.sendServerRequest(path, {
             ...options,
             headers: {
                 "x-stack-super-secret-admin-key": "superSecretAdminKey" in this.options ? this.options.superSecretAdminKey : "",
                 ...options.headers,
             },
-        }, tokenStore);
+        }, tokenStore, requestType);
     }
     async getProject(options) {
         const response = await this.sendAdminRequest("/projects/" + encodeURIComponent(this.projectId), {

package/dist/interface/clientInterface.d.ts

@@ -105,7 +105,7 @@ export declare class StackClientInterface {
     getSessionCookieName(): string;
     getApiUrl(): string;
     protected refreshAccessToken(tokenStore: TokenStore): Promise<void>;
-    protected sendClientRequest(path: string, requestOptions: RequestInit, tokenStoreOrNull: TokenStore | null): Promise<Response & {
+    protected sendClientRequest(path: string, requestOptions: RequestInit, tokenStoreOrNull: TokenStore | null, requestType?: "client" | "server" | "admin"): Promise<Response & {
         usedTokens: Readonly<{
             refreshToken: string | null;
             accessToken: string | null;

package/dist/interface/clientInterface.js

@@ -94,12 +94,12 @@ export class StackClientInterface {
             refreshToken: result.refresh_token ?? old?.refreshToken ?? null,
         }));
     }
-    async sendClientRequest(path, requestOptions, tokenStoreOrNull) {
+    async sendClientRequest(path, requestOptions, tokenStoreOrNull, requestType = "client") {
         const tokenStore = tokenStoreOrNull ?? new AsyncStore({
             accessToken: null,
             refreshToken: null,
         });
-        return await Result.orThrowAsync(Result.retry(() => this.sendClientRequestInner(path, requestOptions, tokenStore), 5, { exponentialDelayBase: 1000 }));
+        return await Result.orThrowAsync(Result.retry(() => this.sendClientRequestInner(path, requestOptions, tokenStore, requestType), 5, { exponentialDelayBase: 1000 }));
     }
     async sendClientRequestAndCatchKnownError(path, requestOptions, tokenStoreOrNull, errorsToCatch) {
         try {
@@ -118,7 +118,7 @@ export class StackClientInterface {
     /**
      * This object will be modified for future retries, so it should be passed by reference.
      */
-    tokenStore) {
+    tokenStore, requestType) {
         let tokenObj = await tokenStore.getOrWait();
         if (!tokenObj.accessToken && tokenObj.refreshToken) {
             await this.refreshAccessToken(tokenStore);
@@ -138,6 +138,7 @@ export class StackClientInterface {
             headers: {
                 "X-Stack-Override-Error-Status": "true",
                 "X-Stack-Project-Id": this.projectId,
+                "X-Stack-Request-Type": requestType,
                 ...tokenObj.accessToken ? {
                     "Authorization": "StackSession " + tokenObj.accessToken,
                 } : {},

package/dist/interface/serverInterface.d.ts

@@ -17,7 +17,7 @@ export type ServerAuthApplicationOptions = (ClientInterfaceOptions & ({
 export declare class StackServerInterface extends StackClientInterface {
     options: ServerAuthApplicationOptions;
     constructor(options: ServerAuthApplicationOptions);
-    protected sendServerRequest(path: string, options: RequestInit, tokenStore: TokenStore | null): Promise<Response & {
+    protected sendServerRequest(path: string, options: RequestInit, tokenStore: TokenStore | null, requestType?: "server" | "admin"): Promise<Response & {
         usedTokens: Readonly<{
             refreshToken: string | null;
             accessToken: string | null;

package/dist/interface/serverInterface.js

@@ -6,14 +6,14 @@ export class StackServerInterface extends StackClientInterface {
         super(options);
         this.options = options;
     }
-    async sendServerRequest(path, options, tokenStore) {
+    async sendServerRequest(path, options, tokenStore, requestType = "server") {
         return await this.sendClientRequest(path, {
             ...options,
             headers: {
                 "x-stack-secret-server-key": "secretServerKey" in this.options ? this.options.secretServerKey : "",
                 ...options.headers,
             },
-        }, tokenStore);
+        }, tokenStore, requestType);
     }
     async getServerUserByToken(tokenStore) {
         const response = await this.sendServerRequest("/current-user?server=true", {}, tokenStore);

package/dist/known-errors.d.ts

@@ -58,6 +58,15 @@ export declare const KnownErrors: {
     InvalidProjectAuthentication: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "INVALID_PROJECT_AUTHENTICATION";
     };
+    ProjectKeyWithoutRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"PROJECT_KEY_WITHOUT_REQUEST_TYPE">, []> & {
+        errorCode: "PROJECT_KEY_WITHOUT_REQUEST_TYPE";
+    };
+    InvalidRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_REQUEST_TYPE">, [requestType: string]> & {
+        errorCode: "INVALID_REQUEST_TYPE";
+    };
+    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">, []> & {
         errorCode: "INVALID_PUBLISHABLE_CLIENT_KEY";
     };
@@ -79,6 +88,9 @@ export declare const KnownErrors: {
     InvalidProjectForAdminAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN"> & KnownErrorBrand<"INVALID_PROJECT_FOR_ADMIN_ACCESS_TOKEN">, []> & {
         errorCode: "INVALID_PROJECT_FOR_ADMIN_ACCESS_TOKEN";
     };
+    AdminAccessTokenIsNotAdmin: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ADMIN_ACCESS_TOKEN"> & KnownErrorBrand<"ADMIN_ACCESS_TOKEN_IS_NOT_ADMIN">, []> & {
+        errorCode: "ADMIN_ACCESS_TOKEN_IS_NOT_ADMIN";
+    };
     ProjectAuthenticationRequired: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & KnownErrorBrand<"PROJECT_AUTHENTICATION_REQUIRED">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "PROJECT_AUTHENTICATION_REQUIRED";
     };

package/dist/known-errors.js

@@ -1,5 +1,6 @@
 import { StatusError, throwErr, throwStackErr } from "./utils/errors";
 import { identityArgs } from "./utils/functions";
+import { deindent } from "./utils/strings";
 export class KnownError extends StatusError {
     statusCode;
     humanReadableMessage;
@@ -80,7 +81,13 @@ const SchemaError = createKnownErrorConstructor(KnownError, "SCHEMA_ERROR", (mes
 ], (json) => [json.message]);
 const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOADS_FAILED", (overloadErrors) => [
     400,
-    "This endpoint has multiple overloads, but they all failed to process the request.",
+    deindent `
+      This endpoint has multiple overloads, but they all failed to process the request.
+
+        ${overloadErrors.map((e, i) => deindent `
+          Overload ${i + 1}: ${JSON.stringify(e, undefined, 2)}
+        `).join("\n\n")}
+    `,
     {
         overloads: overloadErrors,
     },
@@ -89,6 +96,23 @@ const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOAD
 ]);
 const ProjectAuthenticationError = createKnownErrorConstructor(KnownError, "PROJECT_AUTHENTICATION_ERROR", "inherit", "inherit");
 const InvalidProjectAuthentication = createKnownErrorConstructor(ProjectAuthenticationError, "INVALID_PROJECT_AUTHENTICATION", "inherit", "inherit");
+const ProjectKeyWithoutRequestType = createKnownErrorConstructor(InvalidProjectAuthentication, "PROJECT_KEY_WITHOUT_REQUEST_TYPE", () => [
+    400,
+    "Either an API key or an admin access token was provided, but the x-stack-request-type header is missing. Set it to 'client', 'server', or 'admin' as appropriate.",
+], () => []);
+const InvalidRequestType = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_REQUEST_TYPE", (requestType) => [
+    400,
+    `The x-stack-request-type header must be 'client', 'server', or 'admin', but was '${requestType}'.`,
+], (json) => [
+    json.details?.requestType ?? throwErr("requestType not found in InvalidRequestType details"),
+]);
+const RequestTypeWithoutProjectId = createKnownErrorConstructor(InvalidProjectAuthentication, "REQUEST_TYPE_WITHOUT_PROJECT_ID", (requestType) => [
+    400,
+    `The x-stack-request-type header was '${requestType}', but the x-stack-project-id header was not provided.`,
+    {
+        requestType,
+    },
+], (json) => [json.requestType]);
 const InvalidPublishableClientKey = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_PUBLISHABLE_CLIENT_KEY", () => [
     401,
     "The publishable key is not valid for the given project. Does the project and/or the key exist?",
@@ -114,6 +138,10 @@ const InvalidProjectForAdminAccessToken = createKnownErrorConstructor(InvalidAdm
     401,
     "Admin access token not valid for this project.",
 ], () => []);
+const AdminAccessTokenIsNotAdmin = createKnownErrorConstructor(InvalidAdminAccessToken, "ADMIN_ACCESS_TOKEN_IS_NOT_ADMIN", () => [
+    401,
+    "Admin access token does not have the required permissions to access this project.",
+], () => []);
 const ProjectAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationError, "PROJECT_AUTHENTICATION_REQUIRED", "inherit", "inherit");
 const ClientAuthenticationRequired = createKnownErrorConstructor(ProjectAuthenticationRequired, "CLIENT_AUTHENTICATION_REQUIRED", () => [
     401,
@@ -274,6 +302,9 @@ export const KnownErrors = {
     AllOverloadsFailed,
     ProjectAuthenticationError,
     InvalidProjectAuthentication,
+    ProjectKeyWithoutRequestType,
+    InvalidRequestType,
+    RequestTypeWithoutProjectId,
     InvalidPublishableClientKey,
     InvalidSecretServerKey,
     InvalidSuperSecretAdminKey,
@@ -281,6 +312,7 @@ export const KnownErrors = {
     UnparsableAdminAccessToken,
     AdminAccessTokenExpired,
     InvalidProjectForAdminAccessToken,
+    AdminAccessTokenIsNotAdmin,
     ProjectAuthenticationRequired,
     ClientAuthenticationRequired,
     ServerAuthenticationRequired,

package/dist/utils/errors.js

@@ -28,7 +28,12 @@ export function registerErrorSink(sink) {
     }
     errorSinks.add(sink);
 }
-registerErrorSink((location, ...args) => console.error(`Error in ${location}:`, ...args));
+registerErrorSink((location, ...args) => {
+    console.error(`Error in ${location}:`, ...args);
+    if (process.env.NODE_ENV === "development") {
+        debugger;
+    }
+});
 export function captureError(location, error) {
     for (const sink of errorSinks) {
         sink(location, error);

package/dist/utils/strings.d.ts

@@ -1,5 +1,6 @@
 export declare function typedToLowercase<S extends string>(s: S): Lowercase<S>;
 export declare function typedToUppercase<S extends string>(s: S): Uppercase<S>;
+export declare function typedCapitalize<S extends string>(s: S): Capitalize<S>;
 /**
  * Returns all whitespace character at the start of the string.
  *

package/dist/utils/strings.js

@@ -4,6 +4,9 @@ export function typedToLowercase(s) {
 export function typedToUppercase(s) {
     return s.toUpperCase();
 }
+export function typedCapitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
 /**
  * Returns all whitespace character at the start of the string.
  *

package/dist/utils/types.d.ts

@@ -0,0 +1 @@
+export type IsAny<T> = 0 extends (1 & T) ? true : false;

package/dist/utils/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.3.6",
+  "version": "2.4.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -8,7 +8,16 @@
     "dist"
   ],
   "peerDependencies": {
-    "react": "^18.2"
+    "react": "^18.2",
+    "yup": "^1.4.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "yup": {
+      "optional": true
+    }
   },
   "dependencies": {
     "bcrypt": "^5.1.1",