@thatopen/services 0.20.0 → 0.22.0

package/dist/cli.js

@@ -6812,6 +6812,9 @@ const OPS_SCHEMA = "revitflow/ops@1";
 const LEGACY_MODEL_FILE = "revitflow_model.frag";
 const INTERNAL_PREFIX = "revitflow_";
 const versionTag = () => `v-${Date.now()}`;
+function childrenOf(folders, parentId) {
+  return folders.filter((f) => String(f.parentId ?? "") === parentId);
+}
 function idOf(item) {
   return String(item._id ?? item.id ?? "");
 }
@@ -6830,14 +6833,25 @@ class ProjectHistory {
       projectId: this.projectId
     });
     const docs = [];
-    for (const folder of folders) {
+    for (const folder of childrenOf(folders, root)) {
       const name = String(folder.name ?? "");
       const dash = name.indexOf("-");
       if (dash <= 0) continue;
+      const files = await this.client.listFiles({
+        folderId: idOf(folder)
+      });
+      const names2 = files.map(
+        (f) => String(f.name ?? "")
+      );
+      const model = names2.find((n) => n === LEGACY_MODEL_FILE) ?? names2.find(
+        (n) => n.endsWith(".frag") && !n.startsWith(INTERNAL_PREFIX)
+      );
+      const hasAny = names2.includes(HISTORY_FILE) || names2.includes(OPS_FILE) || !!model;
       docs.push({
         source: name.slice(0, dash),
         docId: name.slice(dash + 1),
-        modelName: void 0
+        modelName: model,
+        ...hasAny ? {} : { empty: true }
       });
     }
     return docs;
@@ -6937,7 +6951,7 @@ class FlowDoc {
       throw new StaleHistoryError(input.expectedLatestGuid, head?.guid);
     }
     const version2 = {
-      guid: cryptoRandomGuid(),
+      guid: mintGuid(),
       ...head ? { parents: [head.guid] } : {},
       author: input.author,
       source: input.source,
@@ -6999,7 +7013,7 @@ class FlowDoc {
     const index = await this.#readOps() ?? { schema: OPS_SCHEMA, ops: [] };
     const indexFile = await this.#file(OPS_FILE);
     const suggestion = {
-      opId: cryptoRandomGuid(),
+      opId: input.opId ?? mintGuid(),
       title: input.title,
       verb: input.verb,
       author: input.author,
@@ -7067,7 +7081,7 @@ class FlowDoc {
       parentFolderId: rootId,
       projectId: this.project.projectId
     });
-    const found = folders.find(
+    const found = childrenOf(folders, rootId).find(
       (f) => String(f.name ?? "") === this.#folderName
     );
     if (found) {
@@ -7225,7 +7239,7 @@ function lastByGraph(versions) {
   const ordered = orderByGraph(versions);
   return ordered[ordered.length - 1];
 }
-function cryptoRandomGuid() {
+function mintGuid() {
   const anyCrypto = globalThis.crypto;
   if (anyCrypto?.randomUUID) return anyCrypto.randomUUID();
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
@@ -7256,12 +7270,65 @@ class Recipes {
   get(name) {
     return this.#registry.get(name);
   }
+  /**
+   * Runs a recipe WITHOUT queueing anything: the dry pass. Returns a
+   * {@link RecipePlan} — the result to show (title, tallies, targets) plus
+   * everything {@link queue} needs to queue EXACTLY this, payload and opId
+   * included, with no second run. Discard it and the plan never happened.
+   */
+  async plan(name, options) {
+    const { base, opId, result } = await this.#execute(name, options);
+    return {
+      opId,
+      projectId: options.projectId,
+      target: options.target,
+      ...base?.guid ? { baseCommitGuid: base.guid } : {},
+      result
+    };
+  }
+  /**
+   * Queues exactly what {@link plan} planned: same opId, same payload, no
+   * second execution. The pair plan → confirm → queue is the UI flow; `run`
+   * is the one-shot shortcut.
+   */
+  async queue(plan, options) {
+    const targetDoc = this.client.history(plan.projectId).doc(plan.target.source, plan.target.docId);
+    const suggestion = await targetDoc.suggest({
+      opId: plan.opId,
+      title: plan.result.title,
+      verb: plan.result.verb,
+      author: options.author,
+      payload: plan.result.payload,
+      targets: plan.result.targets,
+      userId: options.userId,
+      baseCommitGuid: plan.baseCommitGuid
+    });
+    return { suggestion, result: plan.result };
+  }
   /**
    * 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.
+   * accepts the suggestion there. Use {@link plan} first when the app wants
+   * to show the tallies before queueing.
    */
   async run(name, options) {
+    const { targetDoc, base, opId, result } = await this.#execute(
+      name,
+      options
+    );
+    const suggestion = await targetDoc.suggest({
+      opId,
+      title: result.title,
+      verb: result.verb,
+      author: options.author,
+      payload: result.payload,
+      targets: result.targets,
+      userId: options.userId,
+      baseCommitGuid: base?.guid
+    });
+    return { suggestion, result };
+  }
+  async #execute(name, options) {
     const recipe = this.#registry.get(name);
     if (!recipe) throw new Error(`No recipe named "${name}" is registered.`);
     if (recipe.to !== options.target.source) {
@@ -7271,23 +7338,16 @@ class Recipes {
     }
     const targetDoc = this.client.history(options.projectId).doc(options.target.source, options.target.docId);
     const base = await targetDoc.latest();
+    const opId = mintGuid();
     const result = await recipe.run({
       client: this.client,
       projectId: options.projectId,
       targetDoc,
+      opId,
       input: options.input,
       settings: options.settings ?? {}
     });
-    const suggestion = await targetDoc.suggest({
-      title: result.title,
-      verb: result.verb,
-      author: options.author,
-      payload: result.payload,
-      targets: result.targets,
-      userId: options.userId,
-      baseCommitGuid: base?.guid
-    });
-    return { suggestion, result };
+    return { recipe, targetDoc, base, opId, result };
   }
 }
 const STORAGE_BATCH_MAX = 100;