@actuate-media/cms-core 0.29.0 → 0.31.0

package/dist/forms/index.js

@@ -1,3 +1,6 @@
 export { captureAttribution, storeAttribution, getStoredAttribution, trackPageView, getAttributionForSubmission, } from './attribution.js';
 export { trackFormStart, trackFormSubmit, trackFormError, pushDataLayerEvent, getDefaultConfirmation, getDefaultAnalyticsConfig, } from './analytics.js';
+export { INPUT_FIELD_TYPES, NON_INPUT_FIELD_TYPES } from './types.js';
+export * from './service.js';
+export * from './entries.js';
 //# sourceMappingURL=index.js.map

package/dist/forms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/forms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,GAC5B,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/forms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,GAC5B,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AA8BrE,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/dist/forms/service.d.ts

@@ -0,0 +1,92 @@
+import { type ActionContext } from '../actions.js';
+import { type FetchFormsParams, type FormDefinition, type FormEmbedSettings, type FormField, type FormNotificationSettings, type FormSchemaVersion, type FormSpamSettings, type FormStats, type FormStatus, type FormsSidebarCount } from './types.js';
+export declare const FORMS_COLLECTION = "forms";
+/** Parse a raw `forms` document row into the typed `FormDefinition` shape. */
+export declare function parseFormDefinition(doc: any): FormDefinition;
+export interface SchemaValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate a set of fields against config limits and structural rules. This is
+ * the single gate used by both the admin "Save Schema" flow and form creation.
+ */
+export declare function validateFormSchema(fields: unknown): SchemaValidationResult;
+export declare function listSchemaVersions(formId: string): Promise<FormSchemaVersion[]>;
+export declare function getSchemaVersion(versionId: string): Promise<FormSchemaVersion | null>;
+export interface ListFormsResult {
+    forms: FormDefinition[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export declare function listForms(params?: FetchFormsParams): Promise<ListFormsResult>;
+export declare function getFormById(id: string): Promise<FormDefinition | null>;
+export declare function getFormBySlug(slug: string): Promise<FormDefinition | null>;
+export interface CreateFormInput {
+    name: string;
+    slug?: string;
+    description?: string;
+    status?: FormStatus;
+    fields?: FormField[];
+    notificationSettings?: FormNotificationSettings;
+    embedSettings?: FormEmbedSettings;
+    spamSettings?: FormSpamSettings;
+    successMessage?: string;
+    redirectUrl?: string;
+}
+export declare function createForm(ctx: ActionContext, input: CreateFormInput): Promise<FormDefinition>;
+export interface UpdateFormInput {
+    name?: string;
+    description?: string;
+    status?: FormStatus;
+    successMessage?: string;
+    redirectUrl?: string;
+    spamSettings?: FormSpamSettings;
+    embedSettings?: FormEmbedSettings;
+}
+export declare function updateForm(ctx: ActionContext, id: string, patch: UpdateFormInput): Promise<FormDefinition>;
+export declare function archiveForm(ctx: ActionContext, id: string): Promise<FormDefinition>;
+export declare function restoreForm(ctx: ActionContext, id: string): Promise<FormDefinition>;
+export declare function duplicateForm(ctx: ActionContext, id: string): Promise<FormDefinition>;
+export interface DeleteFormOptions {
+    force?: boolean;
+}
+export declare function deleteForm(ctx: ActionContext, id: string, options?: DeleteFormOptions): Promise<void>;
+export declare function saveFormSchema(ctx: ActionContext, id: string, fields: FormField[], notes?: string): Promise<{
+    form: FormDefinition;
+    version: FormSchemaVersion;
+}>;
+export declare function getFormSchema(id: string): Promise<{
+    fields: FormField[];
+    activeVersionId: string | null;
+    versions: FormSchemaVersion[];
+}>;
+export declare function getNotificationSettings(id: string): Promise<FormNotificationSettings>;
+export declare function updateNotificationSettings(ctx: ActionContext, id: string, patch: Partial<FormNotificationSettings>): Promise<FormNotificationSettings>;
+/** Toggle the notify flag (maps to the Notify switch in the forms table). */
+export declare function setNotifyEnabled(ctx: ActionContext, id: string, enabled: boolean): Promise<FormNotificationSettings>;
+export declare function getEmbedSettings(id: string): Promise<FormEmbedSettings>;
+export declare function updateEmbedSettings(ctx: ActionContext, id: string, patch: Partial<FormEmbedSettings>): Promise<FormEmbedSettings>;
+export declare function getFormStats(): Promise<FormStats>;
+/**
+ * Unread counts for the sidebar. Only active, non-hidden forms contribute to
+ * the parent badge; archived/draft forms are excluded so the rail reflects
+ * live, publicly-collecting forms.
+ */
+export declare function getFormsSidebarCounts(): Promise<FormsSidebarCount[]>;
+export declare class FormNotFoundError extends Error {
+    constructor(id: string);
+}
+export declare class FormValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+export declare class FormConflictError extends Error {
+    constructor(message: string);
+}
+export declare class FormHasSubmissionsError extends Error {
+    submissionCount: number;
+    constructor(submissionCount: number);
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/forms/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/forms/service.ts"],"names":[],"mappings":"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"}

package/dist/forms/service.js

@@ -0,0 +1,579 @@
+/**
+ * Forms service — definitions, schema versioning, and per-form settings.
+ *
+ * Form *definitions* are stored as documents in the `forms` collection, so we
+ * reuse the standard data-layer actions (`createDocument` / `updateDocument` /
+ * `deleteDocument`) to inherit version history, cache invalidation, and plugin
+ * hooks. Field *schema* is additionally snapshotted into `FormSchemaVersion`
+ * rows so historical submissions always render against the schema they were
+ * captured with.
+ *
+ * Submissions/entries live in the dedicated `FormSubmission` table and are
+ * handled in `./entries.ts`.
+ */
+import { getDB } from '../db.js';
+import { createDocument, updateDocument, deleteDocument } from '../actions.js';
+import { logEvent } from '../security/audit.js';
+import { getActuateConfig } from '../config/runtime.js';
+import { INPUT_FIELD_TYPES, NON_INPUT_FIELD_TYPES, } from './types.js';
+export const FORMS_COLLECTION = 'forms';
+const ALL_FIELD_TYPES = [...INPUT_FIELD_TYPES, ...NON_INPUT_FIELD_TYPES];
+const DEFAULT_MAX_FIELDS = 60;
+const KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+function rawDb() {
+    return getDB();
+}
+function toISO(value) {
+    if (!value)
+        return undefined;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === 'string')
+        return value;
+    return undefined;
+}
+function normalizeStatus(value) {
+    return value === 'active' || value === 'archived' ? value : 'draft';
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+// ─── Parsing ──────────────────────────────────────────────────────────────
+/** Parse a raw `forms` document row into the typed `FormDefinition` shape. */
+export function parseFormDefinition(doc) {
+    const data = asRecord(doc?.data);
+    const notif = asRecord(data.notificationSettings);
+    const fields = Array.isArray(data.fields) ? data.fields : [];
+    return {
+        id: String(doc.id),
+        name: String(data.name ?? doc.title ?? 'Untitled form'),
+        slug: String(data.slug ?? doc.slug ?? ''),
+        description: typeof data.description === 'string' ? data.description : '',
+        status: normalizeStatus(data.status),
+        activeSchemaVersionId: data.activeSchemaVersionId ?? null,
+        fields,
+        notificationSettings: data.notificationSettings
+            ? data.notificationSettings
+            : undefined,
+        embedSettings: data.embedSettings ? data.embedSettings : undefined,
+        spamSettings: data.spamSettings ? data.spamSettings : undefined,
+        successMessage: typeof data.successMessage === 'string' ? data.successMessage : undefined,
+        redirectUrl: typeof data.redirectUrl === 'string' ? data.redirectUrl : undefined,
+        notifyEnabled: Boolean(notif.enabled ?? data.notifyEnabled ?? false),
+        createdBy: doc.createdById ? String(doc.createdById) : undefined,
+        createdAt: toISO(doc.createdAt),
+        updatedAt: toISO(doc.updatedAt),
+        archivedAt: data.archivedAt ?? null,
+    };
+}
+/**
+ * Validate a set of fields against config limits and structural rules. This is
+ * the single gate used by both the admin "Save Schema" flow and form creation.
+ */
+export function validateFormSchema(fields) {
+    const errors = [];
+    if (!Array.isArray(fields)) {
+        return { valid: false, errors: ['Fields must be an array'] };
+    }
+    const cfg = getActuateConfig()?.forms;
+    const allowed = cfg?.allowedFieldTypes ?? ALL_FIELD_TYPES;
+    const maxFields = cfg?.maxFieldsPerForm ?? DEFAULT_MAX_FIELDS;
+    if (fields.length > maxFields) {
+        errors.push(`Too many fields (max ${maxFields}).`);
+    }
+    const seenKeys = new Set();
+    for (const raw of fields) {
+        const key = raw?.key;
+        if (!key || !KEY_PATTERN.test(key)) {
+            errors.push(`Invalid field key "${key ?? ''}". Use letters, numbers, and underscores.`);
+        }
+        else if (seenKeys.has(key)) {
+            errors.push(`Duplicate field key "${key}".`);
+        }
+        if (key)
+            seenKeys.add(key);
+        if (!raw?.label || typeof raw.label !== 'string') {
+            errors.push(`Field "${key ?? ''}" is missing a label.`);
+        }
+        if (!allowed.includes(raw?.type)) {
+            errors.push(`Field type "${raw?.type ?? ''}" is not allowed.`);
+        }
+        if ((raw?.type === 'select' || raw?.type === 'multiselect' || raw?.type === 'radio') &&
+            (!Array.isArray(raw.options) || raw.options.length === 0)) {
+            errors.push(`Field "${key ?? ''}" of type ${raw.type} requires at least one option.`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/** Normalize incoming field objects: assign ids and sortOrder, coerce required. */
+function normalizeFields(fields) {
+    return fields.map((f, i) => ({
+        ...f,
+        id: f.id || `fld_${Math.random().toString(36).slice(2, 10)}`,
+        required: Boolean(f.required),
+        sortOrder: typeof f.sortOrder === 'number' ? f.sortOrder : i,
+    }));
+}
+// ─── Schema versions ─────────────────────────────────────────────────────
+function parseSchemaVersion(row) {
+    return {
+        id: String(row.id),
+        formId: String(row.formId),
+        version: Number(row.version),
+        fields: Array.isArray(row.fields) ? row.fields : [],
+        notes: row.notes ?? null,
+        createdById: row.createdById ?? null,
+        createdAt: toISO(row.createdAt) ?? new Date().toISOString(),
+    };
+}
+async function createSchemaVersionRow(formId, fields, createdById, notes) {
+    const db = rawDb();
+    const latest = await db.formSchemaVersion.findFirst({
+        where: { formId },
+        orderBy: { version: 'desc' },
+        select: { version: true },
+    });
+    const nextVersion = (latest?.version ?? 0) + 1;
+    const row = await db.formSchemaVersion.create({
+        data: {
+            formId,
+            version: nextVersion,
+            fields,
+            notes: notes ?? null,
+            createdById: createdById ?? null,
+        },
+    });
+    return parseSchemaVersion(row);
+}
+export async function listSchemaVersions(formId) {
+    const rows = await rawDb().formSchemaVersion.findMany({
+        where: { formId },
+        orderBy: { version: 'desc' },
+    });
+    return rows.map(parseSchemaVersion);
+}
+export async function getSchemaVersion(versionId) {
+    const row = await rawDb().formSchemaVersion.findUnique({ where: { id: versionId } });
+    return row ? parseSchemaVersion(row) : null;
+}
+/** Compute per-form entry counters for the supplied form ids in three grouped queries. */
+async function computeFormCounters(formIds) {
+    const out = new Map();
+    for (const id of formIds)
+        out.set(id, { total: 0, unread: 0, starred: 0, lastEntryAt: null });
+    if (formIds.length === 0)
+        return out;
+    const db = rawDb();
+    const where = { formId: { in: formIds }, spamStatus: { not: 'spam' } };
+    const [totals, unreads, starreds] = await Promise.all([
+        db.formSubmission.groupBy({
+            by: ['formId'],
+            where,
+            _count: { _all: true },
+            _max: { submittedAt: true },
+        }),
+        db.formSubmission.groupBy({
+            by: ['formId'],
+            where: { ...where, unread: true, archived: false },
+            _count: { _all: true },
+        }),
+        db.formSubmission.groupBy({
+            by: ['formId'],
+            where: { ...where, starred: true },
+            _count: { _all: true },
+        }),
+    ]);
+    for (const g of totals) {
+        const c = out.get(g.formId);
+        if (c) {
+            c.total = g._count._all;
+            c.lastEntryAt = g._max?.submittedAt ? new Date(g._max.submittedAt).toISOString() : null;
+        }
+    }
+    for (const g of unreads) {
+        const c = out.get(g.formId);
+        if (c)
+            c.unread = g._count._all;
+    }
+    for (const g of starreds) {
+        const c = out.get(g.formId);
+        if (c)
+            c.starred = g._count._all;
+    }
+    return out;
+}
+// ─── Forms CRUD ──────────────────────────────────────────────────────────
+function matchesSearch(form, term) {
+    const haystack = [
+        form.name,
+        form.slug,
+        form.description ?? '',
+        form.status,
+        ...(form.fields ?? []).flatMap((f) => [f.label, f.key, f.type]),
+        ...(form.notificationSettings?.recipients ?? []),
+        ...(form.embedSettings?.allowedDomains ?? []),
+    ]
+        .join(' ')
+        .toLowerCase();
+    return haystack.includes(term.toLowerCase());
+}
+export async function listForms(params = {}) {
+    const db = rawDb();
+    const rows = await db.document.findMany({
+        where: { collection: FORMS_COLLECTION, deletedAt: null },
+        orderBy: { createdAt: 'desc' },
+    });
+    let forms = rows.map((r) => parseFormDefinition(r));
+    const counters = await computeFormCounters(forms.map((f) => f.id));
+    forms = forms.map((f) => {
+        const c = counters.get(f.id);
+        return {
+            ...f,
+            totalEntries: c?.total ?? 0,
+            unreadEntries: c?.unread ?? 0,
+            starredEntries: c?.starred ?? 0,
+            lastEntryAt: c?.lastEntryAt ?? null,
+        };
+    });
+    if (params.status)
+        forms = forms.filter((f) => f.status === params.status);
+    if (typeof params.notifyEnabled === 'boolean') {
+        forms = forms.filter((f) => Boolean(f.notifyEnabled) === params.notifyEnabled);
+    }
+    if (params.search?.trim()) {
+        const term = params.search.trim();
+        forms = forms.filter((f) => matchesSearch(f, term));
+    }
+    const sortBy = params.sortBy ?? 'createdAt';
+    const dir = params.sortDirection === 'asc' ? 1 : -1;
+    forms.sort((a, b) => {
+        const av = a[sortBy];
+        const bv = b[sortBy];
+        if (av == null && bv == null)
+            return 0;
+        if (av == null)
+            return 1;
+        if (bv == null)
+            return -1;
+        return av > bv ? dir : av < bv ? -dir : 0;
+    });
+    const total = forms.length;
+    const page = Math.max(1, params.page ?? 1);
+    const pageSize = Math.min(100, Math.max(1, params.pageSize ?? 50));
+    const start = (page - 1) * pageSize;
+    return { forms: forms.slice(start, start + pageSize), total, page, pageSize };
+}
+export async function getFormById(id) {
+    const row = await rawDb().document.findFirst({
+        where: { id, collection: FORMS_COLLECTION, deletedAt: null },
+    });
+    if (!row)
+        return null;
+    const form = parseFormDefinition(row);
+    const counters = await computeFormCounters([id]);
+    const c = counters.get(id);
+    return {
+        ...form,
+        totalEntries: c?.total ?? 0,
+        unreadEntries: c?.unread ?? 0,
+        starredEntries: c?.starred ?? 0,
+        lastEntryAt: c?.lastEntryAt ?? null,
+    };
+}
+export async function getFormBySlug(slug) {
+    const row = await rawDb().document.findFirst({
+        where: { collection: FORMS_COLLECTION, slug, deletedAt: null },
+    });
+    return row ? parseFormDefinition(row) : null;
+}
+async function slugExists(slug, excludeId) {
+    const row = await rawDb().document.findFirst({
+        where: {
+            collection: FORMS_COLLECTION,
+            slug,
+            deletedAt: null,
+            ...(excludeId ? { id: { not: excludeId } } : {}),
+        },
+        select: { id: true },
+    });
+    return Boolean(row);
+}
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64);
+}
+export async function createForm(ctx, input) {
+    const fields = normalizeFields(input.fields ?? []);
+    const validation = validateFormSchema(fields);
+    if (!validation.valid) {
+        throw new FormValidationError(validation.errors);
+    }
+    let slug = input.slug?.trim() ? slugify(input.slug) : slugify(input.name);
+    if (!slug)
+        slug = `form-${Date.now()}`;
+    if (await slugExists(slug)) {
+        throw new FormConflictError(`A form with slug "${slug}" already exists.`);
+    }
+    const data = {
+        name: input.name,
+        slug,
+        description: input.description ?? '',
+        status: normalizeStatus(input.status),
+        fields,
+        notificationSettings: input.notificationSettings ?? { enabled: false, recipients: [] },
+        embedSettings: input.embedSettings ?? {},
+        spamSettings: input.spamSettings ?? {},
+        successMessage: input.successMessage ?? getActuateConfig()?.forms?.defaultSuccessMessage,
+        redirectUrl: input.redirectUrl,
+    };
+    const doc = (await createDocument(FORMS_COLLECTION, data, ctx));
+    const version = await createSchemaVersionRow(doc.id, fields, ctx.userId, 'Initial schema');
+    await rawDb().document.update({
+        where: { id: doc.id },
+        data: { data: { ...asRecord(doc.data), activeSchemaVersionId: version.id } },
+    });
+    await logEvent({
+        event: 'form.created',
+        userId: ctx.userId,
+        details: { formId: doc.id, name: input.name, slug },
+    });
+    const created = await getFormById(doc.id);
+    if (!created)
+        throw new Error('Form created but could not be reloaded');
+    return created;
+}
+export async function updateForm(ctx, id, patch) {
+    const existing = await getFormById(id);
+    if (!existing)
+        throw new FormNotFoundError(id);
+    const data = {};
+    if (patch.name !== undefined)
+        data.name = patch.name;
+    if (patch.description !== undefined)
+        data.description = patch.description;
+    if (patch.successMessage !== undefined)
+        data.successMessage = patch.successMessage;
+    if (patch.redirectUrl !== undefined)
+        data.redirectUrl = patch.redirectUrl;
+    if (patch.spamSettings !== undefined)
+        data.spamSettings = patch.spamSettings;
+    if (patch.embedSettings !== undefined)
+        data.embedSettings = patch.embedSettings;
+    let statusChanged = false;
+    if (patch.status !== undefined && patch.status !== existing.status) {
+        statusChanged = true;
+        data.status = patch.status;
+        data.archivedAt = patch.status === 'archived' ? new Date().toISOString() : null;
+    }
+    await updateDocument(FORMS_COLLECTION, id, data, ctx);
+    await logEvent({
+        event: statusChanged
+            ? patch.status === 'archived'
+                ? 'form.archived'
+                : existing.status === 'archived'
+                    ? 'form.restored'
+                    : 'form.updated'
+            : 'form.updated',
+        userId: ctx.userId,
+        details: { formId: id, ...(statusChanged ? { status: patch.status } : {}) },
+    });
+    const updated = await getFormById(id);
+    if (!updated)
+        throw new FormNotFoundError(id);
+    return updated;
+}
+export async function archiveForm(ctx, id) {
+    return updateForm(ctx, id, { status: 'archived' });
+}
+export async function restoreForm(ctx, id) {
+    return updateForm(ctx, id, { status: 'draft' });
+}
+export async function duplicateForm(ctx, id) {
+    const source = await getFormById(id);
+    if (!source)
+        throw new FormNotFoundError(id);
+    let slug = slugify(`${source.slug || source.name}-copy`);
+    let n = 2;
+    while (await slugExists(slug)) {
+        slug = slugify(`${source.slug || source.name}-copy-${n++}`);
+    }
+    return createForm(ctx, {
+        name: `${source.name} (copy)`,
+        slug,
+        description: source.description,
+        status: 'draft',
+        fields: source.fields,
+        notificationSettings: source.notificationSettings,
+        embedSettings: {},
+        spamSettings: source.spamSettings,
+        successMessage: source.successMessage,
+        redirectUrl: source.redirectUrl,
+    });
+}
+export async function deleteForm(ctx, id, options = {}) {
+    const existing = await getFormById(id);
+    if (!existing)
+        throw new FormNotFoundError(id);
+    const submissionCount = await rawDb().formSubmission.count({ where: { formId: id } });
+    if (submissionCount > 0 && !options.force) {
+        throw new FormHasSubmissionsError(submissionCount);
+    }
+    await deleteDocument(FORMS_COLLECTION, id, ctx);
+    await logEvent({
+        event: 'form.deleted',
+        userId: ctx.userId,
+        details: { formId: id, submissionCount, forced: Boolean(options.force) },
+    });
+}
+// ─── Schema save ───────────────────────────────────────────────────────
+export async function saveFormSchema(ctx, id, fields, notes) {
+    const existing = await getFormById(id);
+    if (!existing)
+        throw new FormNotFoundError(id);
+    const normalized = normalizeFields(fields);
+    const validation = validateFormSchema(normalized);
+    if (!validation.valid)
+        throw new FormValidationError(validation.errors);
+    const version = await createSchemaVersionRow(id, normalized, ctx.userId, notes);
+    await updateDocument(FORMS_COLLECTION, id, { fields: normalized, activeSchemaVersionId: version.id }, ctx);
+    await logEvent({
+        event: 'form.schema.updated',
+        userId: ctx.userId,
+        details: { formId: id, version: version.version, fieldCount: normalized.length },
+    });
+    const form = await getFormById(id);
+    if (!form)
+        throw new FormNotFoundError(id);
+    return { form, version };
+}
+export async function getFormSchema(id) {
+    const form = await getFormById(id);
+    if (!form)
+        throw new FormNotFoundError(id);
+    const versions = await listSchemaVersions(id);
+    return { fields: form.fields, activeVersionId: form.activeSchemaVersionId ?? null, versions };
+}
+// ─── Settings ──────────────────────────────────────────────────────────
+const DEFAULT_NOTIFICATION_SETTINGS = {
+    enabled: false,
+    recipients: [],
+    includeFields: true,
+    excludeSensitiveFields: false,
+    autoresponderEnabled: false,
+    webhookEnabled: false,
+};
+export async function getNotificationSettings(id) {
+    const form = await getFormById(id);
+    if (!form)
+        throw new FormNotFoundError(id);
+    return { ...DEFAULT_NOTIFICATION_SETTINGS, ...(form.notificationSettings ?? {}) };
+}
+export async function updateNotificationSettings(ctx, id, patch) {
+    const current = await getNotificationSettings(id);
+    const next = { ...current, ...patch };
+    await updateDocument(FORMS_COLLECTION, id, { notificationSettings: next, notifyEnabled: next.enabled }, ctx);
+    await logEvent({
+        event: 'form.notifications.changed',
+        userId: ctx.userId,
+        details: { formId: id, enabled: next.enabled },
+    });
+    return next;
+}
+/** Toggle the notify flag (maps to the Notify switch in the forms table). */
+export async function setNotifyEnabled(ctx, id, enabled) {
+    return updateNotificationSettings(ctx, id, { enabled });
+}
+export async function getEmbedSettings(id) {
+    const form = await getFormById(id);
+    if (!form)
+        throw new FormNotFoundError(id);
+    return form.embedSettings ?? {};
+}
+export async function updateEmbedSettings(ctx, id, patch) {
+    const current = await getEmbedSettings(id);
+    const next = { ...current, ...patch };
+    await updateDocument(FORMS_COLLECTION, id, { embedSettings: next }, ctx);
+    await logEvent({
+        event: 'form.updated',
+        userId: ctx.userId,
+        details: { formId: id, embed: true },
+    });
+    return next;
+}
+// ─── Stats + sidebar ─────────────────────────────────────────────────────
+export async function getFormStats() {
+    const db = rawDb();
+    const forms = (await db.document.findMany({
+        where: { collection: FORMS_COLLECTION, deletedAt: null },
+        select: { data: true },
+    })).map((r) => normalizeStatus(asRecord(r.data).status));
+    const [totalEntries, unreadEntries] = await Promise.all([
+        db.formSubmission.count({ where: { spamStatus: { not: 'spam' } } }),
+        db.formSubmission.count({
+            where: { unread: true, archived: false, spamStatus: { not: 'spam' } },
+        }),
+    ]);
+    return {
+        totalForms: forms.length,
+        activeForms: forms.filter((s) => s === 'active').length,
+        totalEntries,
+        unreadEntries,
+    };
+}
+/**
+ * Unread counts for the sidebar. Only active, non-hidden forms contribute to
+ * the parent badge; archived/draft forms are excluded so the rail reflects
+ * live, publicly-collecting forms.
+ */
+export async function getFormsSidebarCounts() {
+    const db = rawDb();
+    const rows = await db.document.findMany({
+        where: { collection: FORMS_COLLECTION, deletedAt: null },
+        orderBy: { createdAt: 'asc' },
+    });
+    const forms = rows.map(parseFormDefinition).filter((f) => f.status === 'active');
+    const counters = await computeFormCounters(forms.map((f) => f.id));
+    return forms.map((f) => ({
+        formId: f.id,
+        name: f.name,
+        slug: f.slug,
+        status: f.status,
+        unread: counters.get(f.id)?.unread ?? 0,
+    }));
+}
+// ─── Errors ──────────────────────────────────────────────────────────────
+export class FormNotFoundError extends Error {
+    constructor(id) {
+        super(`Form "${id}" not found`);
+        this.name = 'FormNotFoundError';
+    }
+}
+export class FormValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Invalid form schema: ${errors.join('; ')}`);
+        this.name = 'FormValidationError';
+        this.errors = errors;
+    }
+}
+export class FormConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FormConflictError';
+    }
+}
+export class FormHasSubmissionsError extends Error {
+    submissionCount;
+    constructor(submissionCount) {
+        super(`Form has ${submissionCount} submission(s); deletion requires force or export first.`);
+        this.name = 'FormHasSubmissionsError';
+        this.submissionCount = submissionCount;
+    }
+}
+//# sourceMappingURL=service.js.map