@subsquid/openreader 0.2.1 → 0.4.0

package/src/model.ts

@@ -0,0 +1,137 @@
+export type Name = string
+
+
+export type Model = Record<Name, Entity | JsonObject | Interface | Union | Enum | FTS_Query>
+
+
+export interface Entity extends TypeMeta {
+    kind: 'entity'
+    properties: Record<Name, Prop>
+    interfaces?: Name[]
+    indexes?: Index[]
+}
+
+
+export interface JsonObject extends TypeMeta {
+    kind: 'object'
+    properties: Record<Name, Prop>
+    interfaces?: Name[]
+}
+
+
+export interface Interface extends TypeMeta {
+    kind: 'interface'
+    properties: Record<Name, Prop>
+}
+
+
+export interface Union extends TypeMeta {
+    kind: 'union'
+    variants: Name[]
+}
+
+
+export interface Enum extends TypeMeta {
+    kind: 'enum'
+    values: Record<string, {}>
+}
+
+
+export interface TypeMeta {
+    description?: string
+}
+
+
+export interface Prop {
+    type: PropType
+    nullable: boolean
+    description?: string
+    /**
+     * Whether the values in the column must be unique. Applicable only to entities.
+     */
+    unique?: boolean
+}
+
+
+export type PropType =
+    ScalarPropType |
+    EnumPropType |
+    ListPropType |
+    ObjectPropType |
+    UnionPropType |
+    FkPropType |
+    LookupPropType |
+    ListLookupPropType
+
+
+export interface ScalarPropType {
+    kind: 'scalar'
+    name: Name
+}
+
+
+export interface EnumPropType {
+    kind: 'enum'
+    name: Name
+}
+
+
+export interface ObjectPropType {
+    kind: 'object'
+    name: Name
+}
+
+
+export interface UnionPropType {
+    kind: 'union'
+    name: Name
+}
+
+
+export interface ListPropType {
+    kind: 'list'
+    item: Prop
+}
+
+
+export interface FkPropType {
+    kind: 'fk'
+    foreignEntity: Name
+}
+
+
+export interface LookupPropType {
+    kind: 'lookup'
+    entity: Name
+    field: Name
+}
+
+
+export interface ListLookupPropType {
+    kind: 'list-lookup'
+    entity: Name
+    field: Name
+}
+
+
+export interface FTS_Query {
+    kind: 'fts'
+    sources: FTS_Source[]
+}
+
+
+export interface FTS_Source {
+    entity: Name
+    fields: Name[]
+}
+
+
+export interface Index {
+    fields: IndexField[]
+    unique?: boolean
+}
+
+
+export interface IndexField {
+    name: string
+}

package/src/orderBy.ts

@@ -0,0 +1,105 @@
+import assert from "assert"
+import type {Model} from "./model"
+import {getUnionProps} from "./model.tools"
+
+
+export type SortOrder = 'ASC' | 'DESC'
+
+
+export interface OrderBy {
+    [field: string]: SortOrder | OrderBy
+}
+
+
+/**
+ * OpenCRUD orderBy enum value (e.g. foo_ASC)
+ */
+export type OpenCrudOrderByValue = string
+
+
+/**
+ * A mapping between OpenCRUD enum variants and OrderBy specs
+ */
+export type OpenCrud_OrderBy_Mapping = ReadonlyMap<OpenCrudOrderByValue, OrderBy>
+
+
+const MAPPING_CACHE = new WeakMap<Model, Record<string, OpenCrud_OrderBy_Mapping>>()
+
+
+export function getOrderByMapping(model: Model, entityName: string): OpenCrud_OrderBy_Mapping {
+    let cache = MAPPING_CACHE.get(model)
+    if (cache == null) {
+        cache = {}
+        MAPPING_CACHE.set(model, cache)
+    }
+    if (cache[entityName]) return cache[entityName]
+    return cache[entityName] = buildOrderByMapping(model, entityName, 2)
+}
+
+
+function buildOrderByMapping(model: Model, typeName: string, depth: number): OpenCrud_OrderBy_Mapping {
+    if (depth <= 0) return new Map()
+    let object = model[typeName]
+    if (object.kind == 'union') {
+        object = getUnionProps(model, typeName)
+    }
+    assert(object.kind == 'entity' || object.kind == 'object')
+    let m = new Map<string, OrderBy>()
+    for (let key in object.properties) {
+        let propType = object.properties[key].type
+        switch(propType.kind) {
+            case 'scalar':
+            case 'enum':
+                m.set(key + '_ASC', {[key]: 'ASC'})
+                m.set(key + '_DESC', {[key]: 'DESC'})
+                break
+            case 'object':
+            case 'union':
+                for (let [name, spec] of buildOrderByMapping(model, propType.name, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+            case 'fk':
+                for (let [name, spec] of buildOrderByMapping(model, propType.foreignEntity, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+            case 'lookup':
+                for (let [name, spec] of buildOrderByMapping(model, propType.entity, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+        }
+    }
+    return m
+}
+
+
+export function parseOrderBy(model: Model, entityName: string, input: OpenCrudOrderByValue[]): OrderBy {
+    let mapping = getOrderByMapping(model, entityName)
+    return mergeOrderBy(
+        input.map(value => {
+            let spec = mapping.get(value)
+            assert(spec != null)
+            return spec
+        })
+    )
+}
+
+
+export function mergeOrderBy(list: OrderBy[]): OrderBy {
+    let result: OrderBy = {}
+    list.forEach(item => {
+        for (let key in item) {
+            let current = result[key]
+            if (current == null ) {
+                result[key] = item[key]
+            } else if (typeof current != 'string') {
+                let it = item[key]
+                assert(typeof it == 'object')
+                result[key] = mergeOrderBy([current, it])
+            }
+        }
+    })
+    return result
+}