Successful first run on major revamp

Author: ox-harris

src/clients/abstracts/AbstractSQLClient.js

@@ -0,0 +1,65 @@
+import { SimpleEmitter } from './SimpleEmitter.js';
+
+export class LinkedQLClient extends SimpleEmitter {
+    
+    #dialect;
+    #options;
+
+    #capabilityOverride;
+    #workingCapability;
+
+    get dialect() { return this.#dialect; }
+    get options() { return this.#options; }
+
+    constructor({ dialect, capability = {}, ...options } = {}) {
+        super();
+        
+        this.#dialect = dialect;
+        this.#options = options;
+
+        this.#capabilityOverride = capability;
+        this.#workingCapability = capability;
+    }
+
+    async connect() { }
+
+    async disconnect() { }
+
+    async setCapability(capMap) {
+        const _capMap = Object.fromEntries(
+            Object.entries(capMap).filter(([k, v]) => {
+                return !v || this.#capabilityOverride[k] !== false;
+            })
+        );
+
+        // Publish...
+        this.#workingCapability = {
+            ...this.#workingCapability,
+            ..._capMap,
+        };
+
+        // realtime?
+        if (_capMap.realtime === false) {
+            await this._teardownRealtime?.();
+        } else if (_capMap.realtime) {
+            await this._setupRealtime?.();
+        }
+
+        return _capMap;
+    }
+
+    // ------------
+
+    #lifetimeSchemaInference;
+
+    resolveGetResolver(cb) {
+        if (this.#options.nonDDLMode) {
+            // We've been promised no DDL operations will
+            // happen while we're running
+            if (!this.#lifetimeSchemaInference)
+                this.#lifetimeSchemaInference = cb();
+            return this.#lifetimeSchemaInference;
+        }
+        return cb();
+    }
+}

src/clients/abstracts/LinkedQLClient.js

@@ -1,73 +1,59 @@
-import { AbstractSQLClient } from './AbstractSQLClient.js';
+import { LinkedQLClient } from './LinkedQLClient.js';
 import { RealtimeClient } from '../../proc/realtime/RealtimeClient.js';
 import { SchemaInference } from './SchemaInference.js';
 import { SyncEngine } from '../../proc/sync/SyncEngine.js';
 import { SQLParser } from '../../lang/SQLParser.js';
+import { registry } from '../../lang/registry.js';
 import { normalizeQueryArgs } from './util.js';
 import { Result } from '../Result.js';
-import { registry } from '../../lang/registry.js';
 
-export class MainstreamSQLClient extends AbstractSQLClient {
+export class MainstreamDBClient extends LinkedQLClient {
+
+    // Standard getters: parsers, resolver, sync
 
     #parser;
     #sync;
-    #realtimeClient;
 
     get parser() { return this.#parser; }
+    get resolver() {
+        return super.resolveGetResolver(() =>
+            new SchemaInference({ client: this }));
+    }
     get sync() { return this.#sync; }
-    get realtimeClient() { return this.#realtimeClient; }
 
-    async connect() {
-        if (this.#parser) return;
+    // Internal
+    
+    #realtimeClient;
+
+    // ------------
+
+    constructor(options) {
+        super(options);
 
         this.#parser = new SQLParser({ dialect: this.dialect });
         this.#sync = new SyncEngine({
-            dialect: this.dialect,
             drainMode: 'drain',
             lifecycleHook: async (status) => {
                 await this.setCapability({ realtime: !!status });
             }
         });
 
         this.#realtimeClient = new RealtimeClient(this);
-        await super.connect();
     }
 
     async disconnect() {
-        await super.disconnect();
         await this.#sync.close({ destroy: true });
+        await super.disconnect();
     }
 
-    async setCapability(capMap) {
-        capMap = await super.setCapability(capMap);
-        // realtime?
-        if (capMap.realtime === false) {
-            await this._teardownRealtime();
-        } else if (capMap.realtime) {
-            await this._setupRealtime();
-        }
-        return capMap;
-    }
-
-    #lifetimeSchemaInference;
-
-    createSchemaInference() {
-        if (this.options.nonDDLMode) {
-            // We've been promised no DDL operations will
-            // happen while we're running
-            if (!this.#lifetimeSchemaInference)
-                this.#lifetimeSchemaInference = new SchemaInference({ client: this });
-            return this.#lifetimeSchemaInference;
-        }
-        return new SchemaInference({ client: this });
-    }
+    // ------------
 
     async query(...args) {
         const [_query, options] = normalizeQueryArgs(...args);
         const query = await this.#parser.parse(_query, options);
 
         const resolveQuery = async (query, tx = null) => {
-            const schemaInference = this.createSchemaInference();
+            const schemaInference = this.resolver;
             return await schemaInference.resolveQuery(query, { tx });
         };
 
@@ -104,7 +90,7 @@ export class MainstreamSQLClient extends AbstractSQLClient {
         const [_query, options] = normalizeQueryArgs(...args);
         const query = await this.#parser.parse(_query, options);
 
-        const schemaInference = this.createSchemaInference();
+        const schemaInference = this.resolver;
         const resolvedQuery = await schemaInference.resolveQuery(query, options);
 
         return await this._stream(resolvedQuery, options);