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

package/lib/api/tooling.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tooling = void 0;
+/**
+ * @file Manages Tooling APIs
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const jsforce_1 = require("../jsforce");
+const connection_1 = __importDefault(require("../connection"));
+const cache_1 = __importDefault(require("../cache"));
+/**
+ *
+ */
+const { query, queryMore, _ensureVersion, create, _createSingle, _createMany, _createParallel, retrieve, _retrieveSingle, _retrieveParallel, _retrieveMany, update, _updateSingle, _updateParallel, _updateMany, upsert, destroy, _destroySingle, _destroyParallel, _destroyMany, describe, describeGlobal, sobject, } = connection_1.default.prototype;
+const describeCacheKey = (type) => type ? `describe.${type}` : 'describe';
+/**
+ * API class for Tooling API call
+ */
+class Tooling {
+    _conn;
+    get version() {
+        return this._conn.version;
+    }
+    /**
+     * Execute query by using SOQL
+     */
+    query = query;
+    /**
+     * Query next record set by using query locator
+     */
+    queryMore = queryMore;
+    _ensureVersion = _ensureVersion;
+    /**
+     * Create records
+     */
+    create = create;
+    _createSingle = _createSingle;
+    _createParallel = _createParallel;
+    _createMany = _createMany;
+    /**
+     * Synonym of Tooling#create()
+     */
+    insert = create;
+    /**
+     * Retrieve specified records
+     */
+    retrieve = retrieve;
+    _retrieveSingle = _retrieveSingle;
+    _retrieveParallel = _retrieveParallel;
+    _retrieveMany = _retrieveMany;
+    /**
+     * Update records
+     */
+    update = update;
+    _updateSingle = _updateSingle;
+    _updateParallel = _updateParallel;
+    _updateMany = _updateMany;
+    /**
+     * Upsert records
+     */
+    upsert = upsert;
+    /**
+     * Delete records
+     */
+    destroy = destroy;
+    _destroySingle = _destroySingle;
+    _destroyParallel = _destroyParallel;
+    _destroyMany = _destroyMany;
+    /**
+     * Synonym of Tooling#destroy()
+     */
+    delete = destroy;
+    /**
+     * Synonym of Tooling#destroy()
+     */
+    del = destroy;
+    cache = new cache_1.default();
+    /**
+     * Describe SObject metadata
+     */
+    describe = this.cache.createCachedFunction(describe, this, {
+        key: describeCacheKey,
+        strategy: 'NOCACHE',
+    });
+    describe$ = this.cache.createCachedFunction(describe, this, {
+        key: describeCacheKey,
+        strategy: 'HIT',
+    });
+    describe$$ = this.cache.createCachedFunction(describe, this, {
+        key: describeCacheKey,
+        strategy: 'IMMEDIATE',
+    });
+    /**
+     * Synonym of Tooling#describe()
+     */
+    describeSObject = this.describe;
+    describeSObject$ = this.describe$;
+    describeSObject$$ = this.describe$$;
+    /**
+     * Describe global SObjects
+     */
+    describeGlobal = this.cache.createCachedFunction(describeGlobal, this, {
+        key: 'describeGlobal',
+        strategy: 'NOCACHE',
+    });
+    describeGlobal$ = this.cache.createCachedFunction(describeGlobal, this, {
+        key: 'describeGlobal',
+        strategy: 'HIT',
+    });
+    describeGlobal$$ = this.cache.createCachedFunction(describeGlobal, this, {
+        key: 'describeGlobal',
+        strategy: 'IMMEDIATE',
+    });
+    /**
+     * Get SObject instance
+     */
+    sobject = sobject;
+    sobjects = {};
+    /**
+     *
+     */
+    constructor(conn) {
+        this._conn = conn;
+    }
+    /**
+     * @private
+     */
+    _establish() {
+        this.sobjects = {};
+        this.cache.clear();
+        this.cache.get('describeGlobal').removeAllListeners('value');
+        this.cache.get('describeGlobal').on('value', (res) => {
+            if (res.result) {
+                for (const { name: type } of res.result.sobjects) {
+                    this.sobject(type);
+                }
+            }
+        });
+    }
+    /**
+     * @private
+     */
+    _baseUrl() {
+        return this._conn._baseUrl() + '/tooling';
+    }
+    /**
+     * @private
+     */
+    _supports(feature) {
+        return this._conn._supports(feature);
+    }
+    /**
+     *
+     */
+    request(request, options) {
+        return this._conn.request(request, options);
+    }
+    /**
+     * Executes Apex code anonymously
+     */
+    executeAnonymous(body) {
+        const url = this._baseUrl() +
+            '/executeAnonymous?anonymousBody=' +
+            encodeURIComponent(body);
+        return this.request(url);
+    }
+    /**
+     * Executes Apex tests asynchronously
+     */
+    runTestsAsynchronous(req) {
+        const url = this._baseUrl() + '/runTestsAsynchronous/';
+        return this._conn.requestPost(url, req);
+    }
+    /**
+     * Executes Apex tests synchronously
+     */
+    runTestsSynchronous(req) {
+        const url = this._baseUrl() + '/runTestsSynchronous/';
+        return this._conn.requestPost(url, req);
+    }
+    /**
+     * Retrieves available code completions of the referenced type
+     */
+    completions(type = 'apex') {
+        const url = this._baseUrl() + '/completions?type=' + encodeURIComponent(type);
+        return this.request({
+            method: 'GET',
+            url,
+            headers: { Accept: 'application/json' },
+        });
+    }
+}
+exports.Tooling = Tooling;
+/*--------------------------------------------*/
+/*
+ * Register hook in connection instantiation for dynamically adding this API module features
+ */
+(0, jsforce_1.registerModule)('tooling', (conn) => new Tooling(conn));
+exports.default = Tooling;

package/lib/api/wsdl/wsdl2schema.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/wsdl/wsdl2schema.js

@@ -0,0 +1,354 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const xml2js_1 = __importDefault(require("xml2js"));
+const soap_1 = require("../../soap");
+const function_1 = require("../../util/function");
+/**
+ *
+ */
+const WSDLRestrictionSchema = {
+    $: { base: 'string' },
+    enumeration: [
+        {
+            $: { value: 'string' },
+        },
+    ],
+    'xsd:enumeration': [
+        {
+            $: { value: 'string' },
+        },
+    ],
+};
+const WSDLSimpleTypeSchema = {
+    $: { name: 'string' },
+    restriction: WSDLRestrictionSchema,
+    'xsd:restriction': WSDLRestrictionSchema,
+};
+const WSDLElementSchema = {
+    $: {
+        name: 'string',
+        type: 'string',
+        minOccurs: '?number',
+        maxOccurs: '?string',
+        nillable: '?boolean',
+    },
+};
+const WSDLSequenceSchema = {
+    element: ['?', WSDLElementSchema],
+    'xsd:element': ['?', WSDLElementSchema],
+};
+const WSDLExtensionSchema = {
+    $: { base: 'string' },
+    sequence: { '?': WSDLSequenceSchema },
+    'xsd:sequence': { '?': WSDLSequenceSchema },
+};
+const WSDLComplexContentSchema = {
+    extension: { '?': WSDLExtensionSchema },
+    'xsd:extension': { '?': WSDLExtensionSchema },
+};
+const WSDLComplexTypeSchema = {
+    $: { name: 'string' },
+    sequence: { '?': WSDLSequenceSchema },
+    'xsd:sequence': { '?': WSDLSequenceSchema },
+    complexContent: { '?': WSDLComplexContentSchema },
+    'xsd:complexContent': { '?': WSDLComplexContentSchema },
+};
+const WSDLSchemaSchema = {
+    $: 'any',
+    complexType: ['?', 'any'],
+    simpleType: ['?', 'any'],
+    'xsd:complexType': ['?', 'any'],
+    'xsd:simpleType': ['?', 'any'],
+};
+const WSDLSchema = {
+    definitions: {
+        $: 'any',
+        types: {
+            schema: ['?', WSDLSchemaSchema],
+            'xsd:schema': ['?', WSDLSchemaSchema],
+        },
+        message: ['any'],
+        portType: {
+            $: 'any',
+            operation: ['any'],
+        },
+        binding: {
+            $: 'any',
+            operation: ['any'],
+        },
+        service: {
+            $: 'any',
+            documentation: 'string',
+            operation: ['any'],
+        },
+    },
+};
+/**
+ *
+ */
+function toJsType(xsdType, simpleTypes) {
+    switch (xsdType) {
+        case 'xsd:boolean':
+            return 'boolean';
+        case 'xsd:string':
+        case 'xsd:date':
+        case 'xsd:dateTime':
+        case 'xsd:time':
+        case 'xsd:base64Binary':
+            return 'string';
+        case 'xsd:int':
+        case 'xsd:long':
+        case 'xsd:double':
+            return 'number';
+        case 'xsd:anyType':
+            return 'any';
+        default: {
+            const [ns, type] = xsdType.split(':');
+            if (simpleTypes[type]) {
+                return simpleTypes[type];
+            }
+            if (ns) {
+                return type;
+            }
+            return xsdType;
+        }
+    }
+}
+/**
+ *
+ */
+async function readWSDLFile(filePath) {
+    const xmlData = await fs_extra_1.default.readFile(filePath, 'utf8');
+    const json = await xml2js_1.default.parseStringPromise(xmlData, {
+        explicitArray: false,
+    });
+    return (0, soap_1.castTypeUsingSchema)(json, WSDLSchema);
+}
+/**
+ *
+ */
+function getTypeInfo(el, simpleTypes) {
+    const type = toJsType(el.$.type, simpleTypes);
+    const isArray = el.$.maxOccurs === 'unbounded';
+    const nillable = (!isArray && el.$.minOccurs === 0) || el.$.nillable;
+    return isArray
+        ? nillable
+            ? ['?', type]
+            : [type]
+        : nillable
+            ? `?${type}`
+            : type;
+}
+/**
+ *
+ */
+function extractComplexTypes(wsdl) {
+    console.log(wsdl.definitions.types['xsd:schema']);
+    const schemas = {};
+    const simpleTypes = {};
+    const types = wsdl.definitions.types;
+    for (const sc of types.schema ?? types['xsd:schema'] ?? []) {
+        for (const st of sc.simpleType ?? sc['xsd:simpleType'] ?? []) {
+            const simpleType = (0, soap_1.castTypeUsingSchema)(st, WSDLSimpleTypeSchema);
+            const rs = simpleType.restriction ?? simpleType['xsd:restriction'];
+            const base = rs.$.base.split(':')[1];
+            simpleTypes[simpleType.$.name] = base;
+        }
+    }
+    console.log({ simpleTypes });
+    for (const sc of types.schema ?? types['xsd:schema'] ?? []) {
+        for (const ct of sc.complexType ?? sc['xsd:complexType'] ?? []) {
+            const complexType = (0, soap_1.castTypeUsingSchema)(ct, WSDLComplexTypeSchema);
+            const schema = {
+                type: complexType.$.name,
+                props: {},
+            };
+            const seq = complexType.sequence ?? complexType['xsd:sequence'];
+            const els = seq?.element ?? seq?.['xsd:element'];
+            for (const el of els ?? []) {
+                schema.props[el.$.name] = getTypeInfo(el, simpleTypes);
+            }
+            const cc = complexType.complexContent ?? complexType['xsd:complexContent'];
+            if (cc) {
+                const extension = cc.extension ?? cc['xsd:extension'];
+                if (extension) {
+                    schema.extends = extension.$.base.split(':')[1];
+                    const seq = extension.sequence ?? extension['xsd:sequence'];
+                    const els = seq?.element ?? seq?.['xsd:element'];
+                    for (const el of els ?? []) {
+                        schema.props[el.$.name] = getTypeInfo(el, simpleTypes);
+                    }
+                }
+            }
+            schemas[complexType.$.name] = schema;
+        }
+    }
+    return schemas;
+}
+/**
+ *
+ */
+const GENERATED_MESSAGE_COMMENT = `/**
+ * This file is generated from WSDL file by wsdl2schema.ts.
+ * Do not modify directly.
+ * To generate the file, run "ts-node path/to/wsdl2schema.ts path/to/wsdl.xml path/to/schema.ts"
+ */
+`;
+/**
+ *
+ */
+async function dumpSchema(schemas, outFile) {
+    const out = fs_extra_1.default.createWriteStream(outFile, 'utf8');
+    const print = (str, indent = 0) => {
+        for (let i = 0; i < indent; i++) {
+            out.write(' ');
+        }
+        out.write(str);
+    };
+    const println = (str = '', indent = 0) => {
+        print(str + '\n', indent);
+    };
+    return new Promise((resolve, reject) => {
+        out.on('error', reject);
+        out.on('finish', () => resolve());
+        println(GENERATED_MESSAGE_COMMENT);
+        print('export const ApiSchemas = ');
+        writeSchema(schemas);
+        println(' as const;');
+        println();
+        writeTypeDefs(schemas);
+        out.end();
+    });
+    function writeSchema(o, indent = 0) {
+        if (indent > 20) {
+            print("'any'");
+            return;
+        }
+        if (Array.isArray(o)) {
+            print('[');
+            let i = 0;
+            for (const co of o) {
+                if (i > 0) {
+                    print(', ');
+                }
+                writeSchema(co, indent);
+                i++;
+            }
+            print(']');
+        }
+        else if ((0, function_1.isMapObject)(o)) {
+            const keys = Object.keys(o);
+            if (keys.length > 0) {
+                println('{');
+                for (const name of keys) {
+                    const co = o[name];
+                    const nameId = /^[\w_$]+$/.test(name) ? name : `'${name}'`;
+                    print(`${nameId}: `, indent + 2);
+                    writeSchema(co, indent + 2);
+                    println(',');
+                }
+                print('}', indent);
+            }
+            else {
+                print('{}');
+            }
+        }
+        else {
+            print(JSON.stringify(o).replace(/"/g, "'"));
+        }
+    }
+    function writeTypeDef(o, schemas, indent = 0) {
+        if (typeof o === 'string') {
+            print(o);
+        }
+        else if ((0, function_1.isMapObject)(o)) {
+            if ('type' in o && 'props' in o) {
+                if ('extends' in o && typeof o.extends === 'string') {
+                    print(`${o.extends} & `);
+                }
+                writeTypeDef(o.props, schemas, indent);
+                return;
+            }
+            const keys = Object.keys(o);
+            if (keys.length > 0) {
+                println('{');
+                for (const prop of Object.keys(o)) {
+                    let value = o[prop];
+                    let nillable = false;
+                    let isArray = false;
+                    if (Array.isArray(value)) {
+                        isArray = true;
+                        const len = value.length;
+                        if (len === 2 && value[0] === '?') {
+                            nillable = true;
+                            value = value[1];
+                        }
+                        else {
+                            value = value[0];
+                        }
+                    }
+                    else if ((0, function_1.isMapObject)(value)) {
+                        if ('?' in value) {
+                            nillable = true;
+                            value = value['?'];
+                        }
+                    }
+                    if (typeof value === 'string' && value[0] === '?') {
+                        nillable = true;
+                        value = value.substring(1);
+                    }
+                    print(`${prop}${nillable ? '?' : ''}: `, indent + 2);
+                    writeTypeDef(value, schemas, indent + 2);
+                    if (isArray) {
+                        print('[]');
+                    }
+                    if (nillable) {
+                        print(' | null | undefined');
+                    }
+                    println(';');
+                }
+                print('}', indent);
+            }
+            else {
+                print('{}');
+            }
+        }
+    }
+    function writeTypeDefs(schemas) {
+        for (const name of Object.keys(schemas)) {
+            const schema = schemas[name];
+            print(`export type ${name} = `);
+            writeTypeDef(schema, schemas);
+            println(';');
+            println();
+        }
+        println('export type ApiSchemaTypes = {');
+        for (const name of Object.keys(schemas)) {
+            println(`${name}: ${name};`, 2);
+        }
+        println('};');
+    }
+}
+/**
+ *
+ */
+async function main() {
+    const wsdlFilePath = process.argv[2];
+    if (!wsdlFilePath) {
+        console.error('No input WSDL file is specified.');
+        return;
+    }
+    const outFilePath = process.argv[3];
+    if (!wsdlFilePath) {
+        console.error('No output typescript schema file is specified.');
+        return;
+    }
+    const wsdl = await readWSDLFile(wsdlFilePath);
+    const schemas = extractComplexTypes(wsdl);
+    dumpSchema(schemas, outFilePath);
+}
+main();

package/lib/browser/canvas.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import { Transform } from 'stream';
+import { HttpRequest, SignedRequestObject } from '../types';
+declare function createRequest(signedRequest: SignedRequestObject): (params: HttpRequest) => Transform;
+declare const _default: {
+    supported: boolean;
+    createRequest: typeof createRequest;
+};
+export default _default;

package/lib/browser/canvas.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ */
+const stream_1 = require("stream");
+function parseHeaders(hs) {
+    const headers = {};
+    for (const line of hs.split(/\n/)) {
+        const [name, value] = line.split(/\s*:\s*/);
+        headers[name.toLowerCase()] = value;
+    }
+    return headers;
+}
+async function processCanvasRequest(params, signedRequest, requestBody) {
+    const settings = {
+        client: signedRequest.client,
+        method: params.method,
+        data: requestBody,
+    };
+    const paramHeaders = params.headers;
+    if (paramHeaders) {
+        settings.headers = {};
+        for (const name of Object.keys(paramHeaders)) {
+            if (name.toLowerCase() === 'content-type') {
+                settings.contentType = paramHeaders[name];
+            }
+            else {
+                settings.headers[name] = paramHeaders[name];
+            }
+        }
+    }
+    const data = await new Promise((resolve, reject) => {
+        settings.success = resolve;
+        settings.failure = reject;
+        Sfdc.canvas.client.ajax(params.url, settings);
+    });
+    const headers = parseHeaders(data.responseHeaders);
+    let responseBody = data.payload;
+    if (typeof responseBody !== 'string') {
+        responseBody = JSON.stringify(responseBody);
+    }
+    return {
+        statusCode: data.status,
+        headers,
+        body: responseBody,
+    };
+}
+function createRequest(signedRequest) {
+    return (params) => {
+        const buf = [];
+        const stream = new stream_1.Transform({
+            transform(chunk, encoding, callback) {
+                buf.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+                callback();
+            },
+            flush() {
+                (async () => {
+                    const body = buf.join('');
+                    const response = await processCanvasRequest(params, signedRequest, body);
+                    stream.emit('response', response);
+                    stream.emit('complete', response);
+                    stream.push(response.body);
+                    stream.push(null);
+                })();
+            },
+        });
+        if (params.body) {
+            stream.end(params.body);
+        }
+        return stream;
+    };
+}
+exports.default = {
+    supported: typeof Sfdc === 'object' && typeof Sfdc.canvas !== 'undefined',
+    createRequest,
+};