fix(openreader): Use READ COMMITTED to allow the usage of PostgreSQL replicas

graphql/graphql-server/docker-compose.yml

@@ -12,7 +12,7 @@ services:
     command: ["postgres", "-c", "log_statement=all"]
 
   cockroach:
-    image: cockroachdb/cockroach:v21.2.9
+    image: cockroachdb/cockroach:v23.2.2
     ports:
       - "${DB_PORT_COCKROACH}:26257"
     command: ["start-single-node", "--insecure"]

graphql/graphql-server/src/main.ts

@@ -21,6 +21,7 @@ runProgram(async () => {
     program.option('--max-response-size <nodes>', 'max response size measured in nodes', nat)
     program.option('--sql-statement-timeout <ms>', 'sql statement timeout in ms', nat)
     program.option('--validation-max-errors <count>', 'max validation errors', nat)
+    program.addOption(new Option('--isolation-level <level>', 'transaction isolation level').choices(['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED']))
     program.option('--subscriptions', 'enable gql subscriptions')
     program.option('--subscription-poll-interval <ms>', 'subscription poll interval in ms', nat, 5000)
     program.option('--subscription-max-response-size <nodes>', 'max response size measured in nodes', nat)
@@ -46,6 +47,7 @@ runProgram(async () => {
         validationMaxErrors?: number
         tsNode?: boolean
         dialect?: Dialect
+        isolationLevel: 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
     }
 
     await registerTsNodeIfRequired()

graphql/graphql-server/src/server.ts

@@ -39,6 +39,7 @@ export interface ServerOptions {
     validationMaxErrors?: number
     dumbCache?: DumbRedisCacheOptions | DumbInMemoryCacheOptions
     dialect?: Dialect
+    isolationLevel?: 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
 }
 
 
@@ -244,6 +245,7 @@ export class Server {
                     pool,
                     pool,
                     this.options.subscriptionPollInterval,
+                    this.options.isolationLevel,
                     this.options.log
                 )
             }

graphql/openreader/docker-compose.yml

@@ -10,7 +10,7 @@ services:
     command: ["postgres", "-c", "log_statement=all"]
 
   cockroach:
-    image: cockroachdb/cockroach:v21.2.9
+    image: cockroachdb/cockroach:v23.2.2
     ports:
       - "${DB_PORT_COCKROACH}:26257"
     command: [

graphql/openreader/src/db.ts

@@ -14,6 +14,8 @@ let CTX_COUNTER = 0
 export type DbType = 'postgres' | 'cockroach'
 
 
+export type TransactionIsolationLevel = 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
+
 export class PoolOpenreaderContext implements OpenreaderContext {
     public id = (CTX_COUNTER = (CTX_COUNTER + 1) % Number.MAX_SAFE_INTEGER)
     public log?: Logger
@@ -26,6 +28,7 @@ export class PoolOpenreaderContext implements OpenreaderContext {
         pool: Pool,
         subscriptionPool?: Pool,
         private subscriptionPollInterval: number = 1000,
+        private isolationLevel: TransactionIsolationLevel = 'SERIALIZABLE',
         log?: Logger
     ) {
         this.log = log?.child({graphqlCtx: this.id})
@@ -53,7 +56,7 @@ export class PoolOpenreaderContext implements OpenreaderContext {
     private async transact<T>(pool: Pool, cb: (db: Database) => Promise<T>): Promise<T> {
         let client = await pool.connect()
         try {
-            await this.query(client, 'START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY')
+            await this.query(client, `START TRANSACTION ISOLATION LEVEL ${this.isolationLevel} READ ONLY`)
             try {
                 return await cb(async (sql, parameters) => {
                     let result = await this.query(client, sql, parameters)

graphql/openreader/src/main.ts

@@ -33,6 +33,7 @@ GraphQL server for postgres-compatible databases
     program.option('--subscriptions', 'enable gql subscriptions')
     program.option('--subscription-poll-interval <ms>', 'subscription poll interval in ms', nat, 1000)
     program.option('--subscription-max-response-size <nodes>', 'max response size measured in nodes', nat)
+    program.addOption(new Option('--isolation-level <level>', 'transaction isolation level').choices(['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED']))
 
     let opts = program.parse().opts() as {
         schema: string
@@ -47,6 +48,7 @@ GraphQL server for postgres-compatible databases
         subscriptions?: boolean
         subscriptionPollInterval: number
         subscriptionMaxResponseSize?: number
+        isolationLevel: 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
     }
 
     let model = loadModel(opts.schema)
@@ -68,7 +70,8 @@ GraphQL server for postgres-compatible databases
         subscriptions: opts.subscriptions,
         subscriptionPollInterval: opts.subscriptionPollInterval,
         subscriptionMaxResponseNodes: opts.subscriptionMaxResponseSize,
-        validationMaxErrors: opts.validationMaxErrors
+        validationMaxErrors: opts.validationMaxErrors,
+        isolationLevel: opts.isolationLevel
     })
 
     LOG.info(`listening on port ${server.port}`)

graphql/openreader/src/server.ts

@@ -36,6 +36,7 @@ export interface ServerOptions {
     subscriptionMaxResponseNodes?: number
     validationMaxErrors?: number
     cache?: KeyValueCache
+    isolationLevel?: 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
 }
 
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
@@ -54,12 +55,15 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
     let schemaBuilder = await getSchemaBuilder(options)
     let schema = schemaBuilder.build()
 
+    let isolationLevel = options.isolationLevel ?? 'SERIALIZABLE'
+
     let context = () => {
         let openreader: OpenreaderContext = new PoolOpenreaderContext(
             dbType,
             connection,
             subscriptionConnection,
             subscriptionPollInterval,
+            isolationLevel,
             log
         )