@hachej/boring-files 0.4.34 → 0.4.36

package/dist/contracts.d.ts

@@ -189,11 +189,15 @@ export interface ResourceRenameRequest {
     readonly to: ResourceLocator;
     readonly expectedRevision: string;
     readonly operationId: string;
+    /** Also remove the folders this leaves empty: a folder operation in the tree, never a single-file change, since another consumer may have its cwd there. */
+    readonly pruneEmptied?: true;
 }
 export interface ResourceDeleteRequest {
     readonly path: ResourceLocator;
     readonly expectedRevision: string;
     readonly operationId: string;
+    /** Also remove the folders this leaves empty: a folder operation in the tree, never a single-file change, since another consumer may have its cwd there. */
+    readonly pruneEmptied?: true;
 }
 /** Conditional regular-file mutations; receipts and lookup use the publication journal. */
 export interface ResourceRenamer {

package/dist/publication-input.js

@@ -99,11 +99,11 @@ export function renameSnapshot(value) {
         throw new TypeError('Rename requires one provider and view');
     if (from.resource.path === to.resource.path || from.resource.path.startsWith(`${to.resource.path}/`) || to.resource.path.startsWith(`${from.resource.path}/`))
         throw new TypeError('Rename requires independent file paths');
-    return { from, to, expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId) };
+    return { from, to, expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId), ...(input.pruneEmptied === true ? { pruneEmptied: true } : {}) };
 }
 export function deleteSnapshot(value) {
     const input = object(value);
-    return { path: locator(input.path), expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId) };
+    return { path: locator(input.path), expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId), ...(input.pruneEmptied === true ? { pruneEmptied: true } : {}) };
 }
 export function deletePublication(request) {
     return { operationId: request.operationId, atomicity: 'all-or-nothing', changes: [{ kind: 'delete', target: { ...request.path, revision: request.expectedRevision } }] };

package/dist/sqlite-filesystem.js

@@ -439,7 +439,7 @@ export function openSqliteFileSystem(options) {
         setMaxFileBytes: limit => { assertLimit(limit); maxFileBytes = limit; },
         bytes: path => { const found = row(normalize(path)); return !found ? null : found.kind === 'directory' ? undefined : bytes(normalize(path)); },
         write: (path, content) => { const absolute = normalize(path); makeDirectory(dirname(absolute), true); write(absolute, content); notify(); },
-        rename: (from, to) => { rename(normalize(from), normalize(to)); notify(); },
+        rename: (from, to) => { const target = normalize(to); makeDirectory(dirname(target), true); rename(normalize(from), target); notify(); },
         remove: path => { remove(normalize(path)); notify(); },
     });
     return fs;

package/dist/workspace.js

@@ -157,6 +157,20 @@ export function createWorkspaceProvider(options) {
         const bytes = Uint8Array.from(result.value);
         return { kind: 'file', bytes, revision: await blobRevision(bytes) };
     }
+    /**
+     * A folder exists through its files: the one a move or delete left empty goes, up to the first that still holds something. Best effort and
+     * never recursive, so a file landing meanwhile stays; a file system that cannot remove a directory that way (Pi's Node one) keeps the folder.
+     */
+    const pruneEmptied = async (path) => {
+        for (let folder = path.slice(0, Math.max(0, path.lastIndexOf('/'))); folder; folder = folder.slice(0, Math.max(0, folder.lastIndexOf('/')))) {
+            const listed = await fs.listDir(absolute(folder), fsContext()).catch(() => undefined);
+            if (!listed?.ok || listed.value.length)
+                return;
+            const gone = await fs.remove(absolute(folder), { recursive: false }, fsContext()).catch(() => undefined);
+            if (!gone?.ok)
+                return;
+        }
+    };
     /** Once per provider, before its first operation: remove temporary files that an earlier process left behind. */
     let swept;
     const sweep = () => swept ??= (async () => {
@@ -216,7 +230,7 @@ export function createWorkspaceProvider(options) {
             changes: committedChanges(stored.changes, ref),
         };
     }
-    const mutate = async (request, access) => {
+    const mutate = async (request, access, prune = false) => {
         const moving = 'from' in request ? request : undefined;
         const publication = 'changes' in request ? request : undefined;
         const digest = moving ? await renameDigest(moving) : await publicationDigest(publication);
@@ -365,11 +379,28 @@ export function createWorkspaceProvider(options) {
                     applying = true;
                     if (!together)
                         journal.complete(operation, record, versions);
+                    if (prune && moving)
+                        await pruneEmptied(moving.from.resource.path);
+                    else if (prune)
+                        for (const plan of plans)
+                            if (plan.change.kind === 'delete')
+                                await pruneEmptied(plan.path);
                 }
                 else if (moving || plans[0].change.kind === 'delete') {
                     applying = true;
+                    // Like a publication, a move creates the folder it lands in: a folder renames file by file, so the first file finds none.
+                    const landing = moving ? absolute(moving.to.resource.path) : '';
+                    if (moving) {
+                        const made = await fs.createDir(landing.slice(0, landing.lastIndexOf('/')) || '/', { recursive: true }, fsContext(access.signal));
+                        if (!made.ok) {
+                            if (made.error.code === 'unknown' || made.error.code === 'aborted')
+                                throw made.error;
+                            return refuse(made.error.message);
+                        }
+                    }
+                    const leaving = moving ? moving.from.resource.path : plans[0].path;
                     const result = moving
-                        ? await fs.renameFile(absolute(moving.from.resource.path), absolute(moving.to.resource.path), fsContext(access.signal))
+                        ? await fs.renameFile(absolute(moving.from.resource.path), landing, fsContext(access.signal))
                         : await fs.remove(absolute(plans[0].path), { recursive: false }, fsContext(access.signal));
                     if (!result.ok) {
                         if (result.error.code === 'unknown' || result.error.code === 'aborted')
@@ -377,6 +408,8 @@ export function createWorkspaceProvider(options) {
                         return refuse(result.error.message);
                     }
                     journal.complete(operation, record, versions);
+                    if (prune)
+                        await pruneEmptied(leaving);
                 }
                 else {
                     const { change, path, unchanged } = plans[0];
@@ -419,8 +452,8 @@ export function createWorkspaceProvider(options) {
         });
     };
     const publish = async (input, context) => mutate(publicationSnapshot(input), accessSnapshot(context));
-    const rename = async (input, context) => mutate(renameSnapshot(input), accessSnapshot(context));
-    const remove = async (input, context) => mutate(deletePublication(deleteSnapshot(input)), accessSnapshot(context));
+    const rename = async (input, context) => { const request = renameSnapshot(input); return mutate(request, accessSnapshot(context), request.pruneEmptied === true); };
+    const remove = async (input, context) => { const request = deleteSnapshot(input); return mutate(deletePublication(request), accessSnapshot(context), request.pruneEmptied === true); };
     const lookup = async (operationId, context) => {
         const id = identifier(operationId);
         const access = accessSnapshot(context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-files",
-  "version": "0.4.34",
+  "version": "0.4.36",
   "license": "MIT",
   "private": false,
   "type": "module",