atomically 1.7.0 → 2.0.0

package/src/utils/temp.ts

@@ -1,26 +1,31 @@
 
 /* IMPORT */
 
-import * as path from 'path';
-import {LIMIT_BASENAME_LENGTH} from '../consts';
-import {Disposer} from '../types';
-import FS from './fs';
+import path from 'node:path';
+import fs from 'stubborn-fs';
+import whenExit from 'when-exit';
+import {LIMIT_BASENAME_LENGTH} from '../constants';
+import type {Disposer} from '../types';
 
-/* TEMP */
+/* MAIN */
 
 //TODO: Maybe publish this as a standalone package
 
 const Temp = {
 
+  /* VARIABLES */
+
   store: <Record<string, boolean>> {}, // filePath => purge
 
+  /* API */
+
   create: ( filePath: string ): string => {
 
-    const randomness = `000000${Math.floor ( Math.random () * 16777215 ).toString ( 16 )}`.slice ( -6 ), // 6 random-enough hex characters
-          timestamp = Date.now ().toString ().slice ( -10 ), // 10 precise timestamp digits
-          prefix = 'tmp-',
-          suffix = `.${prefix}${timestamp}${randomness}`,
-          tempPath = `${filePath}${suffix}`;
+    const randomness = `000000${Math.floor ( Math.random () * 16777215 ).toString ( 16 )}`.slice ( -6 ); // 6 random-enough hex characters
+    const timestamp = Date.now ().toString ().slice ( -10 ); // 10 precise timestamp digits
+    const prefix = 'tmp-';
+    const suffix = `.${prefix}${timestamp}${randomness}`;
+    const tempPath = `${filePath}${suffix}`;
 
     return tempPath;
 
@@ -46,7 +51,7 @@ const Temp = {
 
     delete Temp.store[filePath];
 
-    FS.unlinkAttempt ( filePath );
+    fs.attempt.unlink ( filePath );
 
   },
 
@@ -56,7 +61,7 @@ const Temp = {
 
     delete Temp.store[filePath];
 
-    FS.unlinkSyncAttempt ( filePath );
+    fs.attempt.unlinkSync ( filePath );
 
   },
 
@@ -90,7 +95,7 @@ const Temp = {
 
 /* INIT */
 
-process.on ( 'exit', Temp.purgeSyncAll ); // Ensuring purgeable temp files are purged on exit
+whenExit ( Temp.purgeSyncAll ); // Ensuring purgeable temp files are purged on exit
 
 /* EXPORT */
 

package/tasks/benchmark.js

@@ -1,18 +1,20 @@
 
 /* IMPORT */
 
-const fs = require ( 'fs' ),
-      os = require ( 'os' ),
-      path = require ( 'path' ),
-      delay = require ( 'promise-resolve-timeout' ),
-      writeFileAtomic = require ( 'write-file-atomic' ),
-      {writeFile, writeFileSync} = require ( '../dist' );
+import {randomUUID} from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {setTimeout as delay} from 'node:timers/promises';
+import writeFileAtomic from 'write-file-atomic';
+import {writeFile, writeFileSync} from '../dist/index.js';
 
-/* BENCHMARK */
+/* MAIN */
 
-const TEMP = os.tmpdir (),
-      DST = i => path.join ( TEMP, `atomically-temp-${i}.txt` ),
-      ITERATIONS = 250;
+const TEMP = os.tmpdir ();
+const UUID = randomUUID ();
+const DST = i => path.join ( TEMP, `atomically-${UUID}-temp-${i}.txt` );
+const ITERATIONS = 250;
 
 const runSingleAsync = async ( name, fn, buffer, options ) => {
   console.time ( name );
@@ -37,7 +39,8 @@ const runAllDummy = () => { // Preparation run
 };
 
 const runAllAsync = async ( name, buffer ) => {
-  await runSingleAsync ( `${name} -> async -> write-file-atomic`, writeFileAtomic, buffer );
+  await runSingleAsync ( `${name} -> async -> write-file-atomic`, writeFileAtomic, buffer, { mode: 0o666 } );
+  await runSingleAsync ( `${name} -> async -> write-file-atomic (faster)`, writeFileAtomic, buffer );
   await runSingleAsync ( `${name} -> async -> write-file-atomic (fastest)`, writeFileAtomic, buffer, { fsync: false } );
   await runSingleAsync ( `${name} -> async -> atomically`, writeFile, buffer );
   await runSingleAsync ( `${name} -> async -> atomically (faster)`, writeFile, buffer, { mode: false, chown: false, fsyncWait: false } );
@@ -45,7 +48,8 @@ const runAllAsync = async ( name, buffer ) => {
 };
 
 const runAllSync = ( name, buffer ) => {
-  runSingleSync ( `${name} -> sync -> write-file-atomic`, writeFileAtomic.sync, buffer );
+  runSingleSync ( `${name} -> sync -> write-file-atomic`, writeFileAtomic.sync, buffer, { mode: 0o666 } );
+  runSingleSync ( `${name} -> sync -> write-file-atomic (faster)`, writeFileAtomic.sync, buffer );
   runSingleSync ( `${name} -> sync -> write-file-atomic (fastest)`, writeFileAtomic.sync, buffer, { fsync: false } );
   runSingleSync ( `${name} -> sync -> atomically`, writeFileSync, buffer );
   runSingleSync ( `${name} -> sync -> atomically (faster)`, writeFileSync, buffer, { mode: false, chown: false, fsyncWait: false } );

package/test/{basic.js → basic.cjs}

@@ -1,8 +1,5 @@
-'use strict'
-
 process.setMaxListeners(1000000);
 
-const _ = require('lodash')
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
@@ -117,7 +114,7 @@ const fsMock = Object.assign ( {}, fs, {
 const makeUnstableAsyncFn = function () {
   return function () {
     if ( Math.random () <= .75 ) {
-      const code = _.shuffle ([ 'EMFILE', 'ENFILE', 'EAGAIN', 'EBUSY', 'EACCESS', 'EPERM' ])[0];
+      const code = ['EMFILE', 'ENFILE', 'EAGAIN', 'EBUSY', 'EACCESS', 'EPERM'].sort ( () => Math.random () - .5 )[0];
       throw createErr ( code );
     }
     return arguments[arguments.length -1](null, arguments[0]);
@@ -127,7 +124,7 @@ const makeUnstableAsyncFn = function () {
 const makeUnstableSyncFn = function ( fn ) {
   return function () {
     if ( Math.random () <= .75 ) {
-      const code = _.shuffle ([ 'EMFILE', 'ENFILE', 'EAGAIN', 'EBUSY', 'EACCESS', 'EPERM' ])[0];
+      const code = ['EMFILE', 'ENFILE', 'EAGAIN', 'EBUSY', 'EACCESS', 'EPERM'].sort ( () => Math.random () - .5 )[0];
       throw createErr ( code );
     }
     return fn.apply(undefined, arguments)
@@ -140,14 +137,14 @@ const fsMockUnstable = Object.assign ( {}, fsMock, {
   fsync: makeUnstableAsyncFn (),
   close: makeUnstableAsyncFn (),
   rename: makeUnstableAsyncFn (),
-  openSync: makeUnstableSyncFn ( _.identity ),
-  writeSync: makeUnstableSyncFn ( _.noop ),
-  fsyncSync: makeUnstableSyncFn ( _.noop ),
-  closeSync: makeUnstableSyncFn ( _.noop ),
-  renameSync: makeUnstableSyncFn ( _.noop )
+  openSync: makeUnstableSyncFn ( x => x ),
+  writeSync: makeUnstableSyncFn ( () => {} ),
+  fsyncSync: makeUnstableSyncFn ( () => {} ),
+  closeSync: makeUnstableSyncFn ( () => {} ),
+  renameSync: makeUnstableSyncFn ( () => {} )
 });
 
-const {writeFile: writeFileAtomic, writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: fsMock });
+const {writeFile: writeFileAtomic, writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: fsMock });
 
 test('async tests', t => {
   t.plan(2)
@@ -176,34 +173,34 @@ test('async tests', t => {
       t.notOk(err)
     })
     writeFileAtomic('noopen', 'test', err => {
-      t.is(err && err.message, 'ENOOPEN', 'fs.open failures propagate')
+      t.equal(err.message, 'ENOOPEN', 'fs.open failures propagate')
     })
     writeFileAtomic('nowrite', 'test', err => {
-      t.is(err && err.message, 'ENOWRITE', 'fs.writewrite failures propagate')
+      t.equal(err.message, 'ENOWRITE', 'fs.writewrite failures propagate')
     })
     writeFileAtomic('nowrite', Buffer.from('test', 'utf8'), err => {
-      t.is(err && err.message, 'ENOWRITE', 'fs.writewrite failures propagate for buffers')
+      t.equal(err.message, 'ENOWRITE', 'fs.writewrite failures propagate for buffers')
     })
     writeFileAtomic('nochown', 'test', { chown: { uid: 100, gid: 100 } }, err => {
-      t.is(err && err.message, 'ENOCHOWN', 'Chown failures propagate')
+      t.equal(err.message, 'ENOCHOWN', 'Chown failures propagate')
     })
     writeFileAtomic('nochown', 'test', err => {
       t.notOk(err, 'No attempt to chown when no uid/gid passed in')
     })
     writeFileAtomic('nochmod', 'test', { mode: parseInt('741', 8) }, err => {
-      t.is(err && err.message, 'ENOCHMOD', 'Chmod failures propagate')
+      t.equal(err.message, 'ENOCHMOD', 'Chmod failures propagate')
     })
     writeFileAtomic('nofsyncopt', 'test', { fsync: false }, err => {
       t.notOk(err, 'fsync skipped if options.fsync is false')
     })
     writeFileAtomic('norename', 'test', err => {
-      t.is(err && err.message, 'ENORENAME', 'Rename errors propagate')
+      t.equal(err.message, 'ENORENAME', 'Rename errors propagate')
     })
     writeFileAtomic('norename nounlink', 'test', err => {
-      t.is(err && err.message, 'ENORENAME', 'Failure to unlink the temp file does not clobber the original error')
+      t.equal(err.message, 'ENORENAME', 'Failure to unlink the temp file does not clobber the original error')
     })
     writeFileAtomic('nofsync', 'test', err => {
-      t.is(err && err.message, 'ENOFSYNC', 'Fsync failures propagate')
+      t.equal(err.message, 'ENOFSYNC', 'Fsync failures propagate')
     })
     writeFileAtomic('enosys', 'test', err => {
       t.notOk(err, 'No errors on ENOSYS')
@@ -223,13 +220,13 @@ test('async tests', t => {
     const optionsImmutable = {};
     writeFileAtomic('statful', 'test', optionsImmutable, err => {
       t.notOk(err);
-      t.deepEquals(optionsImmutable, {});
+      t.same(optionsImmutable, {});
     });
     const schedule = filePath => {
-      t.is(filePath, 'good');
+      t.equal(filePath, 'good');
       return new Promise ( resolve => {
         resolve ( () => {
-          t.is(true,true);
+          t.equal(true,true);
         });
       });
     };
@@ -237,12 +234,12 @@ test('async tests', t => {
       t.notOk(err);
     });
     const tmpCreate = filePath => `.${filePath}.custom`;
-    const tmpCreated = filePath => t.is ( filePath, '.good.custom' );
+    const tmpCreated = filePath => t.equal(filePath, '.good.custom' );
     writeFileAtomic('good','test', {tmpCreate, tmpCreated}, err => {
       t.notOk(err)
     })
     const longPath = path.join(os.tmpdir(),'.012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.txt');
-    const {writeFile: writeFileAtomicNative} = requireInject('../dist', { fs });
+    const {writeFile: writeFileAtomicNative} = requireInject('./atomically.cjs', { fs });
     writeFileAtomicNative(longPath,'test', err => {
       t.notOk(err)
     })
@@ -258,7 +255,7 @@ test('async tests', t => {
     t.teardown(() => {
       process.getuid = getuid
     })
-    const {writeFile: writeFileAtomic} = requireInject('../dist', { fs: fsMock });
+    const {writeFile: writeFileAtomic} = requireInject('./atomically.cjs', { fs: fsMock });
     t.plan(2)
     writeFileAtomic('einval', 'test', { chown: { uid: 100, gid: 100 } }, err => {
       t.match(err, { code: 'EINVAL' })
@@ -271,12 +268,12 @@ test('async tests', t => {
 
 test('unstable async tests', t => {
   t.plan(2);
-  const {writeFile: writeFileAtomic} = requireInject('../dist', { fs: fsMockUnstable });
+  const {writeFile: writeFileAtomic} = requireInject('./atomically.cjs', { fs: fsMockUnstable });
   writeFileAtomic('good', 'test', err => {
     t.notOk(err, 'No errors occur when retryable errors are thrown')
   })
   writeFileAtomic('good', 'test', { timeout: 0 }, err => {
-    t.is(!!err.code, true, 'Retrying can be disabled')
+    t.equal(!!err.code, true, 'Retrying can be disabled')
   })
 });
 
@@ -293,12 +290,12 @@ test('sync tests', t => {
   const throws = function (t, shouldthrow, msg, todo) {
     let err
     try { todo() } catch (e) { err = e }
-    t.is(shouldthrow, err && err.message, msg)
+    t.equal(shouldthrow, err.message, msg)
   }
   const noexception = function (t, msg, todo) {
     let err
     try { todo() } catch (e) { err = e }
-    t.ifError(err, msg)
+    t.error(err, msg)
   }
   let tmpfile
 
@@ -334,7 +331,7 @@ test('sync tests', t => {
         }
       })
     })
-    t.is(tmpfile, undefined, 'tmpCreated not called for open failure')
+    t.equal(tmpfile, undefined, 'tmpCreated not called for open failure')
 
     throws(t, 'ENOWRITE', 'fs.writeSync failures propagate', () => {
       writeFileAtomicSync('nowrite', 'test', {
@@ -386,44 +383,44 @@ test('sync tests', t => {
     noexception(t, 'options are immutable', () => {
       writeFileAtomicSync('statful', 'test', optionsImmutable)
     })
-    t.deepEquals(optionsImmutable, {});
+    t.same(optionsImmutable, {});
     const tmpCreate = filePath => `.${filePath}.custom`;
-    const tmpCreated = filePath => t.is ( filePath, '.good.custom' );
+    const tmpCreated = filePath => t.equal(filePath, '.good.custom' );
     noexception(t, 'custom temp creator', () => {
       writeFileAtomicSync('good', 'test', {tmpCreate, tmpCreated})
     })
     const path0 = path.join(os.tmpdir(),'atomically-test-0');
     const tmpPath0 = path0 + '.temp';
     noexception(t, 'temp files are purged on success', () => {
-      const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs });
+      const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs });
       writeFileAtomicSync(path0, 'test', {tmpCreate: () => tmpPath0})
     })
-    t.is(true,fs.existsSync(path0));
-    t.is(false,fs.existsSync(tmpPath0));
+    t.equal(true,fs.existsSync(path0));
+    t.equal(false,fs.existsSync(tmpPath0));
     const path1 = path.join(os.tmpdir(),'atomically-test-norename-1');
     const tmpPath1 = path1 + '.temp';
     throws(t, 'ENORENAME', 'temp files are purged on error', () => {
-      const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: Object.assign ( {}, fs, { renameSync: fsMock.renameSync })});
+      const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: Object.assign ( {}, fs, { renameSync: fsMock.renameSync })});
       writeFileAtomicSync(path1, 'test', {tmpCreate: () => tmpPath1})
     })
-    t.is(false,fs.existsSync(path1));
-    t.is(false,fs.existsSync(tmpPath1));
+    t.equal(false,fs.existsSync(path1));
+    t.equal(false,fs.existsSync(tmpPath1));
     const path2 = path.join(os.tmpdir(),'atomically-test-norename-2');
     const tmpPath2 = path2 + '.temp';
     throws(t, 'ENORENAME', 'temp files can also not be purged on error', () => {
-      const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: Object.assign ( {}, fs, { renameSync: fsMock.renameSync })});
+      const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: Object.assign ( {}, fs, { renameSync: fsMock.renameSync })});
       writeFileAtomicSync(path2, 'test', {tmpCreate: () => tmpPath2,tmpPurge: false})
     })
-    t.is(false,fs.existsSync(path2));
-    t.is(true,fs.existsSync(tmpPath2));
+    t.equal(false,fs.existsSync(path2));
+    t.equal(true,fs.existsSync(tmpPath2));
     const longPath = path.join(os.tmpdir(),'.012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.txt');
     noexception(t, 'temp files are truncated', () => {
-      const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs });
+      const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs });
       writeFileAtomicSync(longPath, 'test')
     })
     const pathMissingFolders = path.join(os.tmpdir(),String(Math.random()),String(Math.random()),String(Math.random()),'foo.txt');
     noexception(t, 'parent folders are created', () => {
-      const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs });
+      const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs });
       writeFileAtomicSync(pathMissingFolders, 'test')
     })
   })
@@ -434,7 +431,7 @@ test('sync tests', t => {
     t.teardown(() => {
       process.getuid = getuid
     })
-    const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: fsMock });
+    const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: fsMock });
     t.plan(2)
     throws(t, 'EINVAL', 'Chown error as root user', () => {
       writeFileAtomicSync('einval', 'test', { chown: { uid: 100, gid: 100 } })
@@ -451,21 +448,22 @@ test('unstable sync tests', t => {
   const throws = function (t, msg, todo) {
     let err
     try { todo() } catch (e) { err = e }
-    t.is(!!err.code, true, msg)
+    t.equal(!!err.code, true, msg)
   }
+
   const noexception = function (t, msg, todo) {
     let err
     try { todo() } catch (e) { err = e }
-    t.ifError(err, msg)
+    t.error(err, msg)
   }
 
   noexception(t, 'No errors occur when retryable errors are thrown', () => {
-    const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: fsMockUnstable });
+    const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: fsMockUnstable });
     writeFileAtomicSync('good', 'test')
   })
 
   throws(t, 'retrying can be disabled', () => {
-    const {writeFileSync: writeFileAtomicSync} = requireInject('../dist', { fs: fsMockUnstable });
+    const {writeFileSync: writeFileAtomicSync} = requireInject('./atomically.cjs', { fs: fsMockUnstable });
     writeFileAtomicSync('good', 'test', { timeout: 0 })
   })
 });
@@ -499,7 +497,7 @@ test('promises', async t => {
       tmpfile = gottmpfile
     }
   }))
-  t.is(tmpfile, undefined, 'tmpCreated is not called on open failure')
+  t.equal(tmpfile, undefined, 'tmpCreated is not called on open failure')
 
   await t.rejects(writeFileAtomic('nowrite', 'test', {
     tmpCreated (gottmpfile) {

package/test/{concurrency.js → concurrency.cjs}

@@ -1,5 +1,3 @@
-'use strict'
-
 process.setMaxListeners(1000000);
 
 const fs = require('fs')
@@ -84,7 +82,7 @@ const fsMock = Object.assign ( {}, fs, {
   }
 })
 
-const {writeFile: writeFileAtomic} = requireInject('../dist', { fs: fsMock });
+const {writeFile: writeFileAtomic} = requireInject('./atomically.cjs', { fs: fsMock });
 
 // preserve original functions
 const oldRealPath = fsMock.realpath
@@ -95,16 +93,16 @@ test('ensure writes to the same file are serial', t => {
   const ops = 5 // count for how many concurrent write ops to request
   t.plan(ops * 3 + 3)
   fsMock.realpath = (...args) => {
-    t.false(fileInUse, 'file not in use')
+    t.notOk(fileInUse, 'file not in use')
     fileInUse = true
     oldRealPath(...args)
   }
   fsMock.rename = (...args) => {
-    t.true(fileInUse, 'file in use')
+    t.ok(fileInUse, 'file in use')
     fileInUse = false
     oldRename(...args)
   }
-  const {writeFile: writeFileAtomic} = requireInject('../dist', { fs: fsMock });
+  const {writeFile: writeFileAtomic} = requireInject('./atomically.cjs', { fs: fsMock });
   for (let i = 0; i < ops; i++) {
     writeFileAtomic('test', 'test', err => {
       if (err) t.fail(err)
@@ -134,7 +132,7 @@ test('allow write to multiple files in parallel, but same file writes are serial
     filesInUse.splice(filesInUse.indexOf(filename), 1)
     oldRename(filename, ...args)
   }
-  const {writeFile: writeFileAtomic} = requireInject('../dist', { fs: fsMock });
+  const {writeFile: writeFileAtomic} = requireInject('./atomically.cjs', { fs: fsMock });
   t.plan(ops * 2 * 2 + 1)
   let opCount = 0
   for (let i = 0; i < ops; i++) {
@@ -144,7 +142,7 @@ test('allow write to multiple files in parallel, but same file writes are serial
     })
     writeFileAtomic('test2', 'test', err => {
       opCount++
-      if (opCount === ops) t.true(wasParallel, 'parallel writes')
+      if (opCount === ops) t.ok(wasParallel, 'parallel writes')
 
       if (err) t.fail(err, 'wrote without error')
       else t.pass('wrote without error')