santoid-sdk 1.0.6 → 2.0.0

package/liveness/methods/uploadIdentificationDocument.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadIdentificationDocument = void 0;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../../utils/constants");
+const utils_1 = require("../utils");
+const livenessDetection_1 = require("./livenessDetection");
+async function typificationPredict(options, file) {
+    var _a, _b, _c;
+    const formData = new FormData();
+    formData.append('track', options.track);
+    formData.append('imageFile', file);
+    const decodedToken = (0, utils_1.tryDecodeJwt)(options.token);
+    const domain = (_a = options.domain) !== null && _a !== void 0 ? _a : (_b = decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.claims) === null || _b === void 0 ? void 0 : _b.domain;
+    const axiosConfig = {
+        headers: {
+            'Content-Type': 'multipart/form-data',
+            Authorization: `Bearer ${options.token}`,
+        },
+    };
+    if (axiosConfig.headers && domain) {
+        axiosConfig.headers.Domain = domain;
+    }
+    const response = await axios_1.default.post(`${(_c = options === null || options === void 0 ? void 0 : options.customApiUrl) !== null && _c !== void 0 ? _c : constants_1.API_GATEWAY_URL}/api/v3/typification/predict`, formData, axiosConfig);
+    return response.data;
+}
+async function faceMatch(options, firstImage, secondImage) {
+    var _a, _b, _c;
+    const formData = new FormData();
+    formData.append('track', options.track);
+    formData.append('firstImage', firstImage);
+    formData.append('secondImage', secondImage);
+    const decodedToken = (0, utils_1.tryDecodeJwt)(options.token);
+    const domain = (_a = options.domain) !== null && _a !== void 0 ? _a : (_b = decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.claims) === null || _b === void 0 ? void 0 : _b.domain;
+    const axiosConfig = {
+        params: {
+            sensitive_data_compliance: true,
+        },
+        headers: {
+            'Content-Type': 'multipart/form-data',
+            Authorization: `Bearer ${options.token}`,
+        },
+    };
+    if (axiosConfig.headers && domain) {
+        axiosConfig.headers.Domain = domain;
+    }
+    const response = await axios_1.default.post(`${(_c = options === null || options === void 0 ? void 0 : options.customApiUrl) !== null && _c !== void 0 ? _c : constants_1.API_GATEWAY_URL}/api/v1/facematch/pair`, formData, axiosConfig);
+    return response.data;
+}
+function uploadIdentificationDocument(options) {
+    let results = {
+        uploadedDocument: null,
+        typification: {
+            status: null,
+            results: null,
+            loading: false,
+            error: null,
+        },
+        liveness: {
+            status: null,
+            results: null,
+            loading: false,
+            error: null,
+        },
+        faceMatch: {
+            status: null,
+            results: null,
+            loading: false,
+            error: null,
+        },
+    };
+    async function startFaceMatch(firstImage, secondImage) {
+        var _a, _b, _c;
+        try {
+            updateResults({
+                faceMatch: {
+                    status: null,
+                    results: null,
+                    loading: true,
+                    error: null,
+                },
+            });
+            const faceMatchResults = await faceMatch(options, firstImage, secondImage);
+            updateResults({
+                faceMatch: {
+                    results: faceMatchResults,
+                    status: 'success',
+                    loading: false,
+                    error: null,
+                },
+            });
+        }
+        catch (err) {
+            await ((_a = options.errorCallback) === null || _a === void 0 ? void 0 : _a.call(options, { code: 'face-match-error', details: (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.data }));
+            updateResults({
+                faceMatch: {
+                    results: null,
+                    status: 'error',
+                    loading: false,
+                    error: (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data,
+                },
+            });
+        }
+    }
+    function tryStartFaceMatch() {
+        var _a;
+        if (results.uploadedDocument &&
+            ((_a = results.liveness.results) === null || _a === void 0 ? void 0 : _a.successFrames.front) &&
+            !results.faceMatch.results &&
+            !results.faceMatch.loading) {
+            void startFaceMatch(results.uploadedDocument, results.liveness.results.successFrames.front);
+        }
+    }
+    function updateUploadedDocument(file) {
+        results.uploadedDocument = file;
+        tryStartFaceMatch();
+    }
+    function updateResults(updatedResults) {
+        var _a, _b, _c;
+        results = Object.assign(Object.assign({}, results), updatedResults);
+        void ((_a = options.resultChangeCallback) === null || _a === void 0 ? void 0 : _a.call(options, results));
+        if (Object.entries(results).every(([key, value]) => key === 'uploadedDocument' || !!value.results)) {
+            void ((_b = options.successCallback) === null || _b === void 0 ? void 0 : _b.call(options, results));
+            void ((_c = options.endCallback) === null || _c === void 0 ? void 0 : _c.call(options));
+            return;
+        }
+        tryStartFaceMatch();
+    }
+    async function startDocumentUpload(file) {
+        var _a, _b, _c;
+        try {
+            updateResults({
+                typification: {
+                    status: null,
+                    results: null,
+                    loading: true,
+                    error: null,
+                },
+            });
+            updateUploadedDocument(file);
+            const typificationResults = await typificationPredict(options, file);
+            updateResults({
+                typification: {
+                    status: 'success',
+                    results: typificationResults,
+                    loading: false,
+                    error: null,
+                },
+            });
+        }
+        catch (err) {
+            await ((_a = options.errorCallback) === null || _a === void 0 ? void 0 : _a.call(options, { code: 'typification-error', details: (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.data }));
+            updateResults({
+                typification: {
+                    status: 'error',
+                    results: null,
+                    loading: false,
+                    error: (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data,
+                },
+            });
+        }
+    }
+    async function startLivenessDetection(startLivenessDetectionOptions) {
+        var _a, _b, _c, _d, _e;
+        const adaptedLivenessOptions = Object.assign({}, startLivenessDetectionOptions);
+        delete adaptedLivenessOptions.successCallback;
+        delete adaptedLivenessOptions.errorCallback;
+        updateResults({
+            liveness: {
+                results: null,
+                status: null,
+                loading: true,
+                error: null,
+            },
+        });
+        try {
+            return await (0, livenessDetection_1.livenessDetection)(Object.assign(Object.assign({ domain: options.domain, customId: options.customId, customWebSocketUrl: options.customWebSocketUrl, successCallback: (livenessResults) => {
+                    var _a;
+                    void ((_a = startLivenessDetectionOptions === null || startLivenessDetectionOptions === void 0 ? void 0 : startLivenessDetectionOptions.successCallback) === null || _a === void 0 ? void 0 : _a.call(startLivenessDetectionOptions, livenessResults));
+                    updateResults({
+                        liveness: {
+                            status: 'success',
+                            results: (livenessResults),
+                            loading: false,
+                            error: null,
+                        },
+                    });
+                }, errorCallback: async (livenessErrorDetails) => {
+                    var _a, _b;
+                    if ((livenessErrorDetails === null || livenessErrorDetails === void 0 ? void 0 : livenessErrorDetails.code) === 'wrong-position') {
+                        void ((_a = startLivenessDetectionOptions === null || startLivenessDetectionOptions === void 0 ? void 0 : startLivenessDetectionOptions.errorCallback) === null || _a === void 0 ? void 0 : _a.call(startLivenessDetectionOptions, livenessErrorDetails));
+                    }
+                    else {
+                        void ((_b = options.errorCallback) === null || _b === void 0 ? void 0 : _b.call(options, livenessErrorDetails));
+                    }
+                    updateResults({
+                        liveness: {
+                            status: 'error',
+                            results: null,
+                            loading: (livenessErrorDetails === null || livenessErrorDetails === void 0 ? void 0 : livenessErrorDetails.code) === 'wrong-position',
+                            error: livenessErrorDetails,
+                        },
+                    });
+                } }, adaptedLivenessOptions), { token: (_a = adaptedLivenessOptions.token) !== null && _a !== void 0 ? _a : options.token, track: (_b = adaptedLivenessOptions.track) !== null && _b !== void 0 ? _b : options.track }));
+        }
+        catch (err) {
+            await ((_c = options.errorCallback) === null || _c === void 0 ? void 0 : _c.call(options, { code: 'liveness-error', details: (_d = err === null || err === void 0 ? void 0 : err.response) === null || _d === void 0 ? void 0 : _d.data }));
+            updateResults({
+                liveness: {
+                    status: 'error',
+                    results: null,
+                    loading: false,
+                    error: (_e = err === null || err === void 0 ? void 0 : err.response) === null || _e === void 0 ? void 0 : _e.data,
+                },
+            });
+        }
+    }
+    function startAll(file, startLivenessDetectionOptions) {
+        void startDocumentUpload(file);
+        void startLivenessDetection(startLivenessDetectionOptions);
+    }
+    function getResults() {
+        return results;
+    }
+    return {
+        getResults,
+        startDocumentUpload,
+        startLivenessDetection,
+        startFaceComparison: tryStartFaceMatch,
+        startAll,
+    };
+}
+exports.uploadIdentificationDocument = uploadIdentificationDocument;

package/liveness/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare function decodeJwt(token: string): any;
+export declare function tryDecodeJwt(token: string): any;

package/{dist/esm/liveness → liveness}/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeJwt = void 0;
+exports.tryDecodeJwt = exports.decodeJwt = void 0;
 function decodeJwt(token) {
     const base64Url = token.split('.')[1];
     const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
@@ -14,3 +14,12 @@ function decodeJwt(token) {
     return JSON.parse(jsonPayload);
 }
 exports.decodeJwt = decodeJwt;
+function tryDecodeJwt(token) {
+    try {
+        return decodeJwt(token);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+exports.tryDecodeJwt = tryDecodeJwt;

package/{dist/esm/liveness → liveness}/utils/types.d.ts

@@ -1,5 +1,5 @@
-import { type ISDKOptions } from '../../../utils/types';
+import { type ISDKOptions } from '../../utils/types';
 export type TWebSDKOptions = ISDKOptions & {
     getNextFrame?: () => Promise<Blob | null>;
 };
-export * from '../../../utils/types';
+export * from '../../utils/types';

package/{dist/node/liveness → liveness}/utils/types.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../../../utils/types"), exports);
+__exportStar(require("../../utils/types"), exports);

package/{dist/esm/liveness → liveness}/utils/websocket.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.disconnectFromWebSocket = exports.connectToWebSocket = void 0;
 const _1 = require(".");
-const constants_1 = require("../../../utils/constants");
+const constants_1 = require("../../utils/constants");
 async function waitForWebSocketConnection(websocket) {
     await new Promise((resolve) => {
         const intervalKey = setInterval(() => {

package/{dist/node → node}/auth/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initialize = void 0;
 const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("axios"));
 const constants_1 = require("../../utils/constants");
 async function initialize(options) {
     var _a;
@@ -29,12 +30,8 @@ async function initialize(options) {
         }
     }
     if (credentialsBase64) {
-        const response = await fetch((_a = options === null || options === void 0 ? void 0 : options.customApiUrl) !== null && _a !== void 0 ? _a : constants_1.API_GATEWAY_URL, {
-            method: 'POST',
-            body: JSON.stringify({ service_account_base64: credentialsBase64 }),
-            headers: { 'Content-Type': 'application/json' },
-        });
-        const token = await response.json();
+        const response = await axios_1.default.post(`${(_a = options === null || options === void 0 ? void 0 : options.customApiUrl) !== null && _a !== void 0 ? _a : constants_1.API_GATEWAY_URL}/api/v1/service-account/refresh-token`, { service_account_base64: credentialsBase64 }, { headers: { 'Content-Type': 'application/json' } });
+        const token = await response.data;
         if (typeof token !== 'string') {
             throw new Error('Cannot generate token');
         }

package/node/liveness/index.d.ts

@@ -0,0 +1,9 @@
+import { livenessDetection } from './methods/livenessDetection';
+import { uploadIdentificationDocument } from './methods/uploadIdentificationDocument';
+export { livenessDetection } from './methods/livenessDetection';
+export { uploadIdentificationDocument } from './methods/uploadIdentificationDocument';
+export * from './utils/types';
+export default class SantoiDSDK {
+    static livenessDetection: typeof livenessDetection;
+    static uploadIdentificationDocument: typeof uploadIdentificationDocument;
+}

package/node/liveness/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadIdentificationDocument = exports.livenessDetection = void 0;
+const livenessDetection_1 = require("./methods/livenessDetection");
+const uploadIdentificationDocument_1 = require("./methods/uploadIdentificationDocument");
+var livenessDetection_2 = require("./methods/livenessDetection");
+Object.defineProperty(exports, "livenessDetection", { enumerable: true, get: function () { return livenessDetection_2.livenessDetection; } });
+var uploadIdentificationDocument_2 = require("./methods/uploadIdentificationDocument");
+Object.defineProperty(exports, "uploadIdentificationDocument", { enumerable: true, get: function () { return uploadIdentificationDocument_2.uploadIdentificationDocument; } });
+__exportStar(require("./utils/types"), exports);
+class SantoiDSDK {
+}
+SantoiDSDK.livenessDetection = livenessDetection_1.livenessDetection;
+SantoiDSDK.uploadIdentificationDocument = uploadIdentificationDocument_1.uploadIdentificationDocument;
+exports.default = SantoiDSDK;

package/node/liveness/methods/livenessDetection.d.ts

@@ -0,0 +1,6 @@
+import { type Data } from 'ws';
+import { type TNodeSDKOptions } from '../utils/types';
+export type FrameType = Data | null | undefined;
+export declare function livenessDetection(options: TNodeSDKOptions): Promise<{
+    stopLivenessDetection: () => Promise<void>;
+}>;

package/{dist/node/liveness/index.js → node/liveness/methods/livenessDetection.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.livenessDetection = void 0;
-const constants_1 = require("../../utils/constants");
-const websocket_1 = require("./utils/websocket");
+const constants_1 = require("../../../utils/constants");
+const websocket_1 = require("../utils/websocket");
 async function onWebSocketMessage(options, event) {
     var _a, _b, _c;
     const message = event.data;
@@ -106,7 +106,6 @@ async function livenessDetection(options) {
         };
     }
     catch (err) {
-        console.error('catch error', err);
         !validationSuccess && ((_c = options.errorCallback) === null || _c === void 0 ? void 0 : _c.call(options, { code: 'internal-error' }));
         await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
         throw err;

package/node/liveness/methods/uploadIdentificationDocument.d.ts

@@ -0,0 +1,91 @@
+import { type Data } from 'ws';
+import { type ILivenessResults, type TNodeSDKOptions, type IBaseSDKOptions, type TCallbackFunction, type TErrorCode } from '../utils/types';
+type TResultStatuses = 'success' | 'error' | null;
+type FileType = Data;
+interface ITypificationResult {
+    n_documents: number;
+    predictOCR: Array<{
+        typification: {
+            document_type: string;
+            ocr_success: boolean;
+            typification_score: number;
+        };
+        ocr_error?: boolean | null;
+        ocr_message?: {
+            template: string;
+            labels: any;
+        } | null;
+        ocr_extraction: {
+            template: string;
+            labels: Array<{
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+                bottomRight: number[];
+                topLeft: number[];
+                dataField?: string;
+                dataFieldValue?: boolean;
+                ocr?: string | null;
+                ocr_score?: number;
+                cropBase64?: string | null;
+                serpro_query?: {
+                    serpro_data: any;
+                    search_logs: {
+                        document: string;
+                        type: string;
+                        search_time: string;
+                        status_code: number;
+                        message: string;
+                    };
+                };
+                validation?: Record<string, number | boolean>;
+            }> | null;
+        } | boolean;
+    }>;
+}
+interface IFaceMatchResult {
+    comparison_score: number;
+    similarity_score: number;
+    match: boolean;
+}
+interface IUploadIdentificationDocumentResults {
+    uploadedDocument: FileType | null;
+    typification: {
+        status: TResultStatuses;
+        results: ITypificationResult | null;
+        loading: boolean;
+        error: any;
+    };
+    liveness: {
+        status: TResultStatuses;
+        results: ILivenessResults<FileType | null | undefined> | null;
+        loading: boolean;
+        error: any;
+    };
+    faceMatch: {
+        status: TResultStatuses;
+        results: IFaceMatchResult | null;
+        loading: boolean;
+        error: any;
+    };
+}
+interface IUploadIdentificationDocumentOptions extends IBaseSDKOptions {
+    resultChangeCallback: (results?: IUploadIdentificationDocumentResults) => void | Promise<void>;
+    successCallback: <FrameType, ResultsType = ILivenessResults<FrameType>>(results?: ResultsType) => void | Promise<void>;
+    errorCallback?: (error?: {
+        code: TErrorCode;
+        details?: any;
+    }) => void | Promise<void>;
+    endCallback?: TCallbackFunction;
+}
+export declare function uploadIdentificationDocument(options: IUploadIdentificationDocumentOptions): {
+    getResults: () => IUploadIdentificationDocumentResults;
+    startDocumentUpload: (file: FileType) => Promise<void>;
+    startLivenessDetection: (startLivenessDetectionOptions: TNodeSDKOptions) => Promise<{
+        stopLivenessDetection: () => Promise<void>;
+    } | undefined>;
+    startFaceComparison: () => void;
+    startAll: (file: FileType, startLivenessDetectionOptions: TNodeSDKOptions) => void;
+};
+export {};