@stackframe/stack-shared 2.5.2 → 2.5.4

package/dist/interface/crud/users.js

@@ -1,37 +1,45 @@
 import { createCrud } from "../../crud";
-import * as yup from "yup";
 import * as fieldSchema from "../../schema-fields";
-export const usersCrudServerUpdateSchema = yup.object({
+import { teamsCrudServerReadSchema } from "./teams";
+export const usersCrudServerUpdateSchema = fieldSchema.yupObject({
     display_name: fieldSchema.userDisplayNameSchema.optional(),
+    profile_image_url: fieldSchema.profileImageUrlSchema.optional(),
     client_metadata: fieldSchema.userClientMetadataSchema.optional(),
     server_metadata: fieldSchema.userServerMetadataSchema.optional(),
     primary_email: fieldSchema.primaryEmailSchema.nullable().optional(),
     primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.optional(),
+    primary_email_auth_enabled: fieldSchema.yupBoolean().optional().meta({ openapiField: { description: "Whether the primary email can be used to sign into this user's account", exampleValue: true } }),
+    password: fieldSchema.yupString().nullable().meta({ openapiField: { description: 'A new password for the user, overwriting the old one (if it exists).', exampleValue: 'password' } }),
     selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().optional(),
 }).required();
-export const usersCrudServerReadSchema = yup.object({
+export const usersCrudServerReadSchema = fieldSchema.yupObject({
     project_id: fieldSchema.projectIdSchema.required(),
-    id: fieldSchema.userIdResponseSchema.required(),
+    id: fieldSchema.userIdSchema.required(),
     primary_email: fieldSchema.primaryEmailSchema.nullable().defined(),
     primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.required(),
     display_name: fieldSchema.userDisplayNameSchema.nullable().defined(),
-    // TODO give this one the type of an actual team
-    selected_team: yup.mixed().nullable().defined(),
+    selected_team: teamsCrudServerReadSchema.nullable().defined(),
     selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().defined(),
     profile_image_url: fieldSchema.profileImageUrlSchema.nullable().defined(),
     signed_up_at_millis: fieldSchema.signedUpAtMillisSchema.required(),
-    has_password: yup.boolean().required().meta({ openapiField: { description: 'Whether the user has a password associated with their account', exampleValue: true } }),
-    auth_with_email: yup.boolean().required().meta({ openapiField: { description: 'Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.', exampleValue: true } }),
-    oauth_providers: yup.array(yup.string().required()).required().meta({ openapiField: { description: 'All the OAuth providers connected to this account', exampleValue: ['google', 'github'] } }),
+    has_password: fieldSchema.yupBoolean().required().meta({ openapiField: { description: 'Whether the user has a password associated with their account', exampleValue: true } }),
+    auth_with_email: fieldSchema.yupBoolean().required().meta({ openapiField: { description: 'Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.', exampleValue: true } }),
+    oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({
+        id: fieldSchema.yupString().required(),
+        account_id: fieldSchema.yupString().required(),
+        email: fieldSchema.yupString().nullable(),
+    }).required()).required().meta({ openapiField: { description: 'A list of OAuth providers connected to this account', exampleValue: ['google', 'github'] } }),
     client_metadata: fieldSchema.userClientMetadataSchema,
     server_metadata: fieldSchema.userServerMetadataSchema,
 }).required();
-export const usersCrudServerCreateSchema = usersCrudServerUpdateSchema.concat(yup.object({
-    primary_email: fieldSchema.primaryEmailSchema.required(),
-    primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.required(),
-    auth_with_email: yup.boolean().oneOf([true]).required().meta({ openapiField: { description: 'Must always be set to true.', exampleValue: true } }),
+export const usersCrudServerCreateSchema = usersCrudServerUpdateSchema.concat(fieldSchema.yupObject({
+    oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({
+        id: fieldSchema.yupString().required(),
+        account_id: fieldSchema.yupString().required(),
+        email: fieldSchema.yupString().nullable().defined().default(null),
+    }).required()).optional(),
 }).required());
-export const usersCrudServerDeleteSchema = yup.mixed();
+export const usersCrudServerDeleteSchema = fieldSchema.yupMixed();
 export const usersCrud = createCrud({
     serverReadSchema: usersCrudServerReadSchema,
     serverUpdateSchema: usersCrudServerUpdateSchema,

package/dist/interface/crud-deprecated/api-keys.d.ts

@@ -0,0 +1,134 @@
+import { CrudTypeOf } from "../../crud";
+export declare const apiKeysCreateInputSchema: import("yup").ObjectSchema<{
+    description: string;
+    expires_at_millis: number;
+    has_publishable_client_key: NonNullable<boolean | undefined>;
+    has_secret_server_key: NonNullable<boolean | undefined>;
+    has_super_secret_admin_key: NonNullable<boolean | undefined>;
+}, import("yup").AnyObject, {
+    description: undefined;
+    expires_at_millis: undefined;
+    has_publishable_client_key: undefined;
+    has_secret_server_key: undefined;
+    has_super_secret_admin_key: undefined;
+}, "">;
+export declare const apiKeysCreateOutputSchema: import("yup").ObjectSchema<{
+    id: string;
+    description: string;
+    expires_at_millis: number;
+    manually_revoked_at_millis: number | undefined;
+    created_at_millis: number;
+} & {
+    publishable_client_key: string | undefined;
+    secret_server_key: string | undefined;
+    super_secret_admin_key: string | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    description: undefined;
+    expires_at_millis: undefined;
+    manually_revoked_at_millis: undefined;
+    created_at_millis: undefined;
+    publishable_client_key: undefined;
+    secret_server_key: undefined;
+    super_secret_admin_key: undefined;
+}, "">;
+export declare const apiKeysCrudAdminObfuscatedReadSchema: import("yup").ObjectSchema<{
+    id: string;
+    description: string;
+    expires_at_millis: number;
+    manually_revoked_at_millis: number | undefined;
+    created_at_millis: number;
+} & {
+    publishable_client_key: {
+        last_four: string;
+    } | undefined;
+    secret_server_key: {
+        last_four: string;
+    } | undefined;
+    super_secret_admin_key: {
+        last_four: string;
+    } | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    description: undefined;
+    expires_at_millis: undefined;
+    manually_revoked_at_millis: undefined;
+    created_at_millis: undefined;
+    publishable_client_key: {
+        last_four: undefined;
+    };
+    secret_server_key: {
+        last_four: undefined;
+    };
+    super_secret_admin_key: {
+        last_four: undefined;
+    };
+}, "">;
+export declare const apiKeysCrudAdminUpdateSchema: import("yup").ObjectSchema<{
+    description: string | undefined;
+    revoked: boolean | undefined;
+}, import("yup").AnyObject, {
+    description: undefined;
+    revoked: undefined;
+}, "">;
+export declare const apiKeysCrudAdminDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const apiKeysCrud: import("../../crud").CrudSchemaFromOptions<{
+    adminReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        description: string;
+        expires_at_millis: number;
+        manually_revoked_at_millis: number | undefined;
+        created_at_millis: number;
+    } & {
+        publishable_client_key: {
+            last_four: string;
+        } | undefined;
+        secret_server_key: {
+            last_four: string;
+        } | undefined;
+        super_secret_admin_key: {
+            last_four: string;
+        } | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        description: undefined;
+        expires_at_millis: undefined;
+        manually_revoked_at_millis: undefined;
+        created_at_millis: undefined;
+        publishable_client_key: {
+            last_four: undefined;
+        };
+        secret_server_key: {
+            last_four: undefined;
+        };
+        super_secret_admin_key: {
+            last_four: undefined;
+        };
+    }, "">;
+    adminUpdateSchema: import("yup").ObjectSchema<{
+        description: string | undefined;
+        revoked: boolean | undefined;
+    }, import("yup").AnyObject, {
+        description: undefined;
+        revoked: undefined;
+    }, "">;
+    adminDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        adminList: {
+            hidden: true;
+        };
+        adminRead: {
+            hidden: true;
+        };
+        adminCreate: {
+            hidden: true;
+        };
+        adminUpdate: {
+            hidden: true;
+        };
+        adminDelete: {
+            hidden: true;
+        };
+    };
+}>;
+export type ApiKeysCrud = CrudTypeOf<typeof apiKeysCrud>;

package/dist/interface/crud-deprecated/api-keys.js

@@ -0,0 +1,61 @@
+import { createCrud } from "../../crud";
+import { yupBoolean, yupMixed, yupNumber, yupObject, yupString } from "../../schema-fields";
+const baseApiKeysReadSchema = yupObject({
+    id: yupString().required(),
+    description: yupString().required(),
+    expires_at_millis: yupNumber().required(),
+    manually_revoked_at_millis: yupNumber().optional(),
+    created_at_millis: yupNumber().required(),
+});
+// Used for the result of the create endpoint
+export const apiKeysCreateInputSchema = yupObject({
+    description: yupString().required(),
+    expires_at_millis: yupNumber().required(),
+    has_publishable_client_key: yupBoolean().required(),
+    has_secret_server_key: yupBoolean().required(),
+    has_super_secret_admin_key: yupBoolean().required(),
+});
+export const apiKeysCreateOutputSchema = baseApiKeysReadSchema.concat(yupObject({
+    publishable_client_key: yupString().optional(),
+    secret_server_key: yupString().optional(),
+    super_secret_admin_key: yupString().optional(),
+}).required());
+// Used for list, read and update endpoints after the initial creation
+export const apiKeysCrudAdminObfuscatedReadSchema = baseApiKeysReadSchema.concat(yupObject({
+    publishable_client_key: yupObject({
+        last_four: yupString().required(),
+    }).optional(),
+    secret_server_key: yupObject({
+        last_four: yupString().required(),
+    }).optional(),
+    super_secret_admin_key: yupObject({
+        last_four: yupString().required(),
+    }).optional(),
+}));
+export const apiKeysCrudAdminUpdateSchema = yupObject({
+    description: yupString().optional(),
+    revoked: yupBoolean().oneOf([true]).optional(),
+}).required();
+export const apiKeysCrudAdminDeleteSchema = yupMixed();
+export const apiKeysCrud = createCrud({
+    adminReadSchema: apiKeysCrudAdminObfuscatedReadSchema,
+    adminUpdateSchema: apiKeysCrudAdminUpdateSchema,
+    adminDeleteSchema: apiKeysCrudAdminDeleteSchema,
+    docs: {
+        adminList: {
+            hidden: true,
+        },
+        adminRead: {
+            hidden: true,
+        },
+        adminCreate: {
+            hidden: true,
+        },
+        adminUpdate: {
+            hidden: true,
+        },
+        adminDelete: {
+            hidden: true,
+        },
+    },
+});

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

@@ -0,0 +1,127 @@
+import { CrudTypeOf } from "../../crud";
+export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions<{
+    clientReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        display_name: string | null;
+        oauth_providers: {
+            email?: string | null | undefined;
+            account_id: string;
+            provider_id: string;
+        }[];
+        project_id: string;
+        primary_email: string | null;
+        profile_image_url: string | null;
+        client_metadata: {} | null;
+        primary_email_verified: NonNullable<boolean | undefined>;
+        selected_team_id: string | null;
+        selected_team: {} | null;
+        signed_up_at_millis: number;
+        has_password: NonNullable<boolean | undefined>;
+        auth_with_email: NonNullable<boolean | undefined>;
+    } | null, import("yup").AnyObject, {
+        project_id: undefined;
+        id: undefined;
+        primary_email: undefined;
+        primary_email_verified: undefined;
+        display_name: undefined;
+        selected_team: undefined;
+        selected_team_id: undefined;
+        profile_image_url: undefined;
+        signed_up_at_millis: undefined;
+        has_password: undefined;
+        auth_with_email: undefined;
+        oauth_providers: undefined;
+        client_metadata: undefined;
+        server_metadata: undefined;
+    }, "">;
+    serverReadSchema: import("yup").ObjectSchema<{
+        project_id: string;
+        id: string;
+        primary_email: string | null;
+        primary_email_verified: NonNullable<boolean | undefined>;
+        display_name: string | null;
+        selected_team: {} | null;
+        selected_team_id: string | null;
+        profile_image_url: string | null;
+        signed_up_at_millis: number;
+        has_password: NonNullable<boolean | undefined>;
+        auth_with_email: NonNullable<boolean | undefined>;
+        oauth_providers: {
+            email?: string | null | undefined;
+            account_id: string;
+            provider_id: string;
+        }[];
+        client_metadata: {} | null;
+        server_metadata: {} | null;
+    } | null, import("yup").AnyObject, {
+        project_id: undefined;
+        id: undefined;
+        primary_email: undefined;
+        primary_email_verified: undefined;
+        display_name: undefined;
+        selected_team: undefined;
+        selected_team_id: undefined;
+        profile_image_url: undefined;
+        signed_up_at_millis: undefined;
+        has_password: undefined;
+        auth_with_email: undefined;
+        oauth_providers: undefined;
+        client_metadata: undefined;
+        server_metadata: undefined;
+    }, "">;
+    clientUpdateSchema: import("yup").ObjectSchema<{
+        display_name: string | null | undefined;
+        client_metadata: {} | null | undefined;
+        selected_team_id: string | null | undefined;
+    }, import("yup").AnyObject, {
+        display_name: undefined;
+        profile_image_url: undefined;
+        client_metadata: undefined;
+        server_metadata: undefined;
+        primary_email: undefined;
+        primary_email_verified: undefined;
+        primary_email_auth_enabled: undefined;
+        password: undefined;
+        selected_team_id: undefined;
+    }, "">;
+    serverUpdateSchema: import("yup").ObjectSchema<{
+        display_name: string | null | undefined;
+        profile_image_url: string | undefined;
+        client_metadata: {} | null | undefined;
+        server_metadata: {} | null | undefined;
+        primary_email: string | null | undefined;
+        primary_email_verified: boolean | undefined;
+        primary_email_auth_enabled: boolean | undefined;
+        password: string | null | undefined;
+        selected_team_id: string | null | undefined;
+    }, import("yup").AnyObject, {
+        display_name: undefined;
+        profile_image_url: undefined;
+        client_metadata: undefined;
+        server_metadata: undefined;
+        primary_email: undefined;
+        primary_email_verified: undefined;
+        primary_email_auth_enabled: undefined;
+        password: undefined;
+        selected_team_id: undefined;
+    }, "">;
+    serverDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        clientRead: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        clientUpdate: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        clientDelete: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+    };
+}>;
+export type CurrentUserCrud = CrudTypeOf<typeof currentUserCrud>;

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

@@ -0,0 +1,49 @@
+import { createCrud } from "../../crud";
+import { usersCrudServerReadSchema, usersCrudServerUpdateSchema, usersCrudServerDeleteSchema } from "./users";
+const clientUpdateSchema = usersCrudServerUpdateSchema.pick([
+    "display_name",
+    "client_metadata",
+    "selected_team_id",
+]).required();
+const serverUpdateSchema = usersCrudServerUpdateSchema;
+const clientReadSchema = usersCrudServerReadSchema.pick([
+    "project_id",
+    "id",
+    "primary_email",
+    "primary_email_verified",
+    "display_name",
+    "client_metadata",
+    "profile_image_url",
+    "signed_up_at_millis",
+    "has_password",
+    "auth_with_email",
+    "oauth_providers",
+    "selected_team_id",
+    "selected_team",
+]).nullable().defined();
+const serverReadSchema = usersCrudServerReadSchema.nullable().defined();
+const serverDeleteSchema = usersCrudServerDeleteSchema;
+export const currentUserCrud = createCrud({
+    clientReadSchema,
+    serverReadSchema,
+    clientUpdateSchema,
+    serverUpdateSchema,
+    serverDeleteSchema,
+    docs: {
+        clientRead: {
+            summary: 'Get current user',
+            description: 'Gets the currently authenticated user.',
+            tags: ['Users'],
+        },
+        clientUpdate: {
+            summary: 'Update current user',
+            description: 'Updates the currently authenticated user. Only the values provided will be updated.',
+            tags: ['Users'],
+        },
+        clientDelete: {
+            summary: 'Delete current user',
+            description: 'Deletes the currently authenticated user. Use this with caution.',
+            tags: ['Users'],
+        },
+    },
+});

package/dist/interface/crud-deprecated/email-templates.d.ts

@@ -0,0 +1,75 @@
+import { CrudTypeOf } from "../../crud";
+export type EmailTemplateType = typeof emailTemplateTypes[number];
+export declare const emailTemplateTypes: readonly ["EMAIL_VERIFICATION", "PASSWORD_RESET", "MAGIC_LINK"];
+export declare const emailTemplateServerReadSchema: import("yup").ObjectSchema<{
+    type: NonNullable<"EMAIL_VERIFICATION" | "PASSWORD_RESET" | "MAGIC_LINK" | undefined>;
+    subject: string;
+    content: {};
+}, import("yup").AnyObject, {
+    type: undefined;
+    subject: undefined;
+    content: undefined;
+}, "">;
+export declare const emailTemplateCrudServerUpdateSchema: import("yup").ObjectSchema<{
+    content: {};
+    subject: string;
+}, import("yup").AnyObject, {
+    content: undefined;
+    subject: undefined;
+}, "">;
+export declare const emailTemplateCrudServerDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const emailTemplateCrudServerCreateSchema: import("yup").ObjectSchema<{
+    type: NonNullable<"EMAIL_VERIFICATION" | "PASSWORD_RESET" | "MAGIC_LINK" | undefined>;
+    content: {};
+    subject: string;
+}, import("yup").AnyObject, {
+    type: undefined;
+    content: undefined;
+    subject: undefined;
+}, "">;
+export declare const emailTemplateCrud: import("../../crud").CrudSchemaFromOptions<{
+    serverReadSchema: import("yup").ObjectSchema<{
+        type: NonNullable<"EMAIL_VERIFICATION" | "PASSWORD_RESET" | "MAGIC_LINK" | undefined>;
+        subject: string;
+        content: {};
+    }, import("yup").AnyObject, {
+        type: undefined;
+        subject: undefined;
+        content: undefined;
+    }, "">;
+    serverUpdateSchema: import("yup").ObjectSchema<{
+        content: {};
+        subject: string;
+    }, import("yup").AnyObject, {
+        content: undefined;
+        subject: undefined;
+    }, "">;
+    serverCreateSchema: import("yup").ObjectSchema<{
+        type: NonNullable<"EMAIL_VERIFICATION" | "PASSWORD_RESET" | "MAGIC_LINK" | undefined>;
+        content: {};
+        subject: string;
+    }, import("yup").AnyObject, {
+        type: undefined;
+        content: undefined;
+        subject: undefined;
+    }, "">;
+    serverDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        serverRead: {
+            hidden: true;
+        };
+        serverCreate: {
+            hidden: true;
+        };
+        serverUpdate: {
+            hidden: true;
+        };
+        serverDelete: {
+            hidden: true;
+        };
+        serverList: {
+            hidden: true;
+        };
+    };
+}>;
+export type EmailTemplateCrud = CrudTypeOf<typeof emailTemplateCrud>;

package/dist/interface/crud-deprecated/email-templates.js

@@ -0,0 +1,41 @@
+import { createCrud } from "../../crud";
+import { jsonSchema, yupMixed, yupObject, yupString } from "../../schema-fields";
+export const emailTemplateTypes = ['EMAIL_VERIFICATION', 'PASSWORD_RESET', 'MAGIC_LINK'];
+export const emailTemplateServerReadSchema = yupObject({
+    type: yupString().oneOf(emailTemplateTypes).required(),
+    subject: yupString().required(),
+    content: jsonSchema.required(),
+}).required();
+export const emailTemplateCrudServerUpdateSchema = yupObject({
+    content: jsonSchema.required(),
+    subject: yupString().required(),
+}).required();
+export const emailTemplateCrudServerDeleteSchema = yupMixed();
+export const emailTemplateCrudServerCreateSchema = yupObject({
+    type: yupString().oneOf(emailTemplateTypes).required(),
+    content: jsonSchema.required(),
+    subject: yupString().required(),
+}).required();
+export const emailTemplateCrud = createCrud({
+    serverReadSchema: emailTemplateServerReadSchema,
+    serverUpdateSchema: emailTemplateCrudServerUpdateSchema,
+    serverCreateSchema: emailTemplateCrudServerCreateSchema,
+    serverDeleteSchema: emailTemplateCrudServerDeleteSchema,
+    docs: {
+        serverRead: {
+            hidden: true,
+        },
+        serverCreate: {
+            hidden: true,
+        },
+        serverUpdate: {
+            hidden: true,
+        },
+        serverDelete: {
+            hidden: true,
+        },
+        serverList: {
+            hidden: true,
+        }
+    }
+});

package/dist/interface/crud-deprecated/oauth.d.ts

@@ -0,0 +1,24 @@
+import { CrudTypeOf } from "../../crud";
+export declare const accessTokenReadSchema: import("yup").ObjectSchema<{
+    access_token: string;
+}, import("yup").AnyObject, {
+    access_token: undefined;
+}, "">;
+export declare const accessTokenCreateSchema: import("yup").ObjectSchema<{
+    scope: string | undefined;
+}, import("yup").AnyObject, {
+    scope: undefined;
+}, "">;
+export declare const accessTokenCrud: import("../../crud").CrudSchemaFromOptions<{
+    clientReadSchema: import("yup").ObjectSchema<{
+        access_token: string;
+    }, import("yup").AnyObject, {
+        access_token: undefined;
+    }, "">;
+    clientCreateSchema: import("yup").ObjectSchema<{
+        scope: string | undefined;
+    }, import("yup").AnyObject, {
+        scope: undefined;
+    }, "">;
+}>;
+export type AccessTokenCrud = CrudTypeOf<typeof accessTokenCrud>;

package/dist/interface/crud-deprecated/oauth.js

@@ -0,0 +1,12 @@
+import { createCrud } from "../../crud";
+import { yupObject, yupString } from "../../schema-fields";
+export const accessTokenReadSchema = yupObject({
+    access_token: yupString().required(),
+}).required();
+export const accessTokenCreateSchema = yupObject({
+    scope: yupString().optional(),
+}).required();
+export const accessTokenCrud = createCrud({
+    clientReadSchema: accessTokenReadSchema,
+    clientCreateSchema: accessTokenCreateSchema,
+});