Add FFI for access, copyFile, mkdtemp

Author: JordanMartinez

src/Node/FS/Async.js

@@ -1,4 +1,7 @@
 export {
+  access as accessImpl,
+  copyFile as copyFileImpl,
+  mkdtemp as mkdtempImpl,
   rename as renameImpl,
   truncate as truncateImpl,
   chown as chownImpl,
@@ -22,7 +25,7 @@ export {
   read as readImpl,
   write as writeImpl,
   close as closeImpl
-} from "fs";
+} from "node:fs";
 
 export function handleCallbackImpl(left, right, f) {
   return function (err, value) {

src/Node/FS/Async.purs

@@ -1,5 +1,11 @@
 module Node.FS.Async
   ( Callback(..)
+  , access
+  , access'
+  , copyFile
+  , copyFile'
+  , mkdtemp
+  , mkdtemp'
   , rename
   , truncate
   , chown
@@ -42,13 +48,15 @@ import Data.Either (Either(..))
 import Data.Function.Uncurried (Fn2, Fn6, Fn4, Fn3, runFn2, runFn6, runFn4, runFn3)
 import Data.Int (round)
 import Data.Maybe (Maybe(..))
-import Data.Nullable (Nullable, toNullable)
+import Data.Nullable (Nullable, toMaybe, toNullable)
 import Data.Time.Duration (Milliseconds(..))
 import Effect (Effect)
 import Effect.Exception (Error)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, mkEffectFn1, runEffectFn3, runEffectFn4)
 import Node.Buffer (Buffer, size)
-import Node.Encoding (Encoding)
+import Node.Encoding (Encoding(..), encodingToNode)
 import Node.FS (FileDescriptor, ByteCount, FilePosition, BufferLength, BufferOffset, FileMode, FileFlags, SymlinkType, fileFlagsToNode, symlinkTypeToNode)
+import Node.FS.Constants (AccessMode, CopyMode, defaultAccessMode, defaultCopyMode)
 import Node.FS.Internal (mkEffect)
 import Node.FS.Perms (Perms, permsToString, all, mkPerms)
 import Node.FS.Stats (StatsObj, Stats(..))
@@ -69,6 +77,31 @@ handleCallback cb = runFn3 handleCallbackImpl Left Right cb
 -- | Type synonym for callback functions.
 type Callback a = Either Error a -> Effect Unit
 
+access :: String -> (Maybe Error -> Effect Unit) -> Effect Unit
+access path = access' path defaultAccessMode
+
+access' :: String -> AccessMode -> (Maybe Error -> Effect Unit) -> Effect Unit
+access' path mode cb = runEffectFn3 accessImpl path mode $ mkEffectFn1 \err -> do
+  cb $ toMaybe err
+
+foreign import accessImpl :: EffectFn3 (String) (AccessMode) (EffectFn1 (Nullable Error) Unit) Unit
+
+copyFile :: String -> String -> Callback Unit -> Effect Unit
+copyFile src dest = copyFile' src dest defaultCopyMode
+
+copyFile' :: String -> String -> CopyMode -> Callback Unit -> Effect Unit
+copyFile' src dest mode cb = runEffectFn4 copyFileImpl src dest mode (handleCallback cb)
+
+foreign import copyFileImpl :: EffectFn4 (String) (String) (CopyMode) (JSCallback Unit) (Unit)
+
+mkdtemp :: String -> Callback String -> Effect Unit
+mkdtemp prefix = mkdtemp' prefix UTF8
+
+mkdtemp' :: String -> Encoding -> Callback String -> Effect Unit
+mkdtemp' prefix encoding cb = runEffectFn3 mkdtempImpl prefix (encodingToNode encoding) (handleCallback cb)
+
+foreign import mkdtempImpl :: EffectFn3 (String) (String) (JSCallback String) (Unit)
+
 foreign import renameImpl :: Fn3 FilePath FilePath (JSCallback Unit) Unit
 foreign import truncateImpl :: Fn3 FilePath Int (JSCallback Unit) Unit
 foreign import chownImpl :: Fn4 FilePath Int Int (JSCallback Unit) Unit

src/Node/FS/Constants.js

@@ -0,0 +1,17 @@
+import { constants } from "node:fs";
+
+export const f_OK = constants.F_OK;
+
+export const r_OK = constants.R_OK;
+
+export const w_OK = constants.W_OK;
+
+export const x_OK = constants.X_OK;
+
+export const copyFile_EXCL = constants.COPYFILE_EXCL;
+
+export const copyFile_FICLONE = constants.COPYFILE_FICLONE;
+
+export const copyFile_FICLONE_FORCE = constants.COPYFILE_FICLONE_FORCE;
+
+export const appendCopyMode = (l, r) => l | r;

src/Node/FS/Constants.purs

@@ -0,0 +1,36 @@
+module Node.FS.Constants where
+
+import Prelude
+
+import Data.Function.Uncurried (Fn2, runFn2)
+
+-- | the mode parameter passed to `access` and `accessSync`.
+foreign import data AccessMode :: Type
+
+-- | the file is visible to the calling process. 
+-- | This is useful for determining if a file exists, but says nothing about rwx permissions. Default if no mode is specified.
+foreign import f_OK :: AccessMode
+
+-- | the file can be read by the calling process.
+foreign import r_OK :: AccessMode
+
+-- | the file can be written by the calling process.
+foreign import w_OK :: AccessMode
+
+-- | the file can be executed by the calling process. This has no effect on Windows (will behave like fs.constants.F_OK).
+foreign import x_OK :: AccessMode
+
+defaultAccessMode = f_OK :: AccessMode
+
+foreign import data CopyMode :: Type
+
+foreign import copyFile_EXCL :: CopyMode
+foreign import copyFile_FICLONE :: CopyMode
+foreign import copyFile_FICLONE_FORCE :: CopyMode
+
+defaultCopyMode = copyFile_EXCL :: CopyMode
+
+foreign import appendCopyMode :: Fn2 CopyMode CopyMode CopyMode
+
+instance Semigroup CopyMode where
+  append l r = runFn2 appendCopyMode l r

src/Node/FS/Sync.js

@@ -1,4 +1,7 @@
-export {
+export { 
+  accessSync as accessImpl,
+  copyFileSync as copyFileImpl,
+  mkdtempSync as mkdtempImpl,
   renameSync as renameSyncImpl,
   truncateSync as truncateSyncImpl,
   chownSync as chownSyncImpl,
@@ -24,4 +27,4 @@ export {
   writeSync as writeSyncImpl,
   fsyncSync as fsyncSyncImpl,
   closeSync as closeSyncImpl
-} from "fs";
+} from "node:fs";

src/Node/FS/Sync.purs

@@ -1,5 +1,11 @@
 module Node.FS.Sync
-  ( rename
+  ( access
+  , access'
+  , copyFile
+  , copyFile'
+  , mkdtemp
+  , mkdtemp'
+  , rename
   , truncate
   , chown
   , chmod
@@ -36,21 +42,51 @@ module Node.FS.Sync
   ) where
 
 import Prelude
-import Effect (Effect)
+
 import Data.DateTime (DateTime)
-import Data.Time.Duration (Milliseconds(..))
 import Data.DateTime.Instant (fromDateTime, unInstant)
+import Data.Either (blush)
 import Data.Function.Uncurried (Fn1, Fn5, Fn3, Fn2, runFn1, runFn5, runFn3, runFn2)
-import Data.Nullable (Nullable(), toNullable)
 import Data.Int (round)
 import Data.Maybe (Maybe(..))
-import Node.Buffer (Buffer(), size)
-import Node.Encoding (Encoding)
+import Data.Nullable (Nullable, toNullable)
+import Data.Time.Duration (Milliseconds(..))
+import Effect (Effect)
+import Effect.Exception (Error, try)
+import Effect.Uncurried (EffectFn2, EffectFn3, runEffectFn2, runEffectFn3)
+import Node.Buffer (Buffer, size)
+import Node.Encoding (Encoding(..), encodingToNode)
 import Node.FS (FileDescriptor, ByteCount, FilePosition, BufferLength, BufferOffset, FileMode, FileFlags, SymlinkType, fileFlagsToNode, symlinkTypeToNode)
-import Node.FS.Stats (StatsObj, Stats(..))
-import Node.Path (FilePath())
-import Node.FS.Perms (Perms, permsToString, all, mkPerms)
+import Node.FS.Constants (AccessMode, defaultAccessMode, CopyMode, defaultCopyMode)
 import Node.FS.Internal (mkEffect)
+import Node.FS.Perms (Perms, permsToString, all, mkPerms)
+import Node.FS.Stats (StatsObj, Stats(..))
+import Node.Path (FilePath)
+
+access :: String -> Effect (Maybe Error)
+access = flip access' defaultAccessMode
+
+access' :: String -> AccessMode -> Effect (Maybe Error)
+access' path mode = do
+  map blush $ try $ runEffectFn2 accessImpl path mode
+
+foreign import accessImpl :: EffectFn2 (String) (AccessMode) ((Maybe Error))
+
+copyFile :: String -> String -> Effect Unit
+copyFile src dest = runEffectFn3 copyFileImpl src dest defaultCopyMode
+
+copyFile' :: String -> String -> CopyMode -> Effect Unit
+copyFile' src dest mode = runEffectFn3 copyFileImpl src dest mode
+
+foreign import copyFileImpl :: EffectFn3 (String) (String) (CopyMode) (Unit)
+
+mkdtemp :: String -> Effect String
+mkdtemp prefix = mkdtemp' prefix UTF8
+
+mkdtemp' :: String -> Encoding -> Effect String
+mkdtemp' prefix encoding = runEffectFn2 mkdtempImpl prefix (encodingToNode encoding)
+
+foreign import mkdtempImpl :: EffectFn2 (String) (String) (String)
 
 foreign import renameSyncImpl :: Fn2 FilePath FilePath Unit
 foreign import truncateSyncImpl :: Fn2 FilePath Int Unit