pumuki 6.3.7

package/core/facts/detectors/fs/callbacks.ts

@@ -0,0 +1,93 @@
+import { hasNode, isObject } from '../utils/astHelpers';
+
+const createFsCallbackDetector = (methodName: string) => {
+  return (node: unknown): boolean => {
+    return hasNode(node, (value) => {
+      if (value.type !== 'CallExpression') {
+        return false;
+      }
+      const callee = value.callee;
+
+      if (isObject(callee) && callee.type === 'MemberExpression') {
+        const propertyNode = callee.property;
+        const isTargetProperty =
+          (callee.computed === true &&
+            isObject(propertyNode) &&
+            propertyNode.type === 'StringLiteral' &&
+            propertyNode.value === methodName) ||
+          (callee.computed !== true &&
+            isObject(propertyNode) &&
+            propertyNode.type === 'Identifier' &&
+            propertyNode.name === methodName);
+        if (!isTargetProperty) {
+          return false;
+        }
+
+        const objectNode = callee.object;
+        const isFsObject =
+          isObject(objectNode) &&
+          objectNode.type === 'Identifier' &&
+          objectNode.name === 'fs';
+        if (!isFsObject) {
+          return false;
+        }
+
+        const args = value.arguments as unknown[];
+        return Array.isArray(args) && args.some((argument: unknown) => {
+          return (
+            isObject(argument) &&
+            (argument.type === 'ArrowFunctionExpression' || argument.type === 'FunctionExpression')
+          );
+        });
+      }
+
+      return false;
+    });
+  };
+};
+
+export const hasFsUtimesCallbackCall = createFsCallbackDetector('utimes');
+export const hasFsWatchCallbackCall = createFsCallbackDetector('watch');
+export const hasFsWatchFileCallbackCall = createFsCallbackDetector('watchFile');
+export const hasFsUnwatchFileCallbackCall = createFsCallbackDetector('unwatchFile');
+export const hasFsReadFileCallbackCall = createFsCallbackDetector('readFile');
+export const hasFsExistsCallbackCall = createFsCallbackDetector('exists');
+export const hasFsWriteFileCallbackCall = createFsCallbackDetector('writeFile');
+export const hasFsAppendFileCallbackCall = createFsCallbackDetector('appendFile');
+export const hasFsReaddirCallbackCall = createFsCallbackDetector('readdir');
+export const hasFsMkdirCallbackCall = createFsCallbackDetector('mkdir');
+export const hasFsRmdirCallbackCall = createFsCallbackDetector('rmdir');
+export const hasFsRmCallbackCall = createFsCallbackDetector('rm');
+export const hasFsRenameCallbackCall = createFsCallbackDetector('rename');
+export const hasFsCopyFileCallbackCall = createFsCallbackDetector('copyFile');
+export const hasFsStatCallbackCall = createFsCallbackDetector('stat');
+export const hasFsStatfsCallbackCall = createFsCallbackDetector('statfs');
+export const hasFsLstatCallbackCall = createFsCallbackDetector('lstat');
+export const hasFsRealpathCallbackCall = createFsCallbackDetector('realpath');
+export const hasFsAccessCallbackCall = createFsCallbackDetector('access');
+export const hasFsChmodCallbackCall = createFsCallbackDetector('chmod');
+export const hasFsChownCallbackCall = createFsCallbackDetector('chown');
+export const hasFsLchownCallbackCall = createFsCallbackDetector('lchown');
+export const hasFsLchmodCallbackCall = createFsCallbackDetector('lchmod');
+export const hasFsUnlinkCallbackCall = createFsCallbackDetector('unlink');
+export const hasFsReadlinkCallbackCall = createFsCallbackDetector('readlink');
+export const hasFsSymlinkCallbackCall = createFsCallbackDetector('symlink');
+export const hasFsLinkCallbackCall = createFsCallbackDetector('link');
+export const hasFsMkdtempCallbackCall = createFsCallbackDetector('mkdtemp');
+export const hasFsOpendirCallbackCall = createFsCallbackDetector('opendir');
+export const hasFsOpenCallbackCall = createFsCallbackDetector('open');
+export const hasFsCpCallbackCall = createFsCallbackDetector('cp');
+export const hasFsCloseCallbackCall = createFsCallbackDetector('close');
+export const hasFsReadCallbackCall = createFsCallbackDetector('read');
+export const hasFsWriteCallbackCall = createFsCallbackDetector('write');
+export const hasFsFsyncCallbackCall = createFsCallbackDetector('fsync');
+export const hasFsFdatasyncCallbackCall = createFsCallbackDetector('fdatasync');
+export const hasFsFtruncateCallbackCall = createFsCallbackDetector('ftruncate');
+export const hasFsTruncateCallbackCall = createFsCallbackDetector('truncate');
+export const hasFsFutimesCallbackCall = createFsCallbackDetector('futimes');
+export const hasFsLutimesCallbackCall = createFsCallbackDetector('lutimes');
+export const hasFsFchownCallbackCall = createFsCallbackDetector('fchown');
+export const hasFsFchmodCallbackCall = createFsCallbackDetector('fchmod');
+export const hasFsFstatCallbackCall = createFsCallbackDetector('fstat');
+export const hasFsReadvCallbackCall = createFsCallbackDetector('readv');
+export const hasFsWritevCallbackCall = createFsCallbackDetector('writev');

package/core/facts/detectors/fs/promises.test.ts

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  hasFsPromisesAppendFileCall,
+  hasFsPromisesMkdirCall,
+  hasFsPromisesOpenCall,
+  hasFsPromisesReadFileCall,
+  hasFsPromisesRmCall,
+  hasFsPromisesWriteFileCall,
+} from './promises';
+
+const createFsPromisesCallAst = (
+  methodName: string,
+  options?: {
+    computedMethod?: boolean;
+    computedPromises?: boolean;
+    fsObjectName?: string;
+    promisesPropertyName?: string;
+  }
+) => {
+  const computedMethod = options?.computedMethod === true;
+  const computedPromises = options?.computedPromises === true;
+  const fsObjectName = options?.fsObjectName ?? 'fs';
+  const promisesPropertyName = options?.promisesPropertyName ?? 'promises';
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      computed: computedMethod,
+      object: {
+        type: 'MemberExpression',
+        computed: computedPromises,
+        object: { type: 'Identifier', name: fsObjectName },
+        property: computedPromises
+          ? { type: 'StringLiteral', value: promisesPropertyName }
+          : { type: 'Identifier', name: promisesPropertyName },
+      },
+      property: computedMethod
+        ? { type: 'StringLiteral', value: methodName }
+        : { type: 'Identifier', name: methodName },
+    },
+    arguments: [{ type: 'StringLiteral', value: '/tmp/file.txt' }],
+  };
+};
+
+test('detectores fs.promises detectan llamadas esperadas', () => {
+  assert.equal(hasFsPromisesWriteFileCall(createFsPromisesCallAst('writeFile')), true);
+  assert.equal(hasFsPromisesAppendFileCall(createFsPromisesCallAst('appendFile')), true);
+  assert.equal(hasFsPromisesRmCall(createFsPromisesCallAst('rm')), true);
+  assert.equal(hasFsPromisesReadFileCall(createFsPromisesCallAst('readFile')), true);
+  assert.equal(hasFsPromisesMkdirCall(createFsPromisesCallAst('mkdir')), true);
+  assert.equal(hasFsPromisesOpenCall(createFsPromisesCallAst('open')), true);
+});
+
+test('detectores fs.promises soportan propiedades computed', () => {
+  assert.equal(
+    hasFsPromisesWriteFileCall(
+      createFsPromisesCallAst('writeFile', { computedPromises: true, computedMethod: true })
+    ),
+    true
+  );
+  assert.equal(
+    hasFsPromisesReadFileCall(
+      createFsPromisesCallAst('readFile', { computedPromises: true, computedMethod: true })
+    ),
+    true
+  );
+});
+
+test('detectores fs.promises descartan objetos y rutas no validas', () => {
+  assert.equal(
+    hasFsPromisesWriteFileCall(createFsPromisesCallAst('writeFile', { fsObjectName: 'fsp' })),
+    false
+  );
+  assert.equal(
+    hasFsPromisesReadFileCall(
+      createFsPromisesCallAst('readFile', { promisesPropertyName: 'promise' })
+    ),
+    false
+  );
+});
+
+test('detectores fs.promises descartan metodos distintos al detector', () => {
+  assert.equal(hasFsPromisesWriteFileCall(createFsPromisesCallAst('appendFile')), false);
+  assert.equal(hasFsPromisesRmCall(createFsPromisesCallAst('unlink')), false);
+  assert.equal(hasFsPromisesMkdirCall(createFsPromisesCallAst('mkdtemp')), false);
+});

package/core/facts/detectors/fs/promises.ts

@@ -0,0 +1,75 @@
+import { hasNode, isObject } from '../utils/astHelpers';
+
+const createFsPromiseDetector = (methodName: string) => {
+  return (node: unknown): boolean => {
+    return hasNode(node, (value) => {
+      if (value.type !== 'CallExpression') {
+        return false;
+      }
+      const callee = value.callee;
+      if (!isObject(callee) || callee.type !== 'MemberExpression') {
+        return false;
+      }
+
+      const propertyNode = callee.property;
+      const isTargetProperty =
+        (callee.computed === true &&
+          isObject(propertyNode) &&
+          propertyNode.type === 'StringLiteral' &&
+          propertyNode.value === methodName) ||
+        (callee.computed !== true &&
+          isObject(propertyNode) &&
+          propertyNode.type === 'Identifier' &&
+          propertyNode.name === methodName);
+      if (!isTargetProperty) {
+        return false;
+      }
+
+      const objectNode = callee.object;
+      if (!isObject(objectNode) || objectNode.type !== 'MemberExpression') {
+        return false;
+      }
+
+      const promisesProperty = objectNode.property;
+      const isPromisesProperty =
+        (objectNode.computed === true &&
+          isObject(promisesProperty) &&
+          promisesProperty.type === 'StringLiteral' &&
+          promisesProperty.value === 'promises') ||
+        (objectNode.computed !== true &&
+          isObject(promisesProperty) &&
+          promisesProperty.type === 'Identifier' &&
+          promisesProperty.name === 'promises');
+      if (!isPromisesProperty) {
+        return false;
+      }
+
+      const fsNode = objectNode.object;
+      return isObject(fsNode) && fsNode.type === 'Identifier' && fsNode.name === 'fs';
+    });
+  };
+};
+
+export const hasFsPromisesWriteFileCall = createFsPromiseDetector('writeFile');
+export const hasFsPromisesAppendFileCall = createFsPromiseDetector('appendFile');
+export const hasFsPromisesRmCall = createFsPromiseDetector('rm');
+export const hasFsPromisesUnlinkCall = createFsPromiseDetector('unlink');
+export const hasFsPromisesReadFileCall = createFsPromiseDetector('readFile');
+export const hasFsPromisesReaddirCall = createFsPromiseDetector('readdir');
+export const hasFsPromisesMkdirCall = createFsPromiseDetector('mkdir');
+export const hasFsPromisesStatCall = createFsPromiseDetector('stat');
+export const hasFsPromisesCopyFileCall = createFsPromiseDetector('copyFile');
+export const hasFsPromisesRenameCall = createFsPromiseDetector('rename');
+export const hasFsPromisesAccessCall = createFsPromiseDetector('access');
+export const hasFsPromisesChmodCall = createFsPromiseDetector('chmod');
+export const hasFsPromisesChownCall = createFsPromiseDetector('chown');
+export const hasFsPromisesUtimesCall = createFsPromiseDetector('utimes');
+export const hasFsPromisesLstatCall = createFsPromiseDetector('lstat');
+export const hasFsPromisesRealpathCall = createFsPromiseDetector('realpath');
+export const hasFsPromisesSymlinkCall = createFsPromiseDetector('symlink');
+export const hasFsPromisesLinkCall = createFsPromiseDetector('link');
+export const hasFsPromisesReadlinkCall = createFsPromiseDetector('readlink');
+export const hasFsPromisesOpenCall = createFsPromiseDetector('open');
+export const hasFsPromisesOpendirCall = createFsPromiseDetector('opendir');
+export const hasFsPromisesCpCall = createFsPromiseDetector('cp');
+export const hasFsPromisesMkdtempCall = createFsPromiseDetector('mkdtemp');

package/core/facts/detectors/fs/sync.test.ts

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  hasFsReadlinkSyncCall,
+  hasFsStatSyncCall,
+  hasFsUnlinkSyncCall,
+} from './sync';
+
+const createFsSyncCallAst = (
+  methodName: string,
+  options?: { objectName?: string; computed?: boolean }
+) => {
+  const objectName = options?.objectName ?? 'fs';
+  const computed = options?.computed === true;
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      computed,
+      object: { type: 'Identifier', name: objectName },
+      property: computed
+        ? { type: 'StringLiteral', value: methodName }
+        : { type: 'Identifier', name: methodName },
+    },
+    arguments: [{ type: 'StringLiteral', value: '/tmp/file.txt' }],
+  };
+};
+
+test('sync barrel expone detectores de part1, part2 y part3', () => {
+  assert.equal(hasFsStatSyncCall(createFsSyncCallAst('statSync')), true);
+  assert.equal(hasFsUnlinkSyncCall(createFsSyncCallAst('unlinkSync')), true);
+  assert.equal(hasFsReadlinkSyncCall(createFsSyncCallAst('readlinkSync')), true);
+});
+
+test('sync barrel descarta objetos distintos de fs', () => {
+  assert.equal(hasFsStatSyncCall(createFsSyncCallAst('statSync', { objectName: 'fsp' })), false);
+  assert.equal(
+    hasFsUnlinkSyncCall(createFsSyncCallAst('unlinkSync', { objectName: 'fsp' })),
+    false
+  );
+});
+
+test('sync barrel descarta propiedades computed y metodos no coincidentes', () => {
+  assert.equal(hasFsReadlinkSyncCall(createFsSyncCallAst('readlinkSync', { computed: true })), false);
+  assert.equal(hasFsStatSyncCall(createFsSyncCallAst('lstatSync')), false);
+  assert.equal(hasFsUnlinkSyncCall(createFsSyncCallAst('rmdirSync')), false);
+});

package/core/facts/detectors/fs/sync.ts

@@ -0,0 +1,3 @@
+export * from './syncPart1';
+export * from './syncPart2';
+export * from './syncPart3';

package/core/facts/detectors/fs/syncPart1.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  hasFsMkdirSyncCall,
+  hasFsStatSyncCall,
+  hasFsUtimesSyncCall,
+  hasFsWriteFileSyncCall,
+} from './syncPart1';
+
+const createFsSyncCallAst = (
+  methodName: string,
+  options?: { objectName?: string; computed?: boolean }
+) => {
+  const objectName = options?.objectName ?? 'fs';
+  const computed = options?.computed === true;
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      computed,
+      object: { type: 'Identifier', name: objectName },
+      property: computed
+        ? { type: 'StringLiteral', value: methodName }
+        : { type: 'Identifier', name: methodName },
+    },
+    arguments: [{ type: 'StringLiteral', value: '/tmp/file.txt' }],
+  };
+};
+
+test('syncPart1 reexporta detectores y detecta fs.statSync', () => {
+  assert.equal(hasFsStatSyncCall(createFsSyncCallAst('statSync')), true);
+  assert.equal(hasFsStatSyncCall(createFsSyncCallAst('lstatSync')), false);
+});
+
+test('syncPart1 detecta fs.writeFileSync y descarta objeto distinto', () => {
+  assert.equal(hasFsWriteFileSyncCall(createFsSyncCallAst('writeFileSync')), true);
+  assert.equal(
+    hasFsWriteFileSyncCall(createFsSyncCallAst('writeFileSync', { objectName: 'fsp' })),
+    false
+  );
+});
+
+test('syncPart1 detecta fs.mkdirSync y descarta propiedades computed', () => {
+  assert.equal(hasFsMkdirSyncCall(createFsSyncCallAst('mkdirSync')), true);
+  assert.equal(hasFsMkdirSyncCall(createFsSyncCallAst('mkdirSync', { computed: true })), false);
+});
+
+test('syncPart1 detecta fs.utimesSync y descarta metodos distintos', () => {
+  assert.equal(hasFsUtimesSyncCall(createFsSyncCallAst('utimesSync')), true);
+  assert.equal(hasFsUtimesSyncCall(createFsSyncCallAst('futimesSync')), false);
+});

package/core/facts/detectors/fs/syncPart1.ts

@@ -0,0 +1,3 @@
+export * from './syncPart1Metadata';
+export * from './syncPart1FileOps';
+export * from './syncPart1DirTimes';

package/core/facts/detectors/fs/syncPart1DirTimes.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  hasFsMkdirSyncCall,
+  hasFsReaddirSyncCall,
+  hasFsRmSyncCall,
+  hasFsUtimesSyncCall,
+} from './syncPart1DirTimes';
+
+const createFsDirTimesCallAst = (
+  methodName: string,
+  options?: { objectName?: string; computed?: boolean }
+) => {
+  const objectName = options?.objectName ?? 'fs';
+  const computed = options?.computed === true;
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      computed,
+      object: { type: 'Identifier', name: objectName },
+      property: computed
+        ? { type: 'StringLiteral', value: methodName }
+        : { type: 'Identifier', name: methodName },
+    },
+    arguments: [{ type: 'StringLiteral', value: '/tmp/file.txt' }],
+  };
+};
+
+test('syncPart1DirTimes detecta llamadas fs.*Sync esperadas', () => {
+  assert.equal(hasFsRmSyncCall(createFsDirTimesCallAst('rmSync')), true);
+  assert.equal(hasFsMkdirSyncCall(createFsDirTimesCallAst('mkdirSync')), true);
+  assert.equal(hasFsReaddirSyncCall(createFsDirTimesCallAst('readdirSync')), true);
+  assert.equal(hasFsUtimesSyncCall(createFsDirTimesCallAst('utimesSync')), true);
+});
+
+test('syncPart1DirTimes descarta objeto distinto de fs', () => {
+  assert.equal(hasFsRmSyncCall(createFsDirTimesCallAst('rmSync', { objectName: 'fsp' })), false);
+  assert.equal(
+    hasFsReaddirSyncCall(createFsDirTimesCallAst('readdirSync', { objectName: 'fsp' })),
+    false
+  );
+});
+
+test('syncPart1DirTimes descarta propiedades computed', () => {
+  assert.equal(hasFsMkdirSyncCall(createFsDirTimesCallAst('mkdirSync', { computed: true })), false);
+  assert.equal(
+    hasFsUtimesSyncCall(createFsDirTimesCallAst('utimesSync', { computed: true })),
+    false
+  );
+});
+
+test('syncPart1DirTimes no cruza metodos entre detectores', () => {
+  assert.equal(hasFsRmSyncCall(createFsDirTimesCallAst('mkdirSync')), false);
+  assert.equal(hasFsMkdirSyncCall(createFsDirTimesCallAst('rmSync')), false);
+  assert.equal(hasFsReaddirSyncCall(createFsDirTimesCallAst('utimesSync')), false);
+});

package/core/facts/detectors/fs/syncPart1DirTimes.ts

@@ -0,0 +1,93 @@
+import { hasNode, isObject } from '../utils/astHelpers';
+
+export const hasFsRmSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'rmSync'
+    );
+  });
+};
+
+export const hasFsMkdirSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'mkdirSync'
+    );
+  });
+};
+
+export const hasFsReaddirSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'readdirSync'
+    );
+  });
+};
+
+export const hasFsUtimesSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'utimesSync'
+    );
+  });
+};

package/core/facts/detectors/fs/syncPart1FileOps.test.ts

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  hasFsCopyFileSyncCall,
+  hasFsReadFileSyncCall,
+  hasFsRenameSyncCall,
+  hasFsWriteFileSyncCall,
+} from './syncPart1FileOps';
+
+const createFsFileOpsCallAst = (
+  methodName: string,
+  options?: { objectName?: string; computed?: boolean }
+) => {
+  const objectName = options?.objectName ?? 'fs';
+  const computed = options?.computed === true;
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      computed,
+      object: { type: 'Identifier', name: objectName },
+      property: computed
+        ? { type: 'StringLiteral', value: methodName }
+        : { type: 'Identifier', name: methodName },
+    },
+    arguments: [{ type: 'StringLiteral', value: '/tmp/file.txt' }],
+  };
+};
+
+test('syncPart1FileOps detecta llamadas fs.*Sync esperadas', () => {
+  assert.equal(hasFsWriteFileSyncCall(createFsFileOpsCallAst('writeFileSync')), true);
+  assert.equal(hasFsReadFileSyncCall(createFsFileOpsCallAst('readFileSync')), true);
+  assert.equal(hasFsRenameSyncCall(createFsFileOpsCallAst('renameSync')), true);
+  assert.equal(hasFsCopyFileSyncCall(createFsFileOpsCallAst('copyFileSync')), true);
+});
+
+test('syncPart1FileOps descarta objeto distinto de fs', () => {
+  assert.equal(
+    hasFsWriteFileSyncCall(createFsFileOpsCallAst('writeFileSync', { objectName: 'fsp' })),
+    false
+  );
+  assert.equal(
+    hasFsCopyFileSyncCall(createFsFileOpsCallAst('copyFileSync', { objectName: 'fsp' })),
+    false
+  );
+});
+
+test('syncPart1FileOps descarta propiedades computed', () => {
+  assert.equal(
+    hasFsReadFileSyncCall(createFsFileOpsCallAst('readFileSync', { computed: true })),
+    false
+  );
+  assert.equal(
+    hasFsRenameSyncCall(createFsFileOpsCallAst('renameSync', { computed: true })),
+    false
+  );
+});
+
+test('syncPart1FileOps no cruza metodos entre detectores', () => {
+  assert.equal(hasFsReadFileSyncCall(createFsFileOpsCallAst('writeFileSync')), false);
+  assert.equal(hasFsRenameSyncCall(createFsFileOpsCallAst('copyFileSync')), false);
+  assert.equal(hasFsCopyFileSyncCall(createFsFileOpsCallAst('renameSync')), false);
+});

package/core/facts/detectors/fs/syncPart1FileOps.ts

@@ -0,0 +1,93 @@
+import { hasNode, isObject } from '../utils/astHelpers';
+
+export const hasFsWriteFileSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'writeFileSync'
+    );
+  });
+};
+
+export const hasFsReadFileSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'readFileSync'
+    );
+  });
+};
+
+export const hasFsRenameSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'renameSync'
+    );
+  });
+};
+
+export const hasFsCopyFileSyncCall = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (value.type !== 'CallExpression') {
+      return false;
+    }
+
+    const callee = value.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression' || callee.computed === true) {
+      return false;
+    }
+    const objectNode = callee.object;
+    const propertyNode = callee.property;
+    return (
+      isObject(objectNode) &&
+      objectNode.type === 'Identifier' &&
+      objectNode.name === 'fs' &&
+      isObject(propertyNode) &&
+      propertyNode.type === 'Identifier' &&
+      propertyNode.name === 'copyFileSync'
+    );
+  });
+};