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

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/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;

package/package.json

@@ -1,11 +1,265 @@
 {
+  "author": "Shinichi Tomita <shinichi.tomita@gmail.com>",
   "name": "@jsforce/jsforce-node",
-  "version": "0.0.1",
-  "description": "jsforce node-only release",
-  "main": "index.js",
+  "description": "Salesforce API Library for JavaScript",
+  "keywords": [
+    "salesforce",
+    "salesforce.com",
+    "sfdc",
+    "force.com",
+    "database.com"
+  ],
+  "homepage": "http://github.com/jsforce/jsforce",
+  "version": "3.0.0-next.1",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jsforce/jsforce.git"
+  },
+  "license": "MIT",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/jsforce/jsforce/raw/master/LICENSE"
+    }
+  ],
+  "main": "./index",
+  "module": "./module/index",
+  "types": "./index",
+  "wireit": {
+    "build": {
+      "dependencies": [
+        "build:transpile",
+        "build:bundle"
+      ]
+    },
+    "build:transpile": {
+      "dependencies": [
+        "build:node:cjs",
+        "build:browser"
+      ]
+    },
+    "build:node:cjs": {
+      "command": "tsc -p . --pretty --incremental",
+      "files": [
+        "src/**/*.ts",
+        "**/tsconfig.json"
+      ],
+      "output": [
+        "lib/**",
+        "*.tsbuildinfo"
+      ],
+      "clean": "if-file-deleted"
+    },
+    "build:browser": {
+      "command": "babel src --extensions .ts --source-maps inline --env-name browser --out-dir browser",
+      "files": [
+        "src/**/*.ts",
+        "babel.config.js"
+      ],
+      "output": [
+        "browser/**"
+      ]
+    },
+    "build:bundle": {
+      "command": "webpack",
+      "dependencies": [
+        "build:browser"
+      ],
+      "files": [
+        "browser/**/*.js",
+        "webpack.config.js"
+      ],
+      "output": [
+        "dist"
+      ]
+    },
+    "lint": {
+      "command": "eslint --ext .ts src test --color --cache --cache-location .eslintcache",
+      "files": [
+        "src/**/*.ts",
+        "test/**/*.ts",
+        "**/.eslint*"
+      ],
+      "output": []
+    },
+    "test": {
+      "dependencies": [
+        "test:node",
+        "test:browser",
+        "lint"
+      ]
+    },
+    "test:node": {
+      "command": "jest --forceExit",
+      "dependencies": [
+        "build:node:cjs"
+      ],
+      "files": [
+        "test/**/*.ts",
+        "jest.setup.js",
+        "jest.config.js"
+      ],
+      "output": []
+    },
+    "test:browser": {
+      "command": "karma start",
+      "dependencies": [
+        "clean-test-failures-file",
+        "build:bundle"
+      ],
+      "files": [
+        "test/**/*.ts",
+        "karma.conf.js",
+        "webpack.config.test.js"
+      ],
+      "output": []
+    },
+    "test:browser-ci": {
+      "command": "karma start",
+      "dependencies": [
+        "clean-test-failures-file",
+        "build:bundle",
+        "proxy-server"
+      ],
+      "files": [
+        "test/**/*.ts",
+        "karma.conf.js",
+        "webpack.config.test.js"
+      ],
+      "output": []
+    },
+    "test:browser-ci:retry": {
+      "command": "karma start --retry-failed",
+      "dependencies": [
+        "build:bundle",
+        "proxy-server"
+      ],
+      "files": [
+        "test/**/*.ts",
+        "karma.conf.js",
+        "webpack.config.test.js"
+      ],
+      "output": []
+    },
+    "proxy-server": {
+      "command": "node node_modules/jsforce-ajax-proxy/lib/server.js",
+      "service": {
+        "readyWhen": {
+          "lineMatches": "Express server listening on port \\d+"
+        }
+      }
+    },
+    "typecheck": {
+      "command": "npm run build:node:cjs && npx tsc -p test --pretty",
+      "files": [
+        "src/**/*.ts",
+        "test/**/*.ts",
+        "**/tsconfig.json"
+      ],
+      "output": []
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "wireit",
+    "build:node:cjs": "wireit",
+    "build:transpile": "wireit",
+    "build:browser": "wireit",
+    "build:bundle": "wireit",
+    "lint": "wireit",
+    "test": "wireit",
+    "test:node": "wireit",
+    "test:browser": "wireit",
+    "test:browser-ci": "wireit",
+    "test:browser-ci:retry": "wireit",
+    "typecheck": "wireit",
+    "proxy-server": "wireit",
+    "clean": "rimraf --glob lib/* module/* browser/*",
+    "clean-test-failures-file": "rimraf test/karma/karma-failed-tests.txt",
+    "jsforce-node": "ts-node scripts/jsforce-node.ts",
+    "jsforce-node:dev": "ts-node scripts/jsforce-node.ts --dev"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "lib",
+    "typings",
+    "index.js",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@types/node": "^18.15.3",
+    "abort-controller": "^3.0.0",
+    "base64url": "^3.0.1",
+    "csv-parse": "^5.5.2",
+    "csv-stringify": "^6.4.4",
+    "faye": "^1.4.0",
+    "form-data": "^4.0.0",
+    "fs-extra": "^8.1.0",
+    "https-proxy-agent": "^5.0.0",
+    "multistream": "^3.1.0",
+    "node-fetch": "^2.6.1",
+    "strip-ansi": "^6.0.0",
+    "xml2js": "^0.6.2"
   },
-  "author": "",
-  "license": "ISC"
+  "devDependencies": {
+    "@babel/cli": "^7.23.0",
+    "@babel/core": "^7.23.0",
+    "@babel/plugin-transform-runtime": "^7.22.15",
+    "@babel/preset-env": "^7.22.20",
+    "@babel/preset-typescript": "^7.23.0",
+    "@babel/register": "^7.22.15",
+    "@types/fs-extra": "^8.0.1",
+    "@types/inquirer": "^6.5.0",
+    "@types/jest": "^29.5.5",
+    "@types/multistream": "^2.1.1",
+    "@types/node-fetch": "^2.5.7",
+    "@types/shelljs": "^0.8.15",
+    "@types/through2": "^2.0.34",
+    "@types/xml2js": "^0.4.5",
+    "@typescript-eslint/eslint-plugin": "^6.7.5",
+    "@typescript-eslint/parser": "^6.7.5",
+    "archiver": "^5.1.0",
+    "assert": "^2.0.0",
+    "babel-loader": "^9.1.3",
+    "babel-preset-power-assert": "^3.0.0",
+    "buffer": "^6.0.3",
+    "conditional-type-checks": "^1.0.5",
+    "crypto-browserify": "^3.12.0",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "jest": "^29.5.0",
+    "jsforce-ajax-proxy": "^2.0.0",
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-jasmine": "^5.1.0",
+    "karma-jasmine-html-reporter": "^2.0.0",
+    "karma-sourcemap-loader": "^0.4.0",
+    "karma-webpack": "^5.0.0",
+    "path-browserify": "^1.0.1",
+    "power-assert": "^1.6.1",
+    "prettier": "^2.2.1",
+    "process": "^0.11.10",
+    "puppeteer": "^21.0.1",
+    "querystring-es3": "^0.2.1",
+    "rimraf": "^5.0.5",
+    "shelljs": "^0.8.5",
+    "source-map-loader": "^1.1.3",
+    "stream-browserify": "^3.0.0",
+    "terser-webpack-plugin": "^5.3.7",
+    "through2": "^3.0.1",
+    "timers-browserify": "^2.0.12",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.25.1",
+    "typescript": "^4.9.5",
+    "util": "^0.12.5",
+    "webpack": "^5.82.0",
+    "webpack-cli": "^5.0.2",
+    "wireit": "^0.14.0",
+    "zx": "^7.2.3"
+  }
 }