@stackframe/stack-shared 2.7.0 → 2.7.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @stackframe/stack-shared
 
+## 2.7.1
+
+### Patch Changes
+
+- Various changes
+  - @stackframe/stack-sc@2.7.1
+
 ## 2.7.0
 
 ### Minor Changes

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

@@ -1,6 +1,6 @@
 import { CrudTypeOf } from "../../crud";
 export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions<{
-    clientReadSchema: import("yup").ObjectSchema<({
+    clientReadSchema: import("yup").ObjectSchema<{
         primary_email: string | null;
         id: string;
         display_name: string | null;
@@ -28,7 +28,7 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
             display_name: string;
             profile_image_url: string | null;
         } | null;
-    }) | null, import("yup").AnyObject, {
+    }, import("yup").AnyObject, {
         id: undefined;
         primary_email: undefined;
         primary_email_verified: undefined;
@@ -87,7 +87,7 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
         }[];
         auth_with_email: boolean;
         requires_totp_mfa: boolean;
-    } | null, import("yup").AnyObject, {
+    }, import("yup").AnyObject, {
         id: undefined;
         primary_email: undefined;
         primary_email_verified: undefined;

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

@@ -30,9 +30,8 @@ const clientReadSchema = usersCrudServerReadSchema.pick([
     "passkey_auth_enabled",
 ]).concat(yupObject({
     selected_team: teamsCrudClientReadSchema.nullable().defined(),
-})).nullable().defined(); // TODO: next-release: make required
-// TODO: next-release: make required
-const serverReadSchema = usersCrudServerReadSchema.nullable().defined();
+})).defined();
+const serverReadSchema = usersCrudServerReadSchema.defined();
 const clientDeleteSchema = usersCrudServerDeleteSchema;
 export const currentUserCrud = createCrud({
     clientReadSchema,

package/dist/interface/crud/projects.js

@@ -1,6 +1,6 @@
 import { createCrud } from "../../crud";
 import * as schemaFields from "../../schema-fields";
-import { yupArray, yupDefinedWhen, yupObject, yupString } from "../../schema-fields";
+import { yupArray, yupObject, yupString } from "../../schema-fields";
 const teamPermissionSchema = yupObject({
     id: yupString().defined(),
 }).defined();
@@ -8,8 +8,14 @@ const oauthProviderSchema = yupObject({
     id: schemaFields.oauthIdSchema.defined(),
     enabled: schemaFields.oauthEnabledSchema.defined(),
     type: schemaFields.oauthTypeSchema.defined(),
-    client_id: yupDefinedWhen(schemaFields.oauthClientIdSchema, 'type', 'standard'),
-    client_secret: yupDefinedWhen(schemaFields.oauthClientSecretSchema, 'type', 'standard'),
+    client_id: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.oauthClientIdSchema, {
+        type: 'standard',
+        enabled: true,
+    }),
+    client_secret: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.oauthClientSecretSchema, {
+        type: 'standard',
+        enabled: true,
+    }),
     // extra params
     facebook_config_id: schemaFields.oauthFacebookConfigIdSchema.optional(),
     microsoft_tenant_id: schemaFields.oauthMicrosoftTenantIdSchema.optional(),
@@ -19,12 +25,24 @@ const enabledOAuthProviderSchema = yupObject({
 });
 export const emailConfigSchema = yupObject({
     type: schemaFields.emailTypeSchema.defined(),
-    host: yupDefinedWhen(schemaFields.emailHostSchema, 'type', 'standard'),
-    port: yupDefinedWhen(schemaFields.emailPortSchema, 'type', 'standard'),
-    username: yupDefinedWhen(schemaFields.emailUsernameSchema, 'type', 'standard'),
-    password: yupDefinedWhen(schemaFields.emailPasswordSchema, 'type', 'standard'),
-    sender_name: yupDefinedWhen(schemaFields.emailSenderNameSchema, 'type', 'standard'),
-    sender_email: yupDefinedWhen(schemaFields.emailSenderEmailSchema, 'type', 'standard'),
+    host: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailHostSchema, {
+        type: 'standard',
+    }),
+    port: schemaFields.yupDefinedWhen(schemaFields.emailPortSchema, {
+        type: 'standard',
+    }),
+    username: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailUsernameSchema, {
+        type: 'standard',
+    }),
+    password: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailPasswordSchema, {
+        type: 'standard',
+    }),
+    sender_name: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderNameSchema, {
+        type: 'standard',
+    }),
+    sender_email: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderEmailSchema, {
+        type: 'standard',
+    }),
 });
 const domainSchema = yupObject({
     domain: schemaFields.projectTrustedDomainSchema.defined(),

package/dist/known-errors.d.ts

@@ -66,21 +66,6 @@ export declare const KnownErrors: {
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "INVALID_PROJECT_AUTHENTICATION";
     };
-    ProjectKeyWithoutRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"PROJECT_KEY_WITHOUT_REQUEST_TYPE">, []> & {
-        errorCode: "PROJECT_KEY_WITHOUT_REQUEST_TYPE";
-    };
-    InvalidRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_REQUEST_TYPE">, [requestType: string]> & {
-        errorCode: "INVALID_REQUEST_TYPE";
-    };
-    RequestTypeWithoutProjectId: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"REQUEST_TYPE_WITHOUT_PROJECT_ID">, [requestType: "client" | "server" | "admin"]> & {
-        errorCode: "REQUEST_TYPE_WITHOUT_PROJECT_ID";
-    };
     ProjectKeyWithoutAccessType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"PROJECT_KEY_WITHOUT_ACCESS_TYPE">, []> & {

package/dist/known-errors.js

@@ -105,35 +105,6 @@ const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOAD
 ]);
 const ProjectAuthenticationError = createKnownErrorConstructor(KnownError, "PROJECT_AUTHENTICATION_ERROR", "inherit", "inherit");
 const InvalidProjectAuthentication = createKnownErrorConstructor(ProjectAuthenticationError, "INVALID_PROJECT_AUTHENTICATION", "inherit", "inherit");
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use ProjectKeyWithoutAccessType instead
- */
-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-access-type header is missing. Set it to 'client', 'server', or 'admin' as appropriate.",
-], () => []);
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use InvalidAccessType instead
- */
-const InvalidRequestType = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_REQUEST_TYPE", (requestType) => [
-    400,
-    `The x-stack-access-type header must be 'client', 'server', or 'admin', but was '${requestType}'.`,
-], (json) => [
-    json?.requestType ?? throwErr("requestType not found in InvalidRequestType details"),
-]);
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use AccessTypeWithoutProjectId instead
- */
-const RequestTypeWithoutProjectId = createKnownErrorConstructor(InvalidProjectAuthentication, "REQUEST_TYPE_WITHOUT_PROJECT_ID", (requestType) => [
-    400,
-    `The x-stack-access-type header was '${requestType}', but the x-stack-project-id header was not provided.`,
-    {
-        request_type: requestType,
-    },
-], (json) => [json.request_type]);
 const ProjectKeyWithoutAccessType = createKnownErrorConstructor(InvalidProjectAuthentication, "PROJECT_KEY_WITHOUT_ACCESS_TYPE", () => [
     400,
     "Either an API key or an admin access token was provided, but the x-stack-access-type header is missing. Set it to 'client', 'server', or 'admin' as appropriate.",
@@ -288,7 +259,7 @@ const ProviderRejected = createKnownErrorConstructor(RefreshTokenError, "PROVIDE
 ], () => []);
 const UserEmailAlreadyExists = createKnownErrorConstructor(KnownError, "USER_EMAIL_ALREADY_EXISTS", () => [
     400,
-    "User already exists.",
+    "User email already exists.",
 ], () => []);
 const CannotGetOwnUserWithoutUser = createKnownErrorConstructor(KnownError, "CANNOT_GET_OWN_USER_WITHOUT_USER", () => [
     400,
@@ -570,9 +541,6 @@ export const KnownErrors = {
     AllOverloadsFailed,
     ProjectAuthenticationError,
     InvalidProjectAuthentication,
-    ProjectKeyWithoutRequestType,
-    InvalidRequestType,
-    RequestTypeWithoutProjectId,
     ProjectKeyWithoutAccessType,
     InvalidAccessType,
     AccessTypeWithoutProjectId,

package/dist/schema-fields.d.ts

@@ -2,6 +2,7 @@ import * as yup from "yup";
 declare module "yup" {
     interface StringSchema<TType, TContext, TDefault, TFlags> {
         nonEmpty(message?: string): StringSchema<TType, TContext, TDefault, TFlags>;
+        empty(): StringSchema<TType, TContext, TDefault, TFlags>;
     }
 }
 export declare function yupValidate<S extends yup.ISchema<any>>(schema: S, obj: unknown, options?: yup.ValidateOptions & {
@@ -149,5 +150,6 @@ export declare const contactChannelIsVerifiedSchema: yup.BooleanSchema<boolean |
 export declare const contactChannelIsPrimarySchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare const basicAuthorizationHeaderSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const neonAuthorizationHeaderSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
-export declare function yupDefinedWhen<S extends yup.AnyObject>(schema: S, triggerName: string, isValue: any): S;
+export declare function yupDefinedWhen<S extends yup.AnyObject>(schema: S, triggers: Record<string, any>): S;
+export declare function yupDefinedAndNonEmptyWhen<S extends yup.StringSchema>(schema: S, triggers: Record<string, any>): S;
 export {};

package/dist/schema-fields.js

@@ -9,7 +9,7 @@ import { isValidUrl } from "./utils/urls";
 import { isUuid } from "./utils/uuids";
 // eslint-disable-next-line no-restricted-syntax
 yup.addMethod(yup.string, "nonEmpty", function (message) {
-    return this.test("non-empty", message ?? "String must not be empty", (value) => {
+    return this.test("non-empty", message ?? (({ path }) => `${path} must not be empty`), (value) => {
         return value !== "";
     });
 });
@@ -371,10 +371,19 @@ export const neonAuthorizationHeaderSchema = basicAuthorizationHeaderSchema.test
     return false;
 });
 // Utils
-export function yupDefinedWhen(schema, triggerName, isValue) {
-    return schema.when(triggerName, {
-        is: isValue,
+export function yupDefinedWhen(schema, triggers) {
+    const entries = Object.entries(triggers);
+    return schema.when(entries.map(([key]) => key), {
+        is: (...values) => entries.every(([key, value], index) => value === values[index]),
         then: (schema) => schema.defined(),
         otherwise: (schema) => schema.optional()
     });
 }
+export function yupDefinedAndNonEmptyWhen(schema, triggers) {
+    const entries = Object.entries(triggers);
+    return schema.when(entries.map(([key]) => key), {
+        is: (...values) => entries.every(([key, value], index) => value === values[index]),
+        then: (schema) => schema.defined().nonEmpty(),
+        otherwise: (schema) => schema.optional()
+    });
+}

package/dist/utils/objects.d.ts

@@ -10,8 +10,6 @@ export declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
     ignoreUndefinedValues?: boolean;
 }): obj2 is T;
 export declare function deepPlainClone<T>(obj: T): T;
-export declare function deepPlainSnakeCaseToCamelCase(snakeCaseObj: any): any;
-export declare function deepPlainCamelCaseToSnakeCase(camelCaseObj: any): any;
 export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
 export declare function typedFromEntries<K extends PropertyKey, V>(entries: [K, V][]): Record<K, V>;
 export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];

package/dist/utils/objects.js

@@ -1,5 +1,4 @@
 import { StackAssertionError } from "./errors";
-import { camelCaseToSnakeCase, snakeCaseToCamelCase } from "./strings";
 /**
  * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
  *
@@ -57,24 +56,6 @@ export function deepPlainClone(obj) {
         return obj.map(deepPlainClone);
     return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepPlainClone(v)]));
 }
-export function deepPlainSnakeCaseToCamelCase(snakeCaseObj) {
-    if (typeof snakeCaseObj === 'function')
-        throw new StackAssertionError("deepPlainSnakeCaseToCamelCase does not support functions");
-    if (typeof snakeCaseObj !== 'object' || !snakeCaseObj)
-        return snakeCaseObj;
-    if (Array.isArray(snakeCaseObj))
-        return snakeCaseObj.map(o => deepPlainSnakeCaseToCamelCase(o));
-    return Object.fromEntries(Object.entries(snakeCaseObj).map(([k, v]) => [snakeCaseToCamelCase(k), deepPlainSnakeCaseToCamelCase(v)]));
-}
-export function deepPlainCamelCaseToSnakeCase(camelCaseObj) {
-    if (typeof camelCaseObj === 'function')
-        throw new StackAssertionError("deepPlainCamelCaseToSnakeCase does not support functions");
-    if (typeof camelCaseObj !== 'object' || !camelCaseObj)
-        return camelCaseObj;
-    if (Array.isArray(camelCaseObj))
-        return camelCaseObj.map(o => deepPlainCamelCaseToSnakeCase(o));
-    return Object.fromEntries(Object.entries(camelCaseObj).map(([k, v]) => [camelCaseToSnakeCase(k), deepPlainCamelCaseToSnakeCase(v)]));
-}
 export function typedEntries(obj) {
     return Object.entries(obj);
 }

package/dist/utils/strings.d.ts

@@ -41,8 +41,6 @@ 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 snakeCaseToCamelCase(snakeCase: string): string;
-export declare function camelCaseToSnakeCase(camelCase: string): string;
 export type Nicifiable = {
     getNicifiableKeys?(): PropertyKey[];
     getNicifiedObjectExtraLines?(): string[];

package/dist/utils/strings.js

@@ -105,16 +105,6 @@ export function mergeScopeStrings(...scopes) {
     const allScope = scopes.map((s) => extractScopes(s)).flat().join(" ");
     return extractScopes(allScope).join(" ");
 }
-export function snakeCaseToCamelCase(snakeCase) {
-    if (snakeCase.match(/[A-Z]/))
-        return snakeCase; // TODO next-release: this is a hack for fixing the email templates, remove this after v2 migration
-    return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-export function camelCaseToSnakeCase(camelCase) {
-    if (camelCase.match(/_/))
-        return camelCase; // TODO next-release: this is a hack for fixing the email templates, remove this after v2 migration
-    return camelCase.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
 /**
  * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -51,7 +51,7 @@
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.7.0"
+    "@stackframe/stack-sc": "2.7.1"
   },
   "devDependencies": {
     "@sentry/nextjs": "^8.40.0",