Type alias ModelField<T, UsedMethod, Auth, FT>

Type declaration

• Optional [___auth]?: Auth

• [brandSymbol]: typeof brandName

• [internal]:function

  • [internal](): ModelField<T, UsedMethod, Auth, FT>

  • Internal non-omittable method that allows BaseModelField to retain a reference to T type arg in ModelField. Since all public methods are omittable, the evaluated BaseModelField loses type information unless some property on the type is guaranteed to reference T Context: https://github.com/aws-amplify/amplify-data/pull/406/files#r1869481467

    Returns ModelField<T, UsedMethod, Auth, FT>

• array:function

  • array(): ModelField<ArrayField<T>, "array" | "validate" | Exclude<UsedMethod, "required">, Auth, FT>

  • Converts a field type definition to an array of the field type.

    Returns ModelField<ArrayField<T>, "array" | "validate" | Exclude<UsedMethod, "required">, Auth, FT>

• authorization:function

  • authorization<AuthRuleType>(callback): ModelField<T, UsedMethod | "authorization", AuthRuleType, FT>

  • Configures field-level authorization rules. Pass in an array of authorizations (allow => allow.____) to mix and match multiple authorization rules for this field.

    Type Parameters

    • AuthRuleType extends Authorization<any, any, any>

    Parameters

    • callback: ((allow) => AuthRuleType | AuthRuleType[])

      • • (allow): AuthRuleType | AuthRuleType[]

        • Parameters

          • allow: Omit<{
                authenticated: ((provider?) => Authorization<"private", undefined, false> & {
                    to: typeof to;
                });
                custom: ((provider?) => Authorization<"custom", undefined, false> & {
                    to: typeof to;
                });
                group: ((group, provider?) => Authorization<"groups", undefined, false> & {
                    to: typeof to;
                    withClaimIn: typeof withClaimIn;
                });
                groupDefinedIn: (<T>(groupsField, provider?) => Authorization<"groups", T, false> & {
                    to: typeof to;
                    withClaimIn: typeof withClaimIn;
                });
                groups: ((groups, provider?) => Authorization<"groups", undefined, false> & {
                    to: typeof to;
                    withClaimIn: typeof withClaimIn;
                });
                groupsDefinedIn: (<T>(groupsField, provider?) => Authorization<"groups", T, true> & {
                    to: typeof to;
                    withClaimIn: typeof withClaimIn;
                });
                guest: (() => Authorization<"public", undefined, false> & {
                    to: typeof to;
                });
                owner: ((provider?) => Authorization<"owner", "owner", false> & {
                    identityClaim: typeof identityClaim;
                    to: typeof to;
                });
                ownerDefinedIn: (<T>(ownerField, provider?) => Authorization<"owner", T, false> & {
                    identityClaim: typeof identityClaim;
                    to: typeof to;
                });
                ownersDefinedIn: (<T>(ownersField, provider?) => Authorization<"owner", T, true> & {
                    identityClaim: typeof identityClaim;
                    to: typeof to;
                });
                publicApiKey: (() => Authorization<"public", undefined, false> & {
                    to: typeof to;
                });
                resource: ((fn) => ResourceAuthorization & {
                    to: typeof resourceTo;
                });
            }, "resource">

          Returns AuthRuleType | AuthRuleType[]

    Returns ModelField<T, UsedMethod | "authorization", AuthRuleType, FT>

• default:function

  • default(value?): ModelField<T, "default" | UsedMethod, Auth, FT>

  • Sets a default value for the scalar type.

    Parameters

    • Optional value: ModelFieldTypeParamOuter

      the default value

    Returns ModelField<T, "default" | UsedMethod, Auth, FT>

• required:function

  • required(): ModelField<Exclude<T, null>, UsedMethod | "required", Auth, FT>

  • Marks a field as required.

    Returns ModelField<Exclude<T, null>, UsedMethod | "required", Auth, FT>

• validate:function

  • validate(callback): ModelField<T, "default" | UsedMethod | "array" | "validate", Auth, FT>

  • Configures field-level validation rules.

    Parameters

    • callback: ((v) => void)

      A function that receives a validation builder object for the field type

      • • (v): void

        • Parameters

          • v: FieldTypeToValidationBuilder<T, FT>

          Returns void

    Returns ModelField<T, "default" | UsedMethod | "array" | "validate", Auth, FT>

    Example

    a.integer().validate(v => v.gt(0, 'Integer must be greater than 0'))
    a.float().validate(v => v.gt(0.99, 'Float must be greater than 0.99'))
    a.string().validate(v => v.minLength(5, 'String must be at least 5 characters'))
    Copy