console.log("Welcome To Node Master")

// fileread.js
import { readFileSync } from "fs";
const content = readFileSync("myfile.txt");
console.log(content);

node fileread.js

--experimental-permission

node --experimental-permission fileread.js

node --experimental-permission fileread.js                    
node:internal/modules/cjs/loader:178
  const result = internalModuleStat(filename);
                 ^

Error: Access to this API has been restricted
    at node:internal/main/run_main_module:23:47 {
  code: 'ERR_ACCESS_DENIED',
  permission: 'FileSystemRead',
  resource: '/home/imanhpr/Desktop/sandbox/nod/fileread.js'
}
Node.js v20.9.0

node --experimental-permission --allow-fs-read='*' fileread.js 

export function sum(input) {
  return input + 2;
}

export function minus(input) {
  return input - 2;
}

import assert from "assert";
import { describe, test } from "node:test";
import { sum } from "../main.js";

describe("Check Sum Function.", () => {
  test("Sum 2 + 2 = 4", () => {
    const result = sum(2);
    assert.strictEqual(result, 4);
  });
  test("Sum 4 + 2 == 6", () => {
    const result = sum(4);
    assert.strictEqual(result, 3);
  });
});

--test

node --test

 --experimental-test-coverage 

node --test --experimental-test-coverage

#include <iostream>

int main()
{
    std::cout << "Let The Performance Begin!\n";
    return 0;
}

// main.ts
const result = Deno.readTextFileSync("myfile.txt");
console.log(result);

deno run main.ts

Deno requests read access to "myfile.txt".
├ Requested by `Deno.readFileSync()` API.
├ Run again with --allow-read to bypass this prompt.
└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) > y

deno compile main.ts

{
  "name": "Node Master",
  "author": "imanhpr"
}
```

```javanoscript
import user from "./user.json" with {type : "json"};

Deno.serve({port : 3005} , (req) => {
  return new Response(JSON.stringify(user))
})

function doSomething() {
  return "Something important"
}

function doSomething(done) {
  done("Something important");
}

function print(str) {
  console.log(str);
}

doSomething(print);

import { readFile as readFileCps, readFileSync } from "node:fs";
import { readFile as readFilePromise } from "node:fs/promises";

// Sync api - Direct style.
const syncRead = readFileSync("myfile.txt", "utf-8");
console.log("1.", syncRead);

// Async api - CPS style.
readFileCps("myfile.txt", "utf-8", (err, data) => {
  if (err) process.exit(1);
  console.log("2.", data);
});

// Async Promise api - looks like sync style - await syntax
const asyncRead = await readFilePromise("myfile.txt", "utf-8");
console.log("3.", asyncRead);

// Async Promise api - looks like CPS style.
readFilePromise("myfile.txt", "utf-8").then((data) => console.log("4.", data));

node:util

import { callbackify } from "node:util";

// Promise to CPS
async function myJob() {
  return "this is a result";
}

const cpsMyJob = callbackify(myJob);
cpsMyJob((err, result) => console.log("in cps :", result));

import { promisify } from "node:util";

// CPS to Promise
function myJobSync(done) {
  return done(null, "this is a result");
}

const myJob = promisify(myJobSync);
console.log(await myJob());

import { randomBytes } from "node:crypto";
import { promisify } from "node:util";

const _randomByte = promisify(randomBytes);
console.log(await _randomByte(5));