kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/util/distributedLock.js

@@ -0,0 +1,166 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withLock = exports.MutexLockLostError = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const redis_semaphore_1 = require("redis-semaphore");
+const debug_1 = __importDefault(require("./debug"));
+require("../types/Global");
+const debug = (0, debug_1.default)("kuzzle:distributedLock");
+/**
+ * Thrown when a lock acquired by `withLock` is lost while its callback is
+ * still running (e.g. TTL extension failed and another node may now hold
+ * the lock).
+ */
+class MutexLockLostError extends Error {
+    constructor(key, cause) {
+        super(`Lock lost for resource "${key}"`, cause ? { cause } : undefined);
+        this.name = "MutexLockLostError";
+    }
+}
+exports.MutexLockLostError = MutexLockLostError;
+/**
+ * redis-semaphore's mutex, adjusted to what `withLock` promises:
+ *
+ * - the lock lives under the resource key itself, as with the deprecated
+ *   `Mutex` class (redis-semaphore would prefix it with "mutex:"), so both
+ *   still contend on the same Redis key;
+ * - a TTL extension that fails with a Redis error counts as a lost lock
+ *   (redis-semaphore would let the error escape its refresh timer as an
+ *   unhandled rejection, without knowing whether the lock is still held).
+ *   The error is kept, to be reported as the loss's cause.
+ */
+class ResourceMutex extends redis_semaphore_1.Mutex {
+    constructor(client, key, options) {
+        super(client, key, options);
+        this._key = key;
+    }
+    async _refresh() {
+        try {
+            return await super._refresh();
+        }
+        catch (error) {
+            this.refreshError =
+                error instanceof Error ? error : new Error(String(error));
+            return false;
+        }
+    }
+}
+/**
+ * Tracks, per async context, the set of lock keys already held by an
+ * ancestor `withLock` call. Deliberately separate from the shared
+ * `global.kuzzle.asyncStore`: that store always seeds a fresh Map on
+ * `.run()` (it would silently discard whatever the parent context held) and
+ * throws if no context is active yet (which would break locking used
+ * outside a request scope, e.g. during boot or in background jobs).
+ */
+const lockContext = new node_async_hooks_1.AsyncLocalStorage();
+let clientPromise;
+/**
+ * Lazily fetches and memoizes the internal cache's raw ioredis client.
+ * Self-healing: if the very first call happens before the cache engine has
+ * registered its ask handler (e.g. from an early plugin lifecycle hook), the
+ * failure is not cached, so the next call retries instead of permanently
+ * failing for the rest of the process.
+ */
+async function getClient() {
+    clientPromise ?? (clientPromise = (async () => global.kuzzle.ask("core:cache:internal:client:get"))().catch((err) => {
+        clientPromise = undefined;
+        throw err;
+    }));
+    return clientPromise;
+}
+/**
+ * Runs `callback` while holding a distributed, reentrant lock on `key`.
+ *
+ * Reentrant: if the current async context already holds `key` (i.e. this is
+ * a nested call from inside another `withLock(key, ...)` call for the same
+ * key), `callback` runs immediately with no new Redis round-trip, and
+ * `config` is silently ignored (the ancestor's lock/TTL/retry settings
+ * apply — this is correct reentrant-mutex semantics, not a bug).
+ *
+ * The lock's TTL is extended in the background while `callback` runs. If
+ * the lock cannot be acquired within `retryAttempts + 1` attempts, the
+ * returned promise rejects without running `callback`.
+ *
+ * If the lock is lost mid-callback (e.g. TTL extension failed and another
+ * node may now hold it), the returned promise rejects with
+ * `MutexLockLostError` as soon as that's detected. `callback` itself cannot
+ * be cancelled and keeps running in the background; do not perform
+ * authoritative side effects after observing this rejection.
+ *
+ * Do not use on the same resource key as the deprecated `Mutex` class
+ * concurrently: both write to the same Redis key with incompatible
+ * value/TTL formats and will contend with (but never corrupt) each other.
+ *
+ * @param key - resource identifier to be locked (must be identical across
+ *              all nodes)
+ * @param callback - executed while the lock is held
+ * @param config - lock options (ignored if this call is reentrant)
+ */
+async function withLock(key, callback, config = {}) {
+    const held = lockContext.getStore();
+    if (held?.has(key)) {
+        return callback();
+    }
+    const { retryAttempts = 10, retryDelay = 200, ttl = 30000 } = config;
+    const client = await getClient();
+    const loss = new AbortController();
+    const lockLost = new Promise((_resolve, reject) => {
+        loss.signal.addEventListener("abort", () => reject(loss.signal.reason), {
+            once: true,
+        });
+    });
+    // Only ever observed through the race below; never an unhandled rejection
+    lockLost.catch(() => undefined);
+    const mutex = new ResourceMutex(client, key, {
+        acquireAttemptsLimit: retryAttempts + 1,
+        acquireTimeout: Number.POSITIVE_INFINITY,
+        lockTimeout: ttl,
+        onLockLost: (error) => {
+            loss.abort(new MutexLockLostError(key, mutex.refreshError ?? error));
+        },
+        retryInterval: retryDelay,
+    });
+    if (!(await mutex.tryAcquire())) {
+        throw new Error(`Failed to acquire lock "${key}" after ${retryAttempts + 1} attempts`);
+    }
+    try {
+        const nextHeld = new Set(held);
+        nextHeld.add(key);
+        const callbackPromise = lockContext.run(nextHeld, () => callback());
+        // Settles as soon as the lock is lost, without waiting for the callback
+        return await Promise.race([callbackPromise, lockLost]);
+    }
+    finally {
+        // A failed release only leaves the key to expire with its TTL: it must
+        // not replace the callback's own outcome
+        await mutex.release().catch((error) => {
+            debug("Failed to release lock %s: %s", key, error);
+        });
+    }
+}
+exports.withLock = withLock;
+//# sourceMappingURL=distributedLock.js.map

package/dist/lib/util/dump-collection.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../types/JSONObject";
 import { HttpStream } from "../types";
 /**
  * Flatten an object transform:

package/dist/lib/util/dump-collection.js

@@ -58,10 +58,7 @@ function flattenObject(target) {
 }
 exports.flattenObject = flattenObject;
 function flattenStep(output, object, prev = null) {
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
+    for (const [key, value] of Object.entries(object)) {
         const newKey = prev ? prev + "." + key : key;
         if (Object.prototype.toString.call(value) === "[object Object]") {
             flattenStep(output, value, newKey);
@@ -130,6 +127,8 @@ class AbstractDumper {
         this.query = query;
         this.writeStream = writeStream;
         this.options = options;
+        /** Set by `setup()`, before any document is written. */
+        this.collectionDir = "";
         if (!writeStream) {
             throw kerror.get("api", "assert", "missing_argument", "writeStream");
         }
@@ -197,7 +196,7 @@ class AbstractDumper {
             await this.tearDown();
         }
         catch (e) {
-            this.writeStream.write(e.toString());
+            this.writeStream.write(String(e));
         }
         this.writeStream.end();
         return waitWrite;

package/dist/lib/util/extractFields.d.ts

@@ -1,17 +1,21 @@
-export = extractFields;
+interface ExtractedField {
+    key: string;
+    value: unknown;
+}
 /**
  * Extract nested fields of an object in a flat array.
  * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
  *
- * @param {Object} document - Document to extract fields from
- * @param {Object} options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
+ * @param document - Document to extract fields from
+ * @param options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
  *
- * @returns { Array<String> | Array<{ key: String, value: any }> }
+ * @returns Array of field paths, or of { key, value } pairs when alsoExtractValues is true
  */
-declare function extractFields(document: any, { fieldsToIgnore, alsoExtractValues }?: any, { path, extractedFields }?: {
-    path?: any;
-    extractedFields?: any[];
-}): Array<string> | Array<{
-    key: string;
-    value: any;
-}>;
+declare function extractFields(document: Record<string, unknown>, { fieldsToIgnore, alsoExtractValues, }?: {
+    fieldsToIgnore?: string[];
+    alsoExtractValues?: boolean;
+}, { path, extractedFields, }?: {
+    path?: string | null;
+    extractedFields?: Array<string | ExtractedField>;
+}): Array<string | ExtractedField>;
+export = extractFields;

package/dist/lib/util/extractFields.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,25 +19,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { isPlainObject } = require("./safeObject");
+const safeObject_1 = require("./safeObject");
 /**
  * Extract nested fields of an object in a flat array.
  * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
  *
- * @param {Object} document - Document to extract fields from
- * @param {Object} options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
+ * @param document - Document to extract fields from
+ * @param options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
  *
- * @returns { Array<String> | Array<{ key: String, value: any }> }
+ * @returns Array of field paths, or of { key, value } pairs when alsoExtractValues is true
  */
-function extractFields(document, { fieldsToIgnore = [], alsoExtractValues = false } = {}, { path = null, extractedFields = [] } = {}) {
+function extractFields(document, { fieldsToIgnore = [], alsoExtractValues = false, } = {}, { path = null, extractedFields = [], } = {}) {
     for (const [key, value] of Object.entries(document)) {
-        if (fieldsToIgnore.length &&
-            fieldsToIgnore.find((keyToIgnore) => keyToIgnore === key)) {
+        if (fieldsToIgnore.includes(key)) {
             continue;
         }
         const currentPath = path ? `${path}.${key}` : key;
-        if (isPlainObject(value)) {
+        if ((0, safeObject_1.isPlainObject)(value)) {
             extractFields(value, { alsoExtractValues, fieldsToIgnore }, { extractedFields, path: currentPath });
         }
         else if (alsoExtractValues) {

package/dist/lib/util/koncordeCompat.d.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from "kuzzle-sdk";
-import { Koncorde } from "koncorde";
+import type { JSONObject } from "../types/JSONObject";
+import type { Koncorde } from "koncorde";
 /**
  * Builds a Koncorde v4 index name from the old fashioned index+collection
  * arguments

package/dist/lib/util/koncordeCompat.js

@@ -19,14 +19,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIndexes = exports.getCollections = exports.koncordeTest = exports.fromKoncordeIndex = exports.toKoncordeIndex = void 0;
 /*
   Set of utility functions meant to ease up the use of Koncorde v4 in Kuzzle
  */
 const lodash_1 = require("lodash");
+const kerror = __importStar(require("../kerror"));
 // No collision possible: "/" is forbidden in index (or collection) names
 const SEPARATOR = "/";
+const fatal = kerror.wrap("core", "fatal");
 /**
  * Builds a Koncorde v4 index name from the old fashioned index+collection
  * arguments
@@ -47,6 +72,14 @@ exports.toKoncordeIndex = toKoncordeIndex;
  */
 function fromKoncordeIndex(index) {
     const [kindex, kcollection] = index.split(SEPARATOR);
+    // `split` always yields a first element, but a second one exists only if the
+    // name really is a v4 pair. Two of the three callers read it off a cluster
+    // message payload — remote input — so a name without the separator is
+    // reachable, and answering it with `collection: undefined` would hand the
+    // question to every caller instead of to the node that sent a bad name.
+    if (kindex === undefined || kcollection === undefined) {
+        throw fatal.get("assertion_failed", `"${index}" is not a Koncorde index`);
+    }
     return {
         collection: kcollection,
         index: kindex,

package/dist/lib/util/memoize.d.ts

@@ -1,7 +1,8 @@
+interface Memoized<Args extends unknown[], Result> {
+    (...args: Args): Result;
+    fn: (...args: Args) => Result;
+    cache: Map<unknown, Result>;
+    resolver: ((args: Args) => unknown) | null;
+}
+declare function memoize<Args extends unknown[], Result>(fn: (...args: Args) => Result, resolver?: ((args: Args) => unknown) | null): Memoized<Args, Result>;
 export = memoize;
-declare function memoize(fn: any, resolver?: any): {
-    (...args: any[]): any;
-    fn: any;
-    cache: Map<any, any>;
-    resolver: any;
-};

package/dist/lib/util/memoize.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,9 +19,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
 function memoize(fn, resolver = null) {
-    const memoized = (...args) => {
+    const memoized = ((...args) => {
         const key = memoized.resolver !== null ? memoized.resolver(args) : args[0];
         let result = memoized.cache.get(key);
         if (result === undefined) {
@@ -28,7 +28,7 @@ function memoize(fn, resolver = null) {
             memoized.cache.set(key, result);
         }
         return result;
-    };
+    });
     memoized.fn = fn;
     memoized.cache = new Map();
     memoized.resolver = resolver;

package/dist/lib/util/mutex.d.ts

@@ -33,6 +33,12 @@ export interface MutexOptions {
  * If, in the future, Kuzzle is able to support multiple independant
  * Redis servers, then this class needs to implement redlock to properly handle
  * synchronization between servers (see https://redis.io/topics/distlock)
+ *
+ * @deprecated Use `withLock` from `./distributedLock` instead: it supports
+ * real Redlock semantics and reentrancy. Do not mix `Mutex` and `withLock`
+ * on the same resource key — they use incompatible acquisition/TTL formats
+ * and will contend with (though never corrupt) each other's lock on that
+ * key.
  */
 export declare class Mutex {
     readonly resource: string;
@@ -81,8 +87,22 @@ export declare class Mutex {
      * @return {Promise.<boolean>} True if the ressource has been unlocked before the `timeout`
      */
     wait({ attemptDelay, timeout, }: {
-        attemptDelay?: number;
-        timeout?: number;
+        attemptDelay?: number | undefined;
+        timeout?: number | undefined;
     }): Promise<boolean>;
+    /**
+     * Frees every lock this process holds, and stops it from taking new ones.
+     * Only meant to be called right before `process.exit`.
+     *
+     * A process that exits holding a lock leaves it in Redis until its ttl
+     * expires, and every node waiting on it waits that long. That is how a
+     * node evicted while starting its plugins made another node time out
+     * starting its own, and leave the cluster too (step 15, F-13).
+     *
+     * From then on, `lock()` never resolves: the process is about to exit, and
+     * answering `false` would send its caller down a path meant for a lock
+     * held by another node.
+     */
+    static releaseAllBeforeExit(): Promise<void>;
     get locked(): boolean;
 }

package/dist/lib/util/mutex.js

@@ -68,6 +68,10 @@ end
 // Global: we need to register the LUA script only once. This variable is used
 // to keep track of whether the script was already registered or not
 let delScriptRegistered = false;
+// Every lock this process holds, so that it can give them back before it
+// exits (see `Mutex.releaseAllBeforeExit`).
+const held = new Set(); // NOSONAR: deprecated for callers, not for itself
+let exiting = false;
 /**
  * Mutex meant to work across a kuzzle cluster.
  *
@@ -83,6 +87,12 @@ let delScriptRegistered = false;
  * If, in the future, Kuzzle is able to support multiple independant
  * Redis servers, then this class needs to implement redlock to properly handle
  * synchronization between servers (see https://redis.io/topics/distlock)
+ *
+ * @deprecated Use `withLock` from `./distributedLock` instead: it supports
+ * real Redlock semantics and reentrancy. Do not mix `Mutex` and `withLock`
+ * on the same resource key — they use incompatible acquisition/TTL formats
+ * and will contend with (though never corrupt) each other's lock on that
+ * key.
  */
 class Mutex {
     /**
@@ -114,6 +124,9 @@ class Mutex {
         if (this._locked) {
             throw fatal.get("assertion_failed", `resource "${this.resource}" already locked by this mutex (id: ${this.mutexId})`);
         }
+        if (exiting) {
+            return new Promise(() => { });
+        }
         let duration = 0;
         do {
             this._locked = await global.kuzzle.ask("core:cache:internal:store", this.resource, this.mutexId, { onlyIfNew: true, ttl: this.ttl });
@@ -127,6 +140,12 @@ class Mutex {
             debug("Failed to lock %s (mutex id: %s)", this.resource, this.mutexId);
             return false;
         }
+        held.add(this);
+        // Acquired while `releaseAllBeforeExit` was running: give it back at once.
+        if (exiting) {
+            await this.unlock();
+            return new Promise(() => { });
+        }
         debug("Resource %s locked (mutex id: %s)", this.resource, this.mutexId);
         return true;
     }
@@ -145,6 +164,7 @@ class Mutex {
         }
         await global.kuzzle.ask("core:cache:internal:script:execute", "delIfValueEqual", this.resource, this.mutexId);
         this._locked = false;
+        held.delete(this);
         debug("Resource %s freed (mutex id: %s)", this.resource, this.mutexId);
     }
     /**
@@ -163,7 +183,7 @@ class Mutex {
      */
     async wait({ attemptDelay = this.attemptDelay, timeout = this.timeout, }) {
         let duration = 0;
-        let isLocked = true;
+        let isLocked;
         do {
             isLocked = await global.kuzzle.ask("core:cache:internal:get", this.resource);
             duration += attemptDelay;
@@ -173,6 +193,24 @@ class Mutex {
         } while (isLocked && (timeout === -1 || duration <= timeout));
         return !isLocked;
     }
+    /**
+     * Frees every lock this process holds, and stops it from taking new ones.
+     * Only meant to be called right before `process.exit`.
+     *
+     * A process that exits holding a lock leaves it in Redis until its ttl
+     * expires, and every node waiting on it waits that long. That is how a
+     * node evicted while starting its plugins made another node time out
+     * starting its own, and leave the cluster too (step 15, F-13).
+     *
+     * From then on, `lock()` never resolves: the process is about to exit, and
+     * answering `false` would send its caller down a path meant for a lock
+     * held by another node.
+     */
+    static async releaseAllBeforeExit() {
+        exiting = true;
+        // Best effort: a lock that cannot be freed still expires with its ttl.
+        await Promise.allSettled([...held].map((mutex) => mutex.unlock()));
+    }
     get locked() {
         return this._locked;
     }

package/dist/lib/util/name-generator.js

@@ -34,7 +34,7 @@ class NameGenerator {
      * @returns a random name
      */
     static getRandomName() {
-        return names[randomNumber(names.length)];
+        return randomItem(names);
     }
     /**
      * Returns a random adjective.
@@ -48,7 +48,7 @@ class NameGenerator {
      * @returns a random adjective
      */
     static getRandomAdjective() {
-        return adjectives[randomNumber(adjectives.length)];
+        return randomItem(adjectives);
     }
     /**
      * Generates a random formatted name that consists of an optional prefix, a random adjective,
@@ -99,6 +99,18 @@ function randomNumber(min, max) {
     return Math.floor(Math.random() * (max - min)) + min;
 }
 exports.randomNumber = randomNumber;
+/**
+ * Picks one of `items` at random.
+ *
+ * `items[i]` is `T | undefined` under `noUncheckedIndexedAccess` whatever the
+ * index — a tuple type does not help, the index is still a `number`. The head,
+ * whose index IS a literal and is therefore typed `T`, stands in for the
+ * out-of-range read that cannot happen. No assertion, and no branch claiming a
+ * runtime state that does not exist: the lists below are non-empty by type.
+ */
+function randomItem(items) {
+    return items[randomNumber(items.length)] ?? items[0];
+}
 const adjectives = [
     "aback",
     "abandoned",

package/dist/lib/util/promback.d.ts

@@ -1,13 +1,22 @@
-export = Promback;
-declare class Promback {
-    constructor(callback?: any);
-    _callback: any;
-    _resolve: (thenableOrResult?: any) => void;
-    _reject: (error?: any) => void;
-    deferred: Bluebird<any>;
+import Bluebird from "bluebird";
+type PrombackCallback<T> = (error: unknown, result?: T) => void;
+/**
+ * `resolve()` may be called with no argument, and callers do pass a possibly
+ * missing value (`promback.resolve(updated[0])` under
+ * `noUncheckedIndexedAccess`), so the settled value is `T | undefined` — not
+ * `T`. Declaring it honestly is what lets `resolve`/`reject` type-check
+ * without a cast.
+ */
+type PrombackResult<T> = T | undefined;
+declare class Promback<T = unknown> {
+    private readonly _callback;
+    private _resolve;
+    private _reject;
+    deferred: Bluebird<PrombackResult<T>> | null;
     isPromise: boolean;
-    resolve(result: any): Bluebird<any>;
-    reject(error: any): Bluebird<any>;
-    get promise(): Bluebird<any>;
+    constructor(callback?: PrombackCallback<T> | null);
+    resolve(result?: T): Bluebird<PrombackResult<T>> | null;
+    reject(error?: unknown): Bluebird<PrombackResult<T>> | null;
+    get promise(): Bluebird<PrombackResult<T>> | null;
 }
-import Bluebird = require("bluebird");
+export = Promback;

package/dist/lib/util/promback.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,8 +19,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Bluebird = require("bluebird");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bluebird_1 = __importDefault(require("bluebird"));
 class Promback {
     constructor(callback = null) {
         this._callback = callback;
@@ -28,27 +31,31 @@ class Promback {
         this.deferred = null;
         this.isPromise = this._callback === null;
         if (this.isPromise) {
-            this.deferred = new Bluebird((res, rej) => {
+            this.deferred = new bluebird_1.default((res, rej) => {
                 this._resolve = res;
                 this._reject = rej;
             });
         }
     }
     resolve(result) {
-        if (this.isPromise) {
+        // Narrowing on the settler rather than on `isPromise` is equivalent — the
+        // Bluebird executor runs synchronously, so `_resolve` is set if and only
+        // if no callback was given — and it is what makes the two branches
+        // provably non-null.
+        if (this._resolve !== null) {
             this._resolve(result);
         }
         else {
-            this._callback(null, result);
+            this._callback?.(null, result);
         }
         return this.deferred;
     }
     reject(error) {
-        if (this.isPromise) {
+        if (this._reject !== null) {
             this._reject(error);
         }
         else {
-            this._callback(error);
+            this._callback?.(error);
         }
         return this.deferred;
     }