@stackframe/stack-shared 2.6.7 → 2.6.10

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @stackframe/stack-shared
 
+## 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
+
+- Bugfixes
+  - @stackframe/stack-sc@2.6.8
+
 ## 2.6.7
 
 ### 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/bytes.d.ts

@@ -2,5 +2,8 @@ export declare function encodeBase32(input: Uint8Array): string;
 export declare function decodeBase32(input: string): Uint8Array;
 export declare function encodeBase64(input: Uint8Array): string;
 export declare function decodeBase64(input: string): Uint8Array;
+export declare function encodeBase64Url(input: Uint8Array): string;
+export declare function decodeBase64Url(input: string): Uint8Array;
 export declare function isBase32(input: string): boolean;
 export declare function isBase64(input: string): boolean;
+export declare function isBase64Url(input: string): boolean;

package/dist/utils/bytes.js

@@ -68,6 +68,20 @@ export function decodeBase64(input) {
     }
     return new Uint8Array(atob(input).split("").map((char) => char.charCodeAt(0)));
 }
+export function encodeBase64Url(input) {
+    const res = encodeBase64(input).replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+    // sanity check
+    if (!isBase64Url(res)) {
+        throw new StackAssertionError("Invalid base64url output; this should never happen");
+    }
+    return res;
+}
+export function decodeBase64Url(input) {
+    if (!isBase64Url(input)) {
+        throw new StackAssertionError("Invalid base64url string");
+    }
+    return decodeBase64(input.replace(/-/g, "+").replace(/_/g, "/") + "====".slice((input.length - 1) % 4 + 1));
+}
 export function isBase32(input) {
     for (const char of input) {
         if (char === " ")
@@ -82,3 +96,7 @@ export function isBase64(input) {
     const regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
     return regex.test(input);
 }
+export function isBase64Url(input) {
+    const regex = /^[0-9a-zA-Z_-]+$/;
+    return regex.test(input);
+}

package/dist/utils/jwt.js

@@ -1,6 +1,6 @@
 import elliptic from "elliptic";
 import * as jose from "jose";
-import { encodeBase64 } from "./bytes";
+import { encodeBase64Url } from "./bytes";
 import { getEnvVariable } from "./env";
 import { globalVar } from "./globals";
 import { pick } from "./objects";
@@ -60,9 +60,9 @@ export async function getPrivateJwk(secret) {
     return {
         kty: 'EC',
         crv: 'P-256',
-        d: encodeBase64(priv),
-        x: encodeBase64(publicKey.getX().toBuffer()),
-        y: encodeBase64(publicKey.getY().toBuffer()),
+        d: encodeBase64Url(priv),
+        x: encodeBase64Url(publicKey.getX().toBuffer()),
+        y: encodeBase64Url(publicKey.getY().toBuffer()),
     };
 }
 export async function getPublicJwkSet(secret) {

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.7",
+  "version": "2.6.10",
   "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.7"
+    "@stackframe/stack-sc": "2.6.10"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",