@serptech/api 1.0.0

package/packages/serp-rest-api/src/serp-rest-api/features/utilities/v1/index.ts

@@ -0,0 +1,114 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+
+import { addFileToFormData, addDataToFormData } from "../../../../utils";
+import {
+  UtilitiesInterface,
+  ComparePhotosParamsInterface,
+  ComparePhotosResponseInterface,
+  ComparePersonPhotoWithDocumentPhotoParamsInterface,
+  VerifyPersonPhotoWithDocumentPhotoParamsInterface,
+  VerifyPersonPhotoWithDocumentPhotoResponseInterface,
+  FindOutCustomerParamsInterface,
+  FindOutCustomerResponseInterface,
+  GetApiVersionResponseInterface,
+  CheckAsmParamsInterface,
+  CheckAsmResponseInterface,
+} from "../../../api-facade/v1/utilities";
+
+class Utilities extends Api implements UtilitiesInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.comparePhotos = this.comparePhotos.bind(this);
+    this.comparePersonPhotoWithDocumentPhoto = this.comparePersonPhotoWithDocumentPhoto.bind(
+      this
+    );
+    this.verifyPersonPhotoWithDocumentPhoto = this.verifyPersonPhotoWithDocumentPhoto.bind(
+      this
+    );
+    this.findOutCustomer = this.findOutCustomer.bind(this);
+    this.checkAsm = this.checkAsm.bind(this);
+    this.getSupportedIdTypes = this.getSupportedIdTypes.bind(this);
+    this.getApiVersion = this.getApiVersion.bind(this);
+  }
+
+  comparePhotos({
+    image1,
+    image2,
+    result,
+  }: ComparePhotosParamsInterface): Promise<ComparePhotosResponseInterface> {
+    const fieldsData = { result };
+    const data = new FormData();
+
+    addFileToFormData(data, image1, "image1");
+    addFileToFormData(data, image2, "image2");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post("compare/", data);
+  }
+
+  comparePersonPhotoWithDocumentPhoto({
+    photo,
+    facesize,
+    result,
+  }: ComparePersonPhotoWithDocumentPhotoParamsInterface): Promise<
+    ComparePhotosResponseInterface
+  > {
+    const fieldsData = { facesize, result };
+    const data = new FormData();
+
+    addFileToFormData(data, photo, "photo");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post("faceid/compare/", data);
+  }
+
+  verifyPersonPhotoWithDocumentPhoto({
+    photo_face,
+    photo_face_facesize,
+    photo_id,
+    photo_id_facesize,
+    id_code,
+    result,
+  }: VerifyPersonPhotoWithDocumentPhotoParamsInterface): Promise<
+    VerifyPersonPhotoWithDocumentPhotoResponseInterface
+  > {
+    const fieldsData = {
+      photo_face_facesize,
+      photo_id_facesize,
+      id_code,
+      result,
+    };
+    const data = new FormData();
+
+    addFileToFormData(data, photo_face, "photo_face");
+    addFileToFormData(data, photo_id, "photo_id");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post("faceid/verification/", data);
+  }
+
+  findOutCustomer({
+    source,
+    offset,
+  }: FindOutCustomerParamsInterface): Promise<
+    FindOutCustomerResponseInterface
+  > {
+    return this.httpClient.get("utility/customer/", { source, offset });
+  }
+
+  checkAsm({
+    image,
+  }: CheckAsmParamsInterface): Promise<CheckAsmResponseInterface> {
+    return this.httpClient.post("compare/", { image });
+  }
+
+  getSupportedIdTypes(): Promise<null> {
+    return this.httpClient.get("faceid/id-codes/");
+  }
+
+  getApiVersion(): Promise<GetApiVersionResponseInterface> {
+    return this.httpClient.get("version/");
+  }
+}
+
+export { Utilities };

package/packages/serp-rest-api/src/serp-rest-api/index.ts

@@ -0,0 +1,82 @@
+import "isomorphic-form-data";
+
+import axios from "axios";
+import { createHttpClient } from "../http-client";
+
+import { ApiFacadeV1, ApiFacadeV1Interface } from "./api-facade/v1";
+import { Auth as AuthV1 } from "./features/auth/v1";
+import { Entries as EntriesV1 } from "./features/entries/v1";
+import { Notifications as NotificationsV1 } from "./features/notifications/v1";
+import { Persons as PersonsV1 } from "./features/persons/v1";
+import { Sources as SourcesV1 } from "./features/sources/v1";
+import { Tokens as TokensV1 } from "./features/tokens/v1";
+import { Spaces as SpacesV1 } from "./features/spaces/v1";
+import { Utilities as UtilitiesV1 } from "./features/utilities/v1";
+import { PersonsGroups as PersonsGroupsV1 } from "./features/persons-groups/v1";
+import { Thresholds as ThresholdsV1 } from "./features/thresholds/v1";
+import { StreamTokens as StreamTokensV1 } from "./features/stream-tokens/v1";
+import { Licenses as LicensesV1 } from "./features/licenses/v1";
+
+import { apiEndpoints, apiVersions } from "../constants";
+
+interface SerpRestApiSettingsInterface {
+  token?: string;
+  version?: number;
+}
+
+function createSerpRestApiV1({
+  token,
+}: {
+  token?: string;
+} = {}): ApiFacadeV1Interface {
+  const HttpClient = createHttpClient({ client: axios });
+  const httpClient = new HttpClient({
+    baseURL: apiEndpoints.v1.base,
+    token,
+  });
+
+  return new ApiFacadeV1({
+    httpClient,
+    auth: new AuthV1({ httpClient, authURL: apiEndpoints.v1.auth }),
+    tokens: new TokensV1({ httpClient, authURL: apiEndpoints.v1.auth }),
+    spaces: new SpacesV1({ httpClient, authURL: apiEndpoints.v1.auth }),
+    licenses: new LicensesV1({ httpClient, authURL: apiEndpoints.v1.auth }),
+    notifications: new NotificationsV1({ httpClient }),
+    entries: new EntriesV1({ httpClient }),
+    persons: new PersonsV1({ httpClient }),
+    sources: new SourcesV1({ httpClient }),
+    utilities: new UtilitiesV1({ httpClient }),
+    personsGroups: new PersonsGroupsV1({ httpClient }),
+    thresholds: new ThresholdsV1({ httpClient }),
+    streamTokens: new StreamTokensV1({ httpClient }),
+  });
+}
+
+function createSerpRestApi(
+  settings: SerpRestApiSettingsInterface = {}
+): ApiFacadeV1Interface | undefined {
+  const { version, token } = settings;
+
+  if (!version) {
+    throw new Error(
+      `You did not specify Serp API version.
+      Available versions: ${apiVersions.join(", ")}`
+    );
+  }
+
+  const numVersion = Number(version);
+
+  if (!apiVersions.includes(numVersion)) {
+    throw new Error(
+      `You have specified a non-existent version of Serp API: ${version}.
+      Available versions: ${apiVersions.join(", ")}`
+    );
+  }
+
+  switch (numVersion) {
+    case 1:
+      return createSerpRestApiV1({ token });
+  }
+}
+
+export { createSerpRestApi };

package/packages/serp-rest-api/src/utils/data.ts

@@ -0,0 +1,13 @@
+export function removeEmpty(obj: { [key: string]: any }): any {
+  if (typeof obj !== "object" || obj === null || obj instanceof Array) {
+    return obj;
+  }
+
+  return Object.keys(obj)
+    .filter((key) => obj[key] !== undefined)
+    .reduce((newObj, key) => ({ ...newObj, [key]: obj[key] }), {});
+}
+
+export function isEmpty(obj: {}): boolean {
+  return Object.keys(obj).length === 0;
+}

package/packages/serp-rest-api/src/utils/files.ts

@@ -0,0 +1,83 @@
+import { removeEmpty } from "./index";
+
+// convert base64/URLEncoded data component to raw binary data held in a string
+function dataURItoBlob(dataURI: string): Blob {
+  let byteString;
+
+  if (dataURI.split(",")[0].indexOf("base64") >= 0) {
+    byteString = atob(dataURI.split(",")[1]);
+  } else {
+    byteString = unescape(dataURI.split(",")[1]);
+  }
+
+  // separate out the mime component
+  const mimeString = dataURI.split(",")[0].split(":")[1].split(";")[0];
+  // write the bytes of the string to a typed array
+  const ia = new Uint8Array(byteString.length);
+
+  for (let i = 0; i < byteString.length; i++) {
+    ia[i] = byteString.charCodeAt(i);
+  }
+
+  return new Blob([ia], { type: mimeString });
+}
+
+function getFileExtensionFromBase64String(base64: string): string {
+  return base64.substring("data:image/".length, base64.indexOf(";base64"));
+}
+
+export function addFileToFormData(
+  formData: FormData,
+  file: File | string,
+  fieldName: string,
+  fileName?: string
+): FormData {
+  if (!file) return formData;
+
+  if (typeof file === "string") {
+    const formFieldName =
+      fileName || `${fieldName}.${getFileExtensionFromBase64String(file)}`;
+
+    formData.append(fieldName, dataURItoBlob(file), formFieldName);
+  } else {
+    const formFieldName = fileName || file.name;
+
+    formData.append(fieldName, file, formFieldName);
+  }
+
+  return formData;
+}
+
+interface FieldsData {
+  [key: string]: any;
+}
+
+export function addDataToFormData(
+  formData: FormData,
+  fieldsData: FieldsData
+): FormData {
+  if (!formData) return formData;
+
+  Object.keys(removeEmpty(fieldsData)).forEach((key) => {
+    const value = fieldsData[key];
+
+    formData.append(key, value);
+  });
+
+  return formData;
+}
+
+export function getFormDataSize(formData: FormData): number {
+  if (!formData) return 0;
+
+  return Array.from(formData.entries(), ([_, prop]) => {
+    if (typeof prop === "string") {
+      return prop.length;
+    }
+    if (prop.size) {
+      return prop.size;
+    }
+
+    return 0;
+  }).reduce((resultLength, length) => resultLength + length, 0);
+}

package/packages/serp-rest-api/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./files";

package/packages/serp-websocket/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2024, Serptech, d@serptech.ru
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/serp-websocket/README.md

@@ -0,0 +1,32 @@
+# Serp WebSocket Client TS/JS library
+
+## Installation
+
+### NPM
+
+```bash
+npm i --save @serp/websocket
+```
+
+### Yarn
+
+```bash
+yarn add @serp/websocket
+```
+
+## Usage
+
+```js
+// ES2015 module import:
+import { createSerpWsApi } from "@serp/websocket";
+
+// CommonJS module require:
+const { createSerpWsApi } = require("@serp/websocket");
+
+const SerpWsApi = createSerpWsApi({
+  version: 1,
+  token: SERP_TOKEN,
+});
+
+SerpWsApi.connect();
+```