@aws-amplify/data-schema 0.15.0 → 0.16.0

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -0,0 +1,254 @@
+import type {
+  UnionToIntersection,
+  LazyLoader,
+} from '@aws-amplify/data-schema-types';
+import type { Authorization, ImpliedAuthFields } from '../Authorization';
+import type { ModelField } from '../ModelField';
+import type { ModelType, ModelTypeParamShape } from '../ModelType';
+import type { GenericModelSchema } from '../ModelSchema';
+import type {
+  ModelRelationalField,
+  ModelRelationalFieldParamShape,
+} from '../ModelRelationalField';
+
+import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
+import type { InjectImplicitModelFields } from './ImplicitFieldInjector';
+import type { ModelIdentifier } from './ModelMetadata';
+import type { RefType, RefTypeParamShape } from '../RefType';
+
+import type { NonModelTypesShape } from './ExtractNonModelTypes';
+
+import type { CustomType, CustomTypeParamShape } from '../CustomType';
+import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type {
+  CustomOperation,
+  CustomOperationParamShape,
+} from '../CustomOperation';
+
+export type ResolveFieldProperties<
+  Schema extends GenericModelSchema<any>,
+  NonModelTypes extends NonModelTypesShape,
+  ResolvedSchema = ResolveSchema<Schema>,
+  IdentifierMeta extends Record<
+    string,
+    { identifier: string }
+  > = ModelIdentifier<SchemaTypes<Schema>>,
+  FieldsWithInjectedImplicitFields = InjectImplicitModelFields<
+    ResolvedSchema,
+    IdentifierMeta
+  >,
+  FieldsWithRelationships = ResolveModelsRelationalAndRefFields<
+    FieldsWithInjectedImplicitFields,
+    NonModelTypes
+  >,
+> = Intersection<
+  FilterFieldTypes<
+    MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>
+  >,
+  FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>,
+  FilterFieldTypes<ModelImpliedAuthFields<Schema>>
+>;
+
+export type ResolveStaticFieldProperties<
+  Schema extends GenericModelSchema<any>,
+  NonModelTypes extends NonModelTypesShape,
+  ImplicitModelsSchema,
+  ResolvedSchema = ResolveSchema<Schema>,
+  FieldsWithInjectedImplicitFields = InjectImplicitModelFields<
+    ResolvedSchema & ImplicitModelsSchema,
+    object
+  >,
+  FieldsWithRelationships = ResolveModelsRelationalAndRefFields<
+    FieldsWithInjectedImplicitFields,
+    NonModelTypes
+  >,
+> = Intersection<
+  FilterFieldTypes<
+    MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>
+  >,
+  FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>
+>;
+
+type GetRelationshipRef<
+  T,
+  RM extends keyof T,
+  TypeArg extends ModelRelationalFieldParamShape,
+  Flat extends boolean,
+  ResolvedModel = ResolveRelationalFieldsForModel<T, RM, Flat>,
+  Model = TypeArg['valueRequired'] extends true
+    ? ResolvedModel
+    : ResolvedModel | null | undefined,
+> = LazyLoader<Model, TypeArg['array']>;
+
+type ResolveRelationalFieldsForModel<
+  Schema,
+  ModelName extends keyof Schema,
+  Flat extends boolean,
+> = {
+  [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationalFieldParamShape
+    ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema
+      ? GetRelationshipRef<
+          Schema,
+          Schema[ModelName][FieldName]['relatedModel'],
+          Schema[ModelName][FieldName],
+          Flat
+        >
+      : never
+    : Schema[ModelName][FieldName];
+};
+
+// Ref can point to a customType, enum, or custom operation
+export type ResolveRef<
+  NonModelTypes extends NonModelTypesShape,
+  Ref extends RefTypeParamShape,
+  Link extends string = Ref['link'],
+  RefValue = Link extends keyof NonModelTypes['enums']
+    ? NonModelTypes['enums'][Link]
+    : Link extends keyof NonModelTypes['customTypes']
+      ? ResolveRefsOfCustomType<
+          NonModelTypes,
+          NonModelTypes['customTypes'][Link]
+        >
+      : never,
+  Value = Ref['valueRequired'] extends true ? RefValue : RefValue | null,
+> = ResolveRefValueArrayTraits<Ref, Value>;
+
+/**
+ * Converts the resolved RefType Value type into Array<> according to the
+ * `array` and `arrayRequired` properties of the RefType
+ */
+export type ResolveRefValueArrayTraits<
+  Ref extends RefTypeParamShape,
+  Value,
+> = Ref['array'] extends false
+  ? Value
+  : Ref['arrayRequired'] extends true
+    ? Array<Value>
+    : Array<Value> | null;
+
+export type ResolveRefsOfCustomType<
+  NonModelTypes extends NonModelTypesShape,
+  T,
+> = {
+  [Prop in keyof T]: T[Prop] extends RefType<
+    infer R extends RefTypeParamShape,
+    any,
+    any
+  > | null
+    ? ResolveRef<NonModelTypes, R>
+    : T[Prop];
+} extends infer Resolved
+  ? ResolveCustomTypeFieldsRequirements<Resolved>
+  : never;
+
+export type ResolveCustomTypeFieldsRequirements<Resolved> = Intersection<
+  ExtractNullableFieldsToOptionalFields<Resolved>,
+  ExtractNonNullableFieldsToRequiredFields<Resolved>
+>;
+
+type ResolveModelsRelationalAndRefFields<
+  Schema,
+  NonModelTypes extends NonModelTypesShape,
+  Flat extends boolean = false,
+> = {
+  [ModelProp in keyof Schema]: {
+    [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<
+      infer R extends RefTypeParamShape,
+      any,
+      any
+    > | null
+      ? ResolveRef<NonModelTypes, R>
+      : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape
+        ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema
+          ? GetRelationshipRef<
+              Schema,
+              Schema[ModelProp][FieldProp]['relatedModel'],
+              Schema[ModelProp][FieldProp],
+              Flat
+            >
+          : never // if the field value extends ModelRelationalFieldShape "relatedModel" should always point to a Model (keyof Schema)
+        : Schema[ModelProp][FieldProp];
+  };
+};
+
+type FilterFieldTypes<Schema> = {
+  [ModelProp in keyof Schema]: {
+    [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends undefined
+      ? never
+      : FieldProp]: Schema[ModelProp][FieldProp];
+  };
+};
+
+type ExtractNullableFieldsToOptionalFields<Fields> = Partial<{
+  [FieldProp in keyof Fields as null extends Fields[FieldProp]
+    ? FieldProp
+    : never]: null extends Fields[FieldProp] ? Fields[FieldProp] : never;
+}>;
+
+type MarkModelsNullableFieldsOptional<Schema> = {
+  [ModelProp in keyof Schema]: ExtractNullableFieldsToOptionalFields<
+    Schema[ModelProp]
+  >;
+};
+
+type ExtractNonNullableFieldsToRequiredFields<Fields> = {
+  [FieldProp in keyof Fields as null extends Fields[FieldProp]
+    ? never
+    : FieldProp]: null extends Fields[FieldProp] ? never : Fields[FieldProp];
+};
+
+type MarkModelsNonNullableFieldsRequired<Schema> = {
+  [ModelProp in keyof Schema]: ExtractNonNullableFieldsToRequiredFields<
+    Schema[ModelProp]
+  >;
+};
+
+type Intersection<
+  A = Record<never, never>,
+  B = Record<never, never>,
+  C = Record<never, never>,
+  D = Record<never, never>,
+> = A & B & C & D extends infer U ? { [P in keyof U]: U[P] } : never;
+
+// TODO: this should probably happen in InjectImplicitModelFields instead. Keeping here for now to reduce refactor
+// blast radius
+export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
+  [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape>
+    ? never
+    : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape>
+      ? never
+      : Schema['data']['types'][ModelKey] extends CustomOperation<
+            CustomOperationParamShape,
+            any
+          >
+        ? never
+        : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<
+    infer Model,
+    any
+  >
+    ? AllAuthFieldsForModel<Schema, Model>
+    : object;
+};
+
+type AllAuthFieldsForModel<
+  Schema extends GenericModelSchema<any>,
+  Model extends Schema['data']['types'][keyof Schema['data']['types']],
+> = (Model['authorization'][number] extends never
+  ? Schema['data']['authorization'][number] extends never
+    ? object
+    : ImpliedAuthFields<Schema['data']['authorization'][number]>
+  : ImpliedAuthFields<Model['authorization'][number]>) &
+  ImpliedAuthFieldsFromFields<Model>;
+
+type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<
+  T extends ModelTypeParamShape
+    ? T['fields'][keyof T['fields']] extends
+        | ModelField<any, any, infer Auth>
+        | ModelRelationalField<any, any, any, infer Auth>
+        | RefType<any, any, infer Auth>
+      ? Auth extends Authorization<any, any, any>
+        ? ImpliedAuthFields<Auth>
+        : object
+      : object
+    : object
+>;

package/src/MappedTypes/ResolveSchema.ts

@@ -0,0 +1,148 @@
+import type { ModelType } from '../ModelType';
+import type { GenericModelSchema } from '../ModelSchema';
+import type {
+  ModelRelationalField,
+  ModelRelationshipTypes,
+  RelationTypeFunctionOmitMapping,
+} from '../ModelRelationalField';
+import type { ModelField } from '../ModelField';
+import type { CustomType, CustomTypeParamShape } from '../CustomType';
+import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { RefType, RefTypeParamShape } from '../RefType';
+import type {
+  CustomOperation,
+  CustomOperationParamShape,
+} from '../CustomOperation';
+
+export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
+
+// TODO: find better name
+export type SchemaTypes<T> = T extends GenericModelSchema<any>
+  ? T['data']['types']
+  : never;
+
+/**
+ * Resolves model types
+ *
+ * Removes CustomTypes and Enums from resolved schema.
+ * They are extracted separately in ExtractNonModelTypes.ts and
+ * added to ModelMeta in ClientSchema.ts
+ */
+export type ModelTypes<Schema> = {
+  [Model in keyof Schema as Schema[Model] extends
+    | EnumType<EnumTypeParamShape>
+    | CustomType<CustomTypeParamShape>
+    | CustomOperation<CustomOperationParamShape, any>
+    ? never
+    : Model]: Schema[Model] extends ModelType<infer R, any>
+    ? R['fields']
+    : never;
+};
+
+/**
+ * Gets the collection of all ModelTypes and CustomTypes which are explicitly
+ * defined in the schema.
+ */
+export type ModelAndCustomTypes<Schema> = {
+  [Model in keyof Schema as Schema[Model] extends
+    | EnumType<EnumTypeParamShape>
+    | CustomOperation<CustomOperationParamShape, any>
+    ? never
+    : Model]: Schema[Model] extends ModelType<any, any>
+    ? Schema[Model]
+    : Schema[Model] extends CustomType<CustomTypeParamShape>
+      ? Schema[Model]
+      : never;
+};
+
+/**
+ * Resolves field types
+ *
+ * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
+ */
+export type FieldTypes<T> = {
+  [ModelProp in keyof T]: {
+    [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<
+      // Match the most common field type to improve resolving performance
+      infer R,
+      any,
+      any
+    >
+      ? R
+      : T[ModelProp][FieldProp] extends RefType<
+            infer R extends RefTypeParamShape,
+            any,
+            any
+          >
+        ? // leave Ref as-is. We'll resolve it to the linked entity downstream in ResolveFieldProperties
+          R['valueRequired'] extends true
+          ? T[ModelProp][FieldProp]
+          : T[ModelProp][FieldProp] | null
+        : // replace non-model types with Ref
+          T[ModelProp][FieldProp] extends
+              | EnumType<EnumTypeParamShape>
+              | CustomType<CustomTypeParamShape>
+          ? RefType<{
+              link: `${Capitalize<ModelProp & string>}${Capitalize<
+                FieldProp & string
+              >}`;
+              type: 'ref';
+              valueRequired: false;
+              array: false;
+              arrayRequired: false;
+              authorization: [];
+            }> | null
+          : // resolve relational and model fields to the their first type arg
+            T[ModelProp][FieldProp] extends ModelRelationalField<
+                infer R,
+                string,
+                RelationTypeFunctionOmitMapping<ModelRelationshipTypes>,
+                any
+              >
+            ? R
+            : never;
+  };
+};
+
+/**
+ * Resolves field types for a CustomType.
+ *
+ * This utility type is needed in addition to the `FieldTypes` utility type as
+ * without checking `ModelRelationalField` can improve ~5% on resolving performance.
+ *
+ * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
+ */
+export type FieldTypesOfCustomType<T> = {
+  [CustomTypeName in keyof T]: {
+    [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<
+      infer R,
+      any,
+      any
+    >
+      ? R
+      : T[CustomTypeName][FieldProp] extends RefType<
+            infer R extends RefTypeParamShape,
+            any,
+            any
+          >
+        ? // leave Ref as-is. We'll resolve it to the linked entity downstream in ResolveFieldProperties
+          R['valueRequired'] extends true
+          ? T[CustomTypeName][FieldProp]
+          : T[CustomTypeName][FieldProp] | null
+        : // replace non-model types with Ref
+          T[CustomTypeName][FieldProp] extends
+              | EnumType<EnumTypeParamShape>
+              | CustomType<CustomTypeParamShape>
+          ? RefType<{
+              link: `${Capitalize<CustomTypeName & string>}${Capitalize<
+                FieldProp & string
+              >}`;
+              type: 'ref';
+              valueRequired: false;
+              array: false;
+              arrayRequired: false;
+              authorization: [];
+            }> | null
+          : never;
+  };
+};

package/src/ModelField.ts

@@ -0,0 +1,304 @@
+import { Brand, brand } from './util';
+import { AllowModifier, Authorization, allow } from './Authorization';
+
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+export const __auth = Symbol('__auth');
+
+const brandName = 'modelField';
+
+export enum ModelFieldType {
+  Id = 'ID',
+  String = 'String',
+  Integer = 'Int',
+  Float = 'Float',
+  Boolean = 'Boolean',
+  Date = 'AWSDate',
+  Time = 'AWSTime',
+  DateTime = 'AWSDateTime',
+  Timestamp = 'AWSTimestamp',
+  Email = 'AWSEmail',
+  JSON = 'AWSJSON',
+  Phone = 'AWSPhone',
+  Url = 'AWSURL',
+  IPAddress = 'AWSIPAddress',
+}
+
+export enum ModelFieldDataType {
+  String = 'string',
+  Number = 'number',
+  Boolean = 'boolean',
+  Date = 'Date',
+  JSON = 'any',
+}
+
+type FieldMeta = {
+  lastInvokedMethod: null | keyof ModelField<ModelFieldTypeParamOuter>;
+};
+
+type FieldData = {
+  fieldType: ModelFieldType;
+  required: boolean;
+  array: boolean;
+  arrayRequired: boolean;
+  default: undefined | ModelFieldTypeParamOuter;
+  authorization: Authorization<any, any, any>[];
+};
+
+type ModelFieldTypeParamInner = string | number | boolean | Date | Json | null;
+
+// A precise, recursive Json type blows the type calculation stack without installing
+// explicit `Json extends T ? short-circuit : ...` type checks all over the place.
+// We may take that on later. But, this is a good-enough approximation for now.
+export type Json = null | string | number | boolean | object | any[];
+
+export type ModelFieldTypeParamOuter =
+  | ModelFieldTypeParamInner
+  | Array<ModelFieldTypeParamInner>
+  | null;
+
+/**
+ * Field type arg mutators
+ */
+export type Nullable<T> = T | null;
+export type Required<T> = Exclude<T, null>;
+export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner]
+  ? Array<T> | null // optional by default
+  : never;
+
+/**
+ * Public API for the chainable builder methods exposed by Model Field.
+ * The type is narrowing e.g., after calling .array() it will be omitted from intellisense suggestions
+ *
+ * @typeParam T - holds the JS data type of the field
+ * @typeParam K - union of strings representing already-invoked method names. Used to improve Intellisense
+ */
+export type ModelField<
+  T extends ModelFieldTypeParamOuter,
+  // rename K
+  K extends keyof ModelField<T> = never,
+  Auth = undefined,
+> = Omit<
+  {
+    /**
+     * Marks a field as required.
+     */
+    required(): ModelField<Required<T>, K | 'required'>;
+    // Exclude `optional` after calling array, because both the value and the array itself can be optional
+    /**
+     * Converts a field type definition to an array of the field type.
+     */
+    array(): ModelField<ArrayField<T>, Exclude<K, 'required'> | 'array'>;
+    // TODO: should be T, but .array breaks this constraint. Fix later
+    /**
+     * Sets a default value for the scalar type.
+     * @param value the default value
+     */
+    default(value: ModelFieldTypeParamOuter): ModelField<T, K | 'default'>;
+    /**
+     * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
+     * multiple authorization rules for this field.
+     */
+    authorization<AuthRuleType extends Authorization<any, any, any>>(
+      callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[],
+    ): ModelField<T, K | 'authorization', AuthRuleType>;
+  },
+  K
+> & {
+  // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
+  [__auth]?: Auth;
+} & Brand<typeof brandName>;
+
+/**
+ * Internal representation of Model Field that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalField = ModelField<ModelFieldTypeParamOuter, never> & {
+  data: FieldData;
+};
+
+/**
+ * Model Field Implementation
+ *
+ * @typeParam T - holds the JS data type of the field; invoking the public methods changes this type accordingly
+ * @example
+ * string() => T = string | null
+ * string().array() => T = Array<string | null> | null
+ * string().array().required() => T = Array<string | null>
+ * string().required().array().required() => T = Array<string>
+ *
+ * @param fieldType - stores the GraphQL data type of the field
+ */
+function _field<T extends ModelFieldTypeParamOuter>(fieldType: ModelFieldType) {
+  const _meta: FieldMeta = {
+    lastInvokedMethod: null,
+  };
+
+  const data: FieldData = {
+    fieldType,
+    required: false,
+    array: false,
+    arrayRequired: false,
+    default: undefined,
+    authorization: [],
+  };
+
+  const builder = {
+    required() {
+      if (_meta.lastInvokedMethod === 'array') {
+        data.arrayRequired = true;
+      } else {
+        data.required = true;
+      }
+
+      _meta.lastInvokedMethod = 'required';
+
+      return this;
+    },
+    array(): ModelField<ArrayField<T>> {
+      data.array = true;
+      _meta.lastInvokedMethod = 'array';
+
+      return this;
+    },
+    default(val) {
+      data.default = val;
+      _meta.lastInvokedMethod = 'default';
+
+      return this;
+    },
+    authorization(callback) {
+      const { resource: _, ...rest } = allow;
+      const rules = callback(rest);
+      data.authorization = Array.isArray(rules) ? rules : [rules];
+      _meta.lastInvokedMethod = 'authorization';
+
+      return this;
+    },
+    ...brand(brandName),
+  } as ModelField<T>;
+
+  // this double cast gives us a Subtyping Constraint i.e., hides `data` from the public API,
+  // but makes it available internally when needed
+  return { ...builder, data } as InternalField as ModelField<T>;
+}
+
+/**
+ * A unique identifier scalar type. This scalar is serialized like a String but isn't meant to be human-readable.
+ * If not specified on create operations, a ULID will be auto-generated service-side.
+ * @returns ID field definition
+ */
+export function id(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Id);
+}
+
+/**
+ * A string scalar type that is represented server-side as a UTF-8 character sequence.
+ * @returns string field definition
+ */
+export function string(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.String);
+}
+
+/**
+ * An integer scalar type with a supported value range between -(2^31) and 2^31-1.
+ * @returns integer field definition
+ */
+export function integer(): ModelField<Nullable<number>> {
+  return _field(ModelFieldType.Integer);
+}
+
+/**
+ * A float scalar type following represented server-side as an IEEE 754 floating point value.
+ * @returns float field definition
+ */
+export function float(): ModelField<Nullable<number>> {
+  return _field(ModelFieldType.Float);
+}
+
+/**
+ * A boolean scalar type that can be either true or false.
+ * @returns boolean field definition
+ */
+export function boolean(): ModelField<Nullable<boolean>> {
+  return _field(ModelFieldType.Boolean);
+}
+
+/**
+ * A date scalar type that is represented server-side as an extended ISO 8601 date string in the format `YYYY-MM-DD`.
+ * @returns date field definition
+ */
+export function date(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Date);
+}
+
+/**
+ * A time scalar type that is represented server-side as an extended ISO 8601 time string in the format `hh:mm:ss.sss`.
+ * @returns time field definition
+ */
+export function time(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Time);
+}
+
+/**
+ * A date time scalar type that is represented server-side as an extended ISO 8601 date and time string in the format `YYYY-MM-DDThh:mm:ss.sssZ`.
+ * @returns datetime field definition
+ */
+export function datetime(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.DateTime);
+}
+
+/**
+ * A timestamp scalar type that is represented by an integer value of the number of seconds before or after `1970-01-01-T00:00Z`.
+ * @returns timestamp field definition
+ */
+export function timestamp(): ModelField<Nullable<number>> {
+  return _field(ModelFieldType.Timestamp);
+}
+
+/**
+ * An email scalar type that is represented server-side in the format `local-part@domain-part` as defined by RFC 822.
+ * @returns email field definition
+ */
+export function email(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Email);
+}
+
+/**
+ * A JSON scalar type that is automatically parsed and loaded server-side as maps, lists, or scalar values
+ * rather than as the literal input strings.
+ * @returns JSON field definition
+ */
+export function json(): ModelField<Nullable<Json>> {
+  return _field(ModelFieldType.JSON);
+}
+
+/**
+ * A phone number scalar type thas is stored as a string server-side. Phone numbers can contain either spaces
+ * or hyphens to separate digit groups. Phone numbers without a country code are assumed to be US/North American numbers adhering
+ * to the North American Numbering Plan.
+ * @returns phone number field definition
+ */
+export function phone(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Phone);
+}
+
+/**
+ * A URL scalar type as defined by RFC 1738. For example, https://www.amazon.com/dp/B000NZW3KC/ or mailto:example@example.com.
+ * URLs must contain a schema (http, mailto) and can't contain two forward slashes (//) in the path part.
+ * @returns URL field definition
+ */
+export function url(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.Url);
+}
+
+/**
+ * A valid IPv4 or IPv6 address scalar type. IPv4 addresses are expected in quad-dotted notation (123.12.34.56). IPv6 addresses
+ * are expected in non-bracketed, colon-separated format (1a2b:3c4b:🔢4567). You can include an optional CIDR suffix (123.45.67.89/16)
+ * to indicate subnet mask.
+ * @returns IP address field definition
+ */
+export function ipAddress(): ModelField<Nullable<string>> {
+  return _field(ModelFieldType.IPAddress);
+}