@ekrist1/vulse 0.1.6-alpha.3

package/dist/server/plugins.js

@@ -0,0 +1,134 @@
+import { ValidationError } from '../core/errors.js';
+import { assertValidPluginId, } from '../core/plugins/definition.js';
+import { sendFormEmail } from './forms/email.js';
+const DEFAULT_HOOK_TIMEOUT_MS = 5_000;
+let registeredPlugins = [];
+function orderedPlugins() {
+    return [...registeredPlugins].sort((a, b) => {
+        const priority = (b.plugin.priority ?? 0) - (a.plugin.priority ?? 0);
+        return priority || a.order - b.order;
+    });
+}
+export function setVulsePlugins(plugins = []) {
+    const seen = new Set();
+    registeredPlugins = plugins.map((plugin, order) => {
+        assertValidPluginId(plugin.id);
+        if (seen.has(plugin.id))
+            throw new Error(`Vulse plugin "${plugin.id}" is registered more than once`);
+        seen.add(plugin.id);
+        return { plugin, order };
+    });
+}
+export function getVulsePlugins() {
+    return orderedPlugins().map(({ plugin }) => plugin);
+}
+export function __testResetVulsePlugins() {
+    registeredPlugins = [];
+}
+function loggerFor(pluginId) {
+    return {
+        debug: (message, data) => console.debug(`[vulse:${pluginId}] ${message}`, data ?? ''),
+        info: (message, data) => console.info(`[vulse:${pluginId}] ${message}`, data ?? ''),
+        warn: (message, data) => console.warn(`[vulse:${pluginId}] ${message}`, data ?? ''),
+        error: (message, data) => console.error(`[vulse:${pluginId}] ${message}`, data ?? ''),
+    };
+}
+function pluginContext(pluginId, env) {
+    const safeEnv = env ?? {};
+    return {
+        env: safeEnv,
+        logger: loggerFor(pluginId),
+        email: {
+            send: async (input) => {
+                await sendFormEmail(safeEnv, {
+                    to: input.to,
+                    subject: input.subject,
+                    body: input.body ?? input.text ?? input.html ?? '',
+                });
+            },
+        },
+    };
+}
+async function withTimeout(promise, pluginId, hookName) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new Error(`Vulse plugin "${pluginId}" hook "${hookName}" timed out`));
+                }, DEFAULT_HOOK_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function invokeHook(plugin, hookName, event, env) {
+    const hook = plugin.hooks?.[hookName];
+    if (!hook)
+        return undefined;
+    return await withTimeout(Promise.resolve(hook(event, pluginContext(plugin.id, env))), plugin.id, hookName);
+}
+async function runContinueHook(hookName, event, env) {
+    for (const { plugin } of orderedPlugins()) {
+        try {
+            await invokeHook(plugin, hookName, event, env);
+        }
+        catch (err) {
+            pluginContext(plugin.id, env).logger.error(`Hook "${hookName}" failed`, err);
+        }
+    }
+}
+export async function runFormBeforeSubmitHooks(event, env) {
+    let payload = event.payload;
+    for (const { plugin } of orderedPlugins()) {
+        const result = await invokeHook(plugin, 'form:beforeSubmit', { ...event, payload }, env);
+        if (!result)
+            continue;
+        if (result.action === 'drop') {
+            return { action: 'drop', ...(result.reason ? { reason: result.reason } : {}) };
+        }
+        if (result.action === 'reject') {
+            throw new ValidationError(result.message ?? `Submission rejected by plugin "${plugin.id}"`, { plugin: plugin.id });
+        }
+        if (result.payload)
+            payload = result.payload;
+    }
+    return { action: 'continue', payload };
+}
+export async function runFormAfterSubmitHooks(event, env) {
+    await runContinueHook('form:afterSubmit', event, env);
+}
+export async function runFormBeforeProcessHooks(event, env) {
+    for (const { plugin } of orderedPlugins()) {
+        await invokeHook(plugin, 'form:beforeProcess', event, env);
+    }
+}
+export async function runFormAfterProcessHooks(event, env) {
+    await runContinueHook('form:afterProcess', event, env);
+}
+export async function runAuthUserBeforeCreateHooks(event, env) {
+    let user = event.user;
+    let changed = false;
+    for (const { plugin } of orderedPlugins()) {
+        const result = await invokeHook(plugin, 'auth:userBeforeCreate', { user }, env);
+        if (result === false)
+            return false;
+        if (!result)
+            continue;
+        if (result.action === 'reject') {
+            throw new Error(result.message ?? `User rejected by plugin "${plugin.id}"`);
+        }
+        if (result.data) {
+            user = { ...user, ...result.data };
+            changed = true;
+        }
+    }
+    return changed ? user : undefined;
+}
+export async function runAuthUserAfterCreateHooks(event, env) {
+    await runContinueHook('auth:userAfterCreate', event, env);
+}

package/dist/server/preview.d.ts

@@ -0,0 +1,7 @@
+export declare function mintPreviewToken(secret: string, userId: string, ttlSeconds?: number): Promise<string>;
+export declare function verifyPreviewToken(secret: string, token: string): Promise<boolean>;
+export declare function previewSecret(env: {
+    VULSE_PREVIEW_SECRET?: string;
+    BETTER_AUTH_SECRET: string;
+}): string;
+//# sourceMappingURL=preview.d.ts.map

package/dist/server/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/server/preview.ts"],"names":[],"mappings":"AAIA,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,SAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAM5G;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQxF;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE;IAAE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAExG"}

package/dist/server/preview.js

@@ -0,0 +1,22 @@
+import { SignJWT, jwtVerify } from 'jose';
+const ALG = 'HS256';
+export async function mintPreviewToken(secret, userId, ttlSeconds = 60 * 60) {
+    const key = new TextEncoder().encode(secret);
+    return await new SignJWT({ sub: userId, kind: 'vulse-preview' })
+        .setProtectedHeader({ alg: ALG })
+        .setExpirationTime(Math.floor(Date.now() / 1000) + ttlSeconds)
+        .sign(key);
+}
+export async function verifyPreviewToken(secret, token) {
+    try {
+        const key = new TextEncoder().encode(secret);
+        const { payload } = await jwtVerify(token, key);
+        return payload.kind === 'vulse-preview';
+    }
+    catch {
+        return false;
+    }
+}
+export function previewSecret(env) {
+    return env.VULSE_PREVIEW_SECRET ?? env.BETTER_AUTH_SECRET;
+}

package/dist/server/r2.d.ts

@@ -0,0 +1,8 @@
+export interface UploadContext {
+    bucket: R2Bucket;
+}
+export declare function putToR2(ctx: UploadContext, body: ArrayBuffer, mime: string): Promise<{
+    key: string;
+}>;
+export declare function deleteFromR2(ctx: UploadContext, key: string): Promise<void>;
+//# sourceMappingURL=r2.d.ts.map

package/dist/server/r2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2.d.ts","sourceRoot":"","sources":["../../src/server/r2.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAAG,MAAM,EAAE,QAAQ,CAAA;CAAE;AAEnD,wBAAsB,OAAO,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAI3G;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjF"}

package/dist/server/r2.js

@@ -0,0 +1,9 @@
+import { nanoid } from 'nanoid';
+export async function putToR2(ctx, body, mime) {
+    const key = `${new Date().toISOString().slice(0, 10)}/${nanoid()}`;
+    await ctx.bucket.put(key, body, { httpMetadata: { contentType: mime } });
+    return { key };
+}
+export async function deleteFromR2(ctx, key) {
+    await ctx.bucket.delete(key);
+}

package/dist/server/routes/blueprints.d.ts

@@ -0,0 +1,10 @@
+import type { Auth } from '../better-auth.js';
+import type { VulseDb } from '../../core/db.js';
+export declare function blueprintsRoutes(db: VulseDb, auth: Auth): {
+    list: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    get: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    create: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    update: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    delete: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+};
+//# sourceMappingURL=blueprints.d.ts.map

package/dist/server/routes/blueprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blueprints.d.ts","sourceRoot":"","sources":["../../../src/server/routes/blueprints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAkB/C,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI;;;;;;EAyCvD"}

package/dist/server/routes/blueprints.js

@@ -0,0 +1,46 @@
+import { z } from 'astro/zod';
+import { BlueprintDefinitionSchema, BlueprintDefinitionWithRenamesSchema, } from '../../core/blueprints/definition.js';
+import { createBlueprint, deleteBlueprint, getBlueprintDefinition, listBlueprintDefinitions, updateBlueprint, } from '../../core/blueprints/mutations.js';
+import { _resetRegistry } from '../../core/blueprints/load.js';
+import { _resetRuntime } from '../runtime.js';
+import { defineHandler } from '../handler.js';
+const paramsHandle = z.object({ handle: z.string() });
+export function blueprintsRoutes(db, auth) {
+    return {
+        list: defineHandler(auth, {}, async () => listBlueprintDefinitions(db)),
+        get: defineHandler(auth, { params: paramsHandle }, async ({ params }) => {
+            const def = await getBlueprintDefinition(db, params.handle);
+            if (!def)
+                throw new (await import('../../core/errors.js')).NotFoundError('blueprint not found');
+            return def;
+        }),
+        create: defineHandler(auth, {
+            body: BlueprintDefinitionSchema,
+            requireRole: ['admin'],
+        }, async ({ body }) => {
+            const out = await createBlueprint(db, body);
+            _resetRegistry();
+            _resetRuntime();
+            return out;
+        }),
+        update: defineHandler(auth, {
+            params: paramsHandle,
+            body: BlueprintDefinitionWithRenamesSchema,
+            requireRole: ['admin'],
+        }, async ({ params, body }) => {
+            const out = await updateBlueprint(db, params.handle, body);
+            _resetRegistry();
+            _resetRuntime();
+            return out;
+        }),
+        delete: defineHandler(auth, {
+            params: paramsHandle,
+            requireRole: ['admin'],
+        }, async ({ params }) => {
+            await deleteBlueprint(db, params.handle);
+            _resetRegistry();
+            _resetRuntime();
+            return null;
+        }),
+    };
+}

package/dist/server/routes/entries.d.ts

@@ -0,0 +1,16 @@
+import type { VulseDb } from '../../core/db.js';
+import type { Auth } from '../better-auth.js';
+import type { BlueprintRegistry } from '../../core/blueprints/registry.js';
+export declare function entriesRoutes(db: VulseDb, auth: Auth, reg: BlueprintRegistry): {
+    list: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    tree: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    findById: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    listLocales: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    create: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    createLocale: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    update: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    move: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    publish: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+    delete: (request: Request, rawParams?: Record<string, string>) => Promise<Response>;
+};
+//# sourceMappingURL=entries.d.ts.map

package/dist/server/routes/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../src/server/routes/entries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAmC1E,wBAAgB,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,iBAAiB;;;;;;;;;;;EAwN5E"}

package/dist/server/routes/entries.js

@@ -0,0 +1,262 @@
+import { z } from 'astro/zod';
+import { DEFAULT_LOCALE, EntriesRepo } from '../../core/repos/entries.js';
+import { AccessDeniedError, NotFoundError, ValidationError } from '../../core/errors.js';
+import { evaluate } from '../../core/access.js';
+import { parseContent } from '../../core/parse-content.js';
+import { defineHandler } from '../handler.js';
+import { isValidLocaleCode, readLocalesConfig } from '../../core/locales.js';
+/**
+ * The URL slug is owned by the entry locale row. If a user schema also declares a
+ * `slug` field (common for templates), it is hidden from the form; we mirror
+ * the canonical slug into content here so schemas that require it still parse.
+ */
+function withCanonicalSlug(content, slug) {
+    if (slug === undefined)
+        return content;
+    if (content === null || typeof content !== 'object' || Array.isArray(content))
+        return content;
+    return { ...content, slug };
+}
+const paramsByCollection = z.object({ collection: z.string() });
+const paramsById = z.object({ collection: z.string(), id: z.string() });
+async function resolveLocaleParam(db, raw) {
+    const cfg = await readLocalesConfig(db);
+    if (!raw || raw === DEFAULT_LOCALE)
+        return cfg.defaultLocale;
+    if (!isValidLocaleCode(raw))
+        throw new ValidationError(`Invalid locale code: ${raw}`);
+    if (!cfg.locales.includes(raw)) {
+        throw new ValidationError(`Locale '${raw}' is not enabled for this site.`, {
+            field: 'locale',
+            supported: cfg.locales,
+        });
+    }
+    return raw;
+}
+export function entriesRoutes(db, auth, reg) {
+    const entries = new EntriesRepo(db);
+    function blueprintFor(name) {
+        const bp = reg.get(name);
+        if (!bp)
+            throw new NotFoundError(`Unknown collection: ${name}`);
+        return bp;
+    }
+    return {
+        list: defineHandler(auth, { params: paramsByCollection }, async ({ params, url, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const locale = await resolveLocaleParam(db, url.searchParams.get('locale'));
+            if (!(await evaluate(bp, 'read', { user: authCtx.user }))) {
+                return await entries.list({ collection: params.collection, locale, status: 'published' });
+            }
+            const parentRaw = url.searchParams.get('parentId');
+            const parentId = parentRaw === 'root' || parentRaw === '' ? null : parentRaw ?? undefined;
+            return await entries.list({
+                collection: params.collection,
+                locale,
+                ...(parentId !== undefined ? { parentId } : {}),
+            });
+        }),
+        tree: defineHandler(auth, {
+            params: paramsByCollection,
+            requireRole: ['admin', 'editor'],
+        }, async ({ params, url }) => {
+            const bp = blueprintFor(params.collection);
+            if (!bp.tree)
+                throw new ValidationError('Collection does not support tree structure');
+            const locale = await resolveLocaleParam(db, url.searchParams.get('locale'));
+            return await entries.tree(params.collection, locale);
+        }),
+        findById: defineHandler(auth, { params: paramsById }, async ({ params, url, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const locale = await resolveLocaleParam(db, url.searchParams.get('locale'));
+            const row = await entries.findById(params.id, locale);
+            if (!row)
+                throw new NotFoundError(`Entry ${params.id} (${locale}) not found`);
+            const allowed = await evaluate(bp, 'read', {
+                user: authCtx.user,
+                entry: { id: row.id, status: row.status, createdBy: row.createdBy, content: row.content },
+            });
+            if (!allowed)
+                throw new NotFoundError(`Entry ${params.id} not found`);
+            return row;
+        }),
+        listLocales: defineHandler(auth, {
+            params: paramsById,
+            requireRole: ['admin', 'editor'],
+        }, async ({ params }) => {
+            blueprintFor(params.collection);
+            return await entries.listLocales(params.id);
+        }),
+        create: defineHandler(auth, {
+            params: paramsByCollection,
+            body: z.object({
+                slug: z.string(),
+                content: z.unknown(),
+                status: z.enum(['draft', 'published']).optional(),
+                parentId: z.string().nullable().optional(),
+                locale: z.string().optional(),
+            }),
+        }, async ({ params, body, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const allowed = await evaluate(bp, 'create', { user: authCtx.user });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot create');
+            if (!authCtx.user)
+                throw new AccessDeniedError('Authentication required');
+            if (body.parentId && !bp.tree)
+                throw new ValidationError('Collection does not support nesting');
+            const locale = await resolveLocaleParam(db, body.locale);
+            const validated = parseContent(bp.schema, withCanonicalSlug(body.content, body.slug));
+            return await entries.create({
+                collection: params.collection,
+                slug: body.slug,
+                content: validated,
+                locale,
+                ...(body.status !== undefined ? { status: body.status } : {}),
+                ...(body.parentId !== undefined ? { parentId: body.parentId } : {}),
+                draftsEnabled: bp.drafts === true,
+                createdBy: authCtx.user.id,
+            });
+        }),
+        createLocale: defineHandler(auth, {
+            params: paramsById,
+            body: z.object({
+                locale: z.string(),
+                slug: z.string(),
+                content: z.unknown(),
+                status: z.enum(['draft', 'published']).optional(),
+            }),
+        }, async ({ params, body, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const allowed = await evaluate(bp, 'create', { user: authCtx.user });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot create');
+            if (!authCtx.user)
+                throw new AccessDeniedError('Authentication required');
+            const locale = await resolveLocaleParam(db, body.locale);
+            const validated = parseContent(bp.schema, withCanonicalSlug(body.content, body.slug));
+            return await entries.createLocale(params.id, {
+                locale,
+                slug: body.slug,
+                content: validated,
+                updatedBy: authCtx.user.id,
+                ...(body.status !== undefined ? { status: body.status } : {}),
+                draftsEnabled: bp.drafts === true,
+            });
+        }),
+        update: defineHandler(auth, {
+            params: paramsById,
+            body: z.object({
+                slug: z.string().optional(),
+                content: z.unknown().optional(),
+                status: z.enum(['draft', 'published']).optional(),
+                changeSummary: z.string().optional(),
+                publish: z.boolean().optional(),
+                locale: z.string().optional(),
+            }),
+        }, async ({ params, body, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const locale = await resolveLocaleParam(db, body.locale);
+            const row = await entries.findById(params.id, locale);
+            if (!row)
+                throw new NotFoundError(`Entry ${params.id} (${locale}) not found`);
+            const allowed = await evaluate(bp, 'update', {
+                user: authCtx.user,
+                entry: { id: row.id, status: row.status, createdBy: row.createdBy, content: row.content },
+            });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot update');
+            if (!authCtx.user)
+                throw new AccessDeniedError('Authentication required');
+            const nextSlug = body.slug ?? row.slug;
+            const validated = body.content !== undefined
+                ? parseContent(bp.schema, withCanonicalSlug(body.content, nextSlug))
+                : undefined;
+            return await entries.updateWithRevision(params.id, {
+                locale,
+                ...(body.slug !== undefined ? { slug: body.slug } : {}),
+                ...(validated !== undefined ? { content: validated } : {}),
+                ...(body.status !== undefined ? { status: body.status } : {}),
+                ...(body.publish !== undefined ? { publish: body.publish } : {}),
+                draftsEnabled: bp.drafts === true,
+                updatedBy: authCtx.user.id,
+                ...(body.changeSummary !== undefined ? { changeSummary: body.changeSummary } : {}),
+            });
+        }),
+        move: defineHandler(auth, {
+            params: paramsById,
+            body: z.object({
+                parentId: z.string().nullable(),
+                sortOrder: z.number().int().positive().optional(),
+            }),
+        }, async ({ params, body, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            if (!bp.tree)
+                throw new ValidationError('Collection does not support tree structure');
+            const shell = await entries.findShellById(params.id);
+            if (!shell || shell.collection !== params.collection)
+                throw new NotFoundError(`Entry ${params.id} not found`);
+            const allowed = await evaluate(bp, 'update', {
+                user: authCtx.user,
+                entry: { id: shell.id, status: 'draft', createdBy: shell.createdBy, content: {} },
+            });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot move');
+            return await entries.move(params.collection, params.id, {
+                parentId: body.parentId,
+                ...(body.sortOrder !== undefined ? { sortOrder: body.sortOrder } : {}),
+            });
+        }),
+        publish: defineHandler(auth, { params: paramsById }, async ({ params, url, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            if (!bp.drafts)
+                throw new ValidationError('Drafts not enabled for this collection');
+            const locale = await resolveLocaleParam(db, url.searchParams.get('locale'));
+            const row = await entries.findById(params.id, locale);
+            if (!row)
+                throw new NotFoundError(`Entry ${params.id} (${locale}) not found`);
+            const allowed = await evaluate(bp, 'update', {
+                user: authCtx.user,
+                entry: { id: row.id, status: row.status, createdBy: row.createdBy, content: row.content },
+            });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot publish');
+            if (!authCtx.user)
+                throw new AccessDeniedError('Authentication required');
+            const content = row.draftContent ?? row.content;
+            const validated = parseContent(bp.schema, content);
+            return await entries.updateWithRevision(params.id, {
+                locale,
+                content: validated,
+                publish: true,
+                draftsEnabled: true,
+                updatedBy: authCtx.user.id,
+            });
+        }),
+        delete: defineHandler(auth, { params: paramsById }, async ({ params, url, auth: authCtx }) => {
+            const bp = blueprintFor(params.collection);
+            const localeParam = url.searchParams.get('locale');
+            const shell = await entries.findShellById(params.id);
+            if (!shell || shell.collection !== params.collection)
+                throw new NotFoundError(`Entry ${params.id} not found`);
+            const allowed = await evaluate(bp, 'delete', {
+                user: authCtx.user,
+                entry: { id: shell.id, status: 'draft', createdBy: shell.createdBy, content: {} },
+            });
+            if (!allowed)
+                throw new AccessDeniedError('Cannot delete');
+            if (localeParam) {
+                const locale = await resolveLocaleParam(db, localeParam);
+                const summaries = await entries.listLocales(params.id);
+                if (summaries.length <= 1) {
+                    await entries.delete(params.id);
+                    return { deleted: true };
+                }
+                await entries.deleteLocale(params.id, locale);
+                return { deleted: true, locale };
+            }
+            await entries.delete(params.id);
+            return { deleted: true };
+        }),
+    };
+}

package/dist/server/routes/form-submit.d.ts

@@ -0,0 +1,10 @@
+import type { VulseDb } from '../../core/db.js';
+export interface FormSubmitRouteOptions {
+    queue?: Queue;
+    env?: Record<string, unknown>;
+}
+export declare function formSubmitRoutes(db: VulseDb, options?: FormSubmitRouteOptions): {
+    public: (request: Request, rawParams: Record<string, string>) => Promise<Response>;
+    submit: (request: Request, rawParams: Record<string, string>) => Promise<Response>;
+};
+//# sourceMappingURL=form-submit.d.ts.map

package/dist/server/routes/form-submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-submit.d.ts","sourceRoot":"","sources":["../../../src/server/routes/form-submit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAU/C,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,GAAE,sBAA2B;sBAMtD,OAAO,aAAa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,OAAO,CAAC,QAAQ,CAAC;sBAgC9D,OAAO,aAAa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,OAAO,CAAC,QAAQ,CAAC;EAkHzF"}