sovrium 0.0.2

package/src/domain/models/app/table/field-types/relational/rollup-field.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { ViewFiltersSchema } from '../../views/filters'
+import { BaseFieldSchema } from '../base-field'
+
+export const RollupFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('rollup'),
+      relationshipField: Schema.String.pipe(
+        Schema.nonEmptyString({ message: () => 'relationshipField is required' }),
+        Schema.annotations({ description: 'Name of the relationship field to aggregate from' })
+      ),
+      relatedField: Schema.String.pipe(
+        Schema.nonEmptyString({ message: () => 'relatedField is required' }),
+        Schema.annotations({ description: 'Name of the field in the related table to aggregate' })
+      ),
+      aggregation: Schema.String.pipe(
+        Schema.annotations({ description: 'Aggregation function to apply' })
+      ),
+      format: Schema.optional(
+        Schema.String.pipe(
+          Schema.annotations({
+            description: 'Display format for the result',
+            examples: ['currency', 'number', 'percentage'],
+          })
+        )
+      ),
+      filters: Schema.optional(
+        ViewFiltersSchema.pipe(
+          Schema.annotations({ description: 'Filters to apply to the rollup aggregation' })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Rollup Field',
+    description: 'Aggregates values from related records using functions like SUM, AVG, COUNT.',
+    examples: [
+      {
+        id: 1,
+        name: 'total_sales',
+        type: 'rollup',
+        relationshipField: 'orders',
+        relatedField: 'amount',
+        aggregation: 'SUM',
+      },
+    ],
+  })
+)
+
+export type RollupField = Schema.Schema.Type<typeof RollupFieldSchema>

package/src/domain/models/app/table/field-types/selection/checkbox-field.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Checkbox Field
+ *
+ * Boolean field that stores true/false values.
+ * Typically rendered as a checkbox in the UI.
+ * Supports optional default value and database indexing.
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'is_active',
+ *   type: 'checkbox',
+ *   required: true,
+ *   default: false
+ * }
+ * ```
+ */
+export const CheckboxFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('checkbox'),
+      default: Schema.optional(Schema.Boolean),
+    })
+  ),
+  Schema.annotations({
+    title: 'Checkbox Field',
+    description: 'Boolean field for true/false values. Typically rendered as a checkbox in the UI.',
+    examples: [
+      {
+        id: 1,
+        name: 'is_active',
+        type: 'checkbox',
+        required: true,
+        default: false,
+      },
+    ],
+  })
+)
+
+export type CheckboxField = Schema.Schema.Type<typeof CheckboxFieldSchema>

package/src/domain/models/app/table/field-types/selection/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+export * from './single-select-field'
+export * from './multi-select-field'
+export * from './checkbox-field'
+export * from './status-field'

package/src/domain/models/app/table/field-types/selection/multi-select-field.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+import { createOptionsSchema } from '../validation-utils'
+
+/**
+ * Multi Select Field
+ *
+ * Allows selection of multiple options from a predefined list.
+ * Commonly used for tags, categories, or any multi-valued selections.
+ * Supports optional default value array and maximum selection limit.
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'tags',
+ *   type: 'multi-select',
+ *   options: ['Urgent', 'Important', 'Review'],
+ *   maxSelections: 3,
+ *   default: ['Important']
+ * }
+ * ```
+ */
+export const MultiSelectFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('multi-select'),
+      options: createOptionsSchema('multi-select'),
+      maxSelections: Schema.optional(
+        Schema.Int.pipe(
+          Schema.greaterThanOrEqualTo(1),
+          Schema.annotations({
+            description: 'Maximum number of selections allowed',
+          })
+        )
+      ),
+      default: Schema.optional(Schema.Array(Schema.String)),
+    })
+  ),
+  Schema.filter((field) => {
+    if (field.maxSelections !== undefined && field.maxSelections > field.options.length) {
+      return 'maxSelections exceeds available options'
+    }
+    return true
+  }),
+  Schema.annotations({
+    title: 'Multi Select Field',
+    description: 'Allows selection of multiple options from predefined list.',
+    examples: [
+      {
+        id: 1,
+        name: 'tags',
+        type: 'multi-select',
+        options: ['Urgent', 'Important', 'Review'],
+        maxSelections: 3,
+      },
+    ],
+  })
+)
+
+export type MultiSelectField = Schema.Schema.Type<typeof MultiSelectFieldSchema>

package/src/domain/models/app/table/field-types/selection/single-select-field.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+import { createOptionsSchema } from '../validation-utils'
+
+/**
+ * Single Select Field
+ *
+ * Allows selection of one option from a predefined list.
+ * Commonly used for categories, statuses, or any enumerated values.
+ * Supports optional default value selection.
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'category',
+ *   type: 'single-select',
+ *   options: ['Electronics', 'Clothing', 'Food'],
+ *   default: 'Electronics'
+ * }
+ * ```
+ */
+export const SingleSelectFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('single-select'),
+      options: createOptionsSchema('single-select'),
+      default: Schema.optional(Schema.String),
+    })
+  ),
+  Schema.annotations({
+    title: 'Single Select Field',
+    description:
+      'Allows selection of one option from predefined list. Used for categories or enumerated values.',
+    examples: [
+      {
+        id: 1,
+        name: 'category',
+        type: 'single-select',
+        options: ['Electronics', 'Clothing', 'Food'],
+        default: 'Electronics',
+      },
+    ],
+  })
+)
+
+export type SingleSelectField = Schema.Schema.Type<typeof SingleSelectFieldSchema>

package/src/domain/models/app/table/field-types/selection/status-field.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+import { createStatusOptionsSchema } from '../validation-utils'
+
+export const StatusFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('status'),
+      options: createStatusOptionsSchema(),
+      default: Schema.optional(Schema.String),
+    })
+  ),
+  Schema.annotations({
+    title: 'Status Field',
+    description: 'Status field with colored options for workflow states.',
+    examples: [
+      {
+        id: 1,
+        name: 'status',
+        type: 'status',
+        options: [
+          { value: 'todo', color: '#94A3B8' },
+          { value: 'in_progress', color: '#3B82F6' },
+        ],
+      },
+    ],
+  })
+)
+
+export type StatusField = Schema.Schema.Type<typeof StatusFieldSchema>

package/src/domain/models/app/table/field-types/text/email-field.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Email Field
+ *
+ * Text field with email format validation. Stores email addresses and validates
+ * them against standard email format rules (RFC 5322). Can be marked as required,
+ * unique (for user authentication), or indexed for fast lookups. Email validation
+ * ensures data integrity and prevents invalid email addresses from being stored.
+ *
+ * Business Rules:
+ * - Email format validation enforced at application level using RFC 5322 standard
+ * - Unique constraint recommended for user authentication and preventing duplicate accounts
+ * - Indexing recommended for user lookup, login, and search operations
+ * - Case-insensitive comparison for uniqueness checks to prevent duplicate emails
+ * - Constant value 'email' ensures type safety and enables discriminated unions
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'email',
+ *   type: 'email',
+ *   required: true,
+ *   unique: true,
+ *   indexed: true,
+ *   default: 'user@example.com'
+ * }
+ * ```
+ */
+export const EmailFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('email').pipe(
+        Schema.annotations({
+          description: "Constant value 'email' for type discrimination in discriminated unions",
+        })
+      ),
+      default: Schema.optional(
+        Schema.String.pipe(
+          Schema.annotations({
+            description: 'Default email address when creating new records',
+          })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Email Field',
+    description:
+      'Text field with email format validation (RFC 5322). Validates email addresses and prevents invalid formats from being stored.',
+    examples: [
+      {
+        id: 1,
+        name: 'email',
+        type: 'email',
+        required: true,
+        unique: true,
+        indexed: true,
+      },
+      {
+        id: 2,
+        name: 'contact_email',
+        type: 'email',
+        required: false,
+        default: 'contact@example.com',
+      },
+    ],
+  })
+)
+
+export type EmailField = Schema.Schema.Type<typeof EmailFieldSchema>

package/src/domain/models/app/table/field-types/text/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+export * from './single-line-text-field'
+export * from './long-text-field'
+export * from './rich-text-field'
+export * from './email-field'
+export * from './url-field'
+export * from './phone-number-field'

package/src/domain/models/app/table/field-types/text/long-text-field.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Long Text Field
+ *
+ * Multi-line text input for paragraphs, descriptions, notes, and comments.
+ * Supports line breaks and longer content. Text is stored as-is without rich
+ * formatting (no bold, italics, etc.). Required flag makes the field mandatory.
+ * Indexing improves search performance but may be slower for very long content.
+ *
+ * Business Rules:
+ * - Multi-line support allows paragraphs and extended content while preserving line breaks
+ * - Text is stored without formatting, focusing on plain text content
+ * - Indexing optional due to performance trade-offs with large text content
+ * - Constant value 'long-text' ensures type safety and enables discriminated unions
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'description',
+ *   type: 'long-text',
+ *   required: true,
+ *   indexed: false,
+ *   default: 'Enter description here...'
+ * }
+ * ```
+ */
+export const LongTextFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('long-text').pipe(
+        Schema.annotations({
+          description: "Constant value 'long-text' for type discrimination in discriminated unions",
+        })
+      ),
+      default: Schema.optional(
+        Schema.String.pipe(
+          Schema.annotations({
+            description: 'Default value for this field when creating new records',
+          })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Long Text Field',
+    description:
+      'Multi-line text input for paragraphs, descriptions, notes, and comments. Supports line breaks and longer content without rich formatting.',
+    examples: [
+      {
+        id: 1,
+        name: 'description',
+        type: 'long-text',
+        required: true,
+        indexed: false,
+        default: 'Enter description here...',
+      },
+      {
+        id: 2,
+        name: 'notes',
+        type: 'long-text',
+        required: false,
+      },
+    ],
+  })
+)
+
+export type LongTextField = Schema.Schema.Type<typeof LongTextFieldSchema>

package/src/domain/models/app/table/field-types/text/phone-number-field.ts

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Phone Number Field
+ *
+ * Text field designed for storing phone numbers with optional format validation.
+ * Stores phone numbers as plain text strings, supporting international formats
+ * and various notation styles. Can be marked as required, unique (for preventing
+ * duplicate registrations), or indexed for fast lookups. No automatic formatting
+ * is applied - numbers are stored exactly as entered.
+ *
+ * Business Rules:
+ * - Phone numbers stored as text strings to preserve original formatting (spaces, dashes, parentheses)
+ * - No automatic validation applied - allows flexibility for international formats
+ * - Unique constraint useful for preventing duplicate user registrations
+ * - Indexing recommended for user lookup and search operations
+ * - Constant value 'phone-number' ensures type safety and enables discriminated unions
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'mobile_phone',
+ *   type: 'phone-number',
+ *   required: true,
+ *   unique: true,
+ *   indexed: true,
+ *   default: '+1 (555) 000-0000'
+ * }
+ * ```
+ */
+export const PhoneNumberFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('phone-number').pipe(
+        Schema.annotations({
+          description:
+            "Constant value 'phone-number' for type discrimination in discriminated unions",
+        })
+      ),
+      default: Schema.optional(
+        Schema.String.pipe(
+          Schema.annotations({
+            description: 'Default phone number value when creating new records',
+          })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Phone Number Field',
+    description:
+      'Text field for storing phone numbers with support for international formats. Numbers are stored as plain text without automatic formatting.',
+    examples: [
+      {
+        id: 1,
+        name: 'mobile_phone',
+        type: 'phone-number',
+        required: true,
+        unique: true,
+        indexed: true,
+      },
+      {
+        id: 2,
+        name: 'office_phone',
+        type: 'phone-number',
+        required: false,
+        default: '+1 (555) 000-0000',
+      },
+    ],
+  })
+)
+
+export type PhoneNumberField = Schema.Schema.Type<typeof PhoneNumberFieldSchema>

package/src/domain/models/app/table/field-types/text/rich-text-field.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Rich Text Field
+ *
+ * Stores formatted text with support for bold, italic, links, lists, and other rich formatting.
+ * Typically rendered with a WYSIWYG editor in the UI.
+ * Supports optional maximum length constraints.
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'article_content',
+ *   type: 'rich-text',
+ *   required: true,
+ *   maxLength: 10000
+ * }
+ * ```
+ */
+export const RichTextFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('rich-text'),
+      maxLength: Schema.optional(
+        Schema.Int.pipe(
+          Schema.greaterThanOrEqualTo(1),
+          Schema.annotations({
+            description: 'Maximum length in characters',
+          })
+        )
+      ),
+      fullTextSearch: Schema.optional(
+        Schema.Boolean.pipe(
+          Schema.annotations({
+            description: 'Enable full-text search indexing for this field',
+          })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Rich Text Field',
+    description:
+      'Stores formatted text with rich formatting support. Rendered with WYSIWYG editor in UI.',
+    examples: [
+      {
+        id: 1,
+        name: 'article_content',
+        type: 'rich-text',
+        required: true,
+        maxLength: 10_000,
+      },
+    ],
+  })
+)
+
+export type RichTextField = Schema.Schema.Type<typeof RichTextFieldSchema>

package/src/domain/models/app/table/field-types/text/single-line-text-field.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { BaseFieldSchema } from '../base-field'
+
+/**
+ * Single Line Text Field
+ *
+ * Short text input limited to a single line. Ideal for names, titles, labels,
+ * and brief identifiers. Text is stored as-is without formatting. Required flag
+ * makes the field mandatory. Unique constraint ensures no duplicate values across
+ * records. Indexing improves search and filter performance on this field.
+ *
+ * Business Rules:
+ * - Single-line constraint prevents multi-line input, ensuring consistent formatting and UI display
+ * - Text is stored without formatting, preserving raw input for maximum flexibility
+ * - Constant value 'single-line-text' ensures type safety and enables discriminated unions
+ *
+ * @example
+ * ```typescript
+ * const field = {
+ *   id: 1,
+ *   name: 'title',
+ *   type: 'single-line-text',
+ *   required: true,
+ *   unique: false,
+ *   indexed: true,
+ *   default: 'Untitled'
+ * }
+ * ```
+ */
+export const SingleLineTextFieldSchema = BaseFieldSchema.pipe(
+  Schema.extend(
+    Schema.Struct({
+      type: Schema.Literal('single-line-text').pipe(
+        Schema.annotations({
+          description:
+            "Constant value 'single-line-text' for type discrimination in discriminated unions",
+        })
+      ),
+      default: Schema.optional(
+        Schema.String.pipe(
+          Schema.annotations({
+            description: 'Default value for this field when creating new records',
+          })
+        )
+      ),
+    })
+  ),
+  Schema.annotations({
+    title: 'Single Line Text Field',
+    description:
+      'Short text input limited to a single line. Ideal for names, titles, labels, and brief identifiers. Text is stored as-is without formatting.',
+    examples: [
+      {
+        id: 1,
+        name: 'title',
+        type: 'single-line-text',
+        required: true,
+        unique: false,
+        indexed: true,
+        default: 'Untitled',
+      },
+      {
+        id: 2,
+        name: 'first_name',
+        type: 'single-line-text',
+        required: true,
+      },
+    ],
+  })
+)
+
+export type SingleLineTextField = Schema.Schema.Type<typeof SingleLineTextFieldSchema>