turbine-orm 0.7.1 → 0.9.0

package/dist/cjs/client.js

@@ -134,9 +134,15 @@ class TransactionClient {
         // Return a minimal pool-compatible object that routes queries
         // through the transaction client
         return {
-            query: async (text, values) => {
+            query: async (textOrConfig, values) => {
                 try {
-                    return await client.query(text, values);
+                    if (typeof textOrConfig === 'string') {
+                        return await client.query(textOrConfig, values);
+                    }
+                    // Object form for prepared statements: { name, text, values }
+                    // pg.PoolClient.query accepts QueryConfig but the overloads make TS
+                    // unhappy with the union, so we cast through unknown.
+                    return await client.query(textOrConfig);
                 }
                 catch (err) {
                     throw (0, errors_js_1.wrapPgError)(err);
@@ -191,9 +197,13 @@ class TurbineClient {
         }
         this.logging = config.logging ?? false;
         this.schema = schema;
+        // Respect env var kill switch
+        const envDisablePrepared = typeof process !== 'undefined' && process.env?.TURBINE_DISABLE_PREPARED === '1';
         this.queryOptions = {
             defaultLimit: config.defaultLimit,
             warnOnUnlimited: config.warnOnUnlimited,
+            preparedStatements: envDisablePrepared ? false : (config.preparedStatements ?? !config.pool),
+            sqlCache: config.sqlCache ?? true,
         };
         // Apply NotFoundError message redaction mode (default: safe — values are
         // stripped from messages to avoid leaking PII into error logs).
@@ -307,13 +317,41 @@ class TurbineClient {
     /**
      * Execute multiple queries in a single database round-trip.
      *
-     * Pass the result of any `.build*()` method on a table accessor.
+     * Two call styles:
+     *   - `db.pipeline(q1, q2, q3)` — rest params (backward-compatible)
+     *   - `db.pipeline([q1, q2, q3], { transactional: false })` — array + options
+     *
+     * On pg.Pool-backed connections with TCP, this uses the real Postgres
+     * extended-query pipeline protocol (one TCP flush, one round-trip).
+     * On HTTP-based drivers it falls back to sequential execution.
      */
-    async pipeline(...queries) {
+    async pipeline(...args) {
+        let queries;
+        let options;
+        // Detect which overload was used
+        if (args.length > 0 &&
+            Array.isArray(args[0]) &&
+            args[0].every((item) => item && typeof item === 'object' && 'sql' in item)) {
+            // Array form: pipeline([q1, q2], opts?)
+            queries = args[0];
+            options = args[1];
+        }
+        else {
+            // Rest-param form: pipeline(q1, q2, q3)
+            queries = args;
+        }
         if (this.logging) {
             console.log(`[turbine] Pipeline: ${queries.length} queries — ${queries.map((q) => q.tag).join(', ')}`);
         }
-        return (0, pipeline_js_1.executePipeline)(this.pool, queries);
+        return (0, pipeline_js_1.executePipeline)(this.pool, queries, options);
+    }
+    /**
+     * Check whether the underlying pool supports the real pipeline protocol.
+     * Returns `true` for standard pg.Pool TCP connections, `false` for HTTP
+     * drivers (Neon HTTP, Vercel Postgres, etc.) and mock pools.
+     */
+    async pipelineSupported() {
+        return (0, pipeline_js_1.pipelineSupported)(this.pool);
     }
     // -------------------------------------------------------------------------
     // Raw SQL — tagged template literal escape hatch

package/dist/cjs/errors.js

@@ -6,7 +6,7 @@
  * All Turbine errors extend TurbineError which includes a `code` property.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckConstraintError = exports.SerializationFailureError = exports.DeadlockError = exports.NotNullViolationError = exports.ForeignKeyError = exports.UniqueConstraintError = exports.CircularRelationError = exports.MigrationError = exports.RelationError = exports.ConnectionError = exports.ValidationError = exports.TimeoutError = exports.NotFoundError = exports.TurbineError = exports.TurbineErrorCode = void 0;
+exports.PipelineError = exports.CheckConstraintError = exports.SerializationFailureError = exports.DeadlockError = exports.NotNullViolationError = exports.ForeignKeyError = exports.UniqueConstraintError = exports.CircularRelationError = exports.MigrationError = exports.RelationError = exports.ConnectionError = exports.ValidationError = exports.TimeoutError = exports.NotFoundError = exports.TurbineError = exports.TurbineErrorCode = void 0;
 exports.setErrorMessageMode = setErrorMessageMode;
 exports.getErrorMessageMode = getErrorMessageMode;
 exports.wrapPgError = wrapPgError;
@@ -25,6 +25,7 @@ exports.TurbineErrorCode = {
     CHECK_VIOLATION: 'TURBINE_E011',
     DEADLOCK_DETECTED: 'TURBINE_E012',
     SERIALIZATION_FAILURE: 'TURBINE_E013',
+    PIPELINE: 'TURBINE_E014',
 };
 /** Base error class for all Turbine errors */
 class TurbineError extends Error {
@@ -350,6 +351,47 @@ class CheckConstraintError extends TurbineError {
     }
 }
 exports.CheckConstraintError = CheckConstraintError;
+/**
+ * Thrown when a non-transactional pipeline has partial failures.
+ *
+ * In non-transactional mode (`{ transactional: false }`), each query executes
+ * independently. If one or more queries fail, the pipeline rejects with a
+ * `PipelineError` that carries per-query results so callers can inspect which
+ * succeeded and which failed.
+ *
+ * ```ts
+ * try {
+ *   await db.pipeline([q1, q2, q3], { transactional: false });
+ * } catch (err) {
+ *   if (err instanceof PipelineError) {
+ *     for (const slot of err.results) {
+ *       if (slot.status === 'error') console.error(slot.error);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class PipelineError extends TurbineError {
+    /** Per-query results: each slot is either `{status:'ok', value}` or `{status:'error', error}` */
+    results;
+    /** Zero-based index of the first query that failed */
+    failedIndex;
+    /** Tag of the first query that failed (from DeferredQuery.tag) */
+    failedTag;
+    constructor(opts) {
+        const { results, failedIndex, failedTag, cause } = opts;
+        const failedCount = results.filter((r) => r.status === 'error').length;
+        const message = opts.message ??
+            `[turbine] Pipeline completed with ${failedCount} error(s) out of ${results.length} queries` +
+                (failedTag ? ` (first failure: ${failedTag} at index ${failedIndex})` : '');
+        super(exports.TurbineErrorCode.PIPELINE, message, { cause });
+        this.name = 'PipelineError';
+        this.results = results;
+        this.failedIndex = failedIndex;
+        this.failedTag = failedTag;
+    }
+}
+exports.PipelineError = PipelineError;
 /**
  * Parse column names out of a pg `detail` string like:
  *   "Key (email)=(foo@bar) already exists."

package/dist/cjs/index.js

@@ -34,7 +34,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.executePipeline = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.setErrorMessageMode = exports.SerializationFailureError = exports.RelationError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.getErrorMessageMode = exports.ForeignKeyError = exports.DeadlockError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.TurbineClient = exports.TransactionClient = void 0;
+exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.pipelineSupported = exports.executePipeline = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.setErrorMessageMode = exports.SerializationFailureError = exports.RelationError = exports.PipelineError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.getErrorMessageMode = exports.ForeignKeyError = exports.DeadlockError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.TurbineClient = exports.TransactionClient = void 0;
 // Client
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return client_js_1.TransactionClient; } });
@@ -50,6 +50,7 @@ Object.defineProperty(exports, "getErrorMessageMode", { enumerable: true, get: f
 Object.defineProperty(exports, "MigrationError", { enumerable: true, get: function () { return errors_js_1.MigrationError; } });
 Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
 Object.defineProperty(exports, "NotNullViolationError", { enumerable: true, get: function () { return errors_js_1.NotNullViolationError; } });
+Object.defineProperty(exports, "PipelineError", { enumerable: true, get: function () { return errors_js_1.PipelineError; } });
 Object.defineProperty(exports, "RelationError", { enumerable: true, get: function () { return errors_js_1.RelationError; } });
 Object.defineProperty(exports, "SerializationFailureError", { enumerable: true, get: function () { return errors_js_1.SerializationFailureError; } });
 Object.defineProperty(exports, "setErrorMessageMode", { enumerable: true, get: function () { return errors_js_1.setErrorMessageMode; } });
@@ -68,6 +69,7 @@ Object.defineProperty(exports, "introspect", { enumerable: true, get: function (
 // Pipeline
 var pipeline_js_1 = require("./pipeline.js");
 Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return pipeline_js_1.executePipeline; } });
+Object.defineProperty(exports, "pipelineSupported", { enumerable: true, get: function () { return pipeline_js_1.pipelineSupported; } });
 // Query builder
 var query_js_1 = require("./query.js");
 Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_js_1.QueryInterface; } });

package/dist/cjs/pipeline-submittable.js

@@ -0,0 +1,403 @@
+"use strict";
+/**
+ * turbine-orm — Real Postgres pipeline protocol implementation
+ *
+ * Uses the pg extended-query protocol wire methods (parse/bind/describe/execute/sync)
+ * exposed on pg.Client's Connection object to send multiple queries in a single
+ * TCP flush. This achieves true 1-RTT pipeline execution instead of the sequential
+ * await-per-query approach.
+ *
+ * The approach (listener-swap):
+ *   1. Detach the pg.Client's event listeners from the Connection
+ *   2. Attach our own state-machine listeners
+ *   3. Cork the TCP stream, push all protocol messages, uncork (one TCP write)
+ *   4. Drive a state machine over backend response events
+ *   5. Restore original listeners and release the client
+ *
+ * This is the same pattern used by pg-cursor and pg-query-stream, but extended
+ * to handle N queries in a single pipeline.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipelined = runPipelined;
+exports.supportsExtendedPipeline = supportsExtendedPipeline;
+const result_1 = __importDefault(require("pg/lib/result"));
+const utils_1 = require("pg/lib/utils");
+const errors_js_1 = require("./errors.js");
+// ---------------------------------------------------------------------------
+// Event names we intercept
+// ---------------------------------------------------------------------------
+/**
+ * All backend message event names that the pg Client listens for.
+ * We snapshot, detach, and restore listeners for these events.
+ */
+const INTERCEPTED_EVENTS = [
+    'readyForQuery',
+    'rowDescription',
+    'dataRow',
+    'commandComplete',
+    'parseComplete',
+    'bindComplete',
+    'errorMessage',
+    'emptyQuery',
+    'portalSuspended',
+    'noData',
+    'notice',
+    'copyInResponse',
+    'copyData',
+];
+function snapshotListeners(emitter) {
+    const map = new Map();
+    for (const event of INTERCEPTED_EVENTS) {
+        const listeners = emitter.rawListeners(event);
+        if (listeners.length > 0) {
+            map.set(event, [...listeners]);
+        }
+    }
+    return map;
+}
+function detachListeners(emitter) {
+    for (const event of INTERCEPTED_EVENTS) {
+        emitter.removeAllListeners(event);
+    }
+}
+function restoreListeners(emitter, snapshot) {
+    for (const [event, listeners] of snapshot) {
+        for (const fn of listeners) {
+            emitter.on(event, fn);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Core pipeline execution
+// ---------------------------------------------------------------------------
+/**
+ * Execute multiple queries using the Postgres extended-query pipeline protocol.
+ *
+ * All protocol messages are buffered into a single TCP write via cork/uncork.
+ * The backend processes them in order and sends back results which our state
+ * machine collects.
+ *
+ * @param client - A pg PoolClient with an accessible Connection
+ * @param queries - Array of DeferredQuery descriptors
+ * @param options - Pipeline options (transactional, timeout)
+ * @returns Array of transformed results in the same order as queries
+ */
+async function runPipelined(client, queries, options = {}) {
+    const { transactional = true, timeout } = options;
+    const connection = client.connection;
+    // Snapshot and detach the Client's listeners
+    const savedListeners = snapshotListeners(connection);
+    detachListeners(connection);
+    // Block the Client from processing any queued queries while we own the connection
+    const savedReadyForQuery = client.readyForQuery;
+    client.readyForQuery = false;
+    return new Promise((resolve, reject) => {
+        // -----------------------------------------------------------------------
+        // State machine
+        // -----------------------------------------------------------------------
+        /**
+         * Total expected commandComplete events:
+         * - Transactional: BEGIN + N queries + COMMIT = N + 2
+         * - Non-transactional: N queries
+         */
+        const totalCommands = transactional ? queries.length + 2 : queries.length;
+        /**
+         * Expected readyForQuery events:
+         * - Transactional: 1 (single Sync at end)
+         * - Non-transactional: N (one Sync per query)
+         */
+        const expectedRfq = transactional ? 1 : queries.length;
+        // Results array: one Result per query (not counting BEGIN/COMMIT)
+        const results = [];
+        for (let i = 0; i < queries.length; i++) {
+            results.push(new result_1.default(undefined, client._types));
+        }
+        // commandComplete counter — tracks position across all commands
+        let commandIndex = 0;
+        // readyForQuery counter
+        let rfqCount = 0;
+        // First error encountered
+        let pipelineError = null;
+        // For non-transactional mode: per-query error tracking
+        const queryErrors = new Array(queries.length).fill(null);
+        // Timeout handle
+        let timeoutHandle;
+        // Whether cleanup has already been performed
+        let cleaned = false;
+        /**
+         * Map commandComplete index to the corresponding results[] index.
+         * In transactional mode: index 0 = BEGIN, 1..N = queries, N+1 = COMMIT
+         * In non-transactional mode: index maps 1:1
+         */
+        function commandToQueryIndex(cmdIdx) {
+            if (transactional) {
+                if (cmdIdx === 0 || cmdIdx === totalCommands - 1)
+                    return null;
+                return cmdIdx - 1;
+            }
+            return cmdIdx;
+        }
+        /** Get the current query-results index for row data */
+        function currentQueryIndex() {
+            return commandToQueryIndex(commandIndex);
+        }
+        // -----------------------------------------------------------------------
+        // Cleanup: restore listeners
+        // -----------------------------------------------------------------------
+        function cleanup() {
+            if (cleaned)
+                return;
+            cleaned = true;
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = undefined;
+            }
+            // Remove our listeners
+            detachListeners(connection);
+            // Restore original listeners
+            restoreListeners(connection, savedListeners);
+            // Restore readyForQuery so the Client can process its queue
+            client.readyForQuery = savedReadyForQuery;
+        }
+        // -----------------------------------------------------------------------
+        // Finalize: called on final readyForQuery
+        // -----------------------------------------------------------------------
+        function finalize() {
+            cleanup();
+            if (transactional && pipelineError) {
+                reject(pipelineError);
+                return;
+            }
+            if (!transactional && pipelineError) {
+                // In non-transactional mode, attach partial results to the error
+                const partialResults = [];
+                for (let i = 0; i < queries.length; i++) {
+                    const qErr = queryErrors[i];
+                    if (qErr) {
+                        partialResults.push({ status: 'error', error: qErr });
+                    }
+                    else {
+                        try {
+                            const q = queries[i];
+                            partialResults.push({ status: 'ok', value: q.transform(results[i]) });
+                        }
+                        catch (transformErr) {
+                            partialResults.push({ status: 'error', error: transformErr });
+                        }
+                    }
+                }
+                pipelineError.results = partialResults;
+                reject(pipelineError);
+                return;
+            }
+            // All succeeded — transform results
+            try {
+                const transformed = [];
+                for (let i = 0; i < queries.length; i++) {
+                    const q = queries[i];
+                    transformed.push(q.transform(results[i]));
+                }
+                resolve(transformed);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+        // -----------------------------------------------------------------------
+        // Event handlers
+        // -----------------------------------------------------------------------
+        function onParseComplete() {
+            // No action needed — anonymous prepared statements
+        }
+        function onBindComplete() {
+            // No action needed
+        }
+        function onNoData() {
+            // DML without RETURNING — no RowDescription follows. Fine.
+        }
+        function onRowDescription(msg) {
+            const qIdx = currentQueryIndex();
+            if (qIdx !== null && qIdx >= 0 && qIdx < results.length) {
+                results[qIdx].addFields(msg.fields);
+            }
+        }
+        function onDataRow(msg) {
+            const qIdx = currentQueryIndex();
+            if (qIdx !== null && qIdx >= 0 && qIdx < results.length) {
+                const result = results[qIdx];
+                const row = result.parseRow(msg.fields);
+                result.addRow(row);
+            }
+        }
+        function onCommandComplete(msg) {
+            const qIdx = currentQueryIndex();
+            if (qIdx !== null && qIdx >= 0 && qIdx < results.length) {
+                results[qIdx].addCommandComplete(msg);
+            }
+            commandIndex++;
+        }
+        function onEmptyQuery() {
+            // Treat like a commandComplete with no data
+            commandIndex++;
+        }
+        function onErrorMessage(msg) {
+            const wrapped = (0, errors_js_1.wrapPgError)(msg);
+            const error = wrapped instanceof Error ? wrapped : new Error(String(wrapped));
+            if (transactional) {
+                // In transactional mode, the first error aborts everything.
+                // Postgres marks the transaction as aborted; subsequent commands
+                // until Sync all return errors which we absorb.
+                if (!pipelineError) {
+                    const qIdx = currentQueryIndex();
+                    if (qIdx !== null && qIdx >= 0 && qIdx < queries.length) {
+                        error.failedIndex = qIdx;
+                        error.failedTag = queries[qIdx].tag;
+                    }
+                    pipelineError = error;
+                }
+            }
+            else {
+                // Non-transactional: record per-query error
+                const qIdx = currentQueryIndex();
+                if (qIdx !== null && qIdx >= 0 && qIdx < queries.length) {
+                    queryErrors[qIdx] = error;
+                    if (!pipelineError) {
+                        error.failedIndex = qIdx;
+                        error.failedTag = queries[qIdx].tag;
+                        pipelineError = error;
+                    }
+                }
+            }
+            // Advance command index past the failed command
+            commandIndex++;
+        }
+        function onPortalSuspended() {
+            // We don't use row-limited portals
+        }
+        function onReadyForQuery() {
+            rfqCount++;
+            if (rfqCount >= expectedRfq) {
+                finalize();
+            }
+        }
+        // -----------------------------------------------------------------------
+        // Attach our listeners
+        // -----------------------------------------------------------------------
+        connection.on('parseComplete', onParseComplete);
+        connection.on('bindComplete', onBindComplete);
+        connection.on('noData', onNoData);
+        connection.on('rowDescription', onRowDescription);
+        connection.on('dataRow', onDataRow);
+        connection.on('commandComplete', onCommandComplete);
+        connection.on('emptyQuery', onEmptyQuery);
+        connection.on('errorMessage', onErrorMessage);
+        connection.on('portalSuspended', onPortalSuspended);
+        connection.on('readyForQuery', onReadyForQuery);
+        connection.on('notice', () => { });
+        connection.on('copyInResponse', () => { });
+        connection.on('copyData', () => { });
+        // -----------------------------------------------------------------------
+        // Timeout
+        // -----------------------------------------------------------------------
+        if (timeout && timeout > 0) {
+            timeoutHandle = setTimeout(() => {
+                pipelineError = new Error(`[turbine] Pipeline timed out after ${timeout}ms`);
+                if (connection.stream.destroy) {
+                    connection.stream.destroy(pipelineError);
+                }
+                cleanup();
+                reject(pipelineError);
+            }, timeout);
+        }
+        // -----------------------------------------------------------------------
+        // Send protocol messages — all in one TCP flush
+        // -----------------------------------------------------------------------
+        try {
+            if (connection.stream.cork) {
+                connection.stream.cork();
+            }
+            if (transactional) {
+                // ---- Transactional mode ----
+                // BEGIN + N×(parse+bind+describe+execute) + COMMIT + sync
+                // One sync = one ReadyForQuery
+                // BEGIN
+                connection.parse({ text: 'BEGIN', name: '' });
+                connection.bind({ portal: '', statement: '', values: [], valueMapper: utils_1.prepareValue });
+                connection.execute({ portal: '', rows: 0 });
+                // Each query
+                for (const q of queries) {
+                    connection.parse({ text: q.sql, name: '' });
+                    connection.bind({
+                        portal: '',
+                        statement: '',
+                        values: q.params,
+                        valueMapper: utils_1.prepareValue,
+                    });
+                    connection.describe({ type: 'P', name: '' });
+                    connection.execute({ portal: '', rows: 0 });
+                }
+                // COMMIT
+                connection.parse({ text: 'COMMIT', name: '' });
+                connection.bind({ portal: '', statement: '', values: [], valueMapper: utils_1.prepareValue });
+                connection.execute({ portal: '', rows: 0 });
+                // Single Sync
+                connection.sync();
+            }
+            else {
+                // ---- Non-transactional mode ----
+                // N×(parse+bind+describe+execute+sync)
+                // Each sync = one ReadyForQuery
+                // All messages still go in one cork/uncork (one TCP flush)
+                for (const q of queries) {
+                    connection.parse({ text: q.sql, name: '' });
+                    connection.bind({
+                        portal: '',
+                        statement: '',
+                        values: q.params,
+                        valueMapper: utils_1.prepareValue,
+                    });
+                    connection.describe({ type: 'P', name: '' });
+                    connection.execute({ portal: '', rows: 0 });
+                    connection.sync();
+                }
+            }
+            if (connection.stream.uncork) {
+                connection.stream.uncork();
+            }
+        }
+        catch (err) {
+            cleanup();
+            reject(err);
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Capability detection
+// ---------------------------------------------------------------------------
+/**
+ * Check whether a pool client supports the extended-query pipeline protocol.
+ *
+ * Returns true if the client has a Connection object with the required wire
+ * protocol methods (parse, bind, describe, execute, sync) and is an EventEmitter.
+ *
+ * Returns false for HTTP-based drivers (Neon HTTP, Vercel Postgres), mock pools,
+ * and any pool that doesn't expose pg internals.
+ */
+function supportsExtendedPipeline(poolClient) {
+    if (!poolClient || typeof poolClient !== 'object')
+        return false;
+    const client = poolClient;
+    const conn = client.connection;
+    if (!conn || typeof conn !== 'object')
+        return false;
+    const c = conn;
+    return (typeof c.parse === 'function' &&
+        typeof c.bind === 'function' &&
+        typeof c.describe === 'function' &&
+        typeof c.execute === 'function' &&
+        typeof c.sync === 'function' &&
+        typeof c.on === 'function');
+}