@serptech/api 1.0.0

package/packages/serp-rest-api/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@serp/rest-api",
+  "version": "1.0.0",
+  "description": "Library for work with Serp REST API",
+  "main": "./dist/index.node.js",
+  "types": "./dist/@types/index.d.ts",
+  "browser": {
+    "./dist/index.node.js": "./dist/index.web.js"
+  },
+  "scripts": {
+    "check-types": "tsc",
+    "create-declaration": "tsc --noEmit false --emitDeclarationOnly --declarationDir ./dist/@types --declaration true",
+    "build": "set NODE_OPTIONS=--openssl-legacy-provider && webpack",
+    "prepublishOnly": "npm run build && npm run create-declaration",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "dependencies": {
+    "axios": "^0.19.2",
+    "isomorphic-form-data": "^2.0.0",
+    "object-sizeof": "^1.6.1",
+    "qs": "^6.10.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.15.7",
+    "@babel/core": "^7.15.8",
+    "@babel/plugin-proposal-class-properties": "^7.14.5",
+    "@babel/plugin-proposal-object-rest-spread": "^7.15.6",
+    "@babel/preset-env": "^7.15.8",
+    "@babel/preset-typescript": "^7.15.0",
+    "@types/axios": "^0.14.0",
+    "@types/isomorphic-form-data": "^2.0.0",
+    "@types/jest": "^26.0.24",
+    "@types/qs": "^6.9.7",
+    "@typescript-eslint/eslint-plugin": "^3.10.1",
+    "@typescript-eslint/parser": "^3.10.1",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
+    "babel-loader": "^8.2.2",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-plugin-jest": "^23.20.0",
+    "eslint-plugin-prettier": "^3.4.1",
+    "file-api": "^0.10.4",
+    "jest": "^26.6.3",
+    "jest-mock-axios": "^4.4.1",
+    "parallel-webpack": "^2.6.0",
+    "prettier": "^2.4.1",
+    "ts-jest": "^26.5.6",
+    "ts-loader": "^8.3.0",
+    "typescript": "^3.9.10",
+    "webpack": "^4.46.0",
+    "webpack-cli": "^3.3.12"
+  },
+  "keywords": [],
+  "author": "Dmitriy Balashov <mockedcat@gmail.com>",
+  "license": "MIT"
+}

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

@@ -0,0 +1,15 @@
+export interface ApiSettingsInterface {
+  httpClient: any;
+}
+
+export interface ApiInterface {}
+
+class Api implements ApiInterface {
+  protected httpClient: any;
+
+  constructor(settings: ApiSettingsInterface) {
+    this.httpClient = settings.httpClient;
+  }
+}
+
+export { Api };

package/packages/serp-rest-api/src/base/auth-api.ts

@@ -0,0 +1,25 @@
+import { ApiSettingsInterface, ApiInterface } from "./api";
+
+export interface AuthApiSettingsInterface extends ApiSettingsInterface {
+  authURL: string;
+}
+
+export interface AuthApiInterface extends ApiInterface {
+  setAuthURL(url: string): void;
+}
+
+class AuthApi implements AuthApiInterface {
+  protected httpClient: any;
+  protected authURL: string;
+
+  constructor(settings: AuthApiSettingsInterface) {
+    this.httpClient = settings.httpClient;
+    this.authURL = settings.authURL;
+  }
+
+  setAuthURL(url: string) {
+    this.authURL = url;
+  }
+}
+
+export { AuthApi };

package/packages/serp-rest-api/src/base/types.ts

@@ -0,0 +1,33 @@
+export type numeric = number | string;
+
+export type id = number;
+
+export enum SexEnum {
+  Male = 0,
+  Female = 1,
+}
+
+export type Sex = 1 | 0;
+
+export type Liveness = "passed" | "failed" | "undetermined";
+
+export type Result = "new" | "reinit" | "exact" | "ha" | "junk" | "nm" | "det";
+
+export type Mood =
+  | "neutral"
+  | "anger"
+  | "contempt"
+  | "disgust"
+  | "fear"
+  | "happiness"
+  | "sadness"
+  | "surprise";
+
+export interface Paginatable {
+  offset?: numeric;
+  limit?: numeric;
+}
+
+export interface Searchable {
+  q?: string;
+}

package/packages/serp-rest-api/src/constants/index.js

@@ -0,0 +1,13 @@
+const apiVersions = [1];
+
+const apiEndpoints = {
+  v1: {
+    base: "https://api.serptech.ru/v1/",
+    auth: "https://iam.serptech.ru/v1/",
+  },
+};
+
+module.exports = {
+  apiVersions,
+  apiEndpoints,
+};

package/packages/serp-rest-api/src/http-client.ts

@@ -0,0 +1,207 @@
+import { removeEmpty, isEmpty } from "./utils";
+import qs from "qs";
+import { HttpClientInterface } from "./serp-rest-api/api-facade/auth";
+import sizeof from "object-sizeof";
+import { getFormDataSize } from "./utils";
+
+function getPayloadSize(payload: Record<string, unknown> | FormData): number {
+  if (payload instanceof FormData) {
+    return getFormDataSize(payload);
+  } else {
+    return sizeof(payload);
+  }
+}
+
+const payloadIsTooLargeError = new Error("Payload is too large");
+
+// 6mb
+const MAX_PAYLOAD_SIZE = 6291456;
+
+function prepareUrlParams(params: { q?: string }): Record<string, unknown> {
+  const paramsWithValues = removeEmpty(params);
+
+  if (Object.prototype.hasOwnProperty.call(params, "q")) {
+    if (params.q === "") {
+      delete paramsWithValues.q;
+    }
+  }
+
+  return !isEmpty(paramsWithValues) ? paramsWithValues : {};
+}
+
+type RequestData = FormData | Record<string, unknown>;
+
+type ResponseData = { data: Record<string, unknown> };
+
+interface RequestClientInterface {
+  defaults: { baseURL?: string; headers?: { Authorization?: string } };
+  get(
+    url: string,
+    config?: { params?: Record<string, unknown> }
+  ): Promise<ResponseData>;
+  post(url: string, data?: RequestData): Promise<ResponseData>;
+  put(url: string, data?: RequestData): Promise<ResponseData>;
+  delete(
+    url: string,
+    config?: {
+      params?: Record<string, unknown>;
+      data?: Record<string, unknown> | FormData;
+    }
+  ): Promise<ResponseData>;
+}
+
+interface RequestClientCreatorSettingsInterface {
+  baseURL?: string;
+  headers?: { "Content-Type": string; token?: string };
+  paramsSerializer?(params: any): string;
+}
+
+interface RequestClientCreatorInterface {
+  create(
+    settings: RequestClientCreatorSettingsInterface
+  ): RequestClientInterface;
+}
+
+interface RequestClientCreatorSettingsInterface {
+  baseURL?: string;
+  token?: string;
+}
+
+function createHttpClient({
+  client,
+}: {
+  client: RequestClientCreatorInterface;
+}): {
+  new (settings: RequestClientCreatorSettingsInterface): HttpClientInterface;
+} {
+  return class HttpClient implements HttpClientInterface {
+    private client: RequestClientInterface;
+
+    constructor({ baseURL, token }: RequestClientCreatorSettingsInterface) {
+      Object.assign(this, { baseURL, token });
+
+      const headers: {
+        "Content-Type": string;
+        token?: string;
+      } = {
+        "Content-Type": "application/json",
+      };
+
+      if (token) {
+        headers.token = `Token ${token}`;
+      }
+
+      this.client = client.create({
+        baseURL,
+        headers,
+        paramsSerializer: function (params) {
+          return qs.stringify(params, { arrayFormat: "comma" });
+        },
+      });
+    }
+
+    setToken(token: string): void {
+      if (token && this.client.defaults.headers) {
+        this.client.defaults.headers["Authorization"] = `Token ${token}`;
+      }
+    }
+
+    deleteToken(): void {
+      if (this.client.defaults.headers) {
+        delete this.client.defaults.headers["Authorization"];
+      }
+    }
+
+    setBaseURL(baseURL: string): void {
+      if (baseURL) {
+        this.client.defaults.baseURL = baseURL;
+      }
+    }
+
+    post(url: string, data?: RequestData): Promise<Record<string, unknown>> {
+      let preparedData = data;
+
+      if (data && !(data instanceof FormData)) {
+        preparedData = removeEmpty(data);
+      }
+
+      if (data && getPayloadSize(data) >= MAX_PAYLOAD_SIZE) {
+        return Promise.reject(payloadIsTooLargeError);
+      }
+
+      if (preparedData) {
+        return this.client.post(url, preparedData).then(({ data }) => data);
+      } else {
+        return this.client.post(url).then(({ data }) => data);
+      }
+    }
+
+    get(
+      url: string,
+      params?: Record<string, unknown>
+    ): Promise<Record<string, unknown>> {
+      const config: { params?: Record<string, unknown> } = {};
+
+      if (params) {
+        config.params = prepareUrlParams(params);
+      }
+
+      if (!isEmpty(config)) {
+        return this.client.get(url, config).then(({ data }) => data);
+      } else {
+        return this.client.get(url).then(({ data }) => data);
+      }
+    }
+
+    put(url: string, data?: RequestData): Promise<Record<string, unknown>> {
+      let preparedData = data;
+
+      if (data && !(data instanceof FormData)) {
+        preparedData = removeEmpty(data);
+      }
+
+      if (data && getPayloadSize(data) >= MAX_PAYLOAD_SIZE) {
+        return Promise.reject(payloadIsTooLargeError);
+      }
+
+      return this.client.put(url, preparedData).then(({ data }) => data);
+    }
+
+    delete(
+      url: string,
+      params?: Record<string, unknown>,
+      data?: RequestData
+    ): Promise<Record<string, unknown>> {
+      const config: {
+        params?: Record<string, unknown>;
+        data?: Record<string, unknown> | FormData;
+      } = {};
+
+      if (params) {
+        config.params = prepareUrlParams(params);
+      }
+
+      let preparedData = data;
+
+      if (data && !(data instanceof FormData)) {
+        preparedData = removeEmpty(data);
+      }
+
+      if (preparedData) {
+        config.data = preparedData;
+      }
+
+      if (data && getPayloadSize(data) >= MAX_PAYLOAD_SIZE) {
+        return Promise.reject(payloadIsTooLargeError);
+      }
+
+      if (!isEmpty(config)) {
+        return this.client.delete(url, config).then(({ data }) => data);
+      } else {
+        return this.client.delete(url).then(({ data }) => data);
+      }
+    }
+  };
+}
+
+export { createHttpClient };

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

@@ -0,0 +1,3 @@
+import { createSerpRestApi } from "./serp-rest-api";
+
+export { createSerpRestApi };

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

@@ -0,0 +1,50 @@
+import { SpaceInterface } from "../v1/spaces";
+import { AuthApiInterface } from "../../../base/auth-api";
+
+export interface UserInterface {
+  username: string;
+  space: SpaceInterface | null;
+}
+
+export interface LoginUserInterface {
+  expires_in: number;
+  access_token: string;
+  token_type: string,
+  token_meta: {
+    id: number,
+    created: string,
+    expires: string,
+    is_active: boolean,
+    last_accessed_timestamp: string,
+    last_accessed_sender_uid: string,
+  };
+  user_meta: {
+    id: number;
+    created: string;
+    username: string;
+  };
+  token: {
+    key: string,
+  },
+}
+
+export interface ChangeUserPasswordInterface {
+  old_password: string;
+  password: string;
+  password2: string;
+  reset_tokens?: boolean;
+}
+
+export interface AuthInterface extends AuthApiInterface {
+  login(username: string, password: string): Promise<LoginUserInterface>;
+  logout(tokenId: string): Promise<null>;
+  whoami(): Promise<UserInterface>;
+  changePassword(data: ChangeUserPasswordInterface): Promise<null>;
+}
+
+// _________
+export interface HttpClientInterface {
+  setToken(token: string): void;
+  deleteToken(): void;
+  setBaseURL(url: string): void;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/base.ts

@@ -0,0 +1,58 @@
+import { AuthInterface, LoginUserInterface, HttpClientInterface } from "./auth";
+
+export interface EndpointInterface {
+  base: string;
+  auth: string;
+}
+
+export interface ApiFacadeSettingsInterface {
+  httpClient: HttpClientInterface;
+  auth: AuthInterface;
+}
+
+export interface ApiFacadeInterface {
+  init(username: string, password: string): Promise<LoginUserInterface>;
+  setToken(token: string): void;
+  deleteToken(): void;
+  setEndpoint(endpoint: EndpointInterface): void;
+
+  auth: AuthInterface;
+}
+
+class ApiFacade implements ApiFacadeInterface {
+  protected httpClient: HttpClientInterface;
+  auth: AuthInterface;
+
+  constructor({ httpClient, auth }: ApiFacadeSettingsInterface) {
+    this.httpClient = httpClient;
+    this.auth = auth;
+  }
+
+  init(username: string, password: string): Promise<LoginUserInterface> {
+    return this.auth
+      .login(username, password)
+      .then((body: LoginUserInterface) => {
+        const { token } = body;
+
+        this.setToken(token.key);
+
+        return body;
+      });
+  }
+
+  setToken(token: string): void {
+    this.httpClient.setToken(token);
+  }
+
+  deleteToken(): void {
+    this.httpClient.deleteToken();
+  }
+
+  setEndpoint(endpoint: EndpointInterface): void {
+    if (!endpoint) return;
+    this.httpClient.setBaseURL(endpoint.base);
+    this.auth.setAuthURL(endpoint.auth);
+  }
+}
+
+export { ApiFacade };

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/entries/index.ts

@@ -0,0 +1,87 @@
+import {
+  id,
+  Sex,
+  Liveness,
+  Result,
+  Mood,
+  Paginatable,
+  Searchable,
+} from "../../../../base/types";
+import { SpaceInterface } from "../spaces";
+
+export interface EntriesFiltersInterface extends Paginatable, Searchable {
+  pid?: string;
+
+  person_ids?: Array<id>;
+  spaces_ids?: Array<id>;
+  origin_ids?: string;
+  conf?: Array<Result>;
+  liveness?: Array<Liveness>;
+  sex?: Array<Sex>;
+  mood?: Array<Mood>;
+  age_from?: number;
+  age_to?: number;
+
+  id_from?: number;
+  entry_id_from?: number;
+
+  date_to?: string;
+  date_from?: string;
+}
+
+export interface EntryInterface {
+  id: id;
+  created: string;
+  face_image: string;
+  full_image: string;
+  source: {
+    id: id;
+    name: string;
+  };
+  space: SpaceInterface;
+  facesize: number;
+  age: number;
+  sex: Sex;
+  mood: Mood;
+  liveness: Liveness;
+  pid: string;
+  result: string;
+  confidence: number;
+  pid_created: string;
+  initial_face_image: string;
+  initial_full_image: string;
+  exposure: number;
+  pan: number;
+  tilt: number;
+}
+
+export interface EntriesStatsInterface {
+  pid: string;
+  pid_created: string;
+  pid_source: {
+    id: id;
+    name: string;
+  };
+  age: number;
+  sex: Sex;
+  initial_face_image: string;
+  initial_full_image: string;
+  initial_facesize: number;
+  initial_liveness: string;
+  total: number;
+  exact: number;
+  ha: number;
+  junk: number;
+  reinit: number;
+  liveness: {
+    passed: number;
+    failed: number;
+    undetermined: number;
+  };
+}
+
+export interface EntriesInterface {
+  getEntries(filters: EntriesFiltersInterface): Promise<Array<EntryInterface>>;
+  getEntriesStatsByPersonId(pid: string): Promise<EntriesStatsInterface>;
+  deleteEntry(entryId: id): Promise<null>;
+}

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

@@ -0,0 +1,106 @@
+import {
+  ApiFacade,
+  ApiFacadeInterface,
+  ApiFacadeSettingsInterface,
+  EndpointInterface,
+} from "../base";
+
+import { TokensInterface } from "./tokens";
+import { SpacesInterface } from "./spaces";
+import { NotificationsInterface } from "./notifications";
+import { EntriesInterface } from "./entries";
+import { PersonsInterface } from "./persons";
+import { SourcesInterface } from "./sources";
+import { UtilitiesInterface } from "./utilities";
+import { PersonsGroupsInterface } from "./persons-groups";
+import { ThresholdsClassInterface } from "./thresholds";
+import { StreamTokensInterface } from "./stream-tokens";
+import { LicensesInterface } from "./licenses";
+
+interface ApiFacadeV1SettingsInterface extends ApiFacadeSettingsInterface {
+  tokens: TokensInterface;
+  spaces: SpacesInterface;
+  licenses: LicensesInterface;
+
+  notifications: NotificationsInterface;
+  entries: EntriesInterface;
+  persons: PersonsInterface;
+  sources: SourcesInterface;
+  utilities: UtilitiesInterface;
+  personsGroups: PersonsGroupsInterface;
+  thresholds: ThresholdsClassInterface;
+  streamTokens: StreamTokensInterface;
+}
+
+export interface ApiFacadeV1Interface extends ApiFacadeInterface {
+  tokens: TokensInterface;
+  spaces: SpacesInterface;
+  licenses: LicensesInterface;
+
+  notifications: NotificationsInterface;
+  entries: EntriesInterface;
+  persons: PersonsInterface;
+  sources: SourcesInterface;
+  utilities: UtilitiesInterface;
+  personsGroups: PersonsGroupsInterface;
+  thresholds: ThresholdsClassInterface;
+  streamTokens: StreamTokensInterface;
+}
+
+class ApiFacadeV1 extends ApiFacade {
+  tokens: TokensInterface;
+  spaces: SpacesInterface;
+  licenses: LicensesInterface;
+
+  notifications: NotificationsInterface;
+  entries: EntriesInterface;
+  persons: PersonsInterface;
+  sources: SourcesInterface;
+  utilities: UtilitiesInterface;
+  personsGroups: PersonsGroupsInterface;
+  thresholds: ThresholdsClassInterface;
+  streamTokens: StreamTokensInterface;
+
+  constructor({
+    httpClient,
+    auth,
+    tokens,
+    spaces,
+    licenses,
+    notifications,
+    entries,
+    persons,
+    sources,
+    utilities,
+    personsGroups,
+    thresholds,
+    streamTokens,
+  }: ApiFacadeV1SettingsInterface) {
+    super({
+      auth,
+      httpClient,
+    });
+
+    this.tokens = tokens;
+    this.spaces = spaces;
+    this.licenses = licenses;
+
+    this.notifications = notifications;
+    this.entries = entries;
+    this.persons = persons;
+    this.sources = sources;
+    this.utilities = utilities;
+    this.personsGroups = personsGroups;
+    this.thresholds = thresholds;
+    this.streamTokens = streamTokens;
+  }
+
+  setEndpoint(endpoint: EndpointInterface): void {
+    super.setEndpoint(endpoint);
+    this.tokens.setAuthURL(endpoint.auth);
+    this.spaces.setAuthURL(endpoint.auth);
+    this.licenses.setAuthURL(endpoint.auth);
+  }
+}
+
+export { ApiFacadeV1 };

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/licenses/index.ts

@@ -0,0 +1,28 @@
+import { Paginatable, Searchable, id } from "../../../../base/types";
+import { AuthApiInterface } from "../../../../base/auth-api";
+
+export interface LicenseInterface {
+  // General
+  id?: id;
+
+  // read only
+  unavailable_at?: string;
+  created?: string;
+
+  name?: string;
+  entry_storage_days?: number;
+  is_active?: boolean;
+}
+
+export interface LicensesFiltersInterface extends Paginatable, Searchable {
+  date_from?: string;
+  date_to?: string;
+  is_bound?: boolean;
+}
+
+export interface LicensesInterface extends AuthApiInterface {
+  getLicenses(filters: LicensesFiltersInterface): Promise<LicenseInterface[]>;
+  getLicense(licenseId: id): Promise<LicenseInterface>;
+  createLicense(license: LicenseInterface): Promise<LicenseInterface>;
+  deleteLicense(licenseId: id): Promise<null>;
+}