@stackframe/stack-shared 2.4.1 → 2.4.4

package/dist/crud.d.ts

@@ -0,0 +1,68 @@
+import * as yup from 'yup';
+import { NullishCoalesce } from './utils/types';
+export type CrudOperation = "create" | "read" | "update" | "delete";
+type InnerCrudSchema<CreateSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, ReadSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, UpdateSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, DeleteSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined> = {
+    createSchema: CreateSchema;
+    readSchema: ReadSchema;
+    updateSchema: UpdateSchema;
+    deleteSchema: DeleteSchema;
+};
+export type CrudSchema<ClientSchema extends InnerCrudSchema = InnerCrudSchema, ServerSchema extends InnerCrudSchema = InnerCrudSchema, AdminSchema extends InnerCrudSchema = InnerCrudSchema> = {
+    client: ClientSchema;
+    server: ServerSchema;
+    admin: AdminSchema;
+    hasCreate: boolean;
+    hasRead: boolean;
+    hasUpdate: boolean;
+    hasDelete: boolean;
+};
+type CrudSchemaCreationOptions = {
+    clientCreateSchema?: yup.Schema<any>;
+    clientReadSchema?: yup.Schema<any>;
+    clientUpdateSchema?: yup.Schema<any>;
+    clientDeleteSchema?: yup.Schema<any>;
+    serverCreateSchema?: yup.Schema<any>;
+    serverReadSchema?: yup.Schema<any>;
+    serverUpdateSchema?: yup.Schema<any>;
+    serverDeleteSchema?: yup.Schema<any>;
+    adminCreateSchema?: yup.Schema<any>;
+    adminReadSchema?: yup.Schema<any>;
+    adminUpdateSchema?: yup.Schema<any>;
+    adminDeleteSchema?: yup.Schema<any>;
+};
+type FillInOptionalsPrepareStep<O extends CrudSchemaCreationOptions> = {
+    [K in keyof Required<CrudSchemaCreationOptions>]: K extends keyof O ? O[K] : undefined;
+};
+type FillInOptionalsStep<O extends FillInOptionalsPrepareStep<CrudSchemaCreationOptions>> = {
+    clientCreateSchema: NullishCoalesce<O['clientCreateSchema'], undefined>;
+    clientReadSchema: NullishCoalesce<O['clientReadSchema'], undefined>;
+    clientUpdateSchema: NullishCoalesce<O['clientUpdateSchema'], undefined>;
+    clientDeleteSchema: NullishCoalesce<O['clientDeleteSchema'], undefined>;
+    serverCreateSchema: NullishCoalesce<O['serverCreateSchema'], O['clientCreateSchema']>;
+    serverReadSchema: NullishCoalesce<O['serverReadSchema'], O['clientReadSchema']>;
+    serverUpdateSchema: NullishCoalesce<O['serverUpdateSchema'], O['clientUpdateSchema']>;
+    serverDeleteSchema: NullishCoalesce<O['serverDeleteSchema'], O['clientDeleteSchema']>;
+    adminCreateSchema: NullishCoalesce<O['adminCreateSchema'], O['serverCreateSchema']>;
+    adminReadSchema: NullishCoalesce<O['adminReadSchema'], O['serverReadSchema']>;
+    adminUpdateSchema: NullishCoalesce<O['adminUpdateSchema'], O['serverUpdateSchema']>;
+    adminDeleteSchema: NullishCoalesce<O['adminDeleteSchema'], O['serverDeleteSchema']>;
+};
+type FillInOptionals<O extends CrudSchemaCreationOptions> = FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsPrepareStep<O>>>>;
+type CrudSchemaFromOptionsInner<O extends FillInOptionals<any>> = CrudSchema<InnerCrudSchema<O['clientCreateSchema'], O['clientReadSchema'], O['clientUpdateSchema'], O['clientDeleteSchema']>, InnerCrudSchema<O['serverCreateSchema'], O['serverReadSchema'], O['serverUpdateSchema'], O['serverDeleteSchema']>, InnerCrudSchema<O['adminCreateSchema'], O['adminReadSchema'], O['adminUpdateSchema'], O['adminDeleteSchema']>>;
+type CrudSchemaFromOptions<O extends CrudSchemaCreationOptions> = CrudSchemaFromOptionsInner<FillInOptionals<O>>;
+type InnerCrudTypeOf<S extends InnerCrudSchema> = (S['createSchema'] extends {} ? {
+    Create: yup.InferType<S['createSchema']>;
+} : {}) & (S['readSchema'] extends {} ? {
+    Read: yup.InferType<S['readSchema']>;
+} : {}) & (S['updateSchema'] extends {} ? {
+    Update: yup.InferType<S['updateSchema']>;
+} : {}) & (S['deleteSchema'] extends {} ? {
+    Delete: yup.InferType<S['deleteSchema']>;
+} : {});
+export type CrudTypeOf<S extends CrudSchema> = {
+    Client: InnerCrudTypeOf<S['client']>;
+    Server: InnerCrudTypeOf<S['server']>;
+    Admin: InnerCrudTypeOf<S['admin']>;
+};
+export declare function createCrud<O extends CrudSchemaCreationOptions>(options: O): CrudSchemaFromOptions<O>;
+export {};

package/dist/crud.js

@@ -0,0 +1,38 @@
+import { filterUndefined } from './utils/objects';
+export function createCrud(options) {
+    const client = {
+        createSchema: options.clientCreateSchema,
+        readSchema: options.clientReadSchema,
+        updateSchema: options.clientUpdateSchema,
+        deleteSchema: options.clientDeleteSchema,
+    };
+    const serverOverrides = filterUndefined({
+        createSchema: options.serverCreateSchema,
+        readSchema: options.serverReadSchema,
+        updateSchema: options.serverUpdateSchema,
+        deleteSchema: options.serverDeleteSchema,
+    });
+    const server = {
+        ...client,
+        ...serverOverrides,
+    };
+    const adminOverrides = filterUndefined({
+        createSchema: options.adminCreateSchema,
+        readSchema: options.adminReadSchema,
+        updateSchema: options.adminUpdateSchema,
+        deleteSchema: options.adminDeleteSchema,
+    });
+    const admin = {
+        ...server,
+        ...adminOverrides,
+    };
+    return {
+        client: client,
+        server: server,
+        admin: admin,
+        hasCreate: !!admin.createSchema,
+        hasRead: !!admin.readSchema,
+        hasUpdate: !!admin.updateSchema,
+        hasDelete: !!admin.deleteSchema,
+    };
+}

package/dist/interface/adminInterface.d.ts

@@ -17,6 +17,8 @@ export type OAuthProviderUpdateOptions = {
     tenantId?: string;
 });
 export type ProjectUpdateOptions = {
+    displayName?: string;
+    description?: string;
     isProductionMode?: boolean;
     config?: {
         domains?: {

package/dist/interface/clientInterface.d.ts

@@ -3,44 +3,46 @@ import { Result } from "../utils/results";
 import { ReadonlyJson } from '../utils/json';
 import { AsyncStore, ReadonlyAsyncStore } from '../utils/stores';
 import { KnownErrors } from '../known-errors';
+import { ProjectUpdateOptions } from './adminInterface';
 type UserCustomizableJson = {
-    readonly displayName: string | null;
-    readonly clientMetadata: ReadonlyJson;
+    displayName: string | null;
+    clientMetadata: ReadonlyJson;
 };
 export type UserJson = UserCustomizableJson & {
-    readonly projectId: string;
-    readonly id: string;
-    readonly primaryEmail: string | null;
-    readonly primaryEmailVerified: boolean;
-    readonly displayName: string | null;
-    readonly clientMetadata: ReadonlyJson;
-    readonly profileImageUrl: string | null;
-    readonly signedUpAtMillis: number;
+    projectId: string;
+    id: string;
+    primaryEmail: string | null;
+    primaryEmailVerified: boolean;
+    displayName: string | null;
+    clientMetadata: ReadonlyJson;
+    profileImageUrl: string | null;
+    signedUpAtMillis: number;
     /**
      * not used anymore, for backwards compatibility
      */
-    readonly authMethod: "credential" | "oauth";
-    readonly hasPassword: boolean;
-    readonly authWithEmail: boolean;
-    readonly oauthProviders: readonly string[];
+    authMethod: "credential" | "oauth";
+    hasPassword: boolean;
+    authWithEmail: boolean;
+    oauthProviders: string[];
 };
 export type UserUpdateJson = Partial<UserCustomizableJson>;
 export type ClientProjectJson = {
-    readonly id: string;
-    readonly credentialEnabled: boolean;
-    readonly magicLinkEnabled: boolean;
-    readonly oauthProviders: readonly {
+    id: string;
+    credentialEnabled: boolean;
+    magicLinkEnabled: boolean;
+    oauthProviders: {
         id: string;
         enabled: boolean;
     }[];
 };
 export type ClientInterfaceOptions = {
-    readonly baseUrl: string;
-    readonly projectId: string;
+    clientVersion: string;
+    baseUrl: string;
+    projectId: string;
 } & ({
-    readonly publishableClientKey: string;
+    publishableClientKey: string;
 } | {
-    readonly projectOwnerTokens: ReadonlyTokenStore;
+    projectOwnerTokens: ReadonlyTokenStore;
 });
 export type SharedProvider = "shared-github" | "shared-google" | "shared-facebook" | "shared-microsoft";
 export declare const sharedProviders: readonly ["shared-github", "shared-google", "shared-facebook", "shared-microsoft"];
@@ -179,7 +181,9 @@ export declare class StackClientInterface {
     getClientProject(): Promise<Result<ClientProjectJson>>;
     setClientUserCustomizableData(update: UserUpdateJson, tokenStore: TokenStore): Promise<void>;
     listProjects(tokenStore: TokenStore): Promise<ProjectJson[]>;
-    createProject(project: Pick<ProjectJson, "displayName" | "description">, tokenStore: TokenStore): Promise<ProjectJson>;
+    createProject(project: ProjectUpdateOptions & {
+        displayName: string;
+    }, tokenStore: TokenStore): Promise<ProjectJson>;
 }
 export declare function getProductionModeErrors(project: ProjectJson): ProductionModeError[];
 export {};

package/dist/interface/clientInterface.js

@@ -143,8 +143,13 @@ export class StackClientInterface {
                 "X-Stack-Override-Error-Status": "true",
                 "X-Stack-Project-Id": this.projectId,
                 "X-Stack-Request-Type": requestType,
+                "X-Stack-Client-Version": this.options.clientVersion,
                 ...tokenObj.accessToken ? {
                     "Authorization": "StackSession " + tokenObj.accessToken,
+                    "X-Stack-Access-Token": tokenObj.accessToken,
+                } : {},
+                ...tokenObj.refreshToken ? {
+                    "X-Stack-Refresh-Token": tokenObj.refreshToken,
                 } : {},
                 ...'publishableClientKey' in this.options ? {
                     "X-Stack-Publishable-Client-Key": this.options.publishableClientKey,
@@ -490,7 +495,7 @@ export class StackClientInterface {
 }
 export function getProductionModeErrors(project) {
     const errors = [];
-    const fixUrlRelative = `/projects/${project.id}/auth/urls-and-callbacks`;
+    const fixUrlRelative = `/projects/${project.id}/urls-and-callbacks`;
     if (project.evaluatedConfig.allowLocalhost) {
         errors.push({
             errorMessage: "Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings",

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

@@ -0,0 +1,143 @@
+import { CrudTypeOf } from "../../crud";
+import * as yup from "yup";
+export declare const currentUserCrud: {
+    client: {
+        createSchema: undefined;
+        readSchema: yup.ObjectSchema<{
+            displayName: string | null;
+            id: string;
+            projectId: string;
+            clientMetadata: {} | null;
+            primaryEmail: string | null;
+            primaryEmailVerified: NonNullable<boolean | undefined>;
+            profileImageUrl: string | null;
+            signedUpAtMillis: number;
+            authMethod: NonNullable<"credential" | "oauth" | undefined>;
+            hasPassword: NonNullable<boolean | undefined>;
+            authWithEmail: NonNullable<boolean | undefined>;
+            oauthProviders: string[];
+        } | null, yup.AnyObject, {
+            projectId: undefined;
+            id: undefined;
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+            displayName: undefined;
+            clientMetadata: {};
+            profileImageUrl: undefined;
+            signedUpAtMillis: undefined;
+            authMethod: undefined;
+            hasPassword: undefined;
+            authWithEmail: undefined;
+            oauthProviders: undefined;
+            serverMetadata: {};
+        }, "">;
+        updateSchema: yup.ObjectSchema<{
+            displayName: string | undefined;
+            clientMetadata: {} | undefined;
+        }, yup.AnyObject, {
+            displayName: undefined;
+            clientMetadata: {};
+            serverMetadata: {};
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+        }, "">;
+        deleteSchema: undefined;
+    };
+    server: {
+        createSchema: undefined;
+        readSchema: yup.ObjectSchema<{
+            projectId: string;
+            id: string;
+            primaryEmail: string | null;
+            primaryEmailVerified: NonNullable<boolean | undefined>;
+            displayName: string | null;
+            clientMetadata: {} | null;
+            profileImageUrl: string | null;
+            signedUpAtMillis: number;
+            authMethod: NonNullable<"credential" | "oauth" | undefined>;
+            hasPassword: NonNullable<boolean | undefined>;
+            authWithEmail: NonNullable<boolean | undefined>;
+            oauthProviders: string[];
+            serverMetadata: {} | null;
+        } | null, yup.AnyObject, {
+            projectId: undefined;
+            id: undefined;
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+            displayName: undefined;
+            clientMetadata: {};
+            profileImageUrl: undefined;
+            signedUpAtMillis: undefined;
+            authMethod: undefined;
+            hasPassword: undefined;
+            authWithEmail: undefined;
+            oauthProviders: undefined;
+            serverMetadata: {};
+        }, "">;
+        updateSchema: yup.ObjectSchema<{
+            displayName: string | undefined;
+            clientMetadata: {} | undefined;
+            serverMetadata: {} | undefined;
+            primaryEmail: string | undefined;
+            primaryEmailVerified: boolean | undefined;
+        }, yup.AnyObject, {
+            displayName: undefined;
+            clientMetadata: {};
+            serverMetadata: {};
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+        }, "">;
+        deleteSchema: undefined;
+    };
+    admin: {
+        createSchema: undefined;
+        readSchema: yup.ObjectSchema<{
+            projectId: string;
+            id: string;
+            primaryEmail: string | null;
+            primaryEmailVerified: NonNullable<boolean | undefined>;
+            displayName: string | null;
+            clientMetadata: {} | null;
+            profileImageUrl: string | null;
+            signedUpAtMillis: number;
+            authMethod: NonNullable<"credential" | "oauth" | undefined>;
+            hasPassword: NonNullable<boolean | undefined>;
+            authWithEmail: NonNullable<boolean | undefined>;
+            oauthProviders: string[];
+            serverMetadata: {} | null;
+        } | null, yup.AnyObject, {
+            projectId: undefined;
+            id: undefined;
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+            displayName: undefined;
+            clientMetadata: {};
+            profileImageUrl: undefined;
+            signedUpAtMillis: undefined;
+            authMethod: undefined;
+            hasPassword: undefined;
+            authWithEmail: undefined;
+            oauthProviders: undefined;
+            serverMetadata: {};
+        }, "">;
+        updateSchema: yup.ObjectSchema<{
+            displayName: string | undefined;
+            clientMetadata: {} | undefined;
+            serverMetadata: {} | undefined;
+            primaryEmail: string | undefined;
+            primaryEmailVerified: boolean | undefined;
+        }, yup.AnyObject, {
+            displayName: undefined;
+            clientMetadata: {};
+            serverMetadata: {};
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+        }, "">;
+        deleteSchema: undefined;
+    };
+    hasCreate: boolean;
+    hasRead: boolean;
+    hasUpdate: boolean;
+    hasDelete: boolean;
+};
+export type CurrentUserCrud = CrudTypeOf<typeof currentUserCrud>;

package/dist/interface/crud/current-user.js

@@ -0,0 +1,28 @@
+import { createCrud } from "../../crud";
+import { usersCrudServerReadSchema, usersCrudServerUpdateSchema } from "./users";
+const clientUpdateSchema = usersCrudServerUpdateSchema.pick([
+    "displayName",
+    "clientMetadata",
+]).required();
+const serverUpdateSchema = usersCrudServerUpdateSchema;
+const clientReadSchema = usersCrudServerReadSchema.pick([
+    "projectId",
+    "id",
+    "primaryEmail",
+    "primaryEmailVerified",
+    "displayName",
+    "clientMetadata",
+    "profileImageUrl",
+    "signedUpAtMillis",
+    "authMethod",
+    "hasPassword",
+    "authWithEmail",
+    "oauthProviders",
+]).nullable().defined();
+const serverReadSchema = usersCrudServerReadSchema.nullable().defined();
+export const currentUserCrud = createCrud({
+    clientReadSchema,
+    serverReadSchema,
+    clientUpdateSchema,
+    serverUpdateSchema,
+});

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

@@ -0,0 +1,149 @@
+import { CrudTypeOf } from "../../crud";
+import * as yup from "yup";
+export declare const usersCrudServerUpdateSchema: yup.ObjectSchema<{
+    displayName: string | undefined;
+    clientMetadata: {} | undefined;
+    serverMetadata: {} | undefined;
+    primaryEmail: string | undefined;
+    primaryEmailVerified: boolean | undefined;
+}, yup.AnyObject, {
+    displayName: undefined;
+    clientMetadata: {};
+    serverMetadata: {};
+    primaryEmail: undefined;
+    primaryEmailVerified: undefined;
+}, "">;
+export declare const usersCrudServerReadSchema: yup.ObjectSchema<{
+    projectId: string;
+    id: string;
+    primaryEmail: string | null;
+    primaryEmailVerified: NonNullable<boolean | undefined>;
+    displayName: string | null;
+    clientMetadata: {} | null;
+    profileImageUrl: string | null;
+    signedUpAtMillis: number;
+    authMethod: NonNullable<"credential" | "oauth" | undefined>;
+    hasPassword: NonNullable<boolean | undefined>;
+    authWithEmail: NonNullable<boolean | undefined>;
+    oauthProviders: string[];
+    serverMetadata: {} | null;
+}, yup.AnyObject, {
+    projectId: undefined;
+    id: undefined;
+    primaryEmail: undefined;
+    primaryEmailVerified: undefined;
+    displayName: undefined;
+    clientMetadata: {};
+    profileImageUrl: undefined;
+    signedUpAtMillis: undefined;
+    authMethod: undefined;
+    hasPassword: undefined;
+    authWithEmail: undefined;
+    oauthProviders: undefined;
+    serverMetadata: {};
+}, "">;
+export declare const usersCrud: {
+    client: {
+        createSchema: undefined;
+        readSchema: undefined;
+        updateSchema: undefined;
+        deleteSchema: undefined;
+    };
+    server: {
+        createSchema: undefined;
+        readSchema: yup.ObjectSchema<{
+            projectId: string;
+            id: string;
+            primaryEmail: string | null;
+            primaryEmailVerified: NonNullable<boolean | undefined>;
+            displayName: string | null;
+            clientMetadata: {} | null;
+            profileImageUrl: string | null;
+            signedUpAtMillis: number;
+            authMethod: NonNullable<"credential" | "oauth" | undefined>;
+            hasPassword: NonNullable<boolean | undefined>;
+            authWithEmail: NonNullable<boolean | undefined>;
+            oauthProviders: string[];
+            serverMetadata: {} | null;
+        }, yup.AnyObject, {
+            projectId: undefined;
+            id: undefined;
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+            displayName: undefined;
+            clientMetadata: {};
+            profileImageUrl: undefined;
+            signedUpAtMillis: undefined;
+            authMethod: undefined;
+            hasPassword: undefined;
+            authWithEmail: undefined;
+            oauthProviders: undefined;
+            serverMetadata: {};
+        }, "">;
+        updateSchema: yup.ObjectSchema<{
+            displayName: string | undefined;
+            clientMetadata: {} | undefined;
+            serverMetadata: {} | undefined;
+            primaryEmail: string | undefined;
+            primaryEmailVerified: boolean | undefined;
+        }, yup.AnyObject, {
+            displayName: undefined;
+            clientMetadata: {};
+            serverMetadata: {};
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+        }, "">;
+        deleteSchema: yup.MixedSchema<{} | undefined, yup.AnyObject, undefined, "">;
+    };
+    admin: {
+        createSchema: undefined;
+        readSchema: yup.ObjectSchema<{
+            projectId: string;
+            id: string;
+            primaryEmail: string | null;
+            primaryEmailVerified: NonNullable<boolean | undefined>;
+            displayName: string | null;
+            clientMetadata: {} | null;
+            profileImageUrl: string | null;
+            signedUpAtMillis: number;
+            authMethod: NonNullable<"credential" | "oauth" | undefined>;
+            hasPassword: NonNullable<boolean | undefined>;
+            authWithEmail: NonNullable<boolean | undefined>;
+            oauthProviders: string[];
+            serverMetadata: {} | null;
+        }, yup.AnyObject, {
+            projectId: undefined;
+            id: undefined;
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+            displayName: undefined;
+            clientMetadata: {};
+            profileImageUrl: undefined;
+            signedUpAtMillis: undefined;
+            authMethod: undefined;
+            hasPassword: undefined;
+            authWithEmail: undefined;
+            oauthProviders: undefined;
+            serverMetadata: {};
+        }, "">;
+        updateSchema: yup.ObjectSchema<{
+            displayName: string | undefined;
+            clientMetadata: {} | undefined;
+            serverMetadata: {} | undefined;
+            primaryEmail: string | undefined;
+            primaryEmailVerified: boolean | undefined;
+        }, yup.AnyObject, {
+            displayName: undefined;
+            clientMetadata: {};
+            serverMetadata: {};
+            primaryEmail: undefined;
+            primaryEmailVerified: undefined;
+        }, "">;
+        deleteSchema: yup.MixedSchema<{} | undefined, yup.AnyObject, undefined, "">;
+    };
+    hasCreate: boolean;
+    hasRead: boolean;
+    hasUpdate: boolean;
+    hasDelete: boolean;
+};
+export type UsersCrud = CrudTypeOf<typeof usersCrud>;

package/dist/interface/crud/users.js

@@ -0,0 +1,33 @@
+import { createCrud } from "../../crud";
+import * as yup from "yup";
+export const usersCrudServerUpdateSchema = yup.object({
+    displayName: yup.string().optional(),
+    clientMetadata: yup.object().optional(),
+    serverMetadata: yup.object().optional(),
+    primaryEmail: yup.string().optional(),
+    primaryEmailVerified: yup.boolean().optional(),
+}).required();
+export const usersCrudServerReadSchema = yup.object({
+    projectId: yup.string().required(),
+    id: yup.string().required(),
+    primaryEmail: yup.string().nullable().defined(),
+    primaryEmailVerified: yup.boolean().required(),
+    displayName: yup.string().nullable().defined(),
+    clientMetadata: yup.object().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value))),
+    profileImageUrl: yup.string().nullable().defined(),
+    signedUpAtMillis: yup.number().required(),
+    /**
+     * not used anymore, for backwards compatibility
+     */
+    authMethod: yup.string().oneOf(["credential", "oauth"]).required(),
+    hasPassword: yup.boolean().required(),
+    authWithEmail: yup.boolean().required(),
+    oauthProviders: yup.array(yup.string().required()).required(),
+    serverMetadata: yup.object().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value))),
+}).required();
+const serverDeleteSchema = yup.mixed();
+export const usersCrud = createCrud({
+    serverReadSchema: usersCrudServerReadSchema,
+    serverUpdateSchema: usersCrudServerUpdateSchema,
+    serverDeleteSchema,
+});

package/dist/interface/serverInterface.d.ts

@@ -2,12 +2,12 @@ import { ClientInterfaceOptions, UserJson, TokenStore, StackClientInterface, Rea
 import { Result } from "../utils/results";
 import { ReadonlyJson } from "../utils/json";
 export type ServerUserJson = UserJson & {
-    readonly serverMetadata: ReadonlyJson;
+    serverMetadata: ReadonlyJson;
 };
 export type ServerUserUpdateJson = UserUpdateJson & {
-    readonly serverMetadata?: ReadonlyJson;
-    readonly primaryEmail?: string | null;
-    readonly primaryEmailVerified?: boolean;
+    serverMetadata?: ReadonlyJson;
+    primaryEmail?: string | null;
+    primaryEmailVerified?: boolean;
 };
 export type ServerOrglikeCustomizableJson = Pick<ServerOrglikeJson, "displayName">;
 export type ServerOrglikeJson = OrglikeJson & {};

package/dist/known-errors.d.ts

@@ -47,6 +47,9 @@ export declare const KnownErrors: {
     UnsupportedError: KnownErrorConstructor<KnownError & KnownErrorBrand<"UNSUPPORTED_ERROR">, [originalErrorCode: string]> & {
         errorCode: "UNSUPPORTED_ERROR";
     };
+    BodyParsingError: KnownErrorConstructor<KnownError & KnownErrorBrand<"BODY_PARSING_ERROR">, [string]> & {
+        errorCode: "BODY_PARSING_ERROR";
+    };
     SchemaError: KnownErrorConstructor<KnownError & KnownErrorBrand<"SCHEMA_ERROR">, [string]> & {
         errorCode: "SCHEMA_ERROR";
     };

package/dist/known-errors.js

@@ -75,6 +75,10 @@ const UnsupportedError = createKnownErrorConstructor(KnownError, "UNSUPPORTED_ER
 ], (json) => [
     json.details?.originalErrorCode ?? throwErr("originalErrorCode not found in UnsupportedError details"),
 ]);
+const BodyParsingError = createKnownErrorConstructor(KnownError, "BODY_PARSING_ERROR", (message) => [
+    400,
+    message,
+], (json) => [json.message]);
 const SchemaError = createKnownErrorConstructor(KnownError, "SCHEMA_ERROR", (message) => [
     400,
     message,
@@ -89,7 +93,7 @@ const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOAD
         `).join("\n\n")}
     `,
     {
-        overloads: overloadErrors,
+        overloadErrors,
     },
 ], (json) => [
     json.details?.overloadErrors ?? throwErr("overloadErrors not found in AllOverloadsFailed details"),
@@ -335,6 +339,7 @@ const TeamNotFound = createKnownErrorConstructor(KnownError, "TEAM_NOT_FOUND", (
 ], (json) => [json.details.teamId]);
 export const KnownErrors = {
     UnsupportedError,
+    BodyParsingError,
     SchemaError,
     AllOverloadsFailed,
     ProjectAuthenticationError,

package/dist/utils/arrays.d.ts

@@ -8,3 +8,4 @@ export declare function range(startInclusive: number, endExclusive: number, step
 export declare function rotateLeft(arr: readonly any[], n: number): any[];
 export declare function rotateRight(arr: readonly any[], n: number): any[];
 export declare function shuffle<T>(arr: readonly T[]): T[];
+export declare function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];

package/dist/utils/arrays.js

@@ -52,3 +52,6 @@ export function shuffle(arr) {
     }
     return result;
 }
+export function outerProduct(arr1, arr2) {
+    return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
+}

package/dist/utils/dom.d.ts

@@ -1,4 +1 @@
-/**
- * https://n2d4.github.io/frontend-starter/guides/advanced-concepts#clickable-parents
- */
 export declare function hasClickableParent(element: HTMLElement): boolean;

package/dist/utils/dom.js

@@ -1,6 +1,3 @@
-/**
- * https://n2d4.github.io/frontend-starter/guides/advanced-concepts#clickable-parents
- */
 export function hasClickableParent(element) {
     const parent = element.parentElement;
     if (!parent)

package/dist/utils/errors.d.ts

@@ -4,7 +4,6 @@ export declare function throwErr(error: Error): never;
 export declare function throwErr(...args: StatusErrorConstructorParameters): never;
 export declare class StackAssertionError extends Error {
     readonly extraData?: Record<string, any> | undefined;
-    name: string;
     constructor(message: string, extraData?: Record<string, any> | undefined, options?: ErrorOptions);
 }
 export declare function throwStackErr(message: string, extraData?: any): never;

package/dist/utils/errors.js

@@ -12,12 +12,13 @@ export function throwErr(...args) {
 }
 export class StackAssertionError extends Error {
     extraData;
-    name = "StackAssertionError";
     constructor(message, extraData, options) {
-        super(`${message}\n\nThis is likely an error in Stack. Please report it.`, options);
+        const disclaimer = `\n\nThis is likely an error in Stack. Please report it.`;
+        super(`${message}${message.endsWith(disclaimer) ? "" : disclaimer}`, options);
         this.extraData = extraData;
     }
 }
+StackAssertionError.prototype.name = "StackAssertionError";
 export function throwStackErr(message, extraData) {
     throw new StackAssertionError(message, extraData);
 }
@@ -30,9 +31,6 @@ export function registerErrorSink(sink) {
 }
 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) {

package/dist/utils/objects.d.ts

@@ -12,12 +12,15 @@ export declare function typedFromEntries<K extends PropertyKey, V>(entries: [K,
 export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
 export declare function typedValues<T extends {}>(obj: T): T[keyof T][];
 export declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): asserts target is T & U;
+export type FilterUndefined<T> = {
+    [k in keyof T as (undefined extends T[k] ? (T[k] extends undefined | void ? never : k) : never)]+?: T[k] & ({} | null);
+} & {
+    [k in keyof T as (undefined extends T[k] ? never : k)]: T[k] & ({} | null);
+};
 /**
  * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
  * TypeScript's `Partial<XYZ>` type allows `undefined` values.
  */
-export declare function filterUndefined<T extends {}>(obj: T): {
-    [k in keyof T]+?: T[k] & ({} | null);
-};
+export declare function filterUndefined<T extends {}>(obj: T): FilterUndefined<T>;
 export declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 export declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/dist/utils/types.d.ts

@@ -1 +1,3 @@
 export type IsAny<T> = 0 extends (1 & T) ? true : false;
+export type isNullish<T> = T extends null | undefined ? true : false;
+export type NullishCoalesce<T, U> = T extends null | undefined ? U : T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.4.1",
+  "version": "2.4.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -24,7 +24,7 @@
     "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "1.5.1"
+    "@stackframe/stack-sc": "1.5.2"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",