rimecms 0.22.0

package/dist/panel/navigation.d.ts

@@ -0,0 +1,13 @@
+import type { User } from '../core/collections/auth/types.js';
+import type { BuildConfig } from '../core/config/server/index.server.js';
+import type { Config } from '../types.js';
+import type { Dic } from '../util/types.js';
+/**
+ * Builds navigation structure based on config and user permissions
+ * @param config - Compiled configuration object
+ * @param user - Current user object (optional)
+ * @returns Dictionary of navigation groups
+ */
+declare const buildNavigation: <C extends Config>(config: BuildConfig<C>, user: User | undefined) => Dic;
+export default buildNavigation;
+export type Navigation = ReturnType<typeof buildNavigation>;

package/dist/panel/navigation.js

@@ -0,0 +1,59 @@
+import { panelUrl } from './util/url.js';
+/**
+ * Builds navigation structure based on config and user permissions
+ * @param config - Compiled configuration object
+ * @param user - Current user object (optional)
+ * @returns Dictionary of navigation groups
+ */
+const buildNavigation = (config, user) => {
+    const groups = {};
+    /**
+     * Adds a route to the appropriate navigation group
+     */
+    const addRouteToGroup = (route, group) => {
+        if (group) {
+            if (!(group in groups)) {
+                groups[group] = [];
+            }
+            groups[group].push(route);
+        }
+        else {
+            groups.none.push(route);
+        }
+    };
+    // Process collections
+    config.collections
+        .filter((collection) => collection.panel !== false)
+        .forEach((collection) => {
+        if (user && collection.access.read(user, {})) {
+            const route = {
+                title: collection.label.plural,
+                icon: collection.slug,
+                url: panelUrl(collection.kebab)
+            };
+            addRouteToGroup(route, (collection.panel && collection.panel?.group) || 'collections');
+        }
+    });
+    // Process areas
+    config.areas.forEach((area) => {
+        if (user && area.access.read(user, {})) {
+            const route = {
+                title: area.label,
+                icon: area.slug,
+                url: panelUrl(area.kebab)
+            };
+            addRouteToGroup(route, (area.panel && area.panel?.group) || 'areas');
+        }
+    });
+    // Process custom panel routes
+    Object.entries(config.panel.routes).forEach(([routePath, routeConfig]) => {
+        const route = {
+            title: routeConfig.label,
+            icon: `custom-${routePath}`,
+            url: panelUrl(routePath)
+        };
+        addRouteToGroup(route, routeConfig.group);
+    });
+    return groups;
+};
+export default buildNavigation;

package/dist/panel/pages/area/Area.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	import Document from '../../components/sections/document/Document.svelte';
+	import Unauthorized from '../../components/sections/unauthorized/Unauthorized.svelte';
+	import { API_PROXY, setAPIProxyContext } from '../../context/api-proxy.svelte.js';
+	import Page from '../../components/sections/page-layout/Page.svelte';
+	import type { AreaDocData } from '../../index.js';
+	
+	const { data }: { data : AreaDocData<false>} = $props();
+	
+	setAPIProxyContext(API_PROXY.DOCUMENT);
+</script>
+
+{#if data.status === 200}
+	<Page>
+		{#snippet main()}
+			{#key data.doc.id + data.doc.versionId || '' + data.doc.locale || ''}
+				<Document doc={data.doc} readOnly={data.readOnly} operation="update" />
+			{/key}
+		{/snippet}
+	</Page>
+{:else}
+	<Unauthorized />
+{/if}

package/dist/panel/pages/area/Area.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { AreaDocData } from '../../index.js';
+type $$ComponentProps = {
+    data: AreaDocData<false>;
+};
+declare const Area: import("svelte").Component<$$ComponentProps, {}, "">;
+type Area = ReturnType<typeof Area>;
+export default Area;

package/dist/panel/pages/area/AreaVersionsDoc.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+	import Document from '../../components/sections/document/Document.svelte';
+	import Versions from '../../components/sections/document/Versions.svelte';
+	import Page from '../../components/sections/page-layout/Page.svelte';
+	import Unauthorized from '../../components/sections/unauthorized/Unauthorized.svelte';
+	import { API_PROXY, setAPIProxyContext } from '../../context/api-proxy.svelte.js';
+	import type { AreaDocData } from '../../index.js';
+
+	const { data }: { data: AreaDocData<true> } = $props();
+
+	setAPIProxyContext(API_PROXY.DOCUMENT);
+</script>
+
+{#if data.status === 200}
+	{#key data.doc.id + data.doc.versionId || '' + data.doc.locale || ''}
+		<Page>
+			{#snippet main()}
+				<Document doc={data.doc} operation={data.operation} readOnly={data.readOnly} />
+			{/snippet}
+			{#snippet aside()}
+				<Versions doc={data.doc} versions={data.versions} />
+			{/snippet}
+		</Page>
+	{/key}
+{:else}
+	<Unauthorized />
+{/if}

package/dist/panel/pages/area/AreaVersionsDoc.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { AreaDocData } from '../../index.js';
+type $$ComponentProps = {
+    data: AreaDocData<true>;
+};
+declare const AreaVersionsDoc: import("svelte").Component<$$ComponentProps, {}, "">;
+type AreaVersionsDoc = ReturnType<typeof AreaVersionsDoc>;
+export default AreaVersionsDoc;

package/dist/panel/pages/area/actions.server.d.ts

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

package/dist/panel/pages/area/actions.server.js

@@ -0,0 +1,38 @@
+import { PARAMS } from '../../../core/constant.js';
+import { ERROR_CONTEXT, handleError } from '../../../core/errors/handler.server.js';
+import { extractData } from '../../../core/operations/extract-data.server.js';
+import { panelUrl } from '../../util/url.js';
+import { trycatch } from '../../../util/function.js';
+import { toKebabCase } from '../../../util/string.js';
+import { redirect } from '@sveltejs/kit';
+import { t__ } from '../../../core/i18n/index.js';
+export default function (slug) {
+    const actions = {
+        update: async (event) => {
+            const { rime, locale } = event.locals;
+            const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+            const draft = event.url.searchParams.get(PARAMS.DRAFT) === 'true';
+            const data = await extractData(event.request);
+            const [error, document] = await trycatch(() => rime.area(slug).update({
+                data,
+                versionId,
+                draft,
+                locale
+            }));
+            if (error) {
+                return handleError(error, { context: ERROR_CONTEXT.ACTION });
+            }
+            if (draft && 'versionId' in document) {
+                const referer = event.request.headers.get('referer');
+                if (referer && referer.includes('/versions')) {
+                    return redirect(303, `${panelUrl(toKebabCase(slug))}/versions?versionId=${document.versionId}`);
+                }
+                else {
+                    return redirect(303, `${panelUrl(toKebabCase(slug))}?versionId=${document.versionId}`);
+                }
+            }
+            return { document, message: t__('common.doc_updated') };
+        }
+    };
+    return actions;
+}

package/dist/panel/pages/area/load.server.d.ts

@@ -0,0 +1,18 @@
+import type { AreaSlug } from '../../../core/types/doc.js';
+import type { Route } from '../../types.js';
+import type { ServerLoadEvent } from '@sveltejs/kit';
+export default function <V extends boolean = boolean>(slug: AreaSlug, withVersions?: V): ({ locals, url, fetch }: ServerLoadEvent) => Promise<({
+    aria: Partial<Route>[];
+    doc: import("../../../core/types/doc.js").GenericDoc;
+    status: 200;
+    readOnly: boolean;
+} & {
+    operation: "update";
+}) | ({
+    aria: Partial<Route>[];
+    doc: {};
+    status: 401;
+    readOnly: true;
+} & {
+    operation: "update";
+})>;

package/dist/panel/pages/area/load.server.js

@@ -0,0 +1,47 @@
+import { apiUrl } from '../../../core/api/index.js';
+import { PARAMS } from '../../../core/constant.js';
+import { RimeError } from '../../../core/errors/index.js';
+import { withVersionsSuffix } from '../../../core/naming.js';
+import { panelUrl } from '../../util/url.js';
+import { trycatch } from '../../../util/function.js';
+import { toKebabCase } from '../../../util/string.js';
+export default function (slug, withVersions) {
+    //
+    const load = async ({ locals, url, fetch }) => {
+        const { rime, locale } = locals;
+        const area = rime.area(slug);
+        const authorizedRead = area.config.access.read(locals.user, {});
+        const authorizedUpdate = area.config.access.update(locals.user, {});
+        const aria = [
+            { title: 'Dashboard', icon: 'dashboard', url: panelUrl() },
+            { title: area.config.label }
+        ];
+        if (!authorizedRead) {
+            return { aria, doc: {}, operation: 'update', status: 401, readOnly: true };
+        }
+        const versionId = url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+        const draft = url.searchParams.get(PARAMS.DRAFT) ? url.searchParams.get(PARAMS.DRAFT) === 'true' : undefined;
+        const doc = await area.find({ locale, versionId, draft });
+        if (!authorizedUpdate) {
+            return { aria, doc, operation: 'update', status: 200, readOnly: true };
+        }
+        let data = {
+            aria,
+            doc,
+            operation: 'update',
+            status: 200,
+            readOnly: false
+        };
+        if (withVersions) {
+            const url = `${apiUrl(withVersionsSuffix(toKebabCase(doc._type)))}?where[ownerId][equals]=${doc.id}&sort=-updatedAt&select=updatedAt,status`;
+            const promise = fetch(url).then((r) => r.json());
+            const [error, result] = await trycatch(promise);
+            if (error || !Array.isArray(result.docs)) {
+                throw new RimeError(RimeError.OPERATION_ERROR, 'while getting versions');
+            }
+            data = { ...data, versions: result.docs };
+        }
+        return data;
+    };
+    return load;
+}

package/dist/panel/pages/auth/fields.d.ts

@@ -0,0 +1,4 @@
+import type { EmailField, SimplerField, TextField } from '../../../fields/types.js';
+export declare const passwordField: SimplerField<TextField>;
+export declare const emailField: SimplerField<EmailField>;
+export declare const nameField: SimplerField<TextField>;

package/dist/panel/pages/auth/fields.js

@@ -0,0 +1,23 @@
+import { email as validateEmail } from '../../../util/validate.js';
+export const passwordField = {
+    name: 'password',
+    type: 'text',
+    layout: 'compact',
+    required: true,
+    isEmpty: (value) => !value
+};
+export const emailField = {
+    name: 'email',
+    type: 'email',
+    layout: 'compact',
+    required: true,
+    validate: validateEmail,
+    isEmpty: (value) => !value
+};
+export const nameField = {
+    name: 'name',
+    type: 'text',
+    layout: 'compact',
+    required: true,
+    isEmpty: (value) => !value
+};

package/dist/panel/pages/auth/forgot-password/ForgotPassword.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+	import { t__ } from '../../../../core/i18n/index.js';
+	import Email from '../../../../fields/email/component/Email.svelte';
+	import AuthForm from '../../../components/sections/auth/AuthForm.svelte';
+	import Button from '../../../components/ui/button/button.svelte';
+	import { setFormContext } from '../../../context/form.svelte';
+	import { emailField } from '../fields.js';
+	import { authClient } from '../../../util/auth';
+	import { toast } from 'svelte-sonner';
+
+	type Props = {
+		data: {
+			image: string | null;
+		};
+	};
+	const { data }: Props = $props();
+
+	const context = setFormContext({}, 'login');
+
+	let success = $state(false);
+
+	$effect(() => {
+		const formError = context.errors.get('_form');
+		if (typeof formError === 'string') {
+			toast.error(t__(`errors.${formError}`));
+		}
+	});
+
+	async function sendResetPasswordMail() {
+		const { data, error } = await authClient.forgetPassword({
+			email: context.values.email,
+			redirectTo: `/reset-password`
+		});
+		if (error && error.message) {
+			toast.error(error.message);
+		}
+		if (data && data.status) {
+			success = data.status;
+		}
+	}
+</script>
+
+<AuthForm image={data.image} title={t__('common.forgotPassword')}>
+	{#if success}
+		<p>{t__('common.passwordResetLinkSent', context.values.email)}</p>
+	{:else}
+		<Email config={emailField} form={context} />
+		<Button size="xl" disabled={!context.canSubmit} onclick={sendResetPasswordMail}>
+			{t__('common.requestPasswordReset')}
+		</Button>
+	{/if}
+</AuthForm>
+
+<style>
+	p {
+		font-size: var(--rz-text-lg);
+		font-variation-settings: 'wght' 600;
+		font-weight: 600;
+	}
+</style>

package/dist/panel/pages/auth/forgot-password/ForgotPassword.svelte.d.ts

@@ -0,0 +1,8 @@
+type Props = {
+    data: {
+        image: string | null;
+    };
+};
+declare const ForgotPassword: import("svelte").Component<Props, {}, "">;
+type ForgotPassword = ReturnType<typeof ForgotPassword>;
+export default ForgotPassword;

package/dist/panel/pages/auth/forgot-password/load.server.d.ts

@@ -0,0 +1,5 @@
+import { type ServerLoadEvent } from '@sveltejs/kit';
+export declare const forgotPasswordLoad: ({ locals }: ServerLoadEvent) => Promise<{
+    form: {};
+    image: string | null;
+}>;

package/dist/panel/pages/auth/forgot-password/load.server.js

@@ -0,0 +1,19 @@
+import { error, redirect } from '@sveltejs/kit';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+export const forgotPasswordLoad = async ({ locals }) => {
+    const { session, rime } = locals;
+    if (!('mailer' in rime)) {
+        return error(404);
+    }
+    if (session) {
+        throw redirect(302, '/');
+    }
+    else {
+        const imageExist = existsSync(path.join(process.cwd(), 'static', 'panel.jpg'));
+        return {
+            form: {},
+            image: imageExist ? '/panel/panel.jpg' : null
+        };
+    }
+};

package/dist/panel/pages/auth/index.d.ts

@@ -0,0 +1,4 @@
+import ForgotPassword from './forgot-password/ForgotPassword.svelte';
+import SignIn from './sign-in/SignIn.svelte';
+import ResetPassword from './reset-password/ResetPassword.svelte';
+export { ForgotPassword, SignIn, ResetPassword };

package/dist/panel/pages/auth/index.js

@@ -0,0 +1,4 @@
+import ForgotPassword from './forgot-password/ForgotPassword.svelte';
+import SignIn from './sign-in/SignIn.svelte';
+import ResetPassword from './reset-password/ResetPassword.svelte';
+export { ForgotPassword, SignIn, ResetPassword };

package/dist/panel/pages/auth/index.server.d.ts

@@ -0,0 +1,18 @@
+export declare const authActions: {
+    signIn: import("@sveltejs/kit").Actions;
+};
+export declare const authLoads: {
+    resetPassword: ({ locals, url }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+        image: string | null;
+        token: string;
+    }>;
+    forgotPassword: ({ locals }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+        form: {};
+        image: string | null;
+    }>;
+    signIn: ({ locals }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+        forgotPasswordEnabled: boolean;
+        image: string | null;
+        form: {};
+    }>;
+};

package/dist/panel/pages/auth/index.server.js

@@ -0,0 +1,12 @@
+import { forgotPasswordLoad as forgotPassword } from './forgot-password/load.server.js';
+import { resetPasswordLoad as resetPassword } from './reset-password/load.server.js';
+import { signInLoad } from './sign-in/load.server.js';
+import { signInActions as signIn } from './sign-in/actions.server.js';
+export const authActions = {
+    signIn
+};
+export const authLoads = {
+    resetPassword,
+    forgotPassword,
+    signIn: signInLoad
+};

package/dist/panel/pages/auth/reset-password/ResetPassword.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+	import { t__ } from '../../../../core/i18n';
+	import Text from '../../../../fields/text/component/Text.svelte';
+	import AuthForm from '../../../components/sections/auth/AuthForm.svelte';
+	import Button from '../../../components/ui/button/button.svelte';
+	import { setFormContext } from '../../../context/form.svelte';
+	import { passwordField } from '../fields.js';
+	import { authClient } from '../../../util/auth';
+	import { toast } from 'svelte-sonner';
+
+	let success = $state(false);
+
+	const form = setFormContext({}, 'reset-password');
+
+	type Props = {
+		data: {
+			image: string | null;
+		};
+	};
+	const { data }: Props = $props();
+
+	const passwordConfig = {
+		...passwordField,
+		placeholder: t__('common.newPassword')
+	};
+	const confirmPasswordConfig = {
+		...passwordField,
+		name: 'confirmPassword',
+		placeholder: t__('common.confirmPassword')
+	};
+
+	async function resetPassword() {
+		const token = new URLSearchParams(window.location.search).get('token');
+		if (!token) {
+			return toast.error('An error occured');
+		}
+		const { data, error } = await authClient.resetPassword({
+			newPassword: form.values.password,
+			token
+		});
+		if (error) {
+			console.error(error);
+			return toast.error(error.message || 'An error occured');
+		}
+		success = data?.status;
+	}
+</script>
+
+<AuthForm image={data.image} title={t__('common.resetPassword')}>
+	{#if success}
+		<p>{t__('common.reset_password_success')}</p>
+		<Button size="xl" href="/panel/sign-in">{t__('common.signin')}</Button>
+	{:else}
+		<Text type="password" config={passwordConfig} {form} />
+		<Text type="password" config={confirmPasswordConfig} {form} />
+
+		<Button
+			size="xl"
+			disabled={!(form.canSubmit && form.values.password && form.values.confirmPassword)}
+			onclick={resetPassword}
+		>
+			{t__('common.resetPassword')}
+		</Button>
+	{/if}
+</AuthForm>

package/dist/panel/pages/auth/reset-password/ResetPassword.svelte.d.ts

@@ -0,0 +1,8 @@
+type Props = {
+    data: {
+        image: string | null;
+    };
+};
+declare const ResetPassword: import("svelte").Component<Props, {}, "">;
+type ResetPassword = ReturnType<typeof ResetPassword>;
+export default ResetPassword;

package/dist/panel/pages/auth/reset-password/load.server.d.ts

@@ -0,0 +1,5 @@
+import { type ServerLoadEvent } from '@sveltejs/kit';
+export declare const resetPasswordLoad: ({ locals, url }: ServerLoadEvent) => Promise<{
+    image: string | null;
+    token: string;
+}>;

package/dist/panel/pages/auth/reset-password/load.server.js

@@ -0,0 +1,21 @@
+import { error, redirect } from '@sveltejs/kit';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+export const resetPasswordLoad = async ({ locals, url }) => {
+    const hasParams = url.searchParams.toString() !== '';
+    if (!('mailer' in locals.rime)) {
+        return error(404);
+    }
+    if (!hasParams) {
+        throw redirect(302, '/');
+    }
+    const imageExist = existsSync(path.join(process.cwd(), 'static', 'panel.jpg'));
+    const token = url.searchParams.get('token');
+    if (!token) {
+        throw error(400, 'invalid link');
+    }
+    return {
+        image: imageExist ? '/panel/panel.jpg' : null,
+        token: token
+    };
+};

package/dist/panel/pages/auth/sign-in/SignIn.svelte

@@ -0,0 +1,49 @@
+<script lang="ts">
+	import { enhance } from '$app/forms';
+	import { t__ } from '../../../../core/i18n/index.js';
+	import Email from '../../../../fields/email/component/Email.svelte';
+	import Text from '../../../../fields/text/component/Text.svelte';
+	import AuthForm from '../../../components/sections/auth/AuthForm.svelte';
+	import Button from '../../../components/ui/button/button.svelte';
+	import { setFormContext } from '../../../context/form.svelte';
+	import { emailField, passwordField } from '../fields.js';
+	import type { FormErrors } from '../../../../types.js';
+	import { KeyRound } from '@lucide/svelte';
+	import { toast } from 'svelte-sonner';
+
+	type Props = {
+		data: {
+			forgotPasswordEnabled: boolean;
+			image: string | null;
+			form: { email?: string; password?: string; errors?: FormErrors };
+		};
+	};
+	const { data }: Props = $props();
+
+	const context = setFormContext(data.form, 'login');
+
+	$effect(() => {
+		const formError = context.errors.get('_form');
+		if (typeof formError === 'string') {
+			toast.error(t__(`errors.${formError}`));
+		}
+	});
+</script>
+
+<AuthForm image={data.image} title={t__('common.signin')}>
+	{#if context.status !== 429}
+		<form method="POST" action="/panel/sign-in" use:enhance={context.enhance}>
+			<Email config={emailField} form={context} />
+			<Text type="password" icon={KeyRound} config={passwordField} form={context} />
+			<Button size="xl" disabled={!context.canSubmit} type="submit">Login</Button>
+
+			{#if data.forgotPasswordEnabled}
+				<Button variant="link" href="/forgot-password">
+					{t__('common.forgotPassword')}
+				</Button>
+			{/if}
+		</form>
+	{:else}
+		<p class="rz-locked">{t__(`errors.user_banned`)}</p>
+	{/if}
+</AuthForm>

package/dist/panel/pages/auth/sign-in/SignIn.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { FormErrors } from '../../../../types.js';
+type Props = {
+    data: {
+        forgotPasswordEnabled: boolean;
+        image: string | null;
+        form: {
+            email?: string;
+            password?: string;
+            errors?: FormErrors;
+        };
+    };
+};
+declare const SignIn: import("svelte").Component<Props, {}, "">;
+type SignIn = ReturnType<typeof SignIn>;
+export default SignIn;

package/dist/panel/pages/auth/sign-in/actions.server.d.ts

@@ -0,0 +1,2 @@
+import { type Actions } from '@sveltejs/kit';
+export declare const signInActions: Actions;

package/dist/panel/pages/auth/sign-in/actions.server.js

@@ -0,0 +1,41 @@
+import { dev } from '$app/environment';
+import { handleError } from '../../../../core/errors/handler.server.js';
+import { RimeFormError } from '../../../../core/errors/index.js';
+import { redirect } from '@sveltejs/kit';
+export const signInActions = {
+    default: async ({ cookies, request, locals }) => {
+        const { rime } = locals;
+        const data = await request.formData();
+        const email = data.get('email')?.toString() || '';
+        const password = data.get('password')?.toString() || '';
+        const response = await rime.auth.api.signInEmail({
+            body: { email, password },
+            asResponse: true
+        });
+        const authenticated = response && response.status === 200;
+        if (!authenticated) {
+            return handleError(new RimeFormError({
+                _form: RimeFormError.INVALID_CREDENTIALS,
+                email: RimeFormError.INVALID_CREDENTIALS,
+                password: RimeFormError.INVALID_CREDENTIALS
+            }), {
+                context: 'action',
+                formData: { email }
+            });
+        }
+        const setCookieHeader = response.headers.get('set-cookie');
+        if (setCookieHeader) {
+            const parsedCookie = setCookieHeader.split(';')[0];
+            const [name, encodedValue] = parsedCookie.split('=');
+            const decodedValue = decodeURIComponent(encodedValue);
+            cookies.set(name, decodedValue, {
+                path: '/',
+                httpOnly: true,
+                sameSite: 'lax',
+                maxAge: 604800,
+                secure: !dev
+            });
+        }
+        throw redirect(302, '/panel');
+    }
+};