New Crowdin updates (subquery#669)

* New translations graphql.md (French) * New translations graphql.md (Spanish) * New translations graphql.md (Bulgarian) * New translations graphql.md (German) * New translations graphql.md (Italian) * New translations graphql.md (Japanese) * New translations graphql.md (Korean) * New translations graphql.md (Russian) * New translations graphql.md (Turkish) * New translations graphql.md (Ukrainian) * New translations graphql.md (Chinese Simplified) * New translations graphql.md (Vietnamese) * New translations graphql.md (Indonesian) * New translations graphql.md (Thai) * New translations graphql.md (Chinese Simplified) * New translations graphql.md (Spanish) * New translations graphql.md (Spanish) * New translations graphql.md (French) * New translations README.md (French) * New translations delete-projects.md (French) * New translations graphql.md (French) * New translations moonbeam.md (French) * New translations README.md (French) * New translations README.md (French) * New translations graphql.md (French) * New translations moonbeam.md (French) * New translations moonbeam.md (Spanish) * New translations moonbeam.md (Spanish) * New translations moonbeam.md (Turkish) * Review fix
Rozeris · Dec 6, 2021 · a27be97 · a27be97
1 parent 0ec1fdd
commit a27be97
Show file tree

Hide file tree

Showing 20 changed files with 391 additions and 360 deletions.
diff --git a/docs/bg/create/graphql.md b/docs/bg/create/graphql.md
@@ -31,7 +31,7 @@ We currently supporting flowing scalars types:
 - `Boolean`
 - `<EntityName>` for nested relationship entities, you might use the defined entity's name as one of the fields. Please see in [Entity Relationships](#entity-relationships).
 - `JSON` can alternatively store structured data, please see [JSON type](#json-type)
-- `Enum` types are a special kind of scalar that is restricted to a particular set of allowed values. Please see [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
+- `<EnumName>` types are a special kind of enumerated scalar that is restricted to a particular set of allowed values. Please see [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
 
 ## Indexing by non-primary-key field
 

diff --git a/docs/de/create/graphql.md b/docs/de/create/graphql.md
@@ -31,7 +31,7 @@ We currently supporting flowing scalars types:
 - `Boolean`
 - `<EntityName>` for nested relationship entities, you might use the defined entity's name as one of the fields. Please see in [Entity Relationships](#entity-relationships).
 - `JSON` can alternatively store structured data, please see [JSON type](#json-type)
-- `Enum` types are a special kind of scalar that is restricted to a particular set of allowed values. Please see [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
+- `<EnumName>` types are a special kind of enumerated scalar that is restricted to a particular set of allowed values. Please see [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
 
 ## Indexing by non-primary-key field
 

diff --git a/docs/es/create/graphql.md b/docs/es/create/graphql.md
@@ -1,67 +1,67 @@
-# GraphQL Schema
+# Esquema GraphQL
 
-## Defining Entities
+## Definición de entidades
 
-The `schema.graphql` file defines the various GraphQL schemas. Due to the way that the GraphQL query language works, the schema file essentially dictates the shape of your data from SubQuery. To learn more about how to write in GraphQL schema language, we recommend checking out [Schemas and Types](https://graphql.org/learn/schema/#type-language).
+El archivo `schema.graphql` define los diversos esquemas GraphQL. Debido a la forma en que funciona el lenguaje de consulta de GraphQL, el archivo de esquema esencialmente dicta la forma de sus datos de SubQuery. Para obtener más información sobre cómo escribir en el lenguaje de esquema GraphQL, recomendamos revisar [Esquemas y tipos](https://graphql.org/learn/schema/#type-language).
 
-**Important: When you make any changes to the schema file, please ensure that you regenerate your types directory with the following command `yarn codegen`**
+**Importante: Cuando haga cambios en el archivo de esquema, por favor, asegúrate de regenerar el directorio de tus tipos con el siguiente comando `yarn codegen`**
 
-### Entities
-Each entity must define its required fields `id` with the type of `ID!`. It is used as the primary key and unique among all entities of the same type.
+### Entidades
+Cada entidad debe definir sus campos requeridos `id` con el tipo de `ID!`. Se utiliza como la clave primaria y única entre todas las entidades del mismo tipo.
 
-Non-nullable fields in the entity are indicated by `!`. Please see the example below:
+Los campos que no aceptan valores Null en la entidad se indican mediante `!`. Por favor vea el ejemplo a continuación:
 
 ```graphql
 type Example @entity {
-  id: ID! # id field is always required and must look like this
-  name: String! # This is a required field
-  address: String # This is an optional field
+  id: ID! # campo id siempre es obligatorio y debe verse como este
+  name: String! # Este es un campo obligatorio
+  address: String # Este es un campo opcional
 }
 ```
 
-### Supported scalars and types
+### Escalares y tipos soportados
 
-We currently supporting flowing scalars types:
+Actualmente soportamos tipos de escalares fluidos:
 - `ID`
 - `Int`
 - `String`
 - `BigInt`
 - `Float`
 - `Date`
 - `Boolean`
-- `<EntityName>` for nested relationship entities, you might use the defined entity's name as one of the fields. Please see in [Entity Relationships](#entity-relationships).
-- `JSON` can alternatively store structured data, please see [JSON type](#json-type)
-- `Enum` types are a special kind of scalar that is restricted to a particular set of allowed values. Please see [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
+- `<EntityName>` para entidades de relación anidadas, puede utilizar el nombre de la entidad definida como uno de los campos. Consulte [Relaciones con Entidades](#entity-relationships).
+- `JSON` puede almacenar datos estructurados alternativamente, consulte [tipo JSON](#json-type)
+- `<EnumName>` tipos son un tipo especial de escalar enumerado que está restringido a un conjunto particular de valores permitidos. Por favor vea [Graphql Enum](https://graphql.org/learn/schema/#enumeration-types)
 
-## Indexing by non-primary-key field
+## Indexando por un campo de clave no primaria
 
-To improve query performance, index an entity field simply by implementing the `@index` annotation on a non-primary-key field.
+Para mejorar el rendimiento de la consulta, indexar un campo de entidad simplemente implementando la anotación `@index` en un campo de clave no primaria.
 
-However, we don't allow users to add `@index` annotation on any [JSON](#json-type) object. By default, indexes are automatically added to foreign keys and for JSON fields in the database, but only to enhance query service performance.
+Sin embargo, no permitimos que los usuarios añadan anotación `@index` en cualquier objeto [JSON](#json-type). Por defecto, los índices se añaden automáticamente a las claves foráneas y para los campos JSON en la base de datos, pero sólo para mejorar el rendimiento del servicio de consultas.
 
-Here is an example.
+Aquí tenemos un ejemplo.
 
 ```graphql
 type User @entity {
   id: ID!
-  name: String! @index(unique: true) # unique can be set to true or false
-  title: Title! # Indexes are automatically added to foreign key field 
+  name: String! @index(unique: true) # unique puede establecerse en verdadero o falso
+ title: Title! # Los índices se añaden automáticamente al campo de clave foránea 
 }
 
 type Title @entity {
   id: ID!  
   name: String! @index(unique:true)
 }
 ```
-Assuming we knew this user's name, but we don't know the exact id value, rather than extract all users and then filtering by name we can add `@index` behind the name field. This makes querying much faster and we can additionally pass the `unique: true` to  ensure uniqueness.
+Asumiendo que conocíamos el nombre de este usuario, pero no conocemos el valor exacto del id, en lugar de extraer todos los usuarios y luego filtrar por nombre podemos añadir `@index` detrás del campo nombre. Esto hace que la consulta sea mucho más rápida y además podemos pasar el `único: verdadero` para asegurar la unidad.
 
-**If a field is not unique, the maximum result set size is 100**
+**Si un campo no es único, el tamaño máximo del conjunto de resultados es 100**
 
-When code generation is run, this will automatically create a `getByName` under the `User` model, and the foreign key field `title` will create a `getByTitleId` method, which both can directly be accessed in the mapping function.
+Cuando se ejecuta la generación de código, esto creará automáticamente un `getByName` bajo el modelo `User`, y el campo de clave foránea `title` creará un método `getByTitleId`, a la que se puede acceder directamente ambos en la función de mapeo.
 
 ```sql
-/* Prepare a record for title entity */
-INSERT INTO titles (id, name) VALUES ('id_1', 'Captain')
+/* Prepara un registro para la entidad de título */
+INSERT INTO titles (id, name) VALUES ('id_1', 'capitán')
 ```
 
 ```typescript
@@ -76,17 +76,17 @@ const captainTitle = await Title.getByName('Captain');
 const pirateLords = await User.getByTitleId(captainTitle.id); // List of all Captains
 ```
 
-## Entity Relationships
+## Relaciones de Entidades
 
-An entity often has nested relationships with other entities. Setting the field value to another entity name will define a one-to-one relationship between these two entities by default.
+Una entidad a menudo tiene relaciones anidadas con otras entidades. Establecer el valor del campo a otro nombre de entidad definirá una relación uno a uno entre estas dos entidades por defecto.
 
-Different entity relationships (one-to-one, one-to-many, and many-to-many) can be configured using the examples below.
+Diferentes relaciones de entidad (uno a uno, uno a muchos, y muchos-a-muchos) pueden configurarse usando los ejemplos siguientes.
 
-### One-to-One Relationships
+### Relaciones de uno a uno
 
-One-to-one relationships are the default when only a single entity is mapped to another.
+Las relaciones de uno a uno son el valor por defecto cuando sólo una entidad es asignada a otra.
 
-Example: A passport will only belong to one person and a person only has one passport (in this example):
+Ejemplo: Un pasaporte sólo pertenecerá a una persona y una persona sólo tiene un pasaporte (en este ejemplo):
 
 ```graphql
 type Person @entity {
@@ -99,7 +99,7 @@ type Passport @entity {
 }
 ```
 
-or
+o
 
 ```graphql
 type Person @entity {
@@ -113,11 +113,11 @@ type Passport @entity {
 }
 ```
 
-### One-to-Many relationships
+### Relaciones de Uno a Muchos
 
-You can use square brackets to indicate that a field type includes multiple entities.
+Puede usar corchetes cuadrados para indicar que un tipo de campo incluye múltiples entidades.
 
-Example: A person can have multiple accounts.
+Ejemplo: Una persona puede tener múltiples cuentas.
 
 ```graphql
 type Person @entity {
@@ -131,10 +131,10 @@ type Account @entity {
 }
 ```
 
-### Many-to-Many relationships
-A many-to-many relationship can be achieved by implementing a mapping entity to connect the other two entities.
+### Relaciones Muchos-a-Muchos
+Una relación muchos-a-muchos puede lograrse implementando una entidad de mapeo para conectar las otras dos entidades.
 
-Example: Each person is a part of multiple groups (PersonGroup) and groups have multiple different people (PersonGroup).
+Ejemplo: Cada persona es parte de múltiples grupos (PersonGrup) y los grupos tienen múltiples personas diferentes (PersonGrup).
 
 ```graphql
 type Person @entity {
@@ -156,11 +156,11 @@ type Group @entity {
 }
 ```
 
-Also, it is possible to create a connection of the same entity in multiple fields of the middle entity.
+Además, es posible crear una conexión de la misma entidad en múltiples campos de la entidad media.
 
-For example, an account can have multiple transfers, and each transfer has a source and destination account.
+Por ejemplo, una cuenta puede tener múltiples transferencias, y cada transferencia tiene una cuenta de origen y destino.
 
-This will establish a bi-directional relationship between two Accounts (from and to) through Transfer table.
+Esto establecerá una relación bidireccional entre dos Cuentas (de y a) a través de la tabla Transferencia.
 
 ```graphql
 type Account @entity {
@@ -176,13 +176,13 @@ type Transfer @entity {
 }
 ```
 
-### Reverse Lookups
+### Búsqueda inversa
 
-To enable a reverse lookup on an entity to a relation, attach `@derivedFrom` to the field and point to its reverse lookup field of another entity.
+Para habilitar una búsqueda inversa en una entidad a una relación, adjunta `@derivedFrom` al campo y apunta a su campo de búsqueda inversa de otra entidad.
 
-This creates a virtual field on the entity that can be queried.
+Esto crea un campo virtual en la entidad que se puede consultar.
 
-The Transfer "from" an Account is accessible from the Account entity by setting the sentTransfer or receivedTransfer as having their value derived from the respective from or to fields.
+La transferencia "de" una Cuenta es accesible desde la entidad de la Cuenta estableciendo el sentTransfer o el receivedTransfer como teniendo su valor derivado de los respectivos campos from-de y to-para.
 
 ```graphql
 type Account @entity {
@@ -200,19 +200,19 @@ type Transfer @entity {
 }
 ```
 
-## JSON type
+## Tipo JSON
 
-We are supporting saving data as a JSON type, which is a fast way to store structured data. We'll automatically generate corresponding JSON interfaces for querying this data and save you time defining and managing entities.
+Estamos soportando guardar datos como un tipo JSON, que es una forma rápida de almacenar datos estructurados. Generaremos automáticamente interfaces JSON correspondientes para consultar estos datos y ahorraremos tiempo definiendo y gestionando entidades.
 
-We recommend users use the JSON type in the following scenarios:
-- When storing structured data in a single field is more manageable than creating multiple separate entities.
-- Saving arbitrary key/value user preferences (where the value can be boolean, textual, or numeric, and you don't want to have separate columns for different data types)
-- The schema is volatile and changes frequently
+Recomendamos que los usuarios usen el tipo JSON en los siguientes escenarios:
+- Al almacenar datos estructurados en un solo campo es más manejable que la creación de múltiples entidades separadas.
+- Guardando las preferencias de usuario clave/valor arbitrario (donde el valor puede ser booleano, textual, o numérico, y no quiere tener columnas separadas para diferentes tipos de datos)
+- El esquema es volátil y cambia con frecuencia
 
-### Define JSON directive
-Define the property as a JSON type by adding the `jsonField` annotation in the entity. This will automatically generate interfaces for all JSON objects in your project under `types/interfaces.ts`, and you can access them in your mapping function.
+### Define la directiva JSON
+Define la propiedad como un tipo JSON agregando la anotación `jsonField` en la entidad. Esto automáticamente generará interfaces para todos los objetos JSON en su proyecto bajo `types/interfaces.ts`, y puedes acceder a ellos desde tu función de mapeo.
 
-Unlike the entity, the jsonField directive object does not require any `id` field. A JSON object is also able to nest with other JSON objects.
+A diferencia de la entidad, el objeto de directiva jsonField no requiere ningún campo `id`. Un objeto JSON también es capaz de anidar con otros objetos JSON.
 
 ````graphql
 type AddressDetail @jsonField {
@@ -227,18 +227,18 @@ type ContactCard @jsonField {
 
 type User @entity {
   id: ID! 
-  contact: [ContactCard] # Store a list of JSON objects
+  contact: [ContactCard] # Almacenar una lista de objetos JSON
 }
 ````
 
-### Querying JSON fields
+### Consulta de campos JSON
 
-The drawback of using JSON types is a slight impact on query efficiency when filtering, as each time it performs a text search, it is on the entire entity.
+El inconveniente del uso de tipos JSON es un ligero impacto en la eficiencia de la consulta al filtrar, como cada vez que realiza una búsqueda de texto, se encuentra en toda la entidad.
 
-However, the impact is still acceptable in our query service. Here is an example of how to use the `contains` operator in the GraphQL query on a JSON field to find the first 5 users who own a phone number that contains '0064'.
+Sin embargo, el impacto sigue siendo aceptable en nuestro servicio de consultas. Aquí hay un ejemplo de cómo utilizar el operador `contains` en la consulta GraphQL en un campo JSON para encontrar los 5 primeros usuarios que poseen un número de teléfono que contiene '0064'.
 
 ```graphql
-#To find the the first 5 users own phone numbers contains '0064'.
+#Para encontrar los primeros 5 usuarios de los números de teléfono contienen '0064'.
 
 query{
   user(