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

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

@@ -0,0 +1,617 @@
+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

@@ -0,0 +1,92 @@
+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;