@subsquid/openreader 4.6.0 → 5.0.0-beta.79fbfe

package/src/{opencrud → dialect/opencrud}/schema.ts

@@ -27,29 +27,21 @@ import {
     GraphQLFieldConfigMap,
     GraphQLInputFieldConfigMap
 } from 'graphql/type/definition'
-import {Context} from '../context'
-import {decodeRelayConnectionCursor, RelayConnectionRequest} from '../ir/connection'
-import {AnyFields} from '../ir/fields'
-import {getConnectionSize, getListSize, getObjectSize} from '../limit.size'
-import {Entity, Interface, JsonObject, Model, Prop} from '../model'
-import {getObject, getUniversalProperties} from '../model.tools'
-import {customScalars} from '../scalars'
-import {ConnectionQuery, CountQuery, EntityByIdQuery, ListQuery, Query} from '../sql/query'
-import {Limit} from '../util/limit'
-import {getResolveTree, getTreeRequest, hasTreeRequest, simplifyResolveTree} from '../util/resolve-tree'
-import {ensureArray, identity} from '../util/util'
+import {Context} from '../../context'
+import {decodeRelayConnectionCursor, RelayConnectionRequest} from '../../ir/connection'
+import {AnyFields} from '../../ir/fields'
+import {getConnectionSize, getListSize, getObjectSize} from '../../limit.size'
+import {Entity, Interface, JsonObject, Model, Prop} from '../../model'
+import {getEntity, getObject, getUniversalProperties} from '../../model.tools'
+import {customScalars} from '../../scalars'
+import {ConnectionQuery, CountQuery, EntityByIdQuery, ListQuery, Query} from '../../sql/query'
+import {Limit} from '../../util/limit'
+import {getResolveTree, getTreeRequest, hasTreeRequest, simplifyResolveTree} from '../../util/resolve-tree'
+import {ensureArray, identity} from '../../util/util'
 import {getOrderByMapping, parseOrderBy} from './orderBy'
 import {parseAnyTree, parseObjectTree, parseSqlArguments} from './tree'
 import {parseWhere} from './where'
-
-
-type GqlFieldMap = GraphQLFieldConfigMap<unknown, Context>
-
-
-export interface SchemaOptions {
-    model: Model
-    subscriptions?: boolean
-}
+import {GqlFieldMap, SchemaOptions} from '../common'
 
 
 export class SchemaBuilder {
@@ -377,7 +369,6 @@ export class SchemaBuilder {
                 case "entity":
                     this.installListQuery(name, query, subscription)
                     this.installEntityById(name, query, subscription)
-                    this.installEntityByUniqueInput(name, query)
                     this.installRelayConnection(name, query)
                     break
                 case 'interface':
@@ -403,7 +394,9 @@ export class SchemaBuilder {
 
     private installListQuery(typeName: string, query: GqlFieldMap, subscription: GqlFieldMap): void {
         let model = this.model
-        let queryName = toPlural(toCamelCase(typeName))
+
+        let entity = model[typeName]
+        let queryName = entity.kind === 'entity' && entity.listQueryName || this.normalizeEntityName(typeName).plural
         let outputType = new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(this.get(typeName))))
         let argsType = this.listArguments(typeName)
 
@@ -414,7 +407,7 @@ export class SchemaBuilder {
             limit?.check(() => getListSize(model, typeName, fields, args.limit, args.where) + 1)
             return new ListQuery(
                 model,
-                context.openreader.dialect,
+                context.openreader.dbType,
                 typeName,
                 fields,
                 args
@@ -443,7 +436,9 @@ export class SchemaBuilder {
 
     private installEntityById(entityName: string, query: GqlFieldMap, subscription: GqlFieldMap): void {
         let model = this.model
-        let queryName = `${toCamelCase(entityName)}ById`
+
+        let entity = model[entityName]
+        let queryName = (entity.kind === 'entity' && entity.queryName) || `${this.normalizeEntityName(entityName).singular}ById`
         let argsType = {
             id: {type: new GraphQLNonNull(GraphQLString)}
         }
@@ -454,7 +449,7 @@ export class SchemaBuilder {
             limit?.check(() => getObjectSize(model, fields) + 1)
             return new EntityByIdQuery(
                 model,
-                context.openreader.dialect,
+                context.openreader.dbType,
                 entityName,
                 fields,
                 tree.args.id as string
@@ -481,39 +476,12 @@ export class SchemaBuilder {
         }
     }
 
-    private installEntityByUniqueInput(entityName: string, query: GqlFieldMap): void {
-        let model = this.model
-
-        query[`${toCamelCase(entityName)}ByUniqueInput`] = {
-            deprecationReason: `Use ${toCamelCase(entityName)}ById`,
-            type: this.get(entityName),
-            args: {
-                where: {type: this.whereIdInput()}
-            },
-            async resolve(source, args, context, info) {
-                let tree = getResolveTree(info)
-                let fields = parseObjectTree(model, entityName, info.schema, tree)
-                context.openreader.responseSizeLimit?.check(() => getObjectSize(model, fields) + 1)
-                let query = new ListQuery(
-                    model,
-                    context.openreader.dialect,
-                    entityName,
-                    fields,
-                    {where: {op: 'eq', field: 'id', value: args.where.id}}
-                )
-                let result = await context.openreader.executeQuery(query)
-                assert(result.length < 2)
-                return result[0]
-            }
-        }
-    }
-
     private installRelayConnection(typeName: string, query: GqlFieldMap): void {
         let model = this.model
         let outputType = toPlural(typeName) + 'Connection'
         let edgeType = `${typeName}Edge`
 
-        query[`${toPlural(toCamelCase(typeName))}Connection`] = {
+        query[`${this.normalizeEntityName(typeName).plural}Connection`] = {
             type: new GraphQLNonNull(new GraphQLObjectType({
                 name: outputType,
                 fields: {
@@ -582,7 +550,7 @@ export class SchemaBuilder {
 
                 let result = await context.openreader.executeQuery(new ConnectionQuery(
                     model,
-                    context.openreader.dialect,
+                    context.openreader.dbType,
                     typeName,
                     req
                 ))
@@ -590,7 +558,7 @@ export class SchemaBuilder {
                 if (req.totalCount && result.totalCount == null) {
                     result.totalCount = await context.openreader.executeQuery(new CountQuery(
                         model,
-                        context.openreader.dialect,
+                        context.openreader.dbType,
                         typeName,
                         req.where
                     ))
@@ -627,6 +595,13 @@ export class SchemaBuilder {
             })
         )
     }
+
+    private normalizeEntityName(typeName: string) {
+        let singular = toCamelCase(typeName)
+        let plural = toPlural(singular)
+
+        return {singular, plural}
+    }
 }
 
 

package/src/{opencrud → dialect/opencrud}/tree.ts

@@ -2,12 +2,12 @@ import {unexpectedCase} from '@subsquid/util-internal'
 import assert from 'assert'
 import {GraphQLSchema} from 'graphql'
 import {ResolveTree} from 'graphql-parse-resolve-info'
-import {SqlArguments} from '../ir/args'
-import {AnyFields, FieldRequest, FieldsByEntity, OpaqueRequest} from '../ir/fields'
-import {Model} from '../model'
-import {getQueryableEntities} from '../model.tools'
-import {simplifyResolveTree} from '../util/resolve-tree'
-import {ensureArray} from '../util/util'
+import {SqlArguments} from '../../ir/args'
+import {AnyFields, FieldRequest, FieldsByEntity, OpaqueRequest} from '../../ir/fields'
+import {Model} from '../../model'
+import {getQueryableEntities} from '../../model.tools'
+import {simplifyResolveTree} from '../../util/resolve-tree'
+import {ensureArray} from '../../util/util'
 import {parseOrderBy} from './orderBy'
 import {parseWhere} from './where'
 
@@ -18,7 +18,6 @@ export function parseObjectTree(
     schema: GraphQLSchema,
     tree: ResolveTree
 ): FieldRequest[] {
-
     let requests: FieldRequest[] = []
     let requestedScalars: Record<string, true> = {}
     let object = model[typeName]

package/src/{opencrud → dialect/opencrud}/where.ts

@@ -1,7 +1,8 @@
 import {unexpectedCase} from "@subsquid/util-internal"
 import assert from "assert"
-import {Where} from "../ir/args"
-import {ensureArray} from "../util/util"
+import {Where} from "../../ir/args"
+import {ensureArray} from "../../util/util"
+import {toCondition} from '../common'
 
 
 export function parseWhere(whereArg?: any): Where | undefined {
@@ -86,19 +87,6 @@ export function parseWhere(whereArg?: any): Where | undefined {
     }
 }
 
-
-function toCondition(op: 'AND' | 'OR', operands: Where[]): Where | undefined {
-    switch(operands.length) {
-        case 0:
-            return undefined
-        case 1:
-            return operands[0]
-        default:
-            return {op, args: operands}
-    }
-}
-
-
 export function parseWhereKey(key: string): {op: Where['op'], field: string} {
     let m = WHERE_KEY_REGEX.exec(key)
     if (m) {
@@ -138,4 +126,4 @@ const WHERE_KEY_REGEX = (() => {
         "not_in",
     ]
     return new RegExp(`^([^_]*)_(${ops.join('|')})$`)
-})()
+})()

package/src/dialect/thegraph/locale.ts

@@ -0,0 +1,284 @@
+import {inflections, pluralize} from 'inflected'
+
+const THEGRAPH_LOCALE = 'thegraph'
+
+// ref https://github.com/whatisinternet/Inflector/blob/master/src/string/pluralize/mod.rs
+inflections(THEGRAPH_LOCALE, (inflector) => {
+    inflector.plural(/(\w*)$/, '$1s')
+    inflector.plural(/(\w*)s$/, '$1s')
+    inflector.plural(/(\w*([^aeiou]ese))$/, '$1')
+    inflector.plural(/(\w*(ax|test))is$/, '$1es')
+    inflector.plural(/(\w*(alias|[^aou]us|tlas|gas|ris))$/, '$1es')
+    inflector.plural(/(\w*(e[mn]u))s?$/, '$1s')
+    inflector.plural(/(\w*([^l]ias|[aeiou]las|[emjzr]as|[iu]am))$/, '$1')
+    inflector.plural(
+        /(\w*(alumn|syllab|octop|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat))(?:us|i)$/,
+        '$1i'
+    )
+    inflector.plural(/(\w*(alumn|alg|vertebr))(?:a|ae)$/, '$1ae')
+    inflector.plural(/(\w*(seraph|cherub))(?:im)?$/, '$1im')
+    inflector.plural(/(\w*(her|at|gr))o$/, '$1oes')
+    inflector.plural(
+        /(\w*(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor))(?:a|um)$/,
+        '$1a'
+    )
+    inflector.plural(
+        /(\w*(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat))(?:a|on)$/,
+        '$1a'
+    )
+    inflector.plural(/(\w*)sis$/, '$1ses')
+    inflector.plural(/(\w*(kni|wi|li))fe$/, '$1ves')
+    inflector.plural(/(\w*(ar|l|ea|eo|oa|hoo))f$/, '$1ves')
+    inflector.plural(/(\w*([^aeiouy]|qu))y$/, '$1ies')
+    inflector.plural(/(\w*([^ch][ieo][ln]))ey$/, '$1ies')
+    inflector.plural(/(\w*(x|ch|ss|sh|zz)es)$/, '$1')
+    inflector.plural(/(\w*(x|ch|ss|sh|zz))$/, '$1es')
+    inflector.plural(/(\w*(matr|cod|mur|sil|vert|ind|append))(?:ix|ex)$/, '$1ices')
+    inflector.plural(/(\w*(m|l)(?:ice|ouse))$/, '$1ice')
+    inflector.plural(/(\w*(pe)(?:rson|ople))$/, '$1ople')
+    inflector.plural(/(\w*(child))(?:ren)?$/, '$1ren')
+    inflector.plural(/(\w*eaux)$/, '$1')
+
+    inflector.irregular('ox', 'oxes')
+    inflector.irregular('man', 'men')
+    inflector.irregular('woman', 'women')
+    inflector.irregular('die', 'dice')
+    inflector.irregular('yes', 'yeses')
+    inflector.irregular('foot', 'feet')
+    inflector.irregular('eave', 'eaves')
+    inflector.irregular('goose', 'geese')
+    inflector.irregular('tooth', 'teeth')
+    inflector.irregular('quiz', 'quizzes')
+
+    inflector.uncountable(
+        'accommodation',
+        'adulthood',
+        'advertising',
+        'advice',
+        'aggression',
+        'aid',
+        'air',
+        'aircraft',
+        'alcohol',
+        'anger',
+        'applause',
+        'arithmetic',
+        'assistance',
+        'athletics',
+
+        'bacon',
+        'baggage',
+        'beef',
+        'biology',
+        'blood',
+        'botany',
+        'bread',
+        'butter',
+
+        'carbon',
+        'cardboard',
+        'cash',
+        'chalk',
+        'chaos',
+        'chess',
+        'crossroads',
+        'countryside',
+
+        'dancing',
+        'deer',
+        'dignity',
+        'dirt',
+        'dust',
+
+        'economics',
+        'education',
+        'electricity',
+        'engineering',
+        'enjoyment',
+        'envy',
+        'equipment',
+        'ethics',
+        'evidence',
+        'evolution',
+
+        'fame',
+        'fiction',
+        'flour',
+        'flu',
+        'food',
+        'fuel',
+        'fun',
+        'furniture',
+
+        'gallows',
+        'garbage',
+        'garlic',
+        'genetics',
+        'gold',
+        'golf',
+        'gossip',
+        'grammar',
+        'gratitude',
+        'grief',
+        'guilt',
+        'gymnastics',
+
+        'happiness',
+        'hardware',
+        'harm',
+        'hate',
+        'hatred',
+        'health',
+        'heat',
+        'help',
+        'homework',
+        'honesty',
+        'honey',
+        'hospitality',
+        'housework',
+        'humour',
+        'hunger',
+        'hydrogen',
+
+        'ice',
+        'importance',
+        'inflation',
+        'information',
+        'innocence',
+        'iron',
+        'irony',
+
+        'jam',
+        'jewelry',
+        'judo',
+
+        'karate',
+        'knowledge',
+
+        'lack',
+        'laughter',
+        'lava',
+        'leather',
+        'leisure',
+        'lightning',
+        'linguine',
+        'linguini',
+        'linguistics',
+        'literature',
+        'litter',
+        'livestock',
+        'logic',
+        'loneliness',
+        'luck',
+        'luggage',
+
+        'macaroni',
+        'machinery',
+        'magic',
+        'management',
+        'mankind',
+        'marble',
+        'mathematics',
+        'mayonnaise',
+        'measles',
+        'methane',
+        'milk',
+        'money',
+        'mud',
+        'music',
+        'mumps',
+
+        'nature',
+        'news',
+        'nitrogen',
+        'nonsense',
+        'nurture',
+        'nutrition',
+
+        'obedience',
+        'obesity',
+        'oxygen',
+
+        'pasta',
+        'patience',
+        'physics',
+        'poetry',
+        'pollution',
+        'poverty',
+        'pride',
+        'psychology',
+        'publicity',
+        'punctuation',
+
+        'quartz',
+
+        'racism',
+        'relaxation',
+        'reliability',
+        'research',
+        'respect',
+        'revenge',
+        'rice',
+        'rubbish',
+        'rum',
+
+        'safety',
+        'scenery',
+        'seafood',
+        'seaside',
+        'series',
+        'shame',
+        'sheep',
+        'shopping',
+        'sleep',
+        'smoke',
+        'smoking',
+        'snow',
+        'soap',
+        'software',
+        'soil',
+        'spaghetti',
+        'species',
+        'steam',
+        'stuff',
+        'stupidity',
+        'sunshine',
+        'symmetry',
+
+        'tennis',
+        'thirst',
+        'thunder',
+        'timber',
+        'traffic',
+        'transportation',
+        'trust',
+
+        'underwear',
+        'unemployment',
+        'unity',
+
+        'validity',
+        'veal',
+        'vegetation',
+        'vegetarianism',
+        'vengeance',
+        'violence',
+        'vitality',
+
+        'warmth',
+        'wealth',
+        'weather',
+        'welfare',
+        'wheat',
+        'wildlife',
+        'wisdom',
+        'yoga',
+
+        'zinc',
+        'zoology'
+    )
+})
+
+export function toPlural(value: string) {
+    return pluralize(value, THEGRAPH_LOCALE)
+}

package/src/dialect/thegraph/orderBy.ts

@@ -0,0 +1,75 @@
+import assert from 'assert'
+import type {Model} from '../../model'
+import {getUniversalProperties} from '../../model.tools'
+import {OrderBy, SortOrder} from '../../ir/args'
+import {mergeOrderBy} from '../common'
+
+export type TheGraphOrderByValue = string
+
+export type TheGraph_OrderBy_List = ReadonlySet<TheGraphOrderByValue>
+
+const MAPPING_CACHE = new WeakMap<Model, Record<string, TheGraph_OrderBy_List>>()
+
+export function getOrderByList(model: Model, typeName: string): TheGraph_OrderBy_List {
+    let cache = MAPPING_CACHE.get(model)
+    if (cache == null) {
+        cache = {}
+        MAPPING_CACHE.set(model, cache)
+    }
+    if (cache[typeName]) return cache[typeName]
+    return (cache[typeName] = buildOrderByList(model, typeName, 2))
+}
+
+function buildOrderByList(model: Model, typeName: string, depth: number): TheGraph_OrderBy_List {
+    if (depth <= 0) return new Set()
+    let properties = getUniversalProperties(model, typeName)
+    let m = new Set<TheGraphOrderByValue>()
+    for (let key in properties) {
+        let propType = properties[key].type
+        switch (propType.kind) {
+            case 'scalar':
+            case 'enum':
+                if (propType.name != 'JSON') {
+                    m.add(key)
+                }
+                break
+            case 'object':
+            case 'union':
+                for (let name of buildOrderByList(model, propType.name, depth - 1)) {
+                    m.add(key + '__' + name)
+                }
+                break
+            case 'fk':
+            case 'lookup':
+                m.add(key)
+                for (let name of buildOrderByList(model, propType.entity, depth - 1)) {
+                    m.add(key + '__' + name)
+                }
+                break
+        }
+    }
+    return m
+}
+
+export const ORDER_DIRECTIONS: Record<string, SortOrder> = {
+    asc: 'ASC',
+    asc_nulls_first: 'ASC NULLS FIRST',
+    asc_nulls_last: 'ASC NULLS LAST',
+    desc: 'DESC',
+    desc_nulls_first: 'DESC NULLS FIRST',
+    desc_nulls_last: 'DESC NULLS LAST',
+}
+
+export function parseOrderBy(model: Model, typeName: string, input: {orderBy: string; direction?: string}): OrderBy {
+    let list = getOrderByList(model, typeName)
+    assert(list.has(input.orderBy))
+
+    const sortOrder = input.direction ? ORDER_DIRECTIONS[input.direction] : ORDER_DIRECTIONS['asc']
+    assert(sortOrder)
+
+    const keys = input.orderBy.split('__').reverse()
+    const res = keys.reduce((res: OrderBy | null, key) => ({[key]: res ?? sortOrder}), null)
+    assert(res)
+
+    return res
+}