@stackframe/stack-shared 2.6.8 → 2.6.11

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @stackframe/stack-shared
 
+## 2.6.11
+
+### Patch Changes
+
+- fixed account settings bugs
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.11
+
+## 2.6.10
+
+### Patch Changes
+
+- Various bugfixes
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.10
+
+## 2.6.9
+
+### Patch Changes
+
+- - New contact channel API
+  - Fixed some visual gitches and typos
+  - Bug fixes
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.9
+
 ## 2.6.8
 
 ### Patch Changes

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

@@ -0,0 +1 @@
+export declare const useHash: () => string | undefined;

package/dist/hooks/use-hash.js

@@ -0,0 +1,9 @@
+import { useParams } from "next/navigation";
+import { useEffect, useState } from "react";
+const getHash = () => typeof window === "undefined" ? undefined : window.location.hash.substring(1);
+export const useHash = () => {
+    const params = useParams();
+    const [hash, setHash] = useState(getHash());
+    useEffect(() => setHash(getHash()), [params]);
+    return hash;
+};

package/dist/interface/crud/contact-channels.d.ts

@@ -0,0 +1,165 @@
+import { CrudTypeOf } from "../../crud";
+export declare const contactChannelsClientReadSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    id: string;
+    value: string;
+    type: "email";
+    used_for_auth: NonNullable<boolean | undefined>;
+    is_verified: NonNullable<boolean | undefined>;
+    is_primary: NonNullable<boolean | undefined>;
+}, import("yup").AnyObject, {
+    user_id: undefined;
+    id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_verified: undefined;
+    is_primary: undefined;
+}, "">;
+export declare const contactChannelsCrudClientUpdateSchema: import("yup").ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+}, import("yup").AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+}, "">;
+export declare const contactChannelsCrudServerUpdateSchema: import("yup").ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+} & {
+    is_verified: boolean | undefined;
+}, import("yup").AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+}, "">;
+export declare const contactChannelsCrudClientCreateSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: NonNullable<boolean | undefined>;
+    is_primary: boolean | undefined;
+}, import("yup").AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+}, "">;
+export declare const contactChannelsCrudServerCreateSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: NonNullable<boolean | undefined>;
+    is_primary: boolean | undefined;
+} & {
+    is_verified: boolean | undefined;
+}, import("yup").AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+}, "">;
+export declare const contactChannelsCrudClientDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const contactChannelsCrud: import("../../crud").CrudSchemaFromOptions<{
+    clientReadSchema: import("yup").ObjectSchema<{
+        user_id: string;
+        id: string;
+        value: string;
+        type: "email";
+        used_for_auth: NonNullable<boolean | undefined>;
+        is_verified: NonNullable<boolean | undefined>;
+        is_primary: NonNullable<boolean | undefined>;
+    }, import("yup").AnyObject, {
+        user_id: undefined;
+        id: undefined;
+        value: undefined;
+        type: undefined;
+        used_for_auth: undefined;
+        is_verified: undefined;
+        is_primary: undefined;
+    }, "">;
+    clientUpdateSchema: import("yup").ObjectSchema<{
+        value: string | undefined;
+        type: "email" | undefined;
+        used_for_auth: boolean | undefined;
+        is_primary: boolean | undefined;
+    }, import("yup").AnyObject, {
+        value: undefined;
+        type: undefined;
+        used_for_auth: undefined;
+        is_primary: undefined;
+    }, "">;
+    clientCreateSchema: import("yup").ObjectSchema<{
+        user_id: string;
+        value: string;
+        type: "email";
+        used_for_auth: NonNullable<boolean | undefined>;
+        is_primary: boolean | undefined;
+    }, import("yup").AnyObject, {
+        user_id: undefined;
+        value: undefined;
+        type: undefined;
+        used_for_auth: undefined;
+        is_primary: undefined;
+    }, "">;
+    clientDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    serverUpdateSchema: import("yup").ObjectSchema<{
+        value: string | undefined;
+        type: "email" | undefined;
+        used_for_auth: boolean | undefined;
+        is_primary: boolean | undefined;
+    } & {
+        is_verified: boolean | undefined;
+    }, import("yup").AnyObject, {
+        value: undefined;
+        type: undefined;
+        used_for_auth: undefined;
+        is_primary: undefined;
+        is_verified: undefined;
+    }, "">;
+    serverCreateSchema: import("yup").ObjectSchema<{
+        user_id: string;
+        value: string;
+        type: "email";
+        used_for_auth: NonNullable<boolean | undefined>;
+        is_primary: boolean | undefined;
+    } & {
+        is_verified: boolean | undefined;
+    }, import("yup").AnyObject, {
+        user_id: undefined;
+        value: undefined;
+        type: undefined;
+        used_for_auth: undefined;
+        is_primary: undefined;
+        is_verified: undefined;
+    }, "">;
+    docs: {
+        clientRead: {
+            hidden: true;
+        };
+        clientCreate: {
+            hidden: true;
+        };
+        clientUpdate: {
+            hidden: true;
+        };
+        clientDelete: {
+            hidden: true;
+        };
+        clientList: {
+            hidden: true;
+        };
+    };
+}>;
+export type ContactChannelsCrud = CrudTypeOf<typeof contactChannelsCrud>;

package/dist/interface/crud/contact-channels.js

@@ -0,0 +1,62 @@
+import { createCrud } from "../../crud";
+import { userIdOrMeSchema, userIdSchema, yupBoolean, yupMixed, yupObject, yupString } from "../../schema-fields";
+const contactChannelsTypes = ['email'];
+const type = yupString().oneOf(contactChannelsTypes);
+const value = yupString().when('type', {
+    is: 'email',
+    then: (schema) => schema.email(),
+});
+export const contactChannelsClientReadSchema = yupObject({
+    user_id: userIdSchema.required(),
+    id: yupString().required(),
+    value: value.required(),
+    type: type.required(),
+    used_for_auth: yupBoolean().required(),
+    is_verified: yupBoolean().required(),
+    is_primary: yupBoolean().required(),
+}).required();
+export const contactChannelsCrudClientUpdateSchema = yupObject({
+    value: value.optional(),
+    type: type.optional(),
+    used_for_auth: yupBoolean().optional(),
+    is_primary: yupBoolean().optional(),
+}).required();
+export const contactChannelsCrudServerUpdateSchema = contactChannelsCrudClientUpdateSchema.concat(yupObject({
+    is_verified: yupBoolean().optional(),
+}));
+export const contactChannelsCrudClientCreateSchema = yupObject({
+    user_id: userIdOrMeSchema.required(),
+    value: value.required(),
+    type: type.required(),
+    used_for_auth: yupBoolean().required(),
+    is_primary: yupBoolean().optional(),
+}).required();
+export const contactChannelsCrudServerCreateSchema = contactChannelsCrudClientCreateSchema.concat(yupObject({
+    is_verified: yupBoolean().optional(),
+}));
+export const contactChannelsCrudClientDeleteSchema = yupMixed();
+export const contactChannelsCrud = createCrud({
+    clientReadSchema: contactChannelsClientReadSchema,
+    clientUpdateSchema: contactChannelsCrudClientUpdateSchema,
+    clientCreateSchema: contactChannelsCrudClientCreateSchema,
+    clientDeleteSchema: contactChannelsCrudClientDeleteSchema,
+    serverUpdateSchema: contactChannelsCrudServerUpdateSchema,
+    serverCreateSchema: contactChannelsCrudServerCreateSchema,
+    docs: {
+        clientRead: {
+            hidden: true,
+        },
+        clientCreate: {
+            hidden: true,
+        },
+        clientUpdate: {
+            hidden: true,
+        },
+        clientDelete: {
+            hidden: true,
+        },
+        clientList: {
+            hidden: true,
+        }
+    }
+});

package/dist/interface/crud/users.js

@@ -14,6 +14,14 @@ export const usersCrudServerUpdateSchema = fieldSchema.yupObject({
     totp_secret_base64: fieldSchema.base64Schema.nullable().meta({ openapiField: { description: 'A TOTP secret for the user, overwriting the old one (if it exists). Set to null to disable 2FA.', exampleValue: 'dG90cC1zZWNyZXQ=' } }),
     selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().optional(),
 }).required();
+const contactChannelSchema = fieldSchema.yupObject({
+    id: fieldSchema.yupString().required(),
+    type: fieldSchema.yupString().required(),
+    value: fieldSchema.yupString().required(),
+    is_primary: fieldSchema.yupBoolean().required(),
+    is_verified: fieldSchema.yupBoolean().required(),
+    used_for_auth: fieldSchema.yupBoolean().required(),
+}).required();
 export const usersCrudServerReadSchema = fieldSchema.yupObject({
     id: fieldSchema.userIdSchema.required(),
     primary_email: fieldSchema.primaryEmailSchema.nullable().defined(),

package/dist/utils/promises.js

@@ -90,6 +90,12 @@ export function ignoreUnhandledRejection(promise) {
     return promise;
 }
 export async function wait(ms) {
+    if (!Number.isFinite(ms) || ms < 0) {
+        throw new StackAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);
+    }
+    if (ms >= 2 ** 31) {
+        throw new StackAssertionError("The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)");
+    }
     return await new Promise(resolve => setTimeout(resolve, ms));
 }
 export async function waitUntil(date) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.8",
+  "version": "2.6.11",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -38,7 +38,7 @@
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.6.8"
+    "@stackframe/stack-sc": "2.6.11"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",