rimecms 0.22.0

package/dist/core/collections/api/getById.server.d.ts

@@ -0,0 +1,16 @@
+import type { CollectionSlug } from '../../types/doc.js';
+import { type RequestEvent } from '@sveltejs/kit';
+export default function (slug: CollectionSlug): (event: RequestEvent) => Promise<Response | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: import("../../../types").FormErrors;
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: {
+        email: string;
+    };
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: {};
+    errors: {
+        _form: string;
+    };
+}>>;

package/dist/core/collections/api/getById.server.js

@@ -0,0 +1,28 @@
+import { PARAMS } from '../../constant.js';
+import { handleError } from '../../errors/handler.server.js';
+import { trycatch } from '../../../util/function.js';
+import { json } from '@sveltejs/kit';
+export default function (slug) {
+    //
+    async function GET(event) {
+        const { rime } = event.locals;
+        const id = event.params.id || '-1';
+        const paramDepth = event.url.searchParams.get(PARAMS.DEPTH);
+        const paramDraft = event.url.searchParams.get(PARAMS.DRAFT);
+        const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+        const draft = paramDraft ? paramDraft === 'true' : undefined;
+        const depth = typeof paramDepth === 'string' ? parseInt(paramDepth) : 0;
+        const [error, document] = await trycatch(() => rime.collection(slug).findById({
+            id,
+            locale: rime.getLocale(),
+            depth,
+            draft,
+            versionId
+        }));
+        if (error) {
+            return handleError(error, { context: 'api' });
+        }
+        return json({ doc: document });
+    }
+    return GET;
+}

package/dist/core/collections/api/index.server.d.ts

@@ -0,0 +1,17 @@
+import create from './create.server.js';
+import deleteDocs from './delete.server.js';
+import deleteById from './deleteById.server.js';
+import duplicate from './duplicate.server.js';
+import get from './get.server.js';
+import getById from './getById.server.js';
+import updateById from './updateById.server.js';
+declare const operations: {
+    get: typeof get;
+    getById: typeof getById;
+    deleteById: typeof deleteById;
+    delete: typeof deleteDocs;
+    create: typeof create;
+    updateById: typeof updateById;
+    duplicate: typeof duplicate;
+};
+export default operations;

package/dist/core/collections/api/index.server.js

@@ -0,0 +1,9 @@
+import create from './create.server.js';
+import deleteDocs from './delete.server.js';
+import deleteById from './deleteById.server.js';
+import duplicate from './duplicate.server.js';
+import get from './get.server.js';
+import getById from './getById.server.js';
+import updateById from './updateById.server.js';
+const operations = { get, getById, deleteById, delete: deleteDocs, create, updateById, duplicate };
+export default operations;

package/dist/core/collections/api/updateById.server.d.ts

@@ -0,0 +1,16 @@
+import type { CollectionSlug } from '../../types/doc.js';
+import { type RequestEvent } from '@sveltejs/kit';
+export default function (slug: CollectionSlug): (event: RequestEvent) => Promise<Response | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: import("../../../types").FormErrors;
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: {
+        email: string;
+    };
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: {};
+    errors: {
+        _form: string;
+    };
+}>>;

package/dist/core/collections/api/updateById.server.js

@@ -0,0 +1,38 @@
+import { PARAMS } from '../../constant.js';
+import { handleError } from '../../errors/handler.server.js';
+import { RimeError } from '../../errors/index.js';
+import { extractData } from '../../operations/extract-data.server.js';
+import { trycatch } from '../../../util/function.js';
+import { json } from '@sveltejs/kit';
+export default function (slug) {
+    //
+    async function PATCH(event) {
+        const { rime } = event.locals;
+        const id = event.params.id;
+        if (!id)
+            throw new RimeError(RimeError.NOT_FOUND);
+        const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+        const draft = event.url.searchParams.get(PARAMS.DRAFT)
+            ? event.url.searchParams.get(PARAMS.DRAFT) === 'true'
+            : undefined;
+        const [extractError, data] = await trycatch(() => extractData(event.request));
+        if (extractError) {
+            return handleError(extractError, { context: 'api' });
+        }
+        if (data.locale) {
+            rime.setLocale(data.locale);
+        }
+        const [error, document] = await trycatch(() => rime.collection(slug).updateById({
+            id,
+            data,
+            locale: rime.getLocale(),
+            versionId,
+            draft
+        }));
+        if (error) {
+            return handleError(error, { context: 'api' });
+        }
+        return json({ doc: document });
+    }
+    return PATCH;
+}

package/dist/core/collections/auth/constant.server.d.ts

@@ -0,0 +1,9 @@
+export declare const PRIVATE_FIELDS: string[];
+export declare const BETTER_AUTH_ROLES: {
+    /** Panel users admin */
+    readonly ADMIN: "admin";
+    /** Panel users any role */
+    readonly STAFF: "staff";
+    /** All other users */
+    readonly USER: "user";
+};

package/dist/core/collections/auth/constant.server.js

@@ -0,0 +1,9 @@
+export const PRIVATE_FIELDS = ['password', 'token', 'isSuperAdmin', 'apiKeyId', 'authUserId'];
+export const BETTER_AUTH_ROLES = {
+    /** Panel users admin */
+    ADMIN: 'admin',
+    /** Panel users any role */
+    STAFF: 'staff',
+    /** All other users */
+    USER: 'user'
+};

package/dist/core/collections/auth/fields.d.ts

@@ -0,0 +1,193 @@
+declare const emailField: {
+    _metaUrl: string;
+    layout(layout: "compact" | "default"): /*elided*/ any;
+    readonly component: import("svelte").Component<import("../../../fields/email/component/props").EmailFieldProps, {}, "">;
+    unique(bool?: boolean): /*elided*/ any;
+    defaultValue(value: string | import("../../../fields/types").DefaultValueFn<string>): /*elided*/ any;
+    isTitle(): /*elided*/ any;
+    _generateSchema: null | ((args: {
+        camel: string;
+        snake: string;
+        suffix: string;
+    }) => string);
+    readonly name: string;
+    label(label: string): /*elided*/ any;
+    hidden(): /*elided*/ any;
+    localized(): /*elided*/ any;
+    validate(validateFunction: import("../../../fields/types").FieldValidationFunc<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+    condition(conditionFunction: (doc: import("../../../util/types").Dic, siblings: import("../../../util/types").Dic) => boolean): /*elided*/ any;
+    table(params?: import("../../../types").FieldPanelTableConfig | number): /*elided*/ any;
+    width(value: import("../../../fields/types").FieldWidth): /*elided*/ any;
+    required(bool?: boolean): /*elided*/ any;
+    access(access: {
+        create?: import("../../../fields/types").FieldAccess;
+        read?: import("../../../fields/types").FieldAccess;
+        update?: import("../../../fields/types").FieldAccess;
+    }): /*elided*/ any;
+    onChange(hook: import("../../../fields/types").FieldHookClient): /*elided*/ any;
+    hint(hint: string): /*elided*/ any;
+    clone(): /*elided*/ any;
+    $generateSchema(fn: (args: {
+        camel: string;
+        snake: string;
+        suffix: string;
+    }) => string): /*elided*/ any;
+    $beforeRead(hook: import("../../../fields/types").FieldHook<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+    $beforeSave(hook: import("../../../fields/types").FieldHook<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+    beforeValidate(hook: import("../../../fields/types").FieldHookShared): /*elided*/ any;
+    field: import("../../../fields/email/index.js").EmailField;
+    className(str: string): /*elided*/ any;
+    compile(): {
+        type: "email";
+        live?: boolean | undefined;
+        condition?: ((doc: any, siblings: any) => boolean) | undefined;
+        width?: import("../../../fields/types").FieldWidth | undefined;
+        className?: string | undefined;
+        component: import("svelte").Component<any>;
+        cell: import("svelte").Component<any> | undefined;
+        access: {
+            create: import("../../../fields/types").FieldAccess;
+            read: import("../../../fields/types").FieldAccess;
+            update: import("../../../fields/types").FieldAccess;
+        };
+        name: string;
+        hidden?: boolean | undefined;
+        validate?: import("../../../fields/types").FieldValidationFunc<any> | undefined;
+        required?: boolean | undefined;
+        localized?: boolean | undefined;
+        label?: string | undefined;
+        hint?: string | undefined;
+        table?: {
+            cell?: import("svelte").Component<{
+                value: any;
+            }> | undefined;
+            sort?: boolean | undefined;
+            position: number;
+        } | undefined;
+        hooks?: {
+            beforeRead?: import("../../../fields/types").FieldHook<any>[] | undefined;
+            beforeSave?: import("../../../fields/types").FieldHook<any>[] | undefined;
+            beforeValidate?: import("../../../fields/types").FieldHookShared<any>[] | undefined;
+            onChange?: import("../../../fields/types").FieldHookClient[] | undefined;
+        } | undefined;
+        defaultValue?: string | import("../../../fields/types").DefaultValueFn<string> | undefined;
+        isEmpty: (value: unknown) => boolean;
+        placeholder?: string | undefined;
+        layout?: "compact" | "default" | undefined;
+        unique?: boolean | undefined;
+        isTitle?: true | undefined;
+    } & {
+        component: import("svelte").Component<any>;
+        cell?: import("svelte").Component<{
+            value: any;
+        }> | null;
+    };
+    live(bool: boolean): /*elided*/ any;
+    readonly type: string;
+    readonly raw: import("../../../fields/email/index.js").EmailField;
+    readonly cell: import("svelte").Component<{
+        value: any;
+    }> | null;
+};
+declare const name: import("../../../fields/text/index.js").TextFieldBuilder;
+declare const roles: import("../../../fields/select/index.js").SelectFieldBuilder;
+declare const password: import("../../../fields/text/index.js").TextFieldBuilder;
+declare const confirmPassword: import("../../../fields/text/index.js").TextFieldBuilder;
+export declare const usersFields: {
+    email: {
+        _metaUrl: string;
+        layout(layout: "compact" | "default"): /*elided*/ any;
+        readonly component: import("svelte").Component<import("../../../fields/email/component/props").EmailFieldProps, {}, "">;
+        unique(bool?: boolean): /*elided*/ any;
+        defaultValue(value: string | import("../../../fields/types").DefaultValueFn<string>): /*elided*/ any;
+        isTitle(): /*elided*/ any;
+        _generateSchema: null | ((args: {
+            camel: string;
+            snake: string;
+            suffix: string;
+        }) => string);
+        readonly name: string;
+        label(label: string): /*elided*/ any;
+        hidden(): /*elided*/ any;
+        localized(): /*elided*/ any;
+        validate(validateFunction: import("../../../fields/types").FieldValidationFunc<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+        condition(conditionFunction: (doc: import("../../../util/types").Dic, siblings: import("../../../util/types").Dic) => boolean): /*elided*/ any;
+        table(params?: import("../../../types").FieldPanelTableConfig | number): /*elided*/ any;
+        width(value: import("../../../fields/types").FieldWidth): /*elided*/ any;
+        required(bool?: boolean): /*elided*/ any;
+        access(access: {
+            create?: import("../../../fields/types").FieldAccess;
+            read?: import("../../../fields/types").FieldAccess;
+            update?: import("../../../fields/types").FieldAccess;
+        }): /*elided*/ any;
+        onChange(hook: import("../../../fields/types").FieldHookClient): /*elided*/ any;
+        hint(hint: string): /*elided*/ any;
+        clone(): /*elided*/ any;
+        $generateSchema(fn: (args: {
+            camel: string;
+            snake: string;
+            suffix: string;
+        }) => string): /*elided*/ any;
+        $beforeRead(hook: import("../../../fields/types").FieldHook<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+        $beforeSave(hook: import("../../../fields/types").FieldHook<import("../../../fields/email/index.js").EmailField>): /*elided*/ any;
+        beforeValidate(hook: import("../../../fields/types").FieldHookShared): /*elided*/ any;
+        field: import("../../../fields/email/index.js").EmailField;
+        className(str: string): /*elided*/ any;
+        compile(): {
+            type: "email";
+            live?: boolean | undefined;
+            condition?: ((doc: any, siblings: any) => boolean) | undefined;
+            width?: import("../../../fields/types").FieldWidth | undefined;
+            className?: string | undefined;
+            component: import("svelte").Component<any>;
+            cell: import("svelte").Component<any> | undefined;
+            access: {
+                create: import("../../../fields/types").FieldAccess;
+                read: import("../../../fields/types").FieldAccess;
+                update: import("../../../fields/types").FieldAccess;
+            };
+            name: string;
+            hidden?: boolean | undefined;
+            validate?: import("../../../fields/types").FieldValidationFunc<any> | undefined;
+            required?: boolean | undefined;
+            localized?: boolean | undefined;
+            label?: string | undefined;
+            hint?: string | undefined;
+            table?: {
+                cell?: import("svelte").Component<{
+                    value: any;
+                }> | undefined;
+                sort?: boolean | undefined;
+                position: number;
+            } | undefined;
+            hooks?: {
+                beforeRead?: import("../../../fields/types").FieldHook<any>[] | undefined;
+                beforeSave?: import("../../../fields/types").FieldHook<any>[] | undefined;
+                beforeValidate?: import("../../../fields/types").FieldHookShared<any>[] | undefined;
+                onChange?: import("../../../fields/types").FieldHookClient[] | undefined;
+            } | undefined;
+            defaultValue?: string | import("../../../fields/types").DefaultValueFn<string> | undefined;
+            isEmpty: (value: unknown) => boolean;
+            placeholder?: string | undefined;
+            layout?: "compact" | "default" | undefined;
+            unique?: boolean | undefined;
+            isTitle?: true | undefined;
+        } & {
+            component: import("svelte").Component<any>;
+            cell?: import("svelte").Component<{
+                value: any;
+            }> | null;
+        };
+        live(bool: boolean): /*elided*/ any;
+        readonly type: string;
+        readonly raw: import("../../../fields/email/index.js").EmailField;
+        readonly cell: import("svelte").Component<{
+            value: any;
+        }> | null;
+    };
+    name: import("../../../fields/text/index.js").TextFieldBuilder;
+    roles: import("../../../fields/select/index.js").SelectFieldBuilder;
+    password: import("../../../fields/text/index.js").TextFieldBuilder;
+    confirmPassword: import("../../../fields/text/index.js").TextFieldBuilder;
+};
+export { confirmPassword, emailField as email, name, password, roles };

package/dist/core/collections/auth/fields.js

@@ -0,0 +1,55 @@
+import { email } from '../../../fields/email/index.js';
+import { select } from '../../../fields/select/index.js';
+import { text } from '../../../fields/text/index.js';
+import { access } from '../../../util/access/index.js';
+import { validate } from '../../../util/index.js';
+const emailField = email('email')
+    .access({
+    create: () => true,
+    read: (user) => !!user,
+    update: () => false
+})
+    .required()
+    .unique();
+const name = text('name')
+    .access({
+    create: () => true,
+    read: (user) => !!user,
+    update: () => false
+})
+    .required();
+const roles = select('roles')
+    .options({ value: 'admin', label: 'Admin' }, { value: 'staff', label: 'Staff' })
+    .many()
+    .defaultValue(['staff'])
+    .required()
+    .access({
+    create: () => true,
+    read: (user) => !!user && access.isAdmin(user),
+    update: (user) => !!user && access.isAdmin(user)
+});
+const password = text('password')
+    .required()
+    .access({
+    create: () => true,
+    read: () => false,
+    update: () => false
+})
+    .validate((value) => validate.password(value));
+const confirmPassword = text('confirmPassword')
+    .label('Confirm password')
+    .required()
+    .validate((value, metas) => {
+    if (metas.data.password !== value) {
+        return 'password_mismatch';
+    }
+    return true;
+});
+export const usersFields = {
+    email: emailField,
+    name,
+    roles,
+    password,
+    confirmPassword
+};
+export { confirmPassword, emailField as email, name, password, roles };

package/dist/core/collections/auth/hooks/after-create/populate-api-key.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * After create populate the created API key
+ * on document so user can see it once.
+ */
+export declare const populateAPIKey: import("../../../../operations/hooks/index.server.js").Hook<"auth", "create", "after">;

package/dist/core/collections/auth/hooks/after-create/populate-api-key.server.js

@@ -0,0 +1,22 @@
+import { RimeError } from '../../../../errors/index.js';
+import { Hooks } from '../../../../operations/hooks/index.server.js';
+/**
+ * After create populate the created API key
+ * on document so user can see it once.
+ */
+export const populateAPIKey = Hooks.afterCreate(async (args) => {
+    const { config } = args;
+    const IS_API_AUTH = config.auth && config.auth.type === 'apiKey';
+    if (IS_API_AUTH) {
+        if (!args.context.apiKey)
+            throw new RimeError(RimeError.OPERATION_ERROR, 'missing key @populateAPIKey');
+        return {
+            ...args,
+            doc: {
+                ...args.doc,
+                apiKey: args.context.apiKey
+            }
+        };
+    }
+    return args;
+});

package/dist/core/collections/auth/hooks/after-delete/delete-better-auth-user.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * After delete, delete better-auth user
+ */
+export declare const deleteBetterAuthUser: import("../../../../operations/hooks/index.server.js").Hook<"auth", "delete", "after">;

package/dist/core/collections/auth/hooks/after-delete/delete-better-auth-user.server.js

@@ -0,0 +1,25 @@
+import { Hooks } from '../../../../operations/hooks/index.server.js';
+/**
+ * After delete, delete better-auth user
+ */
+export const deleteBetterAuthUser = Hooks.afterDelete(async (args) => {
+    const { doc, event, config } = args;
+    const IS_API_AUTH = config.auth && config.auth?.type === 'apiKey';
+    if (IS_API_AUTH && doc.apiKeyId) {
+        await event.locals.rime.auth.api.deleteApiKey({
+            headers: args.event.request.headers,
+            body: {
+                keyId: doc.apiKeyId
+            }
+        });
+    }
+    else if (doc.authUserId) {
+        await event.locals.rime.auth.api.removeUser({
+            body: {
+                userId: doc.authUserId
+            },
+            headers: args.event.request.headers
+        });
+    }
+    return args;
+});

package/dist/core/collections/auth/hooks/before-create/create-better-auth-user.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Create a better-auth user before a document creation
+ */
+export declare const createBetterAuthUser: import("../../../../operations/hooks/index.server.js").Hook<"auth", "create", "before">;

package/dist/core/collections/auth/hooks/before-create/create-better-auth-user.server.js

@@ -0,0 +1,186 @@
+import { dev } from '$app/environment';
+import { RimeError, RimeFormError } from '../../../../errors/index.js';
+import { Hooks } from '../../../../operations/hooks/index.server.js';
+import { access } from '../../../../../util/access/index.js';
+import { cases } from '../../../../../util/cases.js';
+import { BETTER_AUTH_ROLES } from '../../constant.server.js';
+/**
+ * Create a better-auth user before a document creation
+ */
+export const createBetterAuthUser = Hooks.beforeCreate(async (args) => {
+    const { config, event } = args;
+    const { rime } = event.locals;
+    if (!config.auth)
+        return args;
+    const IS_API_KEY_OPERATION = config.auth?.type === 'apiKey';
+    const ADMIN_ROLE_IN_DATA = Array.isArray(args.data.roles) && args.data.roles.includes(BETTER_AUTH_ROLES.ADMIN);
+    const IS_CURRENT_USER_ADMIN = access.isAdmin(event.locals.user);
+    const IS_CURRENT_USER_STAFF = Boolean(event.locals.user?.isStaff);
+    const IS_STAFF_CREATION = config.slug === 'staff';
+    const ADMIN_ROLE_ALLOWED = IS_STAFF_CREATION && Boolean(config.auth?.roles?.includes('admin'));
+    const CASE = cases({
+        /**
+         * 1. First-time Setup (Init)
+         * 	- Description: Creating the first admin user when the system is initialized
+         *		- Actor: No authenticated user exists yet
+         *			- Auth Flow:
+         *				- event.locals.isInit = true is set
+         *				- use admin plugin to creates user with "admin" role
+         *				- this will be the only isSuperAdmin user
+         */
+        INIT: Boolean(event.locals.isInit) && dev,
+        /**
+         *	2. Admin Creating Users
+         *		- Description: Admin creates any users through the panel
+         *		- Actor: Authenticated admin user
+         *		- Auth Flow:
+         *			- Use the admin plugin to create a user
+         */
+        ADMIN_CREATE_USER: IS_CURRENT_USER_ADMIN && !IS_API_KEY_OPERATION,
+        /*
+         * 3. Staff Creating users
+         *		- Description: Any panel user (staff collection) non admin, creating other users
+         *		- Actor: Authenticated staff user
+         *		- Auth Flow:
+         *			- ??
+         */
+        STAFF_CREATE_USER: IS_CURRENT_USER_STAFF && !IS_API_KEY_OPERATION,
+        /*
+         * 4. Public User Signup
+         * 	- Description: End users registering themselves or sigin with social Provider
+         * 	- Actor: Unauthenticated visitor
+         * 	- Auth Flow:
+         * 		- User submits signup form
+         * 		- Better-Auth creates user with 'user' role
+         * 		- Better-Auth hook call rime.collection(slug).create to create the document
+         */
+        PUBLIC_SIGNUP: Boolean(args.data.authUserId),
+        /**
+         * 6. API Key Creation
+         * 	- Description: Creating an API KEY
+         * 	- Actor: Authenticated user
+         * 	-	Auth Flow:
+         * 		- Admin creates API key user that forward current authneticated user
+         * 		- API key generated and send by email
+         */
+        API_KEY_CREATION: IS_API_KEY_OPERATION && Boolean(event.locals.user) && Boolean(event.locals.betterAuthUser?.id)
+        /**
+         * 7. Programmatic User Creation : API_KEY APP create user
+         * 	- Description: Creating an API KEY
+         * 	- Actor: Authenticated user related to the API_KEY
+         * 	- equivalent to ADMIN_CREATE_USER or STAFF_CREATE_USER
+         *
+         * Not implemented :
+         * 8. Invitation-based User Creation
+         */
+    });
+    // Prevent superAdmin value to be set on creation
+    if ('isSuperAdmin' in args.data && CASE.value !== CASE.INIT) {
+        throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    let authUserId;
+    switch (CASE.value) {
+        case CASE.INIT:
+            authUserId = args.data.authUserId;
+            break;
+        case CASE.ADMIN_CREATE_USER: {
+            // Define better-auth role
+            const role = cases({
+                [BETTER_AUTH_ROLES.ADMIN]: ADMIN_ROLE_IN_DATA && ADMIN_ROLE_ALLOWED,
+                [BETTER_AUTH_ROLES.STAFF]: !ADMIN_ROLE_IN_DATA && IS_STAFF_CREATION,
+                [BETTER_AUTH_ROLES.USER]: true
+            });
+            const result = await rime.auth.api.createUser({
+                headers: args.event.request.headers,
+                body: {
+                    email: args.data.email,
+                    password: args.data.password,
+                    name: args.data.name,
+                    data: {
+                        type: config.slug
+                    },
+                    role: role.value
+                }
+            });
+            authUserId = result.user.id;
+            break;
+        }
+        //
+        case CASE.STAFF_CREATE_USER: {
+            // Define better-auth role, staff can't create admin
+            const role = cases({
+                [BETTER_AUTH_ROLES.STAFF]: IS_STAFF_CREATION,
+                [BETTER_AUTH_ROLES.USER]: true
+            });
+            const result = await rime.auth.api.createUser({
+                headers: args.event.request.headers,
+                body: {
+                    email: args.data.email,
+                    password: args.data.password,
+                    name: args.data.name,
+                    data: {
+                        type: config.slug
+                    },
+                    role: role.value
+                }
+            });
+            authUserId = result.user.id;
+            break;
+        }
+        case CASE.API_KEY_CREATION: {
+            if (!event.locals.betterAuthUser || !event.locals.user) {
+                throw new RimeError(RimeError.UNAUTHORIZED);
+            }
+            if (!rime.mailer) {
+                throw new RimeError(RimeError.OPERATION_ERROR, `Can't create API KEY without smtp config`);
+            }
+            if (!args.data.name) {
+                throw new RimeFormError({ name: RimeFormError.REQUIRED_FIELD });
+            }
+            const apiKey = await rime.auth.api.createApiKey({
+                body: {
+                    name: args.data.name,
+                    userId: event.locals.betterAuthUser.id,
+                    permissions: {
+                        roles: args.data.roles || [BETTER_AUTH_ROLES.USER]
+                    }
+                }
+            });
+            // Send api key by email to the user
+            await rime.mailer.sendMail({
+                to: event.locals.user.email,
+                subject: 'Your API Key',
+                text: `Your ${args.data.name} apiKey : ${apiKey}, keep it safe, only server-side`
+            });
+            return {
+                ...args,
+                context: {
+                    ...args.context,
+                    apiKey: apiKey.key
+                },
+                data: {
+                    ...args.data,
+                    apiKeyId: apiKey.id,
+                    authUserId: event.locals.betterAuthUser.id,
+                    ownerId: event.locals.user.id
+                }
+            };
+        }
+        case CASE.PUBLIC_SIGNUP:
+            authUserId = args.data.authUserId;
+            break;
+        /**
+         * Any other case : throw UNAUTHORIZED
+         *  - unauthenticated user using direct API calls ex: POST /api/staff
+         */
+        default:
+            throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    return {
+        ...args,
+        data: {
+            ...args.data,
+            authUserId: authUserId
+        }
+    };
+});

package/dist/core/collections/auth/hooks/before-delete/prevent-superadmin-deletion.server.d.ts

@@ -0,0 +1 @@
+export declare const preventSupperAdminDeletion: import("../../../../operations/hooks/index.server.js").Hook<"raw", "delete", "before">;