@subsquid/openreader 0.5.1 → 0.7.1

package/src/resolver.ts

@@ -4,6 +4,8 @@ import {UserInputError} from "apollo-server-core"
 import assert from "assert"
 import type {GraphQLResolveInfo} from "graphql"
 import type {Database, Transaction} from "./db"
+import type {Dialect} from "./dialect"
+import {customScalars} from "./gql/scalars"
 import type {Entity, JsonObject, Model} from "./model"
 import {QueryBuilder} from "./queryBuilder"
 import {
@@ -15,7 +17,6 @@ import {
     PageInfo
 } from "./relayConnection"
 import {connectionRequestedFields, ftsRequestedFields, requestedFields} from "./requestedFields"
-import {getScalarResolvers} from "./scalars"
 import {ensureArray, toQueryListField, unsupportedCase} from "./util"
 
 
@@ -24,9 +25,9 @@ export interface ResolverContext {
 }
 
 
-export function buildResolvers(model: Model): IResolvers<unknown, ResolverContext> {
+export function buildResolvers(model: Model, dialect: Dialect): IResolvers<unknown, ResolverContext> {
     let Query: Record<string, IFieldResolver<unknown, ResolverContext>> = {}
-    let resolvers: IResolvers = {Query, ...getScalarResolvers()}
+    let resolvers: IResolvers = {Query, ...customScalars}
 
     for (let name in model) {
         let item = model[name]
@@ -35,16 +36,16 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[toQueryListField(name)] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    return new QueryBuilder(model, db).executeSelect(name, args, fields)
+                    return new QueryBuilder(model, dialect, db).executeSelect(name, args, fields)
                 }
                 Query[toQueryListField(name) + 'Connection'] = async (source, args, context, info) => {
                     let db = await context.openReaderTransaction.get()
-                    return resolveEntityConnection(model, name, args, info, db)
+                    return resolveEntityConnection(model, dialect, name, args, info, db)
                 }
                 Query[`${toCamelCase(name)}ById`] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    let result = await new QueryBuilder(model, db)
+                    let result = await new QueryBuilder(model, dialect, db)
                         .executeSelect(name, {where: {id_eq: args.id}}, fields)
                     assert(result.length < 2)
                     return result[0]
@@ -52,7 +53,7 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[`${toCamelCase(name)}ByUniqueInput`] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    let result = await new QueryBuilder(model, db)
+                    let result = await new QueryBuilder(model, dialect, db)
                         .executeSelect(name, {where: {id_eq: args.where.id}}, fields)
                     assert(result.length < 2)
                     return result[0]
@@ -71,7 +72,7 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[name] = async (source, args, context, info) => {
                     let fields = ftsRequestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    return new QueryBuilder(model, db).executeFulltextSearch(name, args, fields)
+                    return new QueryBuilder(model, dialect, db).executeFulltextSearch(name, args, fields)
                 }
                 resolvers[`${name}_Item`] = {
                     __resolveType: resolveUnionType
@@ -130,6 +131,7 @@ interface ConnectionResponse extends RelayConnectionResponse<any> {
 
 async function resolveEntityConnection(
     model: Model,
+    dialect: Dialect,
     entityName: string,
     args: ConnectionArgs,
     info: GraphQLResolveInfo,
@@ -162,7 +164,7 @@ async function resolveEntityConnection(
 
     let fields = connectionRequestedFields(model, entityName, info)
     if (fields.edges?.node) {
-        let nodes = await new QueryBuilder(model, db).executeSelect(entityName, listArgs, fields.edges.node)
+        let nodes = await new QueryBuilder(model, dialect, db).executeSelect(entityName, listArgs, fields.edges.node)
         let edges: ConnectionEdge<any>[] = new Array(Math.min(limit, nodes.length))
         for (let i = 0; i < edges.length; i++) {
             edges[i] = {
@@ -176,7 +178,7 @@ async function resolveEntityConnection(
             response.totalCount = offset + nodes.length
         }
     } else if (fields.edges?.cursor || fields.pageInfo) {
-        let listLength = await new QueryBuilder(model, db).executeListCount(entityName, listArgs)
+        let listLength = await new QueryBuilder(model, dialect, db).executeListCount(entityName, listArgs)
         response.pageInfo = pageInfo(listLength)
         if (fields.edges?.cursor) {
             response.edges = []
@@ -192,7 +194,7 @@ async function resolveEntityConnection(
     }
 
     if (fields.totalCount && response.totalCount == null) {
-        response.totalCount = await new QueryBuilder(model, db).executeSelectCount(entityName, listArgs.where)
+        response.totalCount = await new QueryBuilder(model, dialect, db).executeSelectCount(entityName, listArgs.where)
     }
 
     return response

package/src/server.ts

@@ -7,6 +7,7 @@ import http from "http"
 import path from "path"
 import type {Pool} from "pg"
 import {PoolTransaction} from "./db"
+import {Dialect} from "./dialect"
 import {buildServerSchema} from "./gql/opencrud"
 import type {Model} from "./model"
 import {buildResolvers} from "./resolver"
@@ -22,14 +23,16 @@ export interface ServerOptions {
     model: Model
     db: Pool
     port: number | string
+    dialect?: Dialect
     graphiqlConsole?: boolean
 }
 
 
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
     let {model, db} = options
-    let resolvers = buildResolvers(model)
-    let typeDefs = buildServerSchema(model)
+    let dialect = options.dialect ?? 'postgres'
+    let resolvers = buildResolvers(model, dialect)
+    let typeDefs = buildServerSchema(model, dialect)
     let app = express()
     let server = http.createServer(app)
 

package/src/test/basic.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('basic tests', function() {
@@ -44,11 +44,11 @@ describe('basic tests', function() {
     it('can fetch all accounts', function() {
         return client.test(
             `query {
-                accounts {
+                accounts(orderBy: id_ASC) {
                     id
                     wallet
                     balance
-                    history { balance }
+                    history(orderBy: id_ASC) { balance }
                 }
             }`,
             {

package/src/test/connection.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('relay connections', function () {
     useDatabase([

package/src/test/fts.test.ts

@@ -1,10 +1,12 @@
-import {useDatabase, useServer} from "./util/setup"
+import {isCockroach, useDatabase, useServer} from "./setup"
+
 
 function tsvector(columns: string[]) {
     return columns.map(col => `setweight(to_tsvector('english', coalesce(${col}, '')), 'A')`).join(' || ')
 }
 
-describe('full text search', function () {
+
+isCockroach() || describe('full text search', function () {
     useDatabase([
         `create table foo (
             id text primary key, 

package/src/test/isNull.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('isNull operator', function() {

package/src/test/lists.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('lists', function () {
@@ -172,8 +172,8 @@ describe('lists', function () {
             `, {
                 lists: [{
                     datetimeArray: [
-                        '2020-01-01T00:00:00.000Z',
-                        '2021-01-01T00:00:00.000Z'
+                        '2020-01-01T00:00:00.000000Z',
+                        '2021-01-01T00:00:00.000000Z'
                     ]
                 }]
             })

package/src/test/lookup.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {isCockroach, useDatabase, useServer} from "./setup"
 
 describe('lookup test', function () {
     useDatabase([
@@ -82,16 +82,22 @@ describe('lookup test', function () {
     it('supports sorting on lookup fields', function () {
         return client.test(`
             query {
-                issues(orderBy: [payment_amount_DESC]) {
+                issues(orderBy: [payment_amount_ASC]) {
                     id
                 }
             }
         `, {
-            issues: [
-                {id: '3'},
-                {id: '1'},
-                {id: '2'}
-            ]
+            issues: isCockroach()
+                ? [
+                    {id: '3'},
+                    {id: '2'},
+                    {id: '1'}
+                ]
+                : [
+                    {id: '2'},
+                    {id: '1'},
+                    {id: '3'}
+                ]
         })
     })
 

package/src/test/regressions.test.ts

@@ -0,0 +1,39 @@
+import {useDatabase, useServer} from "./setup"
+
+describe('regressions', function () {
+    describe('empty lookup lists', function () {
+        useDatabase([
+            `create table "order" (id text primary key)`,
+            `create table item (id text primary key, order_id text)`,
+            `insert into "order" (id) values ('1')`
+        ])
+
+        const client = useServer(`
+            type Order @entity {
+                id: ID!
+                items: [Item!]! @derivedFrom(field: "order")
+            }
+            
+            type Item @entity {
+                id: ID!
+                order: Order
+            }
+        `)
+
+        it('should return empty array for empty lookup list', async function () {
+            return client.test(`
+                query {
+                    orders {
+                        id
+                        items { id }
+                    }
+                }
+            `, {
+                orders: [{
+                    id: '1',
+                    items: []
+                }]
+            })
+        })
+    })
+})

package/src/test/scalars.test.ts

@@ -1,8 +1,8 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('scalars', function() {
     useDatabase([
-        `create table scalar (id text primary key, "boolean" bool, "bigint" numeric, "string" text, enum text, date_time timestamptz, "bytes" bytea, deep jsonb)`,
+        `create table scalar (id text primary key, "boolean" bool, "bigint" numeric, "string" text, enum text, date_time timestamptz, "bytes" bytea, "json" jsonb, deep jsonb)`,
         `insert into scalar (id, "boolean") values ('1', true)`,
         `insert into scalar (id, "boolean", deep) values ('2', false, '{"boolean": true}'::jsonb)`,
         `insert into scalar (id, "bigint", deep) values ('3', 1000000000000000000000000000000000000, '{"bigint": "1000000000000000000000000000000000000"}'::jsonb)`,
@@ -12,6 +12,7 @@ describe('scalars', function() {
         `insert into scalar (id, "string") values ('7', 'bar baz foo')`,
         `insert into scalar (id, "string") values ('8', 'baz foo bar')`,
         `insert into scalar (id, "string") values ('9', 'hello')`,
+        `insert into scalar (id, "string") values ('9-1', 'A fOo B')`,
         `insert into scalar (id, "date_time", deep) values ('10', '2021-09-24T15:43:13.400Z', '{"dateTime": "2021-09-24T00:00:00.120Z"}'::jsonb)`,
         `insert into scalar (id, "date_time", deep) values ('11', '2021-09-24T00:00:00.000Z', '{"dateTime": "2021-09-24T00:00:00Z"}'::jsonb)`,
         `insert into scalar (id, "date_time", deep) values ('12', '2021-09-24 02:00:00.001 +01:00', '{"dateTime": "2021-09-24T00:00:00.1Z"}'::jsonb)`,
@@ -20,6 +21,8 @@ describe('scalars', function() {
         `insert into scalar (id, "enum") values ('15', 'A')`,
         `insert into scalar (id, "enum") values ('16', 'B')`,
         `insert into scalar (id, "enum") values ('17', 'C')`,
+        `insert into scalar (id, "json") values ('18', '{"key1": "value1"}'::jsonb)`,
+        `insert into scalar (id, "json") values ('19', '{"key2": "value2"}'::jsonb)`,
     ])
 
     const client = useServer(`
@@ -31,6 +34,7 @@ describe('scalars', function() {
             bigint: BigInt
             dateTime: DateTime
             bytes: Bytes
+            json: JSON,
             deep: DeepScalar
         }
         
@@ -106,16 +110,18 @@ describe('scalars', function() {
                     not_ends_with: scalars(where: {string_not_endsWith: "foo"} orderBy: id_ASC) { id }
                     contains: scalars(where: {string_contains: "foo"} orderBy: id_ASC) { id }
                     not_contains: scalars(where: {string_not_contains: "foo"} orderBy: id_ASC) { id }
-                    case_sensitive: scalars(where: {string_contains: "Foo"} orderBy: id_ASC) { id }
+                    contains_insensitive: scalars(where: {string_containsInsensitive: "FoO"} orderBy: id_ASC) { id }
+                    not_contains_insensitive: scalars(where: {string_not_containsInsensitive: "FoO"} orderBy: id_ASC) { id }
                 }
             `, {
                 starts_with: [{id: '6'}],
-                not_starts_with: [{id: '7'}, {id: '8'}, {id: '9'}],
+                not_starts_with: [{id: '7'}, {id: '8'}, {id: '9'}, {id: '9-1'}],
                 ends_with: [{id: '7'}],
-                not_ends_with: [{id: '6'}, {id: '8'}, {id: '9'}],
+                not_ends_with: [{id: '6'}, {id: '8'}, {id: '9'}, {id: '9-1'}],
                 contains: [{id: '6'}, {id: '7'}, {id: '8'}],
-                not_contains: [{id: '9'}],
-                case_sensitive: []
+                not_contains: [{id: '9'}, {id: '9-1'}],
+                contains_insensitive: [{id: '6'}, {id: '7'}, {id: '8'}, {id: '9-1'}],
+                not_contains_insensitive: [{id: '9'}]
             })
         })
     })
@@ -239,9 +245,9 @@ describe('scalars', function() {
                 }
             `, {
                 scalars: [
-                    {id: '10', dateTime: '2021-09-24T15:43:13.400Z', deep: {dateTime: '2021-09-24T00:00:00.120Z'}},
-                    {id: '11', dateTime: '2021-09-24T00:00:00.000Z', deep: {dateTime: '2021-09-24T00:00:00Z'}},
-                    {id: '12', dateTime: '2021-09-24T01:00:00.001Z', deep: {dateTime: '2021-09-24T00:00:00.1Z'}}
+                    {id: '10', dateTime: '2021-09-24T15:43:13.400000Z', deep: {dateTime: '2021-09-24T00:00:00.120Z'}},
+                    {id: '11', dateTime: '2021-09-24T00:00:00.000000Z', deep: {dateTime: '2021-09-24T00:00:00Z'}},
+                    {id: '12', dateTime: '2021-09-24T01:00:00.001000Z', deep: {dateTime: '2021-09-24T00:00:00.1Z'}}
                 ]
             })
         })
@@ -313,4 +319,37 @@ describe('scalars', function() {
             })
         })
     })
+
+    describe('JSON', function () {
+        it('outputs correctly', function() {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["18"]}, orderBy: id_ASC) {
+                        id
+                        json
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '18', json: {'key1': 'value1'}},
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    eq: scalars(where: {json_eq: {key1: "value1"}}) { id }
+                    jsonHasKey: scalars(where: {json_jsonHasKey: "key1"}) { id }
+                    jsonContains: scalars(where: {json_jsonContains: {key2: "value2"}}) { id }
+                    missingKey: scalars(where: {json_jsonHasKey: {foo: 1}}) { id }
+                }
+            `, {
+                eq: [{id: '18'}],
+                jsonHasKey: [{id: '18'}],
+                jsonContains: [{id: '19'}],
+                missingKey: []
+            })
+        })
+    })
 })

package/src/test/{util/setup.ts → setup.ts}

@@ -1,12 +1,25 @@
+import {assertNotNull} from "@subsquid/util"
 import {Client} from "gql-test-client"
 import {parse} from "graphql"
 import {Client as PgClient, ClientBase, Pool} from "pg"
-import {createPoolConfig} from "../../db"
-import {buildModel, buildSchema} from "../../gql/schema"
-import {ListeningServer, serve} from "../../server"
+import {buildModel, buildSchema} from "../gql/schema"
+import {ListeningServer, serve} from "../server"
 
 
-export const db_config = createPoolConfig()
+export function isCockroach(): boolean {
+    return process.env.DB_TYPE == 'cockroach'
+}
+
+
+export const db_config = {
+    host: 'localhost',
+    port: parseInt(assertNotNull(
+        isCockroach() ? process.env.DB_PORT_COCKROACH : process.env.DB_PORT_PG
+    )),
+    user: 'root',
+    password: 'root',
+    database: 'defaultdb'
+}
 
 
 async function withClient(block: (client: ClientBase) => Promise<void>): Promise<void> {
@@ -31,8 +44,8 @@ export function databaseInit(sql: string[]): Promise<void> {
 
 export function databaseDelete(): Promise<void> {
     return withClient(async client => {
-        await client.query(`DROP SCHEMA IF EXISTS public CASCADE`)
-        await client.query(`CREATE SCHEMA public`)
+        await client.query(`DROP SCHEMA IF EXISTS root CASCADE`)
+        await client.query(`CREATE SCHEMA root`)
     })
 }
 
@@ -53,7 +66,8 @@ export function useServer(schema: string): Client {
         info = await serve({
             db,
             model: buildModel(buildSchema(parse(schema))),
-            port: 0
+            port: 0,
+            dialect: isCockroach() ? 'cockroach' : 'postgres'
         })
         client.endpoint = `http://localhost:${info.port}/graphql`
     })

package/src/test/typed-json.test.ts

@@ -1,9 +1,9 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('typed json fields', function () {
     useDatabase([
         `create table entity (id text primary key, a jsonb)`,
-        `insert into entity (id, a) values ('1', '{"a": "a", "b": {"b": "b", "e": "1"}}'::jsonb)`,
+        `insert into entity (id, a) values ('1', '{"a": "a", "b": {"b": "b", "e": "1"}, "c": [1, 2, 3]}'::jsonb)`,
         `insert into entity (id, a) values ('2', '{"a": "A", "b": {"b": "B", "e": "1"}}'::jsonb)`,
         `insert into entity (id, a) values ('3', '{}'::jsonb)`,
         `insert into entity (id) values ('4')`,
@@ -17,6 +17,7 @@ describe('typed json fields', function () {
         type A {
             a: String
             b: B
+            c: JSON
         }
         
         type B {
@@ -44,6 +45,20 @@ describe('typed json fields', function () {
         })
     })
 
+    it('nested JSON scalar', function () {
+        return client.test(`
+            query {
+                entities(where: {id_eq: "1"}) {
+                    a { c }
+                }
+            }
+        `, {
+            entities: [{
+                a: {c: [1, 2, 3]}
+            }]
+        })
+    })
+
     it('can fetch deep entities', function () {
         return client.test(`
             query {

package/src/test/unions.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('unions', function () {
     useDatabase([

package/src/test/where.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('AND, OR on entity filters', function () {
     useDatabase([

package/src/util.ts

@@ -37,3 +37,8 @@ export function toInt(val: number | string): number {
     assert(!isNaN(i) && isFinite(i))
     return i
 }
+
+
+export function invalidFormat(type: string, value: string): Error {
+    return new TypeError(`Not a ${type}: ${value}`)
+}

package/src/where.ts

@@ -9,6 +9,7 @@ export type WhereOp =
     'lte' |
     'in' | 'not_in' |
     'contains' | 'not_contains' |
+    'containsInsensitive' | 'not_containsInsensitive' |
     'startsWith' | 'not_startsWith' |
     'endsWith' | 'not_endsWith' |
     'containsAll' |
@@ -16,7 +17,9 @@ export type WhereOp =
     'containsNone' |
     'some' |
     'every' |
-    'none'
+    'none' |
+    'jsonContains' |
+    'jsonHasKey'
 
 
 const ENDINGS = [
@@ -31,6 +34,8 @@ const ENDINGS = [
     'not_in',
     'contains',
     'not_contains',
+    'containsInsensitive',
+    'not_containsInsensitive',
     'startsWith',
     'not_startsWith',
     'endsWith',
@@ -40,7 +45,9 @@ const ENDINGS = [
     'containsNone',
     'some',
     'every',
-    'none'
+    'none',
+    'jsonContains',
+    'jsonHasKey',
 ].sort((a, b) => b.length - a.length).map(e => '_' + e)
 
 

package/dist/scalars.d.ts

@@ -1,36 +0,0 @@
-/**
- * The current concept of custom scalars is as follows:
- *
- * Each custom scalar has a canonical string representation which is used almost everywhere:
- *    in JSON responses
- *    in graphql queries/schemas
- *    in jsonb database columns
- *    in database results
- *
- * Database must support 2 way coercion between underlying database type and canonical representation
- * of a corresponding scalar.
- *
- * We receive from database canonical strings and use them within our resolvers as is.
- *
- * GraphQL parsing procedures convert canonical string representation to corresponding js type.
- * This is for compatibility with possible extensions which would like to reuse our scalars.
- *
- * In GraphQL serialization procedures we accept both a canonical string representation
- * and corresponding js type.
- */
-import { GraphQLScalarType } from "graphql";
-export interface Scalar {
-    gql: GraphQLScalarType;
-    fromStringCast: (sqlExp: string) => string;
-    toStringCast: (sqlExp: string) => string;
-    toStringArrayCast: (sqlExp: string) => string;
-}
-export declare const scalars: Record<string, Scalar>;
-export declare const scalars_list: string[];
-export declare function getScalarResolvers(): Record<string, GraphQLScalarType>;
-export declare function toOutputCast(scalarType: string, sqlExp: string): string;
-export declare function fromStringCast(scalarType: string, sqlExp: string): string;
-export declare function toOutputArrayCast(scalarType: string, sqlExp: string): string;
-export declare function fromJsonCast(scalarType: string, objSqlExp: string, prop: string): string;
-export declare function fromJsonToOutputCast(scalarType: string, objSqlExp: string, prop: string): string;
-//# sourceMappingURL=scalars.d.ts.map

package/dist/scalars.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../src/scalars.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAC,iBAAiB,EAAC,MAAM,SAAS,CAAA;AAGzC,MAAM,WAAW,MAAM;IACnB,GAAG,EAAE,iBAAiB,CAAA;IACtB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAC1C,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IACxC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;CAChD;AAGD,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA0G1C,CAAA;AAyCD,eAAO,MAAM,YAAY,UAAsC,CAAA;AAG/D,wBAAgB,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAMtE;AAGD,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOvE;AAGD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOzE;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAO5E;AAGD,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAWxF;AAGD,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAWvF"}