@btst/stack 1.5.2 → 1.6.0

package/dist/packages/better-stack/src/plugins/form-builder/db.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const formBuilderSchema = db.createDbPlugin("form-builder", {
+  form: {
+    modelName: "form",
+    fields: {
+      name: {
+        type: "string",
+        required: true
+      },
+      slug: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      description: {
+        type: "string",
+        required: false
+      },
+      // JSON Schema stored as string (includes steps, fieldType, stepGroup, etc.)
+      schema: {
+        type: "string",
+        required: true
+      },
+      // Optional custom success message after submission
+      successMessage: {
+        type: "string",
+        required: false
+      },
+      // Optional redirect URL after submission
+      redirectUrl: {
+        type: "string",
+        required: false
+      },
+      // Form status: active, inactive, archived
+      status: {
+        type: "string",
+        defaultValue: "active"
+      },
+      // User who created the form
+      createdBy: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  formSubmission: {
+    modelName: "formSubmission",
+    fields: {
+      formId: {
+        type: "string",
+        required: true,
+        // Database reference for efficient joins
+        references: {
+          model: "form",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      // Submitted data as JSON string
+      data: {
+        type: "string",
+        required: true
+      },
+      // Submission timestamp
+      submittedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      // Optional user ID if authenticated
+      submittedBy: {
+        type: "string",
+        required: false
+      },
+      // IP address for rate limiting and spam protection
+      ipAddress: {
+        type: "string",
+        required: false
+      },
+      // User agent for analytics
+      userAgent: {
+        type: "string",
+        required: false
+      }
+    }
+  }
+});
+
+exports.formBuilderSchema = formBuilderSchema;

package/dist/packages/better-stack/src/plugins/form-builder/db.mjs

@@ -0,0 +1,97 @@
+import { createDbPlugin } from '@btst/db';
+
+const formBuilderSchema = createDbPlugin("form-builder", {
+  form: {
+    modelName: "form",
+    fields: {
+      name: {
+        type: "string",
+        required: true
+      },
+      slug: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      description: {
+        type: "string",
+        required: false
+      },
+      // JSON Schema stored as string (includes steps, fieldType, stepGroup, etc.)
+      schema: {
+        type: "string",
+        required: true
+      },
+      // Optional custom success message after submission
+      successMessage: {
+        type: "string",
+        required: false
+      },
+      // Optional redirect URL after submission
+      redirectUrl: {
+        type: "string",
+        required: false
+      },
+      // Form status: active, inactive, archived
+      status: {
+        type: "string",
+        defaultValue: "active"
+      },
+      // User who created the form
+      createdBy: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  formSubmission: {
+    modelName: "formSubmission",
+    fields: {
+      formId: {
+        type: "string",
+        required: true,
+        // Database reference for efficient joins
+        references: {
+          model: "form",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      // Submitted data as JSON string
+      data: {
+        type: "string",
+        required: true
+      },
+      // Submission timestamp
+      submittedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      // Optional user ID if authenticated
+      submittedBy: {
+        type: "string",
+        required: false
+      },
+      // IP address for rate limiting and spam protection
+      ipAddress: {
+        type: "string",
+        required: false
+      },
+      // User agent for analytics
+      userAgent: {
+        type: "string",
+        required: false
+      }
+    }
+  }
+});
+
+export { formBuilderSchema };

package/dist/packages/better-stack/src/plugins/form-builder/schemas.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const z = require('zod');
+
+const listFormsQuerySchema = z.z.object({
+  status: z.z.enum(["active", "inactive", "archived"]).optional(),
+  limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.z.coerce.number().min(0).optional().default(0)
+});
+const createFormSchema = z.z.object({
+  name: z.z.string().min(1, "Name is required"),
+  slug: z.z.string().min(1, "Slug is required"),
+  description: z.z.string().optional(),
+  schema: z.z.string().min(1, "Schema is required"),
+  successMessage: z.z.string().optional(),
+  redirectUrl: z.z.string().url().optional().or(z.z.literal("")),
+  status: z.z.enum(["active", "inactive", "archived"]).optional().default("active")
+});
+const updateFormSchema = z.z.object({
+  name: z.z.string().min(1, "Name is required").optional(),
+  slug: z.z.string().min(1, "Slug is required").optional(),
+  description: z.z.string().optional(),
+  schema: z.z.string().min(1, "Schema is required").optional(),
+  successMessage: z.z.string().optional(),
+  redirectUrl: z.z.string().url().optional().or(z.z.literal("")),
+  status: z.z.enum(["active", "inactive", "archived"]).optional()
+});
+const formResponseSchema = z.z.object({
+  id: z.z.string(),
+  name: z.z.string(),
+  slug: z.z.string(),
+  description: z.z.string().nullable().optional(),
+  schema: z.z.string(),
+  successMessage: z.z.string().nullable().optional(),
+  redirectUrl: z.z.string().nullable().optional(),
+  status: z.z.string(),
+  createdBy: z.z.string().nullable().optional(),
+  createdAt: z.z.string(),
+  updatedAt: z.z.string()
+});
+z.z.object({
+  items: z.z.array(formResponseSchema),
+  total: z.z.number(),
+  limit: z.z.number(),
+  offset: z.z.number()
+});
+const listSubmissionsQuerySchema = z.z.object({
+  limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.z.coerce.number().min(0).optional().default(0)
+});
+z.z.object({
+  // Use passthrough object for dynamic form data validation
+  data: z.z.object({}).passthrough()
+});
+const formSubmissionResponseSchema = z.z.object({
+  id: z.z.string(),
+  formId: z.z.string(),
+  data: z.z.string(),
+  submittedAt: z.z.string(),
+  submittedBy: z.z.string().nullable().optional(),
+  ipAddress: z.z.string().nullable().optional(),
+  userAgent: z.z.string().nullable().optional()
+});
+const formSubmissionWithDataResponseSchema = formSubmissionResponseSchema.extend({
+  // Use passthrough object for dynamic parsed data
+  parsedData: z.z.object({}).passthrough(),
+  form: formResponseSchema.optional()
+});
+z.z.object({
+  items: z.z.array(formSubmissionWithDataResponseSchema),
+  total: z.z.number(),
+  limit: z.z.number(),
+  offset: z.z.number()
+});
+
+exports.createFormSchema = createFormSchema;
+exports.formResponseSchema = formResponseSchema;
+exports.formSubmissionResponseSchema = formSubmissionResponseSchema;
+exports.formSubmissionWithDataResponseSchema = formSubmissionWithDataResponseSchema;
+exports.listFormsQuerySchema = listFormsQuerySchema;
+exports.listSubmissionsQuerySchema = listSubmissionsQuerySchema;
+exports.updateFormSchema = updateFormSchema;

package/dist/packages/better-stack/src/plugins/form-builder/schemas.mjs

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+
+const listFormsQuerySchema = z.object({
+  status: z.enum(["active", "inactive", "archived"]).optional(),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().min(0).optional().default(0)
+});
+const createFormSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  slug: z.string().min(1, "Slug is required"),
+  description: z.string().optional(),
+  schema: z.string().min(1, "Schema is required"),
+  successMessage: z.string().optional(),
+  redirectUrl: z.string().url().optional().or(z.literal("")),
+  status: z.enum(["active", "inactive", "archived"]).optional().default("active")
+});
+const updateFormSchema = z.object({
+  name: z.string().min(1, "Name is required").optional(),
+  slug: z.string().min(1, "Slug is required").optional(),
+  description: z.string().optional(),
+  schema: z.string().min(1, "Schema is required").optional(),
+  successMessage: z.string().optional(),
+  redirectUrl: z.string().url().optional().or(z.literal("")),
+  status: z.enum(["active", "inactive", "archived"]).optional()
+});
+const formResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullable().optional(),
+  schema: z.string(),
+  successMessage: z.string().nullable().optional(),
+  redirectUrl: z.string().nullable().optional(),
+  status: z.string(),
+  createdBy: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+z.object({
+  items: z.array(formResponseSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+});
+const listSubmissionsQuerySchema = z.object({
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().min(0).optional().default(0)
+});
+z.object({
+  // Use passthrough object for dynamic form data validation
+  data: z.object({}).passthrough()
+});
+const formSubmissionResponseSchema = z.object({
+  id: z.string(),
+  formId: z.string(),
+  data: z.string(),
+  submittedAt: z.string(),
+  submittedBy: z.string().nullable().optional(),
+  ipAddress: z.string().nullable().optional(),
+  userAgent: z.string().nullable().optional()
+});
+const formSubmissionWithDataResponseSchema = formSubmissionResponseSchema.extend({
+  // Use passthrough object for dynamic parsed data
+  parsedData: z.object({}).passthrough(),
+  form: formResponseSchema.optional()
+});
+z.object({
+  items: z.array(formSubmissionWithDataResponseSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+});
+
+export { createFormSchema, formResponseSchema, formSubmissionResponseSchema, formSubmissionWithDataResponseSchema, listFormsQuerySchema, listSubmissionsQuerySchema, updateFormSchema };

package/dist/packages/better-stack/src/plugins/form-builder/utils.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+require('clsx');
+require('tailwind-merge');
+const slug = require('slug');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const slug__default = /*#__PURE__*/_interopDefaultCompat(slug);
+
+function slugify(text, locale = "en") {
+  return slug__default(text, { lower: true, locale });
+}
+function extractIpAddress(headers) {
+  if (!headers) return void 0;
+  const forwardedFor = headers.get("x-forwarded-for");
+  if (forwardedFor) {
+    return forwardedFor.split(",")[0]?.trim();
+  }
+  const realIp = headers.get("x-real-ip");
+  if (realIp) {
+    return realIp.trim();
+  }
+  const cfConnectingIp = headers.get("cf-connecting-ip");
+  if (cfConnectingIp) {
+    return cfConnectingIp.trim();
+  }
+  return void 0;
+}
+function extractUserAgent(headers) {
+  if (!headers) return void 0;
+  return headers.get("user-agent") || void 0;
+}
+
+exports.extractIpAddress = extractIpAddress;
+exports.extractUserAgent = extractUserAgent;
+exports.slugify = slugify;

package/dist/packages/better-stack/src/plugins/form-builder/utils.mjs

@@ -0,0 +1,29 @@
+import 'clsx';
+import 'tailwind-merge';
+import slug from 'slug';
+
+function slugify(text, locale = "en") {
+  return slug(text, { lower: true, locale });
+}
+function extractIpAddress(headers) {
+  if (!headers) return void 0;
+  const forwardedFor = headers.get("x-forwarded-for");
+  if (forwardedFor) {
+    return forwardedFor.split(",")[0]?.trim();
+  }
+  const realIp = headers.get("x-real-ip");
+  if (realIp) {
+    return realIp.trim();
+  }
+  const cfConnectingIp = headers.get("cf-connecting-ip");
+  if (cfConnectingIp) {
+    return cfConnectingIp.trim();
+  }
+  return void 0;
+}
+function extractUserAgent(headers) {
+  if (!headers) return void 0;
+  return headers.get("user-agent") || void 0;
+}
+
+export { extractIpAddress, extractUserAgent, slugify };

package/dist/packages/ui/src/components/auto-form/index.cjs

@@ -1,13 +1,11 @@
 "use client";
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const jsxRuntime = require('react/jsx-runtime');
 const form = require('../form.cjs');
 const React = require('react');
 const reactHookForm = require('react-hook-form');
-const button = require('../button.cjs');
+require('../button.cjs');
 const utils$1 = require('../../lib/utils.cjs');
 const zod = require('@hookform/resolvers/zod');
 const object = require('./fields/object.cjs');
@@ -17,13 +15,6 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const React__default = /*#__PURE__*/_interopDefaultCompat(React);
 
-function AutoFormSubmit({
-  children,
-  className,
-  disabled
-}) {
-  return /* @__PURE__ */ jsxRuntime.jsx(button.Button, { type: "submit", disabled, className, children: children ?? "Submit" });
-}
 function AutoForm({
   formSchema,
   values: valuesProp,
@@ -83,5 +74,4 @@ function AutoForm({
   ) }) });
 }
 
-exports.AutoFormSubmit = AutoFormSubmit;
-exports.default = AutoForm;
+module.exports = AutoForm;

package/dist/packages/ui/src/components/auto-form/index.mjs

@@ -3,19 +3,12 @@ import { jsx, jsxs } from 'react/jsx-runtime';
 import { Form } from '../form.mjs';
 import React__default from 'react';
 import { useForm } from 'react-hook-form';
-import { Button } from '../button.mjs';
+import '../button.mjs';
 import { cn } from '../../lib/utils.mjs';
 import { zodResolver } from '@hookform/resolvers/zod';
 import AutoFormObject from './fields/object.mjs';
 import { getObjectFormSchema, getDefaultValues } from './utils.mjs';
 
-function AutoFormSubmit({
-  children,
-  className,
-  disabled
-}) {
-  return /* @__PURE__ */ jsx(Button, { type: "submit", disabled, className, children: children ?? "Submit" });
-}
 function AutoForm({
   formSchema,
   values: valuesProp,
@@ -75,4 +68,4 @@ function AutoForm({
   ) }) });
 }
 
-export { AutoFormSubmit, AutoForm as default };
+export { AutoForm as default };