1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-24 08:09:08 -05:00
denoland-deno/ext/node/polyfills/_fs/_fs_readFile.ts
Marvin Hagemeister 50538ba35d
fix(node/fs): missing uv error context for readFile (#27011)
Dart's Node wrapper code in `npm:sass` does string slicing on the thrown
error message which broke because of our missing uv error context.

Code in question:

```js
_systemErrorToFileSystemException0(callback) {
  var error, t1, exception, t2;
  try {
    t1 = callback.call$0();
    return t1;
  } catch (exception) {
    error = A.unwrapException(exception);
    if (!type$.JsSystemError._is(error))
      throw exception;
    t1 = error;
    t2 = J.getInterceptor$x(t1);
    throw A.wrapException(new A.FileSystemException0(J.substring$2$s(t2.get$message(t1), (A.S(t2.get$code(t1)) + ": ").length, J.get$length$asx(t2.get$message(t1)) - (", " + A.S(t2.get$syscall(t1)) + " '" + A.S(t2.get$path(t1)) + "'").length), J.get$path$x(error)));
  }
}
```

Fixes https://github.com/denoland/deno/issues/26994
2024-11-22 22:42:27 +01:00

134 lines
3.8 KiB
TypeScript

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
// TODO(petamoriken): enable prefer-primordials for node polyfills
// deno-lint-ignore-file prefer-primordials
import {
BinaryOptionsArgument,
FileOptionsArgument,
getEncoding,
TextOptionsArgument,
} from "ext:deno_node/_fs/_fs_common.ts";
import { Buffer } from "node:buffer";
import { readAll } from "ext:deno_io/12_io.js";
import { FileHandle } from "ext:deno_node/internal/fs/handle.ts";
import { pathFromURL } from "ext:deno_web/00_infra.js";
import {
BinaryEncodings,
Encodings,
TextEncodings,
} from "ext:deno_node/_utils.ts";
import { FsFile } from "ext:deno_fs/30_fs.js";
import { denoErrorToNodeError } from "ext:deno_node/internal/errors.ts";
function maybeDecode(data: Uint8Array, encoding: TextEncodings): string;
function maybeDecode(
data: Uint8Array,
encoding: BinaryEncodings | null,
): Buffer;
function maybeDecode(
data: Uint8Array,
encoding: Encodings | null,
): string | Buffer {
const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
if (encoding && encoding !== "binary") return buffer.toString(encoding);
return buffer;
}
type TextCallback = (err: Error | null, data?: string) => void;
type BinaryCallback = (err: Error | null, data?: Buffer) => void;
type GenericCallback = (err: Error | null, data?: string | Buffer) => void;
type Callback = TextCallback | BinaryCallback | GenericCallback;
type Path = string | URL | FileHandle;
export function readFile(
path: Path,
options: TextOptionsArgument,
callback: TextCallback,
): void;
export function readFile(
path: Path,
options: BinaryOptionsArgument,
callback: BinaryCallback,
): void;
export function readFile(
path: Path,
options: null | undefined | FileOptionsArgument,
callback: BinaryCallback,
): void;
export function readFile(path: string | URL, callback: BinaryCallback): void;
export function readFile(
path: Path,
optOrCallback?: FileOptionsArgument | Callback | null | undefined,
callback?: Callback,
) {
path = path instanceof URL ? pathFromURL(path) : path;
let cb: Callback | undefined;
if (typeof optOrCallback === "function") {
cb = optOrCallback;
} else {
cb = callback;
}
const encoding = getEncoding(optOrCallback);
let p: Promise<Uint8Array>;
if (path instanceof FileHandle) {
const fsFile = new FsFile(path.fd, Symbol.for("Deno.internal.FsFile"));
p = readAll(fsFile);
} else {
p = Deno.readFile(path);
}
if (cb) {
p.then((data: Uint8Array) => {
if (encoding && encoding !== "binary") {
const text = maybeDecode(data, encoding);
return (cb as TextCallback)(null, text);
}
const buffer = maybeDecode(data, encoding);
(cb as BinaryCallback)(null, buffer);
}, (err) => cb && cb(denoErrorToNodeError(err, { path, syscall: "open" })));
}
}
export function readFilePromise(
path: Path,
options?: FileOptionsArgument | null | undefined,
// deno-lint-ignore no-explicit-any
): Promise<any> {
return new Promise((resolve, reject) => {
readFile(path, options, (err, data) => {
if (err) reject(err);
else resolve(data);
});
});
}
export function readFileSync(
path: string | URL,
opt: TextOptionsArgument,
): string;
export function readFileSync(
path: string | URL,
opt?: BinaryOptionsArgument,
): Buffer;
export function readFileSync(
path: string | URL,
opt?: FileOptionsArgument,
): string | Buffer {
path = path instanceof URL ? pathFromURL(path) : path;
let data;
try {
data = Deno.readFileSync(path);
} catch (err) {
throw denoErrorToNodeError(err, { path, syscall: "open" });
}
const encoding = getEncoding(opt);
if (encoding && encoding !== "binary") {
const text = maybeDecode(data, encoding);
return text;
}
const buffer = maybeDecode(data, encoding);
return buffer;
}