feat(mode): support overwriteMode (#3)

Author: BlackHole1

README.md

@@ -31,7 +31,8 @@ pnpm add @oomol-lab/sparse-file
 * `filepath`: string - Sparse file paths to create/resize
 * `size`: number - Sparse file size
 * `options?.safe`: boolean - Safe mode, default: true
-* `options?.mode`: number - File mode, default: 0o644
+* `options?.mode`: number - File mode. By default, the mode is only set when creating a file, unless overwriteMode is specified. default: 0o644
+* `options?.overwriteMode`: boolean - Overwrite mode. When the overwrite mode is allowed, the mode will be set even if the file exists. default: false
 
 In safe mode, an error will occur if the size is less than 0 or greater than `Number.MAX_SAFE_INTEGER`. Additionally, it will be rejected if the passed size is larger than the current file size.
 

src/index.test.ts

@@ -121,14 +121,79 @@ describe("create sparse without safe mode", () => {
     });
 });
 
-it.concurrent<TestContext>("create sparse with custom mode", async (ctx) => {
-    await createSparse(ctx.file, 1, {
-        mode: 0o600,
+describe("custom mode", () => {
+    it.concurrent<TestContext>("create sparse with custom mode", async (ctx) => {
+        await createSparse(ctx.file, 1, {
+            mode: 0o600,
+        });
+
+        const stat = await fs.stat(ctx.file);
+
+        expect(stat.mode & 0o777).eq(0o600);
+    });
+
+    it.concurrent<TestContext>("should overwrite mode", async (ctx) => {
+        {
+            const fh = await fs.open(ctx.file, "w", 0o644);
+            await fh.writeFile(Buffer.alloc(1));
+            await fh.sync();
+            await fh.close();
+        }
+
+        await createSparse(ctx.file, 10, {
+            mode: 0o600,
+            overwriteMode: true,
+        });
+        const stat = await fs.stat(ctx.file);
+        expect(stat.mode & 0o777).eq(0o600);
+    });
+
+    it.concurrent<TestContext>("should overwrite mode when size same", async (ctx) => {
+        {
+            const fh = await fs.open(ctx.file, "w", 0o644);
+            await fh.writeFile(Buffer.alloc(1));
+            await fh.sync();
+            await fh.close();
+        }
+
+        await createSparse(ctx.file, 1, {
+            mode: 0o600,
+            overwriteMode: true,
+        });
+        const stat = await fs.stat(ctx.file);
+        expect(stat.mode & 0o777).eq(0o600);
     });
 
-    const stat = await fs.stat(ctx.file);
+    it.concurrent<TestContext>("should maintain the original mode", async (ctx) => {
+        {
+            const fh = await fs.open(ctx.file, "w", 0o644);
+            await fh.writeFile(Buffer.alloc(1));
+            await fh.sync();
+            await fh.close();
+        }
+
+        await createSparse(ctx.file, 10, {
+            mode: 0o600,
+            overwriteMode: true,
+        });
+        const stat = await fs.stat(ctx.file);
+        expect(stat.mode & 0o777).eq(0o600);
+    });
 
-    expect(stat.mode & 0o777).eq(0o600);
+    it.concurrent<TestContext>("should overwrite mode when use default mode", async (ctx) => {
+        {
+            const fh = await fs.open(ctx.file, "w", 0o600);
+            await fh.writeFile(Buffer.alloc(1));
+            await fh.sync();
+            await fh.close();
+        }
+
+        await createSparse(ctx.file, 1, {
+            overwriteMode: true,
+        });
+        const stat = await fs.stat(ctx.file);
+        expect(stat.mode & 0o777).eq(0o644);
+    });
 });
 
 describe.concurrent("physical file size", () => {
@@ -138,7 +203,7 @@ describe.concurrent("physical file size", () => {
         expect(await physicalFileSize(ctx.file)).eq(0);
     });
 
-    it<TestContext>("should return 0 when file is empty sparsefile", async (ctx) => {
+    it<TestContext>("should return actual size when file not is empty sparsefile", async (ctx) => {
         const fh = await fs.open(ctx.file, "w");
         const { blksize } = await fh.stat();
         await fh.write(Buffer.alloc(1));

src/index.ts

@@ -7,13 +7,20 @@ export interface SparseOptions {
      */
     safe?: boolean;
     /**
+     * By default, the mode is only set when creating a file, unless overwriteMode is specified.
      * @default 0o644
      */
     mode?: number;
+    /**
+     * When the overwrite mode is allowed, the mode will be set even if the file exists.
+     * @default false
+     */
+    overwriteMode?: boolean;
 }
 
 export const createSparse = async (filepath: string, size: number, options?: SparseOptions): Promise<void> => {
-    const fh = await open(filepath, options?.mode || 0o644);
+    const mode = options?.mode || 0o644;
+    const fh = await open(filepath, mode);
 
     const curState = await fs.stat(filepath);
     if (options?.safe !== false) {
@@ -33,6 +40,9 @@ export const createSparse = async (filepath: string, size: number, options?: Spa
         }
 
         if (curState.size === size) {
+            if (options?.overwriteMode) {
+                await fh.chmod(mode);
+            }
             await fh.close();
             return;
         }
@@ -45,6 +55,9 @@ export const createSparse = async (filepath: string, size: number, options?: Spa
     }
 
     await fh.truncate(size);
+    if (options?.overwriteMode) {
+        await fh.chmod(mode);
+    }
     await fh.sync();
     await fh.close();
 };