 – Build the way you think, not the way your CMS thinks

Sanity is the developer-first content operating system that gives you complete control. Schema-as-code, GROQ queries, and real-time APIs mean no more workarounds or waiting for deployments. Free to start, scale as you grow.

What does "it" mean in Sanity?

export default () =&gt;
  S.list()
    .title('Content')
    .items([
      S.listItem()
        .title('Gestione Categorie')
        .child(async () =&gt; {
          const { data: categories } = await getCategories();
          return categories?.map((element) =&gt;
            S.document()
              .title(carTypes[element])
              .documentId(`category-${element.toLowerCase()}`)
              .schemaType('categoriesSettings')
          );
        }),
      // Add a visual divider (optional)d
      S.divider(),
      // List out the rest of the document types, but filter out the config type
      ...S.documentTypeListItems().filter(
        (listItem) =&gt; !['categoriesSettings'].includes(listItem.getId())
      ),
    ]);

neutral_face

Yes, I see. Just trying to get the same thing going in my code.

import S from '@sanity/desk-tool/structure-builder';
import carTypes from './static/categories';
import axios from 'axios';
import { IGetCategoryResponse } from '../server/src/controllers/getCategoriesController';
const http = axios.create({
  baseURL: '<http://localhost:5000/api/v1>',
  timeout: 1000,
});

function getCategories(): Promise&lt;IGetCategoryResponse&gt; {
  return http.get('/cms/categories').then((res) =&gt; res.data);
}

export default () =&gt;
  S.list()
    .title('Content')
    .items([
      S.listItem()
        .title('Gestione pagina dei risultati')
        .child(
          S.list()
            .title('Risultati per:')
            .items([
              S.listItem()
                .title('Categoria')
                .child(async () =&gt; {
                  const { data: categories } = await getCategories();
                  return categories?.map((element) =&gt;
                    S.document()
                      .schemaType('categoriesSettings')
                      .title(carTypes[element])
                      .documentId(`category-${element}`)
                  );
                }),
            ])
        ),
      // Add a visual divider (optional)d
      S.divider(),
      // List out the rest of the document types, but filter out the config type
      ...S.documentTypeListItems().filter(
        (listItem) =&gt; !['categoriesSettings'].includes(listItem.getId())
      ),
    ]);

you can replace the categories with an array of strings

I will try in a couple of minutes, and I will let you know

This solution will render the document as listItem but I’m not able to edit the document.

morehover I’ve installed a plugin to order documents and I cant’ see that documents cause they are list item not a real documents

That's correct - you are pulling in these categories from outside the studio, so they are not actual documents until you create them. The above only sets them up in the desk structure so you can more easily create them with specific document IDs.

Regarding not being able to edit the documents, could you share your schema definitions for the 

{"type":12,"children":[{"type":0,"text":"yep","source":"yep"}],"source":"yep"}

__experimental_actions: [/*‘create’,*/ ‘update’, /*‘delete’,*/ ‘publish’],

Indeed, by commenting out "create" you are preventing the creation of these documents. What you could try if you do not want to allow additional 

 documents in the future, is temporarily uncommenting, then creating the docs by adding content to them, and commenting out 

and If i will add more “categories” in the future on my api?

why I can’t create directly the document instead of list item?

I read something about in the docs that was possibile

Then the same will apply, so you may want to consider taking a different route: either always allowing the creation of these documents or instead creating the documents using the HTTP API instead, which will ignore 

For more information on creating docs using the HTTP API, see also: 

By putting a string in this method, it will create a document with that ID if it doesn't already exist. 

That's right: in the code above you are using this approach (

 child) - when you start adding content to the empty documents, it will create a document with the provided ID. However, the creation process does rely on the 

 action being allowed for the document type.

so the right approach is to create that documents

so if I have to render all the documents for that specific schemaType what I have to do?

If you want to disable document creation for a type in the studio and still create documents for it without temporarily adding 

 as an allowed action, then using the HTTP API is indeed a good alternative.

To render all documents available for a specific schema type, you can use a 

// deskStructure.js
...
S.listItem()
  .title('Categories')
  .child(
    S.documentList()
      .title('Categories')
      .filter('_type == "categoriesSettings"')
  ),

Sorry about the confusion. There's plenty of stuff to get your head around at the beginning, but there are many advantages to being familiar with the HTTP API if you want to build advanced functionality later 

slightly_smiling_face

 Do let us know if you have any other questions.

{"type":12,"children":[{"type":0,"text":"the token","source":"the token"}],"source":"the token"}

), it will indeed expire. However, you can set up robot tokens by opening your project on 

 and going to Settings &gt; API &gt; Tokens &gt; Add new token. These will not expire 

robot_face

{"type":12,"children":[{"type":0,"text":"ooooook","source":"ooooook"}],"source":"ooooook"}

{"type":12,"children":[{"type":0,"text":"is?","source":"is?"}],"source":"is?"}

 by default). You can find all datasets on your project by going to your project on 

 and opening the Datasets tab - or by using the 

 command in your CLI (make sure to run it from your studio's root folder).

 by default). You can find all datasets on your project by going to 

 &gt; Settings &gt; Datasets or using the 

{"type":12,"children":[{"type":0,"text":"okok","source":"okok"}],"source":"okok"}


export async function postNewCategories(categories: string[]): Promise&lt;void&gt; {
  try {
    await <http://http.post|http.post>('/data/mutate/production', {
      mutations: categories.map((category: string) =&gt; ({
        create: {
          _id: category,
          _type: 'categoriesSettings',
          title: 'category',
        },
      })),
    });
  } catch (err) {
    console.log(err);
    throw new Error(err.message);
  }
}

where http is an instance of axios with token and base url

smile

Yep, that looks alright to me as long as you can guarantee 

 is unique enough for future usage as these document IDs have to be unique 

yep those are unique cause I’ve already do a normalization my backend side

heart

Awesome! The operation will fail if a document with the provided ID already exists. If you prefer that it doesn't fail but skips existing ones, you can use 

. If you wish to replace docs if they already exist, you can use 

S.documentList()
      .title('Categories')
      .filter('_type == "categoriesSettings"')

In you experience is possibile to add a sort on this by specific field inside the document?

i mean, I’m using a plugin for ordering, and I would like to refect the ordering in the menu

when I use create from api I have to referecing the name of the schema right?

{"type":12,"children":[{"type":0,"text":"eg:","source":"eg:"}],"source":"eg:"}

name: ‘resultBrandsSettings’,
  type: ‘document’,
  title: ‘Brands’,

 (mind the underscore) should be set to the schema type (

it’s weird cause I’ve set it up all correct

Are you able to query the documents? e.g. 

sanity documents query '*[_type == "resultBrandsSettings"]'

the function works, and the array with results is passed to the function


export async function postNewBrands(brands: IBrand[]): Promise&lt;void&gt; {
  try {
    await <http://http.post|http.post>('/data/mutate/production', {
      mutations: brands.map((brand: IBrand) =&gt; ({
        createIfNotExists: {
          _id: brand.id,
          _type: 'resultBrandsSettings',
          title: brand.name,
        },
      })),
    });
  } catch (err) {
    throw new Error(
      `Sanity API Error: status:${err?.response?.status}, statusCode: ${err?.response?.statusText}`
    );
  }
}

{"type":12,"children":[{"type":0,"text":"uhm","source":"uhm"}],"source":"uhm"}

Looks like only those docs are in your dataset right now: 

{"type":12,"children":[{"type":0,"text":"yeah","source":"yeah"}],"source":"yeah"}

{"type":12,"children":[{"type":0,"text":"why?","source":"why?"}],"source":"why?"}

on the Backend side i’ve changed just the name of the schema

the weird part is if i change the method to create

but as you can se here there’s any category inside 

categories [
  'cabrio-coupe',
  'city-car',
  'minivan',
  'other',
  'sedan',
  'suv',
  'van',
  'wagon'
]
Error: Sanity API Error: status:409, statusCode: Conflict

Have you double-checked your Axios instance uses the correct base URL (project ID and dataset name)?

That's correct though: those documents exist - just not under the document type. I'm suspecting it's an ID conflict as they share the same ID this way.

{"type":12,"children":[{"type":0,"text":"oh ok","source":"oh ok"}],"source":"oh ok"}

{"type":12,"children":[{"type":0,"text":"make sense","source":"make sense"}],"source":"make sense"}

What does "it" mean in Sanity?

Sanity – Build the way you think, not the way your CMS thinks

Was this answer helpful?