Förstå kraven för GraphQL-schema

Tillgängliga i: både Salesforce Classic och Lightning Experience (inte för externa objekt med hög datavolym)

Tillgängliga i: Developer Edition Tillgängligt mot en tilläggskostnad i: Utgåvorna Enterprise, Performance och Unlimited

Detta är ett representativt schema för att förstå hur man konstruerar ett schema som fungerar med Salesforce Connect. Notationer för att förstå det representativa schemat:

• ObjName: Anger namnet på ett GraphQL-objekt.
• Text i fetstil: Representerar mönstret att följa för varje objekt.
• Text utan fetstil: Representerar vanlig kod, inte specifik för objekten.

type Query {
    objName(
        limit: Int,
        offset: Int,
        orderBy: [ObjName_OrderByInput],
        where: ObjName_FilterInput,
        first: Int,
        after: String
    ): ObjName_Connection
        <additional object queries...>
        node(id: ID!): Node
}

type Mutation {
    create_ObjName(input: ObjName_CreateInput!): ObjName
    <additional create mutations>
    ...
    delete_ObjName(id: ID!): ObjName
    <additional delete mutations>
    ...
    update_ObjName(input: ObjName_UpdateInput!): ObjName
    <additional update mutations>
    ...
}

type ObjName implements Node {
    id: ID!
    <fieldName: fieldType>
    ...
}

type ObjName_Connection {
    edges: [ObjName_Edge]
    pageInfo: PageInfo!
}

input ObjName_CreateInput {
        <fieldName: fieldType>
        ...
}

input ObjName_UpdateInput {
    id: ID!
    <fieldName: fieldType>
    ...
}

type ObjName_Edge {
    cursor: String!
    node: ObjName
}

input ObjName_FilterInput {
    and: [ObjName_FilterInput]
    not: ObjName_FilterInput
    or: [ObjName_FilterInput]
    id: IDOperator
    <fieldName: fieldTypeOperator>
    ...
}

input ObjName_OrderByInput {
    id: OrderByClause
    <fieldName >: OrderByClause
    ...
}

interface Node {
    id: ID!
}

enum NullsOrder {
    NULLS_FIRST
    NULLS_LAST
}

input OrderByClause {
    direction: Direction
    nulls: NullsOrder
}

type PageInfo {
    endCursor: String
    hasNextPage: Boolean!
    hasPreviousPage: Boolean!
    startCursor: String
}

input StringOperator {
    eq: String
    gt: String
    ge: String
    in: [String]
    like: String
    lt: String
    le: String
    ne: String
    nin: [String]
}

input AWSDateOperator {
    eq: AWSDate
    gt: AWSDate
    ge: AWSDate
    in: [AWSDate]
    like: AWSDate
    lt: AWSDate
    le: AWSDate
    ne: AWSDate
    nin: [AWSDate]
}

input AWSDateTimeOperator {
    eq: AWSDateTime
    gt: AWSDateTime
    ge: AWSDateTime
    in: [AWSDateTime]
    like: AWSDateTime
    lt: AWSDateTime
    le: AWSDateTime
    ne: AWSDateTime
    nin: [AWSDateTime]
}

input AWSJSONOperator {
    eq: AWSJSON
    gt: AWSJSON
    ge: AWSJSON
    in: [AWSJSON]
    like: AWSJSON
    lt: AWSJSON
    le: AWSJSON
    ne: AWSJSON
    nin: [AWSJSON]
}

input AWSTimeOperator {
    eq: AWSTime
    gt: AWSTime
    ge: AWSTime
    in: [AWSTime]
    like: AWSTime
    lt: AWSTime
    le: AWSTime
    ne: AWSTime
    nin: [AWSTime]
}

input BooleanOperator {
    eq: Boolean
    gt: Boolean
    gebolded: Boolean
    in: [Boolean]
    like: Boolean
    lt: Boolean
    le: Boolean
    ne: Boolean
    nin: [Boolean]
}

enum Direction {
    ASC
    DESC
}

input FloatOperator {
    eq: Float
    gt: Float
    ge: Float
    in: [Float]
    like: Float
    lt: Float
    le: Float
    ne: Float
    nin: [Float]
}

input IDOperator {
    eq: ID
    gt: ID
    ge: ID
    in: [ID]
    like: ID
    lt: ID
    le: ID
    ne: ID
    nin: [ID]
}

input IntOperator {
    eq: Int
    gt: Int
    ge: Int
    in: [Int]
    like: Int
    lt: Int
    le: Int
    ne: Int
    nin: [Int]
}

Varje objekt måste ha ett ID! som är globalt unikt och detta globala ID måste vara samma för alla objekt. Om du har flera fält av typen ID! och det inte finns något fält med ID som fältnamn, använd keyColumns för att specificera det globala ID:t. Se Kvalificeringsalternativ.

När en extern sökrelation representerar samma sökrelation som finns mellan GraphQL-objekt, tänk på detta. Fältet Externt ID i det överordnade externa objektet måste matcha formatet för det externa sökfältet i det underordnade externa objektet. Om de inte matchar, använd kvalificerare för att hantera något av följande:

• Ändra det överordnade externa objektets externa ID så att det matchar den underordnade externa sökningen.
• Skapa en virtuell kolumn i det underordnade externa objektet för att matcha det överordnade externa ID:t.

Det är viktigt att det globala ID:t för GraphQL och Salesforces externa ID kan beräknas från varandra. Ett möjligt sätt att strukturera ett globalt ID är att använda ett prefix för att namnge ID:t och hålla det unikt. Om objektets primära nyckel består av flera nyckelfält, använd en avgränsare för att separera prefixet och ID:t. Om något av nyckelfältens värde innehåller avgränsaren, se till att undanta avgränsaren.

I detta exempel ObjName| är prefixet och - är avgränsaren. Att använda | efter ObjName hjälper till att tolka prefixet från nyckelkompositionen.

id: ObjName|KEY1\-123-KEY2\-456
key1: KEY1-123
key2: KEY2-456