@rippling/rippling-sdk 0.2.0-alpha.83 → 0.2.0-alpha.85

package/src/core/platform/manifest/custom-objects/typed-condition.ts

@@ -1,617 +0,0 @@
-import type { AnyCustomObjectDefinition, FieldNames } from '../../custom-objects/types';
-import type {
-  ManifestConditionCategory,
-  ManifestConditionFragment,
-  ManifestCustomObjectTarget,
-} from './conditions';
-import type { ManifestRegistration } from './types';
-
-const STANDARD_TYPED_CONDITION_FIELDS = [
-  'id',
-  'name',
-  'created_at',
-  'updated_at',
-  'system_updated_at',
-  'external_id',
-  'owner_role',
-  'created_by',
-  'last_modified_by',
-] as const;
-
-const STANDARD_TYPED_CONDITION_LOOKUP_FIELDS = new Set(['owner_role', 'created_by', 'last_modified_by']);
-
-/** Standard field-name strings accepted by {@link typedCondition}. */
-export type ParsedConditionStandardFieldName<TDefinition extends AnyCustomObjectDefinition> =
-  (typeof STANDARD_TYPED_CONDITION_FIELDS)[number];
-
-/** Field-name strings accepted by {@link typedCondition}. */
-export type ParsedConditionFieldName<TDefinition extends AnyCustomObjectDefinition> =
-  | ParsedConditionStandardFieldName<TDefinition>
-  | FieldNames<TDefinition>;
-
-interface ParsedConditionStringLiteral {
-  readonly kind: 'string';
-  readonly value: string;
-}
-
-interface ParsedConditionNumberLiteral {
-  readonly kind: 'number';
-  readonly value: number;
-}
-
-interface ParsedConditionBooleanLiteral {
-  readonly kind: 'boolean';
-  readonly value: boolean;
-}
-
-interface ParsedConditionNullLiteral {
-  readonly kind: 'null';
-}
-
-interface ParsedConditionFunctionLiteral {
-  readonly kind: 'function';
-  readonly name: 'TODAY';
-}
-
-interface ParsedConditionArrayLiteral {
-  readonly kind: 'array';
-  readonly value: readonly ParsedConditionScalarLiteral[];
-}
-
-type ParsedConditionScalarLiteral =
-  | ParsedConditionStringLiteral
-  | ParsedConditionNumberLiteral
-  | ParsedConditionBooleanLiteral
-  | ParsedConditionNullLiteral;
-
-type ParsedConditionLiteral =
-  | ParsedConditionScalarLiteral
-  | ParsedConditionFunctionLiteral
-  | ParsedConditionArrayLiteral;
-
-interface ParsedConditionComparisonNode {
-  readonly kind: 'comparison';
-  readonly field: string;
-  readonly operator: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'IN' | 'NOT_IN';
-  readonly value: ParsedConditionLiteral;
-}
-
-interface ParsedConditionLogicalNode {
-  readonly kind: 'logical';
-  readonly operator: 'AND' | 'OR';
-  readonly operands: readonly ParsedConditionExpressionNode[];
-}
-
-interface ParsedConditionNotNode {
-  readonly kind: 'not';
-  readonly operand: ParsedConditionExpressionNode;
-}
-
-type ParsedConditionExpressionNode =
-  | ParsedConditionComparisonNode
-  | ParsedConditionLogicalNode
-  | ParsedConditionNotNode;
-
-interface RuntimeParsedConditionState {
-  text: string;
-  index: number;
-}
-
-interface RuntimeConditionFieldMetadata {
-  readonly apiName: string;
-  readonly category: ManifestConditionCategory;
-}
-
-function isManifestRegistration<TDefinition extends AnyCustomObjectDefinition>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-): target is ManifestRegistration<TDefinition> {
-  return typeof target === 'object' && target != null && 'definition' in target && 'object' in target;
-}
-
-function resolveTargetDefinition<TDefinition extends AnyCustomObjectDefinition>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-): TDefinition {
-  return isManifestRegistration(target) ? target.definition : target;
-}
-
-function createFragment(text: string): ManifestConditionFragment {
-  return Object.freeze({ text });
-}
-
-function skipWhitespace(state: RuntimeParsedConditionState): void {
-  while (state.index < state.text.length && /\s/.test(state.text[state.index] ?? '')) {
-    state.index += 1;
-  }
-}
-
-function consumeCharacter(state: RuntimeParsedConditionState, expected: string): boolean {
-  skipWhitespace(state);
-  if (state.text[state.index] === expected) {
-    state.index += 1;
-    return true;
-  }
-  return false;
-}
-
-function expectCharacter(state: RuntimeParsedConditionState, expected: string): void {
-  if (!consumeCharacter(state, expected)) {
-    throw new Error(`Expected "${expected}" at index ${state.index}.`);
-  }
-}
-
-function consumeKeyword(state: RuntimeParsedConditionState, keyword: string): boolean {
-  skipWhitespace(state);
-  const candidate = state.text.slice(state.index, state.index + keyword.length);
-  if (candidate.toUpperCase() !== keyword) return false;
-
-  const nextCharacter = state.text[state.index + keyword.length];
-  if (nextCharacter != null && /[A-Za-z0-9_]/.test(nextCharacter)) return false;
-
-  state.index += keyword.length;
-  return true;
-}
-
-function parseIdentifier(state: RuntimeParsedConditionState): string {
-  skipWhitespace(state);
-  const start = state.index;
-  while (state.index < state.text.length && /[A-Za-z0-9_]/.test(state.text[state.index] ?? '')) {
-    state.index += 1;
-  }
-  if (state.index === start) {
-    throw new Error(`Expected a field or function identifier at index ${state.index}.`);
-  }
-  return state.text.slice(start, state.index);
-}
-
-function parseStringLiteral(state: RuntimeParsedConditionState): ParsedConditionStringLiteral {
-  expectCharacter(state, "'");
-  let value = '';
-  while (state.index < state.text.length) {
-    const character = state.text[state.index];
-    if (character === undefined) break;
-    state.index += 1;
-    if (character === "'") {
-      return { kind: 'string', value };
-    }
-    if (character === '\\') {
-      const escaped = state.text[state.index];
-      if (escaped == null) {
-        throw new Error('Unterminated escape sequence in manifest condition string literal.');
-      }
-      state.index += 1;
-      value += escaped;
-      continue;
-    }
-    value += character;
-  }
-  throw new Error('Unterminated manifest condition string literal.');
-}
-
-function parseNumberLiteral(state: RuntimeParsedConditionState): ParsedConditionNumberLiteral {
-  skipWhitespace(state);
-  const start = state.index;
-  if (state.text[state.index] === '-') {
-    state.index += 1;
-  }
-  let sawDigit = false;
-  while (state.index < state.text.length && /[0-9]/.test(state.text[state.index] ?? '')) {
-    state.index += 1;
-    sawDigit = true;
-  }
-  if (state.text[state.index] === '.') {
-    state.index += 1;
-    while (state.index < state.text.length && /[0-9]/.test(state.text[state.index] ?? '')) {
-      state.index += 1;
-      sawDigit = true;
-    }
-  }
-  if (!sawDigit) {
-    throw new Error(`Expected a number literal at index ${start}.`);
-  }
-  const value = Number(state.text.slice(start, state.index));
-  if (!Number.isFinite(value)) {
-    throw new Error(
-      `Manifest-condition numeric literals must be finite. Received ${state.text.slice(start, state.index)}.`,
-    );
-  }
-  return { kind: 'number', value };
-}
-
-function parseScalarLiteral(
-  state: RuntimeParsedConditionState,
-): ParsedConditionScalarLiteral | ParsedConditionFunctionLiteral {
-  skipWhitespace(state);
-  const character = state.text[state.index];
-  if (character === "'") return parseStringLiteral(state);
-  if (character === '-' || /[0-9]/.test(character ?? '')) return parseNumberLiteral(state);
-  if (consumeKeyword(state, 'TRUE')) return { kind: 'boolean', value: true };
-  if (consumeKeyword(state, 'FALSE')) return { kind: 'boolean', value: false };
-  if (consumeKeyword(state, 'NULL')) return { kind: 'null' };
-  if (consumeKeyword(state, 'TODAY')) {
-    expectCharacter(state, '(');
-    expectCharacter(state, ')');
-    return { kind: 'function', name: 'TODAY' };
-  }
-  throw new Error(`Expected a supported manifest-condition literal at index ${state.index}.`);
-}
-
-function parseArrayLiteral(state: RuntimeParsedConditionState): ParsedConditionArrayLiteral {
-  expectCharacter(state, '[');
-  const values: ParsedConditionScalarLiteral[] = [];
-  while (true) {
-    skipWhitespace(state);
-    if (consumeCharacter(state, ']')) {
-      return { kind: 'array', value: values };
-    }
-    const nextValue = parseScalarLiteral(state);
-    if (nextValue.kind === 'function') {
-      throw new Error('Manifest-condition arrays do not support TODAY().');
-    }
-    values.push(nextValue);
-    skipWhitespace(state);
-    if (consumeCharacter(state, ']')) {
-      return { kind: 'array', value: values };
-    }
-    expectCharacter(state, ',');
-  }
-}
-
-function parseLiteral(state: RuntimeParsedConditionState): ParsedConditionLiteral {
-  skipWhitespace(state);
-  if (state.text[state.index] === '[') {
-    return parseArrayLiteral(state);
-  }
-  return parseScalarLiteral(state);
-}
-
-function parseOperator(state: RuntimeParsedConditionState): ParsedConditionComparisonNode['operator'] {
-  skipWhitespace(state);
-  for (const operator of ['NOT_IN', 'IN', '==', '!=', '<=', '>=', '<', '>'] as const) {
-    if (state.text.slice(state.index, state.index + operator.length).toUpperCase() === operator) {
-      state.index += operator.length;
-      return operator;
-    }
-  }
-  throw new Error(`Expected a manifest-condition operator at index ${state.index}.`);
-}
-
-function parseComparison(state: RuntimeParsedConditionState): ParsedConditionComparisonNode {
-  const field = parseIdentifier(state);
-  const operator = parseOperator(state);
-  const value = parseLiteral(state);
-  return { kind: 'comparison', field, operator, value };
-}
-
-function parsePrimary(state: RuntimeParsedConditionState): ParsedConditionExpressionNode {
-  skipWhitespace(state);
-  if (consumeCharacter(state, '(')) {
-    const expression = parseOrExpression(state);
-    expectCharacter(state, ')');
-    return expression;
-  }
-  return parseComparison(state);
-}
-
-function parseNotExpression(state: RuntimeParsedConditionState): ParsedConditionExpressionNode {
-  skipWhitespace(state);
-  if (consumeKeyword(state, 'NOT')) {
-    return { kind: 'not', operand: parseNotExpression(state) };
-  }
-  return parsePrimary(state);
-}
-
-function parseAndExpression(state: RuntimeParsedConditionState): ParsedConditionExpressionNode {
-  const operands: ParsedConditionExpressionNode[] = [parseNotExpression(state)];
-  while (true) {
-    const checkpoint = state.index;
-    if (!consumeKeyword(state, 'AND')) {
-      state.index = checkpoint;
-      break;
-    }
-    operands.push(parseNotExpression(state));
-  }
-  return operands.length === 1 ? operands[0]! : { kind: 'logical', operator: 'AND', operands };
-}
-
-function parseOrExpression(state: RuntimeParsedConditionState): ParsedConditionExpressionNode {
-  const operands: ParsedConditionExpressionNode[] = [parseAndExpression(state)];
-  while (true) {
-    const checkpoint = state.index;
-    if (!consumeKeyword(state, 'OR')) {
-      state.index = checkpoint;
-      break;
-    }
-    operands.push(parseAndExpression(state));
-  }
-  return operands.length === 1 ? operands[0]! : { kind: 'logical', operator: 'OR', operands };
-}
-
-function parseTypedConditionExpression(text: string): ParsedConditionExpressionNode {
-  const state: RuntimeParsedConditionState = { text, index: 0 };
-  const expression = parseOrExpression(state);
-  skipWhitespace(state);
-  if (state.index !== state.text.length) {
-    throw new Error(
-      `Unexpected trailing manifest-condition content starting at index ${state.index}: ${state.text.slice(
-        state.index,
-      )}.`,
-    );
-  }
-  return expression;
-}
-
-function resolveRuntimeFieldMetadata(
-  definition: AnyCustomObjectDefinition,
-  fieldName: string,
-): RuntimeConditionFieldMetadata {
-  if ((STANDARD_TYPED_CONDITION_FIELDS as readonly string[]).includes(fieldName)) {
-    return {
-      apiName: fieldName,
-      category: STANDARD_TYPED_CONDITION_LOOKUP_FIELDS.has(fieldName) ? 'lookup' : 'string',
-    };
-  }
-
-  const field = definition.fields[fieldName as FieldNames<typeof definition>];
-  if (field == null) {
-    throw new Error(
-      `Unknown manifest-condition field "${fieldName}" for "${definition.apiName}". Valid fields: ${[
-        ...STANDARD_TYPED_CONDITION_FIELDS,
-        ...Object.keys(definition.fields).sort(),
-      ].join(', ')}.`,
-    );
-  }
-
-  switch (field.kind) {
-    case 'text':
-    case 'long-text':
-    case 'email':
-    case 'url':
-    case 'phone':
-    case 'date':
-    case 'datetime':
-    case 'time':
-    case 'select':
-    case 'radio':
-    case 'formula-text':
-    case 'formula-date':
-    case 'formula-url':
-      return { apiName: field.apiName, category: 'string' };
-    case 'number':
-    case 'currency':
-    case 'percentage':
-    case 'formula-number':
-    case 'formula-currency':
-    case 'formula-percentage':
-      return { apiName: field.apiName, category: 'number' };
-    case 'boolean':
-    case 'formula-boolean':
-      return { apiName: field.apiName, category: 'boolean' };
-    case 'lookup':
-    case 'parent-child':
-      return { apiName: field.apiName, category: 'lookup' };
-    default:
-      return { apiName: field.apiName, category: 'unsupported' };
-  }
-}
-
-function encodeConditionString(value: string): string {
-  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
-}
-
-function renderConditionLiteral(literal: ParsedConditionLiteral): string {
-  switch (literal.kind) {
-    case 'string':
-      return encodeConditionString(literal.value);
-    case 'number':
-      return String(literal.value);
-    case 'boolean':
-      return literal.value ? 'True' : 'False';
-    case 'null':
-      return 'null';
-    case 'function':
-      return `${literal.name}()`;
-    case 'array':
-      return `[${literal.value.map((value) => renderConditionLiteral(value)).join(', ')}]`;
-  }
-}
-
-function describeExpectedLiteral(category: ManifestConditionCategory): string {
-  switch (category) {
-    case 'string':
-      return "a quoted string literal such as 'Ada' or TODAY()";
-    case 'number':
-      return 'a numeric literal such as 14';
-    case 'boolean':
-      return 'a boolean literal: True or False';
-    case 'lookup':
-      return "a quoted record-id string such as 'role_123'";
-    default:
-      return 'a supported literal value';
-  }
-}
-
-function describeLiteral(literal: ParsedConditionLiteral): string {
-  switch (literal.kind) {
-    case 'string':
-      return `quoted string ${encodeConditionString(literal.value)}`;
-    case 'number':
-      return `number ${String(literal.value)}`;
-    case 'boolean':
-      return `boolean ${literal.value ? 'True' : 'False'}`;
-    case 'null':
-      return 'null';
-    case 'function':
-      return `${literal.name}()`;
-    case 'array':
-      return `array ${renderConditionLiteral(literal)}`;
-  }
-}
-
-function assertLiteralMatchesCategory(
-  fieldName: string,
-  category: ManifestConditionCategory,
-  operator: ParsedConditionComparisonNode['operator'],
-  literal: ParsedConditionLiteral,
-): void {
-  if (category === 'unsupported') {
-    throw new Error('typedCondition(...) does not yet support this field kind in parsed-string mode.');
-  }
-
-  if (operator === 'IN' || operator === 'NOT_IN') {
-    if (literal.kind !== 'array') {
-      throw new Error(
-        `Manifest-condition field "${fieldName}" with operator "${operator}" requires an array literal such as ['value']; received ${describeLiteral(
-          literal,
-        )}.`,
-      );
-    }
-    if (literal.value.length === 0) {
-      throw new Error(
-        `Manifest-condition field "${fieldName}" with operator "${operator}" requires a non-empty array literal such as ['value'].`,
-      );
-    }
-    for (const value of literal.value) {
-      assertLiteralMatchesCategory(fieldName, category, '==', value);
-    }
-    return;
-  }
-
-  if (literal.kind === 'null') {
-    if (operator === '<' || operator === '<=' || operator === '>' || operator === '>=') {
-      throw new Error(
-        `Manifest-condition field "${fieldName}" with operator "${operator}" does not allow null. Use a concrete ${describeExpectedLiteral(
-          category,
-        )}.`,
-      );
-    }
-    return;
-  }
-
-  if (literal.kind === 'function') {
-    if (literal.name !== 'TODAY' || category !== 'string') {
-      throw new Error(
-        `Manifest-condition field "${fieldName}" with operator "${operator}" does not support ${describeLiteral(
-          literal,
-        )}.`,
-      );
-    }
-    return;
-  }
-
-  if (
-    (operator === '<' || operator === '<=' || operator === '>' || operator === '>=') &&
-    !(category === 'string' || category === 'number')
-  ) {
-    throw new Error(
-      `Manifest-condition field "${fieldName}" uses operator "${operator}", which is only valid for string or number fields; this field expects ${describeExpectedLiteral(
-        category,
-      )}.`,
-    );
-  }
-
-  switch (category) {
-    case 'string':
-      if (literal.kind !== 'string') {
-        throw new Error(
-          `Manifest-condition field "${fieldName}" with operator "${operator}" expects ${describeExpectedLiteral(
-            category,
-          )}; received ${describeLiteral(literal)}.`,
-        );
-      }
-      return;
-    case 'number':
-      if (literal.kind !== 'number') {
-        throw new Error(
-          `Manifest-condition field "${fieldName}" with operator "${operator}" expects ${describeExpectedLiteral(
-            category,
-          )}; received ${describeLiteral(literal)}.`,
-        );
-      }
-      return;
-    case 'boolean':
-      if (literal.kind !== 'boolean') {
-        throw new Error(
-          `Manifest-condition field "${fieldName}" with operator "${operator}" expects ${describeExpectedLiteral(
-            category,
-          )}; received ${describeLiteral(literal)}.`,
-        );
-      }
-      return;
-    case 'lookup':
-      if (literal.kind !== 'string') {
-        throw new Error(
-          `Manifest-condition field "${fieldName}" with operator "${operator}" expects ${describeExpectedLiteral(
-            category,
-          )}; received ${describeLiteral(literal)}.`,
-        );
-      }
-      return;
-    default:
-      return;
-  }
-}
-
-function validateTypedConditionAst(
-  definition: AnyCustomObjectDefinition,
-  node: ParsedConditionExpressionNode,
-): void {
-  switch (node.kind) {
-    case 'logical':
-      for (const operand of node.operands) validateTypedConditionAst(definition, operand);
-      return;
-    case 'not':
-      validateTypedConditionAst(definition, node.operand);
-      return;
-    case 'comparison': {
-      const metadata = resolveRuntimeFieldMetadata(definition, node.field);
-      assertLiteralMatchesCategory(node.field, metadata.category, node.operator, node.value);
-      return;
-    }
-  }
-}
-
-function renderTypedConditionAst(
-  definition: AnyCustomObjectDefinition,
-  node: ParsedConditionExpressionNode,
-): string {
-  switch (node.kind) {
-    case 'logical':
-      return `(${node.operands
-        .map((operand) => renderTypedConditionAst(definition, operand))
-        .join(` ${node.operator} `)})`;
-    case 'not':
-      return `(NOT ${renderTypedConditionAst(definition, node.operand)})`;
-    case 'comparison': {
-      const metadata = resolveRuntimeFieldMetadata(definition, node.field);
-      return `(${metadata.apiName} ${node.operator} ${renderConditionLiteral(node.value)})`;
-    }
-  }
-}
-
-/**
- * Parses one constrained logical-name manifest-condition string, validates it against the typed custom-object definition,
- * and renders a backend-ready manifest condition that uses wire-level field API names.
- *
- * Supported parsed-string manifest-condition contract:
- * - standard record fields and local custom-object fields
- * - `==`, `!=`, `<`, `<=`, `>`, `>=`, `IN`, `NOT_IN`
- * - `AND`, `OR`, `NOT`
- * - parentheses / grouping
- * - string / number / boolean / null / array literals
- * - `TODAY()`
- *
- * @param target - Object definition or manifest registration whose logical field names should be enforced.
- * @param expression - Constrained logical-name manifest-condition source string to parse and render.
- * @returns Opaque manifest-condition fragment that can be passed anywhere typed manifest helpers accept conditions.
- * @typeParam TDefinition - Object definition whose field names and value categories should be enforced.
- * @typeParam TExpression - Candidate manifest-condition expression string.
- */
-export function typedCondition<TDefinition extends AnyCustomObjectDefinition, TExpression extends string>(
-  target: ManifestCustomObjectTarget<TDefinition>,
-  expression: TExpression,
-): ManifestConditionFragment {
-  const definition = resolveTargetDefinition(target);
-  const ast = parseTypedConditionExpression(expression as string);
-  validateTypedConditionAst(definition, ast);
-  return createFragment(renderTypedConditionAst(definition, ast));
-}

package/src/core/platform/manifest/custom-objects/types.ts

@@ -1,92 +0,0 @@
-import type {
-  Category,
-  CustomObject,
-  CustomObjectFieldSection,
-  BooleanField,
-  CurrencyField,
-  DateField,
-  DatetimeField,
-  EmailField,
-  FileField,
-  FormulaField,
-  LongTextField,
-  LookupField,
-  NumberField,
-  ParentChildField,
-  PercentageField,
-  PhoneField,
-  RadioField,
-  SelectField,
-  TextField,
-  TimeField,
-  UrlField,
-} from '../../../../lib/manifest';
-import type {
-  AnyCustomObjectDefinition,
-  BooleanFieldDefinition,
-  CurrencyFieldDefinition,
-  DateFieldDefinition,
-  DatetimeFieldDefinition,
-  EmailFieldDefinition,
-  FieldNames,
-  FileFieldDefinition,
-  FormulaFieldDefinition,
-  LongTextFieldDefinition,
-  LookupFieldDefinition,
-  NumberFieldDefinition,
-  ParentChildFieldDefinition,
-  PercentageFieldDefinition,
-  PhoneFieldDefinition,
-  RadioFieldDefinition,
-  SelectFieldDefinition,
-  TextFieldDefinition,
-  TimeFieldDefinition,
-  UrlFieldDefinition,
-} from '../../custom-objects/types';
-
-/**
- * Runtime compilation result for the typed custom-object manifest adapter.
- *
- * The return type preserves both logical field keys and concrete manifest field
- * classes so authors can continue using the existing manifest APIs while the
- * typed schema layer owns wire-level naming details.
- *
- * @typeParam TDefinition - Object definition that was materialized into manifest classes.
- */
-export interface ManifestRegistration<TDefinition extends AnyCustomObjectDefinition> {
-  readonly definition: TDefinition;
-  readonly category: Category;
-  readonly object: CustomObject;
-  readonly sections: {
-    readonly [K in Extract<keyof TDefinition['sections'], string>]: CustomObjectFieldSection;
-  };
-  readonly fields: {
-    readonly [K in FieldNames<TDefinition>]: ManifestFieldForDefinition<TDefinition['fields'][K]>;
-  };
-}
-
-/**
- * Maps a typed field definition to the concrete manifest field class it compiles into.
- *
- * @typeParam TField - Field definition that should be translated into a manifest class.
- */
-export type ManifestFieldForDefinition<TField> =
-  TField extends TextFieldDefinition<any, any> ? TextField
-  : TField extends LongTextFieldDefinition<any, any> ? LongTextField
-  : TField extends EmailFieldDefinition<any, any> ? EmailField
-  : TField extends UrlFieldDefinition<any, any> ? UrlField
-  : TField extends PhoneFieldDefinition<any, any> ? PhoneField
-  : TField extends NumberFieldDefinition<any, any> ? NumberField
-  : TField extends CurrencyFieldDefinition<any, any> ? CurrencyField
-  : TField extends PercentageFieldDefinition<any, any> ? PercentageField
-  : TField extends DateFieldDefinition<any, any> ? DateField
-  : TField extends DatetimeFieldDefinition<any, any> ? DatetimeField
-  : TField extends TimeFieldDefinition<any, any> ? TimeField
-  : TField extends SelectFieldDefinition<any, any> ? SelectField
-  : TField extends RadioFieldDefinition<any, any> ? RadioField
-  : TField extends BooleanFieldDefinition<any, any> ? BooleanField
-  : TField extends FileFieldDefinition<any, any> ? FileField
-  : TField extends LookupFieldDefinition<any, any, any> ? LookupField
-  : TField extends ParentChildFieldDefinition<any, any> ? ParentChildField
-  : TField extends FormulaFieldDefinition<any, any, any> ? FormulaField
-  : never;