@thatopen/services 0.18.0 → 0.20.0

package/dist/core/client.d.ts

@@ -1,3 +1,5 @@
+import { ProjectHistory } from './history';
+import { Recipes } from './recipes';
 import { ExecutionEntity, ExecutionSuscriptionReturnType } from '../types/execution';
 import { AppVersionProps, ComponentVersionProps, ComponentItem, AppItem, Item, ItemFolder, ItemVersion, ItemWithVersions } from '../types/items';
 import { CreateItemResponse, UpdateItemResponse } from '../types/response';
@@ -186,19 +188,23 @@ export declare class EngineServicesClient {
      * {@link initBuiltInComponent} call will use these globals automatically
      * — you no longer need to pass a `globals` argument to each one.
      *
-     * @param globals - Map of global names to module namespaces.
-     *   Common keys: `OBC`, `OBF`, `BUI`, `CUI`, `THREE`, `FRAGS`, `MARKERJS`.
+     * @param globals - Map of global names to module namespaces. The FULL set
+     *   a built-in may ask for: `OBC`, `OBF`, `BUI`, `THREE`, `FRAGS`,
+     *   `MARKERJS` (plus `CUI` only if the app still uses the deprecated
+     *   `@thatopen/ui-obc`). Only `OBC` and `BUI` are strictly required by
+     *   `setup()`; passing everything you import is the safe default, because
+     *   a built-in that needs a missing one fails at init.
      *
      * @example
      * ```ts
      * import * as OBC from "@thatopen/components";
      * import * as OBF from "@thatopen/components-front";
      * import * as BUI from "@thatopen/ui";
-     * import * as CUI from "@thatopen/ui-obc";
      * import * as THREE from "three";
      * import * as FRAGS from "@thatopen/fragments";
+     * import * as MARKERJS from "@markerjs/markerjs3";
      *
-     * client.setBuiltInGlobals({ OBC, OBF, BUI, CUI, THREE, FRAGS });
+     * client.setBuiltInGlobals({ OBC, OBF, BUI, THREE, FRAGS, MARKERJS });
      *
      * // Now just pass the component — no globals needed:
      * await client.initBuiltInComponent(AppManager, components);
@@ -218,8 +224,8 @@ export declare class EngineServicesClient {
      */
     /**
      * Socket origin without namespace or query, for gateways other than the
-     * execution one. `wsUrl` already carries a token that may be stale when a
-     * provider is in play, so callers append their own.
+     * execution one. Callers pass their own credential in the Socket.IO auth
+     * payload, resolved at connect time so a provider-backed client is current.
      */
     protected get socketOrigin(): string;
     protected resolveAccessToken(): Promise<string>;
@@ -625,6 +631,18 @@ export declare class EngineServicesClient {
      * @param onUpdateCallback - Callback invoked on each progress/result event.
      */
     onExecutionProgress(executionId: string, onUpdateCallback: (data: ExecutionSuscriptionReturnType) => void): Promise<void>;
+    /**
+     * A project's history of connected documents (Revit models, AutoCAD
+     * drawings…): their version timelines and their change requests. See
+     * `src/core/history.ts` — this surface is the only supported way to read
+     * or write it; the storage underneath is private and will move.
+     */
+    history(projectId: string): ProjectHistory;
+    /**
+     * The recipe registry and runner: scripts that write change requests in a
+     * native application's language. See `src/core/recipes.ts`.
+     */
+    get recipes(): Recipes;
     /**
      * Creates a hidden file attached to a parent item (e.g., dependencies, assets).
      * @param file - The file to upload.

package/dist/core/examples/history.d.ts

@@ -0,0 +1,4 @@
+import { EngineServicesClient } from '../client';
+
+export declare function readTheProjectHistory(client: EngineServicesClient, projectId: string): Promise<void>;
+export declare function runARecipe(client: EngineServicesClient, projectId: string): Promise<void>;

package/dist/core/history.d.ts

@@ -0,0 +1,204 @@
+import { EngineServicesClient } from './client';
+
+/** One element mutation inside a version. Wire-compatible with the plugins. */
+export interface FlowChange {
+    /** create | update | delete. */
+    type: 'create' | 'update' | 'delete' | string;
+    /** The native application's own id for the element (Revit UniqueId, AutoCAD handle). */
+    uniqueId: string;
+}
+/** Per-version change tallies. */
+export interface FlowCounts {
+    added: number;
+    modified: number;
+    removed: number;
+}
+/**
+ * One sync of a document. Field names are the wire format the plugins write
+ * (`revitflow_history.json`); do not rename them.
+ */
+export interface FlowVersion {
+    /** Identity, minted by the writer. */
+    guid: string;
+    /** The versions this one was built on; absent on a root. First entry is the continued line. */
+    parents?: string[] | null;
+    /** The CDE's storage version number, when there is one. Data, never identity. */
+    version?: number;
+    /** What the author said it was for, when they said anything. */
+    message?: string;
+    author: string;
+    /** Which application wrote it: 'revit', 'autocad', 'rhino'… */
+    source: string;
+    /** ISO UTC. */
+    timestamp: string;
+    changes: FlowChange[];
+    counts: FlowCounts;
+    /** Hidden-file id of the delta .frag; absent on the baseline and geometry-less versions. */
+    deltaId?: string;
+    /** Hidden-file id of the per-element geometry fingerprints, when the writer keeps them. */
+    geomId?: string;
+    /** Platform user id of the committer, when the writer knew it. */
+    userId?: string;
+    /** This version re-exported the whole model (the visible .frag shows it as of here). */
+    full?: boolean;
+    compact?: boolean;
+    /** Suggestions this version applied (their opIds). */
+    appliedOps?: string[];
+    /** Position in the timeline, derived from the parent graph when read. Never stored. */
+    ordinal?: number;
+}
+/**
+ * A change request queued for a document. Wire-compatible with
+ * `revitflow_ops.json` (schema `revitflow/ops@1`).
+ */
+export interface FlowSuggestion {
+    opId: string;
+    /** Groups the suggestions one authored action produced across several docs. */
+    batchId?: string;
+    /** Hidden-file id of the payload .frag (envelope `revitflow/op@2`). */
+    fragId?: string;
+    title?: string;
+    /** add | set | remove | mixed. */
+    verb?: string;
+    author?: string;
+    userId?: string;
+    createdAt?: string;
+    /** The version this was authored against, by guid. */
+    baseCommitGuid?: string;
+    /** The storage version that version landed in, when known. Data only. */
+    baseCommit?: number;
+    /** How many elements it targets. */
+    targets?: number;
+    state?: 'pending' | 'applied' | 'discarded' | string;
+    /** The native version that materialised it, once applied (storage version number). */
+    appliedInCommit?: number | null;
+    /** Native ids it touched or created, written by the plugin when it applied. */
+    affectedIds?: string[];
+}
+/** A connected document, as listed from the project. */
+export interface FlowDocInfo {
+    /** The native application that owns it: 'revit', 'autocad'… */
+    source: string;
+    /** The document's own id within that application. */
+    docId: string;
+    /** The visible model file's name, when one exists yet. */
+    modelName?: string;
+}
+/** What `sync` needs: the change list plus whatever the writer knows. */
+export interface SyncInput {
+    author: string;
+    /** Which application/tool is writing: 'revit', 'rhino', 'recipe'… */
+    source: string;
+    changes: FlowChange[];
+    message?: string;
+    /** Delta geometry for this version, uploaded as a hidden file. */
+    delta?: Blob;
+    /** Re-upload of the whole model; marks the version `full`. */
+    model?: Blob;
+    /** Platform user id, when known. */
+    userId?: string;
+    /** Suggestions this version applied. */
+    appliedOps?: string[];
+    /**
+     * The head you built on. When given and the stored head differs, `sync`
+     * refuses with {@link StaleHistoryError} instead of forking silently.
+     */
+    expectedLatestGuid?: string;
+}
+/** What `suggest` needs. */
+export interface SuggestInput {
+    title: string;
+    /** add | set | remove | mixed. */
+    verb: string;
+    author: string;
+    /** The suggestion's .frag payload (envelope `revitflow/op@2`), when it has one. */
+    payload?: Blob;
+    targets?: number;
+    batchId?: string;
+    userId?: string;
+    /** The version it was authored against. */
+    baseCommitGuid?: string;
+}
+/** The head moved while a writer prepared its version. Re-read and retry. */
+export declare class StaleHistoryError extends Error {
+    readonly expectedGuid: string;
+    readonly actualGuid: string | undefined;
+    constructor(expectedGuid: string, actualGuid: string | undefined);
+}
+/**
+ * The history of one project. Get it from {@link EngineServicesClient.history}.
+ */
+export declare class ProjectHistory {
+    #private;
+    private readonly client;
+    readonly projectId: string;
+    constructor(client: EngineServicesClient, projectId: string);
+    /** The project's connected documents. */
+    docs(): Promise<FlowDocInfo[]>;
+    /** One document's history. `source` and `docId` as {@link docs} lists them. */
+    doc(source: string, docId: string): FlowDoc;
+    /** @internal The `bimterop` folder id, resolved once. */
+    rootFolderId(create?: boolean): Promise<string | undefined>;
+}
+/**
+ * One connected document: its timeline, its model, and its suggestions.
+ */
+export declare class FlowDoc {
+    #private;
+    private readonly client;
+    private readonly project;
+    readonly source: string;
+    readonly docId: string;
+    constructor(client: EngineServicesClient, project: ProjectHistory, source: string, docId: string);
+    /**
+     * The document's versions, oldest first, ordered by the parent graph (not
+     * by array position, which concurrent writers do not keep meaningful).
+     * Each version gets its `ordinal` filled in.
+     */
+    timeline(): Promise<FlowVersion[]>;
+    /** The head of the timeline, or null before the first sync. */
+    latest(): Promise<FlowVersion | null>;
+    /**
+     * A version's delta geometry as a .frag. The baseline (`full`) versions have
+     * no delta: their geometry IS the model file — use {@link model}.
+     */
+    delta(version: FlowVersion): Promise<Blob>;
+    /** The visible model .frag as last fully exported. */
+    model(): Promise<Blob>;
+    /**
+     * Appends one version: uploads the geometry it carries, then the updated
+     * history. Give `expectedLatestGuid` whenever you built on a head you read,
+     * so a concurrent writer surfaces as {@link StaleHistoryError} instead of a
+     * silent fork.
+     */
+    sync(input: SyncInput): Promise<FlowVersion>;
+    /** Every suggestion in the document's queue, pending or resolved. */
+    suggestions(): Promise<FlowSuggestion[]>;
+    /** The suggestions still waiting for the owner, oldest first. */
+    pendingSuggestions(): Promise<FlowSuggestion[]>;
+    /**
+     * Queues a change request for this document. The payload, when given, is
+     * uploaded as a hidden file under the suggestions index.
+     */
+    suggest(input: SuggestInput): Promise<FlowSuggestion>;
+    /** A suggestion's .frag payload. */
+    suggestionPayload(suggestion: FlowSuggestion): Promise<Blob>;
+    /**
+     * Marks a suggestion applied (naming the version that materialised it) or
+     * discarded. The native plugins do this themselves when they apply; apps
+     * use it for `discarded`.
+     */
+    resolveSuggestion(opId: string, outcome: {
+        state: 'applied';
+        appliedInCommit?: number;
+        affectedIds?: string[];
+    } | {
+        state: 'discarded';
+    }): Promise<FlowSuggestion>;
+}
+/**
+ * Orders versions by walking the parent graph from the root along first
+ * parents, breaking forks by timestamp — array position is not meaningful
+ * once more than one application writes. Fills `ordinal`.
+ */
+export declare function orderByGraph(versions: FlowVersion[]): FlowVersion[];

package/dist/core/platform-client.d.ts

@@ -1,5 +1,5 @@
 import { EngineServicesClient, EngineServicesClientProps } from './client';
-import { Project, ProjectData } from '../types/projects';
+import { Project, ProjectData, ProjectWithRole } from '../types/projects';
 import { ChannelClient } from './channel';
 import { MarkNotificationsReadResultDto, NotificationPageDto, NotificationSubscriptionView } from '../types/notifications';
 
@@ -129,6 +129,22 @@ export declare class PlatformClient extends EngineServicesClient {
      * ```
      */
     get channel(): ChannelClient;
+    /**
+     * Lists the caller's projects, each with their role in it. The discovery
+     * call: everything else on this surface takes a projectId, and until this
+     * method there was no way to find out which ids exist — a portfolio
+     * dashboard had to be configured by hand. `ProjectWithRole` existed as a
+     * type with no producer; this is the producer.
+     *
+     * @example
+     * ```ts
+     * const projects = await client.listProjects();
+     * for (const { project, role } of projects) {
+     *   console.log(project.title, role?.name ?? 'no role');
+     * }
+     * ```
+     */
+    listProjects(): Promise<ProjectWithRole[]>;
     /**
      * Gets a project by ID. JWT-only — lives here because
      * `GET /project/:id` is guarded by `AccountActiveGuard + ProjectAccessGuard`.

package/dist/core/recipes.d.ts

@@ -0,0 +1,98 @@
+import { EngineServicesClient } from './client';
+import { FlowDoc, FlowSuggestion } from './history';
+
+/** What a recipe declares about itself. Shown in catalogs, checked by apps. */
+export interface RecipeManifest {
+    /** Machine name, unique in a catalog: 'rhino-points-to-revit-columns'. */
+    name: string;
+    /** The one sentence a non-programmer reads: what it converts into what. */
+    description: string;
+    /** The native application whose language it writes: 'revit', 'autocad'… */
+    to: string;
+    /** The input kinds it understands: 'rhino-model', 'platform-elements', 'points', 'csv'… */
+    inputs: string[];
+    /** Where it runs by default. Browser unless it must run unattended. */
+    runtime?: 'browser' | 'cloud';
+    /**
+     * JSON Schema for `settings`. Apps generate the settings form from it, so
+     * anything that names an EXISTING thing (a target document, a family, a
+     * level) must be an enum the app can fill — people pick, they never type
+     * names of things that exist.
+     */
+    settingsSchema?: Record<string, unknown>;
+    /**
+     * The self-documentation an app renders: a "reads → proposes" table whose
+     * rows are RULES (not objects), so a dry run can fill it with real tallies.
+     */
+    rules?: {
+        reads: string;
+        proposes: string;
+    }[];
+}
+/** Everything a recipe's `run` gets to work with. */
+export interface RecipeContext<Settings = Record<string, unknown>> {
+    client: EngineServicesClient;
+    projectId: string;
+    /** The document the suggestion is for. Read its timeline/model if needed. */
+    targetDoc: FlowDoc;
+    /** The declared input, already fetched by the caller (bytes, ids, rows…). */
+    input: unknown;
+    settings: Settings;
+}
+/** What a recipe's `run` returns: the suggestion, ready to queue. */
+export interface RecipeResult {
+    title: string;
+    /** add | set | remove | mixed. */
+    verb: string;
+    /** The .frag payload (envelope `revitflow/op@2`), when the recipe builds one. */
+    payload?: Blob;
+    targets?: number;
+    /** Per-rule tallies matching `manifest.rules`, filled by the run. */
+    ruleTallies?: {
+        read: number;
+        proposed: number;
+    }[];
+}
+/** A recipe: its manifest plus the function that writes the suggestion. */
+export interface Recipe<Settings = Record<string, unknown>> extends RecipeManifest {
+    run(context: RecipeContext<Settings>): Promise<RecipeResult>;
+}
+/** What {@link Recipes.run} returns: the queued suggestion plus the tallies. */
+export interface RecipeRunOutcome {
+    suggestion: FlowSuggestion;
+    result: RecipeResult;
+}
+/**
+ * The local recipe registry and runner. Reach it as `client.recipes`.
+ */
+export declare class Recipes {
+    #private;
+    private readonly client;
+    constructor(client: EngineServicesClient);
+    /** Registers a recipe. One per name; a second with the same name throws. */
+    register<S>(recipe: Recipe<S>): void;
+    /** The registered recipes, optionally filtered by target application. */
+    list(filter?: {
+        to?: string;
+        input?: string;
+    }): RecipeManifest[];
+    /** A registered recipe by name, or undefined. */
+    get(name: string): RecipeManifest | undefined;
+    /**
+     * Runs a recipe and queues its suggestion on the target document. Safe to
+     * call freely: nothing touches the native application until its owner
+     * accepts the suggestion there.
+     */
+    run<S>(name: string, options: {
+        projectId: string;
+        /** The target document, as `client.history(projectId).docs()` lists it. */
+        target: {
+            source: string;
+            docId: string;
+        };
+        input?: unknown;
+        settings?: S;
+        author: string;
+        userId?: string;
+    }): Promise<RecipeRunOutcome>;
+}