@milaboratories/pl-middle-layer 1.72.0 → 1.73.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-middle-layer",
-  "version": "1.72.0",
+  "version": "1.73.1",
   "description": "Pl Middle Layer",
   "keywords": [],
   "license": "UNLICENSED",
@@ -30,26 +30,26 @@
     "utility-types": "^3.11.0",
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
-    "@milaboratories/pf-driver": "1.9.5",
     "@milaboratories/columns-collection-driver": "0.2.7",
     "@milaboratories/computable": "2.9.8",
+    "@milaboratories/pf-driver": "1.9.6",
     "@milaboratories/helpers": "1.14.5",
-    "@milaboratories/pf-spec-driver": "1.5.5",
-    "@milaboratories/pl-crash-recorder": "0.3.3",
-    "@milaboratories/pl-client": "3.17.3",
+    "@milaboratories/pf-spec-driver": "1.5.6",
     "@milaboratories/pl-deployments": "3.0.19",
-    "@milaboratories/pl-drivers": "1.16.26",
-    "@milaboratories/pl-errors": "1.4.44",
+    "@milaboratories/pl-crash-recorder": "0.3.3",
+    "@milaboratories/pl-drivers": "1.16.27",
+    "@milaboratories/pl-client": "3.17.4",
     "@milaboratories/pl-http": "1.2.4",
-    "@milaboratories/pl-model-backend": "1.4.29",
+    "@milaboratories/pl-errors": "1.4.45",
+    "@milaboratories/pl-model-backend": "1.4.30",
     "@milaboratories/pl-model-common": "1.51.0",
-    "@milaboratories/pl-model-middle-layer": "1.33.0",
-    "@milaboratories/pl-tree": "1.15.4",
+    "@milaboratories/pl-model-middle-layer": "1.34.0",
+    "@milaboratories/pl-tree": "1.15.5",
     "@milaboratories/resolve-helper": "1.1.3",
     "@milaboratories/ts-helpers": "1.8.6",
-    "@platforma-sdk/block-tools": "2.16.3",
-    "@platforma-sdk/workflow-tengo": "6.12.1",
-    "@platforma-sdk/model": "1.84.1"
+    "@platforma-sdk/block-tools": "2.16.5",
+    "@platforma-sdk/model": "1.84.3",
+    "@platforma-sdk/workflow-tengo": "6.12.1"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
@@ -57,8 +57,8 @@
     "@vitest/coverage-istanbul": "^4.1.3",
     "typescript": "7.0.2",
     "vitest": "^4.1.3",
-    "@milaboratories/build-configs": "2.0.2",
     "@milaboratories/ts-builder": "1.7.2",
+    "@milaboratories/build-configs": "2.0.2",
     "@milaboratories/ts-configs": "1.4.0"
   },
   "engines": {

package/src/middle_layer/folders.test.ts

@@ -79,18 +79,20 @@ test("a typed name is stored trimmed, and a blank folder name is refused", async
   });
 });
 
-test("a name a human typed is rejected when it is taken, whatever its case", async () => {
+test("a name a human typed is rejected when another folder carries it, whatever its case", async () => {
   await withMl(async (ml) => {
     await ml.createFolder("Samples");
-    await expect(ml.createFolder("samples")).rejects.toThrow(/already used/);
+    await expect(ml.createFolder("samples")).rejects.toThrow(
+      'A folder named "samples" is already here.',
+    );
 
-    // A project shares the namespace with folders inside the same parent.
+    // A project is another kind of item: its name is no obstacle to a folder's.
     await ml.createProject({ label: "Alpha" });
     await untilListing(ml, (l) => l.projects.length === 1);
-    await expect(ml.createFolder("alpha")).rejects.toThrow(/already used/);
+    await ml.createFolder("alpha");
 
     const other = await ml.createFolder("Other");
-    await expect(ml.renameFolder(other, "SAMPLES")).rejects.toThrow(/already used/);
+    await expect(ml.renameFolder(other, "SAMPLES")).rejects.toThrow(/folder named .* already here/);
 
     // Renaming a folder to what it is already called is not a collision with itself.
     await ml.renameFolder(other, "Other");
@@ -625,16 +627,22 @@ test("renaming a project onto a sibling's name is refused, in whatever case", as
     await move(ml, other, folder);
     await untilListing(ml, (l) => l.projects.filter((p) => p.folder === folder).length === 2);
 
-    await expect(ml.setProjectMeta(other, { label: "Alpha" })).rejects.toThrow(/already used/);
-    await expect(ml.setProjectMeta(other, { label: "ALPHA" })).rejects.toThrow(/already used/);
-    // Folders and projects share one namespace inside a parent.
-    await ml.createFolder("Archive", folder);
-    await expect(ml.setProjectMeta(other, { label: "archive" })).rejects.toThrow(/already used/);
+    await expect(ml.setProjectMeta(other, { label: "Alpha" })).rejects.toThrow(
+      'A project named "Alpha" is already here.',
+    );
+    await expect(ml.setProjectMeta(other, { label: "ALPHA" })).rejects.toThrow(
+      /project named .* already here/,
+    );
 
-    // Nothing was written by any of the refusals.
+    // Nothing was written by either refusal.
     const listing = await untilListing(ml, (l) => l.projects.length === 2);
     expect(labelOf(listing, other)).toBe("Beta");
     expect(labelOf(listing, resident)).toBe("Alpha");
+
+    // A folder is another kind of item: a project may take the name of one beside it.
+    await ml.createFolder("Archive", folder);
+    await ml.setProjectMeta(other, { label: "archive" });
+    await untilListing(ml, (l) => labelOf(l, other) === "archive");
   });
 });
 
@@ -858,8 +866,8 @@ test("a template saved from a project lands beside it", async () => {
     const listing = await untilListing(ml, (l) => l.templates.length === 1);
     expect(listing.templates[0].id).toBe(saved.templateId);
     expect(listing.templates[0].folder).toBe(folder);
-    // The project beside it already answers to its own label.
-    expect(listing.templates[0].label).toBe("Alpha (Copy)");
+    // The project beside it answers to that label too, but a project is another kind of item.
+    expect(listing.templates[0].label).toBe("Alpha");
   });
 });
 
@@ -913,7 +921,7 @@ test("duplicating a folder rebuilds its subtree beside it, descriptions and all"
 
     const copiedTemplate = listing.templates.find((t) => t.id !== saved.templateId);
     expect(copiedTemplate?.folder).toBe(copiedInner.id);
-    expect(copiedTemplate?.label).toBe("Alpha (Copy)");
+    expect(copiedTemplate?.label).toBe("Alpha");
     expect(copiedTemplate?.description).toBe("Reusable");
   });
 });

package/src/middle_layer/folders.ts

@@ -376,26 +376,28 @@ export interface FoldersTx {
   /** Resource id of every template the list holds under a label. */
   readonly templateRids: ReadonlyMap<TemplateId, SignedResourceId>;
   /**
-   * Names already taken in a folder, or at the top level, for choosing one that is free before
-   * anything is created.
+   * Names already taken by items of one kind in a folder, or at the top level, for choosing one
+   * that is free before anything of that kind is created. Each kind has a namespace of its own.
    *
    * Empty when the folder document is not ours to read: nothing is then known about who sits
    * where, and inventing collisions out of that would rename copies for no reason.
    */
-  namesTakenIn(folder: FolderId | undefined): string[];
-  /** Names already taken where `project` sits — where something made from it lands. Empty for
-   *  the same reason {@link namesTakenIn} can be. */
-  namesTakenBeside(project: ProjectId): string[];
+  namesTakenIn(folder: FolderId | undefined, kind: FoldersItem["kind"]): string[];
+  /** Names already taken by items of one kind where `project` sits — where something made from it
+   *  lands. Empty for the same reason {@link namesTakenIn} can be. */
+  namesTakenBeside(project: ProjectId, kind: FoldersItem["kind"]): string[];
   /** The folder holding a project, or undefined at the top level. */
   folderOf(project: ProjectId): FolderId | undefined;
   /**
-   * Refuses a name for a project or template rename when one of its siblings already carries it.
+   * Refuses a name for a project or template rename when a sibling of the same kind already
+   * carries it. A folder, a project and a template beside each other may share a name; two
+   * projects, or two templates, may not.
    *
    * Renaming a project or a template is not a folder operation and does not go through
-   * {@link withFolders} — it writes the item's own metadata. But it shares the namespace the
-   * folder rule governs, so without this check a user could rename two things sitting in the
-   * same folder to the same name, and the uniqueness the rest of the feature relies on would be
-   * false from the day it shipped.
+   * {@link withFolders} — it writes the item's own metadata. But the folder rule governs its
+   * name, so without this check a user could rename two projects sitting in the same folder to
+   * the same name, and the uniqueness the rest of the feature relies on would be false from the
+   * day it shipped.
    *
    * The name is checked against the state the rename actually commits against, since the read
    * happened in the rename's own transaction. Four things it deliberately does not do:
@@ -424,8 +426,8 @@ export interface FoldersTx {
    *
    * What travels is the shape of a subtree, not its identity: the incoming folder keys are the
    * caller's and mean nothing here, so a fresh id is minted for each. Only the root is renamed to
-   * be free among the destination's siblings — the folders inside it are only ever compared with
-   * each other, and they came in already distinct.
+   * be free among the folders in the destination — the folders inside it are only ever compared
+   * with each other, and they came in already distinct.
    *
    * @returns `unwritable` when the document is not ours to rewrite and nothing was grafted.
    */
@@ -468,8 +470,8 @@ export async function openFoldersTx(tx: PlTransaction, rids: FoldersRids): Promi
       throw new Error(`Folder ${folder} does not exist.`);
   };
 
-  const namesTakenIn = (folder: FolderId | undefined): string[] =>
-    read.decoded.writable ? foldersSiblingNames(view, folder) : [];
+  const namesTakenIn = (folder: FolderId | undefined, kind: FoldersItem["kind"]): string[] =>
+    read.decoded.writable ? foldersSiblingNames(view, folder, [], { kind }) : [];
 
   const folderOf = (project: ProjectId): FolderId | undefined =>
     view.projects.find((candidate) => candidate.id === project)?.folder;
@@ -481,7 +483,7 @@ export async function openFoldersTx(tx: PlTransaction, rids: FoldersRids): Promi
     projectRids: read.projectRids,
     templateRids: read.templateRids,
     namesTakenIn,
-    namesTakenBeside: (project) => namesTakenIn(folderOf(project)),
+    namesTakenBeside: (project, kind) => namesTakenIn(folderOf(project), kind),
     folderOf,
 
     assertNameFree(item, name) {
@@ -497,8 +499,8 @@ export async function openFoldersTx(tx: PlTransaction, rids: FoldersRids): Promi
       // name goes through even where a pre-existing duplicate sits beside it.
       if (foldersNameTaken(name, [placed.name])) return;
 
-      const siblings = foldersSiblingNames(view, placed.folder, [item.id]);
-      if (foldersNameTaken(name, siblings)) throw new Error(`"${name}" is already used here.`);
+      const siblings = foldersSiblingNames(view, placed.folder, [item.id], { kind: item.kind });
+      if (foldersNameTaken(name, siblings)) throw new Error(nameTakenMessage(item.kind, name));
     },
 
     place(items, folder) {
@@ -520,7 +522,10 @@ export async function openFoldersTx(tx: PlTransaction, rids: FoldersRids): Promi
 
       const root: FoldersGraft["folders"][string] | undefined = subtree.folders[subtree.root];
       if (root === undefined) throw new Error(`The subtree holds no folder ${subtree.root}.`);
-      const rootName = foldersUniqueName(root.name, foldersSiblingNames(view, destination));
+      const rootName = foldersUniqueName(
+        root.name,
+        foldersSiblingNames(view, destination, [], { kind: "folder" }),
+      );
 
       const incoming = Object.keys(subtree.folders);
       const minted = new Map<string, FolderId>();
@@ -560,9 +565,9 @@ export async function openFoldersTx(tx: PlTransaction, rids: FoldersRids): Promi
 /**
  * Creates a folder and returns its id.
  *
- * The name is typed by a human, so a name already used in the destination is rejected rather than
- * quietly suffixed — a text field that disagrees with what was typed is worse than one that says
- * no.
+ * The name is typed by a human, so a name another folder in the destination already carries is
+ * rejected rather than quietly suffixed — a text field that disagrees with what was typed is worse
+ * than one that says no. A project or a template of that name beside it is no obstacle.
  */
 export async function createFolder(
   pl: PlClient,
@@ -580,8 +585,8 @@ export async function createFolder(
   await withFolders(pl, "MLCreateFolder", rids, (view) => {
     if (parent !== undefined && !view.folders.some((folder) => folder.id === parent))
       throw new Error(`Folder ${parent} does not exist.`);
-    if (foldersNameTaken(wanted, foldersSiblingNames(view, parent)))
-      throw new Error(`"${wanted}" is already used here.`);
+    if (foldersNameTaken(wanted, foldersSiblingNames(view, parent, [], { kind: "folder" })))
+      throw new Error(nameTakenMessage("folder", wanted));
 
     const base = foldersDocumentFromView(view);
     return {
@@ -613,8 +618,8 @@ export async function renameFolder(
     const target = view.folders.find((candidate) => candidate.id === folder);
     if (target === undefined) throw new Error(`Folder ${folder} does not exist.`);
 
-    const siblings = foldersSiblingNames(view, target.parent, [folder]);
-    if (foldersNameTaken(wanted, siblings)) throw new Error(`"${wanted}" is already used here.`);
+    const siblings = foldersSiblingNames(view, target.parent, [folder], { kind: "folder" });
+    if (foldersNameTaken(wanted, siblings)) throw new Error(nameTakenMessage("folder", wanted));
 
     const base = foldersDocumentFromView(view);
     return {
@@ -797,6 +802,11 @@ export async function resetFolders(pl: PlClient, rids: FoldersRids): Promise<voi
   );
 }
 
+/** Why a typed name is refused: another item of the same kind beside it already carries it. */
+export function nameTakenMessage(kind: FoldersItem["kind"], name: string): string {
+  return `A ${kind} named "${name}" is already here.`;
+}
+
 //
 // Internals
 //
@@ -898,7 +908,7 @@ async function readFolders(tx: PlTransaction, rids: FoldersRids): Promise<Folder
     projects.push({ id, name: meta.label });
   });
 
-  // Labels as well as ids: a template is named in the same namespace as folders and projects.
+  // Labels as well as ids: a template's name is held to the folder rule, among templates.
   const templateRids = new Map<TemplateId, SignedResourceId>();
   const templates: FoldersTemplateInput[] = [];
   [...listedTemplates.values()].forEach(({ rid }, index) => {

package/src/middle_layer/middle_layer.ts

@@ -24,6 +24,7 @@ import {
   createFolderList,
   deleteFolder,
   moveFolderItems,
+  nameTakenMessage,
   openFoldersTx,
   previewFolderDeletion,
   previewFoldersMove,
@@ -413,9 +414,9 @@ export class MiddleLayer {
    * different places: a rename that carried a stale description alongside the new name would
    * undo a description edit that happened in between, and the reverse.
    *
-   * The label is stored trimmed, and it goes into the namespace folders share, so a label
-   * already carried by something else inside the same folder is refused rather than written — a
-   * human typed it, and a name that silently becomes a different name is worse than one that is
+   * The label is stored trimmed, and the folder rule governs it, so a label another project
+   * inside the same folder already carries is refused rather than written — a folder or a
+   * template of that name beside it is no obstacle. A human typed it, and a name that silently becomes a different name is worse than one that is
    * turned down. The check and the write share one transaction, so two renames racing for the
    * same name cannot both win. Duplicates an account already holds are tolerated and never
    * rewritten; see the name check of {@link openFoldersTx}.
@@ -459,7 +460,7 @@ export class MiddleLayer {
     return id;
   }
 
-  /** Renames a folder. A name already used beside it is rejected. */
+  /** Renames a folder. A name another folder beside it already carries is rejected. */
   public async renameFolder(folder: FolderId, name: string): Promise<void> {
     await renameFolder(this.pl, this.foldersRids, folder, name);
     await this.foldersTree.refreshState();
@@ -552,7 +553,7 @@ export class MiddleLayer {
    * in them, and a copy of every template.
    *
    * The copy lands beside the source, so only its root needs a name of its own — `X (Copy)`.
-   * Nothing inside is renamed: names are compared among siblings, and a copied folder's children
+   * Nothing inside is renamed: names are compared among siblings of one kind, and a copied folder's children
    * are only ever compared with each other, where they came in distinct already.
    *
    * The subtree is read first and rebuilt in one write transaction, so the folders and everything
@@ -887,10 +888,10 @@ export class MiddleLayer {
    * A block that cannot be expressed as a template entry stores nothing at all, and every
    * such block is reported — fixing an unexportable project takes one pass, not one per block.
    *
-   * The template lands beside its project, and is named by the rule everything there is named
-   * by: a label the caller chose is stored trimmed and refused if it is already used there, and
-   * without one the project's own label is taken — suffixed, since the project itself already
-   * answers to it.
+   * The template lands beside its project, and is named by the rule templates there are named
+   * by: a label the caller chose is stored trimmed and refused if another template there already
+   * carries it, and without one the project's own label is taken — suffixed only when a template
+   * there already answers to it. The project is not a template, so its own name is no obstacle.
    *
    * The template's description is the one the caller gives, stored trimmed; blank means none.
    * Without one the template is stored undescribed, whatever the project's own description says.
@@ -912,11 +913,10 @@ export class MiddleLayer {
     const signedRid = await this.pl.withWriteTx("MLSaveProjectAsTemplate", async (tx) => {
       const meta = await tx.getKValueJson<ProjectMeta>(rid, ProjectMetaKey);
       const tree = await openFoldersTx(tx, this.foldersRids);
-      const taken = tree.namesTakenBeside(projectId);
+      const taken = tree.namesTakenBeside(projectId, "template");
       if (wanted !== undefined && foldersNameTaken(wanted, taken))
-        throw new Error(`"${wanted}" is already used here.`);
-      // The project's own label is taken beside it even when the tree cannot say what else is.
-      const name = wanted ?? foldersUniqueName(meta.label, [meta.label, ...taken]);
+        throw new Error(nameTakenMessage("template", wanted));
+      const name = wanted ?? foldersUniqueName(meta.label, taken);
 
       const tpl = createTemplate(
         tx,
@@ -947,8 +947,8 @@ export class MiddleLayer {
    * Changes a template's label. The stored document is immutable and stays untouched —
    * improving a template means saving a new one.
    *
-   * The label is stored trimmed. It is in the namespace folders, projects and templates share,
-   * so one already used beside the template is refused, in the transaction that writes it.
+   * The label is stored trimmed. One another template beside it already carries is refused, in
+   * the transaction that writes it; a folder or a project of that name beside it is no obstacle.
    */
   public async renameTemplate(id: TemplateId, label: string): Promise<void> {
     const rid = await this.resolveTemplateId(id);
@@ -1115,7 +1115,7 @@ export class MiddleLayer {
         rename === undefined
           ? foldersUniqueName(sourceMeta.label, [
               sourceMeta.label,
-              ...tree.namesTakenBeside(srcProjectId),
+              ...tree.namesTakenBeside(srcProjectId, "project"),
             ])
           : rename(sourceMeta.label, await existingProjectLabels(tx, this.projectListResourceId));
 
@@ -1492,7 +1492,7 @@ export class MiddleLayer {
               tx,
               this.templateListResourceId,
               {
-                label: foldersUniqueName(payload.label, tree.namesTakenIn(destination)),
+                label: foldersUniqueName(payload.label, tree.namesTakenIn(destination, "template")),
                 description: payload.description,
               },
               { schemaVersion: 1, document: payload.document, sender: payload.from },
@@ -1577,7 +1577,7 @@ export class MiddleLayer {
           // Scoped to where the copies are going, because that is the only place their names have
           // to be free. `taken` grows as the pack is copied, so two projects of one name inside a
           // single share do not land on top of each other either.
-          const taken = [...tree.namesTakenIn(destination)];
+          const taken = [...tree.namesTakenIn(destination, "project")];
           const created = await copyEnvelopeProjectsIntoList(
             tx,
             envelope.rid,

package/src/middle_layer/templates.test.ts

@@ -153,7 +153,7 @@ test("copying a template share lands it among the recipient's templates and buil
     const list = await awaitTemplateList(ml, (l) => l.length === 2);
     const copied = list.find((t) => t.id === outcome.templates[0]);
     if (copied === undefined) throw new Error("the copied template is not in the list");
-    // The original is at the top level too, and one folder never holds two things of one name.
+    // The original is at the top level too, and one folder never holds two templates of one name.
     expect(copied.label).toBe("A pipeline (Copy)");
     // Who sent it, kept as the copy's provenance; the donor's own source project is not part of
     // the payload and does not travel.