@hydranium/core 1.0.0-next.28 → 1.0.0-next.281

package/lib/langium/model-service/client-session.d.ts

@@ -0,0 +1,372 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type BaseVersion, type MaybeObservableValue, type MaybePromise, ObservableValue, type TextVersion, type Tracer, type TransferElement } from '@hydranium/protocol';
+import { type AstNode } from '@hydranium/langium';
+import { type CancellationToken, type Disposable, Emitter, type Event } from 'vscode-languageserver';
+import { type AstDocument, type SavedAstDocument } from '../../documents/ast-document-manager.js';
+import { type OpenOptions, type SessionEndCause } from '../../documents/client-session-registry.js';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type ServerSharedServices } from '../module.js';
+import { type AstDiagnostic } from '../validation/document-validator.js';
+import { type ModelService } from './model-service.js';
+/** What a session's `update` and `save` write into one document; the session supplies its own client id. */
+export interface ClientSessionWriteArgs<TTransfer> {
+    uri: string;
+    /** The whole structured model root, or its serialised textual form. */
+    model: TTransfer | string;
+    /**
+     * The version the write was authored against, or `'any'` to write
+     * unconditionally. Required, so an ungated write is a decision the caller
+     * makes rather than a field it forgot.
+     */
+    baseVersion: BaseVersion;
+}
+/** What a session's `persist` writes: the text the store holds for `uri`. */
+export type ClientSessionPersistArgs = Omit<ClientSessionWriteArgs<never>, 'model'>;
+/** What a session's `delete` removes: the document at `uri`, at the version it was based on. */
+export type ClientSessionDeleteArgs = Omit<ClientSessionWriteArgs<never>, 'model'>;
+/** What a session's `updateAll` writes, all or none. */
+export interface ClientSessionUpdateAllArgs<TTransfer> {
+    updates: ClientSessionWriteArgs<TTransfer>[];
+}
+/**
+ * One participant's handle on the documents it works on, started by
+ * `ModelService.createSession`.
+ *
+ * The session writes only what it has open: `update`, `save`, `persist` and
+ * `delete` fail with `DocumentNotOpenError` unless this session has the URI
+ * open in the synchronous step that applies or takes the text, or marks the
+ * document for deletion, so a write either lands while the document is open or
+ * fails. They fail the same way while any session's `delete` of the URI is
+ * under way. A document stays open until this session closes it, the session
+ * ends, or the file is deleted.
+ *
+ * One open per URI, without reference counting: opening a URI the session
+ * already has open changes nothing, and one `close` ends it.
+ *
+ * After `dispose`, every other member throws `SessionClosedError`
+ * synchronously, before returning a promise.
+ *
+ * Reads need no session and live on `ModelService`.
+ */
+export interface ClientSession<TAst extends AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic, TTransfer extends TransferElement = TransferElement, TOpenOptions extends OpenOptions = OpenOptions> {
+    /** Unique in the process while the session is live: the author label on its writes and the key of its opens. */
+    readonly clientId: string;
+    readonly label: string;
+    /**
+     * Open `uri` for this session, reading it from disk unless some client has
+     * it open already or it holds this client's unsaved text within its release
+     * grace. `options` are kept for this open until it closes; a repeat open,
+     * concurrent or not, keeps the options of the first.
+     */
+    open(uri: string, options?: TOpenOptions): Promise<void>;
+    /** The options this session opened `uri` with, or `undefined` when it gave none or does not have `uri` open. */
+    openOptions(uri: string): TOpenOptions | undefined;
+    /**
+     * Create a document with `text` and open it for this session. It reaches
+     * disk on the first `save`. Fails when the file exists, any client has the
+     * URI open, or the URI waits out the release grace, and of two creates of one
+     * URI at most one succeeds.
+     *
+     * Resolves with the version the created document took, which a write based
+     * on it names: once this resolves, the store's version may already be
+     * another client's write.
+     */
+    create(uri: string, text: string): Promise<TextVersion>;
+    /**
+     * Write `args.model` into a document this session has open. Resolves to the
+     * rebuilt document once it is validated, in whichever build carried the
+     * write, so the answer holds every diagnostic its update event does: that
+     * event names this session, and a client dropping its own echo would
+     * otherwise never see them.
+     */
+    update(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Write several documents this session has open, all or none: a
+     * `ConflictError` or `DocumentNotOpenError` for any of them is thrown before
+     * any text applies. Resolves to the rebuilt documents, in the order given,
+     * each validated as {@link update}'s is.
+     */
+    updateAll(args: ClientSessionUpdateAllArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>[]>;
+    /** Write `args.model` as {@link update} does, then persist the document. */
+    save(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<SavedAstDocument<TAst, TDiagnostic>>;
+    /**
+     * Persist the text the store holds for `args.uri` as it is, with no update
+     * and no serialisation. Resolves with the version of the text written, once
+     * it is on disk, without waiting for a build. The saved event names this
+     * session, also when another client wrote the text.
+     */
+    persist(args: ClientSessionPersistArgs): Promise<TextVersion>;
+    /**
+     * Delete `args.uri` at once: its file, then the document, as a deletion a
+     * file watcher reports removes it. Every session's open of it closes, the
+     * editor's stays, and the deletion event names this session. Resolves once
+     * the build that removes the document has run. `args.baseVersion` is gated
+     * as {@link persist} gates it; a file already gone deletes only the
+     * document, and one that cannot be removed fails the call, deleting nothing.
+     * The file removed is the one the store keys the document by: under
+     * `RealpathDocumentUriPolicy`, a symlink's target rather than the link.
+     *
+     * A change requested before that build starts, by the editor or a file
+     * watcher, keeps the document, and only this session's open of it closes.
+     * From inside a build the call fails with `ReentrantWriteLockError`,
+     * whatever `ModelServiceOptions.allowReentrantBuilds` says.
+     */
+    delete(args: ClientSessionDeleteArgs): Promise<void>;
+    /** Close this session's open of `uri`, at once. A no-op when it does not have `uri` open. */
+    close(uri: string): Promise<void>;
+    /**
+     * Open `uri`, run `fn`, and close `uri` when `fn` settles, whether it
+     * returned or threw. A URI the session already had open, or is still
+     * opening through another call, stays open: the close undoes only the open
+     * this call made.
+     */
+    withOpen<T>(uri: string, fn: () => MaybePromise<T>): Promise<T>;
+    /** Whether an event's `sourceClientId` names this session, i.e. the event echoes its own write. */
+    isOwnEcho(sourceClientId: string): boolean;
+    /**
+     * End the session: close everything it has open and free its id.
+     * Idempotent. `cause` is `'lost'` when the session ends because its
+     * client's connection went away, which lets each document it was the last
+     * to have open wait out the store's release grace; ending it for any other
+     * reason releases such a document at once.
+     */
+    dispose(cause?: SessionEndCause): void;
+    /**
+     * Fires once the session has ended, its documents closed, with the cause it
+     * ended with. A takeover through `createSession` ends it as `'lost'` from
+     * another caller, so a holder that keeps per-session state releases it here.
+     */
+    readonly onDidDispose: Event<SessionEndCause>;
+}
+/**
+ * The framework's {@link ClientSession}, built by
+ * {@link DefaultClientSessionFactory}.
+ *
+ * Override the protected method behind a member to change how every session
+ * writes, and return the subclass from a {@link ClientSessionFactory} bound on
+ * `model.ClientSessionFactory`. Serialising a model and rebuilding a document
+ * are the {@link ModelService}'s.
+ *
+ * An override of {@link dispose} calls `super.dispose(cause)`: that is what
+ * closes the session's opens and frees its id, and dropping `cause` reverts
+ * a lost client's documents without their grace.
+ */
+export declare class DefaultClientSession<TAst extends AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic, TTransfer extends TransferElement = TransferElement, TOpenOptions extends OpenOptions = OpenOptions> implements ClientSession<TAst, TDiagnostic, TTransfer, TOpenOptions> {
+    protected readonly services: ServerSharedServices;
+    protected disposed: boolean;
+    /**
+     * This session's opens still under way, by canonical URI. Recorded before
+     * the first await, so a second open of the same URI joins the first rather
+     * than racing it, and `withOpen` can tell an open another call is making.
+     */
+    protected readonly pendingOpens: Map<string, Promise<void>>;
+    /**
+     * The options of this session's opens, by canonical URI. A first open
+     * records its entry before the store has the URI open, and the entry goes
+     * when that open closes, whoever ends it: this session, or the store for a
+     * deleted file. A first open that fails never opens, so nothing closes it
+     * and its entry stays until the next first open of the URI overwrites it;
+     * {@link openOptions} therefore reads an entry only while the store has the
+     * URI open for this session.
+     */
+    protected readonly openOptionsByUri: Map<string, TOpenOptions | undefined>;
+    /** Drops an open's options from {@link openOptionsByUri} when the store closes the open. */
+    protected readonly closeListener: Disposable;
+    protected readonly disposeEmitter: Emitter<SessionEndCause>;
+    /** Logs under `logName`, `ClientSession` when none is given, with this session's id in a bracket of its own, so a line names the session that wrote. */
+    protected readonly tracer: Tracer;
+    /** The service bound on `model.ModelService`, which serialises and rebuilds for this session. */
+    protected readonly modelService: ModelService<TAst, TDiagnostic, TTransfer>;
+    /** See {@link ClientSessionFactoryOptions.slowUpdateWarnMs}; `undefined` when not set. */
+    protected readonly slowUpdateWarn?: ObservableValue<number>;
+    readonly clientId: string;
+    readonly label: string;
+    constructor(services: ServerSharedServices, options: ClientSessionOptions);
+    open(uri: string, options?: TOpenOptions): Promise<void>;
+    openOptions(uri: string): TOpenOptions | undefined;
+    create(uri: string, text: string): Promise<TextVersion>;
+    update(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    updateAll(args: ClientSessionUpdateAllArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>[]>;
+    save(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<SavedAstDocument<TAst, TDiagnostic>>;
+    persist(args: ClientSessionPersistArgs): Promise<TextVersion>;
+    close(uri: string): Promise<void>;
+    delete(args: ClientSessionDeleteArgs): Promise<void>;
+    withOpen<T>(uri: string, fn: () => MaybePromise<T>): Promise<T>;
+    isOwnEcho(sourceClientId: string): boolean;
+    dispose(cause?: SessionEndCause): void;
+    get onDidDispose(): Event<SessionEndCause>;
+    protected assertLive(): void;
+    /** Throw `DocumentNotOpenError` unless this session has `uri` open and no delete of it is under way. */
+    protected assertOpen(uri: string): void;
+    /**
+     * Throw `ConflictError` when `baseVersion` names a version other than
+     * `currentVersion`. A write calls it at the door and again in the
+     * synchronous step that applies the text, and has to call it synchronously
+     * there: a check separated from the apply by an await lets two writes based
+     * on one version both apply.
+     */
+    protected assertBaseVersion(uri: string, baseVersion: BaseVersion, currentVersion: number): void;
+    /**
+     * Serialise `args.model`, apply it to the store under this session's id,
+     * rebuild, and resolve to the rebuilt document.
+     *
+     * The open check and the `baseVersion` gate run at the door, so a write that
+     * cannot land is refused before any adopter serialiser runs, and again in
+     * the synchronous step that applies the text: made only before the
+     * serialiser's await, a close during it lets the write land on a document
+     * this session no longer has open, and two writes based on one version
+     * both apply.
+     *
+     * Resolves with the latest build of the document, which may already carry
+     * a newer write; that is logged at debug, and a slow update at warn when
+     * `ClientSessionFactoryOptions.slowUpdateWarnMs` is set. It waits for the
+     * builder's final phase rather than the write's own build: a later write
+     * cancels that build, and the one that takes over validates the document
+     * after the answer was taken.
+     */
+    protected updateDocument(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
+    /**
+     * Write every document of `args.updates`, all or none: every model is
+     * serialised first, then every open check and `baseVersion` gate runs and every
+     * text is applied in one synchronous step. Checked at the door as well, so
+     * a stale set is refused before any adopter serialiser runs.
+     *
+     * The apply step relies on `AstDocumentManager.update` applying its text
+     * before its first await, as the default does: an override that awaits first
+     * lets another write land between two documents of the set.
+     */
+    protected updateDocuments(args: ClientSessionUpdateAllArgs<TTransfer>, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>[]>;
+    /**
+     * Write `args.model` through {@link updateDocument}, then persist it through
+     * {@link persistDocument}, so an override of either applies to saves too.
+     *
+     * Fails with `DocumentNotOpenError` and writes nothing when this session
+     * closes the URI while the text is being built. Persisted at `'any'`: the
+     * update already gated on `args.baseVersion` and moved the text past it.
+     */
+    protected saveDocument(args: ClientSessionWriteArgs<TTransfer>, cancelToken?: CancellationToken): Promise<SavedAstDocument<TAst, TDiagnostic>>;
+    /**
+     * Persist the store's text for `args.uri` under this session's id. Every
+     * write to disk a session makes goes through here, so an override sees each
+     * of them.
+     *
+     * The open check and the `baseVersion` gate sit in the same synchronous step
+     * as the manager taking the text: an await between them lets another
+     * client's write land after the gate, and its text is then persisted under
+     * this session's id without this session ever having seen it. An override
+     * that awaits before calling the base lets a diagram save take its
+     * documents' texts at different moments, and a diagram that ends during the
+     * await fails the documents not yet taken with `DocumentNotOpenError`.
+     */
+    protected persistDocument(args: ClientSessionPersistArgs): Promise<TextVersion>;
+    /**
+     * Delete `args.uri` under this session's id. The open check and the
+     * `baseVersion` gate sit in the same synchronous step as the manager's
+     * mark, which refuses every later write of the URI: an await between them
+     * lets another client's write land after the gate, and the delete then
+     * discards text this session never saw.
+     */
+    protected deleteDocument(args: ClientSessionDeleteArgs): Promise<void>;
+    protected closeDocument(uri: string): Promise<void>;
+    /** Open `uri`, or join the open of it this session already has under way, whose options then stand. */
+    protected openDocument(uri: string, options: TOpenOptions | undefined): Promise<void>;
+    /**
+     * Open `uri` in the store for this session. The open path does not thread
+     * cancellation: the file read behind it takes no token, so a cancelled
+     * caller still completes the open.
+     *
+     * A first open records its options before the store opens the URI, so a
+     * listener of the store's open reads this open's options rather than an
+     * earlier one's.
+     */
+    protected registerOpen(uri: string, options: TOpenOptions | undefined): Promise<void>;
+    protected canonicalKey(uri: string): string;
+    protected createDocument(uri: string, text: string): Promise<TextVersion>;
+    protected runWithOpen<T>(uri: string, fn: () => MaybePromise<T>): Promise<T>;
+    /**
+     * Undo an open that completed after the session ended, then fail it.
+     *
+     * Ending the session closed only what it had open at that moment. An open
+     * still reading from disk registers afterwards, under an id that is no
+     * longer a session, and nothing would ever close it.
+     *
+     * Opens are keyed by id, so once a new session holds the same id this open
+     * is indistinguishable from one of its own, and closing it would close the
+     * new session's. It is left to that session, which releases it at its end.
+     */
+    protected rejectIfEnded(uri: string, wasOpen: boolean): Promise<void>;
+}
+/** Constructor options for {@link DefaultClientSessionFactory}. */
+export interface ClientSessionFactoryOptions extends LogNameOptions {
+    /**
+     * The name the factory and every session it builds log under, so one
+     * option renames both. Default: `ClientSessionFactory` for the factory,
+     * and `ClientSession` for a session, which adds its client id in a bracket
+     * of its own.
+     */
+    readonly logName?: string;
+    /**
+     * When set, a session's `update` logs a `warn` line if its end-to-end wait
+     * (serialise, apply, rebuild) takes at least this many milliseconds. Default
+     * `undefined`: no warn line, and no per-update stopwatch.
+     *
+     * Observability only: the update is neither aborted nor resolved
+     * differently. A hard timeout that throws is an override of
+     * `DefaultClientSession.updateDocument` racing the parent call against a
+     * deadline.
+     *
+     * A recommended starting threshold is 2-5 seconds; workspaces with very
+     * large documents or slow validation can exceed 5 s on a cold build. A
+     * `Settings.number` binding retunes it live.
+     */
+    readonly slowUpdateWarnMs?: MaybeObservableValue<number>;
+}
+/**
+ * Constructor options for {@link DefaultClientSession}: the factory's options,
+ * which it forwards, plus the session's identity.
+ */
+export interface ClientSessionOptions extends ClientSessionFactoryOptions {
+    readonly clientId: string;
+    /** What the session is. Pass one: the client id stands in for it otherwise. */
+    readonly label?: string;
+}
+/**
+ * Builds the handle for a session `ModelService.createSession` has already
+ * registered, so registration and the uniqueness check cannot be skipped by
+ * binding a factory of one's own. Bind one on `model.ClientSessionFactory` to
+ * use a session class of your own. A factory that does not pass
+ * {@link ClientSessionFactoryOptions.slowUpdateWarnMs} on to its sessions
+ * loses their slow-update warn; subclassing {@link DefaultClientSessionFactory}
+ * keeps it.
+ *
+ * Typed for every grammar, since the slot is shared: `createSession` narrows
+ * the result to its caller's types.
+ */
+export interface ClientSessionFactory {
+    create(clientId: string, label: string): ClientSession<AstNode>;
+}
+/**
+ * The framework's {@link ClientSessionFactory}: a {@link DefaultClientSession}
+ * over the {@link ModelService} bound on `model.ModelService`, which the session
+ * serialises and rebuilds through. A model service constructed outside that
+ * slot therefore starts sessions that write through the bound one.
+ *
+ * A subclass that overrides {@link create} to build a session class of its
+ * own passes {@link options} on to that session's constructor; a session built
+ * without them has no slow-update warn and logs under the default name.
+ */
+export declare class DefaultClientSessionFactory implements ClientSessionFactory {
+    protected readonly services: ServerSharedServices;
+    protected readonly options: ClientSessionFactoryOptions;
+    protected readonly tracer: Tracer;
+    constructor(services: ServerSharedServices, options?: ClientSessionFactoryOptions);
+    create(clientId: string, label: string): ClientSession<AstNode>;
+}
+//# sourceMappingURL=client-session.d.ts.map

package/lib/langium/model-service/client-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-session.d.ts","sourceRoot":"","sources":["../../../src/langium/model-service/client-session.ts"],"names":[],"mappings":"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"}