TypeScript jsforce.Connection类代码示例

async function testDescribe() {
    const global: sf.DescribeGlobalResult = await salesforceConnection.describeGlobal();
    const globalCached: sf.DescribeGlobalResult = salesforceConnection.describeGlobal$();
    const globalCachedCorrectly = global === globalCached;
    salesforceConnection.describeGlobal$.clear();

    globalCached.sobjects.forEach(async (sobject: sf.DescribeGlobalSObjectResult) => {
        const object: sf.DescribeSObjectResult = await salesforceConnection.describe(sobject.name);
        const cachedObject: sf.DescribeSObjectResult = salesforceConnection.describe$(sobject.name);
        salesforceConnection.describe$.clear();

        object.fields.forEach(field => {
            const type: sf.FieldType = field.type;
            // following should never compile
            // $ExpectError
            const fail = type === 'hey';

            const isString = type === 'string';
        });

        // following should never compile (if StrictNullChecks is on)
        // $ExpectError
        object.keyPrefix.length;

        console.log(`${sobject.name} Label: `, object.label);

        const correctlyCached = object === cachedObject;
    });
}

(async () => {
    const query2: sf.QueryResult<object> =
        await (salesforceConnection.query("SELECT Id, Name FROM User") as Promise<sf.QueryResult<object>>);
    console.log("Query Promise: total in database: " + query2.totalSize);
    console.log("Query Promise: total fetched : " + query2.records[0]);

    await testAnalytics(salesforceConnection);
    await testChatter(salesforceConnection);
    await testMetadata(salesforceConnection);
})();

import * as stream from 'stream';
import * as express from 'express';
import * as glob from 'glob';

import * as sf from 'jsforce';

export interface DummyRecord {
    thing: boolean;
    other: number;
    person: string;
}

const salesforceConnection: sf.Connection = new sf.Connection({
    instanceUrl: '',
    refreshToken: '',
    oauth2: {
        clientId: '',
        clientSecret: '',
    },
});

salesforceConnection.sobject<DummyRecord>("Dummy").select(["thing", "other"]);

// note the following should never compile:
// salesforceConnection.sobject<DummyRecord>("Dummy").select(["lol"]);

salesforceConnection.sobject("Account").create({
    Name: "Test Acc 2",
    BillingStreet: "Maplestory street",
    BillingPostalCode: "ME4 666"
}, (err: Error, ret: sf.RecordResult) => {
    if (err || !ret.success) {

async function testSObject(connection: sf.Connection) {
    interface DummyRecord {
        thing: boolean;
        other: number;
        person: string;
    }

    const dummySObject: SObject<DummyRecord> = connection.sobject<DummyRecord>('Dummy');

    // currently untyped, but some future change may make this stricter
    const restApiOptions = {
        headers: { Bearer: 'I have no idea what this wants' }
    };

    { // Test SObject.record
        // $ExpectType RecordReference<DummyRecord>
        dummySObject.record('50130000000014C');
    }

    { // Test SObject.retrieve
        // with single id
        // $ExpectType Record<DummyRecord>
        await dummySObject.retrieve('50130000000014C');
        // with single id and rest api options
        // $ExpectType Record<DummyRecord>
        await dummySObject.retrieve('50130000000014C', restApiOptions);

        // with single id and callback
        dummySObject.retrieve('50130000000014C', restApiOptions, (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType Record<DummyRecord>
        });

        // with ids array
        // $ExpectType Record<DummyRecord>[]
        await dummySObject.retrieve(['IIIIDDD']);
        // with ids array and rest api options
        // $ExpectType Record<DummyRecord>[]
        await dummySObject.retrieve(['IIIIDDD'], restApiOptions);

        // with ids array and callback
        dummySObject.retrieve(['50130000000014C'], restApiOptions, (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType Record<DummyRecord>[]
        });

        salesforceConnection.sobject<any>("ContentVersion").retrieve("world", {
            test: "test"
        }, (err, ret) => {
            err; // $ExpectType Error | null
            ret; // $ExpectType any
        });
    }

    { // Test SObject.update
        // if we require that records have an id field this will fail
        // //$ExpectError
        await dummySObject.update({ thing: false });

        // If we require that the records have an Id field
        // await dummySObject.update({ thing: false, Id: 'asdf' }); // $ExpectType RecordResult

        // invalid field
        // $ExpectError
        await dummySObject.update({ asdf: false });

        // with rest api options
        // $ExpectType RecordResult
        await dummySObject.update({ thing: false }, restApiOptions);

        // with callback
        dummySObject.update({ thing: false }, (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType RecordResult
        });

        dummySObject.update({ thing: false }, restApiOptions, (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType RecordResult
        });

        // with multiple records
        // $ExpectType RecordResult[]
        await dummySObject.update([{ thing: false }]);

        // with multiple records and api options
        // $ExpectType RecordResult[]
        await dummySObject.update([{ thing: false }], restApiOptions);

        // with multiple records and callback
        dummySObject.update([{ thing: false }], restApiOptions, (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType RecordResult[]
        });

        dummySObject.update([{ thing: false }], (err, res) => {
            err; // $ExpectType Error | null
            res; // $ExpectType RecordResult[]
        });
    }
//.........这里部分代码省略.........

import * as sf from 'jsforce';

const salesforceConnection: sf.Connection = new sf.Connection({
    instanceUrl: '',
    refreshToken: '',
    oauth2: {
        clientId: '',
        clientSecret: '',
    },
});

salesforceConnection.sobject("Account").create({
    Name: "Test Acc 2",
    BillingStreet: "Maplestory street",
    BillingPostalCode: "ME4 666"
}, (err: Error, ret: sf.RecordResult) => {
    if (err || !ret.success) {
        return;
    }
});

salesforceConnection.sobject("ContentVersion").create({
    OwnerId: '',
    Title: 'hello',
    PathOnClient: './hello-world.jpg',
    VersionData: '{ Test: Data }'
}, (err: Error, ret: sf.RecordResult) => {
    if (err || !ret.success) {
        return;
    }
});