@frigear-nu/forms 0.0.6 → 0.0.8

package/dist/runtime/server/utils/admin-schemas.d.ts

@@ -23,9 +23,11 @@ export declare const formInput: z.ZodObject<{
             showIf: z.ZodOptional<z.ZodObject<{
                 field: z.ZodString;
                 op: z.ZodEnum<{
+                    in: "in";
                     eq: "eq";
                     neq: "neq";
-                    in: "in";
+                    empty: "empty";
+                    notEmpty: "notEmpty";
                     truthy: "truthy";
                 }>;
                 value: z.ZodOptional<z.ZodUnknown>;
@@ -34,16 +36,17 @@ export declare const formInput: z.ZodObject<{
                 key: z.ZodString;
                 type: z.ZodEnum<{
                     number: "number";
-                    text: "text";
+                    date: "date";
+                    file: "file";
                     email: "email";
+                    text: "text";
                     tel: "tel";
                     textarea: "textarea";
                     select: "select";
                     radio: "radio";
                     checkbox: "checkbox";
-                    date: "date";
-                    file: "file";
                     markdown: "markdown";
+                    captcha: "captcha";
                 }>;
                 content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                 label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
@@ -67,12 +70,39 @@ export declare const formInput: z.ZodObject<{
                     accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                 }, z.core.$strip>>;
+                phone: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodOptional<z.ZodEnum<{
+                        simple: "simple";
+                        country: "country";
+                    }>>;
+                    countries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    defaultCountry: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                captcha: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        turnstile: "turnstile";
+                        recaptcha: "recaptcha";
+                        hcaptcha: "hcaptcha";
+                    }>>;
+                    siteKey: z.ZodOptional<z.ZodString>;
+                    theme: z.ZodOptional<z.ZodEnum<{
+                        auto: "auto";
+                        light: "light";
+                        dark: "dark";
+                    }>>;
+                    size: z.ZodOptional<z.ZodEnum<{
+                        normal: "normal";
+                        compact: "compact";
+                    }>>;
+                }, z.core.$strip>>;
                 showIf: z.ZodOptional<z.ZodObject<{
                     field: z.ZodString;
                     op: z.ZodEnum<{
+                        in: "in";
                         eq: "eq";
                         neq: "neq";
-                        in: "in";
+                        empty: "empty";
+                        notEmpty: "notEmpty";
                         truthy: "truthy";
                     }>;
                     value: z.ZodOptional<z.ZodUnknown>;
@@ -87,10 +117,48 @@ export declare const formInput: z.ZodObject<{
                 keep: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        access: z.ZodOptional<z.ZodObject<{
+            availability: z.ZodDefault<z.ZodEnum<{
+                web: "web";
+                api: "api";
+            }>>;
+            auth: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                user: "user";
+                token: "token";
+                password: "password";
+            }>>;
+            schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"always">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"range">;
+                from: z.ZodOptional<z.ZodString>;
+                to: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"yearly">;
+                from: z.ZodObject<{
+                    month: z.ZodNumber;
+                    day: z.ZodNumber;
+                    time: z.ZodString;
+                }, z.core.$strip>;
+                to: z.ZodObject<{
+                    month: z.ZodNumber;
+                    day: z.ZodNumber;
+                    time: z.ZodString;
+                }, z.core.$strip>;
+                timezone: z.ZodString;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>>;
         delivery: z.ZodOptional<z.ZodObject<{
             email: z.ZodOptional<z.ZodObject<{
                 to: z.ZodArray<z.ZodString>;
                 subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                routes: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    to: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                replyToField: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
@@ -114,9 +182,11 @@ export declare const formPatch: z.ZodObject<{
             showIf: z.ZodOptional<z.ZodObject<{
                 field: z.ZodString;
                 op: z.ZodEnum<{
+                    in: "in";
                     eq: "eq";
                     neq: "neq";
-                    in: "in";
+                    empty: "empty";
+                    notEmpty: "notEmpty";
                     truthy: "truthy";
                 }>;
                 value: z.ZodOptional<z.ZodUnknown>;
@@ -125,16 +195,17 @@ export declare const formPatch: z.ZodObject<{
                 key: z.ZodString;
                 type: z.ZodEnum<{
                     number: "number";
-                    text: "text";
+                    date: "date";
+                    file: "file";
                     email: "email";
+                    text: "text";
                     tel: "tel";
                     textarea: "textarea";
                     select: "select";
                     radio: "radio";
                     checkbox: "checkbox";
-                    date: "date";
-                    file: "file";
                     markdown: "markdown";
+                    captcha: "captcha";
                 }>;
                 content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                 label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
@@ -158,12 +229,39 @@ export declare const formPatch: z.ZodObject<{
                     accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                 }, z.core.$strip>>;
+                phone: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodOptional<z.ZodEnum<{
+                        simple: "simple";
+                        country: "country";
+                    }>>;
+                    countries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    defaultCountry: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                captcha: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        turnstile: "turnstile";
+                        recaptcha: "recaptcha";
+                        hcaptcha: "hcaptcha";
+                    }>>;
+                    siteKey: z.ZodOptional<z.ZodString>;
+                    theme: z.ZodOptional<z.ZodEnum<{
+                        auto: "auto";
+                        light: "light";
+                        dark: "dark";
+                    }>>;
+                    size: z.ZodOptional<z.ZodEnum<{
+                        normal: "normal";
+                        compact: "compact";
+                    }>>;
+                }, z.core.$strip>>;
                 showIf: z.ZodOptional<z.ZodObject<{
                     field: z.ZodString;
                     op: z.ZodEnum<{
+                        in: "in";
                         eq: "eq";
                         neq: "neq";
-                        in: "in";
+                        empty: "empty";
+                        notEmpty: "notEmpty";
                         truthy: "truthy";
                     }>;
                     value: z.ZodOptional<z.ZodUnknown>;
@@ -178,10 +276,48 @@ export declare const formPatch: z.ZodObject<{
                 keep: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        access: z.ZodOptional<z.ZodObject<{
+            availability: z.ZodDefault<z.ZodEnum<{
+                web: "web";
+                api: "api";
+            }>>;
+            auth: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                user: "user";
+                token: "token";
+                password: "password";
+            }>>;
+            schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"always">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"range">;
+                from: z.ZodOptional<z.ZodString>;
+                to: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"yearly">;
+                from: z.ZodObject<{
+                    month: z.ZodNumber;
+                    day: z.ZodNumber;
+                    time: z.ZodString;
+                }, z.core.$strip>;
+                to: z.ZodObject<{
+                    month: z.ZodNumber;
+                    day: z.ZodNumber;
+                    time: z.ZodString;
+                }, z.core.$strip>;
+                timezone: z.ZodString;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>>;
         delivery: z.ZodOptional<z.ZodObject<{
             email: z.ZodOptional<z.ZodObject<{
                 to: z.ZodArray<z.ZodString>;
                 subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                routes: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    to: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                replyToField: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
@@ -211,9 +347,11 @@ export declare const importInput: z.ZodObject<{
                 showIf: z.ZodOptional<z.ZodObject<{
                     field: z.ZodString;
                     op: z.ZodEnum<{
+                        in: "in";
                         eq: "eq";
                         neq: "neq";
-                        in: "in";
+                        empty: "empty";
+                        notEmpty: "notEmpty";
                         truthy: "truthy";
                     }>;
                     value: z.ZodOptional<z.ZodUnknown>;
@@ -222,16 +360,17 @@ export declare const importInput: z.ZodObject<{
                     key: z.ZodString;
                     type: z.ZodEnum<{
                         number: "number";
-                        text: "text";
+                        date: "date";
+                        file: "file";
                         email: "email";
+                        text: "text";
                         tel: "tel";
                         textarea: "textarea";
                         select: "select";
                         radio: "radio";
                         checkbox: "checkbox";
-                        date: "date";
-                        file: "file";
                         markdown: "markdown";
+                        captcha: "captcha";
                     }>;
                     content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                     label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
@@ -255,12 +394,39 @@ export declare const importInput: z.ZodObject<{
                         accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                         message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
                     }, z.core.$strip>>;
+                    phone: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodOptional<z.ZodEnum<{
+                            simple: "simple";
+                            country: "country";
+                        }>>;
+                        countries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        defaultCountry: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    captcha: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodOptional<z.ZodEnum<{
+                            turnstile: "turnstile";
+                            recaptcha: "recaptcha";
+                            hcaptcha: "hcaptcha";
+                        }>>;
+                        siteKey: z.ZodOptional<z.ZodString>;
+                        theme: z.ZodOptional<z.ZodEnum<{
+                            auto: "auto";
+                            light: "light";
+                            dark: "dark";
+                        }>>;
+                        size: z.ZodOptional<z.ZodEnum<{
+                            normal: "normal";
+                            compact: "compact";
+                        }>>;
+                    }, z.core.$strip>>;
                     showIf: z.ZodOptional<z.ZodObject<{
                         field: z.ZodString;
                         op: z.ZodEnum<{
+                            in: "in";
                             eq: "eq";
                             neq: "neq";
-                            in: "in";
+                            empty: "empty";
+                            notEmpty: "notEmpty";
                             truthy: "truthy";
                         }>;
                         value: z.ZodOptional<z.ZodUnknown>;
@@ -275,10 +441,48 @@ export declare const importInput: z.ZodObject<{
                     keep: z.ZodArray<z.ZodString>;
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
+            access: z.ZodOptional<z.ZodObject<{
+                availability: z.ZodDefault<z.ZodEnum<{
+                    web: "web";
+                    api: "api";
+                }>>;
+                auth: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    user: "user";
+                    token: "token";
+                    password: "password";
+                }>>;
+                schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"always">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"range">;
+                    from: z.ZodOptional<z.ZodString>;
+                    to: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"yearly">;
+                    from: z.ZodObject<{
+                        month: z.ZodNumber;
+                        day: z.ZodNumber;
+                        time: z.ZodString;
+                    }, z.core.$strip>;
+                    to: z.ZodObject<{
+                        month: z.ZodNumber;
+                        day: z.ZodNumber;
+                        time: z.ZodString;
+                    }, z.core.$strip>;
+                    timezone: z.ZodString;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>>;
             delivery: z.ZodOptional<z.ZodObject<{
                 email: z.ZodOptional<z.ZodObject<{
                     to: z.ZodArray<z.ZodString>;
                     subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                    body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+                    routes: z.ZodOptional<z.ZodObject<{
+                        field: z.ZodString;
+                        to: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    replyToField: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
         }, z.core.$strip>;

package/dist/runtime/server/utils/auth.d.ts

@@ -1,11 +1,11 @@
 import type { H3Event } from 'h3';
-/**
- * Gate for the admin routes (form definitions, submissions, files). This repo has no shared
- * permission system, so the host app decides through the `forms:authorize` Nitro hook.
- * Denied by default:
- *
- *     nitroApp.hooks.hook('forms:authorize', (ctx) => { ctx.allowed = isStaff(ctx.userId) })
- */
+/** Gate for the admin routes (form definitions, submissions, files). */
 export declare function requireFormsManager(event: H3Event): Promise<{
     userId: number;
 }>;
+/** Non-throwing form of the `forms:authorize` policy for the caller of an already-authenticated request (MCP). */
+export declare const canManageForms: (event: H3Event, principal: {
+    user: {
+        id: number;
+    };
+}) => any;

package/dist/runtime/server/utils/auth.js

@@ -1,7 +1,7 @@
+const gate = definePolicyGate("forms:authorize");
 export async function requireFormsManager(event) {
-  const { user } = await requireUserSession(event);
-  const ctx = { event, userId: user.id, allowed: false };
-  await useNitroApp().hooks.callHook("forms:authorize", ctx);
-  if (!ctx.allowed) throw createError({ statusCode: 403, statusMessage: "You are not allowed to manage forms." });
+  const user = await requireUser(event, { scopes: ["forms:manage"] });
+  await gate.assert(event, user.id, "You are not allowed to manage forms.");
   return { userId: user.id };
 }
+export const canManageForms = (event, principal) => gate.isAllowed(event, principal.user.id);

package/dist/runtime/server/utils/captcha.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+import type { CaptchaProvider } from '../../../types.js';
+/**
+ * Verifies a captcha response token. The `forms:captcha:verify` hook runs first and can decide
+ * (`ctx.valid`) without any network call; otherwise the provider's siteverify endpoint is asked with the
+ * secret key: the form's own encrypted secret first, then `runtimeConfig.forms.captcha.<provider>.secretKey`
+ * (env `NUXT_FORMS_CAPTCHA_<PROVIDER>_SECRET_KEY`). Fails closed: a provider without a secret key, or an
+ * unreachable endpoint, is an error, never a pass.
+ */
+export declare function verifyCaptcha(event: H3Event, provider: CaptchaProvider, token: string, formId?: string): Promise<boolean>;

package/dist/runtime/server/utils/captcha.js

@@ -0,0 +1,25 @@
+const VERIFY_URLS = {
+  turnstile: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+  recaptcha: "https://www.google.com/recaptcha/api/siteverify",
+  hcaptcha: "https://api.hcaptcha.com/siteverify"
+};
+export async function verifyCaptcha(event, provider, token, formId) {
+  const ip = getRequestIP(event, { xForwardedFor: true });
+  const { secretKey: secret, source } = await resolveCaptchaSecret(event, provider, formId);
+  const ctx = { event, provider, token, ip, formId, secretKey: secret, secretSource: source, valid: void 0 };
+  await useNitroApp().hooks.callHook("forms:captcha:verify", ctx);
+  if (ctx.valid !== void 0) return ctx.valid;
+  if (!secret) {
+    console.error(`[forms] captcha provider "${provider}" has no secret key: set one on the form or NUXT_FORMS_CAPTCHA_${provider.toUpperCase()}_SECRET_KEY.`);
+    throw createError({ statusCode: 500, statusMessage: `The ${provider} captcha is not configured on the server.`, data: { captcha: true } });
+  }
+  const body = new URLSearchParams({ secret, response: token });
+  if (ip) body.set("remoteip", ip);
+  try {
+    const result = await $fetch(VERIFY_URLS[provider], { method: "POST", body, timeout: 1e4 });
+    return result?.success === true;
+  } catch (cause) {
+    console.error(`[forms] ${provider} verification request failed:`, cause);
+    throw createError({ statusCode: 502, statusMessage: "The captcha could not be verified. Please try again.", data: { captcha: true } });
+  }
+}

package/dist/runtime/server/utils/crypto.d.ts

@@ -0,0 +1,18 @@
+export declare class FormsDecryptionError extends Error {
+    name: string;
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/** True for a `FormsDecryptionError`, also across separately bundled copies of this file. */
+export declare const isDecryptionError: (error: unknown) => boolean;
+export declare function initEncryptionKey(secret: string | undefined | null): void;
+/** Encrypts any JSON value into a `{ ct, iv, tag }` string with a fresh random 12-byte IV. */
+export declare function encryptSync(plaintext: unknown): string;
+export declare function decryptSync(raw: string): unknown;
+declare global {
+    var __frigearFormsCrypto: {
+        encrypt: (value: unknown) => string;
+        decrypt: (raw: string) => unknown;
+    } | undefined;
+}

package/dist/runtime/server/utils/crypto.js

@@ -0,0 +1,48 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+const KEY_LENGTH = 32;
+const SCRYPT_SALT = "frigear-nu:forms:encrypted-json";
+const store = globalThis;
+export class FormsDecryptionError extends Error {
+  name = "FormsDecryptionError";
+  constructor(message = "Stored secrets could not be decrypted. The encryption key has changed or the data is corrupt.", options) {
+    super(message, options);
+  }
+}
+export const isDecryptionError = (error) => error instanceof Error && error.name === "FormsDecryptionError";
+export function initEncryptionKey(secret) {
+  store.__frigearFormsKey = secret ? scryptSync(secret, SCRYPT_SALT, KEY_LENGTH) : void 0;
+}
+function requireKey() {
+  if (!store.__frigearFormsKey) {
+    const secret = process.env.NUXT_FORMS_ENCRYPTION_KEY || process.env.NUXT_ENCRYPTION_KEY || process.env.NUXT_SESSION_PASSWORD;
+    if (secret) initEncryptionKey(secret);
+  }
+  if (!store.__frigearFormsKey) {
+    throw new Error("[forms] No encryption key: set NUXT_FORMS_ENCRYPTION_KEY, NUXT_ENCRYPTION_KEY or NUXT_SESSION_PASSWORD.");
+  }
+  return store.__frigearFormsKey;
+}
+export function encryptSync(plaintext) {
+  const key = requireKey();
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const ciphertext = Buffer.concat([cipher.update(JSON.stringify(plaintext), "utf8"), cipher.final()]);
+  return JSON.stringify({
+    ct: ciphertext.toString("base64"),
+    iv: iv.toString("base64"),
+    tag: cipher.getAuthTag().toString("base64")
+  });
+}
+export function decryptSync(raw) {
+  const key = requireKey();
+  try {
+    const { ct, iv, tag } = JSON.parse(raw);
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64"));
+    decipher.setAuthTag(Buffer.from(tag, "base64"));
+    const decrypted = Buffer.concat([decipher.update(Buffer.from(ct, "base64")), decipher.final()]);
+    return JSON.parse(decrypted.toString("utf8"));
+  } catch (cause) {
+    throw new FormsDecryptionError(void 0, { cause });
+  }
+}
+globalThis.__frigearFormsCrypto = { encrypt: encryptSync, decrypt: decryptSync };

package/dist/runtime/server/utils/forms.d.ts

@@ -1,9 +1,14 @@
 import { schema } from '@nuxthub/db';
-import type { FormAdminDto, PublicFormDto } from '../../../types.js';
+import type { FormAccessTokenDto, FormAdminDto, PublicFormDto } from '../../../types.js';
+import type { z } from 'zod';
+import type { formInput, formPatch } from './admin-schemas.js';
 type FormRow = typeof schema.forms.$inferSelect;
 export declare const toPublicForm: (row: FormRow) => PublicFormDto;
+export declare const toTokenDto: (row: typeof schema.formAccessTokens.$inferSelect) => FormAccessTokenDto;
 export declare const toAdminForm: (row: FormRow) => FormAdminDto;
 export declare function findFormById(id: string): Promise<FormRow>;
 export declare function findFormBySlug(slug: string): Promise<FormRow | undefined>;
 export declare function findPublishedForm(slug: string): Promise<FormRow>;
+export declare function createForm(input: z.output<typeof formInput>): Promise<FormRow>;
+export declare function patchForm(id: string, input: z.output<typeof formPatch>): Promise<FormRow>;
 export {};

package/dist/runtime/server/utils/forms.js

@@ -1,9 +1,18 @@
 import { eq } from "drizzle-orm";
 import { db, schema } from "@nuxthub/db";
+import { newId } from "../../utils/index.js";
 export const toPublicForm = (row) => {
   const { delivery: _delivery, ...definition } = row.definition;
   return { id: row.id, slug: row.slug, name: row.name, version: row.version, definition };
 };
+export const toTokenDto = (row) => ({
+  id: row.id,
+  name: row.name,
+  prefix: row.prefix,
+  createdAt: row.createdAt.toISOString(),
+  lastUsedAt: row.lastUsedAt?.toISOString() ?? null,
+  revokedAt: row.revokedAt?.toISOString() ?? null
+});
 export const toAdminForm = (row) => ({
   id: row.id,
   slug: row.slug,
@@ -28,3 +37,22 @@ export async function findPublishedForm(slug) {
   if (!row || row.status !== "published") throw createError({ statusCode: 404, statusMessage: "Form not found." });
   return row;
 }
+export async function createForm(input) {
+  if (await findFormBySlug(input.slug)) {
+    throw createError({ statusCode: 409, statusMessage: "A form with this slug already exists." });
+  }
+  const [row] = await db.insert(schema.forms).values({ id: newId("frm"), ...input }).returning();
+  return row;
+}
+export async function patchForm(id, input) {
+  const current = await findFormById(id);
+  if (input.slug && input.slug !== current.slug && await findFormBySlug(input.slug)) {
+    throw createError({ statusCode: 409, statusMessage: "A form with this slug already exists." });
+  }
+  const definitionChanged = input.definition !== void 0 && JSON.stringify(input.definition) !== JSON.stringify(current.definition);
+  const [row] = await db.update(schema.forms).set({
+    ...input,
+    version: definitionChanged ? current.version + 1 : current.version
+  }).where(eq(schema.forms.id, current.id)).returning();
+  return row;
+}

package/dist/runtime/server/utils/mcp-access.d.ts

@@ -0,0 +1,9 @@
+import type { H3Event } from 'h3';
+type FormRow = Parameters<typeof authorizeFormAccess>[1];
+/**
+ * Forms reachable over MCP: those open to everyone or to signed-in users. Forms gated by a
+ * per-form token or password are refused, since the MCP credential is the user's own and must
+ * never be presented as (or confused with) a form credential.
+ */
+export declare function assertMcpFormAccess(event: H3Event, form: FormRow): Promise<void>;
+export {};

package/dist/runtime/server/utils/mcp-access.js

@@ -0,0 +1,8 @@
+import { resolveAccess } from "../../utils/index.js";
+export async function assertMcpFormAccess(event, form) {
+  const { auth } = resolveAccess(form.definition);
+  if (auth === "token" || auth === "password") {
+    throw createError({ statusCode: 403, statusMessage: "This form needs its own access token or password and cannot be used through MCP." });
+  }
+  await authorizeFormAccess(event, form);
+}

package/dist/runtime/server/utils/rate-limit.d.ts

@@ -4,3 +4,6 @@ import type { H3Event } from 'h3';
  * write), which is fine for throttling casual abuse. `rateLimit: 0` disables it.
  */
 export declare function enforceRateLimit(event: H3Event, slug: string): Promise<void>;
+/** Refuses further password guesses once `rateLimit` wrong ones were made in the window. `rateLimit: 0` disables. */
+export declare function assertPasswordAttemptsLeft(event: H3Event, slug: string): Promise<void>;
+export declare function recordPasswordFailure(event: H3Event, slug: string): Promise<void>;

package/dist/runtime/server/utils/rate-limit.js

@@ -12,3 +12,22 @@ export async function enforceRateLimit(event, slug) {
   }
   await kv.set(key, used + 1, { ttl: rateLimitWindowSeconds });
 }
+const attemptKey = (event, slug) => {
+  const { rateLimitWindowSeconds } = useRuntimeConfig().forms;
+  const ip = getRequestIP(event, { xForwardedFor: true }) ?? "unknown";
+  return `forms:password:${slug}:${ip}:${Math.floor(Date.now() / (rateLimitWindowSeconds * 1e3))}`;
+};
+export async function assertPasswordAttemptsLeft(event, slug) {
+  const { rateLimit, rateLimitWindowSeconds } = useRuntimeConfig().forms;
+  if (!rateLimit) return;
+  if (Number(await kv.get(attemptKey(event, slug)) ?? 0) >= rateLimit) {
+    setResponseHeader(event, "retry-after", rateLimitWindowSeconds);
+    throw createError({ statusCode: 429, statusMessage: "Too many attempts, try again later." });
+  }
+}
+export async function recordPasswordFailure(event, slug) {
+  const { rateLimit, rateLimitWindowSeconds } = useRuntimeConfig().forms;
+  if (!rateLimit) return;
+  const key = attemptKey(event, slug);
+  await kv.set(key, Number(await kv.get(key) ?? 0) + 1, { ttl: rateLimitWindowSeconds });
+}

package/dist/runtime/server/utils/render.d.ts

@@ -1,11 +1,2 @@
-import type { FormDefinition } from '../../../types.js';
-export type RenderedAnswer = {
-    key: string;
-    label: string;
-    value: string;
-};
-/** Answers as label/value rows in form order, using the definition the answers were given against. */
-export declare function renderAnswers(definition: FormDefinition, answers: Record<string, unknown>, locale: string): RenderedAnswer[];
-export declare const escapeHtml: (value: string) => string;
-export declare function answersToText(rows: RenderedAnswer[]): string;
-export declare function answersToHtml(rows: RenderedAnswer[]): string;
+export { renderAnswers, escapeHtml, answersToText, answersToHtml } from '../../utils/template.js';
+export type { RenderedAnswer } from '../../utils/template.js';