About ZyraForm

🚀 What is ZyraForm?

ZyraForm is a Swift package that extends the PowerSync Swift Package for offline-first functionality. It provides syntax similar to Zod for validation, Drizzle ORM for schema definitions, and React Hook Form for form management. It eliminates the need for repetitive boilerplate code while maintaining zero runtime overhead and providing end-to-end type safety.

😓 The Problem ZyraForm Solves

Traditional Swift form development requires:

• ❌ Manual schema definitions (PowerSync tables)
• ❌ Separate validation logic (custom validators)
• ❌ Manual field configuration (TableFieldConfig arrays)
• ❌ Custom form state management (ObservableObject boilerplate)
• ❌ Manual CRUD implementations (one service per table)
• ❌ Manual encryption handling (encrypt/decrypt calls everywhere)
• ❌ Duplicate type definitions (schema → form values → models)

😱 Result: 500+ lines of boilerplate code per table, prone to errors, and difficult to maintain.

✨ The ZyraForm Solution

With ZyraForm, you define your schema once:

let UsersSchema = ExtendedTable(
    name: "\(AppConfig.dbPrefix)users",
    columns: [
        .text("email").email().notNull(),
        .text("name").minLength(2).maxLength(50).notNull(),
        .text("age").int().positive().intMin(18).intMax(120)
    ]
)

🎯 Everything else is automatic:

• ✅ Form validation
• ✅ Error handling
• ✅ Type inference
• ✅ CRUD operations
• ✅ Encryption handling
• ✅ Swift model generation
• ✅ Drizzle schema generation
• ✅ SQL migration generation

🎨 Features

Define your schema once, generate forms, validation, migrations, and CRUD operations automatically. Single source of truth eliminates inconsistencies. Compile-time type checking ensures your forms match your schema exactly. Catch errors before runtime. Schema definitions are computed once at initialization. Identical query performance to manual implementations. React Hook Form patterns, Zod-like validation, and Drizzle-style schemas. Developers from web backgrounds feel right at home. Reduce boilerplate by 90%+. One schema definition replaces hundreds of lines of manual code. Build forms in minutes, not hours. Focus on business logic, not infrastructure code.

📊 Code Comparison

See Core Concepts → for detailed before/after comparisons showing how ZyraForm reduces boilerplate code by eliminating repetitive patterns across schema definitions, validation logic, form state management, and CRUD operations.

⚡ Performance

🚀 Zero Runtime Overhead

ZyraForm has zero performance impact on database queries:

• ✅ Schema computed once at initialization (~0.1ms one-time cost)
• ✅ Query execution identical to manual PowerSync implementations
• ✅ Builder methods inlined by Swift compiler
• ✅ No runtime reflection - all metadata is explicit

Performance Characteristics:

• Schema initialization: ~0.1ms one-time cost per table
• Query execution: Identical to manual PowerSync implementations
• Memory overhead: ~200-500 bytes per table definition (negligible)

The metadata is static data computed once at app startup. At query time, ZyraForm uses the same native PowerSync.Table instances as manual implementations, resulting in identical performance.

Developer Experience 👨‍💻

Familiar Syntax 👋

React Hook Form developers will recognize:

// React Hook Form
const { register, handleSubmit, errors } = useForm()

// ZyraForm
@StateObject var form = PowerSyncForm<UserFormValues>(schema: UsersSchema)
form.handleSubmit { values in ... }
form.errors["email"]

Zod users will recognize:

// Zod
z.string().email().min(3).max(50)

// ZyraForm
.text("email").email().minLength(3).maxLength(50)

Drizzle ORM users will recognize:

// Drizzle
pgTable("users", {
  email: text().notNull(),
  name: text().notNull()
})

// ZyraForm
ExtendedTable(
  name: "users",
  columns: [
    .text("email").notNull(),
    .text("name").notNull()
  ]
)

Faster Development Times ⏱️

Traditional Approach:

• Define schema: 15 minutes
• Create service class: 30 minutes
• Build form view: 45 minutes
• Add validation: 20 minutes
• Test and debug: 30 minutes
• 😴 Total: ~2.5 hours per form

With ZyraForm:

• Define schema: 5 minutes
• Create form view: 10 minutes
• Test: 5 minutes
• 🎉 Total: ~20 minutes per form

🚀 Result: Estimated 87% faster development (based on typical form complexity)

💪 Less Syntax, More Power

ZyraForm eliminates repetitive code patterns:

• Validation: Define once in schema, used automatically in forms and services
• CRUD Operations: One generic service replaces hundreds of lines of per-table code
• Type Safety: Schema-driven type inference eliminates manual type conversions
• Code Generation: SQL migrations, Drizzle schemas, and Swift models generated automatically

See Core Concepts → for detailed comparisons showing how ZyraForm reduces boilerplate.

🏢 Enterprise Ready

✅ 🛡️ Type Safety: Compile-time checked schemas and forms
✅ 🔄 Backward Compatible: Works with existing PowerSync code
✅ 🔒 Thread Safe: Immutable structs, no retain cycles
✅ 💾 Memory Safe: No leaks, proper error handling
✅ ✅ Production Ready: Built on proven PowerSync patterns
✅ ⚡ Zero Runtime Cost: Query execution identical to manual implementations

📊 Impact Metrics

Based on typical form development patterns:

• 📉 90%+ code reduction per table (estimated from code comparisons)
• ⚡ Significantly faster development time (estimated 70-90% faster for typical forms)
• 🎯 Zero runtime overhead for query execution (identical performance to manual implementations)
• 🛡️ Compile-time type safety with Swift’s type system
• 📝 1 schema definition replaces 5+ files (PowerSync table, config, validation, models, migrations)

💬 Why Developers Choose ZyraForm

Developers benefit from ZyraForm because:

• Schema-first approach eliminates the need to maintain separate validation logic
• Familiar patterns from React Hook Form and Zod make it easy to learn
• Zero runtime overhead means you get all the benefits without performance trade-offs
• Type safety catches errors at compile-time, reducing bugs
• Rapid development lets you focus on business logic instead of boilerplate

🧩 Understanding the Core Components

ZyraForm is built on three powerful components that work together. Learn more about each component →

Built With ❤️

ZyraForm integrates seamlessly with these powerful technologies:

• PowerSync - Offline-first database synchronization
• Zod - TypeScript-first schema validation (inspiration for validation API)
• Drizzle ORM - TypeScript ORM (schema generation compatible)
• React Hook Form - Form state management patterns (API inspiration)

🚀 Get Started

Ready to experience the ZyraForm difference?

• 🧩 Core Concepts - Understand the architecture
• 📦 Installation - Set up in minutes
• ⚡ Quick Start - Build your first form
• 📋 Schema Definition - Learn the API

---

🎉 Start building faster, better forms with ZyraForm today.