@jsforce/jsforce-node 0.0.1 → 3.0.0-next.2

package/lib/types/standard-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/util.d.ts

@@ -0,0 +1,7 @@
+export type Optional<T> = T | null | undefined;
+export type StringKeys<O> = Extract<keyof O, string>;
+export type PickIfMatch<O extends {
+    [name: string]: any;
+}, P extends string> = Pick<O, Extract<P, keyof O>>;
+export type IsEqualType<S, T> = [S] extends [T] ? [T] extends [S] ? true : false : false;
+export type ConditionalPartial<O, IsPartial extends boolean> = IsPartial extends true ? Partial<O> : O;

package/lib/types/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util/formatter.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ */
+export declare function zeroPad(num: number, digits?: number): string;
+/**
+ *
+ */
+export declare function formatDate(date: Date): string;

package/lib/util/formatter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = exports.zeroPad = void 0;
+/**
+ *
+ */
+function zeroPad(num, digits = 2) {
+    let nstr = '';
+    for (let d = digits - 1; d > 0; d--) {
+        if (num >= 10 ** d) {
+            break;
+        }
+        nstr += '0';
+    }
+    return nstr + String(num);
+}
+exports.zeroPad = zeroPad;
+/**
+ *
+ */
+function formatDate(date) {
+    return `${date.getUTCFullYear()}-${zeroPad(date.getUTCMonth() + 1)}-${zeroPad(date.getUTCDate())}T${zeroPad(date.getUTCHours())}:${zeroPad(date.getUTCMinutes())}:${zeroPad(date.getUTCSeconds())}+00:00`;
+}
+exports.formatDate = formatDate;

package/lib/util/function.d.ts

@@ -0,0 +1,32 @@
+/**
+ *
+ */
+export declare function isObject(v: any): v is object;
+/**
+ *
+ */
+export declare function isMapObject(v: any): v is {
+    [name: string]: unknown;
+};
+/**
+ *
+ */
+export declare function isFunction(v: any): v is (...args: any[]) => any;
+/**
+ *
+ */
+export declare function isNumber(v: any): v is number;
+/**
+ * Detect whether the value has CommonJS Promise/A+ interface or not
+ */
+export declare function isPromiseLike(v: any): v is {
+    then: Function;
+};
+/**
+ *
+ */
+export declare function identityFunc<T>(a: T): T;
+/**
+ *
+ */
+export declare function emptyFunc(): void;

package/lib/util/function.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyFunc = exports.identityFunc = exports.isPromiseLike = exports.isNumber = exports.isFunction = exports.isMapObject = exports.isObject = void 0;
+/**
+ *
+ */
+function isObject(v) {
+    const t = typeof v;
+    return v != null && (t == 'object' || t == 'function');
+}
+exports.isObject = isObject;
+/**
+ *
+ */
+function isMapObject(v) {
+    const t = typeof v;
+    return v != null && t == 'object';
+}
+exports.isMapObject = isMapObject;
+/**
+ *
+ */
+function isFunction(v) {
+    return typeof v == 'function';
+}
+exports.isFunction = isFunction;
+/**
+ *
+ */
+function isNumber(v) {
+    return typeof v == 'number';
+}
+exports.isNumber = isNumber;
+/**
+ * Detect whether the value has CommonJS Promise/A+ interface or not
+ */
+function isPromiseLike(v) {
+    return isObject(v) && isFunction(v.then);
+}
+exports.isPromiseLike = isPromiseLike;
+/**
+ *
+ */
+function identityFunc(a) {
+    return a;
+}
+exports.identityFunc = identityFunc;
+/**
+ *
+ */
+function emptyFunc() { }
+exports.emptyFunc = emptyFunc;

package/lib/util/get-body-size.d.ts

@@ -0,0 +1,4 @@
+import { HttpBody } from '../types';
+export declare function getBodySize(body: HttpBody | undefined, headers?: {
+    [name: string]: string;
+}): number | undefined;

package/lib/util/get-body-size.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBodySize = void 0;
+const is_1 = __importDefault(require("@sindresorhus/is"));
+function getBodySize(body, headers = {}) {
+    function isFormData(body) {
+        return is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary);
+    }
+    if (headers && 'content-length' in headers) {
+        return Number(headers['content-length']);
+    }
+    if (!body) {
+        return 0;
+    }
+    if (is_1.default.string(body)) {
+        return Buffer.byteLength(body);
+    }
+    if (is_1.default.urlSearchParams(body)) {
+        return Buffer.byteLength(body.toString());
+    }
+    if (is_1.default.buffer(body)) {
+        return body.length;
+    }
+    try {
+        // `getLengthSync` will throw if body has a stream:
+        // https://github.com/form-data/form-data#integer-getlengthsync
+        if (isFormData(body)) {
+            return body.getLengthSync();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+exports.getBodySize = getBodySize;

package/lib/util/logger.d.ts

@@ -0,0 +1,29 @@
+/**
+ *
+ */
+export declare const LogLevels: {
+    [level: string]: number;
+};
+export type LogLevelConfig = string | number | {
+    [name: string]: string | number;
+};
+/**
+ *
+ */
+export declare class Logger {
+    _moduleName: string;
+    _logLevel: number;
+    constructor(moduleName: string, logLevelConfig?: LogLevelConfig);
+    createInstance(logLevelConfig?: LogLevelConfig): Logger;
+    setLogLevel(logLevel: string | number): void;
+    log(logLevel: number, ...messages: Array<any>): void;
+    debug(...messages: Array<any>): void;
+    info(...messages: Array<any>): void;
+    warn(...messages: Array<any>): void;
+    error(...messages: Array<any>): void;
+    fatal(...messages: Array<any>): void;
+}
+/**
+ *
+ */
+export declare function getLogger(moduleName: string): Logger;

package/lib/util/logger.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.Logger = exports.LogLevels = void 0;
+/**
+ *
+ */
+exports.LogLevels = {
+    DEBUG: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+    FATAL: 5,
+    NONE: 6,
+};
+const LogLevelLabels = ['', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL', 'NONE'];
+const globalLogLevelConfig = (() => {
+    const globalLogLevelStr = process.env.JSFORCE_LOG_LEVEL ||
+        global.__JSFORCE_LOG_LEVEL__ ||
+        'NONE';
+    if (/^(DEBUG|INFO|WARN|ERROR|FATAL|NONE)$/i.test(globalLogLevelStr)) {
+        return { '*': globalLogLevelStr };
+    }
+    try {
+        return JSON.parse(globalLogLevelStr);
+    }
+    catch (e) {
+        return { '*': 'NONE' };
+    }
+})();
+function getModuleLogLevel(logLevelConfig, moduleName) {
+    const logLevel = logLevelConfig[moduleName] || logLevelConfig['*'];
+    return typeof logLevel === 'number'
+        ? logLevel
+        : exports.LogLevels[logLevel] || exports.LogLevels.NONE;
+}
+/**
+ *
+ */
+class Logger {
+    _moduleName;
+    _logLevel;
+    constructor(moduleName, logLevelConfig = globalLogLevelConfig) {
+        this._moduleName = moduleName;
+        this._logLevel =
+            typeof logLevelConfig === 'number'
+                ? logLevelConfig
+                : typeof logLevelConfig === 'string'
+                    ? exports.LogLevels[logLevelConfig] || exports.LogLevels.NONE
+                    : getModuleLogLevel(logLevelConfig, moduleName);
+    }
+    createInstance(logLevelConfig = this._logLevel) {
+        return new Logger(this._moduleName, logLevelConfig);
+    }
+    setLogLevel(logLevel) {
+        if (typeof logLevel === 'string') {
+            this._logLevel = exports.LogLevels[logLevel] || exports.LogLevels.NONE;
+        }
+        else {
+            this._logLevel = logLevel;
+        }
+    }
+    log(logLevel, ...messages) {
+        if (this._logLevel <= logLevel) {
+            const msgs = [
+                `${LogLevelLabels[logLevel]}\t[${this._moduleName}] `,
+                ...messages,
+            ];
+            if (logLevel < exports.LogLevels.ERROR) {
+                console.log(...msgs); // eslint-disable-line no-console
+            }
+            else {
+                console.error(...msgs); // eslint-disable-line no-console
+            }
+        }
+    }
+    debug(...messages) {
+        this.log(exports.LogLevels.DEBUG, ...messages);
+    }
+    info(...messages) {
+        this.log(exports.LogLevels.INFO, ...messages);
+    }
+    warn(...messages) {
+        this.log(exports.LogLevels.WARN, ...messages);
+    }
+    error(...messages) {
+        this.log(exports.LogLevels.ERROR, ...messages);
+    }
+    fatal(...messages) {
+        this.log(exports.LogLevels.FATAL, ...messages);
+    }
+}
+exports.Logger = Logger;
+const loggers = {};
+/**
+ *
+ */
+function getLogger(moduleName) {
+    const logger = loggers[moduleName] || new Logger(moduleName);
+    loggers[moduleName] = logger;
+    return logger;
+}
+exports.getLogger = getLogger;

package/lib/util/promise.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import { Duplex } from 'stream';
+/**
+ *
+ */
+export type StreamPromiseBuilder<T> = () => {
+    stream: Duplex;
+    promise: Promise<T>;
+};
+/**
+ *
+ */
+export declare class StreamPromise<T> extends Promise<T> {
+    stream(): Duplex;
+    static create<T>(builder: StreamPromiseBuilder<T>): StreamPromise<T>;
+}

package/lib/util/promise.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamPromise = void 0;
+/**
+ *
+ */
+const stream_1 = require("stream");
+/**
+ *
+ */
+class StreamPromise extends Promise {
+    stream() {
+        // dummy
+        return new stream_1.Duplex();
+    }
+    static create(builder) {
+        const { stream, promise } = builder();
+        const streamPromise = new StreamPromise((resolve, reject) => {
+            promise.then(resolve, reject);
+        });
+        streamPromise.stream = () => stream;
+        return streamPromise;
+    }
+}
+exports.StreamPromise = StreamPromise;

package/lib/util/stream.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Duplex, Readable, Writable } from 'stream';
+export declare function createLazyStream(): {
+    stream: Duplex;
+    setStream: (str: Duplex) => void;
+};
+export declare function readAll(rs: Readable, encoding?: BufferEncoding): Promise<string>;
+export declare function concatStreamsAsDuplex(ws: Writable, rs: Readable, opts?: {
+    writableObjectMode?: boolean;
+    readableObjectMode?: boolean;
+}): Duplex;

package/lib/util/stream.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatStreamsAsDuplex = exports.readAll = exports.createLazyStream = void 0;
+const stream_1 = require("stream");
+function createLazyStream() {
+    const ins = new stream_1.PassThrough();
+    const outs = new stream_1.PassThrough();
+    const stream = concatStreamsAsDuplex(ins, outs);
+    let piped = false;
+    const setStream = (str) => {
+        if (piped) {
+            throw new Error('stream is already piped to actual stream');
+        }
+        piped = true;
+        ins.pipe(str).pipe(outs);
+    };
+    return { stream, setStream };
+}
+exports.createLazyStream = createLazyStream;
+class MemoryWriteStream extends stream_1.Writable {
+    _buf;
+    constructor() {
+        super();
+        this._buf = Buffer.alloc(0);
+    }
+    _write(chunk, encoding, callback) {
+        this._buf = Buffer.concat([this._buf, chunk]);
+        callback();
+    }
+    _writev(data, callback) {
+        this._buf = Buffer.concat([this._buf, ...data.map(({ chunk }) => chunk)]);
+        callback();
+    }
+    toString(encoding = 'utf-8') {
+        return this._buf.toString(encoding);
+    }
+}
+async function readAll(rs, encoding = 'utf-8') {
+    return new Promise((resolve, reject) => {
+        const ws = new MemoryWriteStream();
+        rs.on('error', reject)
+            .pipe(ws)
+            .on('finish', () => resolve(ws.toString(encoding)));
+    });
+}
+exports.readAll = readAll;
+class DuplexifiedStream extends stream_1.Duplex {
+    _writable;
+    _readable;
+    constructor(ws, rs, opts = {}) {
+        super({
+            writableObjectMode: opts.writableObjectMode ?? ws.writableObjectMode,
+            readableObjectMode: opts.readableObjectMode ?? rs.readableObjectMode,
+        });
+        this._writable = ws;
+        this._readable = rs;
+        ws.once('finish', () => {
+            this.end();
+        });
+        this.once('finish', () => {
+            ws.end();
+        });
+        rs.on('readable', () => {
+            this._readStream();
+        });
+        rs.once('end', () => {
+            this.push(null);
+        });
+        ws.on('error', (err) => this.emit('error', err));
+        rs.on('error', (err) => this.emit('error', err));
+    }
+    _write(chunk, encoding, callback) {
+        this._writable.write(chunk, encoding, callback);
+    }
+    _read(n) {
+        this._readStream(n);
+    }
+    _readStream(n) {
+        let data;
+        while ((data = this._readable.read(n)) !== null) {
+            this.push(data);
+        }
+    }
+}
+function concatStreamsAsDuplex(ws, rs, opts) {
+    return new DuplexifiedStream(ws, rs, opts);
+}
+exports.concatStreamsAsDuplex = concatStreamsAsDuplex;