agl 1.0.17 → 21.0.2

package/dist_ts/classes.embeddeddb.js

@@ -0,0 +1,159 @@
+import * as plugins from './plugins.js';
+import { EmbeddedDatabaseMigrationRunner, } from '../dist_ts_migration/classes.migrationrunner.js';
+import { embeddedDatabaseSocketPath, isSocketListening, } from './functions.embeddeddb.js';
+export { embeddedDatabaseSocketPath } from './functions.embeddeddb.js';
+const lstatDirectory = async (directoryArg) => {
+    try {
+        const stats = await plugins.fs.promises.lstat(directoryArg);
+        if (!stats.isDirectory()) {
+            throw new Error(`Controller database path must be a real directory: ${directoryArg}`);
+        }
+        return stats;
+    }
+    catch (errorArg) {
+        if (errorArg.code === 'ENOENT')
+            return undefined;
+        throw errorArg;
+    }
+};
+/**
+ * The controller's embedded database engine: a @push.rocks/smartdb
+ * LocalSmartDb over a unix socket inside the data directory. The socket
+ * path is deterministic so a second controller process (e.g. the
+ * temp-password CLI) attaches to the running daemon's engine instead of
+ * opening the storage files a second time; only the process that booted
+ * the engine stops it.
+ */
+export class EmbeddedControllerDatabase {
+    options;
+    localDb;
+    connectionUri;
+    startPromise;
+    migrationRunner;
+    constructor(options) {
+        this.options = options;
+    }
+    get socketPath() {
+        // Unix socket paths are capped near 108 bytes (SUN_LEN), so the socket
+        // lives in tmpdir under a short name derived from the data directory —
+        // deterministic, so a second controller process attaches to the same
+        // engine, and independent of how deep the data directory is nested.
+        return embeddedDatabaseSocketPath(this.options.dataDirectory);
+    }
+    get ownsEngine() {
+        return this.localDb !== undefined;
+    }
+    /** Starts (or attaches to) the engine and returns the smartdata-ready URI. */
+    async start() {
+        if (this.connectionUri)
+            return this.connectionUri;
+        if (this.startPromise)
+            return this.startPromise;
+        const startPromise = this.startOnce();
+        this.startPromise = startPromise;
+        try {
+            return await startPromise;
+        }
+        finally {
+            if (this.startPromise === startPromise)
+                this.startPromise = undefined;
+        }
+    }
+    async startOnce() {
+        if (this.localDb || this.migrationRunner?.hasOwnedResources) {
+            throw new Error('Embedded database startup cleanup must complete before retrying.');
+        }
+        if (this.options.legacyDataDirectory) {
+            const migrationRunner = new EmbeddedDatabaseMigrationRunner({
+                sourceDirectory: this.options.legacyDataDirectory,
+                destinationDirectory: this.options.dataDirectory,
+                sourceSocketPath: embeddedDatabaseSocketPath(this.options.legacyDataDirectory),
+                destinationSocketPath: this.socketPath,
+            });
+            this.migrationRunner = migrationRunner;
+            try {
+                const result = await migrationRunner.run();
+                if (result) {
+                    this.localDb = result.localDb;
+                    this.connectionUri = result.connectionUri;
+                    return result.connectionUri;
+                }
+            }
+            finally {
+                if (!migrationRunner.hasOwnedResources && this.migrationRunner === migrationRunner) {
+                    this.migrationRunner = undefined;
+                }
+            }
+        }
+        await plugins.fs.promises.mkdir(this.options.dataDirectory, {
+            recursive: true,
+            mode: 0o700,
+        });
+        await lstatDirectory(this.options.dataDirectory);
+        const socketUri = `mongodb://${encodeURIComponent(this.socketPath)}/?directConnection=true`;
+        if (await this.isSocketListening()) {
+            this.connectionUri = socketUri;
+            return socketUri;
+        }
+        const localDb = new plugins.smartdb.LocalSmartDb({
+            folderPath: this.options.dataDirectory,
+            socketPath: this.socketPath,
+        });
+        this.localDb = localDb;
+        try {
+            await localDb.start();
+        }
+        catch (errorArg) {
+            try {
+                await localDb.stop();
+                if (this.localDb === localDb)
+                    this.localDb = undefined;
+            }
+            catch (cleanupErrorArg) {
+                throw new AggregateError([errorArg, cleanupErrorArg], 'Embedded database startup failed and cleanup was incomplete.', { cause: errorArg });
+            }
+            throw errorArg;
+        }
+        this.connectionUri = socketUri;
+        return socketUri;
+    }
+    async stop() {
+        if (this.startPromise) {
+            await this.startPromise.catch(() => undefined);
+        }
+        const localDb = this.localDb;
+        const migrationRunner = this.migrationRunner;
+        const errors = [];
+        if (localDb) {
+            try {
+                await localDb.stop();
+                if (this.localDb === localDb)
+                    this.localDb = undefined;
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+        }
+        if (migrationRunner) {
+            try {
+                await migrationRunner.stop();
+                if (this.migrationRunner === migrationRunner)
+                    this.migrationRunner = undefined;
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+        }
+        if (errors.length === 0)
+            this.connectionUri = undefined;
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1) {
+            throw new AggregateError(errors, 'Embedded database shutdown was incomplete.');
+        }
+    }
+    isSocketListening() {
+        return isSocketListening(this.socketPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.flexframedtransport.d.ts

@@ -0,0 +1,56 @@
+import * as plugins from './plugins.js';
+export interface IFlexFramedTransportOptions<TIncoming, TOutgoing> {
+    readable: plugins.stream.Readable;
+    writable: plugins.stream.Writable;
+    parseIncoming: (valueArg: unknown) => TIncoming;
+    validateOutgoing?: (valueArg: unknown) => TOutgoing;
+    maximumFrameBytes?: number;
+}
+type TMessageListener<TMessage> = (messageArg: TMessage) => void;
+type TErrorListener = (errorArg: Error) => void;
+type TCloseListener = () => void;
+export declare const flexIpcMaximumQueuedFrames = 128;
+export declare const flexIpcMaximumQueuedFrameBytes: number;
+export declare const encodeFlexFrame: (valueArg: unknown, maximumFrameBytesArg?: number) => Buffer;
+/**
+ * A single-reader/single-writer JSON transport. The body buffer is allocated
+ * only after the fixed header has passed the configured length limit.
+ */
+export declare class FlexFramedTransport<TIncoming, TOutgoing> {
+    private readonly readable;
+    private readonly writable;
+    private readonly parseIncoming;
+    private readonly validateOutgoing?;
+    private readonly maximumFrameBytes;
+    private readonly header;
+    private headerOffset;
+    private body?;
+    private bodyOffset;
+    private messageListeners;
+    private errorListeners;
+    private closeListeners;
+    private writeTail;
+    private queuedFrames;
+    private queuedFrameBytes;
+    private failed;
+    private closed;
+    private closePromise?;
+    constructor(optionsArg: IFlexFramedTransportOptions<TIncoming, TOutgoing>);
+    onMessage(listenerArg: TMessageListener<TIncoming>): () => void;
+    onError(listenerArg: TErrorListener): () => void;
+    onClose(listenerArg: TCloseListener): () => void;
+    send(messageArg: TOutgoing): Promise<void>;
+    close(): Promise<void>;
+    private closeTransport;
+    private readonly onData;
+    private finishBody;
+    private writeFrame;
+    private readonly onReadError;
+    private readonly onWriteError;
+    private readonly onReadableClosed;
+    private readonly onWritableClosed;
+    private fail;
+    private detachStreams;
+    private emitClose;
+}
+export {};

package/dist_ts/classes.flexframedtransport.js

@@ -0,0 +1,275 @@
+import * as plugins from './plugins.js';
+import { flexIpcMaximumFrameBytes } from './interfaces.flexipc.js';
+export const flexIpcMaximumQueuedFrames = 128;
+export const flexIpcMaximumQueuedFrameBytes = 64 * 1024 * 1024;
+const flexIpcCloseDrainTimeoutMs = 2_000;
+const normalizeMaximumFrameBytes = (valueArg) => {
+    const selected = valueArg ?? flexIpcMaximumFrameBytes;
+    if (!Number.isSafeInteger(selected) || selected < 1 || selected > flexIpcMaximumFrameBytes) {
+        throw new Error(`maximumFrameBytes must be between 1 and ${flexIpcMaximumFrameBytes}.`);
+    }
+    return selected;
+};
+export const encodeFlexFrame = (valueArg, maximumFrameBytesArg = flexIpcMaximumFrameBytes) => {
+    const serialized = Buffer.from(JSON.stringify(valueArg), 'utf8');
+    try {
+        if (serialized.byteLength > maximumFrameBytesArg) {
+            throw new Error('Flex IPC frame exceeds its size limit.');
+        }
+        const frame = Buffer.allocUnsafe(4 + serialized.byteLength);
+        frame.writeUInt32BE(serialized.byteLength, 0);
+        serialized.copy(frame, 4);
+        return frame;
+    }
+    finally {
+        serialized.fill(0);
+    }
+};
+/**
+ * A single-reader/single-writer JSON transport. The body buffer is allocated
+ * only after the fixed header has passed the configured length limit.
+ */
+export class FlexFramedTransport {
+    readable;
+    writable;
+    parseIncoming;
+    validateOutgoing;
+    maximumFrameBytes;
+    header = Buffer.allocUnsafe(4);
+    headerOffset = 0;
+    body;
+    bodyOffset = 0;
+    messageListeners = new Set();
+    errorListeners = new Set();
+    closeListeners = new Set();
+    writeTail = Promise.resolve();
+    queuedFrames = 0;
+    queuedFrameBytes = 0;
+    failed = false;
+    closed = false;
+    closePromise;
+    constructor(optionsArg) {
+        this.readable = optionsArg.readable;
+        this.writable = optionsArg.writable;
+        this.parseIncoming = optionsArg.parseIncoming;
+        this.validateOutgoing = optionsArg.validateOutgoing;
+        this.maximumFrameBytes = normalizeMaximumFrameBytes(optionsArg.maximumFrameBytes);
+        this.readable.on('data', this.onData);
+        this.readable.once('error', this.onReadError);
+        this.readable.once('end', this.onReadableClosed);
+        this.readable.once('close', this.onReadableClosed);
+        this.writable.once('error', this.onWriteError);
+        this.writable.once('finish', this.onWritableClosed);
+        this.writable.once('close', this.onWritableClosed);
+    }
+    onMessage(listenerArg) {
+        this.messageListeners.add(listenerArg);
+        return () => this.messageListeners.delete(listenerArg);
+    }
+    onError(listenerArg) {
+        this.errorListeners.add(listenerArg);
+        return () => this.errorListeners.delete(listenerArg);
+    }
+    onClose(listenerArg) {
+        this.closeListeners.add(listenerArg);
+        return () => this.closeListeners.delete(listenerArg);
+    }
+    async send(messageArg) {
+        if (this.closed || this.failed)
+            throw new Error('Flex IPC transport is closed.');
+        this.validateOutgoing?.(messageArg);
+        const frame = encodeFlexFrame(messageArg, this.maximumFrameBytes);
+        if (this.queuedFrames >= flexIpcMaximumQueuedFrames
+            || this.queuedFrameBytes + frame.byteLength > flexIpcMaximumQueuedFrameBytes)
+            throw new Error('Flex IPC outbound queue limit exceeded.');
+        this.queuedFrames++;
+        this.queuedFrameBytes += frame.byteLength;
+        const write = this.writeTail.then(() => this.writeFrame(frame));
+        this.writeTail = write.catch(() => undefined);
+        try {
+            await write;
+        }
+        finally {
+            this.queuedFrames--;
+            this.queuedFrameBytes -= frame.byteLength;
+            frame.fill(0);
+        }
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        if (this.closed)
+            return Promise.resolve();
+        this.closePromise = this.closeTransport();
+        return this.closePromise;
+    }
+    async closeTransport() {
+        this.closed = true;
+        this.detachStreams();
+        let drainTimer;
+        const drainTimeout = new Promise((resolve) => {
+            drainTimer = setTimeout(() => resolve('timeout'), flexIpcCloseDrainTimeoutMs);
+            drainTimer.unref?.();
+        });
+        const gracefulClose = this.writeTail.then(async () => {
+            if (!this.writable.destroyed && !this.writable.writableEnded) {
+                await new Promise((resolve) => {
+                    this.writable.end(resolve);
+                });
+            }
+            return 'drained';
+        });
+        const drainResult = await Promise.race([
+            gracefulClose,
+            drainTimeout,
+        ]);
+        if (drainTimer)
+            clearTimeout(drainTimer);
+        if (drainResult === 'timeout') {
+            if (!this.writable.destroyed)
+                this.writable.destroy();
+            if (!this.readable.destroyed)
+                this.readable.destroy();
+            this.emitClose();
+            return;
+        }
+        if (!this.readable.destroyed)
+            this.readable.destroy();
+        this.emitClose();
+    }
+    onData = (chunkArg) => {
+        if (this.closed || this.failed)
+            return;
+        const chunk = typeof chunkArg === 'string'
+            ? Buffer.from(chunkArg, 'utf8')
+            : chunkArg instanceof Uint8Array
+                ? Buffer.from(chunkArg.buffer, chunkArg.byteOffset, chunkArg.byteLength)
+                : undefined;
+        if (!chunk) {
+            this.fail(new Error('Flex IPC received a non-byte chunk.'));
+            return;
+        }
+        let chunkOffset = 0;
+        try {
+            while (chunkOffset < chunk.byteLength) {
+                if (!this.body) {
+                    const headerBytes = Math.min(4 - this.headerOffset, chunk.byteLength - chunkOffset);
+                    chunk.copy(this.header, this.headerOffset, chunkOffset, chunkOffset + headerBytes);
+                    this.headerOffset += headerBytes;
+                    chunkOffset += headerBytes;
+                    if (this.headerOffset < 4)
+                        continue;
+                    const bodyLength = this.header.readUInt32BE(0);
+                    if (bodyLength > this.maximumFrameBytes) {
+                        throw new Error('Flex IPC frame exceeds its size limit.');
+                    }
+                    this.body = Buffer.allocUnsafe(bodyLength);
+                    this.bodyOffset = 0;
+                    if (bodyLength === 0)
+                        this.finishBody();
+                    continue;
+                }
+                const bodyBytes = Math.min(this.body.byteLength - this.bodyOffset, chunk.byteLength - chunkOffset);
+                chunk.copy(this.body, this.bodyOffset, chunkOffset, chunkOffset + bodyBytes);
+                this.bodyOffset += bodyBytes;
+                chunkOffset += bodyBytes;
+                if (this.bodyOffset === this.body.byteLength)
+                    this.finishBody();
+            }
+        }
+        catch (errorArg) {
+            this.fail(errorArg instanceof Error ? errorArg : new Error('Flex IPC framing failed.'));
+        }
+    };
+    finishBody() {
+        const completedBody = this.body;
+        this.body = undefined;
+        this.bodyOffset = 0;
+        this.headerOffset = 0;
+        if (!completedBody)
+            throw new Error('Flex IPC body state was lost.');
+        let parsed;
+        try {
+            parsed = JSON.parse(completedBody.toString('utf8'));
+        }
+        catch {
+            throw new Error('Flex IPC frame contains invalid JSON.');
+        }
+        finally {
+            completedBody.fill(0);
+        }
+        const message = this.parseIncoming(parsed);
+        for (const listener of [...this.messageListeners])
+            listener(message);
+    }
+    writeFrame(frameArg) {
+        if (this.closed || this.failed || this.writable.destroyed || this.writable.writableEnded) {
+            throw new Error('Flex IPC transport is closed.');
+        }
+        return new Promise((resolve, reject) => {
+            this.writable.write(frameArg, (errorArg) => {
+                if (errorArg)
+                    reject(errorArg);
+                else
+                    resolve();
+            });
+        });
+    }
+    onReadError = (errorArg) => this.fail(errorArg);
+    onWriteError = (errorArg) => this.fail(errorArg);
+    onReadableClosed = () => {
+        if (this.closed)
+            return;
+        if (this.headerOffset !== 0 || this.body) {
+            this.fail(new Error('Flex IPC stream ended within a frame.'));
+            return;
+        }
+        this.closed = true;
+        this.detachStreams();
+        if (!this.readable.destroyed)
+            this.readable.destroy();
+        if (!this.writable.destroyed)
+            this.writable.destroy();
+        this.emitClose();
+    };
+    onWritableClosed = () => {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.detachStreams();
+        if (!this.readable.destroyed)
+            this.readable.destroy();
+        if (!this.writable.destroyed)
+            this.writable.destroy();
+        this.emitClose();
+    };
+    fail(errorArg) {
+        if (this.failed || this.closed)
+            return;
+        this.failed = true;
+        this.detachStreams();
+        if (!this.readable.destroyed)
+            this.readable.destroy();
+        if (!this.writable.destroyed)
+            this.writable.destroy();
+        for (const listener of [...this.errorListeners])
+            listener(errorArg);
+        this.emitClose();
+    }
+    detachStreams() {
+        this.readable.removeListener('data', this.onData);
+        this.readable.removeListener('error', this.onReadError);
+        this.readable.removeListener('end', this.onReadableClosed);
+        this.readable.removeListener('close', this.onReadableClosed);
+        this.writable.removeListener('error', this.onWriteError);
+        this.writable.removeListener('finish', this.onWritableClosed);
+        this.writable.removeListener('close', this.onWritableClosed);
+    }
+    emitClose() {
+        const listeners = [...this.closeListeners];
+        this.closeListeners.clear();
+        for (const listener of listeners)
+            listener();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexframedtransport.js","sourceRoot":"","sources":["../../ts/classes.flexframedtransport.ts"],"names":[],"mappings":"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"}