@stonecrop/schema 0.11.0 → 0.11.1

package/dist/src/converter/heuristics.js

@@ -1,256 +0,0 @@
-/**
- * Default heuristics for identifying entity types and fields in a GraphQL schema.
- *
- * These heuristics work across common GraphQL servers (PostGraphile, Hasura, Apollo, etc.)
- * by detecting widely-adopted conventions like the Relay connection pattern.
- *
- * All heuristics can be overridden via the `isEntityType`, `isEntityField`, and
- * `classifyField` options in `GraphQLConversionOptions`.
- *
- * @packageDocumentation
- */
-import { isScalarType, isEnumType, isObjectType, isListType, isNonNullType, } from 'graphql';
-import { buildScalarMap, INTERNAL_SCALARS } from './scalars';
-import { toSlug, camelToLabel } from '../naming';
-/**
- * Suffixes that identify synthetic/framework types generated by GraphQL servers.
- * Types ending with these suffixes are typically not entities.
- */
-const SYNTHETIC_SUFFIXES = [
-    'Connection',
-    'Edge',
-    'Input',
-    'Patch',
-    'Payload',
-    'Condition',
-    'Filter',
-    'OrderBy',
-    'Aggregate',
-    'AggregateResult',
-    'AggregateFilter',
-    'DeleteResponse',
-    'InsertResponse',
-    'UpdateResponse',
-    'MutationResponse',
-];
-/**
- * Root operation type names that are never entities.
- */
-const ROOT_TYPE_NAMES = new Set(['Query', 'Mutation', 'Subscription']);
-/**
- * Default heuristic to determine if a GraphQL object type represents an entity.
- * An entity type becomes a Stonecrop doctype.
- *
- * This heuristic excludes:
- * - Introspection types (`__*`)
- * - Root operation types (`Query`, `Mutation`, `Subscription`)
- * - Types with synthetic suffixes (e.g., `*Connection`, `*Edge`, `*Input`)
- * - Types starting with `Node` interface marker (exact match only)
- *
- * @param typeName - The GraphQL type name
- * @param type - The GraphQL object type definition
- * @returns `true` if this type should become a Stonecrop doctype
- * @public
- */
-export function defaultIsEntityType(typeName, type) {
-    // Exclude introspection types
-    if (typeName.startsWith('__')) {
-        return false;
-    }
-    // Exclude root operation types
-    if (ROOT_TYPE_NAMES.has(typeName)) {
-        return false;
-    }
-    // Exclude the Node interface marker type
-    if (typeName === 'Node') {
-        return false;
-    }
-    // Exclude types matching synthetic suffixes
-    for (const suffix of SYNTHETIC_SUFFIXES) {
-        if (typeName.endsWith(suffix)) {
-            return false;
-        }
-    }
-    // Must have at least one field
-    const fields = type.getFields();
-    if (Object.keys(fields).length === 0) {
-        return false;
-    }
-    return true;
-}
-/**
- * Fields to skip by default on entity types.
- * These are internal to GraphQL servers and don't represent semantic data.
- */
-const SKIP_FIELDS = new Set(['nodeId', '__typename', 'clientMutationId']);
-/**
- * Default heuristic to filter fields on entity types.
- * Skips internal fields that don't represent meaningful data.
- *
- * @param fieldName - The GraphQL field name
- * @param _field - The GraphQL field definition (unused in default implementation)
- * @param _parentType - The parent entity type (unused in default implementation)
- * @returns `true` if this field should be included
- * @public
- */
-export function defaultIsEntityField(fieldName, _field, _parentType) {
-    return !SKIP_FIELDS.has(fieldName);
-}
-/**
- * Unwrap NonNull and List wrappers from a GraphQL type, tracking nullability.
- *
- * @param type - The GraphQL output type
- * @returns The unwrapped named type, whether it's required, and whether it's a list
- * @internal
- */
-function unwrapType(type) {
-    let required = false;
-    let isList = false;
-    let current = type;
-    // Unwrap outer NonNull
-    if (isNonNullType(current)) {
-        required = true;
-        current = current.ofType;
-    }
-    // Unwrap List
-    if (isListType(current)) {
-        isList = true;
-        current = current.ofType;
-        // Unwrap inner NonNull (e.g., [Type!])
-        if (isNonNullType(current)) {
-            current = current.ofType;
-        }
-    }
-    // At this point, current should be a named type
-    return { namedType: current, required, isList };
-}
-/**
- * Check if a GraphQL object type looks like a Relay Connection type.
- * A connection type has an `edges` field returning a list of edge types,
- * where each edge has a `node` field.
- *
- * @param type - The GraphQL object type to check
- * @returns The node type name if this is a connection, or `undefined`
- * @internal
- */
-function getConnectionNodeType(type) {
-    const fields = type.getFields();
-    // Must have an 'edges' field
-    const edgesField = fields['edges'];
-    if (!edgesField)
-        return undefined;
-    // edges must be a list
-    const { namedType: edgesType, isList: edgesIsList } = unwrapType(edgesField.type);
-    if (!edgesIsList || !isObjectType(edgesType))
-        return undefined;
-    // Each edge must have a 'node' field
-    const edgeFields = edgesType.getFields();
-    const nodeField = edgeFields['node'];
-    if (!nodeField)
-        return undefined;
-    const { namedType: nodeType } = unwrapType(nodeField.type);
-    if (!isObjectType(nodeType))
-        return undefined;
-    return nodeType.name;
-}
-/**
- * Classify a single GraphQL field into a Stonecrop field definition.
- *
- * Classification rules (in order):
- * 1. Scalar types → look up in merged scalar map
- * 2. Enum types → `Select` with enum values as options
- * 3. Object types that are entities → `Link` with slug as options
- * 4. Object types that are Connections → `Doctype` with node type slug as options
- * 5. List of entity type → `Doctype` with item type slug as options
- * 6. Anything else → `Data` with `_unmapped: true`
- *
- * @param fieldName - The GraphQL field name
- * @param field - The GraphQL field definition
- * @param entityTypes - Set of type names classified as entities
- * @param options - Conversion options (for custom scalars, unmapped meta, etc.)
- * @returns The Stonecrop field definition
- * @public
- */
-export function classifyFieldType(fieldName, field, entityTypes, options = {}) {
-    const { namedType, required, isList } = unwrapType(field.type);
-    const scalarMap = buildScalarMap(options.customScalars);
-    const base = {
-        fieldname: fieldName,
-        label: camelToLabel(fieldName),
-        component: 'ATextInput',
-        fieldtype: 'Data',
-    };
-    if (required) {
-        base.required = true;
-    }
-    // 1. Scalar types
-    if (isScalarType(namedType)) {
-        // Skip internal scalars (e.g., Cursor)
-        if (INTERNAL_SCALARS.has(namedType.name)) {
-            base._unmapped = true;
-            if (options.includeUnmappedMeta) {
-                base._graphqlType = namedType.name;
-            }
-            return base;
-        }
-        const template = scalarMap[namedType.name];
-        if (template) {
-            base.component = template.component;
-            base.fieldtype = template.fieldtype;
-        }
-        else {
-            // Unknown scalar — default to Data with unmapped marker
-            base._unmapped = true;
-            if (options.includeUnmappedMeta) {
-                base._graphqlType = namedType.name;
-            }
-        }
-        return base;
-    }
-    // 2. Enum types → Select
-    if (isEnumType(namedType)) {
-        base.component = 'ADropdown';
-        base.fieldtype = 'Select';
-        base.options = namedType.getValues().map(v => v.name);
-        return base;
-    }
-    // 3–5. Object types
-    if (isObjectType(namedType)) {
-        // 3. Direct reference to an entity type → Link
-        if (!isList && entityTypes.has(namedType.name)) {
-            base.component = 'ALink';
-            base.fieldtype = 'Link';
-            base.options = toSlug(namedType.name);
-            return base;
-        }
-        // 4. Connection type → Doctype (child table)
-        const connectionNodeTypeName = getConnectionNodeType(namedType);
-        if (connectionNodeTypeName && entityTypes.has(connectionNodeTypeName)) {
-            base.component = 'ATable';
-            base.fieldtype = 'Doctype';
-            base.options = toSlug(connectionNodeTypeName);
-            base.cardinality = 'many';
-            return base;
-        }
-        // 5. List of entity type → Doctype
-        if (isList && entityTypes.has(namedType.name)) {
-            base.component = 'ATable';
-            base.fieldtype = 'Doctype';
-            base.options = toSlug(namedType.name);
-            base.cardinality = 'many';
-            return base;
-        }
-        // Unknown object type — mark as unmapped
-        base._unmapped = true;
-        if (options.includeUnmappedMeta) {
-            base._graphqlType = namedType.name;
-        }
-        return base;
-    }
-    // Fallback — shouldn't normally be reached
-    base._unmapped = true;
-    if (options.includeUnmappedMeta) {
-        base._graphqlType = namedType.name;
-    }
-    return base;
-}

package/dist/src/converter/index.js

@@ -1,164 +0,0 @@
-/**
- * GraphQL Introspection to Stonecrop Schema Converter
- *
- * Converts a standard GraphQL introspection result (or SDL string) into
- * Stonecrop doctype schemas. Source-agnostic — works with any GraphQL server.
- *
- * @packageDocumentation
- */
-import { buildClientSchema, buildSchema, isObjectType } from 'graphql';
-import { toSlug, pascalToSnake } from '../naming';
-import { defaultIsEntityType, defaultIsEntityField, classifyFieldType } from './heuristics';
-/**
- * Convert a GraphQL schema to Stonecrop doctype schemas.
- *
- * Accepts either an `IntrospectionQuery` result object or an SDL string.
- * Entity types are identified using heuristics (or a custom `isEntityType` function)
- * and converted to `DoctypeMeta`-compatible JSON objects.
- *
- * @param source - GraphQL introspection result or SDL string
- * @param options - Conversion options for controlling output format and behavior
- * @returns Array of converted Stonecrop doctype definitions
- *
- * @example
- * ```typescript
- * // From introspection result (fetched from any GraphQL server)
- * const introspection = await fetchIntrospection('http://localhost:5000/graphql')
- * const doctypes = convertGraphQLSchema(introspection)
- *
- * // From SDL string
- * const sdl = fs.readFileSync('schema.graphql', 'utf-8')
- * const doctypes = convertGraphQLSchema(sdl)
- *
- * // With PostGraphile custom scalars
- * const doctypes = convertGraphQLSchema(introspection, {
- *   customScalars: {
- *     BigFloat: { component: 'ADecimalInput', fieldtype: 'Decimal' }
- *   }
- * })
- * ```
- *
- * @public
- */
-export function convertGraphQLSchema(source, options = {}) {
-    const schema = buildGraphQLSchema(source);
-    const typeMap = schema.getTypeMap();
-    // Determine the root operation type names to exclude
-    const rootTypeNames = new Set();
-    const queryType = schema.getQueryType();
-    const mutationType = schema.getMutationType();
-    const subscriptionType = schema.getSubscriptionType();
-    if (queryType)
-        rootTypeNames.add(queryType.name);
-    if (mutationType)
-        rootTypeNames.add(mutationType.name);
-    if (subscriptionType)
-        rootTypeNames.add(subscriptionType.name);
-    // Use custom or default entity type detector
-    const isEntityType = options.isEntityType ?? defaultIsEntityType;
-    // Phase 1: Identify all entity types
-    const entityTypes = new Set();
-    for (const [typeName, type] of Object.entries(typeMap)) {
-        if (!isObjectType(type))
-            continue;
-        // Always skip root operation types (even if custom isEntityType doesn't)
-        if (rootTypeNames.has(typeName))
-            continue;
-        if (isEntityType(typeName, type)) {
-            entityTypes.add(typeName);
-        }
-    }
-    // Phase 2: Apply include/exclude filters
-    let filteredEntityTypes = entityTypes;
-    if (options.include) {
-        const includeSet = new Set(options.include);
-        filteredEntityTypes = new Set([...entityTypes].filter(t => includeSet.has(t)));
-    }
-    if (options.exclude) {
-        const excludeSet = new Set(options.exclude);
-        filteredEntityTypes = new Set([...filteredEntityTypes].filter(t => !excludeSet.has(t)));
-    }
-    // Phase 3: Convert each entity type to a doctype
-    const isEntityField = options.isEntityField ?? defaultIsEntityField;
-    const deriveTableName = options.deriveTableName ?? ((typeName) => pascalToSnake(typeName));
-    const doctypes = [];
-    for (const typeName of filteredEntityTypes) {
-        const type = typeMap[typeName];
-        if (!isObjectType(type))
-            continue;
-        const fields = type.getFields();
-        const typeOverrides = options.typeOverrides?.[typeName];
-        const convertedFields = Object.entries(fields)
-            .filter(([fieldName, field]) => isEntityField(fieldName, field, type))
-            .map(([fieldName, field]) => {
-            // Check for full custom classification first
-            if (options.classifyField) {
-                const custom = options.classifyField(fieldName, field, type);
-                if (custom !== null && custom !== undefined) {
-                    return {
-                        fieldname: fieldName,
-                        label: custom.label ?? fieldName,
-                        component: custom.component ?? 'ATextInput',
-                        fieldtype: custom.fieldtype ?? 'Data',
-                        ...custom,
-                    };
-                }
-            }
-            // Default classification
-            const classified = classifyFieldType(fieldName, field, entityTypes, options);
-            // Apply per-field overrides
-            if (typeOverrides?.[fieldName]) {
-                return { ...classified, ...typeOverrides[fieldName] };
-            }
-            return classified;
-        })
-            // Clean up internal metadata unless requested
-            .map(field => {
-            if (!options.includeUnmappedMeta) {
-                const { _graphqlType, _unmapped, ...clean } = field;
-                return clean;
-            }
-            return field;
-        });
-        const doctype = {
-            name: typeName,
-            slug: toSlug(typeName),
-            fields: convertedFields,
-        };
-        const tableName = deriveTableName(typeName);
-        if (tableName) {
-            doctype.tableName = tableName;
-        }
-        if (options.includeUnmappedMeta) {
-            doctype._graphqlTypeName = typeName;
-        }
-        doctypes.push(doctype);
-    }
-    return doctypes;
-}
-/**
- * Build a GraphQLSchema from either an introspection result or SDL string.
- *
- * @param source - IntrospectionQuery object or SDL string
- * @returns A complete GraphQLSchema
- * @internal
- */
-function buildGraphQLSchema(source) {
-    if (typeof source === 'string') {
-        // SDL string
-        return buildSchema(source);
-    }
-    // IntrospectionQuery result
-    return buildClientSchema(source);
-}
-// ═══════════════════════════════════════════════════════════════
-// Re-exports
-// ═══════════════════════════════════════════════════════════════
-// Main converter (this file)
-export { convertGraphQLSchema as default };
-// Scalar maps
-export { GQL_SCALAR_MAP, WELL_KNOWN_SCALARS, INTERNAL_SCALARS, buildScalarMap } from './scalars';
-// Heuristics
-export { defaultIsEntityType, defaultIsEntityField, classifyFieldType } from './heuristics';
-// Naming utilities
-export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from '../naming';

package/dist/src/converter/scalars.js

@@ -1,86 +0,0 @@
-/**
- * GraphQL Scalar Type Mappings
- *
- * Maps standard GraphQL scalars and well-known custom scalars to Stonecrop field types.
- * Source-agnostic — covers scalars commonly emitted by PostGraphile, Hasura, Apollo, etc.
- *
- * Users can extend these via the `customScalars` option in `GraphQLConversionOptions`.
- *
- * @packageDocumentation
- */
-/**
- * Mapping from standard GraphQL scalar types to Stonecrop field types.
- * These are defined by the GraphQL specification and are always available.
- *
- * @public
- */
-export const GQL_SCALAR_MAP = {
-    String: { component: 'ATextInput', fieldtype: 'Data' },
-    Int: { component: 'ANumericInput', fieldtype: 'Int' },
-    Float: { component: 'ANumericInput', fieldtype: 'Float' },
-    Boolean: { component: 'ACheckbox', fieldtype: 'Check' },
-    ID: { component: 'ATextInput', fieldtype: 'Data' },
-};
-/**
- * Mapping from well-known custom GraphQL scalars to Stonecrop field types.
- * These cover scalars commonly used across GraphQL servers (PostGraphile, Hasura, etc.)
- * without baking in knowledge of any specific server.
- *
- * Entries here have lower precedence than `customScalars` from options, but higher
- * precedence than unknown/unmapped scalars.
- *
- * @public
- */
-export const WELL_KNOWN_SCALARS = {
-    // Arbitrary precision / large numbers
-    BigFloat: { component: 'ADecimalInput', fieldtype: 'Decimal' },
-    BigDecimal: { component: 'ADecimalInput', fieldtype: 'Decimal' },
-    Decimal: { component: 'ADecimalInput', fieldtype: 'Decimal' },
-    BigInt: { component: 'ANumericInput', fieldtype: 'Int' },
-    Long: { component: 'ANumericInput', fieldtype: 'Int' },
-    // Identifiers
-    UUID: { component: 'ATextInput', fieldtype: 'Data' },
-    // Date / Time
-    DateTime: { component: 'ADatetimePicker', fieldtype: 'Datetime' },
-    Datetime: { component: 'ADatetimePicker', fieldtype: 'Datetime' },
-    Date: { component: 'ADate', fieldtype: 'Date' },
-    Time: { component: 'ATimeInput', fieldtype: 'Time' },
-    Interval: { component: 'ADurationInput', fieldtype: 'Duration' },
-    Duration: { component: 'ADurationInput', fieldtype: 'Duration' },
-    // Structured data
-    JSON: { component: 'ACodeEditor', fieldtype: 'JSON' },
-    JSONObject: { component: 'ACodeEditor', fieldtype: 'JSON' },
-    JsonNode: { component: 'ACodeEditor', fieldtype: 'JSON' },
-};
-/**
- * Set of scalar type names that are internal to GraphQL servers and should be skipped
- * during field conversion (they don't represent meaningful data fields).
- *
- * @public
- */
-export const INTERNAL_SCALARS = new Set(['Cursor']);
-/**
- * Build a merged scalar map from the built-in maps and user-provided custom scalars.
- * Precedence (highest to lowest): customScalars → GQL_SCALAR_MAP → WELL_KNOWN_SCALARS
- *
- * @param customScalars - User-provided scalar overrides
- * @returns Merged scalar map
- * @public
- */
-export function buildScalarMap(customScalars) {
-    const merged = { ...WELL_KNOWN_SCALARS };
-    // Standard scalars override well-known
-    for (const [key, value] of Object.entries(GQL_SCALAR_MAP)) {
-        merged[key] = value;
-    }
-    // Custom scalars override everything
-    if (customScalars) {
-        for (const [key, value] of Object.entries(customScalars)) {
-            merged[key] = {
-                component: value.component ?? 'ATextInput',
-                fieldtype: value.fieldtype ?? 'Data',
-            };
-        }
-    }
-    return merged;
-}

package/dist/src/converter/types.js

@@ -1,5 +0,0 @@
-/**
- * Types for the GraphQL introspection to Stonecrop schema converter.
- * Source-agnostic — works with any GraphQL server (PostGraphile, Hasura, Apollo, etc.)
- * @packageDocumentation
- */

package/dist/src/doctype.js

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-import { FieldMeta } from './field';
-/**
- * Action definition within a workflow
- * @public
- */
-export const ActionDefinition = z
-    .object({
-    /** Display label for the action */
-    label: z.string().min(1),
-    /** Handler function name or path */
-    handler: z.string().min(1),
-    /** Fields that must have values before action can execute */
-    requiredFields: z.array(z.string()).optional(),
-    /** Workflow states where this action is available */
-    allowedStates: z.array(z.string()).optional(),
-    /** Whether to show a confirmation dialog */
-    confirm: z.boolean().optional(),
-    /** Additional arguments for the action */
-    args: z.record(z.string(), z.unknown()).optional(),
-})
-    .meta({
-    title: 'ActionDefinition',
-    description: 'Action definition within a workflow',
-});
-/**
- * Workflow metadata - states and actions for a doctype
- * @public
- */
-export const WorkflowMeta = z
-    .object({
-    /** List of workflow states */
-    states: z.array(z.string()).optional(),
-    /** Actions available in this workflow */
-    actions: z.record(z.string(), ActionDefinition).optional(),
-})
-    .meta({
-    title: 'WorkflowMeta',
-    description: 'Workflow metadata - states and actions for a doctype',
-});
-/**
- * Doctype metadata - complete definition of a doctype
- * @public
- */
-export const DoctypeMeta = z
-    .object({
-    /** Display name of the doctype */
-    name: z.string().min(1),
-    /** URL-friendly slug (kebab-case) */
-    slug: z.string().min(1).optional(),
-    /** Database table name */
-    tableName: z.string().optional(),
-    /** Field definitions */
-    fields: z.array(FieldMeta),
-    /** Workflow configuration */
-    workflow: WorkflowMeta.optional(),
-    /** Parent doctype for inheritance */
-    inherits: z.string().optional(),
-    /** Doctype to use for list views */
-    listDoctype: z.string().optional(),
-    /** Parent doctype for child tables */
-    parentDoctype: z.string().optional(),
-})
-    .meta({
-    title: 'DoctypeMeta',
-    description: 'Doctype metadata - complete definition of a doctype',
-});

package/dist/src/field.js

@@ -1,108 +0,0 @@
-import { z } from 'zod';
-import { StonecropFieldType } from './fieldtype';
-/**
- * Field options - flexible bag for type-specific configuration.
- *
- * Usage by fieldtype:
- * - Link/Doctype: target doctype slug as string ("customer", "sales-order-item")
- * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
- * - Decimal: config object (\{ precision: 10, scale: 2 \})
- * - Code: config object (\{ language: "python" \})
- *
- * @public
- */
-export const FieldOptions = z
-    .union([
-    z.string(), // Link/Doctype target: "customer"
-    z.array(z.string()), // Select choices: ["A", "B", "C"]
-    z.record(z.string(), z.unknown()), // Config: \{ precision: 10, scale: 2 \}
-])
-    .meta({
-    title: 'FieldOptions',
-    description: 'Field options - flexible bag for type-specific configuration',
-});
-/**
- * Validation configuration for form fields
- * @public
- */
-export const FieldValidation = z
-    .looseObject({
-    /** Error message to display when validation fails */
-    errorMessage: z.string(),
-})
-    .meta({
-    title: 'FieldValidation',
-    description: 'Validation configuration for form fields',
-});
-/**
- * Unified field metadata - the single source of truth for field definitions.
- * Works for both forms (AForm) and tables (ATable).
- *
- * Core principle: "Text" is "Text" regardless of rendering context.
- *
- * @public
- */
-export const FieldMeta = z
-    .object({
-    // === CORE (required) ===
-    /** Unique identifier for the field within its doctype */
-    fieldname: z.string().min(1),
-    /** Semantic field type - determines behavior and default component */
-    fieldtype: StonecropFieldType,
-    // === COMPONENT (optional - derived from fieldtype when not specified) ===
-    /** Vue component to render this field. If not specified, derived from TYPE_MAP */
-    component: z.string().optional(),
-    // === DISPLAY ===
-    /** Human-readable label for the field */
-    label: z.string().optional(),
-    /** Width of the field (CSS value, e.g., "40ch", "200px") */
-    width: z.string().optional(),
-    /** Text alignment within the field */
-    align: z.enum(['left', 'center', 'right', 'start', 'end']).optional(),
-    // === BEHAVIOR ===
-    /** Whether the field is required */
-    required: z.boolean().optional(),
-    /** Whether the field is read-only */
-    readOnly: z.boolean().optional(),
-    /** Whether the field is editable (for table cells) */
-    edit: z.boolean().optional(),
-    /** Whether the field is hidden from the UI */
-    hidden: z.boolean().optional(),
-    // === VALUE ===
-    /** Current value of the field */
-    value: z.unknown().optional(),
-    /** Default value for new records */
-    default: z.unknown().optional(),
-    // === TYPE-SPECIFIC ===
-    /**
-     * Type-specific options:
-     * - Link: target doctype slug ("customer")
-     * - Doctype: child doctype slug ("sales-order-item")
-     * - Select: choices array (["Draft", "Submitted"])
-     * - Decimal: \{ precision, scale \}
-     * - Code: \{ language \}
-     */
-    options: FieldOptions.optional(),
-    /**
-     * Cardinality for Doctype fields:
-     * - 'one': 1:1 nested form (default)
-     * - 'many': 1:many child table
-     */
-    cardinality: z.enum(['one', 'many']).optional(),
-    /**
-     * Input mask pattern. Accepts either a plain mask string or a stringified
-     * arrow function that receives `locale` and returns a mask string.
-     *
-     * Plain pattern: `"##/##/####"`
-     *
-     * Function pattern: `"(locale) => locale === 'en-US' ? '(###) ###-####' : '####-######'"`
-     */
-    mask: z.string().optional(),
-    // === VALIDATION ===
-    /** Validation configuration */
-    validation: FieldValidation.optional(),
-})
-    .meta({
-    title: 'FieldMeta',
-    description: 'Unified field metadata - the single source of truth for field definitions, works for both forms (AForm) and tables (ATable)',
-});