@ekrist1/vulse 0.1.6-alpha.3

package/dist/core/blueprints/zod-helpers.js

@@ -0,0 +1,72 @@
+import { z as astroZ } from 'astro/zod';
+import { blockSchema } from '../blocks/schema.js';
+import { LinkValueSchema } from './definition.js';
+export const EMPTY_BLOCKS_DOC = {
+    type: 'doc',
+    content: [{ type: 'paragraph' }],
+};
+export function blocks(sets) {
+    const tag = sets?.length ? `vulse:blocks:${sets.join(',')}` : 'vulse:blocks';
+    return astroZ.any().default(EMPTY_BLOCKS_DOC).describe(tag);
+}
+/** Legacy flat block list (deprecated). */
+export function blocksLegacy() {
+    return astroZ.array(blockSchema).default([]).describe('vulse:blocks-legacy');
+}
+/** Media reference: stored as the media row's id; resolved at read time. */
+export function media() {
+    return astroZ.string().min(1).describe('vulse:media');
+}
+/** Reference to another collection (or 'user'). Kept for backward compatibility. */
+export function ref(target) {
+    return astroZ.string().min(1).describe(`vulse:ref:${target}`);
+}
+/** Single entry picker from one or more collections. */
+export function entry(...collections) {
+    if (collections.length === 0)
+        throw new Error('entry() requires at least one collection');
+    return astroZ.string().min(1).describe(`vulse:entry:${collections.join(',')}`);
+}
+/** Multi-entry picker from one or more collections. */
+export function entries(collections, max) {
+    if (collections.length === 0)
+        throw new Error('entries() requires at least one collection');
+    let schema = astroZ.array(astroZ.string().min(1));
+    if (max !== undefined)
+        schema = schema.max(max);
+    const tag = max !== undefined
+        ? `vulse:entries:${collections.join(',')}:${max}`
+        : `vulse:entries:${collections.join(',')}`;
+    return schema.describe(tag);
+}
+/** URL, entry, or first-child link value. */
+export function link(collections) {
+    const tag = collections?.length ? `vulse:link:${collections.join(',')}` : 'vulse:link';
+    return LinkValueSchema.describe(tag);
+}
+/** Homogeneous row grid (array of objects with fixed columns). */
+export function grid(fields, opts) {
+    let schema = astroZ.array(astroZ.object(fields));
+    if (opts?.minRows !== undefined)
+        schema = schema.min(opts.minRows);
+    if (opts?.maxRows !== undefined)
+        schema = schema.max(opts.maxRows);
+    return schema.describe('vulse:grid');
+}
+export const z = new Proxy(astroZ, {
+    get(target, prop, receiver) {
+        if (prop === 'media')
+            return media;
+        if (prop === 'ref')
+            return ref;
+        if (prop === 'entry')
+            return entry;
+        if (prop === 'entries')
+            return entries;
+        if (prop === 'link')
+            return link;
+        if (prop === 'grid')
+            return grid;
+        return Reflect.get(target, prop, receiver);
+    },
+});

package/dist/core/db.d.ts

@@ -0,0 +1,7 @@
+import * as schema from './schema.js';
+export type VulseDb = ReturnType<typeof createDb>;
+export declare function createDb(binding: D1Database): import("drizzle-orm/d1").DrizzleD1Database<typeof schema> & {
+    $client: D1Database;
+};
+export * as schema from './schema.js';
+//# sourceMappingURL=db.d.ts.map

package/dist/core/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/core/db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAEjD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU;;EAG3C;AAED,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}

package/dist/core/db.js

@@ -0,0 +1,8 @@
+import { drizzle } from 'drizzle-orm/d1';
+import * as schema from './schema.js';
+export function createDb(binding) {
+    if (!binding)
+        throw new Error('Vulse: D1 binding "DB" is missing. Add it to wrangler.toml.');
+    return drizzle(binding, { schema });
+}
+export * as schema from './schema.js';

package/dist/core/errors.d.ts

@@ -0,0 +1,21 @@
+export type ErrorCode = 'VALIDATION' | 'NOT_FOUND' | 'ACCESS_DENIED' | 'CONFLICT' | 'INTERNAL';
+export declare class VulseError extends Error {
+    readonly code: ErrorCode;
+    readonly status: number;
+    readonly details?: Record<string, unknown>;
+    constructor(code: ErrorCode, status: number, message: string, details?: Record<string, unknown>);
+    static isVulseError(e: unknown): e is VulseError;
+}
+export declare class ValidationError extends VulseError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare class NotFoundError extends VulseError {
+    constructor(message?: string);
+}
+export declare class AccessDeniedError extends VulseError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends VulseError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,eAAe,GAAG,UAAU,GAAG,UAAU,CAAA;AAE9F,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAE9B,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAU/F,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU;CAGjD;AAED,qBAAa,eAAgB,SAAQ,UAAU;gBACjC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAC/D;AACD,qBAAa,aAAc,SAAQ,UAAU;gBAC/B,OAAO,SAAc;CAClC;AACD,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,SAAkB;CACtC;AACD,qBAAa,aAAc,SAAQ,UAAU;gBAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAC/D"}

package/dist/core/errors.js

@@ -0,0 +1,29 @@
+export class VulseError extends Error {
+    code;
+    status;
+    details;
+    constructor(code, status, message, details) {
+        super(message);
+        this.name = 'VulseError';
+        this.code = code;
+        this.status = status;
+        if (details !== undefined) {
+            this.details = details;
+        }
+    }
+    static isVulseError(e) {
+        return e instanceof VulseError;
+    }
+}
+export class ValidationError extends VulseError {
+    constructor(message, details) { super('VALIDATION', 422, message, details); }
+}
+export class NotFoundError extends VulseError {
+    constructor(message = 'Not found') { super('NOT_FOUND', 404, message); }
+}
+export class AccessDeniedError extends VulseError {
+    constructor(message = 'Access denied') { super('ACCESS_DENIED', 403, message); }
+}
+export class ConflictError extends VulseError {
+    constructor(message, details) { super('CONFLICT', 409, message, details); }
+}

package/dist/core/forms/compile.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'astro/zod';
+import type { FormDefinition, FormFieldDefinition } from './definition.js';
+export interface CompiledForm {
+    schema: z.ZodObject<z.ZodRawShape>;
+    inputFields: FormFieldDefinition[];
+    uniqueFields: string[];
+}
+export declare function compileForm(def: FormDefinition): CompiledForm;
+//# sourceMappingURL=compile.d.ts.map

package/dist/core/forms/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/core/forms/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1E,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAA;IAClC,WAAW,EAAE,mBAAmB,EAAE,CAAA;IAClC,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AAID,wBAAgB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,YAAY,CAgB7D"}

package/dist/core/forms/compile.js

@@ -0,0 +1,80 @@
+import { z } from 'astro/zod';
+const LAYOUT_KINDS = new Set(['submit', 'honeypot']);
+export function compileForm(def) {
+    const inputFields = def.fields.filter((f) => !LAYOUT_KINDS.has(f.ui.kind));
+    const uniqueFields = inputFields
+        .filter((f) => f.validation?.unique)
+        .map((f) => f.name);
+    const shape = {};
+    for (const field of inputFields) {
+        shape[field.name] = compileFormField(field);
+    }
+    return {
+        schema: z.object(shape),
+        inputFields,
+        uniqueFields,
+    };
+}
+function compileFormField(f) {
+    let s = z.never();
+    const v = f.validation;
+    switch (f.ui.kind) {
+        case 'text':
+        case 'textarea': {
+            let str = z.string();
+            if (v?.min !== undefined)
+                str = str.min(v.min);
+            if (v?.max !== undefined)
+                str = str.max(v.max);
+            if (v?.pattern)
+                str = str.regex(new RegExp(v.pattern));
+            if (v?.url)
+                str = str.url();
+            s = str;
+            break;
+        }
+        case 'email': {
+            let str = z.string().email();
+            if (v?.min !== undefined)
+                str = str.min(v.min);
+            if (v?.max !== undefined)
+                str = str.max(v.max);
+            s = str;
+            break;
+        }
+        case 'number': {
+            let num = v?.integer ? z.coerce.number().int() : z.coerce.number();
+            if (v?.min !== undefined)
+                num = num.min(v.min);
+            if (v?.max !== undefined)
+                num = num.max(v.max);
+            s = num;
+            break;
+        }
+        case 'date':
+        case 'time':
+        case 'datetime':
+            s = z.string();
+            break;
+        case 'select':
+        case 'radio':
+            s = z.enum(f.ui.options);
+            break;
+        case 'checkbox':
+            s = z.boolean();
+            break;
+        case 'file':
+            s = z.string().min(1);
+            break;
+        case 'hidden':
+            s = z.string();
+            break;
+    }
+    if (f.default !== undefined)
+        s = s.default(f.default);
+    if (f.optional && !v?.required)
+        s = s.optional();
+    else if (v?.required)
+        s = s.refine((val) => val !== '' && val !== undefined && val !== null, { message: 'Required' });
+    return s;
+}

package/dist/core/forms/definition.d.ts

@@ -0,0 +1,226 @@
+import { z } from 'astro/zod';
+export declare const FormFieldValidationSchema: z.ZodObject<{
+    required: z.ZodOptional<z.ZodBoolean>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodBoolean>;
+    integer: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FormFieldValidation = z.infer<typeof FormFieldValidationSchema>;
+export declare const FormFieldUiSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"textarea">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"email">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"date">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"time">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"datetime">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        select: "select";
+        radio: "radio";
+    }>;
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"checkbox">;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"hidden">;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"honeypot">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"submit">;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type FormFieldUi = z.infer<typeof FormFieldUiSchema>;
+export declare const FormFieldDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    ui: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"textarea">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"email">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"date">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"time">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"datetime">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            select: "select";
+            radio: "radio";
+        }>;
+        options: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"checkbox">;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hidden">;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"honeypot">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"submit">;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">;
+    optional: z.ZodBoolean;
+    default: z.ZodOptional<z.ZodUnknown>;
+    validation: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodBoolean>;
+        integer: z.ZodOptional<z.ZodBoolean>;
+        unique: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FormFieldDefinition = z.infer<typeof FormFieldDefinitionSchema>;
+export declare const FormSettingsSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    successMessage: z.ZodOptional<z.ZodString>;
+    redirectTo: z.ZodOptional<z.ZodString>;
+    honeypotField: z.ZodOptional<z.ZodString>;
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        maxPerIp: z.ZodNumber;
+        windowSec: z.ZodNumber;
+    }, z.core.$strip>>;
+    uploadDraftTtlHours: z.ZodOptional<z.ZodNumber>;
+    notifyEmails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    confirmationEmail: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        toField: z.ZodString;
+        subject: z.ZodString;
+        bodyTemplate: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FormSettings = z.infer<typeof FormSettingsSchema>;
+export declare const FormActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"notify">;
+    emails: z.ZodArray<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"confirmation">;
+    toField: z.ZodString;
+    subject: z.ZodString;
+    bodyTemplate: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"webhook">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>], "type">;
+export type FormAction = z.infer<typeof FormActionSchema>;
+export declare const FormDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        ui: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"textarea">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"email">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"date">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"time">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"datetime">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                select: "select";
+                radio: "radio";
+            }>;
+            options: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"checkbox">;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"hidden">;
+            value: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"honeypot">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"submit">;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">;
+        optional: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodUnknown>;
+        validation: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodBoolean>;
+            url: z.ZodOptional<z.ZodBoolean>;
+            integer: z.ZodOptional<z.ZodBoolean>;
+            unique: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    settings: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        successMessage: z.ZodOptional<z.ZodString>;
+        redirectTo: z.ZodOptional<z.ZodString>;
+        honeypotField: z.ZodOptional<z.ZodString>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            maxPerIp: z.ZodNumber;
+            windowSec: z.ZodNumber;
+        }, z.core.$strip>>;
+        uploadDraftTtlHours: z.ZodOptional<z.ZodNumber>;
+        notifyEmails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        confirmationEmail: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            toField: z.ZodString;
+            subject: z.ZodString;
+            bodyTemplate: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"notify">;
+        emails: z.ZodArray<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"confirmation">;
+        toField: z.ZodString;
+        subject: z.ZodString;
+        bodyTemplate: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"webhook">;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+export type FormDefinition = z.infer<typeof FormDefinitionSchema>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/core/forms/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/core/forms/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAK7B,eAAO,MAAM,yBAAyB;;;;;;;;;iBASpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkB5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAiB7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;2BAiB3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/core/forms/definition.js

@@ -0,0 +1,83 @@
+import { z } from 'astro/zod';
+const handleRegex = /^[a-z][a-z0-9_-]*$/;
+const fieldNameRegex = /^[a-z_][a-z0-9_-]*$/;
+export const FormFieldValidationSchema = z.object({
+    required: z.boolean().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    pattern: z.string().optional(),
+    email: z.boolean().optional(),
+    url: z.boolean().optional(),
+    integer: z.boolean().optional(),
+    unique: z.boolean().optional(),
+});
+export const FormFieldUiSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('text') }),
+    z.object({ kind: z.literal('textarea') }),
+    z.object({ kind: z.literal('email') }),
+    z.object({ kind: z.literal('number') }),
+    z.object({ kind: z.literal('date') }),
+    z.object({ kind: z.literal('time') }),
+    z.object({ kind: z.literal('datetime') }),
+    z.object({ kind: z.enum(['select', 'radio']), options: z.array(z.string()).min(1) }),
+    z.object({ kind: z.literal('checkbox'), label: z.string().optional() }),
+    z.object({
+        kind: z.literal('file'),
+        accept: z.array(z.string()).optional(),
+        maxBytes: z.number().int().positive().optional(),
+    }),
+    z.object({ kind: z.literal('hidden'), value: z.string().optional() }),
+    z.object({ kind: z.literal('honeypot') }),
+    z.object({ kind: z.literal('submit'), label: z.string().optional() }),
+]);
+export const FormFieldDefinitionSchema = z.object({
+    name: z.string().regex(fieldNameRegex),
+    label: z.string().optional(),
+    ui: FormFieldUiSchema,
+    optional: z.boolean(),
+    default: z.unknown().optional(),
+    validation: FormFieldValidationSchema.optional(),
+});
+export const FormSettingsSchema = z.object({
+    enabled: z.boolean().default(true),
+    successMessage: z.string().optional(),
+    redirectTo: z.string().optional(),
+    honeypotField: z.string().optional(),
+    rateLimit: z.object({
+        maxPerIp: z.number().int().positive(),
+        windowSec: z.number().int().positive(),
+    }).optional(),
+    uploadDraftTtlHours: z.number().int().positive().optional(),
+    notifyEmails: z.array(z.string().email()).optional(),
+    confirmationEmail: z.object({
+        enabled: z.boolean(),
+        toField: z.string(),
+        subject: z.string(),
+        bodyTemplate: z.string(),
+    }).optional(),
+});
+export const FormActionSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('notify'),
+        emails: z.array(z.string().email()),
+        template: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal('confirmation'),
+        toField: z.string(),
+        subject: z.string(),
+        bodyTemplate: z.string(),
+    }),
+    z.object({
+        type: z.literal('webhook'),
+        url: z.string().url(),
+        headers: z.record(z.string(), z.string()).optional(),
+    }),
+]);
+export const FormDefinitionSchema = z.object({
+    handle: z.string().regex(handleRegex),
+    label: z.string().min(1),
+    fields: z.array(FormFieldDefinitionSchema).default([]),
+    settings: FormSettingsSchema,
+    actions: z.array(FormActionSchema).default([]),
+});

package/dist/core/forms/rate-limit.d.ts

@@ -0,0 +1,10 @@
+import type { VulseDb } from '../db.js';
+export declare function hashIp(ip: string): string;
+export declare function checkRateLimit(db: VulseDb, formHandle: string, ipHash: string, opts?: {
+    maxPerIp: number;
+    windowSec: number;
+}): Promise<{
+    allowed: boolean;
+    retryAfterSec?: number;
+}>;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/core/forms/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../../src/core/forms/rate-limit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGvC,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,OAAO,EACX,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAsC,GAChF,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAqCvD"}

package/dist/core/forms/rate-limit.js

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+import { eq, and, lt } from 'drizzle-orm';
+import { vulseFormRateLimits } from '../schema.js';
+export function hashIp(ip) {
+    return createHash('sha256').update(ip).digest('hex');
+}
+export async function checkRateLimit(db, formHandle, ipHash, opts = { maxPerIp: 10, windowSec: 3600 }) {
+    const windowMs = opts.windowSec * 1000;
+    const now = Date.now();
+    const windowStart = new Date(Math.floor(now / windowMs) * windowMs);
+    const existing = await db.select().from(vulseFormRateLimits)
+        .where(and(eq(vulseFormRateLimits.formHandle, formHandle), eq(vulseFormRateLimits.ipHash, ipHash), eq(vulseFormRateLimits.windowStart, windowStart)))
+        .get();
+    if (!existing) {
+        await db.insert(vulseFormRateLimits).values({
+            formHandle,
+            ipHash,
+            windowStart,
+            count: 1,
+        });
+        return { allowed: true };
+    }
+    if (existing.count >= opts.maxPerIp) {
+        const retryAfterSec = Math.ceil((windowStart.getTime() + windowMs - now) / 1000);
+        return { allowed: false, retryAfterSec };
+    }
+    await db.update(vulseFormRateLimits)
+        .set({ count: existing.count + 1 })
+        .where(and(eq(vulseFormRateLimits.formHandle, formHandle), eq(vulseFormRateLimits.ipHash, ipHash), eq(vulseFormRateLimits.windowStart, windowStart)));
+    return { allowed: true };
+}

package/dist/core/forms/unique.d.ts

@@ -0,0 +1,5 @@
+import type { VulseDb } from '../db.js';
+export declare function normalizeUniqueValue(value: unknown): string;
+export declare function hashUniqueValue(value: unknown): string;
+export declare function insertUniqueValues(db: VulseDb, formHandle: string, submissionId: string, fields: Record<string, unknown>, uniqueFieldNames: string[]): Promise<void>;
+//# sourceMappingURL=unique.d.ts.map

package/dist/core/forms/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","sourceRoot":"","sources":["../../../src/core/forms/unique.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAIvC,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE3D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,OAAO,EACX,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,gBAAgB,EAAE,MAAM,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/core/forms/unique.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+import { vulseFormUniqueValues } from '../schema.js';
+import { ConflictError } from '../errors.js';
+export function normalizeUniqueValue(value) {
+    return String(value).trim().toLowerCase();
+}
+export function hashUniqueValue(value) {
+    return createHash('sha256').update(normalizeUniqueValue(value)).digest('hex');
+}
+export async function insertUniqueValues(db, formHandle, submissionId, fields, uniqueFieldNames) {
+    const now = new Date();
+    for (const name of uniqueFieldNames) {
+        const value = fields[name];
+        if (value === undefined || value === null || value === '')
+            continue;
+        const valueHash = hashUniqueValue(value);
+        try {
+            await db.insert(vulseFormUniqueValues).values({
+                formHandle,
+                fieldName: name,
+                valueHash,
+                submissionId,
+                createdAt: now,
+            });
+        }
+        catch {
+            throw new ConflictError(`Duplicate value for field "${name}"`, { field: name });
+        }
+    }
+}

package/dist/core/globals/compile.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'astro/zod';
+import type { CompiledSet } from '../sets/compile.js';
+import type { FieldDefinition } from '../blueprints/definition.js';
+import { type GlobalSetDefinition } from './definition.js';
+export interface CompiledGlobalSet {
+    handle: string;
+    label: string;
+    fields: FieldDefinition[];
+    schema: z.ZodObject<z.ZodRawShape>;
+    hash: string;
+}
+export declare function compileGlobalSet(def: GlobalSetDefinition, sets?: Map<string, CompiledSet>): CompiledGlobalSet;
+//# sourceMappingURL=compile.d.ts.map

package/dist/core/globals/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/core/globals/compile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAElC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,iBAAiB,CAAA;AAEnF,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAA;IAClC,IAAI,EAAE,MAAM,CAAA;CACb;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,mBAAmB,EACxB,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAC9B,iBAAiB,CAiBnB"}