@btst/stack 1.5.2 → 1.7.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 };