@funnelsgrove/cli 0.1.20 → 0.1.26

package/dist/localSync.d.ts

@@ -17,6 +17,10 @@ export type SourceFile = {
     contentType?: string;
     contentEncoding?: 'base64';
 };
+export type SafeRootWriteHooks = {
+    beforeDirectoryCreate?: (relativeDirectoryPath: string) => void | Promise<void>;
+    afterDirectoryEntrySync?: (relativeDirectoryPath: string) => void | Promise<void>;
+};
 export type ChangedSourceFiles = {
     currentManifest: SyncManifest;
     deletedPaths: string[];
@@ -80,7 +84,11 @@ export type SyncDownLocalLifecycle = {
     writeSyncState: () => Promise<unknown>;
 };
 export declare function runSyncDownLocalLifecycle(lifecycle: SyncDownLocalLifecycle): Promise<void>;
+export declare const assertSafeRootFileWriteTarget: (rootDir: string, relativePath: string) => Promise<void>;
+export declare const readSafeRootFile: (rootDir: string, relativePath: string) => Promise<Buffer>;
+export declare const writeSafeRootFile: (rootDir: string, relativePath: string, content: string | Buffer, hooks?: SafeRootWriteHooks) => Promise<void>;
 export declare function normalizeSyncPath(filePath: string): string;
+export declare function assertSafeSyncPath(filePath: string): string;
 export declare function shouldSyncFile(filePath: string): boolean;
 export declare function buildSyncManifest(rootDir: string, input: SyncManifestInput): Promise<SyncManifest>;
 export declare function buildCommittedSyncManifest(input: {

package/dist/localSync.js

@@ -60,28 +60,83 @@ const resolveSafeRoot = async (rootDir, create) => {
     }
     return realpath(rootDir);
 };
-const assertSafeExistingPath = async (rootDir, relativePath, createParents) => {
-    const safePath = assertSafeSyncPath(relativePath);
-    const segments = safePath.split('/');
+const syncDirectory = async (directoryPath) => {
+    const handle = await open(directoryPath, constants.O_RDONLY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+const ensureDurableDirectoryChain = async (rootDir, segments, hooks) => {
     let current = rootDir;
-    for (const segment of segments.slice(0, -1)) {
+    for (const [index, segment] of segments.entries()) {
+        const parent = current;
         current = path.join(current, segment);
         let metadata;
         try {
             metadata = await lstat(current);
         }
         catch (error) {
-            if (!createParents || !isErrno(error, 'ENOENT'))
+            if (!isErrno(error, 'ENOENT'))
                 throw error;
-            await mkdir(current);
+            const relativeDirectoryPath = segments.slice(0, index + 1).join('/');
+            await hooks.beforeDirectoryCreate?.(relativeDirectoryPath);
+            try {
+                await mkdir(current);
+            }
+            catch (mkdirError) {
+                if (!isErrno(mkdirError, 'EEXIST'))
+                    throw mkdirError;
+            }
             metadata = await lstat(current);
+            if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+                throw sourceCandidateInvariantError(`Local sync path traverses a symlink: ${relativeDirectoryPath}`);
+            }
+            await syncDirectory(parent);
+            await hooks.afterDirectoryEntrySync?.(relativeDirectoryPath);
+            continue;
         }
         if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
-            throw sourceCandidateInvariantError(`Local sync path traverses a symlink: ${relativePath}`);
+            throw sourceCandidateInvariantError(`Local sync path traverses a symlink: ${segments.join('/')}`);
+        }
+    }
+};
+const assertSafeExistingPath = async (rootDir, relativePath, createParents, allowMissingParents = false, hooks = {}) => {
+    const safePath = assertSafeSyncPath(relativePath);
+    const segments = safePath.split('/');
+    let parentIsMissing = false;
+    const parentSegments = segments.slice(0, -1);
+    if (createParents) {
+        await ensureDurableDirectoryChain(rootDir, parentSegments, hooks);
+    }
+    else {
+        let current = rootDir;
+        for (const segment of parentSegments) {
+            current = path.join(current, segment);
+            if (parentIsMissing)
+                continue;
+            let metadata;
+            try {
+                metadata = await lstat(current);
+            }
+            catch (error) {
+                if (allowMissingParents && isErrno(error, 'ENOENT')) {
+                    parentIsMissing = true;
+                    continue;
+                }
+                throw error;
+            }
+            if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+                throw sourceCandidateInvariantError(`Local sync path traverses a symlink: ${relativePath}`);
+            }
         }
     }
     const absolutePath = path.join(rootDir, ...segments);
     assertContainedPath(rootDir, absolutePath);
+    if (parentIsMissing)
+        return absolutePath;
     try {
         const metadata = await lstat(absolutePath);
         if (metadata.isSymbolicLink() || !metadata.isFile()) {
@@ -94,6 +149,10 @@ const assertSafeExistingPath = async (rootDir, relativePath, createParents) => {
     }
     return absolutePath;
 };
+export const assertSafeRootFileWriteTarget = async (rootDir, relativePath) => {
+    const resolvedRoot = await resolveSafeRoot(rootDir, false);
+    await assertSafeExistingPath(resolvedRoot, relativePath, false, true);
+};
 const assertOpenFileContained = async (rootDir, absolutePath, opened) => {
     const openedStat = await opened.stat();
     if (!openedStat.isFile()) {
@@ -106,7 +165,7 @@ const assertOpenFileContained = async (rootDir, absolutePath, opened) => {
         throw sourceCandidateInvariantError('Local source changed while opening it. Retry the sync.');
     }
 };
-const readSafeRootFile = async (rootDir, relativePath) => {
+export const readSafeRootFile = async (rootDir, relativePath) => {
     const resolvedRoot = await resolveSafeRoot(rootDir, false);
     const absolutePath = await assertSafeExistingPath(resolvedRoot, relativePath, false);
     let handle;
@@ -127,9 +186,9 @@ const readSafeRootFile = async (rootDir, relativePath) => {
         await handle.close();
     }
 };
-const writeSafeRootFile = async (rootDir, relativePath, content) => {
+export const writeSafeRootFile = async (rootDir, relativePath, content, hooks = {}) => {
     const resolvedRoot = await resolveSafeRoot(rootDir, true);
-    const absolutePath = await assertSafeExistingPath(resolvedRoot, relativePath, true);
+    const absolutePath = await assertSafeExistingPath(resolvedRoot, relativePath, true, false, hooks);
     const tempPath = path.join(path.dirname(absolutePath), `.${path.basename(absolutePath)}.fgrove-${randomUUID()}.tmp`);
     let handle = null;
     try {
@@ -141,6 +200,7 @@ const writeSafeRootFile = async (rootDir, relativePath, content) => {
         handle = null;
         await assertSafeExistingPath(resolvedRoot, relativePath, true);
         await rename(tempPath, absolutePath);
+        await syncDirectory(path.dirname(absolutePath));
         assertContainedPath(resolvedRoot, await realpath(absolutePath));
     }
     finally {
@@ -154,7 +214,7 @@ export function normalizeSyncPath(filePath) {
     return normalized.replace(/^(\.\/|\/)+/, '');
 }
 const sourceCandidateInvariantError = (reason) => Object.assign(new Error(reason), { code: 'FG-CANDIDATE-001' });
-function assertSafeSyncPath(filePath) {
+export function assertSafeSyncPath(filePath) {
     if (filePath.length === 0
         || Array.from(filePath).length > MAX_SOURCE_CANDIDATE_PATH_CHARACTERS
         || filePath !== filePath.trim()