@stackframe/stack-shared 2.6.15 → 2.6.17

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @stackframe/stack-shared
 
+## 2.6.17
+
+### Patch Changes
+
+- Loading skeletons
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.17
+
+## 2.6.16
+
+### Patch Changes
+
+- - list user pagination
+  - fixed visual glitches
+  - @stackframe/stack-sc@2.6.16
+
 ## 2.6.15
 
 ### Patch Changes

package/dist/crud.d.ts

@@ -81,6 +81,9 @@ type InnerCrudTypeOf<S extends InnerCrudSchema> = (S['createSchema'] extends {}
     List: {
         items: yup.InferType<S['readSchema']>[];
         is_paginated: boolean;
+        pagination?: {
+            next_cursor: string | null;
+        };
     };
 } : {});
 export type CrudTypeOf<S extends CrudSchema> = {

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

@@ -146,19 +146,29 @@ export declare const contactChannelsCrud: import("../../crud").CrudSchemaFromOpt
     }, "">;
     docs: {
         clientRead: {
-            hidden: true;
+            summary: string;
+            description: string;
+            tags: string[];
         };
         clientCreate: {
-            hidden: true;
+            summary: string;
+            description: string;
+            tags: string[];
         };
         clientUpdate: {
-            hidden: true;
+            summary: string;
+            description: string;
+            tags: string[];
         };
         clientDelete: {
-            hidden: true;
+            summary: string;
+            description: string;
+            tags: string[];
         };
         clientList: {
-            hidden: true;
+            summary: string;
+            description: string;
+            tags: string[];
         };
     };
 }>;

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

@@ -1,38 +1,32 @@
 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(),
-});
+import { contactChannelIdSchema, contactChannelIsPrimarySchema, contactChannelIsVerifiedSchema, contactChannelTypeSchema, contactChannelUsedForAuthSchema, contactChannelValueSchema, userIdOrMeSchema, userIdSchema, yupMixed, yupObject } from "../../schema-fields";
 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(),
+    id: contactChannelIdSchema.required(),
+    value: contactChannelValueSchema.required(),
+    type: contactChannelTypeSchema.required(),
+    used_for_auth: contactChannelUsedForAuthSchema.required(),
+    is_verified: contactChannelIsVerifiedSchema.required(),
+    is_primary: contactChannelIsPrimarySchema.required(),
 }).required();
 export const contactChannelsCrudClientUpdateSchema = yupObject({
-    value: value.optional(),
-    type: type.optional(),
-    used_for_auth: yupBoolean().optional(),
-    is_primary: yupBoolean().optional(),
+    value: contactChannelValueSchema.optional(),
+    type: contactChannelTypeSchema.optional(),
+    used_for_auth: contactChannelUsedForAuthSchema.optional(),
+    is_primary: contactChannelIsPrimarySchema.optional(),
 }).required();
 export const contactChannelsCrudServerUpdateSchema = contactChannelsCrudClientUpdateSchema.concat(yupObject({
-    is_verified: yupBoolean().optional(),
+    is_verified: contactChannelIsVerifiedSchema.optional(),
 }));
 export const contactChannelsCrudClientCreateSchema = yupObject({
     user_id: userIdOrMeSchema.required(),
-    value: value.required(),
-    type: type.required(),
-    used_for_auth: yupBoolean().required(),
-    is_primary: yupBoolean().optional(),
+    value: contactChannelValueSchema.required(),
+    type: contactChannelTypeSchema.required(),
+    used_for_auth: contactChannelUsedForAuthSchema.required(),
+    is_primary: contactChannelIsPrimarySchema.optional(),
 }).required();
 export const contactChannelsCrudServerCreateSchema = contactChannelsCrudClientCreateSchema.concat(yupObject({
-    is_verified: yupBoolean().optional(),
+    is_verified: contactChannelIsVerifiedSchema.optional(),
 }));
 export const contactChannelsCrudClientDeleteSchema = yupMixed();
 export const contactChannelsCrud = createCrud({
@@ -44,19 +38,29 @@ export const contactChannelsCrud = createCrud({
     serverCreateSchema: contactChannelsCrudServerCreateSchema,
     docs: {
         clientRead: {
-            hidden: true,
+            summary: "Get a contact channel",
+            description: "",
+            tags: ["Contact Channels"],
         },
         clientCreate: {
-            hidden: true,
+            summary: "Create a contact channel",
+            description: "",
+            tags: ["Contact Channels"],
         },
         clientUpdate: {
-            hidden: true,
+            summary: "Update a contact channel",
+            description: "",
+            tags: ["Contact Channels"],
         },
         clientDelete: {
-            hidden: true,
+            summary: "Delete a contact channel",
+            description: "",
+            tags: ["Contact Channels"],
         },
         clientList: {
-            hidden: true,
+            summary: "List contact channels",
+            description: "",
+            tags: ["Contact Channels"],
         }
     }
 });

package/dist/interface/serverInterface.d.ts

@@ -45,7 +45,13 @@ export declare class StackServerInterface extends StackClientInterface {
         teamId?: string;
         recursive: boolean;
     }, session: InternalSession | null): Promise<TeamPermissionsCrud['Server']['Read'][]>;
-    listServerUsers(): Promise<UsersCrud['Server']['Read'][]>;
+    listServerUsers(options: {
+        cursor?: string;
+        limit?: number;
+        orderBy?: 'signedUpAt';
+        desc?: boolean;
+        query?: string;
+    }): Promise<UsersCrud['Server']['List']>;
     listServerTeams(options?: {
         userId?: string;
     }): Promise<TeamsCrud['Server']['Read'][]>;
@@ -78,5 +84,5 @@ export declare class StackServerInterface extends StackClientInterface {
     updateServerContactChannel(userId: string, contactChannelId: string, data: ContactChannelsCrud['Server']['Update']): Promise<ContactChannelsCrud['Server']['Read']>;
     deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;
     listServerContactChannels(userId: string): Promise<ContactChannelsCrud['Server']['Read'][]>;
-    sendServerContactChannelVerificationEmail(userId: string, contactChannelId: string, callbackUrl: string): Promise<Result<undefined, KnownErrors["EmailAlreadyVerified"]>>;
+    sendServerContactChannelVerificationEmail(userId: string, contactChannelId: string, callbackUrl: string): Promise<void>;
 }

package/dist/interface/serverInterface.js

@@ -81,10 +81,22 @@ export class StackServerInterface extends StackClientInterface {
         const result = await response.json();
         return result.items;
     }
-    async listServerUsers() {
-        const response = await this.sendServerRequest("/users", {}, null);
-        const result = await response.json();
-        return result.items;
+    async listServerUsers(options) {
+        const searchParams = new URLSearchParams(filterUndefined({
+            cursor: options.cursor,
+            limit: options.limit?.toString(),
+            desc: options.desc?.toString(),
+            ...options.orderBy ? {
+                order_by: {
+                    signedUpAt: "signed_up_at",
+                }[options.orderBy],
+            } : {},
+            ...options.query ? {
+                query: options.query,
+            } : {},
+        }));
+        const response = await this.sendServerRequest("/users?" + searchParams.toString(), {}, null);
+        return await response.json();
     }
     async listServerTeams(options) {
         const response = await this.sendServerRequest("/teams?" + new URLSearchParams(filterUndefined({
@@ -247,16 +259,12 @@ export class StackServerInterface extends StackClientInterface {
         return json.items;
     }
     async sendServerContactChannelVerificationEmail(userId, contactChannelId, callbackUrl) {
-        const responseOrError = await this.sendServerRequestAndCatchKnownError(`/contact-channels/${userId}/${contactChannelId}/send-verification-code`, {
+        await this.sendServerRequest(`/contact-channels/${userId}/${contactChannelId}/send-verification-code`, {
             method: "POST",
             headers: {
                 "content-type": "application/json",
             },
             body: JSON.stringify({ callback_url: callbackUrl }),
-        }, null, [KnownErrors.EmailAlreadyVerified]);
-        if (responseOrError.status === "error") {
-            return Result.error(responseOrError.error);
-        }
-        return Result.ok(undefined);
+        }, null);
     }
 }

package/dist/schema-fields.d.ts

@@ -123,5 +123,11 @@ export declare const teamInvitationCallbackUrlSchema: yup.StringSchema<string |
 export declare const teamCreatorUserIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const teamMemberDisplayNameSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const teamMemberProfileImageUrlSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelTypeSchema: yup.StringSchema<"email" | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelValueSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelUsedForAuthSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelIsVerifiedSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
+export declare const contactChannelIsPrimarySchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare function yupRequiredWhen<S extends yup.AnyObject>(schema: S, triggerName: string, isValue: any): S;
 export {};

package/dist/schema-fields.js

@@ -53,7 +53,7 @@ export async function yupValidate(schema, obj, options) {
         throw error;
     }
 }
-const _idDescription = (identify) => `The unique identifier of this ${identify}`;
+const _idDescription = (identify) => `The unique identifier of the ${identify}`;
 const _displayNameDescription = (identify) => `Human-readable ${identify} display name. This is not a unique identifier.`;
 const _clientMetaDataDescription = (identify) => `Client metadata. Used as a data store, accessible from the client side. Do not store information that should not be exposed to the client.`;
 const _clientReadOnlyMetaDataDescription = (identify) => `Client read-only, server-writable metadata. Used as a data store, accessible from the client side. Do not store information that should not be exposed to the client. The client can read this data, but cannot modify it. This is useful for things like subscription status.`;
@@ -320,6 +320,16 @@ export const teamCreatorUserIdSchema = userIdOrMeSchema.meta({ openapiField: { d
 // Team member profiles
 export const teamMemberDisplayNameSchema = yupString().meta({ openapiField: { description: _displayNameDescription('team member') + ' Note that this is separate from the display_name of the user.', exampleValue: 'John Doe' } });
 export const teamMemberProfileImageUrlSchema = urlSchema.max(1000000).meta({ openapiField: { description: _profileImageUrlDescription('team member'), exampleValue: 'https://example.com/image.jpg' } });
+// Contact channels
+export const contactChannelIdSchema = yupString().uuid().meta({ openapiField: { description: _idDescription('contact channel'), exampleValue: 'b3d396b8-c574-4c80-97b3-50031675ceb2' } });
+export const contactChannelTypeSchema = yupString().oneOf(['email']).meta({ openapiField: { description: `The type of the contact channel. Currently only "email" is supported.`, exampleValue: 'email' } });
+export const contactChannelValueSchema = yupString().when('type', {
+    is: 'email',
+    then: (schema) => schema.email(),
+}).meta({ openapiField: { description: 'The value of the contact channel. For email, this should be a valid email address.', exampleValue: 'johndoe@example.com' } });
+export const contactChannelUsedForAuthSchema = yupBoolean().meta({ openapiField: { description: 'Whether the contact channel is used for authentication. If this is set to `true`, the user will be able to sign in with the contact channel with password or OTP.', exampleValue: true } });
+export const contactChannelIsVerifiedSchema = yupBoolean().meta({ openapiField: { description: 'Whether the contact channel has been verified. If this is set to `true`, the contact channel has been verified to belong to the user.', exampleValue: true } });
+export const contactChannelIsPrimarySchema = yupBoolean().meta({ openapiField: { description: 'Whether the contact channel is the primary contact channel. If this is set to `true`, it will be used for authentication and notifications by default.', exampleValue: true } });
 // Utils
 export function yupRequiredWhen(schema, triggerName, isValue) {
     return schema.when(triggerName, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.15",
+  "version": "2.6.17",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -39,7 +39,7 @@
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.6.15"
+    "@stackframe/stack-sc": "2.6.17"
   },
   "devDependencies": {
     "@simplewebauthn/types": "^11.0.0",