sfobjects-basic-client 1.1.4 → 1.1.6

package/dist/index.d.ts

@@ -133,6 +133,11 @@ export type SfDmlOptions = {
         };
     };
 };
+export type SfClientOptions = {
+    breakOnError?: boolean;
+    query?: SfQueryOptions;
+    dml?: SfDmlOptions;
+};
 export type SfQueryResult<R> = {
     records: R[];
 };
@@ -161,19 +166,20 @@ export interface SfSelectActions<OI, N extends KeyOf<OI>, S extends SfRootSelect
     limit: (limit: number) => SfSelectActions<OI, N, S>;
 }
 export interface SfOrderByAction<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
-    orderBy: (orderBy: SfRootOrderBy<OI, N>) => SfSelectActions<OI, N, S>;
+    orderBy: <R extends SfRootOrderBy<OI, N>>(orderBy: R) => SfSelectActions<OI, N, S>;
 }
 export interface SfWhereActions<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
-    where: (where: SfRootWhere<OI, N>) => (SfSelectActions<OI, N, S> & SfOrderByAction<OI, N, S>);
+    where: <W extends SfRootWhere<OI, N>>(where: W) => (SfSelectActions<OI, N, S> & SfOrderByAction<OI, N, S>);
 }
 export interface SfSelectAditionalActions<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
     find: (id: string, options?: SfQueryOptions) => Promise<SfRootSelectProjection<OI, N, S> | undefined>;
+    retrieve: (id: string, options?: SfQueryOptions) => Promise<SfRootSelectProjection<OI, N, S>>;
     selection: S[];
 }
 export interface SfObjActions<OI, N extends KeyOf<OI>> {
-    query: <S extends SfRootSelect<OI, N>>(q: {
+    query: <S extends SfRootSelect<OI, N>, W extends SfRootWhere<OI, N>>(q: {
         select: S[];
-        where?: SfRootWhere<OI, N>;
+        where?: string | W;
         orderBy?: SfRootOrderBy<OI, N>;
         limit?: number;
     }) => SfSelectActions<OI, N, S>;
@@ -183,10 +189,20 @@ export interface SfObjActions<OI, N extends KeyOf<OI>> {
     upsert: <K extends MandatoryCreateProps<OI[N]>>(records: SfUpsert<OI[N], K>[], key: K, options?: SfDmlOptions) => PromiseLike<SfSaveResult[]>;
     select: <S extends SfRootSelect<OI, N>>(select: S[]) => (SfSelectActions<OI, N, S> & SfWhereActions<OI, N, S> & SfSelectAditionalActions<OI, N, S>);
 }
+export declare class SfBasicClientSaveError extends Error {
+    errors: SfSaveError[];
+    constructor(errors: SfSaveError[]);
+}
+export declare class SfBasicClientReadError extends Error {
+    error: string;
+    constructor(error: string);
+}
 export declare function isPlainObject(value: unknown): value is Record<string, any>;
 export declare function constructSoql<OI>(_cfg: SfObjCfgIndex<OI>): (objName: string, from: string, select: (string | {})[], where?: string | Record<string, any>, orderBy?: Record<string, any>, limit?: number) => string;
-export declare function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>): <N extends KeyOf<OI>>(from: N, _conn: ISfConnection) => SfObjActions<OI, N>;
-export declare const getSfObjects: <OI>(cfg: SfObjCfgIndex<OI>) => (conn: ISfConnection) => { [N in KeyOf<OI>]: SfObjActions<OI, N>; };
+export declare function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>, o?: SfClientOptions): <N extends KeyOf<OI>>(from: N, _conn: ISfConnection) => SfObjActions<OI, N>;
+export declare const getSfObjects: <OI>(cfg: SfObjCfgIndex<OI>) => (conn: ISfConnection, options?: SfClientOptions) => { [N in KeyOf<OI>]: SfObjActions<OI, N>; } & {
+    __getObject: <N_1 extends KeyOf<OI>>(from: N_1, _conn: ISfConnection) => SfObjActions<OI, N_1>;
+};
 export declare const sfObject: <OI, N extends KeyOf<OI>>(cfg: SfObjCfgIndex<OI>, n: N) => {
     info: SfObjCfgIndex<OI>[N];
     select: <S extends SfRootSelect<OI, N>>(s: S[]) => S[];

package/dist/index.js

@@ -21,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sfObject = exports.getSfObjects = void 0;
+exports.sfObject = exports.getSfObjects = exports.SfBasicClientReadError = exports.SfBasicClientSaveError = void 0;
 exports.isPlainObject = isPlainObject;
 exports.constructSoql = constructSoql;
 exports.getSfObject = getSfObject;
@@ -70,6 +70,24 @@ const OP_RULES = [
     { ops: OP_KEYS_LIKE, soqlOp: 'like' },
     { ops: OP_KEYS_NLIKE, soqlOp: 'like', isNot: true },
 ];
+class SfBasicClientSaveError extends Error {
+    constructor(errors) {
+        super('Salesforce error(s): ' + errors.map(e => { var _a; return `[${e.errorCode}] ${e.message}, field(s): ${(_a = e.fields) === null || _a === void 0 ? void 0 : _a.join(',')}`; }).join(';\r\n'));
+        this.errors = errors;
+        this.name = 'SfBasicClientSaveError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.SfBasicClientSaveError = SfBasicClientSaveError;
+class SfBasicClientReadError extends Error {
+    constructor(error) {
+        super('Salesforce error: ' + error);
+        this.error = error;
+        this.name = 'SfBasicClientReadError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.SfBasicClientReadError = SfBasicClientReadError;
 // functions
 function isPlainObject(value) {
     if (typeof value !== 'object' || value === null)
@@ -222,37 +240,55 @@ function constructSoql(_cfg) {
     }
     return _constructFullQuery;
 }
-function getSfObject(_cfg) {
+function processSaveResult(sr, breakOnError) {
+    if (breakOnError) {
+        const _errors = sr.filter(r => (r.success !== true)).map(r => r.errors).flat();
+        if (_errors.length) {
+            throw new SfBasicClientSaveError(_errors);
+        }
+    }
+    return sr;
+}
+function getSfObject(_cfg, o) {
     function _query(conn, from, select, where, orderBy, limit) {
         const soql = () => constructSoql(_cfg)(from, from, select, where, orderBy, limit);
         return ({
             soql,
-            get: (options) => __awaiter(this, void 0, void 0, function* () { return yield conn.query(soql(), options); }), // to get rid of promiselike,            
+            get: (...args_1) => __awaiter(this, [...args_1], void 0, function* (options = o === null || o === void 0 ? void 0 : o.query) { return yield conn.query(soql(), options); }), // to get rid of promiselike,            
             limit: (limit) => _query(conn, from, select, where, orderBy, limit)
         });
     }
+    function _queryOne(conn, from, select, id, options = o === null || o === void 0 ? void 0 : o.query) {
+        return _query(conn, from, select, `Id = '${id}'`).limit(1).get(options);
+    }
     return (from, _conn) => {
         return ({
             query: (q) => {
                 const { select, where, orderBy, limit } = q;
                 return _query(_conn, from, select, where, orderBy, limit);
             },
-            delete: (ids, options) => _conn.delete(from, ids, options),
-            update: (records, options) => _conn.update(from, records, options),
-            create: (records, options) => _conn.create(from, records, options),
-            upsert: (records, key, options) => _conn.upsert(from, records, key, options),
-            select: (select) => (Object.assign(Object.assign({}, _query(_conn, from, select)), { orderBy: (orderBy) => _query(_conn, from, select, undefined, orderBy), where: (where) => (Object.assign(Object.assign({}, _query(_conn, from, select, where)), { orderBy: (orderBy) => _query(_conn, from, select, where, orderBy) })), find: (id, options) => __awaiter(this, void 0, void 0, function* () {
-                    const result = yield _query(_conn, from, select, `Id = '${id}'`).limit(1).get(options);
+            delete: (ids_1, ...args_1) => __awaiter(this, [ids_1, ...args_1], void 0, function* (ids, options = o === null || o === void 0 ? void 0 : o.dml) { return processSaveResult(yield _conn.delete(from, ids, options), o === null || o === void 0 ? void 0 : o.breakOnError); }),
+            update: (records_1, ...args_1) => __awaiter(this, [records_1, ...args_1], void 0, function* (records, options = o === null || o === void 0 ? void 0 : o.dml) { return processSaveResult(yield _conn.update(from, records, options), o === null || o === void 0 ? void 0 : o.breakOnError); }),
+            create: (records_1, ...args_1) => __awaiter(this, [records_1, ...args_1], void 0, function* (records, options = o === null || o === void 0 ? void 0 : o.dml) { return processSaveResult(yield _conn.create(from, records, options), o === null || o === void 0 ? void 0 : o.breakOnError); }),
+            upsert: (records_1, key_1, ...args_1) => __awaiter(this, [records_1, key_1, ...args_1], void 0, function* (records, key, options = o === null || o === void 0 ? void 0 : o.dml) { return processSaveResult(yield _conn.upsert(from, records, key, options), o === null || o === void 0 ? void 0 : o.breakOnError); }),
+            select: (select) => (Object.assign(Object.assign({}, _query(_conn, from, select)), { orderBy: (orderBy) => _query(_conn, from, select, undefined, orderBy), where: (where) => (Object.assign(Object.assign({}, _query(_conn, from, select, where)), { orderBy: (orderBy) => _query(_conn, from, select, where, orderBy) })), find: (id_1, ...args_1) => __awaiter(this, [id_1, ...args_1], void 0, function* (id, options = o === null || o === void 0 ? void 0 : o.query) {
+                    const result = yield _queryOne(_conn, from, select, id, options);
                     if (result.records.length) {
                         return result.records[0];
                     }
+                }), retrieve: (id_1, ...args_1) => __awaiter(this, [id_1, ...args_1], void 0, function* (id, options = o === null || o === void 0 ? void 0 : o.query) {
+                    const result = yield _queryOne(_conn, from, select, id, options);
+                    if (!result.records.length) {
+                        throw new SfBasicClientReadError(`Record with id '${id}' is not found in '${from}'.`);
+                    }
+                    return result.records[0];
                 }), selection: select }))
         });
     };
 }
-const getSfObjects = (cfg) => (conn) => {
-    const _func = getSfObject(cfg);
-    return Object.keys(cfg).reduce((p, n) => (Object.assign(Object.assign({}, p), { [n]: _func(n, conn) })), {});
+const getSfObjects = (cfg) => (conn, options) => {
+    const __getObject = getSfObject(cfg, options);
+    return Object.assign(Object.assign({}, Object.keys(cfg).reduce((p, n) => (Object.assign(Object.assign({}, p), { [n]: __getObject(n, conn) })), {})), { __getObject });
 };
 exports.getSfObjects = getSfObjects;
 const sfObject = (cfg, n) => ({ info: cfg[n], select: (s) => s });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sfobjects-basic-client",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Basic Salesforce Client to use together with sfobjects-to-typescript lib",
   "license": "ISC",
   "author": "Murad Aliyev",  

package/src/index.ts

@@ -228,6 +228,12 @@ export type SfDmlOptions = {
     };
 };
 
+export type SfClientOptions = {
+    breakOnError?: boolean
+    query?: SfQueryOptions;
+    dml?: SfDmlOptions;
+}
+
 export type SfQueryResult<R> = { records: R[] };
 
 export type SfSaveResult = {
@@ -259,21 +265,22 @@ export interface SfSelectActions<OI, N extends KeyOf<OI>, S extends SfRootSelect
 }
 
 export interface SfOrderByAction<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
-    orderBy: (orderBy: SfRootOrderBy<OI, N>) => SfSelectActions<OI, N, S>;
+    orderBy: <R extends SfRootOrderBy<OI, N>>(orderBy: R) => SfSelectActions<OI, N, S>;
 }
 
 export interface SfWhereActions<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
-    where: (where: SfRootWhere<OI, N>) => (SfSelectActions<OI, N, S> & SfOrderByAction<OI, N, S>);
+    where: <W extends SfRootWhere<OI, N>>(where: W) => (SfSelectActions<OI, N, S> & SfOrderByAction<OI, N, S>);
 }
 
 export interface SfSelectAditionalActions<OI, N extends KeyOf<OI>, S extends SfRootSelect<OI, N>> {
     find: (id: string, options?: SfQueryOptions) => Promise<SfRootSelectProjection<OI, N, S> | undefined>;
+    retrieve: (id: string, options?: SfQueryOptions) => Promise<SfRootSelectProjection<OI, N, S>>;
     selection: S[];
     //S extends SfRootSelect<OI, N>
 }
 
 export interface SfObjActions<OI, N extends KeyOf<OI>> {
-    query: <S extends SfRootSelect<OI, N>>(q: { select: S[], where?: SfRootWhere<OI, N>, orderBy?: SfRootOrderBy<OI, N>, limit?: number }) => SfSelectActions<OI, N, S>;
+    query: <S extends SfRootSelect<OI, N>, W extends SfRootWhere<OI, N>>(q: { select: S[], where?: string | W, orderBy?: SfRootOrderBy<OI, N>, limit?: number }) => SfSelectActions<OI, N, S>;
     delete: (ids: string[], options?: SfDmlOptions) => PromiseLike<SfSaveResult[]>;
     update: (records: SfUpdate<OI[N]>[], options?: SfDmlOptions) => PromiseLike<SfSaveResult[]>;
     create: (records: SfCreate<OI[N]>[], options?: SfDmlOptions) => PromiseLike<SfSaveResult[]>;
@@ -281,6 +288,22 @@ export interface SfObjActions<OI, N extends KeyOf<OI>> {
     select: <S extends SfRootSelect<OI, N>>(select: S[]) => (SfSelectActions<OI, N, S> & SfWhereActions<OI, N, S> & SfSelectAditionalActions<OI, N, S>);
 }
 
+export class SfBasicClientSaveError extends Error {
+    constructor(public errors: SfSaveError[]) {
+        super('Salesforce error(s): ' + errors.map(e => `[${e.errorCode}] ${e.message}, field(s): ${e.fields?.join(',')}`).join(';\r\n'))
+        this.name = 'SfBasicClientSaveError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+export class SfBasicClientReadError extends Error {
+    constructor(public error: string) {
+        super('Salesforce error: ' + error)
+        this.name = 'SfBasicClientReadError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
 // functions
 
 export function isPlainObject(value: unknown): value is Record<string, any> {
@@ -350,8 +373,6 @@ export function constructSoql<OI>(_cfg: SfObjCfgIndex<OI>) {
             'limit': limit?.toString()
         }
 
-
-
         return Object.keys(o).filter(k => !!o[k]).reduce((p, k) => ([p, k, o[k]].join(' ')), '');
     }
 
@@ -519,14 +540,29 @@ export function constructSoql<OI>(_cfg: SfObjCfgIndex<OI>) {
     return _constructFullQuery;
 }
 
-export function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>) {
+function processSaveResult(sr: SfSaveResult[], breakOnError?: boolean): SfSaveResult[] {
+
+    if (breakOnError) {
+
+        const _errors: SfSaveError[] = sr.filter(r => (r.success !== true)).map(r => r.errors).flat();
+
+        if (_errors.length) {
+            throw new SfBasicClientSaveError(_errors);
+        }
+    }
+
+    return sr;
+}
+
+export function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>, o?: SfClientOptions) {
 
-    function _query<S extends SfRootSelect<OI, N>, N extends KeyOf<OI>>(
+
+    function _query<S extends SfRootSelect<OI, N>, W extends SfRootWhere<OI, N>, R extends SfRootOrderBy<OI, N>, N extends KeyOf<OI>>(
         conn: ISfConnection,
         from: N,
         select: S[],
-        where?: string | SfRootWhere<OI, N>,
-        orderBy?: SfRootOrderBy<OI, N>,
+        where?: string | W,
+        orderBy?: R,
         limit?: number
     ): SfSelectActions<OI, N, S> {
 
@@ -534,53 +570,73 @@ export function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>) {
 
         return ({
             soql,
-            get: async (options?: SfQueryOptions) => await conn.query<SfRootSelectProjection<OI, N, S>>(soql(), options), // to get rid of promiselike,            
+            get: async (options: SfQueryOptions | undefined = o?.query) => await conn.query<SfRootSelectProjection<OI, N, S>>(soql(), options), // to get rid of promiselike,            
             limit: (limit: number) => _query(conn, from, select, where, orderBy, limit)
         });
     }
 
+    function _queryOne<S extends SfRootSelect<OI, N>, N extends KeyOf<OI>>(
+        conn: ISfConnection,
+        from: N,
+        select: S[],
+        id: string,
+        options: SfQueryOptions | undefined = o?.query
+    ) {
+        return _query(conn, from, select, `Id = '${id}'`).limit(1).get(options);
+    }
+
     return <N extends KeyOf<OI>>(from: N, _conn: ISfConnection): SfObjActions<OI, N> => {
 
         return ({
 
-            query: <S extends SfRootSelect<OI, N>>(q: { select: S[], where?: SfRootWhere<OI, N>, orderBy?: SfRootOrderBy<OI, N>, limit?: number }) => {
+            query: <S extends SfRootSelect<OI, N>, W extends SfRootWhere<OI, N>, R extends SfRootOrderBy<OI, N>>(q: { select: S[], where?: string | W, orderBy?: R, limit?: number }) => {
                 const { select, where, orderBy, limit } = q;
                 return _query(_conn, from, select, where, orderBy, limit);
             },
 
-            delete: (ids: string[], options?: SfDmlOptions) => _conn.delete(from, ids, options),
+            delete: async (ids: string[], options: SfDmlOptions | undefined = o?.dml) => processSaveResult(await _conn.delete(from, ids, options), o?.breakOnError),
 
-            update: (records: SfUpdate<OI[N]>[], options?: SfDmlOptions) => _conn.update(from, records, options),
+            update: async (records: SfUpdate<OI[N]>[], options: SfDmlOptions | undefined = o?.dml) => processSaveResult(await _conn.update(from, records, options), o?.breakOnError),
 
-            create: (records: SfCreate<OI[N]>[], options?: SfDmlOptions) => _conn.create(from, records, options),
+            create: async (records: SfCreate<OI[N]>[], options: SfDmlOptions | undefined = o?.dml) => processSaveResult(await _conn.create(from, records, options), o?.breakOnError),
 
-            upsert: <K extends MandatoryCreateProps<OI[N]>>(records: SfUpsert<OI[N], K>[], key: K, options?: SfDmlOptions) => _conn.upsert(from, records, key, options),
+            upsert: async <K extends MandatoryCreateProps<OI[N]>>(records: SfUpsert<OI[N], K>[], key: K, options: SfDmlOptions | undefined = o?.dml) => processSaveResult(await _conn.upsert(from, records, key, options), o?.breakOnError),
 
             select: <S extends SfRootSelect<OI, N>>(select: S[]) => ({
 
                 ..._query(_conn, from, select),
 
-                orderBy: (orderBy: SfRootOrderBy<OI, N>) => _query(_conn, from, select, undefined, orderBy),
+                orderBy: <R extends SfRootOrderBy<OI, N>>(orderBy: R) => _query(_conn, from, select, undefined, orderBy),
 
-                where: (where: SfRootWhere<OI, N>) => ({
+                where: <W extends SfRootWhere<OI, N>>(where: string | W) => ({
 
                     ..._query(_conn, from, select, where),
 
-                    orderBy: (orderBy: SfRootOrderBy<OI, N>) => _query(_conn, from, select, where, orderBy),
+                    orderBy: <R extends SfRootOrderBy<OI, N>>(orderBy: R) => _query(_conn, from, select, where, orderBy),
 
                 }),
 
-                find: async (id: string, options?: SfQueryOptions) => {
+                find: async (id: string, options: SfQueryOptions | undefined = o?.query) => {
 
-                    const result = await _query(_conn, from, select, `Id = '${id}'`).limit(1).get(options);
+                    const result = await _queryOne(_conn, from, select, id, options);
 
                     if (result.records.length) {
                         return result.records[0];
                     }
                 },
 
-                selection: select
+                retrieve: async (id: string, options: SfQueryOptions | undefined = o?.query) => {
+
+                    const result = await _queryOne(_conn, from, select, id, options);
+
+                    if (!result.records.length) {
+                        throw new SfBasicClientReadError(`Record with id '${id}' is not found in '${from}'.`);
+                    }
+
+                    return result.records[0];
+                },
 
+                selection: select
             })
         })
     };
@@ -588,9 +644,9 @@ export function getSfObject<OI>(_cfg: SfObjCfgIndex<OI>) {
 }
 
 
-export const getSfObjects = <OI>(cfg: SfObjCfgIndex<OI>) => (conn: ISfConnection) => {
-    const _func = getSfObject<OI>(cfg);
-    return (Object.keys(cfg) as KeyOf<OI>[]).reduce((p, n) => ({ ...p, [n]: _func(n, conn) }), {} as { [N in KeyOf<OI>]: SfObjActions<OI, N> });
+export const getSfObjects = <OI>(cfg: SfObjCfgIndex<OI>) => (conn: ISfConnection, options?: SfClientOptions) => {
+    const __getObject = getSfObject<OI>(cfg, options);
+    return { ...(Object.keys(cfg) as KeyOf<OI>[]).reduce((p, n) => ({ ...p, [n]: __getObject(n, conn) }), {} as { [N in KeyOf<OI>]: SfObjActions<OI, N> }), __getObject };
 }
 
 export const sfObject = <OI, N extends KeyOf<OI>>(cfg: SfObjCfgIndex<OI>, n: N) => ({ info: cfg[n], select: <S extends SfRootSelect<OI, N>>(s: S[]) => s });