@stackframe/stack-shared 2.7.27 → 2.7.29

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @stackframe/stack-shared
 
+## 2.7.29
+
+### Patch Changes
+
+- Various changes
+
+## 2.7.28
+
+### Patch Changes
+
+- Various changes
+
 ## 2.7.27
 
 ### Patch Changes

package/dist/interface/clientInterface.d.ts

@@ -15,6 +15,7 @@ import { TeamsCrud } from './crud/teams';
 export type ClientInterfaceOptions = {
     clientVersion: string;
     getBaseUrl: () => string;
+    extraRequestHeaders: Record<string, string>;
     projectId: string;
     prepareRequest?: () => Promise<void>;
 } & ({
@@ -115,7 +116,7 @@ export declare class StackClientInterface {
     signUpWithCredential(email: string, password: string, emailVerificationRedirectUrl: string, session: InternalSession): Promise<Result<{
         accessToken: string;
         refreshToken: string;
-    }, KnownErrors["UserEmailAlreadyExists"] | KnownErrors["PasswordRequirementsNotMet"]>>;
+    }, KnownErrors["UserWithEmailAlreadyExists"] | KnownErrors["PasswordRequirementsNotMet"]>>;
     signInWithMagicLink(code: string): Promise<Result<{
         newUser: boolean;
         accessToken: string;

package/dist/interface/clientInterface.js

@@ -212,6 +212,7 @@ export class StackClientInterface {
                  * the case (I haven't actually tested.)
                  */
                 "X-Stack-Random-Nonce": generateSecureRandomString(),
+                ...this.options.extraRequestHeaders,
                 ...options.headers,
             },
             /**
@@ -565,7 +566,7 @@ export class StackClientInterface {
                 password,
                 verification_callback_url: emailVerificationRedirectUrl,
             }),
-        }, session, [KnownErrors.UserEmailAlreadyExists, KnownErrors.PasswordRequirementsNotMet]);
+        }, session, [KnownErrors.UserWithEmailAlreadyExists, KnownErrors.PasswordRequirementsNotMet]);
         if (res.status === "error") {
             return Result.error(res.error);
         }

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

@@ -4,30 +4,60 @@ export declare const sentEmailReadSchema: import("yup").ObjectSchema<{
     subject: string;
     sent_at_millis: number;
     to: string[] | undefined;
-    sender_config: {} | null;
+    sender_config: {
+        host?: string | undefined;
+        port?: number | undefined;
+        username?: string | undefined;
+        sender_name?: string | undefined;
+        sender_email?: string | undefined;
+        type: "shared" | "standard";
+    };
     error: {} | null | undefined;
 }, import("yup").AnyObject, {
     id: undefined;
     subject: undefined;
     sent_at_millis: undefined;
     to: undefined;
-    sender_config: undefined;
+    sender_config: {
+        type: undefined;
+        host: undefined;
+        port: undefined;
+        username: undefined;
+        password: undefined;
+        sender_name: undefined;
+        sender_email: undefined;
+    };
     error: undefined;
 }, "">;
 export declare const internalEmailsCrud: import("../../crud").CrudSchemaFromOptions<{
-    clientReadSchema: import("yup").ObjectSchema<{
+    adminReadSchema: import("yup").ObjectSchema<{
         id: string;
         subject: string;
         sent_at_millis: number;
         to: string[] | undefined;
-        sender_config: {} | null;
+        sender_config: {
+            host?: string | undefined;
+            port?: number | undefined;
+            username?: string | undefined;
+            sender_name?: string | undefined;
+            sender_email?: string | undefined;
+            type: "shared" | "standard";
+        };
         error: {} | null | undefined;
     }, import("yup").AnyObject, {
         id: undefined;
         subject: undefined;
         sent_at_millis: undefined;
         to: undefined;
-        sender_config: undefined;
+        sender_config: {
+            type: undefined;
+            host: undefined;
+            port: undefined;
+            username: undefined;
+            password: undefined;
+            sender_name: undefined;
+            sender_email: undefined;
+        };
         error: undefined;
     }, "">;
 }>;

package/dist/interface/crud/emails.js

@@ -1,13 +1,14 @@
 import { createCrud } from "../../crud";
 import * as fieldSchema from "../../schema-fields";
+import { emailConfigWithoutPasswordSchema } from "./projects";
 export const sentEmailReadSchema = fieldSchema.yupObject({
     id: fieldSchema.yupString().defined(),
     subject: fieldSchema.yupString().defined(),
     sent_at_millis: fieldSchema.yupNumber().defined(),
     to: fieldSchema.yupArray(fieldSchema.yupString().defined()),
-    sender_config: fieldSchema.yupMixed().nullable().defined(),
+    sender_config: emailConfigWithoutPasswordSchema.defined(),
     error: fieldSchema.yupMixed().nullable().optional(),
 }).defined();
 export const internalEmailsCrud = createCrud({
-    clientReadSchema: sentEmailReadSchema,
+    adminReadSchema: sentEmailReadSchema,
 });

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

@@ -16,6 +16,22 @@ export declare const emailConfigSchema: import("yup").ObjectSchema<{
     sender_name: undefined;
     sender_email: undefined;
 }, "">;
+export declare const emailConfigWithoutPasswordSchema: import("yup").ObjectSchema<{
+    type: "shared" | "standard";
+    host: string | undefined;
+    port: number | undefined;
+    username: string | undefined;
+    sender_name: string | undefined;
+    sender_email: string | undefined;
+}, import("yup").AnyObject, {
+    type: undefined;
+    host: undefined;
+    port: undefined;
+    username: undefined;
+    password: undefined;
+    sender_name: undefined;
+    sender_email: undefined;
+}, "">;
 export declare const projectsCrudAdminReadSchema: import("yup").ObjectSchema<{
     id: string;
     display_name: string;

package/dist/interface/crud/projects.js

@@ -44,6 +44,7 @@ export const emailConfigSchema = yupObject({
         type: 'standard',
     }),
 });
+export const emailConfigWithoutPasswordSchema = emailConfigSchema.pick(['type', 'host', 'port', 'username', 'sender_name', 'sender_email']);
 const domainSchema = yupObject({
     domain: schemaFields.urlSchema.defined()
         .matches(/^https?:\/\//, 'URL must start with http:// or https://')

package/dist/interface/serverInterface.d.ts

@@ -103,4 +103,8 @@ export declare class StackServerInterface extends StackClientInterface {
         teamId: string;
         callbackUrl: string;
     }): Promise<void>;
+    updatePassword(options: {
+        oldPassword: string;
+        newPassword: string;
+    }): Promise<KnownErrors["PasswordConfirmationMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
 }

package/dist/interface/serverInterface.js

@@ -311,4 +311,19 @@ export class StackServerInterface extends StackClientInterface {
             }),
         }, null);
     }
+    async updatePassword(options) {
+        const res = await this.sendServerRequestAndCatchKnownError("/auth/password/update", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                old_password: options.oldPassword,
+                new_password: options.newPassword,
+            }),
+        }, null, [KnownErrors.PasswordConfirmationMismatch, KnownErrors.PasswordRequirementsNotMet]);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
 }

package/dist/known-errors.d.ts

@@ -204,7 +204,7 @@ export declare const KnownErrors: {
     };
     InvalidProjectForAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"INVALID_PROJECT_FOR_ACCESS_TOKEN">, []> & {
+    } & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"INVALID_PROJECT_FOR_ACCESS_TOKEN">, [expectedProjectId: string, actualProjectId: string]> & {
         errorCode: "INVALID_PROJECT_FOR_ACCESS_TOKEN";
     };
     RefreshTokenError: KnownErrorConstructor<KnownError & KnownErrorBrand<"REFRESH_TOKEN_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
@@ -220,7 +220,7 @@ export declare const KnownErrors: {
     } & KnownErrorBrand<"REFRESH_TOKEN_NOT_FOUND_OR_EXPIRED">, []> & {
         errorCode: "REFRESH_TOKEN_NOT_FOUND_OR_EXPIRED";
     };
-    UserEmailAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"USER_EMAIL_ALREADY_EXISTS">, []> & {
+    UserWithEmailAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"USER_EMAIL_ALREADY_EXISTS">, [email: string]> & {
         errorCode: "USER_EMAIL_ALREADY_EXISTS";
     };
     EmailNotVerified: KnownErrorConstructor<KnownError & KnownErrorBrand<"EMAIL_NOT_VERIFIED">, []> & {

package/dist/known-errors.js

@@ -246,10 +246,14 @@ const AccessTokenExpired = createKnownErrorConstructor(InvalidAccessToken, "ACCE
     `Access token has expired. Please refresh it and try again.${expiredAt ? ` (The access token expired at ${expiredAt.toISOString()}.)` : ""}`,
     { expired_at_millis: expiredAt?.getTime() ?? null },
 ], (json) => [json.expired_at_millis ? new Date(json.expired_at_millis) : undefined]);
-const InvalidProjectForAccessToken = createKnownErrorConstructor(InvalidAccessToken, "INVALID_PROJECT_FOR_ACCESS_TOKEN", () => [
+const InvalidProjectForAccessToken = createKnownErrorConstructor(InvalidAccessToken, "INVALID_PROJECT_FOR_ACCESS_TOKEN", (expectedProjectId, actualProjectId) => [
     401,
-    "Access token not valid for this project.",
-], () => []);
+    `Access token not valid for this project. Expected project ID ${JSON.stringify(expectedProjectId)}, but the token is for project ID ${JSON.stringify(actualProjectId)}.`,
+    {
+        expected_project_id: expectedProjectId,
+        actual_project_id: actualProjectId,
+    },
+], (json) => [json.expected_project_id, json.actual_project_id]);
 const RefreshTokenError = createKnownErrorConstructor(KnownError, "REFRESH_TOKEN_ERROR", "inherit", "inherit");
 const RefreshTokenNotFoundOrExpired = createKnownErrorConstructor(RefreshTokenError, "REFRESH_TOKEN_NOT_FOUND_OR_EXPIRED", () => [
     401,
@@ -263,10 +267,13 @@ const ProviderRejected = createKnownErrorConstructor(RefreshTokenError, "PROVIDE
     401,
     "The provider refused to refresh their token. This usually means that the provider used to authenticate the user no longer regards this session as valid, and the user must re-authenticate.",
 ], () => []);
-const UserEmailAlreadyExists = createKnownErrorConstructor(KnownError, "USER_EMAIL_ALREADY_EXISTS", () => [
+const UserWithEmailAlreadyExists = createKnownErrorConstructor(KnownError, "USER_EMAIL_ALREADY_EXISTS", (email) => [
     409,
-    "User email already exists.",
-], () => []);
+    `A user with email ${JSON.stringify(email)} already exists.`,
+    {
+        email,
+    },
+], (json) => [json.email]);
 const EmailNotVerified = createKnownErrorConstructor(KnownError, "EMAIL_NOT_VERIFIED", () => [
     400,
     "The email is not verified.",
@@ -590,7 +597,7 @@ export const KnownErrors = {
     RefreshTokenError,
     ProviderRejected,
     RefreshTokenNotFoundOrExpired,
-    UserEmailAlreadyExists,
+    UserWithEmailAlreadyExists,
     EmailNotVerified,
     UserIdDoesNotExist,
     UserNotFound,

package/package.json

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