Task 

This page documents the task model.

Data Shape 

Gadget's database stores task records by storing and retrieving each of the fields defined on the model in the Gadget Editor to a managed database. Gadget has generated a GraphQL type matching the configured fields for task:

1export type Task = {
2  __typename: "Task";
3
4  /** The globally unique, unchanging identifier for this record. Assigned and managed by Gadget. */
5  id: string;
6
7  /** The time at which this record was first created. Set once upon record creation and never changed. Managed by Gadget. */
8  createdAt: Date;
9
10  /** The time at which this record was last changed. Set each time the record is successfully acted upon by an action. Managed by Gadget. */
11  updatedAt: Date;
12
13  /** The current state this record is in. Changed by invoking actions. Managed by Gadget. */
14  state: string | { [key: string]: Scalars["RecordState"] };
15
16  description: RichText | null;
17
18  owner: User | null;
19
20  ownerId: string;
21
22  title: string;
23
24  /** Get all the fields for this record. Useful for not having to list out all the fields you want to retrieve, but slower. */
25  _all: Record<string, any>;
26};

1type Task {
2  """
3  The globally unique, unchanging identifier for this record. Assigned and managed by Gadget.
4  """
5  id: GadgetID!
6
7  """
8  The time at which this record was first created. Set once upon record creation and never changed. Managed by Gadget.
9  """
10  createdAt: DateTime!
11
12  """
13  The time at which this record was last changed. Set each time the record is successfully acted upon by an action. Managed by Gadget.
14  """
15  updatedAt: DateTime!
16
17  """
18  The current state this record is in. Changed by invoking actions. Managed by Gadget.
19  """
20  state: RecordState!
21  description: RichText
22  owner: User
23  ownerId: GadgetID
24  title: String!
25
26  """
27  Get all the fields for this record. Useful for not having to list out all the fields you want to retrieve, but slower.
28  """
29  _all: JSONObject!
30}

You can preview what a real record's shape looks like by fetching it using the  example-app API Playground.

Any fetched task record will have this same Task type, and expose the same data by default, regardless of if it's fetched by ID or as part of a findMany. This means you can select any of the record's fields wherever you like in a GraphQL query according to the use case at hand.

Retrieving one task record 

Individual task records can be retrieved using the "find by ID" API endpoint. You can also return only some fields, or extra fields beyond what Gadget retrieves by default, using the select option.

const taskRecord = await api.task.findOne("123");
console.log(taskRecord.id); //=> a string
console.log(taskRecord.createdAt); //=> a Date object

1const FindOneComponent = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindOne(api.task, "123");
3
4  console.log(data?.id); //=> a string
5  console.log(data?.createdAt); //=> a Date object
6
7  return <>{JSON.stringify(data)}</>;
8};

1query GetOneTask($id: GadgetID!) {
2  task(id: $id) {
3    __typename
4    id
5    state
6    createdAt
7    description {
8      markdown
9      truncatedHTML
10    }
11    title
12    updatedAt
13  }
14}

{ "id": "123" }

Retrieving the first of many task records 

The first record from a list of records can be retrieved using the "find first" API endpoint. The source list of records can be filtered using the filter option, sorted using the sort option, searched using the search option, though no pagination options are available on this endpoint. You can also return only some fields, or extra fields beyond what Gadget retrieves by default using the select option.

const taskRecord = await api.task.findFirst();
console.log(taskRecord.id); //=> a string
console.log(taskRecord.createdAt); //=> a Date object

1const FindFirstComponent = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindFirst(api.task);
3
4  console.log(data?.id); //=> a string
5  console.log(data?.createdAt); //=> a Date object
6
7  return <>{JSON.stringify(data)}</>;
8};

1query FindManyTasks(
2  $first: Int
3  $search: String
4  $sort: [TaskSort!]
5  $filter: [TaskFilter!]
6) {
7  tasks(first: $first, search: $search, sort: $sort, filter: $filter) {
8    edges {
9      node {
10        __typename
11        id
12        state
13        createdAt
14        description {
15          markdown
16          truncatedHTML
17        }
18        title
19        updatedAt
20      }
21    }
22  }
23}

{ "first": 1 }

Retrieving many task records 

Pages of task records can be retrieved by using the "find many" API endpoint. The returned records can be filtered using the filter option, sorted using the sort option, searched using the search option, and paginated using standard Relay-style pagination options. You can also return only some fields, or extra fields beyond what Gadget retrieves by default using the select option.

This GraphQL endpoint returns records in the Relay Connection style (as a list of edges with nodes and cursors) so they can be paginated. The tasks GraphQL endpoint works with any Relay-compatible caching client, or you can use Gadget's JS client for pagination with the findMany function.

Find a page of tasks 

Fetch a page of records with the task.findMany JS method or the tasks GraphQL field. No options are required. The records returned will be implicitly sorted by ID ascending.

const taskRecords = await api.task.findMany();
console.log(taskRecords.length); //=> a number
console.log(taskRecords[0].id); //=> a string

1const FindManyComponent = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindMany(api.task);
3  if (!data) return null;
4
5  console.log(data.length); //=> a number
6
7  return <>{data.map((record) => JSON.stringify(record))}</>;
8};

1query FindManyTasks {
2  tasks {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{}

Retrieving related model data 

Your app's API is built using GraphQL, which makes it easy to retrieve data from related records through fields like belongs to and has many.

To optimize the performance of your API, data from related records is not retrieved by default, but you can change what data is retrieved with the `select` option to API calls.

For example, you can fetch belongs to data from the record linked by the owner field using the select option:

1const taskRecord = await api.task.findFirst({
2  select: {
3    id: true,
4    owner: {
5      id: true,
6      createdAt: true,
7    },
8  },
9});
10console.log(taskRecord.owner?.id); //=> the related record's id

1const FindRelatedComponent = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindFirst(api.task, {
3    select: {
4      id: true,
5      owner: {
6        id: true,
7        createdAt: true,
8      },
9    },
10  });
11  if (!data) return null;
12  // show the related record's id
13  return <>{data.owner?.id}</>;
14};

Retrieving a single task record by a uniquely identifiable field 

After adding a unique validation to a field, you can retrieve a single record by using the finders generated below. If you would like to edit the fields returned or filtering, see the filtering section.

Retrieving a single task record by id 

Individual task records can be retrieved using the "find many" API endpoint pre-filtered by the field's id. Throws if stored data is not unique.

const taskRecord = await api.task.findById("some-value");
console.log(taskRecord.id); //=> a string

1const FindByComponent = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindBy(
3    api.task.findById,
4    "some-value"
5  );
6
7  console.log(data?.id); //=> a string
8
9  return <>{JSON.stringify(data)}</>;
10};

Sorting 

Records can be sorted in the database to retrieve them in a certain order. Records are always implicitly sorted by ID ascending unless an explicit sort on the id field is defined. The GraphQL type TaskSort defines which fields can be sorted by.

Records can be sorted by multiple different fields and in multiple different directions by passing a list of TaskSort instead of just one.

Pass the sort option to the JS client, or the sort variable to a GraphQL query to sort the records returned.

const taskRecords = await api.task.findMany({ sort: { createdAt: "Descending" } });

const [result, refresh] = useFindMany(api.task, {
  sort: { createdAt: "Descending" },
});
const { data, error, fetching } = result;

1query FindManyTasks($sort: [TaskSort!]) {
2  tasks(sort: $sort) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "sort": { "createdAt": "Descending" } }

Sort by multiple fields by passing an array of { [field]: "Ascending" | "Descending" } objects.

const taskRecords = await api.task.findMany({
  sort: [{ id: "Descending" }, { createdAt: "Ascending" }],
});

const [result, refresh] = useFindMany(api.task, {
  sort: [{ id: "Descending" }, { createdAt: "Ascending" }],
});
const { data, error, fetching } = result;

1query FindManyTasks($sort: [TaskSort!]) {
2  tasks(sort: $sort) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "sort": [{ "id": "Descending" }, { "createdAt": "Ascending" }] }

Available fields for sorting 

You can sort task records by the following fields:

For example, you can sort by the id field:

const taskRecords = await api.task.findMany({
  sort: { id: "Descending" },
});

const [result, refresh] = useFindMany(api.task, {
  sort: { id: "Descending" },
});
const { data, error, fetching } = result;

1query FindManyTasks($sort: [TaskSort!]) {
2  tasks(sort: $sort) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "sort": { "id": "Descending" } }

Read more about sorting in the Sorting and Filtering reference.

Searching 

task records can be searched using Gadget's built in full text search functionality. Gadget search is appropriate for powering autocompletes, searchable tables, or other experiences where humans are writing search queries. It's typo tolerant, synonym aware and supports simple search operators like ! to exclude search terms.

Search Tasks by passing the search parameter with a search query string.

Search isn't field specific in Gadget -- all String or RichText field types are searched with the built in search functionality.

const taskRecords = await api.task.findMany({
  search: "a specific phrase to search for",
});

const [result, refresh] = useFindMany(api.task, {
  search: "a specific phrase to search for",
});
const { data, error, fetching } = result;

1query FindManyTasks($search: String) {
2  tasks(search: $search) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "search": "a specific phrase to search for" }

Filtering 

task records can be filtered to return only the appropriate records. Records can be filtered on any field, including those managed by Gadget or fields added by developers. Filters can be combined with sorts, searches and paginated using cursor-based Relay pagination.

Filter Tasks by passing the filter parameter with a filter object. Filter objects are nestable boolean conditions expressed as JS objects capturing a key, an operator, and usually a value.

const yesterday = new Date(Date.now() - 864e5);
const taskRecords = await api.task.findMany({
  filter: { createdAt: { greaterThan: yesterday } },
});

const yesterday = new Date(Date.now() - 864e5);
const [result, refresh] = useFindMany(api.task, {
  filter: { createdAt: { greaterThan: yesterday } },
});
const { data, error, fetching } = result;

1query FindManyTasks($filter: [TaskFilter!]) {
2  tasks(filter: $filter) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "filter": { "createdAt": { "greaterThan": "2024-04-26T04:56:11.726Z" } } }

Available fields for filtering 

The GraphQL type TaskFilter defines which fields can be filtered on.

For example, we can filter task records on the id field:

const taskRecords = await api.task.findMany({
  filter: {
    id: { isSet: true },
  },
});

1const [result, refresh] = useFindMany(api.task, {
2  filter: {
3    id: { isSet: true },
4  },
5});
6const { data, error, fetching } = result;

1query FindManyTasks($filter: [TaskFilter!]) {
2  tasks(filter: $filter) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

{ "filter": { "id": { "isSet": true } } }

Read more about the available filters in the Sorting and Filtering reference.

Combining filters 

Records can be filtered by multiple different fields simultaneously. If you want to combine filters using boolean logic, nest them under the AND, OR, or NOT keys of a parent filter. Filters can be nested deeply by passing multiple levels boolean condition filters.

You can also pass a list of filters to the filter parameter which will be implicitly ANDed with one another such that they all need to match for a record to be returned.

1const yesterday = new Date(Date.now() - 86400000);
2const oneWeekAgo = new Date(Date.now() - 604800000);
3const taskRecords = await api.task.findMany({
4  filter: {
5    OR: [
6      {
7        createdAt: { greaterThan: oneWeekAgo },
8      },
9      {
10        updatedAt: { greaterThan: yesterday },
11      },
12    ],
13  },
14});

1const yesterday = new Date(Date.now() - 86400000);
2const oneWeekAgo = new Date(Date.now() - 604800000);
3const [result, refresh] = useFindMany(api.task, {
4  filter: {
5    OR: [
6      {
7        createdAt: { greaterThan: oneWeekAgo },
8      },
9      {
10        updatedAt: { greaterThan: yesterday },
11      },
12    ],
13  },
14});
15const { data, error, fetching } = result;

1query FindManyTasks($filter: [TaskFilter!]) {
2  tasks(filter: $filter) {
3    edges {
4      node {
5        __typename
6        id
7        state
8
9        # ...
10
11        createdAt
12        updatedAt
13      }
14    }
15  }
16}

1{
2  "filter": {
3    "OR": [
4      { "createdAt": { "greaterThan": "2024-04-20T04:56:11.726Z" } },
5      { "updatedAt": { "greaterThan": "2024-04-26T04:56:11.726Z" } }
6    ]
7  }
8}

Pagination 

All Gadget record lists, including the top level task finder as well as associations to task, are structured as GraphQL connections. GraphQL connections are the de facto standard for querying lists and support cursor-based forward and backward pagination. When querying via GraphQL, you must select the edges field and then the node field to get the task record. When querying using a Gadget API client, the GraphQL queries are generated for you and the records are unwrapped and returned as a GadgetRecordList ready for use.

task pagination supports the standard GraphQL connection pagination arguments: first + after, or last + before. Pagination is done using cursors, which you can retrieve from the edge.cursor field or the pageInfo.startCursor properties.

const taskRecords = await api.task.findMany({ first: 25 });
console.log(taskRecords.length); //=> no greater than 25

1const FirstPage = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindMany(api.task, { first: 25 });
3  if (!data) return null;
4
5  console.log(data.length); //=> no greater than 25
6
7  return <>{data.map((record) => JSON.stringify(record))}</>;
8};

1query FindManyTasks($first: Int, $after: String) {
2  tasks(first: $first, after: $after) {
3    pageInfo {
4      hasNextPage
5      hasPreviousPage
6      startCursor
7      endCursor
8    }
9    edges {
10      cursor
11      node {
12        __typename
13        id
14        state
15
16        # ...
17
18        createdAt
19        updatedAt
20      }
21    }
22  }
23}

{ "first": 25 }

const taskRecords = await api.task.findMany({ after: "example-cursor", first: 25 });

1const SecondPage = (props) => {
2  const [{ data, error, fetching }, refresh] = useFindMany(api.task, {
3    after: "example-cursor",
4    first: 25,
5  });
6  if (!data) return null;
7
8  console.log(data.length); //=> no greater than 25
9
10  return <>{data.map((record) => JSON.stringify(record))}</>;
11};

1query FindManyTasks($first: Int, $after: String) {
2  tasks(first: $first, after: $after) {
3    pageInfo {
4      hasNextPage
5      hasPreviousPage
6      startCursor
7      endCursor
8    }
9    edges {
10      cursor
11      node {
12        __typename
13        id
14        state
15
16        # ...
17
18        createdAt
19        updatedAt
20      }
21    }
22  }
23}

{ "first": 25, "after": "abcdefg" }

Pagination Limits 

Root-level record finders like tasks support a maximum page size of 250 records and a default page size of 50 records. The page size is controlled using the first or last GraphQL field arguments.

Related record finders that access lists of records through a has many or has many through field support a maximum page size of 100 records and a default page size of 50 records.

Get the next or previous page 

When using the generated JavaScript API client, including the api parameter in a Gadget code effect, the record lists returned from findMany calls can be paginated using the nextPage() or previousPage() option.

1const taskRecords = await api.task.findMany();
2if (taskRecords.hasNextPage) {
3  const nextPage = await taskRecords.nextPage();
4}
5if (taskRecords.hasPreviousPage) {
6  const prevPage = await taskRecords.previousPage();
7}

When using React and paging through records, you can use cursors to get the previous or next pages of records. This is an example of a React component that pages forward and backward through 2 records at a time for task.

1import { api } from "../api"; // your Gadget project's API Client
2import { useFindMany } from "@gadgetinc/react";
3import { useCallback, useState } from "react";
4
5export default function TestComponent() {
6  const NUM_ON_PAGE = 2; // the number of records per page
7
8  const [cursor, setCursor] = useState({ first: NUM_ON_PAGE });
9  // using Gadget React hooks to fetch records of task
10  const [{ data, fetching, error }] = useFindMany(api.task, {
11    ...cursor,
12  });
13
14  const getNextPage = useCallback(() => {
15    // use first + after to page forwards
16    setCursor({ first: NUM_ON_PAGE, after: data.endCursor });
17  }, [data]);
18
19  const getPreviousPage = useCallback(() => {
20    // use last + before to page backwards
21    setCursor({ last: NUM_ON_PAGE, before: data.startCursor });
22  }, [data]);
23
24  return (
25    <div>
26      <button onClick={getPreviousPage} disabled={!data?.hasPreviousPage}>
27        Previous page
28      </button>
29      <button onClick={getNextPage} disabled={!data?.hasNextPage}>
30        Next page
31      </button>
32      {!fetching && data.map((d) => <div>{d.id}</div>)}
33    </div>
34  );
35}

Get all records 

If you need to get all available data for task, you will need to paginate through all pages of data. If you have a large amount of data, this can take a long time. Make sure you need to collect all data at once before writing a pagination loop that reads all records! If you are querying records for display in a UI and cannot display all your records at once, we don't recommend fetching all the data beforehand - instead, use the cursor to read additional data when the user needs it.

If you need all data for analytics applications or to collect some statistics on your data, consider options like intermediate models and pre-defined data rollups.

If you have determined that you need all your data, you can fetch it using cursors and a loop. We also suggest using select so that you only grab fields that are needed, in addition to applying a filter, if possible. Using first with the maximum allowable value will also allow you to grab the maximum number of records you can at once.

1const allRecords = []; // use allRecords to store all records
2let records = await api.task.findMany({
3  first: 250,
4  select: {
5    id: true,
6  },
7  filter: {
8    // add filter conditions, if possible
9  },
10});
11
12allRecords.push(...records);
13
14// loop through additional pages to get all protected orders
15while (records.hasNextPage) {
16  // paginate
17  records = await records.nextPage();
18  allRecords.push(...records);
19}

Selecting fields, and fields of fields 

When using the JavaScript client, all of findOne, maybeFindOne, findMany, findFirst, maybeFindFirst, and various action functions, allow requesting specific fields of a task and its relationships. The select option controls which fields are selected in the generated GraphQL query sent to the Gadget API. Pass each field you want to select in an object, with true as the value for scalar fields, and a nested object of the same shape for nested fields.

Gadget has a default selection that will retrieve all of the scalar fields for a task. If you don't pass a select option to a record finder, this default selection will be used.

1// fetch only the id and createdAt field
2const taskRecords = await api.task.findMany({
3  select: { id: true, createdAt: true },
4});
5// fetch all the scalar fields for the model, but no relationship fields
6const taskRecords = await api.task.findMany();

1const SelectionComponent = (props) => {
2  // fetch only the id and createdAt field
3  const [{ data, error, fetching }, refresh] = useFindMany(api.task, {
4    select: { id: true, createdAt: true },
5  });
6  // ...
7};

Realtime query results 

When using the React hooks, you can subscribe to realtime updates to the results of a query. This is useful for updating your UI when a record is created, updated, or deleted by anyone using your app.

For example, you can render a list of the first ten task records, which will automatically update when backend data changes:

1export const FirstPage = (props) => {
2  const [{ data, error, fetching }] = useFindMany(api.task, {
3    // make this a realtime live query
4    live: true,
5    first: 10,
6  });
7  if (!data) return null;
8  return (
9    <div>
10      {data.map((record) => (
11        <div key={record.id}>{record.id}</div>
12      ))}
13    </div>
14  );
15};

For more information, see the Realtime Queries guide.

Type Safety 

The select option is fully type safe if you're using TypeScript. The returned GadgetRecord type will have a <Shape> exactly matching the fields and nested fields you selected.

This behavior of selecting only some fields is built right into GraphQL. If you want to limit or expand what you retrieve from a GraphQL query, include or exclude those fields in your GraphQL query. For more information on executing GraphQL queries, see GraphQL.

1// fetch the id and createdAt field, and fetch some nested fields from an example relationship field named `someRelatedObject`
2const taskRecords = await api.task.findMany({
3  select: {
4    id: true,
5    createdAt: true,
6    someRelatedObject: { id: true, createdAt: true },
7  },
8});

1const SelectionComponent = (props) => {
2  // fetch the id and createdAt field, and fetch some nested fields from an example relationship field named `someRelatedObject`
3  const [{ data, error, fetching }, refresh] = useFindMany(api.task, {
4    select: {
5      id: true,
6      createdAt: true,
7      someRelatedObject: { id: true, createdAt: true },
8    },
9  });
10  // ...
11};

Combining parameters 

Sort, search, filtering, selection, and pagination parameters can be combined to access the exact set of records needed for your use case.

1const taskRecords = await api.task.findMany({
2  search: "<some search query>",
3  sort: { createdAt: "Descending" },
4  filter: { updatedAt: { greaterThan: new Date(Date.now() - 864e5) } },
5  select: { id: true, createdAt: true },
6  first: 25,
7  after: "abcdefg",
8});

1const [result, refresh] = useFindMany(api.task, {
2  search: "<some search query>",
3  sort: { createdAt: "Descending" },
4  filter: { updatedAt: { greaterThan: new Date(Date.now() - 864e5) } },
5  select: { id: true, createdAt: true },
6  first: 25,
7  after: "abcdefg",
8});
9const { data, error, fetching } = result;

1query FindManyTasks(
2  $after: String
3  $before: String
4  $first: Int
5  $last: Int
6  $search: String
7  $sort: [TaskSort!]
8  $filter: [TaskFilter!]
9) {
10  tasks(
11    after: $after
12    before: $before
13    first: $first
14    last: $last
15    search: $search
16    sort: $sort
17    filter: $filter
18  ) {
19    pageInfo {
20      hasNextPage
21      hasPreviousPage
22      startCursor
23      endCursor
24    }
25    edges {
26      cursor
27      node {
28        __typename
29        id
30        state
31        createdAt
32        description {
33          markdown
34          truncatedHTML
35        }
36        title
37        updatedAt
38      }
39    }
40  }
41}

1{
2  "search": "<some search query>",
3  "sort": { "createdAt": "Descending" },
4  "filter": { "updatedAt": { "greaterThan": "2024-04-26T04:56:11.856Z" } },
5  "first": 25,
6  "after": "abcdefg"
7}

Invoking Actions 

task records are changed by invoking Actions. Actions are the things that "do" stuff -- update records, make API calls, call backend code, etc. Actions with a GraphQL API trigger each have one corresponding GraphQL mutation and a corresponding function available in the API client libraries. Nested Actions can also be invoked with the API client, by providing the actions as input to any relationship fields.

Action Result format 

Each API action returns results in the same format that includes a success indicator, errors, and the actual result if the action succeeded. The result is the record that was acted on for a model action, or a list of records for a bulk action, or a JSON blob for Global Actions. Model actions that delete the record don't return the record.

The success field returns a boolean indicating if the action executed as expected. Any execution errors are returned in the errors object, which will always be null if success is true or contain ExecutionError objects if success is false.

ExecutionError objects always have a message describing what error prevented the action from succeeding, as well as a code attribute that gives a stable, searchable, human-readable error class code for referencing this specific error. Details on each error code can be found in the Errors documentation. All ExecutionError object types returned by the GraphQL object can be one of many types of error, where some types have extra data that is useful for remedying the error. All error types will always have message and code properties, but some, like InvalidRecordError have extra fields for use by clients.

Errors when using the generated client 

The generated JavaScript client automatically interprets errors from invoking actions and throws JavaScript Error instances if the action didn't succeed. The Error objects it throws are rich, and expose extra error properties beyond just message and code if they exist.

Errors thrown by the JavaScript client are easiest to catch by using a try/catch statement around an await, like so:

JavaScript
Copy
1import {
2  GadgetOperationError,
3  InvalidRecordError,
4} from "@gadget-client/example-app";
5
6// must be in an async function to use \`await\` syntax
7const runAction = async () => {
8  try {
9    return await api.exampleModel.create({ name: "example record name" });
10  } catch (error) {
11    if (error instanceof GadgetOperationError) {
12      // a recognized general error has occurred, retry the operation or inspect \error.code\`
13      console.error(error);
14    } else if (error instanceof InvalidRecordError) {
15      // the submitted input data for the action was invalid, inspect the invalid fields which \`InvalidRecordError\` exposes
16      console.error(error.validationErrors);
17    } else {
18      // an unrecognized error occurred like an HTTP connection interrupted error or a syntax error. Re-throw it because it's not clear what to do to fix it
19      throw error;
20    }
21  }
22};

For more information on error codes, consult the Errors documentation.

task create 

Input 

create accepts the following input parameters:

1export type CreateTaskInput = {
2  description?: RichTextInput | null;
3
4  owner?: UserBelongsToInput | null;
5
6  title?: (Scalars["String"] | null) | null;
7};
8
9export type CreateTaskArguments = {
10  task?: CreateTaskInput | null;
11};

1input CreateTaskInput {
2  description: RichTextInput
3  owner: UserBelongsToInput
4  title: String
5}
6
7input CreateTaskArguments {
8  task: CreateTaskInput
9}

1const taskRecord = await api.task.create({
2  description: {
3    markdown: "example _rich_ **text**",
4  },
5  owner: {
6    _link: "123",
7  },
8  title: "example value for title",
9});